(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory(require("@angular/core"), require("@angular/common"), require("@angular/forms"), require("@ng-bootstrap/ng-bootstrap"), require("ngx-toastr"), require("tabby-core"), require("tabby-settings"), require("tabby-terminal"), require("fs"), require("keytar"), require("rxjs"), require("stream"), require("path"), require("@luminati-io/socksv5"), require("net"), require("any-promise"), require("child_process"), require("os"));
	else if(typeof define === 'function' && define.amd)
		define(["@angular/core", "@angular/common", "@angular/forms", "@ng-bootstrap/ng-bootstrap", "ngx-toastr", "tabby-core", "tabby-settings", "tabby-terminal", "fs", "keytar", "rxjs", "stream", "path", "@luminati-io/socksv5", "net", "any-promise", "child_process", "os"], factory);
	else {
		var a = typeof exports === 'object' ? factory(require("@angular/core"), require("@angular/common"), require("@angular/forms"), require("@ng-bootstrap/ng-bootstrap"), require("ngx-toastr"), require("tabby-core"), require("tabby-settings"), require("tabby-terminal"), require("fs"), require("keytar"), require("rxjs"), require("stream"), require("path"), require("@luminati-io/socksv5"), require("net"), require("any-promise"), require("child_process"), require("os")) : factory(root["@angular/core"], root["@angular/common"], root["@angular/forms"], root["@ng-bootstrap/ng-bootstrap"], root["ngx-toastr"], root["tabby-core"], root["tabby-settings"], root["tabby-terminal"], root["fs"], root["keytar"], root["rxjs"], root["stream"], root["path"], root["@luminati-io/socksv5"], root["net"], root["any-promise"], root["child_process"], root["os"]);
		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
	}
})(global, (__WEBPACK_EXTERNAL_MODULE__8900__, __WEBPACK_EXTERNAL_MODULE__5848__, __WEBPACK_EXTERNAL_MODULE__7161__, __WEBPACK_EXTERNAL_MODULE__7571__, __WEBPACK_EXTERNAL_MODULE__7170__, __WEBPACK_EXTERNAL_MODULE__315__, __WEBPACK_EXTERNAL_MODULE__6663__, __WEBPACK_EXTERNAL_MODULE__8316__, __WEBPACK_EXTERNAL_MODULE__2089__, __WEBPACK_EXTERNAL_MODULE__5860__, __WEBPACK_EXTERNAL_MODULE__3832__, __WEBPACK_EXTERNAL_MODULE__3978__, __WEBPACK_EXTERNAL_MODULE__3056__, __WEBPACK_EXTERNAL_MODULE__6608__, __WEBPACK_EXTERNAL_MODULE__1548__, __WEBPACK_EXTERNAL_MODULE__7154__, __WEBPACK_EXTERNAL_MODULE__7198__, __WEBPACK_EXTERNAL_MODULE__9044__) => {
return /******/ (() => { // webpackBootstrap
/******/ 	var __webpack_modules__ = ({

/***/ 442:
/*!*******************************************************************************!*\
  !*** ./src/components/keyboardInteractiveAuthPanel.component.scss?ngResource ***!
  \*******************************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {


        var result = __webpack_require__(/*! !!../../../node_modules/css-loader/dist/cjs.js!../../../node_modules/sass-loader/dist/cjs.js!./keyboardInteractiveAuthPanel.component.scss?ngResource */ 9576);

        if (result && result.__esModule) {
            result = result.default;
        }

        if (typeof result === "string") {
            module.exports = result;
        } else {
            module.exports = result.toString();
        }
    

/***/ }),

/***/ 4987:
/*!************************************************************!*\
  !*** ./src/components/sftpPanel.component.scss?ngResource ***!
  \************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {


        var result = __webpack_require__(/*! !!../../../node_modules/css-loader/dist/cjs.js!../../../node_modules/sass-loader/dist/cjs.js!./sftpPanel.component.scss?ngResource */ 7543);

        if (result && result.__esModule) {
            result = result.default;
        }

        if (typeof result === "string") {
            module.exports = result;
        } else {
            module.exports = result.toString();
        }
    

/***/ }),

/***/ 7846:
/*!**********************************************!*\
  !*** ./src/components/sshTab.component.scss ***!
  \**********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {


        var result = __webpack_require__(/*! !!../../../node_modules/css-loader/dist/cjs.js!../../../node_modules/sass-loader/dist/cjs.js!./sshTab.component.scss */ 9886);

        if (result && result.__esModule) {
            result = result.default;
        }

        if (typeof result === "string") {
            module.exports = result;
        } else {
            module.exports = result.toString();
        }
    

/***/ }),

/***/ 5098:
/*!********************************************************************!*\
  !*** ./src/components/hostKeyPromptModal.component.pug?ngResource ***!
  \********************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var req = __webpack_require__(/*! !!../node_modules/pug-loader/index.js??ruleSet[1].rules[3].use[1]!./src/components/hostKeyPromptModal.component.pug?ngResource */ 7852);
module.exports = (req['default'] || req).apply(req, [])

/***/ }),

/***/ 5897:
/*!******************************************************************************!*\
  !*** ./src/components/keyboardInteractiveAuthPanel.component.pug?ngResource ***!
  \******************************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var req = __webpack_require__(/*! !!../node_modules/pug-loader/index.js??ruleSet[1].rules[3].use[1]!./src/components/keyboardInteractiveAuthPanel.component.pug?ngResource */ 1003);
module.exports = (req['default'] || req).apply(req, [])

/***/ }),

/***/ 7192:
/*!**************************************************************************!*\
  !*** ./src/components/sftpCreateDirectoryModal.component.pug?ngResource ***!
  \**************************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var req = __webpack_require__(/*! !!../node_modules/pug-loader/index.js??ruleSet[1].rules[3].use[1]!./src/components/sftpCreateDirectoryModal.component.pug?ngResource */ 3516);
module.exports = (req['default'] || req).apply(req, [])

/***/ }),

/***/ 7255:
/*!*****************************************************************!*\
  !*** ./src/components/sftpDeleteModal.component.pug?ngResource ***!
  \*****************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var req = __webpack_require__(/*! !!../node_modules/pug-loader/index.js??ruleSet[1].rules[3].use[1]!./src/components/sftpDeleteModal.component.pug?ngResource */ 883);
module.exports = (req['default'] || req).apply(req, [])

/***/ }),

/***/ 687:
/*!***********************************************************!*\
  !*** ./src/components/sftpPanel.component.pug?ngResource ***!
  \***********************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var req = __webpack_require__(/*! !!../node_modules/pug-loader/index.js??ruleSet[1].rules[3].use[1]!./src/components/sftpPanel.component.pug?ngResource */ 3576);
module.exports = (req['default'] || req).apply(req, [])

/***/ }),

/***/ 8192:
/*!*************************************************************************!*\
  !*** ./src/components/sshPortForwardingConfig.component.pug?ngResource ***!
  \*************************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var req = __webpack_require__(/*! !!../node_modules/pug-loader/index.js??ruleSet[1].rules[3].use[1]!./src/components/sshPortForwardingConfig.component.pug?ngResource */ 7083);
module.exports = (req['default'] || req).apply(req, [])

/***/ }),

/***/ 1355:
/*!************************************************************************!*\
  !*** ./src/components/sshPortForwardingModal.component.pug?ngResource ***!
  \************************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var req = __webpack_require__(/*! !!../node_modules/pug-loader/index.js??ruleSet[1].rules[3].use[1]!./src/components/sshPortForwardingModal.component.pug?ngResource */ 9040);
module.exports = (req['default'] || req).apply(req, [])

/***/ }),

/***/ 1295:
/*!********************************************************************!*\
  !*** ./src/components/sshProfileSettings.component.pug?ngResource ***!
  \********************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var req = __webpack_require__(/*! !!../node_modules/pug-loader/index.js??ruleSet[1].rules[3].use[1]!./src/components/sshProfileSettings.component.pug?ngResource */ 3660);
module.exports = (req['default'] || req).apply(req, [])

/***/ }),

/***/ 1602:
/*!****************************************************************!*\
  !*** ./src/components/sshSettingsTab.component.pug?ngResource ***!
  \****************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var req = __webpack_require__(/*! !!../node_modules/pug-loader/index.js??ruleSet[1].rules[3].use[1]!./src/components/sshSettingsTab.component.pug?ngResource */ 5859);
module.exports = (req['default'] || req).apply(req, [])

/***/ }),

/***/ 4113:
/*!*********************************************!*\
  !*** ./src/components/sshTab.component.pug ***!
  \*********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var req = __webpack_require__(/*! !!../node_modules/pug-loader/index.js??ruleSet[1].rules[3].use[1]!./src/components/sshTab.component.pug */ 2517);
module.exports = (req['default'] || req).apply(req, [])

/***/ }),

/***/ 500:
/*!****************************************************!*\
  !*** ../app/node_modules/core-util-is/lib/util.js ***!
  \****************************************************/
/***/ ((__unused_webpack_module, exports) => {

// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

// NOTE: These type checking functions intentionally don't use `instanceof`
// because it is fragile and can be easily faked with `Object.create()`.

function isArray(arg) {
  if (Array.isArray) {
    return Array.isArray(arg);
  }
  return objectToString(arg) === '[object Array]';
}
exports.isArray = isArray;
function isBoolean(arg) {
  return typeof arg === 'boolean';
}
exports.isBoolean = isBoolean;
function isNull(arg) {
  return arg === null;
}
exports.isNull = isNull;
function isNullOrUndefined(arg) {
  return arg == null;
}
exports.isNullOrUndefined = isNullOrUndefined;
function isNumber(arg) {
  return typeof arg === 'number';
}
exports.isNumber = isNumber;
function isString(arg) {
  return typeof arg === 'string';
}
exports.isString = isString;
function isSymbol(arg) {
  return typeof arg === 'symbol';
}
exports.isSymbol = isSymbol;
function isUndefined(arg) {
  return arg === void 0;
}
exports.isUndefined = isUndefined;
function isRegExp(re) {
  return objectToString(re) === '[object RegExp]';
}
exports.isRegExp = isRegExp;
function isObject(arg) {
  return typeof arg === 'object' && arg !== null;
}
exports.isObject = isObject;
function isDate(d) {
  return objectToString(d) === '[object Date]';
}
exports.isDate = isDate;
function isError(e) {
  return objectToString(e) === '[object Error]' || e instanceof Error;
}
exports.isError = isError;
function isFunction(arg) {
  return typeof arg === 'function';
}
exports.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';
}
exports.isPrimitive = isPrimitive;
exports.isBuffer = Buffer.isBuffer;
function objectToString(o) {
  return Object.prototype.toString.call(o);
}

/***/ }),

/***/ 1752:
/*!********************************************************!*\
  !*** ../app/node_modules/filesize/lib/filesize.min.js ***!
  \********************************************************/
/***/ (function(module) {

/*!
 2022 Jason Mulligan <jason.mulligan@avoidwork.com>
 @version 9.0.11
*/
!function (i, t) {
   true ? module.exports = t() : 0;
}(this, function () {
  "use strict";

  function i(t) {
    return i = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (i) {
      return typeof i;
    } : function (i) {
      return i && "function" == typeof Symbol && i.constructor === Symbol && i !== Symbol.prototype ? "symbol" : typeof i;
    }, i(t);
  }
  var t = "array",
    o = "bits",
    e = "byte",
    n = "bytes",
    r = "",
    b = "exponent",
    l = "function",
    a = "iec",
    d = "Invalid number",
    f = "Invalid rounding method",
    u = "jedec",
    s = "object",
    c = ".",
    p = "round",
    y = "kbit",
    m = "string",
    v = {
      symbol: {
        iec: {
          bits: ["bit", "Kibit", "Mibit", "Gibit", "Tibit", "Pibit", "Eibit", "Zibit", "Yibit"],
          bytes: ["B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"]
        },
        jedec: {
          bits: ["bit", "Kbit", "Mbit", "Gbit", "Tbit", "Pbit", "Ebit", "Zbit", "Ybit"],
          bytes: ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"]
        }
      },
      fullform: {
        iec: ["", "kibi", "mebi", "gibi", "tebi", "pebi", "exbi", "zebi", "yobi"],
        jedec: ["", "kilo", "mega", "giga", "tera", "peta", "exa", "zetta", "yotta"]
      }
    };
  function g(g) {
    var h = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : {},
      B = h.bits,
      M = void 0 !== B && B,
      S = h.pad,
      T = void 0 !== S && S,
      w = h.base,
      x = void 0 === w ? -1 : w,
      E = h.round,
      j = void 0 === E ? 2 : E,
      N = h.locale,
      P = void 0 === N ? r : N,
      k = h.localeOptions,
      G = void 0 === k ? {} : k,
      K = h.separator,
      Y = void 0 === K ? r : K,
      Z = h.spacer,
      z = void 0 === Z ? " " : Z,
      I = h.symbols,
      L = void 0 === I ? {} : I,
      O = h.standard,
      q = void 0 === O ? r : O,
      A = h.output,
      C = void 0 === A ? m : A,
      D = h.fullform,
      F = void 0 !== D && D,
      H = h.fullforms,
      J = void 0 === H ? [] : H,
      Q = h.exponent,
      R = void 0 === Q ? -1 : Q,
      U = h.roundingMethod,
      V = void 0 === U ? p : U,
      W = h.precision,
      X = void 0 === W ? 0 : W,
      $ = R,
      _ = Number(g),
      ii = [],
      ti = 0,
      oi = r;
    -1 === x && 0 === q.length ? (x = 10, q = u) : -1 === x && q.length > 0 ? x = (q = q === a ? a : u) === a ? 2 : 10 : q = 10 === (x = 2 === x ? 2 : 10) || q === u ? u : a;
    var ei = 10 === x ? 1e3 : 1024,
      ni = !0 === F,
      ri = _ < 0,
      bi = Math[V];
    if (isNaN(g)) throw new TypeError(d);
    if (i(bi) !== l) throw new TypeError(f);
    if (ri && (_ = -_), (-1 === $ || isNaN($)) && ($ = Math.floor(Math.log(_) / Math.log(ei))) < 0 && ($ = 0), $ > 8 && (X > 0 && (X += 8 - $), $ = 8), C === b) return $;
    if (0 === _) ii[0] = 0, oi = ii[1] = v.symbol[q][M ? o : n][$];else {
      ti = _ / (2 === x ? Math.pow(2, 10 * $) : Math.pow(1e3, $)), M && (ti *= 8) >= ei && $ < 8 && (ti /= ei, $++);
      var li = Math.pow(10, $ > 0 ? j : 0);
      ii[0] = bi(ti * li) / li, ii[0] === ei && $ < 8 && -1 === R && (ii[0] = 1, $++), oi = ii[1] = 10 === x && 1 === $ ? M ? y : "kB" : v.symbol[q][M ? o : n][$];
    }
    if (ri && (ii[0] = -ii[0]), X > 0 && (ii[0] = ii[0].toPrecision(X)), ii[1] = L[ii[1]] || ii[1], !0 === P ? ii[0] = ii[0].toLocaleString() : P.length > 0 ? ii[0] = ii[0].toLocaleString(P, G) : Y.length > 0 && (ii[0] = ii[0].toString().replace(c, Y)), T && !1 === Number.isInteger(ii[0]) && j > 0) {
      var ai = Y || c,
        di = ii[0].toString().split(ai),
        fi = di[1] || r,
        ui = fi.length,
        si = j - ui;
      ii[0] = "".concat(di[0]).concat(ai).concat(fi.padEnd(ui + si, "0"));
    }
    return ni && (ii[1] = J[$] ? J[$] : v.fullform[q][$] + (M ? "bit" : e) + (1 === ii[0] ? r : "s")), C === t ? ii : C === s ? {
      value: ii[0],
      symbol: ii[1],
      exponent: $,
      unit: oi
    } : ii.join(z);
  }
  return g.partial = function (i) {
    return function (t) {
      return g(t, i);
    };
  }, g;
});

/***/ }),

/***/ 9410:
/*!************************************************!*\
  !*** ../app/node_modules/graceful-fs/clone.js ***!
  \************************************************/
/***/ ((module) => {

"use strict";


module.exports = clone;
function clone(obj) {
  if (obj === null || typeof obj !== 'object') return obj;
  if (obj instanceof Object) var copy = {
    __proto__: obj.__proto__
  };else var copy = Object.create(null);
  Object.getOwnPropertyNames(obj).forEach(function (key) {
    Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
  });
  return copy;
}

/***/ }),

/***/ 4389:
/*!******************************************************!*\
  !*** ../app/node_modules/graceful-fs/graceful-fs.js ***!
  \******************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var fs = __webpack_require__(/*! fs */ 2089);
var polyfills = __webpack_require__(/*! ./polyfills.js */ 5581);
var legacy = __webpack_require__(/*! ./legacy-streams.js */ 599);
var clone = __webpack_require__(/*! ./clone.js */ 9410);
var util = __webpack_require__(/*! util */ 3837);

/* istanbul ignore next - node 0.x polyfill */
var gracefulQueue;
var previousSymbol;

/* istanbul ignore else - node 0.x polyfill */
if (typeof Symbol === 'function' && typeof Symbol.for === 'function') {
  gracefulQueue = Symbol.for('graceful-fs.queue');
  // This is used in testing by future versions
  previousSymbol = Symbol.for('graceful-fs.previous');
} else {
  gracefulQueue = '___graceful-fs.queue';
  previousSymbol = '___graceful-fs.previous';
}
function noop() {}
function publishQueue(context, queue) {
  Object.defineProperty(context, gracefulQueue, {
    get: function () {
      return queue;
    }
  });
}
var debug = noop;
if (util.debuglog) debug = util.debuglog('gfs4');else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) debug = function () {
  var m = util.format.apply(util, arguments);
  m = 'GFS4: ' + m.split(/\n/).join('\nGFS4: ');
  console.error(m);
};

// Once time initialization
if (!fs[gracefulQueue]) {
  // This queue can be shared by multiple loaded instances
  var queue = global[gracefulQueue] || [];
  publishQueue(fs, queue);

  // Patch fs.close/closeSync to shared queue version, because we need
  // to retry() whenever a close happens *anywhere* in the program.
  // This is essential when multiple graceful-fs instances are
  // in play at the same time.
  fs.close = function (fs$close) {
    function close(fd, cb) {
      return fs$close.call(fs, fd, function (err) {
        // This function uses the graceful-fs shared queue
        if (!err) {
          retry();
        }
        if (typeof cb === 'function') cb.apply(this, arguments);
      });
    }
    Object.defineProperty(close, previousSymbol, {
      value: fs$close
    });
    return close;
  }(fs.close);
  fs.closeSync = function (fs$closeSync) {
    function closeSync(fd) {
      // This function uses the graceful-fs shared queue
      fs$closeSync.apply(fs, arguments);
      retry();
    }
    Object.defineProperty(closeSync, previousSymbol, {
      value: fs$closeSync
    });
    return closeSync;
  }(fs.closeSync);
  if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) {
    process.on('exit', function () {
      debug(fs[gracefulQueue]);
      (__webpack_require__(/*! assert */ 9491).equal)(fs[gracefulQueue].length, 0);
    });
  }
}
if (!global[gracefulQueue]) {
  publishQueue(global, fs[gracefulQueue]);
}
module.exports = patch(clone(fs));
if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
  module.exports = patch(fs);
  fs.__patched = true;
}
function patch(fs) {
  // Everything that references the open() function needs to be in here
  polyfills(fs);
  fs.gracefulify = patch;
  fs.createReadStream = createReadStream;
  fs.createWriteStream = createWriteStream;
  var fs$readFile = fs.readFile;
  fs.readFile = readFile;
  function readFile(path, options, cb) {
    if (typeof options === 'function') cb = options, options = null;
    return go$readFile(path, options, cb);
    function go$readFile(path, options, cb) {
      return fs$readFile(path, options, function (err) {
        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE')) enqueue([go$readFile, [path, options, cb]]);else {
          if (typeof cb === 'function') cb.apply(this, arguments);
          retry();
        }
      });
    }
  }
  var fs$writeFile = fs.writeFile;
  fs.writeFile = writeFile;
  function writeFile(path, data, options, cb) {
    if (typeof options === 'function') cb = options, options = null;
    return go$writeFile(path, data, options, cb);
    function go$writeFile(path, data, options, cb) {
      return fs$writeFile(path, data, options, function (err) {
        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE')) enqueue([go$writeFile, [path, data, options, cb]]);else {
          if (typeof cb === 'function') cb.apply(this, arguments);
          retry();
        }
      });
    }
  }
  var fs$appendFile = fs.appendFile;
  if (fs$appendFile) fs.appendFile = appendFile;
  function appendFile(path, data, options, cb) {
    if (typeof options === 'function') cb = options, options = null;
    return go$appendFile(path, data, options, cb);
    function go$appendFile(path, data, options, cb) {
      return fs$appendFile(path, data, options, function (err) {
        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE')) enqueue([go$appendFile, [path, data, options, cb]]);else {
          if (typeof cb === 'function') cb.apply(this, arguments);
          retry();
        }
      });
    }
  }
  var fs$readdir = fs.readdir;
  fs.readdir = readdir;
  function readdir(path, options, cb) {
    var args = [path];
    if (typeof options !== 'function') {
      args.push(options);
    } else {
      cb = options;
    }
    args.push(go$readdir$cb);
    return go$readdir(args);
    function go$readdir$cb(err, files) {
      if (files && files.sort) files.sort();
      if (err && (err.code === 'EMFILE' || err.code === 'ENFILE')) enqueue([go$readdir, [args]]);else {
        if (typeof cb === 'function') cb.apply(this, arguments);
        retry();
      }
    }
  }
  function go$readdir(args) {
    return fs$readdir.apply(fs, args);
  }
  if (process.version.substr(0, 4) === 'v0.8') {
    var legStreams = legacy(fs);
    ReadStream = legStreams.ReadStream;
    WriteStream = legStreams.WriteStream;
  }
  var fs$ReadStream = fs.ReadStream;
  if (fs$ReadStream) {
    ReadStream.prototype = Object.create(fs$ReadStream.prototype);
    ReadStream.prototype.open = ReadStream$open;
  }
  var fs$WriteStream = fs.WriteStream;
  if (fs$WriteStream) {
    WriteStream.prototype = Object.create(fs$WriteStream.prototype);
    WriteStream.prototype.open = WriteStream$open;
  }
  Object.defineProperty(fs, 'ReadStream', {
    get: function () {
      return ReadStream;
    },
    set: function (val) {
      ReadStream = val;
    },
    enumerable: true,
    configurable: true
  });
  Object.defineProperty(fs, 'WriteStream', {
    get: function () {
      return WriteStream;
    },
    set: function (val) {
      WriteStream = val;
    },
    enumerable: true,
    configurable: true
  });

  // legacy names
  var FileReadStream = ReadStream;
  Object.defineProperty(fs, 'FileReadStream', {
    get: function () {
      return FileReadStream;
    },
    set: function (val) {
      FileReadStream = val;
    },
    enumerable: true,
    configurable: true
  });
  var FileWriteStream = WriteStream;
  Object.defineProperty(fs, 'FileWriteStream', {
    get: function () {
      return FileWriteStream;
    },
    set: function (val) {
      FileWriteStream = val;
    },
    enumerable: true,
    configurable: true
  });
  function ReadStream(path, options) {
    if (this instanceof ReadStream) return fs$ReadStream.apply(this, arguments), this;else return ReadStream.apply(Object.create(ReadStream.prototype), arguments);
  }
  function ReadStream$open() {
    var that = this;
    open(that.path, that.flags, that.mode, function (err, fd) {
      if (err) {
        if (that.autoClose) that.destroy();
        that.emit('error', err);
      } else {
        that.fd = fd;
        that.emit('open', fd);
        that.read();
      }
    });
  }
  function WriteStream(path, options) {
    if (this instanceof WriteStream) return fs$WriteStream.apply(this, arguments), this;else return WriteStream.apply(Object.create(WriteStream.prototype), arguments);
  }
  function WriteStream$open() {
    var that = this;
    open(that.path, that.flags, that.mode, function (err, fd) {
      if (err) {
        that.destroy();
        that.emit('error', err);
      } else {
        that.fd = fd;
        that.emit('open', fd);
      }
    });
  }
  function createReadStream(path, options) {
    return new fs.ReadStream(path, options);
  }
  function createWriteStream(path, options) {
    return new fs.WriteStream(path, options);
  }
  var fs$open = fs.open;
  fs.open = open;
  function open(path, flags, mode, cb) {
    if (typeof mode === 'function') cb = mode, mode = null;
    return go$open(path, flags, mode, cb);
    function go$open(path, flags, mode, cb) {
      return fs$open(path, flags, mode, function (err, fd) {
        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE')) enqueue([go$open, [path, flags, mode, cb]]);else {
          if (typeof cb === 'function') cb.apply(this, arguments);
          retry();
        }
      });
    }
  }
  return fs;
}
function enqueue(elem) {
  debug('ENQUEUE', elem[0].name, elem[1]);
  fs[gracefulQueue].push(elem);
}
function retry() {
  var elem = fs[gracefulQueue].shift();
  if (elem) {
    debug('RETRY', elem[0].name, elem[1]);
    elem[0].apply(null, elem[1]);
  }
}

/***/ }),

/***/ 599:
/*!*********************************************************!*\
  !*** ../app/node_modules/graceful-fs/legacy-streams.js ***!
  \*********************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var Stream = (__webpack_require__(/*! stream */ 3978).Stream);
module.exports = legacy;
function legacy(fs) {
  return {
    ReadStream: ReadStream,
    WriteStream: WriteStream
  };
  function ReadStream(path, options) {
    if (!(this instanceof ReadStream)) return new ReadStream(path, options);
    Stream.call(this);
    var self = this;
    this.path = path;
    this.fd = null;
    this.readable = true;
    this.paused = false;
    this.flags = 'r';
    this.mode = 438; /*=0666*/
    this.bufferSize = 64 * 1024;
    options = options || {};

    // Mixin options into this
    var keys = Object.keys(options);
    for (var index = 0, length = keys.length; index < length; index++) {
      var key = keys[index];
      this[key] = options[key];
    }
    if (this.encoding) this.setEncoding(this.encoding);
    if (this.start !== undefined) {
      if ('number' !== typeof this.start) {
        throw TypeError('start must be a Number');
      }
      if (this.end === undefined) {
        this.end = Infinity;
      } else if ('number' !== typeof this.end) {
        throw TypeError('end must be a Number');
      }
      if (this.start > this.end) {
        throw new Error('start must be <= end');
      }
      this.pos = this.start;
    }
    if (this.fd !== null) {
      process.nextTick(function () {
        self._read();
      });
      return;
    }
    fs.open(this.path, this.flags, this.mode, function (err, fd) {
      if (err) {
        self.emit('error', err);
        self.readable = false;
        return;
      }
      self.fd = fd;
      self.emit('open', fd);
      self._read();
    });
  }
  function WriteStream(path, options) {
    if (!(this instanceof WriteStream)) return new WriteStream(path, options);
    Stream.call(this);
    this.path = path;
    this.fd = null;
    this.writable = true;
    this.flags = 'w';
    this.encoding = 'binary';
    this.mode = 438; /*=0666*/
    this.bytesWritten = 0;
    options = options || {};

    // Mixin options into this
    var keys = Object.keys(options);
    for (var index = 0, length = keys.length; index < length; index++) {
      var key = keys[index];
      this[key] = options[key];
    }
    if (this.start !== undefined) {
      if ('number' !== typeof this.start) {
        throw TypeError('start must be a Number');
      }
      if (this.start < 0) {
        throw new Error('start must be >= zero');
      }
      this.pos = this.start;
    }
    this.busy = false;
    this._queue = [];
    if (this.fd === null) {
      this._open = fs.open;
      this._queue.push([this._open, this.path, this.flags, this.mode, undefined]);
      this.flush();
    }
  }
}

/***/ }),

/***/ 5581:
/*!****************************************************!*\
  !*** ../app/node_modules/graceful-fs/polyfills.js ***!
  \****************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var constants = __webpack_require__(/*! constants */ 2057);
var origCwd = process.cwd;
var cwd = null;
var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
process.cwd = function () {
  if (!cwd) cwd = origCwd.call(process);
  return cwd;
};
try {
  process.cwd();
} catch (er) {}
var chdir = process.chdir;
process.chdir = function (d) {
  cwd = null;
  chdir.call(process, d);
};
module.exports = patch;
function patch(fs) {
  // (re-)implement some things that are known busted or missing.

  // lchmod, broken prior to 0.6.2
  // back-port the fix here.
  if (constants.hasOwnProperty('O_SYMLINK') && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
    patchLchmod(fs);
  }

  // lutimes implementation, or no-op
  if (!fs.lutimes) {
    patchLutimes(fs);
  }

  // https://github.com/isaacs/node-graceful-fs/issues/4
  // Chown should not fail on einval or eperm if non-root.
  // It should not fail on enosys ever, as this just indicates
  // that a fs doesn't support the intended operation.

  fs.chown = chownFix(fs.chown);
  fs.fchown = chownFix(fs.fchown);
  fs.lchown = chownFix(fs.lchown);
  fs.chmod = chmodFix(fs.chmod);
  fs.fchmod = chmodFix(fs.fchmod);
  fs.lchmod = chmodFix(fs.lchmod);
  fs.chownSync = chownFixSync(fs.chownSync);
  fs.fchownSync = chownFixSync(fs.fchownSync);
  fs.lchownSync = chownFixSync(fs.lchownSync);
  fs.chmodSync = chmodFixSync(fs.chmodSync);
  fs.fchmodSync = chmodFixSync(fs.fchmodSync);
  fs.lchmodSync = chmodFixSync(fs.lchmodSync);
  fs.stat = statFix(fs.stat);
  fs.fstat = statFix(fs.fstat);
  fs.lstat = statFix(fs.lstat);
  fs.statSync = statFixSync(fs.statSync);
  fs.fstatSync = statFixSync(fs.fstatSync);
  fs.lstatSync = statFixSync(fs.lstatSync);

  // if lchmod/lchown do not exist, then make them no-ops
  if (!fs.lchmod) {
    fs.lchmod = function (path, mode, cb) {
      if (cb) process.nextTick(cb);
    };
    fs.lchmodSync = function () {};
  }
  if (!fs.lchown) {
    fs.lchown = function (path, uid, gid, cb) {
      if (cb) process.nextTick(cb);
    };
    fs.lchownSync = function () {};
  }

  // on Windows, A/V software can lock the directory, causing this
  // to fail with an EACCES or EPERM if the directory contains newly
  // created files.  Try again on failure, for up to 60 seconds.

  // Set the timeout this long because some Windows Anti-Virus, such as Parity
  // bit9, may lock files for up to a minute, causing npm package install
  // failures. Also, take care to yield the scheduler. Windows scheduling gives
  // CPU to a busy looping process, which can cause the program causing the lock
  // contention to be starved of CPU by node, so the contention doesn't resolve.
  if (platform === "win32") {
    fs.rename = function (fs$rename) {
      return function (from, to, cb) {
        var start = Date.now();
        var backoff = 0;
        fs$rename(from, to, function CB(er) {
          if (er && (er.code === "EACCES" || er.code === "EPERM") && Date.now() - start < 60000) {
            setTimeout(function () {
              fs.stat(to, function (stater, st) {
                if (stater && stater.code === "ENOENT") fs$rename(from, to, CB);else cb(er);
              });
            }, backoff);
            if (backoff < 100) backoff += 10;
            return;
          }
          if (cb) cb(er);
        });
      };
    }(fs.rename);
  }

  // if read() returns EAGAIN, then just try it again.
  fs.read = function (fs$read) {
    function read(fd, buffer, offset, length, position, callback_) {
      var callback;
      if (callback_ && typeof callback_ === 'function') {
        var eagCounter = 0;
        callback = function (er, _, __) {
          if (er && er.code === 'EAGAIN' && eagCounter < 10) {
            eagCounter++;
            return fs$read.call(fs, fd, buffer, offset, length, position, callback);
          }
          callback_.apply(this, arguments);
        };
      }
      return fs$read.call(fs, fd, buffer, offset, length, position, callback);
    }

    // This ensures `util.promisify` works as it does for native `fs.read`.
    read.__proto__ = fs$read;
    return read;
  }(fs.read);
  fs.readSync = function (fs$readSync) {
    return function (fd, buffer, offset, length, position) {
      var eagCounter = 0;
      while (true) {
        try {
          return fs$readSync.call(fs, fd, buffer, offset, length, position);
        } catch (er) {
          if (er.code === 'EAGAIN' && eagCounter < 10) {
            eagCounter++;
            continue;
          }
          throw er;
        }
      }
    };
  }(fs.readSync);
  function patchLchmod(fs) {
    fs.lchmod = function (path, mode, callback) {
      fs.open(path, constants.O_WRONLY | constants.O_SYMLINK, mode, function (err, fd) {
        if (err) {
          if (callback) callback(err);
          return;
        }
        // prefer to return the chmod error, if one occurs,
        // but still try to close, and report closing errors if they occur.
        fs.fchmod(fd, mode, function (err) {
          fs.close(fd, function (err2) {
            if (callback) callback(err || err2);
          });
        });
      });
    };
    fs.lchmodSync = function (path, mode) {
      var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode);

      // prefer to return the chmod error, if one occurs,
      // but still try to close, and report closing errors if they occur.
      var threw = true;
      var ret;
      try {
        ret = fs.fchmodSync(fd, mode);
        threw = false;
      } finally {
        if (threw) {
          try {
            fs.closeSync(fd);
          } catch (er) {}
        } else {
          fs.closeSync(fd);
        }
      }
      return ret;
    };
  }
  function patchLutimes(fs) {
    if (constants.hasOwnProperty("O_SYMLINK")) {
      fs.lutimes = function (path, at, mt, cb) {
        fs.open(path, constants.O_SYMLINK, function (er, fd) {
          if (er) {
            if (cb) cb(er);
            return;
          }
          fs.futimes(fd, at, mt, function (er) {
            fs.close(fd, function (er2) {
              if (cb) cb(er || er2);
            });
          });
        });
      };
      fs.lutimesSync = function (path, at, mt) {
        var fd = fs.openSync(path, constants.O_SYMLINK);
        var ret;
        var threw = true;
        try {
          ret = fs.futimesSync(fd, at, mt);
          threw = false;
        } finally {
          if (threw) {
            try {
              fs.closeSync(fd);
            } catch (er) {}
          } else {
            fs.closeSync(fd);
          }
        }
        return ret;
      };
    } else {
      fs.lutimes = function (_a, _b, _c, cb) {
        if (cb) process.nextTick(cb);
      };
      fs.lutimesSync = function () {};
    }
  }
  function chmodFix(orig) {
    if (!orig) return orig;
    return function (target, mode, cb) {
      return orig.call(fs, target, mode, function (er) {
        if (chownErOk(er)) er = null;
        if (cb) cb.apply(this, arguments);
      });
    };
  }
  function chmodFixSync(orig) {
    if (!orig) return orig;
    return function (target, mode) {
      try {
        return orig.call(fs, target, mode);
      } catch (er) {
        if (!chownErOk(er)) throw er;
      }
    };
  }
  function chownFix(orig) {
    if (!orig) return orig;
    return function (target, uid, gid, cb) {
      return orig.call(fs, target, uid, gid, function (er) {
        if (chownErOk(er)) er = null;
        if (cb) cb.apply(this, arguments);
      });
    };
  }
  function chownFixSync(orig) {
    if (!orig) return orig;
    return function (target, uid, gid) {
      try {
        return orig.call(fs, target, uid, gid);
      } catch (er) {
        if (!chownErOk(er)) throw er;
      }
    };
  }
  function statFix(orig) {
    if (!orig) return orig;
    // Older versions of Node erroneously returned signed integers for
    // uid + gid.
    return function (target, options, cb) {
      if (typeof options === 'function') {
        cb = options;
        options = null;
      }
      function callback(er, stats) {
        if (stats) {
          if (stats.uid < 0) stats.uid += 0x100000000;
          if (stats.gid < 0) stats.gid += 0x100000000;
        }
        if (cb) cb.apply(this, arguments);
      }
      return options ? orig.call(fs, target, options, callback) : orig.call(fs, target, callback);
    };
  }
  function statFixSync(orig) {
    if (!orig) return orig;
    // Older versions of Node erroneously returned signed integers for
    // uid + gid.
    return function (target, options) {
      var stats = options ? orig.call(fs, target, options) : orig.call(fs, target);
      if (stats.uid < 0) stats.uid += 0x100000000;
      if (stats.gid < 0) stats.gid += 0x100000000;
      return stats;
    };
  }

  // ENOSYS means that the fs doesn't support the op. Just ignore
  // that, because it doesn't matter.
  //
  // if there's no getuid, or if getuid() is something other
  // than 0, and the error is EINVAL or EPERM, then just ignore
  // it.
  //
  // This specific case is a silent failure in cp, install, tar,
  // and most other unix tools that manage permissions.
  //
  // When running as root, or if other types of errors are
  // encountered, then it's strict.
  function chownErOk(er) {
    if (!er) return true;
    if (er.code === "ENOSYS") return true;
    var nonroot = !process.getuid || process.getuid() !== 0;
    if (nonroot) {
      if (er.code === "EINVAL" || er.code === "EPERM") return true;
    }
    return false;
  }
}

/***/ }),

/***/ 8520:
/*!********************************************!*\
  !*** ../app/node_modules/isarray/index.js ***!
  \********************************************/
/***/ ((module) => {

var toString = {}.toString;
module.exports = Array.isArray || function (arr) {
  return toString.call(arr) == '[object Array]';
};

/***/ }),

/***/ 7461:
/*!************************************!*\
  !*** ../app/node_modules/mz/fs.js ***!
  \************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

var Promise = __webpack_require__(/*! any-promise */ 7154);
var fs;
try {
  fs = __webpack_require__(/*! graceful-fs */ 4389);
} catch (err) {
  fs = __webpack_require__(/*! fs */ 2089);
}
var api = ['appendFile', 'chmod', 'chown', 'close', 'fchmod', 'fchown', 'fdatasync', 'fstat', 'fsync', 'ftruncate', 'futimes', 'lchown', 'link', 'lstat', 'mkdir', 'open', 'read', 'readFile', 'readdir', 'readlink', 'realpath', 'rename', 'rmdir', 'stat', 'symlink', 'truncate', 'unlink', 'utimes', 'write', 'writeFile'];
typeof fs.access === 'function' && api.push('access');
typeof fs.copyFile === 'function' && api.push('copyFile');
typeof fs.mkdtemp === 'function' && api.push('mkdtemp');
(__webpack_require__(/*! thenify-all */ 5547).withCallback)(fs, exports, api);
exports.exists = function (filename, callback) {
  // callback
  if (typeof callback === 'function') {
    return fs.stat(filename, function (err) {
      callback(null, !err);
    });
  }
  // or promise
  return new Promise(function (resolve) {
    fs.stat(filename, function (err) {
      resolve(!err);
    });
  });
};

/***/ }),

/***/ 7091:
/*!*********************************************************!*\
  !*** ../app/node_modules/process-nextick-args/index.js ***!
  \*********************************************************/
/***/ ((module) => {

"use strict";


if (typeof process === 'undefined' || !process.version || process.version.indexOf('v0.') === 0 || process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {
  module.exports = {
    nextTick: nextTick
  };
} else {
  module.exports = process;
}
function nextTick(fn, arg1, arg2, arg3) {
  if (typeof fn !== 'function') {
    throw new TypeError('"callback" argument must be a function');
  }
  var len = arguments.length;
  var args, i;
  switch (len) {
    case 0:
    case 1:
      return process.nextTick(fn);
    case 2:
      return process.nextTick(function afterTickOne() {
        fn.call(null, arg1);
      });
    case 3:
      return process.nextTick(function afterTickTwo() {
        fn.call(null, arg1, arg2);
      });
    case 4:
      return process.nextTick(function afterTickThree() {
        fn.call(null, arg1, arg2, arg3);
      });
    default:
      args = new Array(len - 1);
      i = 0;
      while (i < args.length) {
        args[i++] = arguments[i];
      }
      return process.nextTick(function afterTick() {
        fn.apply(null, args);
      });
  }
}

/***/ }),

/***/ 7669:
/*!*****************************************************************!*\
  !*** ../app/node_modules/readable-stream/lib/_stream_duplex.js ***!
  \*****************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

// a duplex stream is just a stream that is both readable and writable.
// Since JS doesn't have multiple prototypal inheritance, this class
// prototypally inherits from Readable, and then parasitically from
// Writable.



/*<replacement>*/
var pna = __webpack_require__(/*! process-nextick-args */ 7091);
/*</replacement>*/

/*<replacement>*/
var objectKeys = Object.keys || function (obj) {
  var keys = [];
  for (var key in obj) {
    keys.push(key);
  }
  return keys;
};
/*</replacement>*/

module.exports = Duplex;

/*<replacement>*/
var util = Object.create(__webpack_require__(/*! core-util-is */ 500));
util.inherits = __webpack_require__(/*! inherits */ 7694);
/*</replacement>*/

var Readable = __webpack_require__(/*! ./_stream_readable */ 1305);
var Writable = __webpack_require__(/*! ./_stream_writable */ 2813);
util.inherits(Duplex, Readable);
{
  // avoid scope creep, the keys array can then be collected
  var keys = objectKeys(Writable.prototype);
  for (var v = 0; v < keys.length; v++) {
    var method = keys[v];
    if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
  }
}
function Duplex(options) {
  if (!(this instanceof Duplex)) return new Duplex(options);
  Readable.call(this, options);
  Writable.call(this, options);
  if (options && options.readable === false) this.readable = false;
  if (options && options.writable === false) this.writable = false;
  this.allowHalfOpen = true;
  if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;
  this.once('end', onend);
}
Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', {
  // making it explicit this property is not enumerable
  // because otherwise some prototype manipulation in
  // userland will fail
  enumerable: false,
  get: function () {
    return this._writableState.highWaterMark;
  }
});

// the no-half-open enforcer
function onend() {
  // if we allow half-open state, or if the writable side ended,
  // then we're ok.
  if (this.allowHalfOpen || this._writableState.ended) return;

  // no more data can be written.
  // But allow more writes to happen in this tick.
  pna.nextTick(onEndNT, this);
}
function onEndNT(self) {
  self.end();
}
Object.defineProperty(Duplex.prototype, 'destroyed', {
  get: function () {
    if (this._readableState === undefined || this._writableState === undefined) {
      return false;
    }
    return this._readableState.destroyed && this._writableState.destroyed;
  },
  set: function (value) {
    // we ignore the value if the stream
    // has not been initialized yet
    if (this._readableState === undefined || this._writableState === undefined) {
      return;
    }

    // backward compatibility, the user is explicitly
    // managing destroyed
    this._readableState.destroyed = value;
    this._writableState.destroyed = value;
  }
});
Duplex.prototype._destroy = function (err, cb) {
  this.push(null);
  this.end();
  pna.nextTick(cb, err);
};

/***/ }),

/***/ 1024:
/*!**********************************************************************!*\
  !*** ../app/node_modules/readable-stream/lib/_stream_passthrough.js ***!
  \**********************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

// a passthrough stream.
// basically just the most minimal sort of Transform stream.
// Every written chunk gets output as-is.



module.exports = PassThrough;
var Transform = __webpack_require__(/*! ./_stream_transform */ 9065);

/*<replacement>*/
var util = Object.create(__webpack_require__(/*! core-util-is */ 500));
util.inherits = __webpack_require__(/*! inherits */ 7694);
/*</replacement>*/

util.inherits(PassThrough, Transform);
function PassThrough(options) {
  if (!(this instanceof PassThrough)) return new PassThrough(options);
  Transform.call(this, options);
}
PassThrough.prototype._transform = function (chunk, encoding, cb) {
  cb(null, chunk);
};

/***/ }),

/***/ 1305:
/*!*******************************************************************!*\
  !*** ../app/node_modules/readable-stream/lib/_stream_readable.js ***!
  \*******************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.



/*<replacement>*/
var pna = __webpack_require__(/*! process-nextick-args */ 7091);
/*</replacement>*/

module.exports = Readable;

/*<replacement>*/
var isArray = __webpack_require__(/*! isarray */ 8520);
/*</replacement>*/

/*<replacement>*/
var Duplex;
/*</replacement>*/

Readable.ReadableState = ReadableState;

/*<replacement>*/
var EE = (__webpack_require__(/*! events */ 2361).EventEmitter);
var EElistenerCount = function (emitter, type) {
  return emitter.listeners(type).length;
};
/*</replacement>*/

/*<replacement>*/
var Stream = __webpack_require__(/*! ./internal/streams/stream */ 7834);
/*</replacement>*/

/*<replacement>*/

var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
var OurUint8Array = global.Uint8Array || function () {};
function _uint8ArrayToBuffer(chunk) {
  return Buffer.from(chunk);
}
function _isUint8Array(obj) {
  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
}

/*</replacement>*/

/*<replacement>*/
var util = Object.create(__webpack_require__(/*! core-util-is */ 500));
util.inherits = __webpack_require__(/*! inherits */ 7694);
/*</replacement>*/

/*<replacement>*/
var debugUtil = __webpack_require__(/*! util */ 3837);
var debug = void 0;
if (debugUtil && debugUtil.debuglog) {
  debug = debugUtil.debuglog('stream');
} else {
  debug = function () {};
}
/*</replacement>*/

var BufferList = __webpack_require__(/*! ./internal/streams/BufferList */ 1651);
var destroyImpl = __webpack_require__(/*! ./internal/streams/destroy */ 5456);
var StringDecoder;
util.inherits(Readable, Stream);
var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];
function prependListener(emitter, event, fn) {
  // Sadly this is not cacheable as some libraries bundle their own
  // event emitter implementation with them.
  if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn);

  // This is a hack to make sure that our error handler is attached before any
  // userland ones.  NEVER DO THIS. This is here only because this code needs
  // to continue to work with older versions of Node.js that do not include
  // the prependListener() method. The goal is to eventually remove this hack.
  if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];
}
function ReadableState(options, stream) {
  Duplex = Duplex || __webpack_require__(/*! ./_stream_duplex */ 7669);
  options = options || {};

  // Duplex streams are both readable and writable, but share
  // the same options object.
  // However, some cases require setting options to different
  // values for the readable and the writable sides of the duplex stream.
  // These options can be provided separately as readableXXX and writableXXX.
  var isDuplex = stream instanceof Duplex;

  // object stream flag. Used to make read(n) ignore n and to
  // make all the buffer merging and length checks go away
  this.objectMode = !!options.objectMode;
  if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;

  // the point at which it stops calling _read() to fill the buffer
  // Note: 0 is a valid value, means "don't call _read preemptively ever"
  var hwm = options.highWaterMark;
  var readableHwm = options.readableHighWaterMark;
  var defaultHwm = this.objectMode ? 16 : 16 * 1024;
  if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm;else this.highWaterMark = defaultHwm;

  // cast to ints.
  this.highWaterMark = Math.floor(this.highWaterMark);

  // A linked list is used to store data chunks instead of an array because the
  // linked list can remove elements from the beginning faster than
  // array.shift()
  this.buffer = new BufferList();
  this.length = 0;
  this.pipes = null;
  this.pipesCount = 0;
  this.flowing = null;
  this.ended = false;
  this.endEmitted = false;
  this.reading = false;

  // a flag to be able to tell if the event 'readable'/'data' is emitted
  // immediately, or on a later tick.  We set this to true at first, because
  // any actions that shouldn't happen until "later" should generally also
  // not happen before the first read call.
  this.sync = true;

  // whenever we return null, then we set a flag to say
  // that we're awaiting a 'readable' event emission.
  this.needReadable = false;
  this.emittedReadable = false;
  this.readableListening = false;
  this.resumeScheduled = false;

  // has it been destroyed
  this.destroyed = false;

  // Crypto is kind of old and crusty.  Historically, its default string
  // encoding is 'binary' so we have to make this configurable.
  // Everything else in the universe uses 'utf8', though.
  this.defaultEncoding = options.defaultEncoding || 'utf8';

  // the number of writers that are awaiting a drain event in .pipe()s
  this.awaitDrain = 0;

  // if true, a maybeReadMore has been scheduled
  this.readingMore = false;
  this.decoder = null;
  this.encoding = null;
  if (options.encoding) {
    if (!StringDecoder) StringDecoder = (__webpack_require__(/*! string_decoder/ */ 7786)/* .StringDecoder */ .s);
    this.decoder = new StringDecoder(options.encoding);
    this.encoding = options.encoding;
  }
}
function Readable(options) {
  Duplex = Duplex || __webpack_require__(/*! ./_stream_duplex */ 7669);
  if (!(this instanceof Readable)) return new Readable(options);
  this._readableState = new ReadableState(options, this);

  // legacy
  this.readable = true;
  if (options) {
    if (typeof options.read === 'function') this._read = options.read;
    if (typeof options.destroy === 'function') this._destroy = options.destroy;
  }
  Stream.call(this);
}
Object.defineProperty(Readable.prototype, 'destroyed', {
  get: function () {
    if (this._readableState === undefined) {
      return false;
    }
    return this._readableState.destroyed;
  },
  set: function (value) {
    // we ignore the value if the stream
    // has not been initialized yet
    if (!this._readableState) {
      return;
    }

    // backward compatibility, the user is explicitly
    // managing destroyed
    this._readableState.destroyed = value;
  }
});
Readable.prototype.destroy = destroyImpl.destroy;
Readable.prototype._undestroy = destroyImpl.undestroy;
Readable.prototype._destroy = function (err, cb) {
  this.push(null);
  cb(err);
};

// Manually shove something into the read() buffer.
// This returns true if the highWaterMark has not been hit yet,
// similar to how Writable.write() returns true if you should
// write() some more.
Readable.prototype.push = function (chunk, encoding) {
  var state = this._readableState;
  var skipChunkCheck;
  if (!state.objectMode) {
    if (typeof chunk === 'string') {
      encoding = encoding || state.defaultEncoding;
      if (encoding !== state.encoding) {
        chunk = Buffer.from(chunk, encoding);
        encoding = '';
      }
      skipChunkCheck = true;
    }
  } else {
    skipChunkCheck = true;
  }
  return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
};

// Unshift should *always* be something directly out of read()
Readable.prototype.unshift = function (chunk) {
  return readableAddChunk(this, chunk, null, true, false);
};
function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
  var state = stream._readableState;
  if (chunk === null) {
    state.reading = false;
    onEofChunk(stream, state);
  } else {
    var er;
    if (!skipChunkCheck) er = chunkInvalid(state, chunk);
    if (er) {
      stream.emit('error', er);
    } else if (state.objectMode || chunk && chunk.length > 0) {
      if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {
        chunk = _uint8ArrayToBuffer(chunk);
      }
      if (addToFront) {
        if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true);
      } else if (state.ended) {
        stream.emit('error', new Error('stream.push() after EOF'));
      } else {
        state.reading = false;
        if (state.decoder && !encoding) {
          chunk = state.decoder.write(chunk);
          if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);
        } else {
          addChunk(stream, state, chunk, false);
        }
      }
    } else if (!addToFront) {
      state.reading = false;
    }
  }
  return needMoreData(state);
}
function addChunk(stream, state, chunk, addToFront) {
  if (state.flowing && state.length === 0 && !state.sync) {
    stream.emit('data', chunk);
    stream.read(0);
  } else {
    // update the buffer info.
    state.length += state.objectMode ? 1 : chunk.length;
    if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);
    if (state.needReadable) emitReadable(stream);
  }
  maybeReadMore(stream, state);
}
function chunkInvalid(state, chunk) {
  var er;
  if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
    er = new TypeError('Invalid non-string/buffer chunk');
  }
  return er;
}

// if it's past the high water mark, we can push in some more.
// Also, if we have no data yet, we can stand some
// more bytes.  This is to work around cases where hwm=0,
// such as the repl.  Also, if the push() triggered a
// readable event, and the user called read(largeNumber) such that
// needReadable was set, then we ought to push more, so that another
// 'readable' event will be triggered.
function needMoreData(state) {
  return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);
}
Readable.prototype.isPaused = function () {
  return this._readableState.flowing === false;
};

// backwards compatibility.
Readable.prototype.setEncoding = function (enc) {
  if (!StringDecoder) StringDecoder = (__webpack_require__(/*! string_decoder/ */ 7786)/* .StringDecoder */ .s);
  this._readableState.decoder = new StringDecoder(enc);
  this._readableState.encoding = enc;
  return this;
};

// Don't raise the hwm > 8MB
var MAX_HWM = 0x800000;
function computeNewHighWaterMark(n) {
  if (n >= MAX_HWM) {
    n = MAX_HWM;
  } else {
    // Get the next highest power of 2 to prevent increasing hwm excessively in
    // tiny amounts
    n--;
    n |= n >>> 1;
    n |= n >>> 2;
    n |= n >>> 4;
    n |= n >>> 8;
    n |= n >>> 16;
    n++;
  }
  return n;
}

// This function is designed to be inlinable, so please take care when making
// changes to the function body.
function howMuchToRead(n, state) {
  if (n <= 0 || state.length === 0 && state.ended) return 0;
  if (state.objectMode) return 1;
  if (n !== n) {
    // Only flow one buffer at a time
    if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;
  }
  // If we're asking for more than the current hwm, then raise the hwm.
  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
  if (n <= state.length) return n;
  // Don't have enough
  if (!state.ended) {
    state.needReadable = true;
    return 0;
  }
  return state.length;
}

// you can override either this method, or the async _read(n) below.
Readable.prototype.read = function (n) {
  debug('read', n);
  n = parseInt(n, 10);
  var state = this._readableState;
  var nOrig = n;
  if (n !== 0) state.emittedReadable = false;

  // if we're doing read(0) to trigger a readable event, but we
  // already have a bunch of data in the buffer, then just trigger
  // the 'readable' event and move on.
  if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {
    debug('read: emitReadable', state.length, state.ended);
    if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);
    return null;
  }
  n = howMuchToRead(n, state);

  // if we've ended, and we're now clear, then finish it up.
  if (n === 0 && state.ended) {
    if (state.length === 0) endReadable(this);
    return null;
  }

  // All the actual chunk generation logic needs to be
  // *below* the call to _read.  The reason is that in certain
  // synthetic stream cases, such as passthrough streams, _read
  // may be a completely synchronous operation which may change
  // the state of the read buffer, providing enough data when
  // before there was *not* enough.
  //
  // So, the steps are:
  // 1. Figure out what the state of things will be after we do
  // a read from the buffer.
  //
  // 2. If that resulting state will trigger a _read, then call _read.
  // Note that this may be asynchronous, or synchronous.  Yes, it is
  // deeply ugly to write APIs this way, but that still doesn't mean
  // that the Readable class should behave improperly, as streams are
  // designed to be sync/async agnostic.
  // Take note if the _read call is sync or async (ie, if the read call
  // has returned yet), so that we know whether or not it's safe to emit
  // 'readable' etc.
  //
  // 3. Actually pull the requested chunks out of the buffer and return.

  // if we need a readable event, then we need to do some reading.
  var doRead = state.needReadable;
  debug('need readable', doRead);

  // if we currently have less than the highWaterMark, then also read some
  if (state.length === 0 || state.length - n < state.highWaterMark) {
    doRead = true;
    debug('length less than watermark', doRead);
  }

  // however, if we've ended, then there's no point, and if we're already
  // reading, then it's unnecessary.
  if (state.ended || state.reading) {
    doRead = false;
    debug('reading or ended', doRead);
  } else if (doRead) {
    debug('do read');
    state.reading = true;
    state.sync = true;
    // if the length is currently zero, then we *need* a readable event.
    if (state.length === 0) state.needReadable = true;
    // call internal read method
    this._read(state.highWaterMark);
    state.sync = false;
    // If _read pushed data synchronously, then `reading` will be false,
    // and we need to re-evaluate how much data we can return to the user.
    if (!state.reading) n = howMuchToRead(nOrig, state);
  }
  var ret;
  if (n > 0) ret = fromList(n, state);else ret = null;
  if (ret === null) {
    state.needReadable = true;
    n = 0;
  } else {
    state.length -= n;
  }
  if (state.length === 0) {
    // If we have nothing in the buffer, then we want to know
    // as soon as we *do* get something into the buffer.
    if (!state.ended) state.needReadable = true;

    // If we tried to read() past the EOF, then emit end on the next tick.
    if (nOrig !== n && state.ended) endReadable(this);
  }
  if (ret !== null) this.emit('data', ret);
  return ret;
};
function onEofChunk(stream, state) {
  if (state.ended) return;
  if (state.decoder) {
    var chunk = state.decoder.end();
    if (chunk && chunk.length) {
      state.buffer.push(chunk);
      state.length += state.objectMode ? 1 : chunk.length;
    }
  }
  state.ended = true;

  // emit 'readable' now to make sure it gets picked up.
  emitReadable(stream);
}

// Don't emit readable right away in sync mode, because this can trigger
// another read() call => stack overflow.  This way, it might trigger
// a nextTick recursion warning, but that's not so bad.
function emitReadable(stream) {
  var state = stream._readableState;
  state.needReadable = false;
  if (!state.emittedReadable) {
    debug('emitReadable', state.flowing);
    state.emittedReadable = true;
    if (state.sync) pna.nextTick(emitReadable_, stream);else emitReadable_(stream);
  }
}
function emitReadable_(stream) {
  debug('emit readable');
  stream.emit('readable');
  flow(stream);
}

// at this point, the user has presumably seen the 'readable' event,
// and called read() to consume some data.  that may have triggered
// in turn another _read(n) call, in which case reading = true if
// it's in progress.
// However, if we're not ended, or reading, and the length < hwm,
// then go ahead and try to read some more preemptively.
function maybeReadMore(stream, state) {
  if (!state.readingMore) {
    state.readingMore = true;
    pna.nextTick(maybeReadMore_, stream, state);
  }
}
function maybeReadMore_(stream, state) {
  var len = state.length;
  while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {
    debug('maybeReadMore read 0');
    stream.read(0);
    if (len === state.length)
      // didn't get any data, stop spinning.
      break;else len = state.length;
  }
  state.readingMore = false;
}

// abstract method.  to be overridden in specific implementation classes.
// call cb(er, data) where data is <= n in length.
// for virtual (non-string, non-buffer) streams, "length" is somewhat
// arbitrary, and perhaps not very meaningful.
Readable.prototype._read = function (n) {
  this.emit('error', new Error('_read() is not implemented'));
};
Readable.prototype.pipe = function (dest, pipeOpts) {
  var src = this;
  var state = this._readableState;
  switch (state.pipesCount) {
    case 0:
      state.pipes = dest;
      break;
    case 1:
      state.pipes = [state.pipes, dest];
      break;
    default:
      state.pipes.push(dest);
      break;
  }
  state.pipesCount += 1;
  debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);
  var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
  var endFn = doEnd ? onend : unpipe;
  if (state.endEmitted) pna.nextTick(endFn);else src.once('end', endFn);
  dest.on('unpipe', onunpipe);
  function onunpipe(readable, unpipeInfo) {
    debug('onunpipe');
    if (readable === src) {
      if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
        unpipeInfo.hasUnpiped = true;
        cleanup();
      }
    }
  }
  function onend() {
    debug('onend');
    dest.end();
  }

  // when the dest drains, it reduces the awaitDrain counter
  // on the source.  This would be more elegant with a .once()
  // handler in flow(), but adding and removing repeatedly is
  // too slow.
  var ondrain = pipeOnDrain(src);
  dest.on('drain', ondrain);
  var cleanedUp = false;
  function cleanup() {
    debug('cleanup');
    // cleanup event handlers once the pipe is broken
    dest.removeListener('close', onclose);
    dest.removeListener('finish', onfinish);
    dest.removeListener('drain', ondrain);
    dest.removeListener('error', onerror);
    dest.removeListener('unpipe', onunpipe);
    src.removeListener('end', onend);
    src.removeListener('end', unpipe);
    src.removeListener('data', ondata);
    cleanedUp = true;

    // if the reader is waiting for a drain event from this
    // specific writer, then it would cause it to never start
    // flowing again.
    // So, if this is awaiting a drain, then we just call it now.
    // If we don't know, then assume that we are waiting for one.
    if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
  }

  // If the user pushes more data while we're writing to dest then we'll end up
  // in ondata again. However, we only want to increase awaitDrain once because
  // dest will only emit one 'drain' event for the multiple writes.
  // => Introduce a guard on increasing awaitDrain.
  var increasedAwaitDrain = false;
  src.on('data', ondata);
  function ondata(chunk) {
    debug('ondata');
    increasedAwaitDrain = false;
    var ret = dest.write(chunk);
    if (false === ret && !increasedAwaitDrain) {
      // If the user unpiped during `dest.write()`, it is possible
      // to get stuck in a permanently paused state if that write
      // also returned false.
      // => Check whether `dest` is still a piping destination.
      if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
        debug('false write response, pause', src._readableState.awaitDrain);
        src._readableState.awaitDrain++;
        increasedAwaitDrain = true;
      }
      src.pause();
    }
  }

  // if the dest has an error, then stop piping into it.
  // however, don't suppress the throwing behavior for this.
  function onerror(er) {
    debug('onerror', er);
    unpipe();
    dest.removeListener('error', onerror);
    if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);
  }

  // Make sure our error handler is attached before userland ones.
  prependListener(dest, 'error', onerror);

  // Both close and finish should trigger unpipe, but only once.
  function onclose() {
    dest.removeListener('finish', onfinish);
    unpipe();
  }
  dest.once('close', onclose);
  function onfinish() {
    debug('onfinish');
    dest.removeListener('close', onclose);
    unpipe();
  }
  dest.once('finish', onfinish);
  function unpipe() {
    debug('unpipe');
    src.unpipe(dest);
  }

  // tell the dest that it's being piped to
  dest.emit('pipe', src);

  // start the flow if it hasn't been started already.
  if (!state.flowing) {
    debug('pipe resume');
    src.resume();
  }
  return dest;
};
function pipeOnDrain(src) {
  return function () {
    var state = src._readableState;
    debug('pipeOnDrain', state.awaitDrain);
    if (state.awaitDrain) state.awaitDrain--;
    if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {
      state.flowing = true;
      flow(src);
    }
  };
}
Readable.prototype.unpipe = function (dest) {
  var state = this._readableState;
  var unpipeInfo = {
    hasUnpiped: false
  };

  // if we're not piping anywhere, then do nothing.
  if (state.pipesCount === 0) return this;

  // just one destination.  most common case.
  if (state.pipesCount === 1) {
    // passed in one, but it's not the right one.
    if (dest && dest !== state.pipes) return this;
    if (!dest) dest = state.pipes;

    // got a match.
    state.pipes = null;
    state.pipesCount = 0;
    state.flowing = false;
    if (dest) dest.emit('unpipe', this, unpipeInfo);
    return this;
  }

  // slow case. multiple pipe destinations.

  if (!dest) {
    // remove all.
    var dests = state.pipes;
    var len = state.pipesCount;
    state.pipes = null;
    state.pipesCount = 0;
    state.flowing = false;
    for (var i = 0; i < len; i++) {
      dests[i].emit('unpipe', this, unpipeInfo);
    }
    return this;
  }

  // try to find the right one.
  var index = indexOf(state.pipes, dest);
  if (index === -1) return this;
  state.pipes.splice(index, 1);
  state.pipesCount -= 1;
  if (state.pipesCount === 1) state.pipes = state.pipes[0];
  dest.emit('unpipe', this, unpipeInfo);
  return this;
};

// set up data events if they are asked for
// Ensure readable listeners eventually get something
Readable.prototype.on = function (ev, fn) {
  var res = Stream.prototype.on.call(this, ev, fn);
  if (ev === 'data') {
    // Start flowing on next tick if stream isn't explicitly paused
    if (this._readableState.flowing !== false) this.resume();
  } else if (ev === 'readable') {
    var state = this._readableState;
    if (!state.endEmitted && !state.readableListening) {
      state.readableListening = state.needReadable = true;
      state.emittedReadable = false;
      if (!state.reading) {
        pna.nextTick(nReadingNextTick, this);
      } else if (state.length) {
        emitReadable(this);
      }
    }
  }
  return res;
};
Readable.prototype.addListener = Readable.prototype.on;
function nReadingNextTick(self) {
  debug('readable nexttick read 0');
  self.read(0);
}

// pause() and resume() are remnants of the legacy readable stream API
// If the user uses them, then switch into old mode.
Readable.prototype.resume = function () {
  var state = this._readableState;
  if (!state.flowing) {
    debug('resume');
    state.flowing = true;
    resume(this, state);
  }
  return this;
};
function resume(stream, state) {
  if (!state.resumeScheduled) {
    state.resumeScheduled = true;
    pna.nextTick(resume_, stream, state);
  }
}
function resume_(stream, state) {
  if (!state.reading) {
    debug('resume read 0');
    stream.read(0);
  }
  state.resumeScheduled = false;
  state.awaitDrain = 0;
  stream.emit('resume');
  flow(stream);
  if (state.flowing && !state.reading) stream.read(0);
}
Readable.prototype.pause = function () {
  debug('call pause flowing=%j', this._readableState.flowing);
  if (false !== this._readableState.flowing) {
    debug('pause');
    this._readableState.flowing = false;
    this.emit('pause');
  }
  return this;
};
function flow(stream) {
  var state = stream._readableState;
  debug('flow', state.flowing);
  while (state.flowing && stream.read() !== null) {}
}

// wrap an old-style stream as the async data source.
// This is *not* part of the readable stream interface.
// It is an ugly unfortunate mess of history.
Readable.prototype.wrap = function (stream) {
  var _this = this;
  var state = this._readableState;
  var paused = false;
  stream.on('end', function () {
    debug('wrapped end');
    if (state.decoder && !state.ended) {
      var chunk = state.decoder.end();
      if (chunk && chunk.length) _this.push(chunk);
    }
    _this.push(null);
  });
  stream.on('data', function (chunk) {
    debug('wrapped data');
    if (state.decoder) chunk = state.decoder.write(chunk);

    // don't skip over falsy values in objectMode
    if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;
    var ret = _this.push(chunk);
    if (!ret) {
      paused = true;
      stream.pause();
    }
  });

  // proxy all the other methods.
  // important when wrapping filters and duplexes.
  for (var i in stream) {
    if (this[i] === undefined && typeof stream[i] === 'function') {
      this[i] = function (method) {
        return function () {
          return stream[method].apply(stream, arguments);
        };
      }(i);
    }
  }

  // proxy certain important events.
  for (var n = 0; n < kProxyEvents.length; n++) {
    stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
  }

  // when we try to consume some more bytes, simply unpause the
  // underlying stream.
  this._read = function (n) {
    debug('wrapped _read', n);
    if (paused) {
      paused = false;
      stream.resume();
    }
  };
  return this;
};
Object.defineProperty(Readable.prototype, 'readableHighWaterMark', {
  // making it explicit this property is not enumerable
  // because otherwise some prototype manipulation in
  // userland will fail
  enumerable: false,
  get: function () {
    return this._readableState.highWaterMark;
  }
});

// exposed for testing purposes only.
Readable._fromList = fromList;

// Pluck off n bytes from an array of buffers.
// Length is the combined lengths of all the buffers in the list.
// This function is designed to be inlinable, so please take care when making
// changes to the function body.
function fromList(n, state) {
  // nothing buffered
  if (state.length === 0) return null;
  var ret;
  if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {
    // read it all, truncate the list
    if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length);
    state.buffer.clear();
  } else {
    // read part of list
    ret = fromListPartial(n, state.buffer, state.decoder);
  }
  return ret;
}

// Extracts only enough buffered data to satisfy the amount requested.
// This function is designed to be inlinable, so please take care when making
// changes to the function body.
function fromListPartial(n, list, hasStrings) {
  var ret;
  if (n < list.head.data.length) {
    // slice is the same for buffers and strings
    ret = list.head.data.slice(0, n);
    list.head.data = list.head.data.slice(n);
  } else if (n === list.head.data.length) {
    // first chunk is a perfect match
    ret = list.shift();
  } else {
    // result spans more than one buffer
    ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);
  }
  return ret;
}

// Copies a specified amount of characters from the list of buffered data
// chunks.
// This function is designed to be inlinable, so please take care when making
// changes to the function body.
function copyFromBufferString(n, list) {
  var p = list.head;
  var c = 1;
  var ret = p.data;
  n -= ret.length;
  while (p = p.next) {
    var str = p.data;
    var nb = n > str.length ? str.length : n;
    if (nb === str.length) ret += str;else ret += str.slice(0, n);
    n -= nb;
    if (n === 0) {
      if (nb === str.length) {
        ++c;
        if (p.next) list.head = p.next;else list.head = list.tail = null;
      } else {
        list.head = p;
        p.data = str.slice(nb);
      }
      break;
    }
    ++c;
  }
  list.length -= c;
  return ret;
}

// Copies a specified amount of bytes from the list of buffered data chunks.
// This function is designed to be inlinable, so please take care when making
// changes to the function body.
function copyFromBuffer(n, list) {
  var ret = Buffer.allocUnsafe(n);
  var p = list.head;
  var c = 1;
  p.data.copy(ret);
  n -= p.data.length;
  while (p = p.next) {
    var buf = p.data;
    var nb = n > buf.length ? buf.length : n;
    buf.copy(ret, ret.length - n, 0, nb);
    n -= nb;
    if (n === 0) {
      if (nb === buf.length) {
        ++c;
        if (p.next) list.head = p.next;else list.head = list.tail = null;
      } else {
        list.head = p;
        p.data = buf.slice(nb);
      }
      break;
    }
    ++c;
  }
  list.length -= c;
  return ret;
}
function endReadable(stream) {
  var state = stream._readableState;

  // If we get here before consuming all the bytes, then that is a
  // bug in node.  Should never happen.
  if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream');
  if (!state.endEmitted) {
    state.ended = true;
    pna.nextTick(endReadableNT, state, stream);
  }
}
function endReadableNT(state, stream) {
  // Check that we didn't get one last unshift.
  if (!state.endEmitted && state.length === 0) {
    state.endEmitted = true;
    stream.readable = false;
    stream.emit('end');
  }
}
function indexOf(xs, x) {
  for (var i = 0, l = xs.length; i < l; i++) {
    if (xs[i] === x) return i;
  }
  return -1;
}

/***/ }),

/***/ 9065:
/*!********************************************************************!*\
  !*** ../app/node_modules/readable-stream/lib/_stream_transform.js ***!
  \********************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

// a transform stream is a readable/writable stream where you do
// something with the data.  Sometimes it's called a "filter",
// but that's not a great name for it, since that implies a thing where
// some bits pass through, and others are simply ignored.  (That would
// be a valid example of a transform, of course.)
//
// While the output is causally related to the input, it's not a
// necessarily symmetric or synchronous transformation.  For example,
// a zlib stream might take multiple plain-text writes(), and then
// emit a single compressed chunk some time in the future.
//
// Here's how this works:
//
// The Transform stream has all the aspects of the readable and writable
// stream classes.  When you write(chunk), that calls _write(chunk,cb)
// internally, and returns false if there's a lot of pending writes
// buffered up.  When you call read(), that calls _read(n) until
// there's enough pending readable data buffered up.
//
// In a transform stream, the written data is placed in a buffer.  When
// _read(n) is called, it transforms the queued up data, calling the
// buffered _write cb's as it consumes chunks.  If consuming a single
// written chunk would result in multiple output chunks, then the first
// outputted bit calls the readcb, and subsequent chunks just go into
// the read buffer, and will cause it to emit 'readable' if necessary.
//
// This way, back-pressure is actually determined by the reading side,
// since _read has to be called to start processing a new chunk.  However,
// a pathological inflate type of transform can cause excessive buffering
// here.  For example, imagine a stream where every byte of input is
// interpreted as an integer from 0-255, and then results in that many
// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in
// 1kb of data being output.  In this case, you could write a very small
// amount of input, and end up with a very large amount of output.  In
// such a pathological inflating mechanism, there'd be no way to tell
// the system to stop doing the transform.  A single 4MB write could
// cause the system to run out of memory.
//
// However, even in such a pathological case, only a single written chunk
// would be consumed, and then the rest would wait (un-transformed) until
// the results of the previous transformed chunk were consumed.



module.exports = Transform;
var Duplex = __webpack_require__(/*! ./_stream_duplex */ 7669);

/*<replacement>*/
var util = Object.create(__webpack_require__(/*! core-util-is */ 500));
util.inherits = __webpack_require__(/*! inherits */ 7694);
/*</replacement>*/

util.inherits(Transform, Duplex);
function afterTransform(er, data) {
  var ts = this._transformState;
  ts.transforming = false;
  var cb = ts.writecb;
  if (!cb) {
    return this.emit('error', new Error('write callback called multiple times'));
  }
  ts.writechunk = null;
  ts.writecb = null;
  if (data != null)
    // single equals check for both `null` and `undefined`
    this.push(data);
  cb(er);
  var rs = this._readableState;
  rs.reading = false;
  if (rs.needReadable || rs.length < rs.highWaterMark) {
    this._read(rs.highWaterMark);
  }
}
function Transform(options) {
  if (!(this instanceof Transform)) return new Transform(options);
  Duplex.call(this, options);
  this._transformState = {
    afterTransform: afterTransform.bind(this),
    needTransform: false,
    transforming: false,
    writecb: null,
    writechunk: null,
    writeencoding: null
  };

  // start out asking for a readable event once data is transformed.
  this._readableState.needReadable = true;

  // we have implemented the _read method, and done the other things
  // that Readable wants before the first _read call, so unset the
  // sync guard flag.
  this._readableState.sync = false;
  if (options) {
    if (typeof options.transform === 'function') this._transform = options.transform;
    if (typeof options.flush === 'function') this._flush = options.flush;
  }

  // When the writable side finishes, then flush out anything remaining.
  this.on('prefinish', prefinish);
}
function prefinish() {
  var _this = this;
  if (typeof this._flush === 'function') {
    this._flush(function (er, data) {
      done(_this, er, data);
    });
  } else {
    done(this, null, null);
  }
}
Transform.prototype.push = function (chunk, encoding) {
  this._transformState.needTransform = false;
  return Duplex.prototype.push.call(this, chunk, encoding);
};

// This is the part where you do stuff!
// override this function in implementation classes.
// 'chunk' is an input chunk.
//
// Call `push(newChunk)` to pass along transformed output
// to the readable side.  You may call 'push' zero or more times.
//
// Call `cb(err)` when you are done with this chunk.  If you pass
// an error, then that'll put the hurt on the whole operation.  If you
// never call cb(), then you'll never get another chunk.
Transform.prototype._transform = function (chunk, encoding, cb) {
  throw new Error('_transform() is not implemented');
};
Transform.prototype._write = function (chunk, encoding, cb) {
  var ts = this._transformState;
  ts.writecb = cb;
  ts.writechunk = chunk;
  ts.writeencoding = encoding;
  if (!ts.transforming) {
    var rs = this._readableState;
    if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
  }
};

// Doesn't matter what the args are here.
// _transform does all the work.
// That we got here means that the readable side wants more data.
Transform.prototype._read = function (n) {
  var ts = this._transformState;
  if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
    ts.transforming = true;
    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
  } else {
    // mark that we need a transform, so that any data that comes in
    // will get processed, now that we've asked for it.
    ts.needTransform = true;
  }
};
Transform.prototype._destroy = function (err, cb) {
  var _this2 = this;
  Duplex.prototype._destroy.call(this, err, function (err2) {
    cb(err2);
    _this2.emit('close');
  });
};
function done(stream, er, data) {
  if (er) return stream.emit('error', er);
  if (data != null)
    // single equals check for both `null` and `undefined`
    stream.push(data);

  // if there's nothing in the write buffer, then that means
  // that nothing more will ever be provided
  if (stream._writableState.length) throw new Error('Calling transform done when ws.length != 0');
  if (stream._transformState.transforming) throw new Error('Calling transform done when still transforming');
  return stream.push(null);
}

/***/ }),

/***/ 2813:
/*!*******************************************************************!*\
  !*** ../app/node_modules/readable-stream/lib/_stream_writable.js ***!
  \*******************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

// A bit simpler than readable streams.
// Implement an async ._write(chunk, encoding, cb), and it'll handle all
// the drain event emission and buffering.



/*<replacement>*/
var pna = __webpack_require__(/*! process-nextick-args */ 7091);
/*</replacement>*/

module.exports = Writable;

/* <replacement> */
function WriteReq(chunk, encoding, cb) {
  this.chunk = chunk;
  this.encoding = encoding;
  this.callback = cb;
  this.next = null;
}

// It seems a linked list but it is not
// there will be only 2 of these for each stream
function CorkedRequest(state) {
  var _this = this;
  this.next = null;
  this.entry = null;
  this.finish = function () {
    onCorkedFinish(_this, state);
  };
}
/* </replacement> */

/*<replacement>*/
var asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;
/*</replacement>*/

/*<replacement>*/
var Duplex;
/*</replacement>*/

Writable.WritableState = WritableState;

/*<replacement>*/
var util = Object.create(__webpack_require__(/*! core-util-is */ 500));
util.inherits = __webpack_require__(/*! inherits */ 7694);
/*</replacement>*/

/*<replacement>*/
var internalUtil = {
  deprecate: __webpack_require__(/*! util-deprecate */ 4521)
};
/*</replacement>*/

/*<replacement>*/
var Stream = __webpack_require__(/*! ./internal/streams/stream */ 7834);
/*</replacement>*/

/*<replacement>*/

var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
var OurUint8Array = global.Uint8Array || function () {};
function _uint8ArrayToBuffer(chunk) {
  return Buffer.from(chunk);
}
function _isUint8Array(obj) {
  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
}

/*</replacement>*/

var destroyImpl = __webpack_require__(/*! ./internal/streams/destroy */ 5456);
util.inherits(Writable, Stream);
function nop() {}
function WritableState(options, stream) {
  Duplex = Duplex || __webpack_require__(/*! ./_stream_duplex */ 7669);
  options = options || {};

  // Duplex streams are both readable and writable, but share
  // the same options object.
  // However, some cases require setting options to different
  // values for the readable and the writable sides of the duplex stream.
  // These options can be provided separately as readableXXX and writableXXX.
  var isDuplex = stream instanceof Duplex;

  // object stream flag to indicate whether or not this stream
  // contains buffers or objects.
  this.objectMode = !!options.objectMode;
  if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;

  // the point at which write() starts returning false
  // Note: 0 is a valid value, means that we always return false if
  // the entire buffer is not flushed immediately on write()
  var hwm = options.highWaterMark;
  var writableHwm = options.writableHighWaterMark;
  var defaultHwm = this.objectMode ? 16 : 16 * 1024;
  if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;else this.highWaterMark = defaultHwm;

  // cast to ints.
  this.highWaterMark = Math.floor(this.highWaterMark);

  // if _final has been called
  this.finalCalled = false;

  // drain event flag.
  this.needDrain = false;
  // at the start of calling end()
  this.ending = false;
  // when end() has been called, and returned
  this.ended = false;
  // when 'finish' is emitted
  this.finished = false;

  // has it been destroyed
  this.destroyed = false;

  // should we decode strings into buffers before passing to _write?
  // this is here so that some node-core streams can optimize string
  // handling at a lower level.
  var noDecode = options.decodeStrings === false;
  this.decodeStrings = !noDecode;

  // Crypto is kind of old and crusty.  Historically, its default string
  // encoding is 'binary' so we have to make this configurable.
  // Everything else in the universe uses 'utf8', though.
  this.defaultEncoding = options.defaultEncoding || 'utf8';

  // not an actual buffer we keep track of, but a measurement
  // of how much we're waiting to get pushed to some underlying
  // socket or file.
  this.length = 0;

  // a flag to see when we're in the middle of a write.
  this.writing = false;

  // when true all writes will be buffered until .uncork() call
  this.corked = 0;

  // a flag to be able to tell if the onwrite cb is called immediately,
  // or on a later tick.  We set this to true at first, because any
  // actions that shouldn't happen until "later" should generally also
  // not happen before the first write call.
  this.sync = true;

  // a flag to know if we're processing previously buffered items, which
  // may call the _write() callback in the same tick, so that we don't
  // end up in an overlapped onwrite situation.
  this.bufferProcessing = false;

  // the callback that's passed to _write(chunk,cb)
  this.onwrite = function (er) {
    onwrite(stream, er);
  };

  // the callback that the user supplies to write(chunk,encoding,cb)
  this.writecb = null;

  // the amount that is being written when _write is called.
  this.writelen = 0;
  this.bufferedRequest = null;
  this.lastBufferedRequest = null;

  // number of pending user-supplied write callbacks
  // this must be 0 before 'finish' can be emitted
  this.pendingcb = 0;

  // emit prefinish if the only thing we're waiting for is _write cbs
  // This is relevant for synchronous Transform streams
  this.prefinished = false;

  // True if the error was already emitted and should not be thrown again
  this.errorEmitted = false;

  // count buffered requests
  this.bufferedRequestCount = 0;

  // allocate the first CorkedRequest, there is always
  // one allocated and free to use, and we maintain at most two
  this.corkedRequestsFree = new CorkedRequest(this);
}
WritableState.prototype.getBuffer = function getBuffer() {
  var current = this.bufferedRequest;
  var out = [];
  while (current) {
    out.push(current);
    current = current.next;
  }
  return out;
};
(function () {
  try {
    Object.defineProperty(WritableState.prototype, 'buffer', {
      get: internalUtil.deprecate(function () {
        return this.getBuffer();
      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')
    });
  } catch (_) {}
})();

// Test _writableState for inheritance to account for Duplex streams,
// whose prototype chain only points to Readable.
var realHasInstance;
if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {
  realHasInstance = Function.prototype[Symbol.hasInstance];
  Object.defineProperty(Writable, Symbol.hasInstance, {
    value: function (object) {
      if (realHasInstance.call(this, object)) return true;
      if (this !== Writable) return false;
      return object && object._writableState instanceof WritableState;
    }
  });
} else {
  realHasInstance = function (object) {
    return object instanceof this;
  };
}
function Writable(options) {
  Duplex = Duplex || __webpack_require__(/*! ./_stream_duplex */ 7669);

  // Writable ctor is applied to Duplexes, too.
  // `realHasInstance` is necessary because using plain `instanceof`
  // would return false, as no `_writableState` property is attached.

  // Trying to use the custom `instanceof` for Writable here will also break the
  // Node.js LazyTransform implementation, which has a non-trivial getter for
  // `_writableState` that would lead to infinite recursion.
  if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {
    return new Writable(options);
  }
  this._writableState = new WritableState(options, this);

  // legacy.
  this.writable = true;
  if (options) {
    if (typeof options.write === 'function') this._write = options.write;
    if (typeof options.writev === 'function') this._writev = options.writev;
    if (typeof options.destroy === 'function') this._destroy = options.destroy;
    if (typeof options.final === 'function') this._final = options.final;
  }
  Stream.call(this);
}

// Otherwise people can pipe Writable streams, which is just wrong.
Writable.prototype.pipe = function () {
  this.emit('error', new Error('Cannot pipe, not readable'));
};
function writeAfterEnd(stream, cb) {
  var er = new Error('write after end');
  // TODO: defer error events consistently everywhere, not just the cb
  stream.emit('error', er);
  pna.nextTick(cb, er);
}

// Checks that a user-supplied chunk is valid, especially for the particular
// mode the stream is in. Currently this means that `null` is never accepted
// and undefined/non-string values are only allowed in object mode.
function validChunk(stream, state, chunk, cb) {
  var valid = true;
  var er = false;
  if (chunk === null) {
    er = new TypeError('May not write null values to stream');
  } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
    er = new TypeError('Invalid non-string/buffer chunk');
  }
  if (er) {
    stream.emit('error', er);
    pna.nextTick(cb, er);
    valid = false;
  }
  return valid;
}
Writable.prototype.write = function (chunk, encoding, cb) {
  var state = this._writableState;
  var ret = false;
  var isBuf = !state.objectMode && _isUint8Array(chunk);
  if (isBuf && !Buffer.isBuffer(chunk)) {
    chunk = _uint8ArrayToBuffer(chunk);
  }
  if (typeof encoding === 'function') {
    cb = encoding;
    encoding = null;
  }
  if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;
  if (typeof cb !== 'function') cb = nop;
  if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {
    state.pendingcb++;
    ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
  }
  return ret;
};
Writable.prototype.cork = function () {
  var state = this._writableState;
  state.corked++;
};
Writable.prototype.uncork = function () {
  var state = this._writableState;
  if (state.corked) {
    state.corked--;
    if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
  }
};
Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
  // node::ParseEncoding() requires lower case.
  if (typeof encoding === 'string') encoding = encoding.toLowerCase();
  if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding);
  this._writableState.defaultEncoding = encoding;
  return this;
};
function decodeChunk(state, chunk, encoding) {
  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {
    chunk = Buffer.from(chunk, encoding);
  }
  return chunk;
}
Object.defineProperty(Writable.prototype, 'writableHighWaterMark', {
  // making it explicit this property is not enumerable
  // because otherwise some prototype manipulation in
  // userland will fail
  enumerable: false,
  get: function () {
    return this._writableState.highWaterMark;
  }
});

// if we're already writing something, then just put this
// in the queue, and wait our turn.  Otherwise, call _write
// If we return false, then we need a drain event, so set that flag.
function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
  if (!isBuf) {
    var newChunk = decodeChunk(state, chunk, encoding);
    if (chunk !== newChunk) {
      isBuf = true;
      encoding = 'buffer';
      chunk = newChunk;
    }
  }
  var len = state.objectMode ? 1 : chunk.length;
  state.length += len;
  var ret = state.length < state.highWaterMark;
  // we must ensure that previous needDrain will not be reset to false.
  if (!ret) state.needDrain = true;
  if (state.writing || state.corked) {
    var last = state.lastBufferedRequest;
    state.lastBufferedRequest = {
      chunk: chunk,
      encoding: encoding,
      isBuf: isBuf,
      callback: cb,
      next: null
    };
    if (last) {
      last.next = state.lastBufferedRequest;
    } else {
      state.bufferedRequest = state.lastBufferedRequest;
    }
    state.bufferedRequestCount += 1;
  } else {
    doWrite(stream, state, false, len, chunk, encoding, cb);
  }
  return ret;
}
function doWrite(stream, state, writev, len, chunk, encoding, cb) {
  state.writelen = len;
  state.writecb = cb;
  state.writing = true;
  state.sync = true;
  if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);
  state.sync = false;
}
function onwriteError(stream, state, sync, er, cb) {
  --state.pendingcb;
  if (sync) {
    // defer the callback if we are being called synchronously
    // to avoid piling up things on the stack
    pna.nextTick(cb, er);
    // this can emit finish, and it will always happen
    // after error
    pna.nextTick(finishMaybe, stream, state);
    stream._writableState.errorEmitted = true;
    stream.emit('error', er);
  } else {
    // the caller expect this to happen before if
    // it is async
    cb(er);
    stream._writableState.errorEmitted = true;
    stream.emit('error', er);
    // this can emit finish, but finish must
    // always follow error
    finishMaybe(stream, state);
  }
}
function onwriteStateUpdate(state) {
  state.writing = false;
  state.writecb = null;
  state.length -= state.writelen;
  state.writelen = 0;
}
function onwrite(stream, er) {
  var state = stream._writableState;
  var sync = state.sync;
  var cb = state.writecb;
  onwriteStateUpdate(state);
  if (er) onwriteError(stream, state, sync, er, cb);else {
    // Check if we're actually ready to finish, but don't emit yet
    var finished = needFinish(state);
    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
      clearBuffer(stream, state);
    }
    if (sync) {
      /*<replacement>*/
      asyncWrite(afterWrite, stream, state, finished, cb);
      /*</replacement>*/
    } else {
      afterWrite(stream, state, finished, cb);
    }
  }
}
function afterWrite(stream, state, finished, cb) {
  if (!finished) onwriteDrain(stream, state);
  state.pendingcb--;
  cb();
  finishMaybe(stream, state);
}

// Must force callback to be called on nextTick, so that we don't
// emit 'drain' before the write() consumer gets the 'false' return
// value, and has a chance to attach a 'drain' listener.
function onwriteDrain(stream, state) {
  if (state.length === 0 && state.needDrain) {
    state.needDrain = false;
    stream.emit('drain');
  }
}

// if there's something in the buffer waiting, then process it
function clearBuffer(stream, state) {
  state.bufferProcessing = true;
  var entry = state.bufferedRequest;
  if (stream._writev && entry && entry.next) {
    // Fast case, write everything using _writev()
    var l = state.bufferedRequestCount;
    var buffer = new Array(l);
    var holder = state.corkedRequestsFree;
    holder.entry = entry;
    var count = 0;
    var allBuffers = true;
    while (entry) {
      buffer[count] = entry;
      if (!entry.isBuf) allBuffers = false;
      entry = entry.next;
      count += 1;
    }
    buffer.allBuffers = allBuffers;
    doWrite(stream, state, true, state.length, buffer, '', holder.finish);

    // doWrite is almost always async, defer these to save a bit of time
    // as the hot path ends with doWrite
    state.pendingcb++;
    state.lastBufferedRequest = null;
    if (holder.next) {
      state.corkedRequestsFree = holder.next;
      holder.next = null;
    } else {
      state.corkedRequestsFree = new CorkedRequest(state);
    }
    state.bufferedRequestCount = 0;
  } else {
    // Slow case, write chunks one-by-one
    while (entry) {
      var chunk = entry.chunk;
      var encoding = entry.encoding;
      var cb = entry.callback;
      var len = state.objectMode ? 1 : chunk.length;
      doWrite(stream, state, false, len, chunk, encoding, cb);
      entry = entry.next;
      state.bufferedRequestCount--;
      // if we didn't call the onwrite immediately, then
      // it means that we need to wait until it does.
      // also, that means that the chunk and cb are currently
      // being processed, so move the buffer counter past them.
      if (state.writing) {
        break;
      }
    }
    if (entry === null) state.lastBufferedRequest = null;
  }
  state.bufferedRequest = entry;
  state.bufferProcessing = false;
}
Writable.prototype._write = function (chunk, encoding, cb) {
  cb(new Error('_write() is not implemented'));
};
Writable.prototype._writev = null;
Writable.prototype.end = function (chunk, encoding, cb) {
  var state = this._writableState;
  if (typeof chunk === 'function') {
    cb = chunk;
    chunk = null;
    encoding = null;
  } else if (typeof encoding === 'function') {
    cb = encoding;
    encoding = null;
  }
  if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);

  // .end() fully uncorks
  if (state.corked) {
    state.corked = 1;
    this.uncork();
  }

  // ignore unnecessary end() calls.
  if (!state.ending && !state.finished) endWritable(this, state, cb);
};
function needFinish(state) {
  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
}
function callFinal(stream, state) {
  stream._final(function (err) {
    state.pendingcb--;
    if (err) {
      stream.emit('error', err);
    }
    state.prefinished = true;
    stream.emit('prefinish');
    finishMaybe(stream, state);
  });
}
function prefinish(stream, state) {
  if (!state.prefinished && !state.finalCalled) {
    if (typeof stream._final === 'function') {
      state.pendingcb++;
      state.finalCalled = true;
      pna.nextTick(callFinal, stream, state);
    } else {
      state.prefinished = true;
      stream.emit('prefinish');
    }
  }
}
function finishMaybe(stream, state) {
  var need = needFinish(state);
  if (need) {
    prefinish(stream, state);
    if (state.pendingcb === 0) {
      state.finished = true;
      stream.emit('finish');
    }
  }
  return need;
}
function endWritable(stream, state, cb) {
  state.ending = true;
  finishMaybe(stream, state);
  if (cb) {
    if (state.finished) pna.nextTick(cb);else stream.once('finish', cb);
  }
  state.ended = true;
  stream.writable = false;
}
function onCorkedFinish(corkReq, state, err) {
  var entry = corkReq.entry;
  corkReq.entry = null;
  while (entry) {
    var cb = entry.callback;
    state.pendingcb--;
    cb(err);
    entry = entry.next;
  }
  if (state.corkedRequestsFree) {
    state.corkedRequestsFree.next = corkReq;
  } else {
    state.corkedRequestsFree = corkReq;
  }
}
Object.defineProperty(Writable.prototype, 'destroyed', {
  get: function () {
    if (this._writableState === undefined) {
      return false;
    }
    return this._writableState.destroyed;
  },
  set: function (value) {
    // we ignore the value if the stream
    // has not been initialized yet
    if (!this._writableState) {
      return;
    }

    // backward compatibility, the user is explicitly
    // managing destroyed
    this._writableState.destroyed = value;
  }
});
Writable.prototype.destroy = destroyImpl.destroy;
Writable.prototype._undestroy = destroyImpl.undestroy;
Writable.prototype._destroy = function (err, cb) {
  this.end();
  cb(err);
};

/***/ }),

/***/ 1651:
/*!******************************************************************************!*\
  !*** ../app/node_modules/readable-stream/lib/internal/streams/BufferList.js ***!
  \******************************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


function _classCallCheck(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}
var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
var util = __webpack_require__(/*! util */ 3837);
function copyBuffer(src, target, offset) {
  src.copy(target, offset);
}
module.exports = function () {
  function BufferList() {
    _classCallCheck(this, BufferList);
    this.head = null;
    this.tail = null;
    this.length = 0;
  }
  BufferList.prototype.push = function push(v) {
    var entry = {
      data: v,
      next: null
    };
    if (this.length > 0) this.tail.next = entry;else this.head = entry;
    this.tail = entry;
    ++this.length;
  };
  BufferList.prototype.unshift = function unshift(v) {
    var entry = {
      data: v,
      next: this.head
    };
    if (this.length === 0) this.tail = entry;
    this.head = entry;
    ++this.length;
  };
  BufferList.prototype.shift = function shift() {
    if (this.length === 0) return;
    var ret = this.head.data;
    if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;
    --this.length;
    return ret;
  };
  BufferList.prototype.clear = function clear() {
    this.head = this.tail = null;
    this.length = 0;
  };
  BufferList.prototype.join = function join(s) {
    if (this.length === 0) return '';
    var p = this.head;
    var ret = '' + p.data;
    while (p = p.next) {
      ret += s + p.data;
    }
    return ret;
  };
  BufferList.prototype.concat = function concat(n) {
    if (this.length === 0) return Buffer.alloc(0);
    if (this.length === 1) return this.head.data;
    var ret = Buffer.allocUnsafe(n >>> 0);
    var p = this.head;
    var i = 0;
    while (p) {
      copyBuffer(p.data, ret, i);
      i += p.data.length;
      p = p.next;
    }
    return ret;
  };
  return BufferList;
}();
if (util && util.inspect && util.inspect.custom) {
  module.exports.prototype[util.inspect.custom] = function () {
    var obj = util.inspect({
      length: this.length
    });
    return this.constructor.name + ' ' + obj;
  };
}

/***/ }),

/***/ 5456:
/*!***************************************************************************!*\
  !*** ../app/node_modules/readable-stream/lib/internal/streams/destroy.js ***!
  \***************************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


/*<replacement>*/
var pna = __webpack_require__(/*! process-nextick-args */ 7091);
/*</replacement>*/

// undocumented cb() API, needed for core, not for public API
function destroy(err, cb) {
  var _this = this;
  var readableDestroyed = this._readableState && this._readableState.destroyed;
  var writableDestroyed = this._writableState && this._writableState.destroyed;
  if (readableDestroyed || writableDestroyed) {
    if (cb) {
      cb(err);
    } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {
      pna.nextTick(emitErrorNT, this, err);
    }
    return this;
  }

  // we set destroyed to true before firing error callbacks in order
  // to make it re-entrance safe in case destroy() is called within callbacks

  if (this._readableState) {
    this._readableState.destroyed = true;
  }

  // if this is a duplex stream mark the writable part as destroyed as well
  if (this._writableState) {
    this._writableState.destroyed = true;
  }
  this._destroy(err || null, function (err) {
    if (!cb && err) {
      pna.nextTick(emitErrorNT, _this, err);
      if (_this._writableState) {
        _this._writableState.errorEmitted = true;
      }
    } else if (cb) {
      cb(err);
    }
  });
  return this;
}
function undestroy() {
  if (this._readableState) {
    this._readableState.destroyed = false;
    this._readableState.reading = false;
    this._readableState.ended = false;
    this._readableState.endEmitted = false;
  }
  if (this._writableState) {
    this._writableState.destroyed = false;
    this._writableState.ended = false;
    this._writableState.ending = false;
    this._writableState.finished = false;
    this._writableState.errorEmitted = false;
  }
}
function emitErrorNT(self, err) {
  self.emit('error', err);
}
module.exports = {
  destroy: destroy,
  undestroy: undestroy
};

/***/ }),

/***/ 7834:
/*!**************************************************************************!*\
  !*** ../app/node_modules/readable-stream/lib/internal/streams/stream.js ***!
  \**************************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

module.exports = __webpack_require__(/*! stream */ 3978);

/***/ }),

/***/ 5979:
/*!*******************************************************!*\
  !*** ../app/node_modules/readable-stream/readable.js ***!
  \*******************************************************/
/***/ ((module, exports, __webpack_require__) => {

var Stream = __webpack_require__(/*! stream */ 3978);
if (process.env.READABLE_STREAM === 'disable' && Stream) {
  module.exports = Stream;
  exports = module.exports = Stream.Readable;
  exports.Readable = Stream.Readable;
  exports.Writable = Stream.Writable;
  exports.Duplex = Stream.Duplex;
  exports.Transform = Stream.Transform;
  exports.PassThrough = Stream.PassThrough;
  exports.Stream = Stream;
} else {
  exports = module.exports = __webpack_require__(/*! ./lib/_stream_readable.js */ 1305);
  exports.Stream = Stream || exports;
  exports.Readable = exports;
  exports.Writable = __webpack_require__(/*! ./lib/_stream_writable.js */ 2813);
  exports.Duplex = __webpack_require__(/*! ./lib/_stream_duplex.js */ 7669);
  exports.Transform = __webpack_require__(/*! ./lib/_stream_transform.js */ 9065);
  exports.PassThrough = __webpack_require__(/*! ./lib/_stream_passthrough.js */ 1024);
}

/***/ }),

/***/ 6565:
/*!************************************************!*\
  !*** ../app/node_modules/safe-buffer/index.js ***!
  \************************************************/
/***/ ((module, exports, __webpack_require__) => {

/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
/* eslint-disable node/no-deprecated-api */
var buffer = __webpack_require__(/*! buffer */ 4300);
var Buffer = buffer.Buffer;

// alternative to using Object.keys for old browsers
function copyProps(src, dst) {
  for (var key in src) {
    dst[key] = src[key];
  }
}
if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
  module.exports = buffer;
} else {
  // Copy properties from require('buffer')
  copyProps(buffer, exports);
  exports.Buffer = SafeBuffer;
}
function SafeBuffer(arg, encodingOrOffset, length) {
  return Buffer(arg, encodingOrOffset, length);
}
SafeBuffer.prototype = Object.create(Buffer.prototype);

// Copy static methods from Buffer
copyProps(Buffer, SafeBuffer);
SafeBuffer.from = function (arg, encodingOrOffset, length) {
  if (typeof arg === 'number') {
    throw new TypeError('Argument must not be a number');
  }
  return Buffer(arg, encodingOrOffset, length);
};
SafeBuffer.alloc = function (size, fill, encoding) {
  if (typeof size !== 'number') {
    throw new TypeError('Argument must be a number');
  }
  var buf = Buffer(size);
  if (fill !== undefined) {
    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 Buffer(size);
};
SafeBuffer.allocUnsafeSlow = function (size) {
  if (typeof size !== 'number') {
    throw new TypeError('Argument must be a number');
  }
  return buffer.SlowBuffer(size);
};

/***/ }),

/***/ 7786:
/*!****************************************************************!*\
  !*** ../app/node_modules/string_decoder/lib/string_decoder.js ***!
  \****************************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.



/*<replacement>*/
var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
/*</replacement>*/

var isEncoding = Buffer.isEncoding || function (encoding) {
  encoding = '' + encoding;
  switch (encoding && encoding.toLowerCase()) {
    case 'hex':
    case 'utf8':
    case 'utf-8':
    case 'ascii':
    case 'binary':
    case 'base64':
    case 'ucs2':
    case 'ucs-2':
    case 'utf16le':
    case 'utf-16le':
    case 'raw':
      return true;
    default:
      return false;
  }
};
function _normalizeEncoding(enc) {
  if (!enc) return 'utf8';
  var retried;
  while (true) {
    switch (enc) {
      case 'utf8':
      case 'utf-8':
        return 'utf8';
      case 'ucs2':
      case 'ucs-2':
      case 'utf16le':
      case 'utf-16le':
        return 'utf16le';
      case 'latin1':
      case 'binary':
        return 'latin1';
      case 'base64':
      case 'ascii':
      case 'hex':
        return enc;
      default:
        if (retried) return; // undefined
        enc = ('' + enc).toLowerCase();
        retried = true;
    }
  }
}
;

// Do not cache `Buffer.isEncoding` when checking encoding names as some
// modules monkey-patch it to support additional encodings
function normalizeEncoding(enc) {
  var nenc = _normalizeEncoding(enc);
  if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);
  return nenc || enc;
}

// StringDecoder provides an interface for efficiently splitting a series of
// buffers into a series of JS strings without breaking apart multi-byte
// characters.
exports.s = StringDecoder;
function StringDecoder(encoding) {
  this.encoding = normalizeEncoding(encoding);
  var nb;
  switch (this.encoding) {
    case 'utf16le':
      this.text = utf16Text;
      this.end = utf16End;
      nb = 4;
      break;
    case 'utf8':
      this.fillLast = utf8FillLast;
      nb = 4;
      break;
    case 'base64':
      this.text = base64Text;
      this.end = base64End;
      nb = 3;
      break;
    default:
      this.write = simpleWrite;
      this.end = simpleEnd;
      return;
  }
  this.lastNeed = 0;
  this.lastTotal = 0;
  this.lastChar = Buffer.allocUnsafe(nb);
}
StringDecoder.prototype.write = function (buf) {
  if (buf.length === 0) return '';
  var r;
  var i;
  if (this.lastNeed) {
    r = this.fillLast(buf);
    if (r === undefined) return '';
    i = this.lastNeed;
    this.lastNeed = 0;
  } else {
    i = 0;
  }
  if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
  return r || '';
};
StringDecoder.prototype.end = utf8End;

// Returns only complete characters in a Buffer
StringDecoder.prototype.text = utf8Text;

// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer
StringDecoder.prototype.fillLast = function (buf) {
  if (this.lastNeed <= buf.length) {
    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
    return this.lastChar.toString(this.encoding, 0, this.lastTotal);
  }
  buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
  this.lastNeed -= buf.length;
};

// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a
// continuation byte. If an invalid byte is detected, -2 is returned.
function utf8CheckByte(byte) {
  if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;
  return byte >> 6 === 0x02 ? -1 : -2;
}

// Checks at most 3 bytes at the end of a Buffer in order to detect an
// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)
// needed to complete the UTF-8 character (if applicable) are returned.
function utf8CheckIncomplete(self, buf, i) {
  var j = buf.length - 1;
  if (j < i) return 0;
  var nb = utf8CheckByte(buf[j]);
  if (nb >= 0) {
    if (nb > 0) self.lastNeed = nb - 1;
    return nb;
  }
  if (--j < i || nb === -2) return 0;
  nb = utf8CheckByte(buf[j]);
  if (nb >= 0) {
    if (nb > 0) self.lastNeed = nb - 2;
    return nb;
  }
  if (--j < i || nb === -2) return 0;
  nb = utf8CheckByte(buf[j]);
  if (nb >= 0) {
    if (nb > 0) {
      if (nb === 2) nb = 0;else self.lastNeed = nb - 3;
    }
    return nb;
  }
  return 0;
}

// Validates as many continuation bytes for a multi-byte UTF-8 character as
// needed or are available. If we see a non-continuation byte where we expect
// one, we "replace" the validated continuation bytes we've seen so far with
// a single UTF-8 replacement character ('\ufffd'), to match v8's UTF-8 decoding
// behavior. The continuation byte check is included three times in the case
// where all of the continuation bytes for a character exist in the same buffer.
// It is also done this way as a slight performance increase instead of using a
// loop.
function utf8CheckExtraBytes(self, buf, p) {
  if ((buf[0] & 0xC0) !== 0x80) {
    self.lastNeed = 0;
    return '\ufffd';
  }
  if (self.lastNeed > 1 && buf.length > 1) {
    if ((buf[1] & 0xC0) !== 0x80) {
      self.lastNeed = 1;
      return '\ufffd';
    }
    if (self.lastNeed > 2 && buf.length > 2) {
      if ((buf[2] & 0xC0) !== 0x80) {
        self.lastNeed = 2;
        return '\ufffd';
      }
    }
  }
}

// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.
function utf8FillLast(buf) {
  var p = this.lastTotal - this.lastNeed;
  var r = utf8CheckExtraBytes(this, buf, p);
  if (r !== undefined) return r;
  if (this.lastNeed <= buf.length) {
    buf.copy(this.lastChar, p, 0, this.lastNeed);
    return this.lastChar.toString(this.encoding, 0, this.lastTotal);
  }
  buf.copy(this.lastChar, p, 0, buf.length);
  this.lastNeed -= buf.length;
}

// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a
// partial character, the character's bytes are buffered until the required
// number of bytes are available.
function utf8Text(buf, i) {
  var total = utf8CheckIncomplete(this, buf, i);
  if (!this.lastNeed) return buf.toString('utf8', i);
  this.lastTotal = total;
  var end = buf.length - (total - this.lastNeed);
  buf.copy(this.lastChar, 0, end);
  return buf.toString('utf8', i, end);
}

// For UTF-8, a replacement character is added when ending on a partial
// character.
function utf8End(buf) {
  var r = buf && buf.length ? this.write(buf) : '';
  if (this.lastNeed) return r + '\ufffd';
  return r;
}

// UTF-16LE typically needs two bytes per character, but even if we have an even
// number of bytes available, we need to check if we end on a leading/high
// surrogate. In that case, we need to wait for the next two bytes in order to
// decode the last character properly.
function utf16Text(buf, i) {
  if ((buf.length - i) % 2 === 0) {
    var r = buf.toString('utf16le', i);
    if (r) {
      var c = r.charCodeAt(r.length - 1);
      if (c >= 0xD800 && c <= 0xDBFF) {
        this.lastNeed = 2;
        this.lastTotal = 4;
        this.lastChar[0] = buf[buf.length - 2];
        this.lastChar[1] = buf[buf.length - 1];
        return r.slice(0, -1);
      }
    }
    return r;
  }
  this.lastNeed = 1;
  this.lastTotal = 2;
  this.lastChar[0] = buf[buf.length - 1];
  return buf.toString('utf16le', i, buf.length - 1);
}

// For UTF-16LE we do not explicitly append special replacement characters if we
// end on a partial character, we simply let v8 handle that.
function utf16End(buf) {
  var r = buf && buf.length ? this.write(buf) : '';
  if (this.lastNeed) {
    var end = this.lastTotal - this.lastNeed;
    return r + this.lastChar.toString('utf16le', 0, end);
  }
  return r;
}
function base64Text(buf, i) {
  var n = (buf.length - i) % 3;
  if (n === 0) return buf.toString('base64', i);
  this.lastNeed = 3 - n;
  this.lastTotal = 3;
  if (n === 1) {
    this.lastChar[0] = buf[buf.length - 1];
  } else {
    this.lastChar[0] = buf[buf.length - 2];
    this.lastChar[1] = buf[buf.length - 1];
  }
  return buf.toString('base64', i, buf.length - n);
}
function base64End(buf) {
  var r = buf && buf.length ? this.write(buf) : '';
  if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);
  return r;
}

// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)
function simpleWrite(buf) {
  return buf.toString(this.encoding);
}
function simpleEnd(buf) {
  return buf && buf.length ? this.write(buf) : '';
}

/***/ }),

/***/ 5547:
/*!************************************************!*\
  !*** ../app/node_modules/thenify-all/index.js ***!
  \************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var thenify = __webpack_require__(/*! thenify */ 1504);
module.exports = thenifyAll;
thenifyAll.withCallback = withCallback;
thenifyAll.thenify = thenify;

/**
 * Promisifies all the selected functions in an object.
 *
 * @param {Object} source the source object for the async functions
 * @param {Object} [destination] the destination to set all the promisified methods
 * @param {Array} [methods] an array of method names of `source`
 * @return {Object}
 * @api public
 */

function thenifyAll(source, destination, methods) {
  return promisifyAll(source, destination, methods, thenify);
}

/**
 * Promisifies all the selected functions in an object and backward compatible with callback.
 *
 * @param {Object} source the source object for the async functions
 * @param {Object} [destination] the destination to set all the promisified methods
 * @param {Array} [methods] an array of method names of `source`
 * @return {Object}
 * @api public
 */

function withCallback(source, destination, methods) {
  return promisifyAll(source, destination, methods, thenify.withCallback);
}
function promisifyAll(source, destination, methods, promisify) {
  if (!destination) {
    destination = {};
    methods = Object.keys(source);
  }
  if (Array.isArray(destination)) {
    methods = destination;
    destination = {};
  }
  if (!methods) {
    methods = Object.keys(source);
  }
  if (typeof source === 'function') destination = promisify(source);
  methods.forEach(function (name) {
    // promisify only if it's a function
    if (typeof source[name] === 'function') destination[name] = promisify(source[name]);
  });

  // proxy the rest
  Object.keys(source).forEach(function (name) {
    if (deprecated(source, name)) return;
    if (destination[name]) return;
    destination[name] = source[name];
  });
  return destination;
}
function deprecated(source, name) {
  var desc = Object.getOwnPropertyDescriptor(source, name);
  if (!desc || !desc.get) return false;
  if (desc.get.name === 'deprecated') return true;
  return false;
}

/***/ }),

/***/ 1504:
/*!********************************************!*\
  !*** ../app/node_modules/thenify/index.js ***!
  \********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var Promise = __webpack_require__(/*! any-promise */ 7154);
var assert = __webpack_require__(/*! assert */ 9491);
module.exports = thenify;

/**
 * Turn async functions into promises
 *
 * @param {Function} fn
 * @return {Function}
 * @api public
 */

function thenify(fn, options) {
  assert(typeof fn === 'function');
  return createWrapper(fn, options);
}

/**
 * Turn async functions into promises and backward compatible with callback
 *
 * @param {Function} fn
 * @return {Function}
 * @api public
 */

thenify.withCallback = function (fn, options) {
  assert(typeof fn === 'function');
  options = options || {};
  options.withCallback = true;
  return createWrapper(fn, options);
};
function createCallback(resolve, reject, multiArgs) {
  // default to true
  if (multiArgs === undefined) multiArgs = true;
  return function (err, value) {
    if (err) return reject(err);
    var length = arguments.length;
    if (length <= 2 || !multiArgs) return resolve(value);
    if (Array.isArray(multiArgs)) {
      var values = {};
      for (var i = 1; i < length; i++) values[multiArgs[i - 1]] = arguments[i];
      return resolve(values);
    }
    var values = new Array(length - 1);
    for (var i = 1; i < length; ++i) values[i - 1] = arguments[i];
    resolve(values);
  };
}
function createWrapper(fn, options) {
  options = options || {};
  var name = fn.name;
  name = (name || '').replace(/\s|bound(?!$)/g, '');
  var newFn = function () {
    var self = this;
    var len = arguments.length;
    if (options.withCallback) {
      var lastType = typeof arguments[len - 1];
      if (lastType === 'function') return fn.apply(self, arguments);
    }
    var args = new Array(len + 1);
    for (var i = 0; i < len; ++i) args[i] = arguments[i];
    var lastIndex = i;
    return new Promise(function (resolve, reject) {
      args[lastIndex] = createCallback(resolve, reject, options.multiArgs);
      fn.apply(self, args);
    });
  };
  Object.defineProperty(newFn, 'name', {
    value: name
  });
  return newFn;
}

/***/ }),

/***/ 4521:
/*!*****************************************************!*\
  !*** ../app/node_modules/util-deprecate/browser.js ***!
  \*****************************************************/
/***/ ((module) => {

/**
 * Module exports.
 */

module.exports = deprecate;

/**
 * Mark that a method should not be used.
 * Returns a modified function which warns once by default.
 *
 * If `localStorage.noDeprecation = true` is set, then it is a no-op.
 *
 * If `localStorage.throwDeprecation = true` is set, then deprecated functions
 * will throw an Error when invoked.
 *
 * If `localStorage.traceDeprecation = true` is set, then deprecated functions
 * will invoke `console.trace()` instead of `console.error()`.
 *
 * @param {Function} fn - the function to deprecate
 * @param {String} msg - the string to print to the console when `fn` is invoked
 * @returns {Function} a new "deprecated" version of `fn`
 * @api public
 */

function deprecate(fn, msg) {
  if (config('noDeprecation')) {
    return fn;
  }
  var warned = false;
  function deprecated() {
    if (!warned) {
      if (config('throwDeprecation')) {
        throw new Error(msg);
      } else if (config('traceDeprecation')) {
        console.trace(msg);
      } else {
        console.warn(msg);
      }
      warned = true;
    }
    return fn.apply(this, arguments);
  }
  return deprecated;
}

/**
 * Checks `localStorage` for boolean values for the given `name`.
 *
 * @param {String} name
 * @returns {Boolean}
 * @api private
 */

function config(name) {
  // accessing global.localStorage can trigger a DOMException in sandboxed iframes
  try {
    if (!global.localStorage) return false;
  } catch (_) {
    return false;
  }
  var val = global.localStorage[name];
  if (null == val) return false;
  return String(val).toLowerCase() === 'true';
}

/***/ }),

/***/ 4908:
/*!*******************************************!*\
  !*** ../node_modules/asn1.js/lib/asn1.js ***!
  \*******************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


const asn1 = exports;
asn1.bignum = __webpack_require__(/*! bn.js */ 1046);
asn1.define = (__webpack_require__(/*! ./asn1/api */ 6888).define);
asn1.base = __webpack_require__(/*! ./asn1/base */ 1868);
asn1.constants = __webpack_require__(/*! ./asn1/constants */ 4931);
asn1.decoders = __webpack_require__(/*! ./asn1/decoders */ 3173);
asn1.encoders = __webpack_require__(/*! ./asn1/encoders */ 5696);

/***/ }),

/***/ 6888:
/*!***********************************************!*\
  !*** ../node_modules/asn1.js/lib/asn1/api.js ***!
  \***********************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


const encoders = __webpack_require__(/*! ./encoders */ 5696);
const decoders = __webpack_require__(/*! ./decoders */ 3173);
const inherits = __webpack_require__(/*! inherits */ 7694);
const api = exports;
api.define = function define(name, body) {
  return new Entity(name, body);
};
function Entity(name, body) {
  this.name = name;
  this.body = body;
  this.decoders = {};
  this.encoders = {};
}
Entity.prototype._createNamed = function createNamed(Base) {
  const name = this.name;
  function Generated(entity) {
    this._initNamed(entity, name);
  }
  inherits(Generated, Base);
  Generated.prototype._initNamed = function _initNamed(entity, name) {
    Base.call(this, entity, name);
  };
  return new Generated(this);
};
Entity.prototype._getDecoder = function _getDecoder(enc) {
  enc = enc || 'der';
  // Lazily create decoder
  if (!this.decoders.hasOwnProperty(enc)) this.decoders[enc] = this._createNamed(decoders[enc]);
  return this.decoders[enc];
};
Entity.prototype.decode = function decode(data, enc, options) {
  return this._getDecoder(enc).decode(data, options);
};
Entity.prototype._getEncoder = function _getEncoder(enc) {
  enc = enc || 'der';
  // Lazily create encoder
  if (!this.encoders.hasOwnProperty(enc)) this.encoders[enc] = this._createNamed(encoders[enc]);
  return this.encoders[enc];
};
Entity.prototype.encode = function encode(data, enc, /* internal */reporter) {
  return this._getEncoder(enc).encode(data, reporter);
};

/***/ }),

/***/ 2848:
/*!*******************************************************!*\
  !*** ../node_modules/asn1.js/lib/asn1/base/buffer.js ***!
  \*******************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


const inherits = __webpack_require__(/*! inherits */ 7694);
const Reporter = (__webpack_require__(/*! ../base/reporter */ 7158)/* .Reporter */ .b);
const Buffer = (__webpack_require__(/*! safer-buffer */ 3745).Buffer);
function DecoderBuffer(base, options) {
  Reporter.call(this, options);
  if (!Buffer.isBuffer(base)) {
    this.error('Input not Buffer');
    return;
  }
  this.base = base;
  this.offset = 0;
  this.length = base.length;
}
inherits(DecoderBuffer, Reporter);
exports.C = DecoderBuffer;
DecoderBuffer.isDecoderBuffer = function isDecoderBuffer(data) {
  if (data instanceof DecoderBuffer) {
    return true;
  }

  // Or accept compatible API
  const isCompatible = typeof data === 'object' && Buffer.isBuffer(data.base) && data.constructor.name === 'DecoderBuffer' && typeof data.offset === 'number' && typeof data.length === 'number' && typeof data.save === 'function' && typeof data.restore === 'function' && typeof data.isEmpty === 'function' && typeof data.readUInt8 === 'function' && typeof data.skip === 'function' && typeof data.raw === 'function';
  return isCompatible;
};
DecoderBuffer.prototype.save = function save() {
  return {
    offset: this.offset,
    reporter: Reporter.prototype.save.call(this)
  };
};
DecoderBuffer.prototype.restore = function restore(save) {
  // Return skipped data
  const res = new DecoderBuffer(this.base);
  res.offset = save.offset;
  res.length = this.offset;
  this.offset = save.offset;
  Reporter.prototype.restore.call(this, save.reporter);
  return res;
};
DecoderBuffer.prototype.isEmpty = function isEmpty() {
  return this.offset === this.length;
};
DecoderBuffer.prototype.readUInt8 = function readUInt8(fail) {
  if (this.offset + 1 <= this.length) return this.base.readUInt8(this.offset++, true);else return this.error(fail || 'DecoderBuffer overrun');
};
DecoderBuffer.prototype.skip = function skip(bytes, fail) {
  if (!(this.offset + bytes <= this.length)) return this.error(fail || 'DecoderBuffer overrun');
  const res = new DecoderBuffer(this.base);

  // Share reporter state
  res._reporterState = this._reporterState;
  res.offset = this.offset;
  res.length = this.offset + bytes;
  this.offset += bytes;
  return res;
};
DecoderBuffer.prototype.raw = function raw(save) {
  return this.base.slice(save ? save.offset : this.offset, this.length);
};
function EncoderBuffer(value, reporter) {
  if (Array.isArray(value)) {
    this.length = 0;
    this.value = value.map(function (item) {
      if (!EncoderBuffer.isEncoderBuffer(item)) item = new EncoderBuffer(item, reporter);
      this.length += item.length;
      return item;
    }, this);
  } else if (typeof value === 'number') {
    if (!(0 <= value && value <= 0xff)) return reporter.error('non-byte EncoderBuffer value');
    this.value = value;
    this.length = 1;
  } else if (typeof value === 'string') {
    this.value = value;
    this.length = Buffer.byteLength(value);
  } else if (Buffer.isBuffer(value)) {
    this.value = value;
    this.length = value.length;
  } else {
    return reporter.error('Unsupported type: ' + typeof value);
  }
}
exports.R = EncoderBuffer;
EncoderBuffer.isEncoderBuffer = function isEncoderBuffer(data) {
  if (data instanceof EncoderBuffer) {
    return true;
  }

  // Or accept compatible API
  const isCompatible = typeof data === 'object' && data.constructor.name === 'EncoderBuffer' && typeof data.length === 'number' && typeof data.join === 'function';
  return isCompatible;
};
EncoderBuffer.prototype.join = function join(out, offset) {
  if (!out) out = Buffer.alloc(this.length);
  if (!offset) offset = 0;
  if (this.length === 0) return out;
  if (Array.isArray(this.value)) {
    this.value.forEach(function (item) {
      item.join(out, offset);
      offset += item.length;
    });
  } else {
    if (typeof this.value === 'number') out[offset] = this.value;else if (typeof this.value === 'string') out.write(this.value, offset);else if (Buffer.isBuffer(this.value)) this.value.copy(out, offset);
    offset += this.length;
  }
  return out;
};

/***/ }),

/***/ 1868:
/*!******************************************************!*\
  !*** ../node_modules/asn1.js/lib/asn1/base/index.js ***!
  \******************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


const base = exports;
base.Reporter = (__webpack_require__(/*! ./reporter */ 7158)/* .Reporter */ .b);
base.DecoderBuffer = (__webpack_require__(/*! ./buffer */ 2848)/* .DecoderBuffer */ .C);
base.EncoderBuffer = (__webpack_require__(/*! ./buffer */ 2848)/* .EncoderBuffer */ .R);
base.Node = __webpack_require__(/*! ./node */ 8324);

/***/ }),

/***/ 8324:
/*!*****************************************************!*\
  !*** ../node_modules/asn1.js/lib/asn1/base/node.js ***!
  \*****************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


const Reporter = (__webpack_require__(/*! ../base/reporter */ 7158)/* .Reporter */ .b);
const EncoderBuffer = (__webpack_require__(/*! ../base/buffer */ 2848)/* .EncoderBuffer */ .R);
const DecoderBuffer = (__webpack_require__(/*! ../base/buffer */ 2848)/* .DecoderBuffer */ .C);
const assert = __webpack_require__(/*! minimalistic-assert */ 5305);

// Supported tags
const tags = ['seq', 'seqof', 'set', 'setof', 'objid', 'bool', 'gentime', 'utctime', 'null_', 'enum', 'int', 'objDesc', 'bitstr', 'bmpstr', 'charstr', 'genstr', 'graphstr', 'ia5str', 'iso646str', 'numstr', 'octstr', 'printstr', 't61str', 'unistr', 'utf8str', 'videostr'];

// Public methods list
const methods = ['key', 'obj', 'use', 'optional', 'explicit', 'implicit', 'def', 'choice', 'any', 'contains'].concat(tags);

// Overrided methods list
const overrided = ['_peekTag', '_decodeTag', '_use', '_decodeStr', '_decodeObjid', '_decodeTime', '_decodeNull', '_decodeInt', '_decodeBool', '_decodeList', '_encodeComposite', '_encodeStr', '_encodeObjid', '_encodeTime', '_encodeNull', '_encodeInt', '_encodeBool'];
function Node(enc, parent, name) {
  const state = {};
  this._baseState = state;
  state.name = name;
  state.enc = enc;
  state.parent = parent || null;
  state.children = null;

  // State
  state.tag = null;
  state.args = null;
  state.reverseArgs = null;
  state.choice = null;
  state.optional = false;
  state.any = false;
  state.obj = false;
  state.use = null;
  state.useDecoder = null;
  state.key = null;
  state['default'] = null;
  state.explicit = null;
  state.implicit = null;
  state.contains = null;

  // Should create new instance on each method
  if (!state.parent) {
    state.children = [];
    this._wrap();
  }
}
module.exports = Node;
const stateProps = ['enc', 'parent', 'children', 'tag', 'args', 'reverseArgs', 'choice', 'optional', 'any', 'obj', 'use', 'alteredUse', 'key', 'default', 'explicit', 'implicit', 'contains'];
Node.prototype.clone = function clone() {
  const state = this._baseState;
  const cstate = {};
  stateProps.forEach(function (prop) {
    cstate[prop] = state[prop];
  });
  const res = new this.constructor(cstate.parent);
  res._baseState = cstate;
  return res;
};
Node.prototype._wrap = function wrap() {
  const state = this._baseState;
  methods.forEach(function (method) {
    this[method] = function _wrappedMethod() {
      const clone = new this.constructor(this);
      state.children.push(clone);
      return clone[method].apply(clone, arguments);
    };
  }, this);
};
Node.prototype._init = function init(body) {
  const state = this._baseState;
  assert(state.parent === null);
  body.call(this);

  // Filter children
  state.children = state.children.filter(function (child) {
    return child._baseState.parent === this;
  }, this);
  assert.equal(state.children.length, 1, 'Root node can have only one child');
};
Node.prototype._useArgs = function useArgs(args) {
  const state = this._baseState;

  // Filter children and args
  const children = args.filter(function (arg) {
    return arg instanceof this.constructor;
  }, this);
  args = args.filter(function (arg) {
    return !(arg instanceof this.constructor);
  }, this);
  if (children.length !== 0) {
    assert(state.children === null);
    state.children = children;

    // Replace parent to maintain backward link
    children.forEach(function (child) {
      child._baseState.parent = this;
    }, this);
  }
  if (args.length !== 0) {
    assert(state.args === null);
    state.args = args;
    state.reverseArgs = args.map(function (arg) {
      if (typeof arg !== 'object' || arg.constructor !== Object) return arg;
      const res = {};
      Object.keys(arg).forEach(function (key) {
        if (key == (key | 0)) key |= 0;
        const value = arg[key];
        res[value] = key;
      });
      return res;
    });
  }
};

//
// Overrided methods
//

overrided.forEach(function (method) {
  Node.prototype[method] = function _overrided() {
    const state = this._baseState;
    throw new Error(method + ' not implemented for encoding: ' + state.enc);
  };
});

//
// Public methods
//

tags.forEach(function (tag) {
  Node.prototype[tag] = function _tagMethod() {
    const state = this._baseState;
    const args = Array.prototype.slice.call(arguments);
    assert(state.tag === null);
    state.tag = tag;
    this._useArgs(args);
    return this;
  };
});
Node.prototype.use = function use(item) {
  assert(item);
  const state = this._baseState;
  assert(state.use === null);
  state.use = item;
  return this;
};
Node.prototype.optional = function optional() {
  const state = this._baseState;
  state.optional = true;
  return this;
};
Node.prototype.def = function def(val) {
  const state = this._baseState;
  assert(state['default'] === null);
  state['default'] = val;
  state.optional = true;
  return this;
};
Node.prototype.explicit = function explicit(num) {
  const state = this._baseState;
  assert(state.explicit === null && state.implicit === null);
  state.explicit = num;
  return this;
};
Node.prototype.implicit = function implicit(num) {
  const state = this._baseState;
  assert(state.explicit === null && state.implicit === null);
  state.implicit = num;
  return this;
};
Node.prototype.obj = function obj() {
  const state = this._baseState;
  const args = Array.prototype.slice.call(arguments);
  state.obj = true;
  if (args.length !== 0) this._useArgs(args);
  return this;
};
Node.prototype.key = function key(newKey) {
  const state = this._baseState;
  assert(state.key === null);
  state.key = newKey;
  return this;
};
Node.prototype.any = function any() {
  const state = this._baseState;
  state.any = true;
  return this;
};
Node.prototype.choice = function choice(obj) {
  const state = this._baseState;
  assert(state.choice === null);
  state.choice = obj;
  this._useArgs(Object.keys(obj).map(function (key) {
    return obj[key];
  }));
  return this;
};
Node.prototype.contains = function contains(item) {
  const state = this._baseState;
  assert(state.use === null);
  state.contains = item;
  return this;
};

//
// Decoding
//

Node.prototype._decode = function decode(input, options) {
  const state = this._baseState;

  // Decode root node
  if (state.parent === null) return input.wrapResult(state.children[0]._decode(input, options));
  let result = state['default'];
  let present = true;
  let prevKey = null;
  if (state.key !== null) prevKey = input.enterKey(state.key);

  // Check if tag is there
  if (state.optional) {
    let tag = null;
    if (state.explicit !== null) tag = state.explicit;else if (state.implicit !== null) tag = state.implicit;else if (state.tag !== null) tag = state.tag;
    if (tag === null && !state.any) {
      // Trial and Error
      const save = input.save();
      try {
        if (state.choice === null) this._decodeGeneric(state.tag, input, options);else this._decodeChoice(input, options);
        present = true;
      } catch (e) {
        present = false;
      }
      input.restore(save);
    } else {
      present = this._peekTag(input, tag, state.any);
      if (input.isError(present)) return present;
    }
  }

  // Push object on stack
  let prevObj;
  if (state.obj && present) prevObj = input.enterObject();
  if (present) {
    // Unwrap explicit values
    if (state.explicit !== null) {
      const explicit = this._decodeTag(input, state.explicit);
      if (input.isError(explicit)) return explicit;
      input = explicit;
    }
    const start = input.offset;

    // Unwrap implicit and normal values
    if (state.use === null && state.choice === null) {
      let save;
      if (state.any) save = input.save();
      const body = this._decodeTag(input, state.implicit !== null ? state.implicit : state.tag, state.any);
      if (input.isError(body)) return body;
      if (state.any) result = input.raw(save);else input = body;
    }
    if (options && options.track && state.tag !== null) options.track(input.path(), start, input.length, 'tagged');
    if (options && options.track && state.tag !== null) options.track(input.path(), input.offset, input.length, 'content');

    // Select proper method for tag
    if (state.any) {
      // no-op
    } else if (state.choice === null) {
      result = this._decodeGeneric(state.tag, input, options);
    } else {
      result = this._decodeChoice(input, options);
    }
    if (input.isError(result)) return result;

    // Decode children
    if (!state.any && state.choice === null && state.children !== null) {
      state.children.forEach(function decodeChildren(child) {
        // NOTE: We are ignoring errors here, to let parser continue with other
        // parts of encoded data
        child._decode(input, options);
      });
    }

    // Decode contained/encoded by schema, only in bit or octet strings
    if (state.contains && (state.tag === 'octstr' || state.tag === 'bitstr')) {
      const data = new DecoderBuffer(result);
      result = this._getUse(state.contains, input._reporterState.obj)._decode(data, options);
    }
  }

  // Pop object
  if (state.obj && present) result = input.leaveObject(prevObj);

  // Set key
  if (state.key !== null && (result !== null || present === true)) input.leaveKey(prevKey, state.key, result);else if (prevKey !== null) input.exitKey(prevKey);
  return result;
};
Node.prototype._decodeGeneric = function decodeGeneric(tag, input, options) {
  const state = this._baseState;
  if (tag === 'seq' || tag === 'set') return null;
  if (tag === 'seqof' || tag === 'setof') return this._decodeList(input, tag, state.args[0], options);else if (/str$/.test(tag)) return this._decodeStr(input, tag, options);else if (tag === 'objid' && state.args) return this._decodeObjid(input, state.args[0], state.args[1], options);else if (tag === 'objid') return this._decodeObjid(input, null, null, options);else if (tag === 'gentime' || tag === 'utctime') return this._decodeTime(input, tag, options);else if (tag === 'null_') return this._decodeNull(input, options);else if (tag === 'bool') return this._decodeBool(input, options);else if (tag === 'objDesc') return this._decodeStr(input, tag, options);else if (tag === 'int' || tag === 'enum') return this._decodeInt(input, state.args && state.args[0], options);
  if (state.use !== null) {
    return this._getUse(state.use, input._reporterState.obj)._decode(input, options);
  } else {
    return input.error('unknown tag: ' + tag);
  }
};
Node.prototype._getUse = function _getUse(entity, obj) {
  const state = this._baseState;
  // Create altered use decoder if implicit is set
  state.useDecoder = this._use(entity, obj);
  assert(state.useDecoder._baseState.parent === null);
  state.useDecoder = state.useDecoder._baseState.children[0];
  if (state.implicit !== state.useDecoder._baseState.implicit) {
    state.useDecoder = state.useDecoder.clone();
    state.useDecoder._baseState.implicit = state.implicit;
  }
  return state.useDecoder;
};
Node.prototype._decodeChoice = function decodeChoice(input, options) {
  const state = this._baseState;
  let result = null;
  let match = false;
  Object.keys(state.choice).some(function (key) {
    const save = input.save();
    const node = state.choice[key];
    try {
      const value = node._decode(input, options);
      if (input.isError(value)) return false;
      result = {
        type: key,
        value: value
      };
      match = true;
    } catch (e) {
      input.restore(save);
      return false;
    }
    return true;
  }, this);
  if (!match) return input.error('Choice not matched');
  return result;
};

//
// Encoding
//

Node.prototype._createEncoderBuffer = function createEncoderBuffer(data) {
  return new EncoderBuffer(data, this.reporter);
};
Node.prototype._encode = function encode(data, reporter, parent) {
  const state = this._baseState;
  if (state['default'] !== null && state['default'] === data) return;
  const result = this._encodeValue(data, reporter, parent);
  if (result === undefined) return;
  if (this._skipDefault(result, reporter, parent)) return;
  return result;
};
Node.prototype._encodeValue = function encode(data, reporter, parent) {
  const state = this._baseState;

  // Decode root node
  if (state.parent === null) return state.children[0]._encode(data, reporter || new Reporter());
  let result = null;

  // Set reporter to share it with a child class
  this.reporter = reporter;

  // Check if data is there
  if (state.optional && data === undefined) {
    if (state['default'] !== null) data = state['default'];else return;
  }

  // Encode children first
  let content = null;
  let primitive = false;
  if (state.any) {
    // Anything that was given is translated to buffer
    result = this._createEncoderBuffer(data);
  } else if (state.choice) {
    result = this._encodeChoice(data, reporter);
  } else if (state.contains) {
    content = this._getUse(state.contains, parent)._encode(data, reporter);
    primitive = true;
  } else if (state.children) {
    content = state.children.map(function (child) {
      if (child._baseState.tag === 'null_') return child._encode(null, reporter, data);
      if (child._baseState.key === null) return reporter.error('Child should have a key');
      const prevKey = reporter.enterKey(child._baseState.key);
      if (typeof data !== 'object') return reporter.error('Child expected, but input is not object');
      const res = child._encode(data[child._baseState.key], reporter, data);
      reporter.leaveKey(prevKey);
      return res;
    }, this).filter(function (child) {
      return child;
    });
    content = this._createEncoderBuffer(content);
  } else {
    if (state.tag === 'seqof' || state.tag === 'setof') {
      // TODO(indutny): this should be thrown on DSL level
      if (!(state.args && state.args.length === 1)) return reporter.error('Too many args for : ' + state.tag);
      if (!Array.isArray(data)) return reporter.error('seqof/setof, but data is not Array');
      const child = this.clone();
      child._baseState.implicit = null;
      content = this._createEncoderBuffer(data.map(function (item) {
        const state = this._baseState;
        return this._getUse(state.args[0], data)._encode(item, reporter);
      }, child));
    } else if (state.use !== null) {
      result = this._getUse(state.use, parent)._encode(data, reporter);
    } else {
      content = this._encodePrimitive(state.tag, data);
      primitive = true;
    }
  }

  // Encode data itself
  if (!state.any && state.choice === null) {
    const tag = state.implicit !== null ? state.implicit : state.tag;
    const cls = state.implicit === null ? 'universal' : 'context';
    if (tag === null) {
      if (state.use === null) reporter.error('Tag could be omitted only for .use()');
    } else {
      if (state.use === null) result = this._encodeComposite(tag, primitive, cls, content);
    }
  }

  // Wrap in explicit
  if (state.explicit !== null) result = this._encodeComposite(state.explicit, false, 'context', result);
  return result;
};
Node.prototype._encodeChoice = function encodeChoice(data, reporter) {
  const state = this._baseState;
  const node = state.choice[data.type];
  if (!node) {
    assert(false, data.type + ' not found in ' + JSON.stringify(Object.keys(state.choice)));
  }
  return node._encode(data.value, reporter);
};
Node.prototype._encodePrimitive = function encodePrimitive(tag, data) {
  const state = this._baseState;
  if (/str$/.test(tag)) return this._encodeStr(data, tag);else if (tag === 'objid' && state.args) return this._encodeObjid(data, state.reverseArgs[0], state.args[1]);else if (tag === 'objid') return this._encodeObjid(data, null, null);else if (tag === 'gentime' || tag === 'utctime') return this._encodeTime(data, tag);else if (tag === 'null_') return this._encodeNull();else if (tag === 'int' || tag === 'enum') return this._encodeInt(data, state.args && state.reverseArgs[0]);else if (tag === 'bool') return this._encodeBool(data);else if (tag === 'objDesc') return this._encodeStr(data, tag);else throw new Error('Unsupported tag: ' + tag);
};
Node.prototype._isNumstr = function isNumstr(str) {
  return /^[0-9 ]*$/.test(str);
};
Node.prototype._isPrintstr = function isPrintstr(str) {
  return /^[A-Za-z0-9 '()+,-./:=?]*$/.test(str);
};

/***/ }),

/***/ 7158:
/*!*********************************************************!*\
  !*** ../node_modules/asn1.js/lib/asn1/base/reporter.js ***!
  \*********************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


const inherits = __webpack_require__(/*! inherits */ 7694);
function Reporter(options) {
  this._reporterState = {
    obj: null,
    path: [],
    options: options || {},
    errors: []
  };
}
exports.b = Reporter;
Reporter.prototype.isError = function isError(obj) {
  return obj instanceof ReporterError;
};
Reporter.prototype.save = function save() {
  const state = this._reporterState;
  return {
    obj: state.obj,
    pathLen: state.path.length
  };
};
Reporter.prototype.restore = function restore(data) {
  const state = this._reporterState;
  state.obj = data.obj;
  state.path = state.path.slice(0, data.pathLen);
};
Reporter.prototype.enterKey = function enterKey(key) {
  return this._reporterState.path.push(key);
};
Reporter.prototype.exitKey = function exitKey(index) {
  const state = this._reporterState;
  state.path = state.path.slice(0, index - 1);
};
Reporter.prototype.leaveKey = function leaveKey(index, key, value) {
  const state = this._reporterState;
  this.exitKey(index);
  if (state.obj !== null) state.obj[key] = value;
};
Reporter.prototype.path = function path() {
  return this._reporterState.path.join('/');
};
Reporter.prototype.enterObject = function enterObject() {
  const state = this._reporterState;
  const prev = state.obj;
  state.obj = {};
  return prev;
};
Reporter.prototype.leaveObject = function leaveObject(prev) {
  const state = this._reporterState;
  const now = state.obj;
  state.obj = prev;
  return now;
};
Reporter.prototype.error = function error(msg) {
  let err;
  const state = this._reporterState;
  const inherited = msg instanceof ReporterError;
  if (inherited) {
    err = msg;
  } else {
    err = new ReporterError(state.path.map(function (elem) {
      return '[' + JSON.stringify(elem) + ']';
    }).join(''), msg.message || msg, msg.stack);
  }
  if (!state.options.partial) throw err;
  if (!inherited) state.errors.push(err);
  return err;
};
Reporter.prototype.wrapResult = function wrapResult(result) {
  const state = this._reporterState;
  if (!state.options.partial) return result;
  return {
    result: this.isError(result) ? null : result,
    errors: state.errors
  };
};
function ReporterError(path, msg) {
  this.path = path;
  this.rethrow(msg);
}
inherits(ReporterError, Error);
ReporterError.prototype.rethrow = function rethrow(msg) {
  this.message = msg + ' at: ' + (this.path || '(shallow)');
  if (Error.captureStackTrace) Error.captureStackTrace(this, ReporterError);
  if (!this.stack) {
    try {
      // IE only adds stack when thrown
      throw new Error(this.message);
    } catch (e) {
      this.stack = e.stack;
    }
  }
  return this;
};

/***/ }),

/***/ 4885:
/*!*********************************************************!*\
  !*** ../node_modules/asn1.js/lib/asn1/constants/der.js ***!
  \*********************************************************/
/***/ ((__unused_webpack_module, exports) => {

"use strict";


// Helper
function reverse(map) {
  const res = {};
  Object.keys(map).forEach(function (key) {
    // Convert key to integer if it is stringified
    if ((key | 0) == key) key = key | 0;
    const value = map[key];
    res[value] = key;
  });
  return res;
}
exports.tagClass = {
  0: 'universal',
  1: 'application',
  2: 'context',
  3: 'private'
};
exports.tagClassByName = reverse(exports.tagClass);
exports.tag = {
  0x00: 'end',
  0x01: 'bool',
  0x02: 'int',
  0x03: 'bitstr',
  0x04: 'octstr',
  0x05: 'null_',
  0x06: 'objid',
  0x07: 'objDesc',
  0x08: 'external',
  0x09: 'real',
  0x0a: 'enum',
  0x0b: 'embed',
  0x0c: 'utf8str',
  0x0d: 'relativeOid',
  0x10: 'seq',
  0x11: 'set',
  0x12: 'numstr',
  0x13: 'printstr',
  0x14: 't61str',
  0x15: 'videostr',
  0x16: 'ia5str',
  0x17: 'utctime',
  0x18: 'gentime',
  0x19: 'graphstr',
  0x1a: 'iso646str',
  0x1b: 'genstr',
  0x1c: 'unistr',
  0x1d: 'charstr',
  0x1e: 'bmpstr'
};
exports.tagByName = reverse(exports.tag);

/***/ }),

/***/ 4931:
/*!***********************************************************!*\
  !*** ../node_modules/asn1.js/lib/asn1/constants/index.js ***!
  \***********************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


const constants = exports;

// Helper
constants._reverse = function reverse(map) {
  const res = {};
  Object.keys(map).forEach(function (key) {
    // Convert key to integer if it is stringified
    if ((key | 0) == key) key = key | 0;
    const value = map[key];
    res[value] = key;
  });
  return res;
};
constants.der = __webpack_require__(/*! ./der */ 4885);

/***/ }),

/***/ 1827:
/*!********************************************************!*\
  !*** ../node_modules/asn1.js/lib/asn1/decoders/der.js ***!
  \********************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


const inherits = __webpack_require__(/*! inherits */ 7694);
const bignum = __webpack_require__(/*! bn.js */ 1046);
const DecoderBuffer = (__webpack_require__(/*! ../base/buffer */ 2848)/* .DecoderBuffer */ .C);
const Node = __webpack_require__(/*! ../base/node */ 8324);

// Import DER constants
const der = __webpack_require__(/*! ../constants/der */ 4885);
function DERDecoder(entity) {
  this.enc = 'der';
  this.name = entity.name;
  this.entity = entity;

  // Construct base tree
  this.tree = new DERNode();
  this.tree._init(entity.body);
}
module.exports = DERDecoder;
DERDecoder.prototype.decode = function decode(data, options) {
  if (!DecoderBuffer.isDecoderBuffer(data)) {
    data = new DecoderBuffer(data, options);
  }
  return this.tree._decode(data, options);
};

// Tree methods

function DERNode(parent) {
  Node.call(this, 'der', parent);
}
inherits(DERNode, Node);
DERNode.prototype._peekTag = function peekTag(buffer, tag, any) {
  if (buffer.isEmpty()) return false;
  const state = buffer.save();
  const decodedTag = derDecodeTag(buffer, 'Failed to peek tag: "' + tag + '"');
  if (buffer.isError(decodedTag)) return decodedTag;
  buffer.restore(state);
  return decodedTag.tag === tag || decodedTag.tagStr === tag || decodedTag.tagStr + 'of' === tag || any;
};
DERNode.prototype._decodeTag = function decodeTag(buffer, tag, any) {
  const decodedTag = derDecodeTag(buffer, 'Failed to decode tag of "' + tag + '"');
  if (buffer.isError(decodedTag)) return decodedTag;
  let len = derDecodeLen(buffer, decodedTag.primitive, 'Failed to get length of "' + tag + '"');

  // Failure
  if (buffer.isError(len)) return len;
  if (!any && decodedTag.tag !== tag && decodedTag.tagStr !== tag && decodedTag.tagStr + 'of' !== tag) {
    return buffer.error('Failed to match tag: "' + tag + '"');
  }
  if (decodedTag.primitive || len !== null) return buffer.skip(len, 'Failed to match body of: "' + tag + '"');

  // Indefinite length... find END tag
  const state = buffer.save();
  const res = this._skipUntilEnd(buffer, 'Failed to skip indefinite length body: "' + this.tag + '"');
  if (buffer.isError(res)) return res;
  len = buffer.offset - state.offset;
  buffer.restore(state);
  return buffer.skip(len, 'Failed to match body of: "' + tag + '"');
};
DERNode.prototype._skipUntilEnd = function skipUntilEnd(buffer, fail) {
  for (;;) {
    const tag = derDecodeTag(buffer, fail);
    if (buffer.isError(tag)) return tag;
    const len = derDecodeLen(buffer, tag.primitive, fail);
    if (buffer.isError(len)) return len;
    let res;
    if (tag.primitive || len !== null) res = buffer.skip(len);else res = this._skipUntilEnd(buffer, fail);

    // Failure
    if (buffer.isError(res)) return res;
    if (tag.tagStr === 'end') break;
  }
};
DERNode.prototype._decodeList = function decodeList(buffer, tag, decoder, options) {
  const result = [];
  while (!buffer.isEmpty()) {
    const possibleEnd = this._peekTag(buffer, 'end');
    if (buffer.isError(possibleEnd)) return possibleEnd;
    const res = decoder.decode(buffer, 'der', options);
    if (buffer.isError(res) && possibleEnd) break;
    result.push(res);
  }
  return result;
};
DERNode.prototype._decodeStr = function decodeStr(buffer, tag) {
  if (tag === 'bitstr') {
    const unused = buffer.readUInt8();
    if (buffer.isError(unused)) return unused;
    return {
      unused: unused,
      data: buffer.raw()
    };
  } else if (tag === 'bmpstr') {
    const raw = buffer.raw();
    if (raw.length % 2 === 1) return buffer.error('Decoding of string type: bmpstr length mismatch');
    let str = '';
    for (let i = 0; i < raw.length / 2; i++) {
      str += String.fromCharCode(raw.readUInt16BE(i * 2));
    }
    return str;
  } else if (tag === 'numstr') {
    const numstr = buffer.raw().toString('ascii');
    if (!this._isNumstr(numstr)) {
      return buffer.error('Decoding of string type: ' + 'numstr unsupported characters');
    }
    return numstr;
  } else if (tag === 'octstr') {
    return buffer.raw();
  } else if (tag === 'objDesc') {
    return buffer.raw();
  } else if (tag === 'printstr') {
    const printstr = buffer.raw().toString('ascii');
    if (!this._isPrintstr(printstr)) {
      return buffer.error('Decoding of string type: ' + 'printstr unsupported characters');
    }
    return printstr;
  } else if (/str$/.test(tag)) {
    return buffer.raw().toString();
  } else {
    return buffer.error('Decoding of string type: ' + tag + ' unsupported');
  }
};
DERNode.prototype._decodeObjid = function decodeObjid(buffer, values, relative) {
  let result;
  const identifiers = [];
  let ident = 0;
  let subident = 0;
  while (!buffer.isEmpty()) {
    subident = buffer.readUInt8();
    ident <<= 7;
    ident |= subident & 0x7f;
    if ((subident & 0x80) === 0) {
      identifiers.push(ident);
      ident = 0;
    }
  }
  if (subident & 0x80) identifiers.push(ident);
  const first = identifiers[0] / 40 | 0;
  const second = identifiers[0] % 40;
  if (relative) result = identifiers;else result = [first, second].concat(identifiers.slice(1));
  if (values) {
    let tmp = values[result.join(' ')];
    if (tmp === undefined) tmp = values[result.join('.')];
    if (tmp !== undefined) result = tmp;
  }
  return result;
};
DERNode.prototype._decodeTime = function decodeTime(buffer, tag) {
  const str = buffer.raw().toString();
  let year;
  let mon;
  let day;
  let hour;
  let min;
  let sec;
  if (tag === 'gentime') {
    year = str.slice(0, 4) | 0;
    mon = str.slice(4, 6) | 0;
    day = str.slice(6, 8) | 0;
    hour = str.slice(8, 10) | 0;
    min = str.slice(10, 12) | 0;
    sec = str.slice(12, 14) | 0;
  } else if (tag === 'utctime') {
    year = str.slice(0, 2) | 0;
    mon = str.slice(2, 4) | 0;
    day = str.slice(4, 6) | 0;
    hour = str.slice(6, 8) | 0;
    min = str.slice(8, 10) | 0;
    sec = str.slice(10, 12) | 0;
    if (year < 70) year = 2000 + year;else year = 1900 + year;
  } else {
    return buffer.error('Decoding ' + tag + ' time is not supported yet');
  }
  return Date.UTC(year, mon - 1, day, hour, min, sec, 0);
};
DERNode.prototype._decodeNull = function decodeNull() {
  return null;
};
DERNode.prototype._decodeBool = function decodeBool(buffer) {
  const res = buffer.readUInt8();
  if (buffer.isError(res)) return res;else return res !== 0;
};
DERNode.prototype._decodeInt = function decodeInt(buffer, values) {
  // Bigint, return as it is (assume big endian)
  const raw = buffer.raw();
  let res = new bignum(raw);
  if (values) res = values[res.toString(10)] || res;
  return res;
};
DERNode.prototype._use = function use(entity, obj) {
  if (typeof entity === 'function') entity = entity(obj);
  return entity._getDecoder('der').tree;
};

// Utility methods

function derDecodeTag(buf, fail) {
  let tag = buf.readUInt8(fail);
  if (buf.isError(tag)) return tag;
  const cls = der.tagClass[tag >> 6];
  const primitive = (tag & 0x20) === 0;

  // Multi-octet tag - load
  if ((tag & 0x1f) === 0x1f) {
    let oct = tag;
    tag = 0;
    while ((oct & 0x80) === 0x80) {
      oct = buf.readUInt8(fail);
      if (buf.isError(oct)) return oct;
      tag <<= 7;
      tag |= oct & 0x7f;
    }
  } else {
    tag &= 0x1f;
  }
  const tagStr = der.tag[tag];
  return {
    cls: cls,
    primitive: primitive,
    tag: tag,
    tagStr: tagStr
  };
}
function derDecodeLen(buf, primitive, fail) {
  let len = buf.readUInt8(fail);
  if (buf.isError(len)) return len;

  // Indefinite form
  if (!primitive && len === 0x80) return null;

  // Definite form
  if ((len & 0x80) === 0) {
    // Short form
    return len;
  }

  // Long form
  const num = len & 0x7f;
  if (num > 4) return buf.error('length octect is too long');
  len = 0;
  for (let i = 0; i < num; i++) {
    len <<= 8;
    const j = buf.readUInt8(fail);
    if (buf.isError(j)) return j;
    len |= j;
  }
  return len;
}

/***/ }),

/***/ 3173:
/*!**********************************************************!*\
  !*** ../node_modules/asn1.js/lib/asn1/decoders/index.js ***!
  \**********************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


const decoders = exports;
decoders.der = __webpack_require__(/*! ./der */ 1827);
decoders.pem = __webpack_require__(/*! ./pem */ 4316);

/***/ }),

/***/ 4316:
/*!********************************************************!*\
  !*** ../node_modules/asn1.js/lib/asn1/decoders/pem.js ***!
  \********************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


const inherits = __webpack_require__(/*! inherits */ 7694);
const Buffer = (__webpack_require__(/*! safer-buffer */ 3745).Buffer);
const DERDecoder = __webpack_require__(/*! ./der */ 1827);
function PEMDecoder(entity) {
  DERDecoder.call(this, entity);
  this.enc = 'pem';
}
inherits(PEMDecoder, DERDecoder);
module.exports = PEMDecoder;
PEMDecoder.prototype.decode = function decode(data, options) {
  const lines = data.toString().split(/[\r\n]+/g);
  const label = options.label.toUpperCase();
  const re = /^-----(BEGIN|END) ([^-]+)-----$/;
  let start = -1;
  let end = -1;
  for (let i = 0; i < lines.length; i++) {
    const match = lines[i].match(re);
    if (match === null) continue;
    if (match[2] !== label) continue;
    if (start === -1) {
      if (match[1] !== 'BEGIN') break;
      start = i;
    } else {
      if (match[1] !== 'END') break;
      end = i;
      break;
    }
  }
  if (start === -1 || end === -1) throw new Error('PEM section not found for: ' + label);
  const base64 = lines.slice(start + 1, end).join('');
  // Remove excessive symbols
  base64.replace(/[^a-z0-9+/=]+/gi, '');
  const input = Buffer.from(base64, 'base64');
  return DERDecoder.prototype.decode.call(this, input, options);
};

/***/ }),

/***/ 4487:
/*!********************************************************!*\
  !*** ../node_modules/asn1.js/lib/asn1/encoders/der.js ***!
  \********************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


const inherits = __webpack_require__(/*! inherits */ 7694);
const Buffer = (__webpack_require__(/*! safer-buffer */ 3745).Buffer);
const Node = __webpack_require__(/*! ../base/node */ 8324);

// Import DER constants
const der = __webpack_require__(/*! ../constants/der */ 4885);
function DEREncoder(entity) {
  this.enc = 'der';
  this.name = entity.name;
  this.entity = entity;

  // Construct base tree
  this.tree = new DERNode();
  this.tree._init(entity.body);
}
module.exports = DEREncoder;
DEREncoder.prototype.encode = function encode(data, reporter) {
  return this.tree._encode(data, reporter).join();
};

// Tree methods

function DERNode(parent) {
  Node.call(this, 'der', parent);
}
inherits(DERNode, Node);
DERNode.prototype._encodeComposite = function encodeComposite(tag, primitive, cls, content) {
  const encodedTag = encodeTag(tag, primitive, cls, this.reporter);

  // Short form
  if (content.length < 0x80) {
    const header = Buffer.alloc(2);
    header[0] = encodedTag;
    header[1] = content.length;
    return this._createEncoderBuffer([header, content]);
  }

  // Long form
  // Count octets required to store length
  let lenOctets = 1;
  for (let i = content.length; i >= 0x100; i >>= 8) lenOctets++;
  const header = Buffer.alloc(1 + 1 + lenOctets);
  header[0] = encodedTag;
  header[1] = 0x80 | lenOctets;
  for (let i = 1 + lenOctets, j = content.length; j > 0; i--, j >>= 8) header[i] = j & 0xff;
  return this._createEncoderBuffer([header, content]);
};
DERNode.prototype._encodeStr = function encodeStr(str, tag) {
  if (tag === 'bitstr') {
    return this._createEncoderBuffer([str.unused | 0, str.data]);
  } else if (tag === 'bmpstr') {
    const buf = Buffer.alloc(str.length * 2);
    for (let i = 0; i < str.length; i++) {
      buf.writeUInt16BE(str.charCodeAt(i), i * 2);
    }
    return this._createEncoderBuffer(buf);
  } else if (tag === 'numstr') {
    if (!this._isNumstr(str)) {
      return this.reporter.error('Encoding of string type: numstr supports ' + 'only digits and space');
    }
    return this._createEncoderBuffer(str);
  } else if (tag === 'printstr') {
    if (!this._isPrintstr(str)) {
      return this.reporter.error('Encoding of string type: printstr supports ' + 'only latin upper and lower case letters, ' + 'digits, space, apostrophe, left and rigth ' + 'parenthesis, plus sign, comma, hyphen, ' + 'dot, slash, colon, equal sign, ' + 'question mark');
    }
    return this._createEncoderBuffer(str);
  } else if (/str$/.test(tag)) {
    return this._createEncoderBuffer(str);
  } else if (tag === 'objDesc') {
    return this._createEncoderBuffer(str);
  } else {
    return this.reporter.error('Encoding of string type: ' + tag + ' unsupported');
  }
};
DERNode.prototype._encodeObjid = function encodeObjid(id, values, relative) {
  if (typeof id === 'string') {
    if (!values) return this.reporter.error('string objid given, but no values map found');
    if (!values.hasOwnProperty(id)) return this.reporter.error('objid not found in values map');
    id = values[id].split(/[\s.]+/g);
    for (let i = 0; i < id.length; i++) id[i] |= 0;
  } else if (Array.isArray(id)) {
    id = id.slice();
    for (let i = 0; i < id.length; i++) id[i] |= 0;
  }
  if (!Array.isArray(id)) {
    return this.reporter.error('objid() should be either array or string, ' + 'got: ' + JSON.stringify(id));
  }
  if (!relative) {
    if (id[1] >= 40) return this.reporter.error('Second objid identifier OOB');
    id.splice(0, 2, id[0] * 40 + id[1]);
  }

  // Count number of octets
  let size = 0;
  for (let i = 0; i < id.length; i++) {
    let ident = id[i];
    for (size++; ident >= 0x80; ident >>= 7) size++;
  }
  const objid = Buffer.alloc(size);
  let offset = objid.length - 1;
  for (let i = id.length - 1; i >= 0; i--) {
    let ident = id[i];
    objid[offset--] = ident & 0x7f;
    while ((ident >>= 7) > 0) objid[offset--] = 0x80 | ident & 0x7f;
  }
  return this._createEncoderBuffer(objid);
};
function two(num) {
  if (num < 10) return '0' + num;else return num;
}
DERNode.prototype._encodeTime = function encodeTime(time, tag) {
  let str;
  const date = new Date(time);
  if (tag === 'gentime') {
    str = [two(date.getUTCFullYear()), two(date.getUTCMonth() + 1), two(date.getUTCDate()), two(date.getUTCHours()), two(date.getUTCMinutes()), two(date.getUTCSeconds()), 'Z'].join('');
  } else if (tag === 'utctime') {
    str = [two(date.getUTCFullYear() % 100), two(date.getUTCMonth() + 1), two(date.getUTCDate()), two(date.getUTCHours()), two(date.getUTCMinutes()), two(date.getUTCSeconds()), 'Z'].join('');
  } else {
    this.reporter.error('Encoding ' + tag + ' time is not supported yet');
  }
  return this._encodeStr(str, 'octstr');
};
DERNode.prototype._encodeNull = function encodeNull() {
  return this._createEncoderBuffer('');
};
DERNode.prototype._encodeInt = function encodeInt(num, values) {
  if (typeof num === 'string') {
    if (!values) return this.reporter.error('String int or enum given, but no values map');
    if (!values.hasOwnProperty(num)) {
      return this.reporter.error('Values map doesn\'t contain: ' + JSON.stringify(num));
    }
    num = values[num];
  }

  // Bignum, assume big endian
  if (typeof num !== 'number' && !Buffer.isBuffer(num)) {
    const numArray = num.toArray();
    if (!num.sign && numArray[0] & 0x80) {
      numArray.unshift(0);
    }
    num = Buffer.from(numArray);
  }
  if (Buffer.isBuffer(num)) {
    let size = num.length;
    if (num.length === 0) size++;
    const out = Buffer.alloc(size);
    num.copy(out);
    if (num.length === 0) out[0] = 0;
    return this._createEncoderBuffer(out);
  }
  if (num < 0x80) return this._createEncoderBuffer(num);
  if (num < 0x100) return this._createEncoderBuffer([0, num]);
  let size = 1;
  for (let i = num; i >= 0x100; i >>= 8) size++;
  const out = new Array(size);
  for (let i = out.length - 1; i >= 0; i--) {
    out[i] = num & 0xff;
    num >>= 8;
  }
  if (out[0] & 0x80) {
    out.unshift(0);
  }
  return this._createEncoderBuffer(Buffer.from(out));
};
DERNode.prototype._encodeBool = function encodeBool(value) {
  return this._createEncoderBuffer(value ? 0xff : 0);
};
DERNode.prototype._use = function use(entity, obj) {
  if (typeof entity === 'function') entity = entity(obj);
  return entity._getEncoder('der').tree;
};
DERNode.prototype._skipDefault = function skipDefault(dataBuffer, reporter, parent) {
  const state = this._baseState;
  let i;
  if (state['default'] === null) return false;
  const data = dataBuffer.join();
  if (state.defaultBuffer === undefined) state.defaultBuffer = this._encodeValue(state['default'], reporter, parent).join();
  if (data.length !== state.defaultBuffer.length) return false;
  for (i = 0; i < data.length; i++) if (data[i] !== state.defaultBuffer[i]) return false;
  return true;
};

// Utility methods

function encodeTag(tag, primitive, cls, reporter) {
  let res;
  if (tag === 'seqof') tag = 'seq';else if (tag === 'setof') tag = 'set';
  if (der.tagByName.hasOwnProperty(tag)) res = der.tagByName[tag];else if (typeof tag === 'number' && (tag | 0) === tag) res = tag;else return reporter.error('Unknown tag: ' + tag);
  if (res >= 0x1f) return reporter.error('Multi-octet tag encoding unsupported');
  if (!primitive) res |= 0x20;
  res |= der.tagClassByName[cls || 'universal'] << 6;
  return res;
}

/***/ }),

/***/ 5696:
/*!**********************************************************!*\
  !*** ../node_modules/asn1.js/lib/asn1/encoders/index.js ***!
  \**********************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


const encoders = exports;
encoders.der = __webpack_require__(/*! ./der */ 4487);
encoders.pem = __webpack_require__(/*! ./pem */ 6668);

/***/ }),

/***/ 6668:
/*!********************************************************!*\
  !*** ../node_modules/asn1.js/lib/asn1/encoders/pem.js ***!
  \********************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


const inherits = __webpack_require__(/*! inherits */ 7694);
const DEREncoder = __webpack_require__(/*! ./der */ 4487);
function PEMEncoder(entity) {
  DEREncoder.call(this, entity);
  this.enc = 'pem';
}
inherits(PEMEncoder, DEREncoder);
module.exports = PEMEncoder;
PEMEncoder.prototype.encode = function encode(data, options) {
  const buf = DEREncoder.prototype.encode.call(this, data);
  const p = buf.toString('base64');
  const out = ['-----BEGIN ' + options.label + '-----'];
  for (let i = 0; i < p.length; i += 64) out.push(p.slice(i, i + 64));
  out.push('-----END ' + options.label + '-----');
  return out.join('\n');
};

/***/ }),

/***/ 1046:
/*!***************************************!*\
  !*** ../node_modules/bn.js/lib/bn.js ***!
  \***************************************/
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {

/* module decorator */ module = __webpack_require__.nmd(module);
(function (module, exports) {
  'use strict';

  // Utils
  function assert(val, msg) {
    if (!val) throw new Error(msg || 'Assertion failed');
  }

  // Could use `inherits` module, but don't want to move from single file
  // architecture yet.
  function inherits(ctor, superCtor) {
    ctor.super_ = superCtor;
    var TempCtor = function () {};
    TempCtor.prototype = superCtor.prototype;
    ctor.prototype = new TempCtor();
    ctor.prototype.constructor = ctor;
  }

  // BN

  function BN(number, base, endian) {
    if (BN.isBN(number)) {
      return number;
    }
    this.negative = 0;
    this.words = null;
    this.length = 0;

    // Reduction context
    this.red = null;
    if (number !== null) {
      if (base === 'le' || base === 'be') {
        endian = base;
        base = 10;
      }
      this._init(number || 0, base || 10, endian || 'be');
    }
  }
  if (typeof module === 'object') {
    module.exports = BN;
  } else {
    exports.BN = BN;
  }
  BN.BN = BN;
  BN.wordSize = 26;
  var Buffer;
  try {
    if (typeof window !== 'undefined' && typeof window.Buffer !== 'undefined') {
      Buffer = window.Buffer;
    } else {
      Buffer = (__webpack_require__(/*! buffer */ 4300).Buffer);
    }
  } catch (e) {}
  BN.isBN = function isBN(num) {
    if (num instanceof BN) {
      return true;
    }
    return num !== null && typeof num === 'object' && num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);
  };
  BN.max = function max(left, right) {
    if (left.cmp(right) > 0) return left;
    return right;
  };
  BN.min = function min(left, right) {
    if (left.cmp(right) < 0) return left;
    return right;
  };
  BN.prototype._init = function init(number, base, endian) {
    if (typeof number === 'number') {
      return this._initNumber(number, base, endian);
    }
    if (typeof number === 'object') {
      return this._initArray(number, base, endian);
    }
    if (base === 'hex') {
      base = 16;
    }
    assert(base === (base | 0) && base >= 2 && base <= 36);
    number = number.toString().replace(/\s+/g, '');
    var start = 0;
    if (number[0] === '-') {
      start++;
      this.negative = 1;
    }
    if (start < number.length) {
      if (base === 16) {
        this._parseHex(number, start, endian);
      } else {
        this._parseBase(number, base, start);
        if (endian === 'le') {
          this._initArray(this.toArray(), base, endian);
        }
      }
    }
  };
  BN.prototype._initNumber = function _initNumber(number, base, endian) {
    if (number < 0) {
      this.negative = 1;
      number = -number;
    }
    if (number < 0x4000000) {
      this.words = [number & 0x3ffffff];
      this.length = 1;
    } else if (number < 0x10000000000000) {
      this.words = [number & 0x3ffffff, number / 0x4000000 & 0x3ffffff];
      this.length = 2;
    } else {
      assert(number < 0x20000000000000); // 2 ^ 53 (unsafe)
      this.words = [number & 0x3ffffff, number / 0x4000000 & 0x3ffffff, 1];
      this.length = 3;
    }
    if (endian !== 'le') return;

    // Reverse the bytes
    this._initArray(this.toArray(), base, endian);
  };
  BN.prototype._initArray = function _initArray(number, base, endian) {
    // Perhaps a Uint8Array
    assert(typeof number.length === 'number');
    if (number.length <= 0) {
      this.words = [0];
      this.length = 1;
      return this;
    }
    this.length = Math.ceil(number.length / 3);
    this.words = new Array(this.length);
    for (var i = 0; i < this.length; i++) {
      this.words[i] = 0;
    }
    var j, w;
    var off = 0;
    if (endian === 'be') {
      for (i = number.length - 1, j = 0; i >= 0; i -= 3) {
        w = number[i] | number[i - 1] << 8 | number[i - 2] << 16;
        this.words[j] |= w << off & 0x3ffffff;
        this.words[j + 1] = w >>> 26 - off & 0x3ffffff;
        off += 24;
        if (off >= 26) {
          off -= 26;
          j++;
        }
      }
    } else if (endian === 'le') {
      for (i = 0, j = 0; i < number.length; i += 3) {
        w = number[i] | number[i + 1] << 8 | number[i + 2] << 16;
        this.words[j] |= w << off & 0x3ffffff;
        this.words[j + 1] = w >>> 26 - off & 0x3ffffff;
        off += 24;
        if (off >= 26) {
          off -= 26;
          j++;
        }
      }
    }
    return this.strip();
  };
  function parseHex4Bits(string, index) {
    var c = string.charCodeAt(index);
    // 'A' - 'F'
    if (c >= 65 && c <= 70) {
      return c - 55;
      // 'a' - 'f'
    } else if (c >= 97 && c <= 102) {
      return c - 87;
      // '0' - '9'
    } else {
      return c - 48 & 0xf;
    }
  }
  function parseHexByte(string, lowerBound, index) {
    var r = parseHex4Bits(string, index);
    if (index - 1 >= lowerBound) {
      r |= parseHex4Bits(string, index - 1) << 4;
    }
    return r;
  }
  BN.prototype._parseHex = function _parseHex(number, start, endian) {
    // Create possibly bigger array to ensure that it fits the number
    this.length = Math.ceil((number.length - start) / 6);
    this.words = new Array(this.length);
    for (var i = 0; i < this.length; i++) {
      this.words[i] = 0;
    }

    // 24-bits chunks
    var off = 0;
    var j = 0;
    var w;
    if (endian === 'be') {
      for (i = number.length - 1; i >= start; i -= 2) {
        w = parseHexByte(number, start, i) << off;
        this.words[j] |= w & 0x3ffffff;
        if (off >= 18) {
          off -= 18;
          j += 1;
          this.words[j] |= w >>> 26;
        } else {
          off += 8;
        }
      }
    } else {
      var parseLength = number.length - start;
      for (i = parseLength % 2 === 0 ? start + 1 : start; i < number.length; i += 2) {
        w = parseHexByte(number, start, i) << off;
        this.words[j] |= w & 0x3ffffff;
        if (off >= 18) {
          off -= 18;
          j += 1;
          this.words[j] |= w >>> 26;
        } else {
          off += 8;
        }
      }
    }
    this.strip();
  };
  function parseBase(str, start, end, mul) {
    var r = 0;
    var len = Math.min(str.length, end);
    for (var i = start; i < len; i++) {
      var c = str.charCodeAt(i) - 48;
      r *= mul;

      // 'a'
      if (c >= 49) {
        r += c - 49 + 0xa;

        // 'A'
      } else if (c >= 17) {
        r += c - 17 + 0xa;

        // '0' - '9'
      } else {
        r += c;
      }
    }
    return r;
  }
  BN.prototype._parseBase = function _parseBase(number, base, start) {
    // Initialize as zero
    this.words = [0];
    this.length = 1;

    // Find length of limb in base
    for (var limbLen = 0, limbPow = 1; limbPow <= 0x3ffffff; limbPow *= base) {
      limbLen++;
    }
    limbLen--;
    limbPow = limbPow / base | 0;
    var total = number.length - start;
    var mod = total % limbLen;
    var end = Math.min(total, total - mod) + start;
    var word = 0;
    for (var i = start; i < end; i += limbLen) {
      word = parseBase(number, i, i + limbLen, base);
      this.imuln(limbPow);
      if (this.words[0] + word < 0x4000000) {
        this.words[0] += word;
      } else {
        this._iaddn(word);
      }
    }
    if (mod !== 0) {
      var pow = 1;
      word = parseBase(number, i, number.length, base);
      for (i = 0; i < mod; i++) {
        pow *= base;
      }
      this.imuln(pow);
      if (this.words[0] + word < 0x4000000) {
        this.words[0] += word;
      } else {
        this._iaddn(word);
      }
    }
    this.strip();
  };
  BN.prototype.copy = function copy(dest) {
    dest.words = new Array(this.length);
    for (var i = 0; i < this.length; i++) {
      dest.words[i] = this.words[i];
    }
    dest.length = this.length;
    dest.negative = this.negative;
    dest.red = this.red;
  };
  BN.prototype.clone = function clone() {
    var r = new BN(null);
    this.copy(r);
    return r;
  };
  BN.prototype._expand = function _expand(size) {
    while (this.length < size) {
      this.words[this.length++] = 0;
    }
    return this;
  };

  // Remove leading `0` from `this`
  BN.prototype.strip = function strip() {
    while (this.length > 1 && this.words[this.length - 1] === 0) {
      this.length--;
    }
    return this._normSign();
  };
  BN.prototype._normSign = function _normSign() {
    // -0 = 0
    if (this.length === 1 && this.words[0] === 0) {
      this.negative = 0;
    }
    return this;
  };
  BN.prototype.inspect = function inspect() {
    return (this.red ? '<BN-R: ' : '<BN: ') + this.toString(16) + '>';
  };

  /*
   var zeros = [];
  var groupSizes = [];
  var groupBases = [];
   var s = '';
  var i = -1;
  while (++i < BN.wordSize) {
    zeros[i] = s;
    s += '0';
  }
  groupSizes[0] = 0;
  groupSizes[1] = 0;
  groupBases[0] = 0;
  groupBases[1] = 0;
  var base = 2 - 1;
  while (++base < 36 + 1) {
    var groupSize = 0;
    var groupBase = 1;
    while (groupBase < (1 << BN.wordSize) / base) {
      groupBase *= base;
      groupSize += 1;
    }
    groupSizes[base] = groupSize;
    groupBases[base] = groupBase;
  }
   */

  var zeros = ['', '0', '00', '000', '0000', '00000', '000000', '0000000', '00000000', '000000000', '0000000000', '00000000000', '000000000000', '0000000000000', '00000000000000', '000000000000000', '0000000000000000', '00000000000000000', '000000000000000000', '0000000000000000000', '00000000000000000000', '000000000000000000000', '0000000000000000000000', '00000000000000000000000', '000000000000000000000000', '0000000000000000000000000'];
  var groupSizes = [0, 0, 25, 16, 12, 11, 10, 9, 8, 8, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5];
  var groupBases = [0, 0, 33554432, 43046721, 16777216, 48828125, 60466176, 40353607, 16777216, 43046721, 10000000, 19487171, 35831808, 62748517, 7529536, 11390625, 16777216, 24137569, 34012224, 47045881, 64000000, 4084101, 5153632, 6436343, 7962624, 9765625, 11881376, 14348907, 17210368, 20511149, 24300000, 28629151, 33554432, 39135393, 45435424, 52521875, 60466176];
  BN.prototype.toString = function toString(base, padding) {
    base = base || 10;
    padding = padding | 0 || 1;
    var out;
    if (base === 16 || base === 'hex') {
      out = '';
      var off = 0;
      var carry = 0;
      for (var i = 0; i < this.length; i++) {
        var w = this.words[i];
        var word = ((w << off | carry) & 0xffffff).toString(16);
        carry = w >>> 24 - off & 0xffffff;
        if (carry !== 0 || i !== this.length - 1) {
          out = zeros[6 - word.length] + word + out;
        } else {
          out = word + out;
        }
        off += 2;
        if (off >= 26) {
          off -= 26;
          i--;
        }
      }
      if (carry !== 0) {
        out = carry.toString(16) + out;
      }
      while (out.length % padding !== 0) {
        out = '0' + out;
      }
      if (this.negative !== 0) {
        out = '-' + out;
      }
      return out;
    }
    if (base === (base | 0) && base >= 2 && base <= 36) {
      // var groupSize = Math.floor(BN.wordSize * Math.LN2 / Math.log(base));
      var groupSize = groupSizes[base];
      // var groupBase = Math.pow(base, groupSize);
      var groupBase = groupBases[base];
      out = '';
      var c = this.clone();
      c.negative = 0;
      while (!c.isZero()) {
        var r = c.modn(groupBase).toString(base);
        c = c.idivn(groupBase);
        if (!c.isZero()) {
          out = zeros[groupSize - r.length] + r + out;
        } else {
          out = r + out;
        }
      }
      if (this.isZero()) {
        out = '0' + out;
      }
      while (out.length % padding !== 0) {
        out = '0' + out;
      }
      if (this.negative !== 0) {
        out = '-' + out;
      }
      return out;
    }
    assert(false, 'Base should be between 2 and 36');
  };
  BN.prototype.toNumber = function toNumber() {
    var ret = this.words[0];
    if (this.length === 2) {
      ret += this.words[1] * 0x4000000;
    } else if (this.length === 3 && this.words[2] === 0x01) {
      // NOTE: at this stage it is known that the top bit is set
      ret += 0x10000000000000 + this.words[1] * 0x4000000;
    } else if (this.length > 2) {
      assert(false, 'Number can only safely store up to 53 bits');
    }
    return this.negative !== 0 ? -ret : ret;
  };
  BN.prototype.toJSON = function toJSON() {
    return this.toString(16);
  };
  BN.prototype.toBuffer = function toBuffer(endian, length) {
    assert(typeof Buffer !== 'undefined');
    return this.toArrayLike(Buffer, endian, length);
  };
  BN.prototype.toArray = function toArray(endian, length) {
    return this.toArrayLike(Array, endian, length);
  };
  BN.prototype.toArrayLike = function toArrayLike(ArrayType, endian, length) {
    var byteLength = this.byteLength();
    var reqLength = length || Math.max(1, byteLength);
    assert(byteLength <= reqLength, 'byte array longer than desired length');
    assert(reqLength > 0, 'Requested array length <= 0');
    this.strip();
    var littleEndian = endian === 'le';
    var res = new ArrayType(reqLength);
    var b, i;
    var q = this.clone();
    if (!littleEndian) {
      // Assume big-endian
      for (i = 0; i < reqLength - byteLength; i++) {
        res[i] = 0;
      }
      for (i = 0; !q.isZero(); i++) {
        b = q.andln(0xff);
        q.iushrn(8);
        res[reqLength - i - 1] = b;
      }
    } else {
      for (i = 0; !q.isZero(); i++) {
        b = q.andln(0xff);
        q.iushrn(8);
        res[i] = b;
      }
      for (; i < reqLength; i++) {
        res[i] = 0;
      }
    }
    return res;
  };
  if (Math.clz32) {
    BN.prototype._countBits = function _countBits(w) {
      return 32 - Math.clz32(w);
    };
  } else {
    BN.prototype._countBits = function _countBits(w) {
      var t = w;
      var r = 0;
      if (t >= 0x1000) {
        r += 13;
        t >>>= 13;
      }
      if (t >= 0x40) {
        r += 7;
        t >>>= 7;
      }
      if (t >= 0x8) {
        r += 4;
        t >>>= 4;
      }
      if (t >= 0x02) {
        r += 2;
        t >>>= 2;
      }
      return r + t;
    };
  }
  BN.prototype._zeroBits = function _zeroBits(w) {
    // Short-cut
    if (w === 0) return 26;
    var t = w;
    var r = 0;
    if ((t & 0x1fff) === 0) {
      r += 13;
      t >>>= 13;
    }
    if ((t & 0x7f) === 0) {
      r += 7;
      t >>>= 7;
    }
    if ((t & 0xf) === 0) {
      r += 4;
      t >>>= 4;
    }
    if ((t & 0x3) === 0) {
      r += 2;
      t >>>= 2;
    }
    if ((t & 0x1) === 0) {
      r++;
    }
    return r;
  };

  // Return number of used bits in a BN
  BN.prototype.bitLength = function bitLength() {
    var w = this.words[this.length - 1];
    var hi = this._countBits(w);
    return (this.length - 1) * 26 + hi;
  };
  function toBitArray(num) {
    var w = new Array(num.bitLength());
    for (var bit = 0; bit < w.length; bit++) {
      var off = bit / 26 | 0;
      var wbit = bit % 26;
      w[bit] = (num.words[off] & 1 << wbit) >>> wbit;
    }
    return w;
  }

  // Number of trailing zero bits
  BN.prototype.zeroBits = function zeroBits() {
    if (this.isZero()) return 0;
    var r = 0;
    for (var i = 0; i < this.length; i++) {
      var b = this._zeroBits(this.words[i]);
      r += b;
      if (b !== 26) break;
    }
    return r;
  };
  BN.prototype.byteLength = function byteLength() {
    return Math.ceil(this.bitLength() / 8);
  };
  BN.prototype.toTwos = function toTwos(width) {
    if (this.negative !== 0) {
      return this.abs().inotn(width).iaddn(1);
    }
    return this.clone();
  };
  BN.prototype.fromTwos = function fromTwos(width) {
    if (this.testn(width - 1)) {
      return this.notn(width).iaddn(1).ineg();
    }
    return this.clone();
  };
  BN.prototype.isNeg = function isNeg() {
    return this.negative !== 0;
  };

  // Return negative clone of `this`
  BN.prototype.neg = function neg() {
    return this.clone().ineg();
  };
  BN.prototype.ineg = function ineg() {
    if (!this.isZero()) {
      this.negative ^= 1;
    }
    return this;
  };

  // Or `num` with `this` in-place
  BN.prototype.iuor = function iuor(num) {
    while (this.length < num.length) {
      this.words[this.length++] = 0;
    }
    for (var i = 0; i < num.length; i++) {
      this.words[i] = this.words[i] | num.words[i];
    }
    return this.strip();
  };
  BN.prototype.ior = function ior(num) {
    assert((this.negative | num.negative) === 0);
    return this.iuor(num);
  };

  // Or `num` with `this`
  BN.prototype.or = function or(num) {
    if (this.length > num.length) return this.clone().ior(num);
    return num.clone().ior(this);
  };
  BN.prototype.uor = function uor(num) {
    if (this.length > num.length) return this.clone().iuor(num);
    return num.clone().iuor(this);
  };

  // And `num` with `this` in-place
  BN.prototype.iuand = function iuand(num) {
    // b = min-length(num, this)
    var b;
    if (this.length > num.length) {
      b = num;
    } else {
      b = this;
    }
    for (var i = 0; i < b.length; i++) {
      this.words[i] = this.words[i] & num.words[i];
    }
    this.length = b.length;
    return this.strip();
  };
  BN.prototype.iand = function iand(num) {
    assert((this.negative | num.negative) === 0);
    return this.iuand(num);
  };

  // And `num` with `this`
  BN.prototype.and = function and(num) {
    if (this.length > num.length) return this.clone().iand(num);
    return num.clone().iand(this);
  };
  BN.prototype.uand = function uand(num) {
    if (this.length > num.length) return this.clone().iuand(num);
    return num.clone().iuand(this);
  };

  // Xor `num` with `this` in-place
  BN.prototype.iuxor = function iuxor(num) {
    // a.length > b.length
    var a;
    var b;
    if (this.length > num.length) {
      a = this;
      b = num;
    } else {
      a = num;
      b = this;
    }
    for (var i = 0; i < b.length; i++) {
      this.words[i] = a.words[i] ^ b.words[i];
    }
    if (this !== a) {
      for (; i < a.length; i++) {
        this.words[i] = a.words[i];
      }
    }
    this.length = a.length;
    return this.strip();
  };
  BN.prototype.ixor = function ixor(num) {
    assert((this.negative | num.negative) === 0);
    return this.iuxor(num);
  };

  // Xor `num` with `this`
  BN.prototype.xor = function xor(num) {
    if (this.length > num.length) return this.clone().ixor(num);
    return num.clone().ixor(this);
  };
  BN.prototype.uxor = function uxor(num) {
    if (this.length > num.length) return this.clone().iuxor(num);
    return num.clone().iuxor(this);
  };

  // Not ``this`` with ``width`` bitwidth
  BN.prototype.inotn = function inotn(width) {
    assert(typeof width === 'number' && width >= 0);
    var bytesNeeded = Math.ceil(width / 26) | 0;
    var bitsLeft = width % 26;

    // Extend the buffer with leading zeroes
    this._expand(bytesNeeded);
    if (bitsLeft > 0) {
      bytesNeeded--;
    }

    // Handle complete words
    for (var i = 0; i < bytesNeeded; i++) {
      this.words[i] = ~this.words[i] & 0x3ffffff;
    }

    // Handle the residue
    if (bitsLeft > 0) {
      this.words[i] = ~this.words[i] & 0x3ffffff >> 26 - bitsLeft;
    }

    // And remove leading zeroes
    return this.strip();
  };
  BN.prototype.notn = function notn(width) {
    return this.clone().inotn(width);
  };

  // Set `bit` of `this`
  BN.prototype.setn = function setn(bit, val) {
    assert(typeof bit === 'number' && bit >= 0);
    var off = bit / 26 | 0;
    var wbit = bit % 26;
    this._expand(off + 1);
    if (val) {
      this.words[off] = this.words[off] | 1 << wbit;
    } else {
      this.words[off] = this.words[off] & ~(1 << wbit);
    }
    return this.strip();
  };

  // Add `num` to `this` in-place
  BN.prototype.iadd = function iadd(num) {
    var r;

    // negative + positive
    if (this.negative !== 0 && num.negative === 0) {
      this.negative = 0;
      r = this.isub(num);
      this.negative ^= 1;
      return this._normSign();

      // positive + negative
    } else if (this.negative === 0 && num.negative !== 0) {
      num.negative = 0;
      r = this.isub(num);
      num.negative = 1;
      return r._normSign();
    }

    // a.length > b.length
    var a, b;
    if (this.length > num.length) {
      a = this;
      b = num;
    } else {
      a = num;
      b = this;
    }
    var carry = 0;
    for (var i = 0; i < b.length; i++) {
      r = (a.words[i] | 0) + (b.words[i] | 0) + carry;
      this.words[i] = r & 0x3ffffff;
      carry = r >>> 26;
    }
    for (; carry !== 0 && i < a.length; i++) {
      r = (a.words[i] | 0) + carry;
      this.words[i] = r & 0x3ffffff;
      carry = r >>> 26;
    }
    this.length = a.length;
    if (carry !== 0) {
      this.words[this.length] = carry;
      this.length++;
      // Copy the rest of the words
    } else if (a !== this) {
      for (; i < a.length; i++) {
        this.words[i] = a.words[i];
      }
    }
    return this;
  };

  // Add `num` to `this`
  BN.prototype.add = function add(num) {
    var res;
    if (num.negative !== 0 && this.negative === 0) {
      num.negative = 0;
      res = this.sub(num);
      num.negative ^= 1;
      return res;
    } else if (num.negative === 0 && this.negative !== 0) {
      this.negative = 0;
      res = num.sub(this);
      this.negative = 1;
      return res;
    }
    if (this.length > num.length) return this.clone().iadd(num);
    return num.clone().iadd(this);
  };

  // Subtract `num` from `this` in-place
  BN.prototype.isub = function isub(num) {
    // this - (-num) = this + num
    if (num.negative !== 0) {
      num.negative = 0;
      var r = this.iadd(num);
      num.negative = 1;
      return r._normSign();

      // -this - num = -(this + num)
    } else if (this.negative !== 0) {
      this.negative = 0;
      this.iadd(num);
      this.negative = 1;
      return this._normSign();
    }

    // At this point both numbers are positive
    var cmp = this.cmp(num);

    // Optimization - zeroify
    if (cmp === 0) {
      this.negative = 0;
      this.length = 1;
      this.words[0] = 0;
      return this;
    }

    // a > b
    var a, b;
    if (cmp > 0) {
      a = this;
      b = num;
    } else {
      a = num;
      b = this;
    }
    var carry = 0;
    for (var i = 0; i < b.length; i++) {
      r = (a.words[i] | 0) - (b.words[i] | 0) + carry;
      carry = r >> 26;
      this.words[i] = r & 0x3ffffff;
    }
    for (; carry !== 0 && i < a.length; i++) {
      r = (a.words[i] | 0) + carry;
      carry = r >> 26;
      this.words[i] = r & 0x3ffffff;
    }

    // Copy rest of the words
    if (carry === 0 && i < a.length && a !== this) {
      for (; i < a.length; i++) {
        this.words[i] = a.words[i];
      }
    }
    this.length = Math.max(this.length, i);
    if (a !== this) {
      this.negative = 1;
    }
    return this.strip();
  };

  // Subtract `num` from `this`
  BN.prototype.sub = function sub(num) {
    return this.clone().isub(num);
  };
  function smallMulTo(self, num, out) {
    out.negative = num.negative ^ self.negative;
    var len = self.length + num.length | 0;
    out.length = len;
    len = len - 1 | 0;

    // Peel one iteration (compiler can't do it, because of code complexity)
    var a = self.words[0] | 0;
    var b = num.words[0] | 0;
    var r = a * b;
    var lo = r & 0x3ffffff;
    var carry = r / 0x4000000 | 0;
    out.words[0] = lo;
    for (var k = 1; k < len; k++) {
      // Sum all words with the same `i + j = k` and accumulate `ncarry`,
      // note that ncarry could be >= 0x3ffffff
      var ncarry = carry >>> 26;
      var rword = carry & 0x3ffffff;
      var maxJ = Math.min(k, num.length - 1);
      for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {
        var i = k - j | 0;
        a = self.words[i] | 0;
        b = num.words[j] | 0;
        r = a * b + rword;
        ncarry += r / 0x4000000 | 0;
        rword = r & 0x3ffffff;
      }
      out.words[k] = rword | 0;
      carry = ncarry | 0;
    }
    if (carry !== 0) {
      out.words[k] = carry | 0;
    } else {
      out.length--;
    }
    return out.strip();
  }

  // TODO(indutny): it may be reasonable to omit it for users who don't need
  // to work with 256-bit numbers, otherwise it gives 20% improvement for 256-bit
  // multiplication (like elliptic secp256k1).
  var comb10MulTo = function comb10MulTo(self, num, out) {
    var a = self.words;
    var b = num.words;
    var o = out.words;
    var c = 0;
    var lo;
    var mid;
    var hi;
    var a0 = a[0] | 0;
    var al0 = a0 & 0x1fff;
    var ah0 = a0 >>> 13;
    var a1 = a[1] | 0;
    var al1 = a1 & 0x1fff;
    var ah1 = a1 >>> 13;
    var a2 = a[2] | 0;
    var al2 = a2 & 0x1fff;
    var ah2 = a2 >>> 13;
    var a3 = a[3] | 0;
    var al3 = a3 & 0x1fff;
    var ah3 = a3 >>> 13;
    var a4 = a[4] | 0;
    var al4 = a4 & 0x1fff;
    var ah4 = a4 >>> 13;
    var a5 = a[5] | 0;
    var al5 = a5 & 0x1fff;
    var ah5 = a5 >>> 13;
    var a6 = a[6] | 0;
    var al6 = a6 & 0x1fff;
    var ah6 = a6 >>> 13;
    var a7 = a[7] | 0;
    var al7 = a7 & 0x1fff;
    var ah7 = a7 >>> 13;
    var a8 = a[8] | 0;
    var al8 = a8 & 0x1fff;
    var ah8 = a8 >>> 13;
    var a9 = a[9] | 0;
    var al9 = a9 & 0x1fff;
    var ah9 = a9 >>> 13;
    var b0 = b[0] | 0;
    var bl0 = b0 & 0x1fff;
    var bh0 = b0 >>> 13;
    var b1 = b[1] | 0;
    var bl1 = b1 & 0x1fff;
    var bh1 = b1 >>> 13;
    var b2 = b[2] | 0;
    var bl2 = b2 & 0x1fff;
    var bh2 = b2 >>> 13;
    var b3 = b[3] | 0;
    var bl3 = b3 & 0x1fff;
    var bh3 = b3 >>> 13;
    var b4 = b[4] | 0;
    var bl4 = b4 & 0x1fff;
    var bh4 = b4 >>> 13;
    var b5 = b[5] | 0;
    var bl5 = b5 & 0x1fff;
    var bh5 = b5 >>> 13;
    var b6 = b[6] | 0;
    var bl6 = b6 & 0x1fff;
    var bh6 = b6 >>> 13;
    var b7 = b[7] | 0;
    var bl7 = b7 & 0x1fff;
    var bh7 = b7 >>> 13;
    var b8 = b[8] | 0;
    var bl8 = b8 & 0x1fff;
    var bh8 = b8 >>> 13;
    var b9 = b[9] | 0;
    var bl9 = b9 & 0x1fff;
    var bh9 = b9 >>> 13;
    out.negative = self.negative ^ num.negative;
    out.length = 19;
    /* k = 0 */
    lo = Math.imul(al0, bl0);
    mid = Math.imul(al0, bh0);
    mid = mid + Math.imul(ah0, bl0) | 0;
    hi = Math.imul(ah0, bh0);
    var w0 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w0 >>> 26) | 0;
    w0 &= 0x3ffffff;
    /* k = 1 */
    lo = Math.imul(al1, bl0);
    mid = Math.imul(al1, bh0);
    mid = mid + Math.imul(ah1, bl0) | 0;
    hi = Math.imul(ah1, bh0);
    lo = lo + Math.imul(al0, bl1) | 0;
    mid = mid + Math.imul(al0, bh1) | 0;
    mid = mid + Math.imul(ah0, bl1) | 0;
    hi = hi + Math.imul(ah0, bh1) | 0;
    var w1 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w1 >>> 26) | 0;
    w1 &= 0x3ffffff;
    /* k = 2 */
    lo = Math.imul(al2, bl0);
    mid = Math.imul(al2, bh0);
    mid = mid + Math.imul(ah2, bl0) | 0;
    hi = Math.imul(ah2, bh0);
    lo = lo + Math.imul(al1, bl1) | 0;
    mid = mid + Math.imul(al1, bh1) | 0;
    mid = mid + Math.imul(ah1, bl1) | 0;
    hi = hi + Math.imul(ah1, bh1) | 0;
    lo = lo + Math.imul(al0, bl2) | 0;
    mid = mid + Math.imul(al0, bh2) | 0;
    mid = mid + Math.imul(ah0, bl2) | 0;
    hi = hi + Math.imul(ah0, bh2) | 0;
    var w2 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w2 >>> 26) | 0;
    w2 &= 0x3ffffff;
    /* k = 3 */
    lo = Math.imul(al3, bl0);
    mid = Math.imul(al3, bh0);
    mid = mid + Math.imul(ah3, bl0) | 0;
    hi = Math.imul(ah3, bh0);
    lo = lo + Math.imul(al2, bl1) | 0;
    mid = mid + Math.imul(al2, bh1) | 0;
    mid = mid + Math.imul(ah2, bl1) | 0;
    hi = hi + Math.imul(ah2, bh1) | 0;
    lo = lo + Math.imul(al1, bl2) | 0;
    mid = mid + Math.imul(al1, bh2) | 0;
    mid = mid + Math.imul(ah1, bl2) | 0;
    hi = hi + Math.imul(ah1, bh2) | 0;
    lo = lo + Math.imul(al0, bl3) | 0;
    mid = mid + Math.imul(al0, bh3) | 0;
    mid = mid + Math.imul(ah0, bl3) | 0;
    hi = hi + Math.imul(ah0, bh3) | 0;
    var w3 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w3 >>> 26) | 0;
    w3 &= 0x3ffffff;
    /* k = 4 */
    lo = Math.imul(al4, bl0);
    mid = Math.imul(al4, bh0);
    mid = mid + Math.imul(ah4, bl0) | 0;
    hi = Math.imul(ah4, bh0);
    lo = lo + Math.imul(al3, bl1) | 0;
    mid = mid + Math.imul(al3, bh1) | 0;
    mid = mid + Math.imul(ah3, bl1) | 0;
    hi = hi + Math.imul(ah3, bh1) | 0;
    lo = lo + Math.imul(al2, bl2) | 0;
    mid = mid + Math.imul(al2, bh2) | 0;
    mid = mid + Math.imul(ah2, bl2) | 0;
    hi = hi + Math.imul(ah2, bh2) | 0;
    lo = lo + Math.imul(al1, bl3) | 0;
    mid = mid + Math.imul(al1, bh3) | 0;
    mid = mid + Math.imul(ah1, bl3) | 0;
    hi = hi + Math.imul(ah1, bh3) | 0;
    lo = lo + Math.imul(al0, bl4) | 0;
    mid = mid + Math.imul(al0, bh4) | 0;
    mid = mid + Math.imul(ah0, bl4) | 0;
    hi = hi + Math.imul(ah0, bh4) | 0;
    var w4 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w4 >>> 26) | 0;
    w4 &= 0x3ffffff;
    /* k = 5 */
    lo = Math.imul(al5, bl0);
    mid = Math.imul(al5, bh0);
    mid = mid + Math.imul(ah5, bl0) | 0;
    hi = Math.imul(ah5, bh0);
    lo = lo + Math.imul(al4, bl1) | 0;
    mid = mid + Math.imul(al4, bh1) | 0;
    mid = mid + Math.imul(ah4, bl1) | 0;
    hi = hi + Math.imul(ah4, bh1) | 0;
    lo = lo + Math.imul(al3, bl2) | 0;
    mid = mid + Math.imul(al3, bh2) | 0;
    mid = mid + Math.imul(ah3, bl2) | 0;
    hi = hi + Math.imul(ah3, bh2) | 0;
    lo = lo + Math.imul(al2, bl3) | 0;
    mid = mid + Math.imul(al2, bh3) | 0;
    mid = mid + Math.imul(ah2, bl3) | 0;
    hi = hi + Math.imul(ah2, bh3) | 0;
    lo = lo + Math.imul(al1, bl4) | 0;
    mid = mid + Math.imul(al1, bh4) | 0;
    mid = mid + Math.imul(ah1, bl4) | 0;
    hi = hi + Math.imul(ah1, bh4) | 0;
    lo = lo + Math.imul(al0, bl5) | 0;
    mid = mid + Math.imul(al0, bh5) | 0;
    mid = mid + Math.imul(ah0, bl5) | 0;
    hi = hi + Math.imul(ah0, bh5) | 0;
    var w5 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w5 >>> 26) | 0;
    w5 &= 0x3ffffff;
    /* k = 6 */
    lo = Math.imul(al6, bl0);
    mid = Math.imul(al6, bh0);
    mid = mid + Math.imul(ah6, bl0) | 0;
    hi = Math.imul(ah6, bh0);
    lo = lo + Math.imul(al5, bl1) | 0;
    mid = mid + Math.imul(al5, bh1) | 0;
    mid = mid + Math.imul(ah5, bl1) | 0;
    hi = hi + Math.imul(ah5, bh1) | 0;
    lo = lo + Math.imul(al4, bl2) | 0;
    mid = mid + Math.imul(al4, bh2) | 0;
    mid = mid + Math.imul(ah4, bl2) | 0;
    hi = hi + Math.imul(ah4, bh2) | 0;
    lo = lo + Math.imul(al3, bl3) | 0;
    mid = mid + Math.imul(al3, bh3) | 0;
    mid = mid + Math.imul(ah3, bl3) | 0;
    hi = hi + Math.imul(ah3, bh3) | 0;
    lo = lo + Math.imul(al2, bl4) | 0;
    mid = mid + Math.imul(al2, bh4) | 0;
    mid = mid + Math.imul(ah2, bl4) | 0;
    hi = hi + Math.imul(ah2, bh4) | 0;
    lo = lo + Math.imul(al1, bl5) | 0;
    mid = mid + Math.imul(al1, bh5) | 0;
    mid = mid + Math.imul(ah1, bl5) | 0;
    hi = hi + Math.imul(ah1, bh5) | 0;
    lo = lo + Math.imul(al0, bl6) | 0;
    mid = mid + Math.imul(al0, bh6) | 0;
    mid = mid + Math.imul(ah0, bl6) | 0;
    hi = hi + Math.imul(ah0, bh6) | 0;
    var w6 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w6 >>> 26) | 0;
    w6 &= 0x3ffffff;
    /* k = 7 */
    lo = Math.imul(al7, bl0);
    mid = Math.imul(al7, bh0);
    mid = mid + Math.imul(ah7, bl0) | 0;
    hi = Math.imul(ah7, bh0);
    lo = lo + Math.imul(al6, bl1) | 0;
    mid = mid + Math.imul(al6, bh1) | 0;
    mid = mid + Math.imul(ah6, bl1) | 0;
    hi = hi + Math.imul(ah6, bh1) | 0;
    lo = lo + Math.imul(al5, bl2) | 0;
    mid = mid + Math.imul(al5, bh2) | 0;
    mid = mid + Math.imul(ah5, bl2) | 0;
    hi = hi + Math.imul(ah5, bh2) | 0;
    lo = lo + Math.imul(al4, bl3) | 0;
    mid = mid + Math.imul(al4, bh3) | 0;
    mid = mid + Math.imul(ah4, bl3) | 0;
    hi = hi + Math.imul(ah4, bh3) | 0;
    lo = lo + Math.imul(al3, bl4) | 0;
    mid = mid + Math.imul(al3, bh4) | 0;
    mid = mid + Math.imul(ah3, bl4) | 0;
    hi = hi + Math.imul(ah3, bh4) | 0;
    lo = lo + Math.imul(al2, bl5) | 0;
    mid = mid + Math.imul(al2, bh5) | 0;
    mid = mid + Math.imul(ah2, bl5) | 0;
    hi = hi + Math.imul(ah2, bh5) | 0;
    lo = lo + Math.imul(al1, bl6) | 0;
    mid = mid + Math.imul(al1, bh6) | 0;
    mid = mid + Math.imul(ah1, bl6) | 0;
    hi = hi + Math.imul(ah1, bh6) | 0;
    lo = lo + Math.imul(al0, bl7) | 0;
    mid = mid + Math.imul(al0, bh7) | 0;
    mid = mid + Math.imul(ah0, bl7) | 0;
    hi = hi + Math.imul(ah0, bh7) | 0;
    var w7 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w7 >>> 26) | 0;
    w7 &= 0x3ffffff;
    /* k = 8 */
    lo = Math.imul(al8, bl0);
    mid = Math.imul(al8, bh0);
    mid = mid + Math.imul(ah8, bl0) | 0;
    hi = Math.imul(ah8, bh0);
    lo = lo + Math.imul(al7, bl1) | 0;
    mid = mid + Math.imul(al7, bh1) | 0;
    mid = mid + Math.imul(ah7, bl1) | 0;
    hi = hi + Math.imul(ah7, bh1) | 0;
    lo = lo + Math.imul(al6, bl2) | 0;
    mid = mid + Math.imul(al6, bh2) | 0;
    mid = mid + Math.imul(ah6, bl2) | 0;
    hi = hi + Math.imul(ah6, bh2) | 0;
    lo = lo + Math.imul(al5, bl3) | 0;
    mid = mid + Math.imul(al5, bh3) | 0;
    mid = mid + Math.imul(ah5, bl3) | 0;
    hi = hi + Math.imul(ah5, bh3) | 0;
    lo = lo + Math.imul(al4, bl4) | 0;
    mid = mid + Math.imul(al4, bh4) | 0;
    mid = mid + Math.imul(ah4, bl4) | 0;
    hi = hi + Math.imul(ah4, bh4) | 0;
    lo = lo + Math.imul(al3, bl5) | 0;
    mid = mid + Math.imul(al3, bh5) | 0;
    mid = mid + Math.imul(ah3, bl5) | 0;
    hi = hi + Math.imul(ah3, bh5) | 0;
    lo = lo + Math.imul(al2, bl6) | 0;
    mid = mid + Math.imul(al2, bh6) | 0;
    mid = mid + Math.imul(ah2, bl6) | 0;
    hi = hi + Math.imul(ah2, bh6) | 0;
    lo = lo + Math.imul(al1, bl7) | 0;
    mid = mid + Math.imul(al1, bh7) | 0;
    mid = mid + Math.imul(ah1, bl7) | 0;
    hi = hi + Math.imul(ah1, bh7) | 0;
    lo = lo + Math.imul(al0, bl8) | 0;
    mid = mid + Math.imul(al0, bh8) | 0;
    mid = mid + Math.imul(ah0, bl8) | 0;
    hi = hi + Math.imul(ah0, bh8) | 0;
    var w8 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w8 >>> 26) | 0;
    w8 &= 0x3ffffff;
    /* k = 9 */
    lo = Math.imul(al9, bl0);
    mid = Math.imul(al9, bh0);
    mid = mid + Math.imul(ah9, bl0) | 0;
    hi = Math.imul(ah9, bh0);
    lo = lo + Math.imul(al8, bl1) | 0;
    mid = mid + Math.imul(al8, bh1) | 0;
    mid = mid + Math.imul(ah8, bl1) | 0;
    hi = hi + Math.imul(ah8, bh1) | 0;
    lo = lo + Math.imul(al7, bl2) | 0;
    mid = mid + Math.imul(al7, bh2) | 0;
    mid = mid + Math.imul(ah7, bl2) | 0;
    hi = hi + Math.imul(ah7, bh2) | 0;
    lo = lo + Math.imul(al6, bl3) | 0;
    mid = mid + Math.imul(al6, bh3) | 0;
    mid = mid + Math.imul(ah6, bl3) | 0;
    hi = hi + Math.imul(ah6, bh3) | 0;
    lo = lo + Math.imul(al5, bl4) | 0;
    mid = mid + Math.imul(al5, bh4) | 0;
    mid = mid + Math.imul(ah5, bl4) | 0;
    hi = hi + Math.imul(ah5, bh4) | 0;
    lo = lo + Math.imul(al4, bl5) | 0;
    mid = mid + Math.imul(al4, bh5) | 0;
    mid = mid + Math.imul(ah4, bl5) | 0;
    hi = hi + Math.imul(ah4, bh5) | 0;
    lo = lo + Math.imul(al3, bl6) | 0;
    mid = mid + Math.imul(al3, bh6) | 0;
    mid = mid + Math.imul(ah3, bl6) | 0;
    hi = hi + Math.imul(ah3, bh6) | 0;
    lo = lo + Math.imul(al2, bl7) | 0;
    mid = mid + Math.imul(al2, bh7) | 0;
    mid = mid + Math.imul(ah2, bl7) | 0;
    hi = hi + Math.imul(ah2, bh7) | 0;
    lo = lo + Math.imul(al1, bl8) | 0;
    mid = mid + Math.imul(al1, bh8) | 0;
    mid = mid + Math.imul(ah1, bl8) | 0;
    hi = hi + Math.imul(ah1, bh8) | 0;
    lo = lo + Math.imul(al0, bl9) | 0;
    mid = mid + Math.imul(al0, bh9) | 0;
    mid = mid + Math.imul(ah0, bl9) | 0;
    hi = hi + Math.imul(ah0, bh9) | 0;
    var w9 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w9 >>> 26) | 0;
    w9 &= 0x3ffffff;
    /* k = 10 */
    lo = Math.imul(al9, bl1);
    mid = Math.imul(al9, bh1);
    mid = mid + Math.imul(ah9, bl1) | 0;
    hi = Math.imul(ah9, bh1);
    lo = lo + Math.imul(al8, bl2) | 0;
    mid = mid + Math.imul(al8, bh2) | 0;
    mid = mid + Math.imul(ah8, bl2) | 0;
    hi = hi + Math.imul(ah8, bh2) | 0;
    lo = lo + Math.imul(al7, bl3) | 0;
    mid = mid + Math.imul(al7, bh3) | 0;
    mid = mid + Math.imul(ah7, bl3) | 0;
    hi = hi + Math.imul(ah7, bh3) | 0;
    lo = lo + Math.imul(al6, bl4) | 0;
    mid = mid + Math.imul(al6, bh4) | 0;
    mid = mid + Math.imul(ah6, bl4) | 0;
    hi = hi + Math.imul(ah6, bh4) | 0;
    lo = lo + Math.imul(al5, bl5) | 0;
    mid = mid + Math.imul(al5, bh5) | 0;
    mid = mid + Math.imul(ah5, bl5) | 0;
    hi = hi + Math.imul(ah5, bh5) | 0;
    lo = lo + Math.imul(al4, bl6) | 0;
    mid = mid + Math.imul(al4, bh6) | 0;
    mid = mid + Math.imul(ah4, bl6) | 0;
    hi = hi + Math.imul(ah4, bh6) | 0;
    lo = lo + Math.imul(al3, bl7) | 0;
    mid = mid + Math.imul(al3, bh7) | 0;
    mid = mid + Math.imul(ah3, bl7) | 0;
    hi = hi + Math.imul(ah3, bh7) | 0;
    lo = lo + Math.imul(al2, bl8) | 0;
    mid = mid + Math.imul(al2, bh8) | 0;
    mid = mid + Math.imul(ah2, bl8) | 0;
    hi = hi + Math.imul(ah2, bh8) | 0;
    lo = lo + Math.imul(al1, bl9) | 0;
    mid = mid + Math.imul(al1, bh9) | 0;
    mid = mid + Math.imul(ah1, bl9) | 0;
    hi = hi + Math.imul(ah1, bh9) | 0;
    var w10 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w10 >>> 26) | 0;
    w10 &= 0x3ffffff;
    /* k = 11 */
    lo = Math.imul(al9, bl2);
    mid = Math.imul(al9, bh2);
    mid = mid + Math.imul(ah9, bl2) | 0;
    hi = Math.imul(ah9, bh2);
    lo = lo + Math.imul(al8, bl3) | 0;
    mid = mid + Math.imul(al8, bh3) | 0;
    mid = mid + Math.imul(ah8, bl3) | 0;
    hi = hi + Math.imul(ah8, bh3) | 0;
    lo = lo + Math.imul(al7, bl4) | 0;
    mid = mid + Math.imul(al7, bh4) | 0;
    mid = mid + Math.imul(ah7, bl4) | 0;
    hi = hi + Math.imul(ah7, bh4) | 0;
    lo = lo + Math.imul(al6, bl5) | 0;
    mid = mid + Math.imul(al6, bh5) | 0;
    mid = mid + Math.imul(ah6, bl5) | 0;
    hi = hi + Math.imul(ah6, bh5) | 0;
    lo = lo + Math.imul(al5, bl6) | 0;
    mid = mid + Math.imul(al5, bh6) | 0;
    mid = mid + Math.imul(ah5, bl6) | 0;
    hi = hi + Math.imul(ah5, bh6) | 0;
    lo = lo + Math.imul(al4, bl7) | 0;
    mid = mid + Math.imul(al4, bh7) | 0;
    mid = mid + Math.imul(ah4, bl7) | 0;
    hi = hi + Math.imul(ah4, bh7) | 0;
    lo = lo + Math.imul(al3, bl8) | 0;
    mid = mid + Math.imul(al3, bh8) | 0;
    mid = mid + Math.imul(ah3, bl8) | 0;
    hi = hi + Math.imul(ah3, bh8) | 0;
    lo = lo + Math.imul(al2, bl9) | 0;
    mid = mid + Math.imul(al2, bh9) | 0;
    mid = mid + Math.imul(ah2, bl9) | 0;
    hi = hi + Math.imul(ah2, bh9) | 0;
    var w11 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w11 >>> 26) | 0;
    w11 &= 0x3ffffff;
    /* k = 12 */
    lo = Math.imul(al9, bl3);
    mid = Math.imul(al9, bh3);
    mid = mid + Math.imul(ah9, bl3) | 0;
    hi = Math.imul(ah9, bh3);
    lo = lo + Math.imul(al8, bl4) | 0;
    mid = mid + Math.imul(al8, bh4) | 0;
    mid = mid + Math.imul(ah8, bl4) | 0;
    hi = hi + Math.imul(ah8, bh4) | 0;
    lo = lo + Math.imul(al7, bl5) | 0;
    mid = mid + Math.imul(al7, bh5) | 0;
    mid = mid + Math.imul(ah7, bl5) | 0;
    hi = hi + Math.imul(ah7, bh5) | 0;
    lo = lo + Math.imul(al6, bl6) | 0;
    mid = mid + Math.imul(al6, bh6) | 0;
    mid = mid + Math.imul(ah6, bl6) | 0;
    hi = hi + Math.imul(ah6, bh6) | 0;
    lo = lo + Math.imul(al5, bl7) | 0;
    mid = mid + Math.imul(al5, bh7) | 0;
    mid = mid + Math.imul(ah5, bl7) | 0;
    hi = hi + Math.imul(ah5, bh7) | 0;
    lo = lo + Math.imul(al4, bl8) | 0;
    mid = mid + Math.imul(al4, bh8) | 0;
    mid = mid + Math.imul(ah4, bl8) | 0;
    hi = hi + Math.imul(ah4, bh8) | 0;
    lo = lo + Math.imul(al3, bl9) | 0;
    mid = mid + Math.imul(al3, bh9) | 0;
    mid = mid + Math.imul(ah3, bl9) | 0;
    hi = hi + Math.imul(ah3, bh9) | 0;
    var w12 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w12 >>> 26) | 0;
    w12 &= 0x3ffffff;
    /* k = 13 */
    lo = Math.imul(al9, bl4);
    mid = Math.imul(al9, bh4);
    mid = mid + Math.imul(ah9, bl4) | 0;
    hi = Math.imul(ah9, bh4);
    lo = lo + Math.imul(al8, bl5) | 0;
    mid = mid + Math.imul(al8, bh5) | 0;
    mid = mid + Math.imul(ah8, bl5) | 0;
    hi = hi + Math.imul(ah8, bh5) | 0;
    lo = lo + Math.imul(al7, bl6) | 0;
    mid = mid + Math.imul(al7, bh6) | 0;
    mid = mid + Math.imul(ah7, bl6) | 0;
    hi = hi + Math.imul(ah7, bh6) | 0;
    lo = lo + Math.imul(al6, bl7) | 0;
    mid = mid + Math.imul(al6, bh7) | 0;
    mid = mid + Math.imul(ah6, bl7) | 0;
    hi = hi + Math.imul(ah6, bh7) | 0;
    lo = lo + Math.imul(al5, bl8) | 0;
    mid = mid + Math.imul(al5, bh8) | 0;
    mid = mid + Math.imul(ah5, bl8) | 0;
    hi = hi + Math.imul(ah5, bh8) | 0;
    lo = lo + Math.imul(al4, bl9) | 0;
    mid = mid + Math.imul(al4, bh9) | 0;
    mid = mid + Math.imul(ah4, bl9) | 0;
    hi = hi + Math.imul(ah4, bh9) | 0;
    var w13 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w13 >>> 26) | 0;
    w13 &= 0x3ffffff;
    /* k = 14 */
    lo = Math.imul(al9, bl5);
    mid = Math.imul(al9, bh5);
    mid = mid + Math.imul(ah9, bl5) | 0;
    hi = Math.imul(ah9, bh5);
    lo = lo + Math.imul(al8, bl6) | 0;
    mid = mid + Math.imul(al8, bh6) | 0;
    mid = mid + Math.imul(ah8, bl6) | 0;
    hi = hi + Math.imul(ah8, bh6) | 0;
    lo = lo + Math.imul(al7, bl7) | 0;
    mid = mid + Math.imul(al7, bh7) | 0;
    mid = mid + Math.imul(ah7, bl7) | 0;
    hi = hi + Math.imul(ah7, bh7) | 0;
    lo = lo + Math.imul(al6, bl8) | 0;
    mid = mid + Math.imul(al6, bh8) | 0;
    mid = mid + Math.imul(ah6, bl8) | 0;
    hi = hi + Math.imul(ah6, bh8) | 0;
    lo = lo + Math.imul(al5, bl9) | 0;
    mid = mid + Math.imul(al5, bh9) | 0;
    mid = mid + Math.imul(ah5, bl9) | 0;
    hi = hi + Math.imul(ah5, bh9) | 0;
    var w14 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w14 >>> 26) | 0;
    w14 &= 0x3ffffff;
    /* k = 15 */
    lo = Math.imul(al9, bl6);
    mid = Math.imul(al9, bh6);
    mid = mid + Math.imul(ah9, bl6) | 0;
    hi = Math.imul(ah9, bh6);
    lo = lo + Math.imul(al8, bl7) | 0;
    mid = mid + Math.imul(al8, bh7) | 0;
    mid = mid + Math.imul(ah8, bl7) | 0;
    hi = hi + Math.imul(ah8, bh7) | 0;
    lo = lo + Math.imul(al7, bl8) | 0;
    mid = mid + Math.imul(al7, bh8) | 0;
    mid = mid + Math.imul(ah7, bl8) | 0;
    hi = hi + Math.imul(ah7, bh8) | 0;
    lo = lo + Math.imul(al6, bl9) | 0;
    mid = mid + Math.imul(al6, bh9) | 0;
    mid = mid + Math.imul(ah6, bl9) | 0;
    hi = hi + Math.imul(ah6, bh9) | 0;
    var w15 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w15 >>> 26) | 0;
    w15 &= 0x3ffffff;
    /* k = 16 */
    lo = Math.imul(al9, bl7);
    mid = Math.imul(al9, bh7);
    mid = mid + Math.imul(ah9, bl7) | 0;
    hi = Math.imul(ah9, bh7);
    lo = lo + Math.imul(al8, bl8) | 0;
    mid = mid + Math.imul(al8, bh8) | 0;
    mid = mid + Math.imul(ah8, bl8) | 0;
    hi = hi + Math.imul(ah8, bh8) | 0;
    lo = lo + Math.imul(al7, bl9) | 0;
    mid = mid + Math.imul(al7, bh9) | 0;
    mid = mid + Math.imul(ah7, bl9) | 0;
    hi = hi + Math.imul(ah7, bh9) | 0;
    var w16 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w16 >>> 26) | 0;
    w16 &= 0x3ffffff;
    /* k = 17 */
    lo = Math.imul(al9, bl8);
    mid = Math.imul(al9, bh8);
    mid = mid + Math.imul(ah9, bl8) | 0;
    hi = Math.imul(ah9, bh8);
    lo = lo + Math.imul(al8, bl9) | 0;
    mid = mid + Math.imul(al8, bh9) | 0;
    mid = mid + Math.imul(ah8, bl9) | 0;
    hi = hi + Math.imul(ah8, bh9) | 0;
    var w17 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w17 >>> 26) | 0;
    w17 &= 0x3ffffff;
    /* k = 18 */
    lo = Math.imul(al9, bl9);
    mid = Math.imul(al9, bh9);
    mid = mid + Math.imul(ah9, bl9) | 0;
    hi = Math.imul(ah9, bh9);
    var w18 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w18 >>> 26) | 0;
    w18 &= 0x3ffffff;
    o[0] = w0;
    o[1] = w1;
    o[2] = w2;
    o[3] = w3;
    o[4] = w4;
    o[5] = w5;
    o[6] = w6;
    o[7] = w7;
    o[8] = w8;
    o[9] = w9;
    o[10] = w10;
    o[11] = w11;
    o[12] = w12;
    o[13] = w13;
    o[14] = w14;
    o[15] = w15;
    o[16] = w16;
    o[17] = w17;
    o[18] = w18;
    if (c !== 0) {
      o[19] = c;
      out.length++;
    }
    return out;
  };

  // Polyfill comb
  if (!Math.imul) {
    comb10MulTo = smallMulTo;
  }
  function bigMulTo(self, num, out) {
    out.negative = num.negative ^ self.negative;
    out.length = self.length + num.length;
    var carry = 0;
    var hncarry = 0;
    for (var k = 0; k < out.length - 1; k++) {
      // Sum all words with the same `i + j = k` and accumulate `ncarry`,
      // note that ncarry could be >= 0x3ffffff
      var ncarry = hncarry;
      hncarry = 0;
      var rword = carry & 0x3ffffff;
      var maxJ = Math.min(k, num.length - 1);
      for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {
        var i = k - j;
        var a = self.words[i] | 0;
        var b = num.words[j] | 0;
        var r = a * b;
        var lo = r & 0x3ffffff;
        ncarry = ncarry + (r / 0x4000000 | 0) | 0;
        lo = lo + rword | 0;
        rword = lo & 0x3ffffff;
        ncarry = ncarry + (lo >>> 26) | 0;
        hncarry += ncarry >>> 26;
        ncarry &= 0x3ffffff;
      }
      out.words[k] = rword;
      carry = ncarry;
      ncarry = hncarry;
    }
    if (carry !== 0) {
      out.words[k] = carry;
    } else {
      out.length--;
    }
    return out.strip();
  }
  function jumboMulTo(self, num, out) {
    var fftm = new FFTM();
    return fftm.mulp(self, num, out);
  }
  BN.prototype.mulTo = function mulTo(num, out) {
    var res;
    var len = this.length + num.length;
    if (this.length === 10 && num.length === 10) {
      res = comb10MulTo(this, num, out);
    } else if (len < 63) {
      res = smallMulTo(this, num, out);
    } else if (len < 1024) {
      res = bigMulTo(this, num, out);
    } else {
      res = jumboMulTo(this, num, out);
    }
    return res;
  };

  // Cooley-Tukey algorithm for FFT
  // slightly revisited to rely on looping instead of recursion

  function FFTM(x, y) {
    this.x = x;
    this.y = y;
  }
  FFTM.prototype.makeRBT = function makeRBT(N) {
    var t = new Array(N);
    var l = BN.prototype._countBits(N) - 1;
    for (var i = 0; i < N; i++) {
      t[i] = this.revBin(i, l, N);
    }
    return t;
  };

  // Returns binary-reversed representation of `x`
  FFTM.prototype.revBin = function revBin(x, l, N) {
    if (x === 0 || x === N - 1) return x;
    var rb = 0;
    for (var i = 0; i < l; i++) {
      rb |= (x & 1) << l - i - 1;
      x >>= 1;
    }
    return rb;
  };

  // Performs "tweedling" phase, therefore 'emulating'
  // behaviour of the recursive algorithm
  FFTM.prototype.permute = function permute(rbt, rws, iws, rtws, itws, N) {
    for (var i = 0; i < N; i++) {
      rtws[i] = rws[rbt[i]];
      itws[i] = iws[rbt[i]];
    }
  };
  FFTM.prototype.transform = function transform(rws, iws, rtws, itws, N, rbt) {
    this.permute(rbt, rws, iws, rtws, itws, N);
    for (var s = 1; s < N; s <<= 1) {
      var l = s << 1;
      var rtwdf = Math.cos(2 * Math.PI / l);
      var itwdf = Math.sin(2 * Math.PI / l);
      for (var p = 0; p < N; p += l) {
        var rtwdf_ = rtwdf;
        var itwdf_ = itwdf;
        for (var j = 0; j < s; j++) {
          var re = rtws[p + j];
          var ie = itws[p + j];
          var ro = rtws[p + j + s];
          var io = itws[p + j + s];
          var rx = rtwdf_ * ro - itwdf_ * io;
          io = rtwdf_ * io + itwdf_ * ro;
          ro = rx;
          rtws[p + j] = re + ro;
          itws[p + j] = ie + io;
          rtws[p + j + s] = re - ro;
          itws[p + j + s] = ie - io;

          /* jshint maxdepth : false */
          if (j !== l) {
            rx = rtwdf * rtwdf_ - itwdf * itwdf_;
            itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;
            rtwdf_ = rx;
          }
        }
      }
    }
  };
  FFTM.prototype.guessLen13b = function guessLen13b(n, m) {
    var N = Math.max(m, n) | 1;
    var odd = N & 1;
    var i = 0;
    for (N = N / 2 | 0; N; N = N >>> 1) {
      i++;
    }
    return 1 << i + 1 + odd;
  };
  FFTM.prototype.conjugate = function conjugate(rws, iws, N) {
    if (N <= 1) return;
    for (var i = 0; i < N / 2; i++) {
      var t = rws[i];
      rws[i] = rws[N - i - 1];
      rws[N - i - 1] = t;
      t = iws[i];
      iws[i] = -iws[N - i - 1];
      iws[N - i - 1] = -t;
    }
  };
  FFTM.prototype.normalize13b = function normalize13b(ws, N) {
    var carry = 0;
    for (var i = 0; i < N / 2; i++) {
      var w = Math.round(ws[2 * i + 1] / N) * 0x2000 + Math.round(ws[2 * i] / N) + carry;
      ws[i] = w & 0x3ffffff;
      if (w < 0x4000000) {
        carry = 0;
      } else {
        carry = w / 0x4000000 | 0;
      }
    }
    return ws;
  };
  FFTM.prototype.convert13b = function convert13b(ws, len, rws, N) {
    var carry = 0;
    for (var i = 0; i < len; i++) {
      carry = carry + (ws[i] | 0);
      rws[2 * i] = carry & 0x1fff;
      carry = carry >>> 13;
      rws[2 * i + 1] = carry & 0x1fff;
      carry = carry >>> 13;
    }

    // Pad with zeroes
    for (i = 2 * len; i < N; ++i) {
      rws[i] = 0;
    }
    assert(carry === 0);
    assert((carry & ~0x1fff) === 0);
  };
  FFTM.prototype.stub = function stub(N) {
    var ph = new Array(N);
    for (var i = 0; i < N; i++) {
      ph[i] = 0;
    }
    return ph;
  };
  FFTM.prototype.mulp = function mulp(x, y, out) {
    var N = 2 * this.guessLen13b(x.length, y.length);
    var rbt = this.makeRBT(N);
    var _ = this.stub(N);
    var rws = new Array(N);
    var rwst = new Array(N);
    var iwst = new Array(N);
    var nrws = new Array(N);
    var nrwst = new Array(N);
    var niwst = new Array(N);
    var rmws = out.words;
    rmws.length = N;
    this.convert13b(x.words, x.length, rws, N);
    this.convert13b(y.words, y.length, nrws, N);
    this.transform(rws, _, rwst, iwst, N, rbt);
    this.transform(nrws, _, nrwst, niwst, N, rbt);
    for (var i = 0; i < N; i++) {
      var rx = rwst[i] * nrwst[i] - iwst[i] * niwst[i];
      iwst[i] = rwst[i] * niwst[i] + iwst[i] * nrwst[i];
      rwst[i] = rx;
    }
    this.conjugate(rwst, iwst, N);
    this.transform(rwst, iwst, rmws, _, N, rbt);
    this.conjugate(rmws, _, N);
    this.normalize13b(rmws, N);
    out.negative = x.negative ^ y.negative;
    out.length = x.length + y.length;
    return out.strip();
  };

  // Multiply `this` by `num`
  BN.prototype.mul = function mul(num) {
    var out = new BN(null);
    out.words = new Array(this.length + num.length);
    return this.mulTo(num, out);
  };

  // Multiply employing FFT
  BN.prototype.mulf = function mulf(num) {
    var out = new BN(null);
    out.words = new Array(this.length + num.length);
    return jumboMulTo(this, num, out);
  };

  // In-place Multiplication
  BN.prototype.imul = function imul(num) {
    return this.clone().mulTo(num, this);
  };
  BN.prototype.imuln = function imuln(num) {
    assert(typeof num === 'number');
    assert(num < 0x4000000);

    // Carry
    var carry = 0;
    for (var i = 0; i < this.length; i++) {
      var w = (this.words[i] | 0) * num;
      var lo = (w & 0x3ffffff) + (carry & 0x3ffffff);
      carry >>= 26;
      carry += w / 0x4000000 | 0;
      // NOTE: lo is 27bit maximum
      carry += lo >>> 26;
      this.words[i] = lo & 0x3ffffff;
    }
    if (carry !== 0) {
      this.words[i] = carry;
      this.length++;
    }
    return this;
  };
  BN.prototype.muln = function muln(num) {
    return this.clone().imuln(num);
  };

  // `this` * `this`
  BN.prototype.sqr = function sqr() {
    return this.mul(this);
  };

  // `this` * `this` in-place
  BN.prototype.isqr = function isqr() {
    return this.imul(this.clone());
  };

  // Math.pow(`this`, `num`)
  BN.prototype.pow = function pow(num) {
    var w = toBitArray(num);
    if (w.length === 0) return new BN(1);

    // Skip leading zeroes
    var res = this;
    for (var i = 0; i < w.length; i++, res = res.sqr()) {
      if (w[i] !== 0) break;
    }
    if (++i < w.length) {
      for (var q = res.sqr(); i < w.length; i++, q = q.sqr()) {
        if (w[i] === 0) continue;
        res = res.mul(q);
      }
    }
    return res;
  };

  // Shift-left in-place
  BN.prototype.iushln = function iushln(bits) {
    assert(typeof bits === 'number' && bits >= 0);
    var r = bits % 26;
    var s = (bits - r) / 26;
    var carryMask = 0x3ffffff >>> 26 - r << 26 - r;
    var i;
    if (r !== 0) {
      var carry = 0;
      for (i = 0; i < this.length; i++) {
        var newCarry = this.words[i] & carryMask;
        var c = (this.words[i] | 0) - newCarry << r;
        this.words[i] = c | carry;
        carry = newCarry >>> 26 - r;
      }
      if (carry) {
        this.words[i] = carry;
        this.length++;
      }
    }
    if (s !== 0) {
      for (i = this.length - 1; i >= 0; i--) {
        this.words[i + s] = this.words[i];
      }
      for (i = 0; i < s; i++) {
        this.words[i] = 0;
      }
      this.length += s;
    }
    return this.strip();
  };
  BN.prototype.ishln = function ishln(bits) {
    // TODO(indutny): implement me
    assert(this.negative === 0);
    return this.iushln(bits);
  };

  // Shift-right in-place
  // NOTE: `hint` is a lowest bit before trailing zeroes
  // NOTE: if `extended` is present - it will be filled with destroyed bits
  BN.prototype.iushrn = function iushrn(bits, hint, extended) {
    assert(typeof bits === 'number' && bits >= 0);
    var h;
    if (hint) {
      h = (hint - hint % 26) / 26;
    } else {
      h = 0;
    }
    var r = bits % 26;
    var s = Math.min((bits - r) / 26, this.length);
    var mask = 0x3ffffff ^ 0x3ffffff >>> r << r;
    var maskedWords = extended;
    h -= s;
    h = Math.max(0, h);

    // Extended mode, copy masked part
    if (maskedWords) {
      for (var i = 0; i < s; i++) {
        maskedWords.words[i] = this.words[i];
      }
      maskedWords.length = s;
    }
    if (s === 0) {
      // No-op, we should not move anything at all
    } else if (this.length > s) {
      this.length -= s;
      for (i = 0; i < this.length; i++) {
        this.words[i] = this.words[i + s];
      }
    } else {
      this.words[0] = 0;
      this.length = 1;
    }
    var carry = 0;
    for (i = this.length - 1; i >= 0 && (carry !== 0 || i >= h); i--) {
      var word = this.words[i] | 0;
      this.words[i] = carry << 26 - r | word >>> r;
      carry = word & mask;
    }

    // Push carried bits as a mask
    if (maskedWords && carry !== 0) {
      maskedWords.words[maskedWords.length++] = carry;
    }
    if (this.length === 0) {
      this.words[0] = 0;
      this.length = 1;
    }
    return this.strip();
  };
  BN.prototype.ishrn = function ishrn(bits, hint, extended) {
    // TODO(indutny): implement me
    assert(this.negative === 0);
    return this.iushrn(bits, hint, extended);
  };

  // Shift-left
  BN.prototype.shln = function shln(bits) {
    return this.clone().ishln(bits);
  };
  BN.prototype.ushln = function ushln(bits) {
    return this.clone().iushln(bits);
  };

  // Shift-right
  BN.prototype.shrn = function shrn(bits) {
    return this.clone().ishrn(bits);
  };
  BN.prototype.ushrn = function ushrn(bits) {
    return this.clone().iushrn(bits);
  };

  // Test if n bit is set
  BN.prototype.testn = function testn(bit) {
    assert(typeof bit === 'number' && bit >= 0);
    var r = bit % 26;
    var s = (bit - r) / 26;
    var q = 1 << r;

    // Fast case: bit is much higher than all existing words
    if (this.length <= s) return false;

    // Check bit and return
    var w = this.words[s];
    return !!(w & q);
  };

  // Return only lowers bits of number (in-place)
  BN.prototype.imaskn = function imaskn(bits) {
    assert(typeof bits === 'number' && bits >= 0);
    var r = bits % 26;
    var s = (bits - r) / 26;
    assert(this.negative === 0, 'imaskn works only with positive numbers');
    if (this.length <= s) {
      return this;
    }
    if (r !== 0) {
      s++;
    }
    this.length = Math.min(s, this.length);
    if (r !== 0) {
      var mask = 0x3ffffff ^ 0x3ffffff >>> r << r;
      this.words[this.length - 1] &= mask;
    }
    return this.strip();
  };

  // Return only lowers bits of number
  BN.prototype.maskn = function maskn(bits) {
    return this.clone().imaskn(bits);
  };

  // Add plain number `num` to `this`
  BN.prototype.iaddn = function iaddn(num) {
    assert(typeof num === 'number');
    assert(num < 0x4000000);
    if (num < 0) return this.isubn(-num);

    // Possible sign change
    if (this.negative !== 0) {
      if (this.length === 1 && (this.words[0] | 0) < num) {
        this.words[0] = num - (this.words[0] | 0);
        this.negative = 0;
        return this;
      }
      this.negative = 0;
      this.isubn(num);
      this.negative = 1;
      return this;
    }

    // Add without checks
    return this._iaddn(num);
  };
  BN.prototype._iaddn = function _iaddn(num) {
    this.words[0] += num;

    // Carry
    for (var i = 0; i < this.length && this.words[i] >= 0x4000000; i++) {
      this.words[i] -= 0x4000000;
      if (i === this.length - 1) {
        this.words[i + 1] = 1;
      } else {
        this.words[i + 1]++;
      }
    }
    this.length = Math.max(this.length, i + 1);
    return this;
  };

  // Subtract plain number `num` from `this`
  BN.prototype.isubn = function isubn(num) {
    assert(typeof num === 'number');
    assert(num < 0x4000000);
    if (num < 0) return this.iaddn(-num);
    if (this.negative !== 0) {
      this.negative = 0;
      this.iaddn(num);
      this.negative = 1;
      return this;
    }
    this.words[0] -= num;
    if (this.length === 1 && this.words[0] < 0) {
      this.words[0] = -this.words[0];
      this.negative = 1;
    } else {
      // Carry
      for (var i = 0; i < this.length && this.words[i] < 0; i++) {
        this.words[i] += 0x4000000;
        this.words[i + 1] -= 1;
      }
    }
    return this.strip();
  };
  BN.prototype.addn = function addn(num) {
    return this.clone().iaddn(num);
  };
  BN.prototype.subn = function subn(num) {
    return this.clone().isubn(num);
  };
  BN.prototype.iabs = function iabs() {
    this.negative = 0;
    return this;
  };
  BN.prototype.abs = function abs() {
    return this.clone().iabs();
  };
  BN.prototype._ishlnsubmul = function _ishlnsubmul(num, mul, shift) {
    var len = num.length + shift;
    var i;
    this._expand(len);
    var w;
    var carry = 0;
    for (i = 0; i < num.length; i++) {
      w = (this.words[i + shift] | 0) + carry;
      var right = (num.words[i] | 0) * mul;
      w -= right & 0x3ffffff;
      carry = (w >> 26) - (right / 0x4000000 | 0);
      this.words[i + shift] = w & 0x3ffffff;
    }
    for (; i < this.length - shift; i++) {
      w = (this.words[i + shift] | 0) + carry;
      carry = w >> 26;
      this.words[i + shift] = w & 0x3ffffff;
    }
    if (carry === 0) return this.strip();

    // Subtraction overflow
    assert(carry === -1);
    carry = 0;
    for (i = 0; i < this.length; i++) {
      w = -(this.words[i] | 0) + carry;
      carry = w >> 26;
      this.words[i] = w & 0x3ffffff;
    }
    this.negative = 1;
    return this.strip();
  };
  BN.prototype._wordDiv = function _wordDiv(num, mode) {
    var shift = this.length - num.length;
    var a = this.clone();
    var b = num;

    // Normalize
    var bhi = b.words[b.length - 1] | 0;
    var bhiBits = this._countBits(bhi);
    shift = 26 - bhiBits;
    if (shift !== 0) {
      b = b.ushln(shift);
      a.iushln(shift);
      bhi = b.words[b.length - 1] | 0;
    }

    // Initialize quotient
    var m = a.length - b.length;
    var q;
    if (mode !== 'mod') {
      q = new BN(null);
      q.length = m + 1;
      q.words = new Array(q.length);
      for (var i = 0; i < q.length; i++) {
        q.words[i] = 0;
      }
    }
    var diff = a.clone()._ishlnsubmul(b, 1, m);
    if (diff.negative === 0) {
      a = diff;
      if (q) {
        q.words[m] = 1;
      }
    }
    for (var j = m - 1; j >= 0; j--) {
      var qj = (a.words[b.length + j] | 0) * 0x4000000 + (a.words[b.length + j - 1] | 0);

      // NOTE: (qj / bhi) is (0x3ffffff * 0x4000000 + 0x3ffffff) / 0x2000000 max
      // (0x7ffffff)
      qj = Math.min(qj / bhi | 0, 0x3ffffff);
      a._ishlnsubmul(b, qj, j);
      while (a.negative !== 0) {
        qj--;
        a.negative = 0;
        a._ishlnsubmul(b, 1, j);
        if (!a.isZero()) {
          a.negative ^= 1;
        }
      }
      if (q) {
        q.words[j] = qj;
      }
    }
    if (q) {
      q.strip();
    }
    a.strip();

    // Denormalize
    if (mode !== 'div' && shift !== 0) {
      a.iushrn(shift);
    }
    return {
      div: q || null,
      mod: a
    };
  };

  // NOTE: 1) `mode` can be set to `mod` to request mod only,
  //       to `div` to request div only, or be absent to
  //       request both div & mod
  //       2) `positive` is true if unsigned mod is requested
  BN.prototype.divmod = function divmod(num, mode, positive) {
    assert(!num.isZero());
    if (this.isZero()) {
      return {
        div: new BN(0),
        mod: new BN(0)
      };
    }
    var div, mod, res;
    if (this.negative !== 0 && num.negative === 0) {
      res = this.neg().divmod(num, mode);
      if (mode !== 'mod') {
        div = res.div.neg();
      }
      if (mode !== 'div') {
        mod = res.mod.neg();
        if (positive && mod.negative !== 0) {
          mod.iadd(num);
        }
      }
      return {
        div: div,
        mod: mod
      };
    }
    if (this.negative === 0 && num.negative !== 0) {
      res = this.divmod(num.neg(), mode);
      if (mode !== 'mod') {
        div = res.div.neg();
      }
      return {
        div: div,
        mod: res.mod
      };
    }
    if ((this.negative & num.negative) !== 0) {
      res = this.neg().divmod(num.neg(), mode);
      if (mode !== 'div') {
        mod = res.mod.neg();
        if (positive && mod.negative !== 0) {
          mod.isub(num);
        }
      }
      return {
        div: res.div,
        mod: mod
      };
    }

    // Both numbers are positive at this point

    // Strip both numbers to approximate shift value
    if (num.length > this.length || this.cmp(num) < 0) {
      return {
        div: new BN(0),
        mod: this
      };
    }

    // Very short reduction
    if (num.length === 1) {
      if (mode === 'div') {
        return {
          div: this.divn(num.words[0]),
          mod: null
        };
      }
      if (mode === 'mod') {
        return {
          div: null,
          mod: new BN(this.modn(num.words[0]))
        };
      }
      return {
        div: this.divn(num.words[0]),
        mod: new BN(this.modn(num.words[0]))
      };
    }
    return this._wordDiv(num, mode);
  };

  // Find `this` / `num`
  BN.prototype.div = function div(num) {
    return this.divmod(num, 'div', false).div;
  };

  // Find `this` % `num`
  BN.prototype.mod = function mod(num) {
    return this.divmod(num, 'mod', false).mod;
  };
  BN.prototype.umod = function umod(num) {
    return this.divmod(num, 'mod', true).mod;
  };

  // Find Round(`this` / `num`)
  BN.prototype.divRound = function divRound(num) {
    var dm = this.divmod(num);

    // Fast case - exact division
    if (dm.mod.isZero()) return dm.div;
    var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
    var half = num.ushrn(1);
    var r2 = num.andln(1);
    var cmp = mod.cmp(half);

    // Round down
    if (cmp < 0 || r2 === 1 && cmp === 0) return dm.div;

    // Round up
    return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
  };
  BN.prototype.modn = function modn(num) {
    assert(num <= 0x3ffffff);
    var p = (1 << 26) % num;
    var acc = 0;
    for (var i = this.length - 1; i >= 0; i--) {
      acc = (p * acc + (this.words[i] | 0)) % num;
    }
    return acc;
  };

  // In-place division by number
  BN.prototype.idivn = function idivn(num) {
    assert(num <= 0x3ffffff);
    var carry = 0;
    for (var i = this.length - 1; i >= 0; i--) {
      var w = (this.words[i] | 0) + carry * 0x4000000;
      this.words[i] = w / num | 0;
      carry = w % num;
    }
    return this.strip();
  };
  BN.prototype.divn = function divn(num) {
    return this.clone().idivn(num);
  };
  BN.prototype.egcd = function egcd(p) {
    assert(p.negative === 0);
    assert(!p.isZero());
    var x = this;
    var y = p.clone();
    if (x.negative !== 0) {
      x = x.umod(p);
    } else {
      x = x.clone();
    }

    // A * x + B * y = x
    var A = new BN(1);
    var B = new BN(0);

    // C * x + D * y = y
    var C = new BN(0);
    var D = new BN(1);
    var g = 0;
    while (x.isEven() && y.isEven()) {
      x.iushrn(1);
      y.iushrn(1);
      ++g;
    }
    var yp = y.clone();
    var xp = x.clone();
    while (!x.isZero()) {
      for (var i = 0, im = 1; (x.words[0] & im) === 0 && i < 26; ++i, im <<= 1);
      if (i > 0) {
        x.iushrn(i);
        while (i-- > 0) {
          if (A.isOdd() || B.isOdd()) {
            A.iadd(yp);
            B.isub(xp);
          }
          A.iushrn(1);
          B.iushrn(1);
        }
      }
      for (var j = 0, jm = 1; (y.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);
      if (j > 0) {
        y.iushrn(j);
        while (j-- > 0) {
          if (C.isOdd() || D.isOdd()) {
            C.iadd(yp);
            D.isub(xp);
          }
          C.iushrn(1);
          D.iushrn(1);
        }
      }
      if (x.cmp(y) >= 0) {
        x.isub(y);
        A.isub(C);
        B.isub(D);
      } else {
        y.isub(x);
        C.isub(A);
        D.isub(B);
      }
    }
    return {
      a: C,
      b: D,
      gcd: y.iushln(g)
    };
  };

  // This is reduced incarnation of the binary EEA
  // above, designated to invert members of the
  // _prime_ fields F(p) at a maximal speed
  BN.prototype._invmp = function _invmp(p) {
    assert(p.negative === 0);
    assert(!p.isZero());
    var a = this;
    var b = p.clone();
    if (a.negative !== 0) {
      a = a.umod(p);
    } else {
      a = a.clone();
    }
    var x1 = new BN(1);
    var x2 = new BN(0);
    var delta = b.clone();
    while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {
      for (var i = 0, im = 1; (a.words[0] & im) === 0 && i < 26; ++i, im <<= 1);
      if (i > 0) {
        a.iushrn(i);
        while (i-- > 0) {
          if (x1.isOdd()) {
            x1.iadd(delta);
          }
          x1.iushrn(1);
        }
      }
      for (var j = 0, jm = 1; (b.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);
      if (j > 0) {
        b.iushrn(j);
        while (j-- > 0) {
          if (x2.isOdd()) {
            x2.iadd(delta);
          }
          x2.iushrn(1);
        }
      }
      if (a.cmp(b) >= 0) {
        a.isub(b);
        x1.isub(x2);
      } else {
        b.isub(a);
        x2.isub(x1);
      }
    }
    var res;
    if (a.cmpn(1) === 0) {
      res = x1;
    } else {
      res = x2;
    }
    if (res.cmpn(0) < 0) {
      res.iadd(p);
    }
    return res;
  };
  BN.prototype.gcd = function gcd(num) {
    if (this.isZero()) return num.abs();
    if (num.isZero()) return this.abs();
    var a = this.clone();
    var b = num.clone();
    a.negative = 0;
    b.negative = 0;

    // Remove common factor of two
    for (var shift = 0; a.isEven() && b.isEven(); shift++) {
      a.iushrn(1);
      b.iushrn(1);
    }
    do {
      while (a.isEven()) {
        a.iushrn(1);
      }
      while (b.isEven()) {
        b.iushrn(1);
      }
      var r = a.cmp(b);
      if (r < 0) {
        // Swap `a` and `b` to make `a` always bigger than `b`
        var t = a;
        a = b;
        b = t;
      } else if (r === 0 || b.cmpn(1) === 0) {
        break;
      }
      a.isub(b);
    } while (true);
    return b.iushln(shift);
  };

  // Invert number in the field F(num)
  BN.prototype.invm = function invm(num) {
    return this.egcd(num).a.umod(num);
  };
  BN.prototype.isEven = function isEven() {
    return (this.words[0] & 1) === 0;
  };
  BN.prototype.isOdd = function isOdd() {
    return (this.words[0] & 1) === 1;
  };

  // And first word and num
  BN.prototype.andln = function andln(num) {
    return this.words[0] & num;
  };

  // Increment at the bit position in-line
  BN.prototype.bincn = function bincn(bit) {
    assert(typeof bit === 'number');
    var r = bit % 26;
    var s = (bit - r) / 26;
    var q = 1 << r;

    // Fast case: bit is much higher than all existing words
    if (this.length <= s) {
      this._expand(s + 1);
      this.words[s] |= q;
      return this;
    }

    // Add bit and propagate, if needed
    var carry = q;
    for (var i = s; carry !== 0 && i < this.length; i++) {
      var w = this.words[i] | 0;
      w += carry;
      carry = w >>> 26;
      w &= 0x3ffffff;
      this.words[i] = w;
    }
    if (carry !== 0) {
      this.words[i] = carry;
      this.length++;
    }
    return this;
  };
  BN.prototype.isZero = function isZero() {
    return this.length === 1 && this.words[0] === 0;
  };
  BN.prototype.cmpn = function cmpn(num) {
    var negative = num < 0;
    if (this.negative !== 0 && !negative) return -1;
    if (this.negative === 0 && negative) return 1;
    this.strip();
    var res;
    if (this.length > 1) {
      res = 1;
    } else {
      if (negative) {
        num = -num;
      }
      assert(num <= 0x3ffffff, 'Number is too big');
      var w = this.words[0] | 0;
      res = w === num ? 0 : w < num ? -1 : 1;
    }
    if (this.negative !== 0) return -res | 0;
    return res;
  };

  // Compare two numbers and return:
  // 1 - if `this` > `num`
  // 0 - if `this` == `num`
  // -1 - if `this` < `num`
  BN.prototype.cmp = function cmp(num) {
    if (this.negative !== 0 && num.negative === 0) return -1;
    if (this.negative === 0 && num.negative !== 0) return 1;
    var res = this.ucmp(num);
    if (this.negative !== 0) return -res | 0;
    return res;
  };

  // Unsigned comparison
  BN.prototype.ucmp = function ucmp(num) {
    // At this point both numbers have the same sign
    if (this.length > num.length) return 1;
    if (this.length < num.length) return -1;
    var res = 0;
    for (var i = this.length - 1; i >= 0; i--) {
      var a = this.words[i] | 0;
      var b = num.words[i] | 0;
      if (a === b) continue;
      if (a < b) {
        res = -1;
      } else if (a > b) {
        res = 1;
      }
      break;
    }
    return res;
  };
  BN.prototype.gtn = function gtn(num) {
    return this.cmpn(num) === 1;
  };
  BN.prototype.gt = function gt(num) {
    return this.cmp(num) === 1;
  };
  BN.prototype.gten = function gten(num) {
    return this.cmpn(num) >= 0;
  };
  BN.prototype.gte = function gte(num) {
    return this.cmp(num) >= 0;
  };
  BN.prototype.ltn = function ltn(num) {
    return this.cmpn(num) === -1;
  };
  BN.prototype.lt = function lt(num) {
    return this.cmp(num) === -1;
  };
  BN.prototype.lten = function lten(num) {
    return this.cmpn(num) <= 0;
  };
  BN.prototype.lte = function lte(num) {
    return this.cmp(num) <= 0;
  };
  BN.prototype.eqn = function eqn(num) {
    return this.cmpn(num) === 0;
  };
  BN.prototype.eq = function eq(num) {
    return this.cmp(num) === 0;
  };

  //
  // A reduce context, could be using montgomery or something better, depending
  // on the `m` itself.
  //
  BN.red = function red(num) {
    return new Red(num);
  };
  BN.prototype.toRed = function toRed(ctx) {
    assert(!this.red, 'Already a number in reduction context');
    assert(this.negative === 0, 'red works only with positives');
    return ctx.convertTo(this)._forceRed(ctx);
  };
  BN.prototype.fromRed = function fromRed() {
    assert(this.red, 'fromRed works only with numbers in reduction context');
    return this.red.convertFrom(this);
  };
  BN.prototype._forceRed = function _forceRed(ctx) {
    this.red = ctx;
    return this;
  };
  BN.prototype.forceRed = function forceRed(ctx) {
    assert(!this.red, 'Already a number in reduction context');
    return this._forceRed(ctx);
  };
  BN.prototype.redAdd = function redAdd(num) {
    assert(this.red, 'redAdd works only with red numbers');
    return this.red.add(this, num);
  };
  BN.prototype.redIAdd = function redIAdd(num) {
    assert(this.red, 'redIAdd works only with red numbers');
    return this.red.iadd(this, num);
  };
  BN.prototype.redSub = function redSub(num) {
    assert(this.red, 'redSub works only with red numbers');
    return this.red.sub(this, num);
  };
  BN.prototype.redISub = function redISub(num) {
    assert(this.red, 'redISub works only with red numbers');
    return this.red.isub(this, num);
  };
  BN.prototype.redShl = function redShl(num) {
    assert(this.red, 'redShl works only with red numbers');
    return this.red.shl(this, num);
  };
  BN.prototype.redMul = function redMul(num) {
    assert(this.red, 'redMul works only with red numbers');
    this.red._verify2(this, num);
    return this.red.mul(this, num);
  };
  BN.prototype.redIMul = function redIMul(num) {
    assert(this.red, 'redMul works only with red numbers');
    this.red._verify2(this, num);
    return this.red.imul(this, num);
  };
  BN.prototype.redSqr = function redSqr() {
    assert(this.red, 'redSqr works only with red numbers');
    this.red._verify1(this);
    return this.red.sqr(this);
  };
  BN.prototype.redISqr = function redISqr() {
    assert(this.red, 'redISqr works only with red numbers');
    this.red._verify1(this);
    return this.red.isqr(this);
  };

  // Square root over p
  BN.prototype.redSqrt = function redSqrt() {
    assert(this.red, 'redSqrt works only with red numbers');
    this.red._verify1(this);
    return this.red.sqrt(this);
  };
  BN.prototype.redInvm = function redInvm() {
    assert(this.red, 'redInvm works only with red numbers');
    this.red._verify1(this);
    return this.red.invm(this);
  };

  // Return negative clone of `this` % `red modulo`
  BN.prototype.redNeg = function redNeg() {
    assert(this.red, 'redNeg works only with red numbers');
    this.red._verify1(this);
    return this.red.neg(this);
  };
  BN.prototype.redPow = function redPow(num) {
    assert(this.red && !num.red, 'redPow(normalNum)');
    this.red._verify1(this);
    return this.red.pow(this, num);
  };

  // Prime numbers with efficient reduction
  var primes = {
    k256: null,
    p224: null,
    p192: null,
    p25519: null
  };

  // Pseudo-Mersenne prime
  function MPrime(name, p) {
    // P = 2 ^ N - K
    this.name = name;
    this.p = new BN(p, 16);
    this.n = this.p.bitLength();
    this.k = new BN(1).iushln(this.n).isub(this.p);
    this.tmp = this._tmp();
  }
  MPrime.prototype._tmp = function _tmp() {
    var tmp = new BN(null);
    tmp.words = new Array(Math.ceil(this.n / 13));
    return tmp;
  };
  MPrime.prototype.ireduce = function ireduce(num) {
    // Assumes that `num` is less than `P^2`
    // num = HI * (2 ^ N - K) + HI * K + LO = HI * K + LO (mod P)
    var r = num;
    var rlen;
    do {
      this.split(r, this.tmp);
      r = this.imulK(r);
      r = r.iadd(this.tmp);
      rlen = r.bitLength();
    } while (rlen > this.n);
    var cmp = rlen < this.n ? -1 : r.ucmp(this.p);
    if (cmp === 0) {
      r.words[0] = 0;
      r.length = 1;
    } else if (cmp > 0) {
      r.isub(this.p);
    } else {
      if (r.strip !== undefined) {
        // r is BN v4 instance
        r.strip();
      } else {
        // r is BN v5 instance
        r._strip();
      }
    }
    return r;
  };
  MPrime.prototype.split = function split(input, out) {
    input.iushrn(this.n, 0, out);
  };
  MPrime.prototype.imulK = function imulK(num) {
    return num.imul(this.k);
  };
  function K256() {
    MPrime.call(this, 'k256', 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f');
  }
  inherits(K256, MPrime);
  K256.prototype.split = function split(input, output) {
    // 256 = 9 * 26 + 22
    var mask = 0x3fffff;
    var outLen = Math.min(input.length, 9);
    for (var i = 0; i < outLen; i++) {
      output.words[i] = input.words[i];
    }
    output.length = outLen;
    if (input.length <= 9) {
      input.words[0] = 0;
      input.length = 1;
      return;
    }

    // Shift by 9 limbs
    var prev = input.words[9];
    output.words[output.length++] = prev & mask;
    for (i = 10; i < input.length; i++) {
      var next = input.words[i] | 0;
      input.words[i - 10] = (next & mask) << 4 | prev >>> 22;
      prev = next;
    }
    prev >>>= 22;
    input.words[i - 10] = prev;
    if (prev === 0 && input.length > 10) {
      input.length -= 10;
    } else {
      input.length -= 9;
    }
  };
  K256.prototype.imulK = function imulK(num) {
    // K = 0x1000003d1 = [ 0x40, 0x3d1 ]
    num.words[num.length] = 0;
    num.words[num.length + 1] = 0;
    num.length += 2;

    // bounded at: 0x40 * 0x3ffffff + 0x3d0 = 0x100000390
    var lo = 0;
    for (var i = 0; i < num.length; i++) {
      var w = num.words[i] | 0;
      lo += w * 0x3d1;
      num.words[i] = lo & 0x3ffffff;
      lo = w * 0x40 + (lo / 0x4000000 | 0);
    }

    // Fast length reduction
    if (num.words[num.length - 1] === 0) {
      num.length--;
      if (num.words[num.length - 1] === 0) {
        num.length--;
      }
    }
    return num;
  };
  function P224() {
    MPrime.call(this, 'p224', 'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001');
  }
  inherits(P224, MPrime);
  function P192() {
    MPrime.call(this, 'p192', 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff');
  }
  inherits(P192, MPrime);
  function P25519() {
    // 2 ^ 255 - 19
    MPrime.call(this, '25519', '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed');
  }
  inherits(P25519, MPrime);
  P25519.prototype.imulK = function imulK(num) {
    // K = 0x13
    var carry = 0;
    for (var i = 0; i < num.length; i++) {
      var hi = (num.words[i] | 0) * 0x13 + carry;
      var lo = hi & 0x3ffffff;
      hi >>>= 26;
      num.words[i] = lo;
      carry = hi;
    }
    if (carry !== 0) {
      num.words[num.length++] = carry;
    }
    return num;
  };

  // Exported mostly for testing purposes, use plain name instead
  BN._prime = function prime(name) {
    // Cached version of prime
    if (primes[name]) return primes[name];
    var prime;
    if (name === 'k256') {
      prime = new K256();
    } else if (name === 'p224') {
      prime = new P224();
    } else if (name === 'p192') {
      prime = new P192();
    } else if (name === 'p25519') {
      prime = new P25519();
    } else {
      throw new Error('Unknown prime ' + name);
    }
    primes[name] = prime;
    return prime;
  };

  //
  // Base reduction engine
  //
  function Red(m) {
    if (typeof m === 'string') {
      var prime = BN._prime(m);
      this.m = prime.p;
      this.prime = prime;
    } else {
      assert(m.gtn(1), 'modulus must be greater than 1');
      this.m = m;
      this.prime = null;
    }
  }
  Red.prototype._verify1 = function _verify1(a) {
    assert(a.negative === 0, 'red works only with positives');
    assert(a.red, 'red works only with red numbers');
  };
  Red.prototype._verify2 = function _verify2(a, b) {
    assert((a.negative | b.negative) === 0, 'red works only with positives');
    assert(a.red && a.red === b.red, 'red works only with red numbers');
  };
  Red.prototype.imod = function imod(a) {
    if (this.prime) return this.prime.ireduce(a)._forceRed(this);
    return a.umod(this.m)._forceRed(this);
  };
  Red.prototype.neg = function neg(a) {
    if (a.isZero()) {
      return a.clone();
    }
    return this.m.sub(a)._forceRed(this);
  };
  Red.prototype.add = function add(a, b) {
    this._verify2(a, b);
    var res = a.add(b);
    if (res.cmp(this.m) >= 0) {
      res.isub(this.m);
    }
    return res._forceRed(this);
  };
  Red.prototype.iadd = function iadd(a, b) {
    this._verify2(a, b);
    var res = a.iadd(b);
    if (res.cmp(this.m) >= 0) {
      res.isub(this.m);
    }
    return res;
  };
  Red.prototype.sub = function sub(a, b) {
    this._verify2(a, b);
    var res = a.sub(b);
    if (res.cmpn(0) < 0) {
      res.iadd(this.m);
    }
    return res._forceRed(this);
  };
  Red.prototype.isub = function isub(a, b) {
    this._verify2(a, b);
    var res = a.isub(b);
    if (res.cmpn(0) < 0) {
      res.iadd(this.m);
    }
    return res;
  };
  Red.prototype.shl = function shl(a, num) {
    this._verify1(a);
    return this.imod(a.ushln(num));
  };
  Red.prototype.imul = function imul(a, b) {
    this._verify2(a, b);
    return this.imod(a.imul(b));
  };
  Red.prototype.mul = function mul(a, b) {
    this._verify2(a, b);
    return this.imod(a.mul(b));
  };
  Red.prototype.isqr = function isqr(a) {
    return this.imul(a, a.clone());
  };
  Red.prototype.sqr = function sqr(a) {
    return this.mul(a, a);
  };
  Red.prototype.sqrt = function sqrt(a) {
    if (a.isZero()) return a.clone();
    var mod3 = this.m.andln(3);
    assert(mod3 % 2 === 1);

    // Fast case
    if (mod3 === 3) {
      var pow = this.m.add(new BN(1)).iushrn(2);
      return this.pow(a, pow);
    }

    // Tonelli-Shanks algorithm (Totally unoptimized and slow)
    //
    // Find Q and S, that Q * 2 ^ S = (P - 1)
    var q = this.m.subn(1);
    var s = 0;
    while (!q.isZero() && q.andln(1) === 0) {
      s++;
      q.iushrn(1);
    }
    assert(!q.isZero());
    var one = new BN(1).toRed(this);
    var nOne = one.redNeg();

    // Find quadratic non-residue
    // NOTE: Max is such because of generalized Riemann hypothesis.
    var lpow = this.m.subn(1).iushrn(1);
    var z = this.m.bitLength();
    z = new BN(2 * z * z).toRed(this);
    while (this.pow(z, lpow).cmp(nOne) !== 0) {
      z.redIAdd(nOne);
    }
    var c = this.pow(z, q);
    var r = this.pow(a, q.addn(1).iushrn(1));
    var t = this.pow(a, q);
    var m = s;
    while (t.cmp(one) !== 0) {
      var tmp = t;
      for (var i = 0; tmp.cmp(one) !== 0; i++) {
        tmp = tmp.redSqr();
      }
      assert(i < m);
      var b = this.pow(c, new BN(1).iushln(m - i - 1));
      r = r.redMul(b);
      c = b.redSqr();
      t = t.redMul(c);
      m = i;
    }
    return r;
  };
  Red.prototype.invm = function invm(a) {
    var inv = a._invmp(this.m);
    if (inv.negative !== 0) {
      inv.negative = 0;
      return this.imod(inv).redNeg();
    } else {
      return this.imod(inv);
    }
  };
  Red.prototype.pow = function pow(a, num) {
    if (num.isZero()) return new BN(1).toRed(this);
    if (num.cmpn(1) === 0) return a.clone();
    var windowSize = 4;
    var wnd = new Array(1 << windowSize);
    wnd[0] = new BN(1).toRed(this);
    wnd[1] = a;
    for (var i = 2; i < wnd.length; i++) {
      wnd[i] = this.mul(wnd[i - 1], a);
    }
    var res = wnd[0];
    var current = 0;
    var currentLen = 0;
    var start = num.bitLength() % 26;
    if (start === 0) {
      start = 26;
    }
    for (i = num.length - 1; i >= 0; i--) {
      var word = num.words[i];
      for (var j = start - 1; j >= 0; j--) {
        var bit = word >> j & 1;
        if (res !== wnd[0]) {
          res = this.sqr(res);
        }
        if (bit === 0 && current === 0) {
          currentLen = 0;
          continue;
        }
        current <<= 1;
        current |= bit;
        currentLen++;
        if (currentLen !== windowSize && (i !== 0 || j !== 0)) continue;
        res = this.mul(res, wnd[current]);
        currentLen = 0;
        current = 0;
      }
      start = 26;
    }
    return res;
  };
  Red.prototype.convertTo = function convertTo(num) {
    var r = num.umod(this.m);
    return r === num ? r.clone() : r;
  };
  Red.prototype.convertFrom = function convertFrom(num) {
    var res = num.clone();
    res.red = null;
    return res;
  };

  //
  // Montgomery method engine
  //

  BN.mont = function mont(num) {
    return new Mont(num);
  };
  function Mont(m) {
    Red.call(this, m);
    this.shift = this.m.bitLength();
    if (this.shift % 26 !== 0) {
      this.shift += 26 - this.shift % 26;
    }
    this.r = new BN(1).iushln(this.shift);
    this.r2 = this.imod(this.r.sqr());
    this.rinv = this.r._invmp(this.m);
    this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);
    this.minv = this.minv.umod(this.r);
    this.minv = this.r.sub(this.minv);
  }
  inherits(Mont, Red);
  Mont.prototype.convertTo = function convertTo(num) {
    return this.imod(num.ushln(this.shift));
  };
  Mont.prototype.convertFrom = function convertFrom(num) {
    var r = this.imod(num.mul(this.rinv));
    r.red = null;
    return r;
  };
  Mont.prototype.imul = function imul(a, b) {
    if (a.isZero() || b.isZero()) {
      a.words[0] = 0;
      a.length = 1;
      return a;
    }
    var t = a.imul(b);
    var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
    var u = t.isub(c).iushrn(this.shift);
    var res = u;
    if (u.cmp(this.m) >= 0) {
      res = u.isub(this.m);
    } else if (u.cmpn(0) < 0) {
      res = u.iadd(this.m);
    }
    return res._forceRed(this);
  };
  Mont.prototype.mul = function mul(a, b) {
    if (a.isZero() || b.isZero()) return new BN(0)._forceRed(this);
    var t = a.mul(b);
    var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
    var u = t.isub(c).iushrn(this.shift);
    var res = u;
    if (u.cmp(this.m) >= 0) {
      res = u.isub(this.m);
    } else if (u.cmpn(0) < 0) {
      res = u.iadd(this.m);
    }
    return res._forceRed(this);
  };
  Mont.prototype.invm = function invm(a) {
    // (AR)^-1 * R^2 = (A^-1 * R^-1) * R^2 = A^-1 * R
    var res = this.imod(a._invmp(this.m).mul(this.r2));
    return res._forceRed(this);
  };
})( false || module, this);

/***/ }),

/***/ 3796:
/*!****************************************!*\
  !*** ../node_modules/brorand/index.js ***!
  \****************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var r;
module.exports = function rand(len) {
  if (!r) r = new Rand(null);
  return r.generate(len);
};
function Rand(rand) {
  this.rand = rand;
}
module.exports.Rand = Rand;
Rand.prototype.generate = function generate(len) {
  return this._rand(len);
};

// Emulate crypto API using randy
Rand.prototype._rand = function _rand(n) {
  if (this.rand.getBytes) return this.rand.getBytes(n);
  var res = new Uint8Array(n);
  for (var i = 0; i < res.length; i++) res[i] = this.rand.getByte();
  return res;
};
if (typeof self === 'object') {
  if (self.crypto && self.crypto.getRandomValues) {
    // Modern browsers
    Rand.prototype._rand = function _rand(n) {
      var arr = new Uint8Array(n);
      self.crypto.getRandomValues(arr);
      return arr;
    };
  } else if (self.msCrypto && self.msCrypto.getRandomValues) {
    // IE
    Rand.prototype._rand = function _rand(n) {
      var arr = new Uint8Array(n);
      self.msCrypto.getRandomValues(arr);
      return arr;
    };

    // Safari's WebWorkers do not have `crypto`
  } else if (typeof window === 'object') {
    // Old junk
    Rand.prototype._rand = function () {
      throw new Error('Not implemented yet');
    };
  }
} else {
  // Node.js or Web worker with no crypto support
  try {
    var crypto = __webpack_require__(/*! crypto */ 6113);
    if (typeof crypto.randomBytes !== 'function') throw new Error('Not supported');
    Rand.prototype._rand = function _rand(n) {
      return crypto.randomBytes(n);
    };
  } catch (e) {}
}

/***/ }),

/***/ 6297:
/*!*********************************************!*\
  !*** ../node_modules/browserify-aes/aes.js ***!
  \*********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// based on the aes implimentation in triple sec
// https://github.com/keybase/triplesec
// which is in turn based on the one from crypto-js
// https://code.google.com/p/crypto-js/

var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
function asUInt32Array(buf) {
  if (!Buffer.isBuffer(buf)) buf = Buffer.from(buf);
  var len = buf.length / 4 | 0;
  var out = new Array(len);
  for (var i = 0; i < len; i++) {
    out[i] = buf.readUInt32BE(i * 4);
  }
  return out;
}
function scrubVec(v) {
  for (var i = 0; i < v.length; v++) {
    v[i] = 0;
  }
}
function cryptBlock(M, keySchedule, SUB_MIX, SBOX, nRounds) {
  var SUB_MIX0 = SUB_MIX[0];
  var SUB_MIX1 = SUB_MIX[1];
  var SUB_MIX2 = SUB_MIX[2];
  var SUB_MIX3 = SUB_MIX[3];
  var s0 = M[0] ^ keySchedule[0];
  var s1 = M[1] ^ keySchedule[1];
  var s2 = M[2] ^ keySchedule[2];
  var s3 = M[3] ^ keySchedule[3];
  var t0, t1, t2, t3;
  var ksRow = 4;
  for (var round = 1; round < nRounds; round++) {
    t0 = SUB_MIX0[s0 >>> 24] ^ SUB_MIX1[s1 >>> 16 & 0xff] ^ SUB_MIX2[s2 >>> 8 & 0xff] ^ SUB_MIX3[s3 & 0xff] ^ keySchedule[ksRow++];
    t1 = SUB_MIX0[s1 >>> 24] ^ SUB_MIX1[s2 >>> 16 & 0xff] ^ SUB_MIX2[s3 >>> 8 & 0xff] ^ SUB_MIX3[s0 & 0xff] ^ keySchedule[ksRow++];
    t2 = SUB_MIX0[s2 >>> 24] ^ SUB_MIX1[s3 >>> 16 & 0xff] ^ SUB_MIX2[s0 >>> 8 & 0xff] ^ SUB_MIX3[s1 & 0xff] ^ keySchedule[ksRow++];
    t3 = SUB_MIX0[s3 >>> 24] ^ SUB_MIX1[s0 >>> 16 & 0xff] ^ SUB_MIX2[s1 >>> 8 & 0xff] ^ SUB_MIX3[s2 & 0xff] ^ keySchedule[ksRow++];
    s0 = t0;
    s1 = t1;
    s2 = t2;
    s3 = t3;
  }
  t0 = (SBOX[s0 >>> 24] << 24 | SBOX[s1 >>> 16 & 0xff] << 16 | SBOX[s2 >>> 8 & 0xff] << 8 | SBOX[s3 & 0xff]) ^ keySchedule[ksRow++];
  t1 = (SBOX[s1 >>> 24] << 24 | SBOX[s2 >>> 16 & 0xff] << 16 | SBOX[s3 >>> 8 & 0xff] << 8 | SBOX[s0 & 0xff]) ^ keySchedule[ksRow++];
  t2 = (SBOX[s2 >>> 24] << 24 | SBOX[s3 >>> 16 & 0xff] << 16 | SBOX[s0 >>> 8 & 0xff] << 8 | SBOX[s1 & 0xff]) ^ keySchedule[ksRow++];
  t3 = (SBOX[s3 >>> 24] << 24 | SBOX[s0 >>> 16 & 0xff] << 16 | SBOX[s1 >>> 8 & 0xff] << 8 | SBOX[s2 & 0xff]) ^ keySchedule[ksRow++];
  t0 = t0 >>> 0;
  t1 = t1 >>> 0;
  t2 = t2 >>> 0;
  t3 = t3 >>> 0;
  return [t0, t1, t2, t3];
}

// AES constants
var RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36];
var G = function () {
  // Compute double table
  var d = new Array(256);
  for (var j = 0; j < 256; j++) {
    if (j < 128) {
      d[j] = j << 1;
    } else {
      d[j] = j << 1 ^ 0x11b;
    }
  }
  var SBOX = [];
  var INV_SBOX = [];
  var SUB_MIX = [[], [], [], []];
  var INV_SUB_MIX = [[], [], [], []];

  // Walk GF(2^8)
  var x = 0;
  var xi = 0;
  for (var i = 0; i < 256; ++i) {
    // Compute sbox
    var sx = xi ^ xi << 1 ^ xi << 2 ^ xi << 3 ^ xi << 4;
    sx = sx >>> 8 ^ sx & 0xff ^ 0x63;
    SBOX[x] = sx;
    INV_SBOX[sx] = x;

    // Compute multiplication
    var x2 = d[x];
    var x4 = d[x2];
    var x8 = d[x4];

    // Compute sub bytes, mix columns tables
    var t = d[sx] * 0x101 ^ sx * 0x1010100;
    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;

    // Compute inv sub bytes, inv mix columns tables
    t = x8 * 0x1010101 ^ x4 * 0x10001 ^ x2 * 0x101 ^ x * 0x1010100;
    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 === 0) {
      x = xi = 1;
    } else {
      x = x2 ^ d[d[d[x8 ^ x2]]];
      xi ^= d[d[xi]];
    }
  }
  return {
    SBOX: SBOX,
    INV_SBOX: INV_SBOX,
    SUB_MIX: SUB_MIX,
    INV_SUB_MIX: INV_SUB_MIX
  };
}();
function AES(key) {
  this._key = asUInt32Array(key);
  this._reset();
}
AES.blockSize = 4 * 4;
AES.keySize = 256 / 8;
AES.prototype.blockSize = AES.blockSize;
AES.prototype.keySize = AES.keySize;
AES.prototype._reset = function () {
  var keyWords = this._key;
  var keySize = keyWords.length;
  var nRounds = keySize + 6;
  var ksRows = (nRounds + 1) * 4;
  var keySchedule = [];
  for (var k = 0; k < keySize; k++) {
    keySchedule[k] = keyWords[k];
  }
  for (k = keySize; k < ksRows; k++) {
    var t = keySchedule[k - 1];
    if (k % keySize === 0) {
      t = t << 8 | t >>> 24;
      t = G.SBOX[t >>> 24] << 24 | G.SBOX[t >>> 16 & 0xff] << 16 | G.SBOX[t >>> 8 & 0xff] << 8 | G.SBOX[t & 0xff];
      t ^= RCON[k / keySize | 0] << 24;
    } else if (keySize > 6 && k % keySize === 4) {
      t = G.SBOX[t >>> 24] << 24 | G.SBOX[t >>> 16 & 0xff] << 16 | G.SBOX[t >>> 8 & 0xff] << 8 | G.SBOX[t & 0xff];
    }
    keySchedule[k] = keySchedule[k - keySize] ^ t;
  }
  var invKeySchedule = [];
  for (var ik = 0; ik < ksRows; ik++) {
    var ksR = ksRows - ik;
    var tt = keySchedule[ksR - (ik % 4 ? 0 : 4)];
    if (ik < 4 || ksR <= 4) {
      invKeySchedule[ik] = tt;
    } else {
      invKeySchedule[ik] = G.INV_SUB_MIX[0][G.SBOX[tt >>> 24]] ^ G.INV_SUB_MIX[1][G.SBOX[tt >>> 16 & 0xff]] ^ G.INV_SUB_MIX[2][G.SBOX[tt >>> 8 & 0xff]] ^ G.INV_SUB_MIX[3][G.SBOX[tt & 0xff]];
    }
  }
  this._nRounds = nRounds;
  this._keySchedule = keySchedule;
  this._invKeySchedule = invKeySchedule;
};
AES.prototype.encryptBlockRaw = function (M) {
  M = asUInt32Array(M);
  return cryptBlock(M, this._keySchedule, G.SUB_MIX, G.SBOX, this._nRounds);
};
AES.prototype.encryptBlock = function (M) {
  var out = this.encryptBlockRaw(M);
  var buf = Buffer.allocUnsafe(16);
  buf.writeUInt32BE(out[0], 0);
  buf.writeUInt32BE(out[1], 4);
  buf.writeUInt32BE(out[2], 8);
  buf.writeUInt32BE(out[3], 12);
  return buf;
};
AES.prototype.decryptBlock = function (M) {
  M = asUInt32Array(M);

  // swap
  var m1 = M[1];
  M[1] = M[3];
  M[3] = m1;
  var out = cryptBlock(M, this._invKeySchedule, G.INV_SUB_MIX, G.INV_SBOX, this._nRounds);
  var buf = Buffer.allocUnsafe(16);
  buf.writeUInt32BE(out[0], 0);
  buf.writeUInt32BE(out[3], 4);
  buf.writeUInt32BE(out[2], 8);
  buf.writeUInt32BE(out[1], 12);
  return buf;
};
AES.prototype.scrub = function () {
  scrubVec(this._keySchedule);
  scrubVec(this._invKeySchedule);
  scrubVec(this._key);
};
module.exports.AES = AES;

/***/ }),

/***/ 2225:
/*!****************************************************!*\
  !*** ../node_modules/browserify-aes/authCipher.js ***!
  \****************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var aes = __webpack_require__(/*! ./aes */ 6297);
var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
var Transform = __webpack_require__(/*! cipher-base */ 7017);
var inherits = __webpack_require__(/*! inherits */ 7694);
var GHASH = __webpack_require__(/*! ./ghash */ 3342);
var xor = __webpack_require__(/*! buffer-xor */ 447);
var incr32 = __webpack_require__(/*! ./incr32 */ 590);
function xorTest(a, b) {
  var out = 0;
  if (a.length !== b.length) out++;
  var len = Math.min(a.length, b.length);
  for (var i = 0; i < len; ++i) {
    out += a[i] ^ b[i];
  }
  return out;
}
function calcIv(self, iv, ck) {
  if (iv.length === 12) {
    self._finID = Buffer.concat([iv, Buffer.from([0, 0, 0, 1])]);
    return Buffer.concat([iv, Buffer.from([0, 0, 0, 2])]);
  }
  var ghash = new GHASH(ck);
  var len = iv.length;
  var toPad = len % 16;
  ghash.update(iv);
  if (toPad) {
    toPad = 16 - toPad;
    ghash.update(Buffer.alloc(toPad, 0));
  }
  ghash.update(Buffer.alloc(8, 0));
  var ivBits = len * 8;
  var tail = Buffer.alloc(8);
  tail.writeUIntBE(ivBits, 0, 8);
  ghash.update(tail);
  self._finID = ghash.state;
  var out = Buffer.from(self._finID);
  incr32(out);
  return out;
}
function StreamCipher(mode, key, iv, decrypt) {
  Transform.call(this);
  var h = Buffer.alloc(4, 0);
  this._cipher = new aes.AES(key);
  var ck = this._cipher.encryptBlock(h);
  this._ghash = new GHASH(ck);
  iv = calcIv(this, iv, ck);
  this._prev = Buffer.from(iv);
  this._cache = Buffer.allocUnsafe(0);
  this._secCache = Buffer.allocUnsafe(0);
  this._decrypt = decrypt;
  this._alen = 0;
  this._len = 0;
  this._mode = mode;
  this._authTag = null;
  this._called = false;
}
inherits(StreamCipher, Transform);
StreamCipher.prototype._update = function (chunk) {
  if (!this._called && this._alen) {
    var rump = 16 - this._alen % 16;
    if (rump < 16) {
      rump = Buffer.alloc(rump, 0);
      this._ghash.update(rump);
    }
  }
  this._called = true;
  var out = this._mode.encrypt(this, chunk);
  if (this._decrypt) {
    this._ghash.update(chunk);
  } else {
    this._ghash.update(out);
  }
  this._len += chunk.length;
  return out;
};
StreamCipher.prototype._final = function () {
  if (this._decrypt && !this._authTag) throw new Error('Unsupported state or unable to authenticate data');
  var tag = xor(this._ghash.final(this._alen * 8, this._len * 8), this._cipher.encryptBlock(this._finID));
  if (this._decrypt && xorTest(tag, this._authTag)) throw new Error('Unsupported state or unable to authenticate data');
  this._authTag = tag;
  this._cipher.scrub();
};
StreamCipher.prototype.getAuthTag = function getAuthTag() {
  if (this._decrypt || !Buffer.isBuffer(this._authTag)) throw new Error('Attempting to get auth tag in unsupported state');
  return this._authTag;
};
StreamCipher.prototype.setAuthTag = function setAuthTag(tag) {
  if (!this._decrypt) throw new Error('Attempting to set auth tag in unsupported state');
  this._authTag = tag;
};
StreamCipher.prototype.setAAD = function setAAD(buf) {
  if (this._called) throw new Error('Attempting to set AAD in unsupported state');
  this._ghash.update(buf);
  this._alen += buf.length;
};
module.exports = StreamCipher;

/***/ }),

/***/ 7590:
/*!*************************************************!*\
  !*** ../node_modules/browserify-aes/browser.js ***!
  \*************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

var ciphers = __webpack_require__(/*! ./encrypter */ 7542);
var deciphers = __webpack_require__(/*! ./decrypter */ 4693);
var modes = __webpack_require__(/*! ./modes/list.json */ 4923);
function getCiphers() {
  return Object.keys(modes);
}
exports.createCipher = exports.Cipher = ciphers.createCipher;
exports.createCipheriv = exports.Cipheriv = ciphers.createCipheriv;
exports.createDecipher = exports.Decipher = deciphers.createDecipher;
exports.createDecipheriv = exports.Decipheriv = deciphers.createDecipheriv;
exports.listCiphers = exports.getCiphers = getCiphers;

/***/ }),

/***/ 4693:
/*!***************************************************!*\
  !*** ../node_modules/browserify-aes/decrypter.js ***!
  \***************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

var AuthCipher = __webpack_require__(/*! ./authCipher */ 2225);
var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
var MODES = __webpack_require__(/*! ./modes */ 5007);
var StreamCipher = __webpack_require__(/*! ./streamCipher */ 4372);
var Transform = __webpack_require__(/*! cipher-base */ 7017);
var aes = __webpack_require__(/*! ./aes */ 6297);
var ebtk = __webpack_require__(/*! evp_bytestokey */ 3325);
var inherits = __webpack_require__(/*! inherits */ 7694);
function Decipher(mode, key, iv) {
  Transform.call(this);
  this._cache = new Splitter();
  this._last = void 0;
  this._cipher = new aes.AES(key);
  this._prev = Buffer.from(iv);
  this._mode = mode;
  this._autopadding = true;
}
inherits(Decipher, Transform);
Decipher.prototype._update = function (data) {
  this._cache.add(data);
  var chunk;
  var thing;
  var out = [];
  while (chunk = this._cache.get(this._autopadding)) {
    thing = this._mode.decrypt(this, chunk);
    out.push(thing);
  }
  return Buffer.concat(out);
};
Decipher.prototype._final = function () {
  var chunk = this._cache.flush();
  if (this._autopadding) {
    return unpad(this._mode.decrypt(this, chunk));
  } else if (chunk) {
    throw new Error('data not multiple of block length');
  }
};
Decipher.prototype.setAutoPadding = function (setTo) {
  this._autopadding = !!setTo;
  return this;
};
function Splitter() {
  this.cache = Buffer.allocUnsafe(0);
}
Splitter.prototype.add = function (data) {
  this.cache = Buffer.concat([this.cache, data]);
};
Splitter.prototype.get = function (autoPadding) {
  var out;
  if (autoPadding) {
    if (this.cache.length > 16) {
      out = this.cache.slice(0, 16);
      this.cache = this.cache.slice(16);
      return out;
    }
  } else {
    if (this.cache.length >= 16) {
      out = this.cache.slice(0, 16);
      this.cache = this.cache.slice(16);
      return out;
    }
  }
  return null;
};
Splitter.prototype.flush = function () {
  if (this.cache.length) return this.cache;
};
function unpad(last) {
  var padded = last[15];
  if (padded < 1 || padded > 16) {
    throw new Error('unable to decrypt data');
  }
  var i = -1;
  while (++i < padded) {
    if (last[i + (16 - padded)] !== padded) {
      throw new Error('unable to decrypt data');
    }
  }
  if (padded === 16) return;
  return last.slice(0, 16 - padded);
}
function createDecipheriv(suite, password, iv) {
  var config = MODES[suite.toLowerCase()];
  if (!config) throw new TypeError('invalid suite type');
  if (typeof iv === 'string') iv = Buffer.from(iv);
  if (config.mode !== 'GCM' && iv.length !== config.iv) throw new TypeError('invalid iv length ' + iv.length);
  if (typeof password === 'string') password = Buffer.from(password);
  if (password.length !== config.key / 8) throw new TypeError('invalid key length ' + password.length);
  if (config.type === 'stream') {
    return new StreamCipher(config.module, password, iv, true);
  } else if (config.type === 'auth') {
    return new AuthCipher(config.module, password, iv, true);
  }
  return new Decipher(config.module, password, iv);
}
function createDecipher(suite, password) {
  var config = MODES[suite.toLowerCase()];
  if (!config) throw new TypeError('invalid suite type');
  var keys = ebtk(password, false, config.key, config.iv);
  return createDecipheriv(suite, keys.key, keys.iv);
}
exports.createDecipher = createDecipher;
exports.createDecipheriv = createDecipheriv;

/***/ }),

/***/ 7542:
/*!***************************************************!*\
  !*** ../node_modules/browserify-aes/encrypter.js ***!
  \***************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

var MODES = __webpack_require__(/*! ./modes */ 5007);
var AuthCipher = __webpack_require__(/*! ./authCipher */ 2225);
var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
var StreamCipher = __webpack_require__(/*! ./streamCipher */ 4372);
var Transform = __webpack_require__(/*! cipher-base */ 7017);
var aes = __webpack_require__(/*! ./aes */ 6297);
var ebtk = __webpack_require__(/*! evp_bytestokey */ 3325);
var inherits = __webpack_require__(/*! inherits */ 7694);
function Cipher(mode, key, iv) {
  Transform.call(this);
  this._cache = new Splitter();
  this._cipher = new aes.AES(key);
  this._prev = Buffer.from(iv);
  this._mode = mode;
  this._autopadding = true;
}
inherits(Cipher, Transform);
Cipher.prototype._update = function (data) {
  this._cache.add(data);
  var chunk;
  var thing;
  var out = [];
  while (chunk = this._cache.get()) {
    thing = this._mode.encrypt(this, chunk);
    out.push(thing);
  }
  return Buffer.concat(out);
};
var PADDING = Buffer.alloc(16, 0x10);
Cipher.prototype._final = function () {
  var chunk = this._cache.flush();
  if (this._autopadding) {
    chunk = this._mode.encrypt(this, chunk);
    this._cipher.scrub();
    return chunk;
  }
  if (!chunk.equals(PADDING)) {
    this._cipher.scrub();
    throw new Error('data not multiple of block length');
  }
};
Cipher.prototype.setAutoPadding = function (setTo) {
  this._autopadding = !!setTo;
  return this;
};
function Splitter() {
  this.cache = Buffer.allocUnsafe(0);
}
Splitter.prototype.add = function (data) {
  this.cache = Buffer.concat([this.cache, data]);
};
Splitter.prototype.get = function () {
  if (this.cache.length > 15) {
    var out = this.cache.slice(0, 16);
    this.cache = this.cache.slice(16);
    return out;
  }
  return null;
};
Splitter.prototype.flush = function () {
  var len = 16 - this.cache.length;
  var padBuff = Buffer.allocUnsafe(len);
  var i = -1;
  while (++i < len) {
    padBuff.writeUInt8(len, i);
  }
  return Buffer.concat([this.cache, padBuff]);
};
function createCipheriv(suite, password, iv) {
  var config = MODES[suite.toLowerCase()];
  if (!config) throw new TypeError('invalid suite type');
  if (typeof password === 'string') password = Buffer.from(password);
  if (password.length !== config.key / 8) throw new TypeError('invalid key length ' + password.length);
  if (typeof iv === 'string') iv = Buffer.from(iv);
  if (config.mode !== 'GCM' && iv.length !== config.iv) throw new TypeError('invalid iv length ' + iv.length);
  if (config.type === 'stream') {
    return new StreamCipher(config.module, password, iv);
  } else if (config.type === 'auth') {
    return new AuthCipher(config.module, password, iv);
  }
  return new Cipher(config.module, password, iv);
}
function createCipher(suite, password) {
  var config = MODES[suite.toLowerCase()];
  if (!config) throw new TypeError('invalid suite type');
  var keys = ebtk(password, false, config.key, config.iv);
  return createCipheriv(suite, keys.key, keys.iv);
}
exports.createCipheriv = createCipheriv;
exports.createCipher = createCipher;

/***/ }),

/***/ 3342:
/*!***********************************************!*\
  !*** ../node_modules/browserify-aes/ghash.js ***!
  \***********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
var ZEROES = Buffer.alloc(16, 0);
function toArray(buf) {
  return [buf.readUInt32BE(0), buf.readUInt32BE(4), buf.readUInt32BE(8), buf.readUInt32BE(12)];
}
function fromArray(out) {
  var buf = Buffer.allocUnsafe(16);
  buf.writeUInt32BE(out[0] >>> 0, 0);
  buf.writeUInt32BE(out[1] >>> 0, 4);
  buf.writeUInt32BE(out[2] >>> 0, 8);
  buf.writeUInt32BE(out[3] >>> 0, 12);
  return buf;
}
function GHASH(key) {
  this.h = key;
  this.state = Buffer.alloc(16, 0);
  this.cache = Buffer.allocUnsafe(0);
}

// from http://bitwiseshiftleft.github.io/sjcl/doc/symbols/src/core_gcm.js.html
// by Juho Vähä-Herttua
GHASH.prototype.ghash = function (block) {
  var i = -1;
  while (++i < block.length) {
    this.state[i] ^= block[i];
  }
  this._multiply();
};
GHASH.prototype._multiply = function () {
  var Vi = toArray(this.h);
  var Zi = [0, 0, 0, 0];
  var j, xi, lsbVi;
  var i = -1;
  while (++i < 128) {
    xi = (this.state[~~(i / 8)] & 1 << 7 - i % 8) !== 0;
    if (xi) {
      // Z_i+1 = Z_i ^ V_i
      Zi[0] ^= Vi[0];
      Zi[1] ^= Vi[1];
      Zi[2] ^= Vi[2];
      Zi[3] ^= Vi[3];
    }

    // Store the value of LSB(V_i)
    lsbVi = (Vi[3] & 1) !== 0;

    // V_i+1 = V_i >> 1
    for (j = 3; j > 0; j--) {
      Vi[j] = Vi[j] >>> 1 | (Vi[j - 1] & 1) << 31;
    }
    Vi[0] = Vi[0] >>> 1;

    // If LSB(V_i) is 1, V_i+1 = (V_i >> 1) ^ R
    if (lsbVi) {
      Vi[0] = Vi[0] ^ 0xe1 << 24;
    }
  }
  this.state = fromArray(Zi);
};
GHASH.prototype.update = function (buf) {
  this.cache = Buffer.concat([this.cache, buf]);
  var chunk;
  while (this.cache.length >= 16) {
    chunk = this.cache.slice(0, 16);
    this.cache = this.cache.slice(16);
    this.ghash(chunk);
  }
};
GHASH.prototype.final = function (abl, bl) {
  if (this.cache.length) {
    this.ghash(Buffer.concat([this.cache, ZEROES], 16));
  }
  this.ghash(fromArray([0, abl, 0, bl]));
  return this.state;
};
module.exports = GHASH;

/***/ }),

/***/ 590:
/*!************************************************!*\
  !*** ../node_modules/browserify-aes/incr32.js ***!
  \************************************************/
/***/ ((module) => {

function incr32(iv) {
  var len = iv.length;
  var item;
  while (len--) {
    item = iv.readUInt8(len);
    if (item === 255) {
      iv.writeUInt8(0, len);
    } else {
      item++;
      iv.writeUInt8(item, len);
      break;
    }
  }
}
module.exports = incr32;

/***/ }),

/***/ 8484:
/*!***************************************************!*\
  !*** ../node_modules/browserify-aes/modes/cbc.js ***!
  \***************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

var xor = __webpack_require__(/*! buffer-xor */ 447);
exports.encrypt = function (self, block) {
  var data = xor(block, self._prev);
  self._prev = self._cipher.encryptBlock(data);
  return self._prev;
};
exports.decrypt = function (self, block) {
  var pad = self._prev;
  self._prev = block;
  var out = self._cipher.decryptBlock(block);
  return xor(out, pad);
};

/***/ }),

/***/ 2132:
/*!***************************************************!*\
  !*** ../node_modules/browserify-aes/modes/cfb.js ***!
  \***************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
var xor = __webpack_require__(/*! buffer-xor */ 447);
function encryptStart(self, data, decrypt) {
  var len = data.length;
  var out = xor(data, self._cache);
  self._cache = self._cache.slice(len);
  self._prev = Buffer.concat([self._prev, decrypt ? data : out]);
  return out;
}
exports.encrypt = function (self, data, decrypt) {
  var out = Buffer.allocUnsafe(0);
  var len;
  while (data.length) {
    if (self._cache.length === 0) {
      self._cache = self._cipher.encryptBlock(self._prev);
      self._prev = Buffer.allocUnsafe(0);
    }
    if (self._cache.length <= data.length) {
      len = self._cache.length;
      out = Buffer.concat([out, encryptStart(self, data.slice(0, len), decrypt)]);
      data = data.slice(len);
    } else {
      out = Buffer.concat([out, encryptStart(self, data, decrypt)]);
      break;
    }
  }
  return out;
};

/***/ }),

/***/ 5719:
/*!****************************************************!*\
  !*** ../node_modules/browserify-aes/modes/cfb1.js ***!
  \****************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
function encryptByte(self, byteParam, decrypt) {
  var pad;
  var i = -1;
  var len = 8;
  var out = 0;
  var bit, value;
  while (++i < len) {
    pad = self._cipher.encryptBlock(self._prev);
    bit = byteParam & 1 << 7 - i ? 0x80 : 0;
    value = pad[0] ^ bit;
    out += (value & 0x80) >> i % 8;
    self._prev = shiftIn(self._prev, decrypt ? bit : value);
  }
  return out;
}
function shiftIn(buffer, value) {
  var len = buffer.length;
  var i = -1;
  var out = Buffer.allocUnsafe(buffer.length);
  buffer = Buffer.concat([buffer, Buffer.from([value])]);
  while (++i < len) {
    out[i] = buffer[i] << 1 | buffer[i + 1] >> 7;
  }
  return out;
}
exports.encrypt = function (self, chunk, decrypt) {
  var len = chunk.length;
  var out = Buffer.allocUnsafe(len);
  var i = -1;
  while (++i < len) {
    out[i] = encryptByte(self, chunk[i], decrypt);
  }
  return out;
};

/***/ }),

/***/ 9623:
/*!****************************************************!*\
  !*** ../node_modules/browserify-aes/modes/cfb8.js ***!
  \****************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
function encryptByte(self, byteParam, decrypt) {
  var pad = self._cipher.encryptBlock(self._prev);
  var out = pad[0] ^ byteParam;
  self._prev = Buffer.concat([self._prev.slice(1), Buffer.from([decrypt ? byteParam : out])]);
  return out;
}
exports.encrypt = function (self, chunk, decrypt) {
  var len = chunk.length;
  var out = Buffer.allocUnsafe(len);
  var i = -1;
  while (++i < len) {
    out[i] = encryptByte(self, chunk[i], decrypt);
  }
  return out;
};

/***/ }),

/***/ 3596:
/*!***************************************************!*\
  !*** ../node_modules/browserify-aes/modes/ctr.js ***!
  \***************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

var xor = __webpack_require__(/*! buffer-xor */ 447);
var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
var incr32 = __webpack_require__(/*! ../incr32 */ 590);
function getBlock(self) {
  var out = self._cipher.encryptBlockRaw(self._prev);
  incr32(self._prev);
  return out;
}
var blockSize = 16;
exports.encrypt = function (self, chunk) {
  var chunkNum = Math.ceil(chunk.length / blockSize);
  var start = self._cache.length;
  self._cache = Buffer.concat([self._cache, Buffer.allocUnsafe(chunkNum * blockSize)]);
  for (var i = 0; i < chunkNum; i++) {
    var out = getBlock(self);
    var offset = start + i * blockSize;
    self._cache.writeUInt32BE(out[0], offset + 0);
    self._cache.writeUInt32BE(out[1], offset + 4);
    self._cache.writeUInt32BE(out[2], offset + 8);
    self._cache.writeUInt32BE(out[3], offset + 12);
  }
  var pad = self._cache.slice(0, chunk.length);
  self._cache = self._cache.slice(chunk.length);
  return xor(chunk, pad);
};

/***/ }),

/***/ 7000:
/*!***************************************************!*\
  !*** ../node_modules/browserify-aes/modes/ecb.js ***!
  \***************************************************/
/***/ ((__unused_webpack_module, exports) => {

exports.encrypt = function (self, block) {
  return self._cipher.encryptBlock(block);
};
exports.decrypt = function (self, block) {
  return self._cipher.decryptBlock(block);
};

/***/ }),

/***/ 5007:
/*!*****************************************************!*\
  !*** ../node_modules/browserify-aes/modes/index.js ***!
  \*****************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var modeModules = {
  ECB: __webpack_require__(/*! ./ecb */ 7000),
  CBC: __webpack_require__(/*! ./cbc */ 8484),
  CFB: __webpack_require__(/*! ./cfb */ 2132),
  CFB8: __webpack_require__(/*! ./cfb8 */ 9623),
  CFB1: __webpack_require__(/*! ./cfb1 */ 5719),
  OFB: __webpack_require__(/*! ./ofb */ 22),
  CTR: __webpack_require__(/*! ./ctr */ 3596),
  GCM: __webpack_require__(/*! ./ctr */ 3596)
};
var modes = __webpack_require__(/*! ./list.json */ 4923);
for (var key in modes) {
  modes[key].module = modeModules[modes[key].mode];
}
module.exports = modes;

/***/ }),

/***/ 22:
/*!***************************************************!*\
  !*** ../node_modules/browserify-aes/modes/ofb.js ***!
  \***************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

var xor = __webpack_require__(/*! buffer-xor */ 447);
function getBlock(self) {
  self._prev = self._cipher.encryptBlock(self._prev);
  return self._prev;
}
exports.encrypt = function (self, chunk) {
  while (self._cache.length < chunk.length) {
    self._cache = Buffer.concat([self._cache, getBlock(self)]);
  }
  var pad = self._cache.slice(0, chunk.length);
  self._cache = self._cache.slice(chunk.length);
  return xor(chunk, pad);
};

/***/ }),

/***/ 4372:
/*!******************************************************!*\
  !*** ../node_modules/browserify-aes/streamCipher.js ***!
  \******************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var aes = __webpack_require__(/*! ./aes */ 6297);
var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
var Transform = __webpack_require__(/*! cipher-base */ 7017);
var inherits = __webpack_require__(/*! inherits */ 7694);
function StreamCipher(mode, key, iv, decrypt) {
  Transform.call(this);
  this._cipher = new aes.AES(key);
  this._prev = Buffer.from(iv);
  this._cache = Buffer.allocUnsafe(0);
  this._secCache = Buffer.allocUnsafe(0);
  this._decrypt = decrypt;
  this._mode = mode;
}
inherits(StreamCipher, Transform);
StreamCipher.prototype._update = function (chunk) {
  return this._mode.encrypt(this, chunk, this._decrypt);
};
StreamCipher.prototype._final = function () {
  this._cipher.scrub();
};
module.exports = StreamCipher;

/***/ }),

/***/ 6386:
/*!***********************************************!*\
  !*** ../node_modules/browserify-rsa/index.js ***!
  \***********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var BN = __webpack_require__(/*! bn.js */ 1046);
var randomBytes = __webpack_require__(/*! randombytes */ 316);
function blind(priv) {
  var r = getr(priv);
  var blinder = r.toRed(BN.mont(priv.modulus)).redPow(new BN(priv.publicExponent)).fromRed();
  return {
    blinder: blinder,
    unblinder: r.invm(priv.modulus)
  };
}
function getr(priv) {
  var len = priv.modulus.byteLength();
  var r;
  do {
    r = new BN(randomBytes(len));
  } while (r.cmp(priv.modulus) >= 0 || !r.umod(priv.prime1) || !r.umod(priv.prime2));
  return r;
}
function crt(msg, priv) {
  var blinds = blind(priv);
  var len = priv.modulus.byteLength();
  var blinded = new BN(msg).mul(blinds.blinder).umod(priv.modulus);
  var c1 = blinded.toRed(BN.mont(priv.prime1));
  var c2 = blinded.toRed(BN.mont(priv.prime2));
  var qinv = priv.coefficient;
  var p = priv.prime1;
  var q = priv.prime2;
  var m1 = c1.redPow(priv.exponent1).fromRed();
  var m2 = c2.redPow(priv.exponent2).fromRed();
  var h = m1.isub(m2).imul(qinv).umod(p).imul(q);
  return m2.iadd(h).imul(blinds.unblinder).umod(priv.modulus).toArrayLike(Buffer, 'be', len);
}
crt.getr = getr;
module.exports = crt;

/***/ }),

/***/ 6052:
/*!********************************************************!*\
  !*** ../node_modules/browserify-sign/browser/index.js ***!
  \********************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
var createHash = __webpack_require__(/*! create-hash */ 8861);
var stream = __webpack_require__(/*! readable-stream */ 5979);
var inherits = __webpack_require__(/*! inherits */ 7694);
var sign = __webpack_require__(/*! ./sign */ 9185);
var verify = __webpack_require__(/*! ./verify */ 4580);
var algorithms = __webpack_require__(/*! ./algorithms.json */ 7536);
Object.keys(algorithms).forEach(function (key) {
  algorithms[key].id = Buffer.from(algorithms[key].id, 'hex');
  algorithms[key.toLowerCase()] = algorithms[key];
});
function Sign(algorithm) {
  stream.Writable.call(this);
  var data = algorithms[algorithm];
  if (!data) throw new Error('Unknown message digest');
  this._hashType = data.hash;
  this._hash = createHash(data.hash);
  this._tag = data.id;
  this._signType = data.sign;
}
inherits(Sign, stream.Writable);
Sign.prototype._write = function _write(data, _, done) {
  this._hash.update(data);
  done();
};
Sign.prototype.update = function update(data, enc) {
  if (typeof data === 'string') data = Buffer.from(data, enc);
  this._hash.update(data);
  return this;
};
Sign.prototype.sign = function signMethod(key, enc) {
  this.end();
  var hash = this._hash.digest();
  var sig = sign(hash, key, this._hashType, this._signType, this._tag);
  return enc ? sig.toString(enc) : sig;
};
function Verify(algorithm) {
  stream.Writable.call(this);
  var data = algorithms[algorithm];
  if (!data) throw new Error('Unknown message digest');
  this._hash = createHash(data.hash);
  this._tag = data.id;
  this._signType = data.sign;
}
inherits(Verify, stream.Writable);
Verify.prototype._write = function _write(data, _, done) {
  this._hash.update(data);
  done();
};
Verify.prototype.update = function update(data, enc) {
  if (typeof data === 'string') data = Buffer.from(data, enc);
  this._hash.update(data);
  return this;
};
Verify.prototype.verify = function verifyMethod(key, sig, enc) {
  if (typeof sig === 'string') sig = Buffer.from(sig, enc);
  this.end();
  var hash = this._hash.digest();
  return verify(sig, hash, key, this._signType, this._tag);
};
function createSign(algorithm) {
  return new Sign(algorithm);
}
function createVerify(algorithm) {
  return new Verify(algorithm);
}
module.exports = {
  Sign: createSign,
  Verify: createVerify,
  createSign: createSign,
  createVerify: createVerify
};

/***/ }),

/***/ 9185:
/*!*******************************************************!*\
  !*** ../node_modules/browserify-sign/browser/sign.js ***!
  \*******************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// much of this based on https://github.com/indutny/self-signed/blob/gh-pages/lib/rsa.js
var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
var createHmac = __webpack_require__(/*! create-hmac */ 9959);
var crt = __webpack_require__(/*! browserify-rsa */ 6386);
var EC = (__webpack_require__(/*! elliptic */ 3225).ec);
var BN = __webpack_require__(/*! bn.js */ 1046);
var parseKeys = __webpack_require__(/*! parse-asn1 */ 5656);
var curves = __webpack_require__(/*! ./curves.json */ 7330);
function sign(hash, key, hashType, signType, tag) {
  var priv = parseKeys(key);
  if (priv.curve) {
    // rsa keys can be interpreted as ecdsa ones in openssl
    if (signType !== 'ecdsa' && signType !== 'ecdsa/rsa') throw new Error('wrong private key type');
    return ecSign(hash, priv);
  } else if (priv.type === 'dsa') {
    if (signType !== 'dsa') throw new Error('wrong private key type');
    return dsaSign(hash, priv, hashType);
  } else {
    if (signType !== 'rsa' && signType !== 'ecdsa/rsa') throw new Error('wrong private key type');
  }
  hash = Buffer.concat([tag, hash]);
  var len = priv.modulus.byteLength();
  var pad = [0, 1];
  while (hash.length + pad.length + 1 < len) pad.push(0xff);
  pad.push(0x00);
  var i = -1;
  while (++i < hash.length) pad.push(hash[i]);
  var out = crt(pad, priv);
  return out;
}
function ecSign(hash, priv) {
  var curveId = curves[priv.curve.join('.')];
  if (!curveId) throw new Error('unknown curve ' + priv.curve.join('.'));
  var curve = new EC(curveId);
  var key = curve.keyFromPrivate(priv.privateKey);
  var out = key.sign(hash);
  return Buffer.from(out.toDER());
}
function dsaSign(hash, priv, algo) {
  var x = priv.params.priv_key;
  var p = priv.params.p;
  var q = priv.params.q;
  var g = priv.params.g;
  var r = new BN(0);
  var k;
  var H = bits2int(hash, q).mod(q);
  var s = false;
  var kv = getKey(x, q, hash, algo);
  while (s === false) {
    k = makeKey(q, kv, algo);
    r = makeR(g, k, p, q);
    s = k.invm(q).imul(H.add(x.mul(r))).mod(q);
    if (s.cmpn(0) === 0) {
      s = false;
      r = new BN(0);
    }
  }
  return toDER(r, s);
}
function toDER(r, s) {
  r = r.toArray();
  s = s.toArray();

  // Pad values
  if (r[0] & 0x80) r = [0].concat(r);
  if (s[0] & 0x80) s = [0].concat(s);
  var total = r.length + s.length + 4;
  var res = [0x30, total, 0x02, r.length];
  res = res.concat(r, [0x02, s.length], s);
  return Buffer.from(res);
}
function getKey(x, q, hash, algo) {
  x = Buffer.from(x.toArray());
  if (x.length < q.byteLength()) {
    var zeros = Buffer.alloc(q.byteLength() - x.length);
    x = Buffer.concat([zeros, x]);
  }
  var hlen = hash.length;
  var hbits = bits2octets(hash, q);
  var v = Buffer.alloc(hlen);
  v.fill(1);
  var k = Buffer.alloc(hlen);
  k = createHmac(algo, k).update(v).update(Buffer.from([0])).update(x).update(hbits).digest();
  v = createHmac(algo, k).update(v).digest();
  k = createHmac(algo, k).update(v).update(Buffer.from([1])).update(x).update(hbits).digest();
  v = createHmac(algo, k).update(v).digest();
  return {
    k: k,
    v: v
  };
}
function bits2int(obits, q) {
  var bits = new BN(obits);
  var shift = (obits.length << 3) - q.bitLength();
  if (shift > 0) bits.ishrn(shift);
  return bits;
}
function bits2octets(bits, q) {
  bits = bits2int(bits, q);
  bits = bits.mod(q);
  var out = Buffer.from(bits.toArray());
  if (out.length < q.byteLength()) {
    var zeros = Buffer.alloc(q.byteLength() - out.length);
    out = Buffer.concat([zeros, out]);
  }
  return out;
}
function makeKey(q, kv, algo) {
  var t;
  var k;
  do {
    t = Buffer.alloc(0);
    while (t.length * 8 < q.bitLength()) {
      kv.v = createHmac(algo, kv.k).update(kv.v).digest();
      t = Buffer.concat([t, kv.v]);
    }
    k = bits2int(t, q);
    kv.k = createHmac(algo, kv.k).update(kv.v).update(Buffer.from([0])).digest();
    kv.v = createHmac(algo, kv.k).update(kv.v).digest();
  } while (k.cmp(q) !== -1);
  return k;
}
function makeR(g, k, p, q) {
  return g.toRed(BN.mont(p)).redPow(k).fromRed().mod(q);
}
module.exports = sign;
module.exports.getKey = getKey;
module.exports.makeKey = makeKey;

/***/ }),

/***/ 4580:
/*!*********************************************************!*\
  !*** ../node_modules/browserify-sign/browser/verify.js ***!
  \*********************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// much of this based on https://github.com/indutny/self-signed/blob/gh-pages/lib/rsa.js
var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
var BN = __webpack_require__(/*! bn.js */ 1046);
var EC = (__webpack_require__(/*! elliptic */ 3225).ec);
var parseKeys = __webpack_require__(/*! parse-asn1 */ 5656);
var curves = __webpack_require__(/*! ./curves.json */ 7330);
function verify(sig, hash, key, signType, tag) {
  var pub = parseKeys(key);
  if (pub.type === 'ec') {
    // rsa keys can be interpreted as ecdsa ones in openssl
    if (signType !== 'ecdsa' && signType !== 'ecdsa/rsa') throw new Error('wrong public key type');
    return ecVerify(sig, hash, pub);
  } else if (pub.type === 'dsa') {
    if (signType !== 'dsa') throw new Error('wrong public key type');
    return dsaVerify(sig, hash, pub);
  } else {
    if (signType !== 'rsa' && signType !== 'ecdsa/rsa') throw new Error('wrong public key type');
  }
  hash = Buffer.concat([tag, hash]);
  var len = pub.modulus.byteLength();
  var pad = [1];
  var padNum = 0;
  while (hash.length + pad.length + 2 < len) {
    pad.push(0xff);
    padNum++;
  }
  pad.push(0x00);
  var i = -1;
  while (++i < hash.length) {
    pad.push(hash[i]);
  }
  pad = Buffer.from(pad);
  var red = BN.mont(pub.modulus);
  sig = new BN(sig).toRed(red);
  sig = sig.redPow(new BN(pub.publicExponent));
  sig = Buffer.from(sig.fromRed().toArray());
  var out = padNum < 8 ? 1 : 0;
  len = Math.min(sig.length, pad.length);
  if (sig.length !== pad.length) out = 1;
  i = -1;
  while (++i < len) out |= sig[i] ^ pad[i];
  return out === 0;
}
function ecVerify(sig, hash, pub) {
  var curveId = curves[pub.data.algorithm.curve.join('.')];
  if (!curveId) throw new Error('unknown curve ' + pub.data.algorithm.curve.join('.'));
  var curve = new EC(curveId);
  var pubkey = pub.data.subjectPrivateKey.data;
  return curve.verify(hash, sig, pubkey);
}
function dsaVerify(sig, hash, pub) {
  var p = pub.data.p;
  var q = pub.data.q;
  var g = pub.data.g;
  var y = pub.data.pub_key;
  var unpacked = parseKeys.signature.decode(sig, 'der');
  var s = unpacked.s;
  var r = unpacked.r;
  checkValue(s, q);
  checkValue(r, q);
  var montp = BN.mont(p);
  var w = s.invm(q);
  var v = g.toRed(montp).redPow(new BN(hash).mul(w).mod(q)).fromRed().mul(y.toRed(montp).redPow(r.mul(w).mod(q)).fromRed()).mod(p).mod(q);
  return v.cmp(r) === 0;
}
function checkValue(b, q) {
  if (b.cmpn(0) <= 0) throw new Error('invalid sig');
  if (b.cmp(q) >= q) throw new Error('invalid sig');
}
module.exports = verify;

/***/ }),

/***/ 447:
/*!*******************************************!*\
  !*** ../node_modules/buffer-xor/index.js ***!
  \*******************************************/
/***/ ((module) => {

module.exports = function xor(a, b) {
  var length = Math.min(a.length, b.length);
  var buffer = new Buffer(length);
  for (var i = 0; i < length; ++i) {
    buffer[i] = a[i] ^ b[i];
  }
  return buffer;
};

/***/ }),

/***/ 7017:
/*!********************************************!*\
  !*** ../node_modules/cipher-base/index.js ***!
  \********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
var Transform = (__webpack_require__(/*! stream */ 3978).Transform);
var StringDecoder = (__webpack_require__(/*! string_decoder */ 1576).StringDecoder);
var inherits = __webpack_require__(/*! inherits */ 7694);
function CipherBase(hashMode) {
  Transform.call(this);
  this.hashMode = typeof hashMode === 'string';
  if (this.hashMode) {
    this[hashMode] = this._finalOrDigest;
  } else {
    this.final = this._finalOrDigest;
  }
  if (this._final) {
    this.__final = this._final;
    this._final = null;
  }
  this._decoder = null;
  this._encoding = null;
}
inherits(CipherBase, Transform);
CipherBase.prototype.update = function (data, inputEnc, outputEnc) {
  if (typeof data === 'string') {
    data = Buffer.from(data, inputEnc);
  }
  var outData = this._update(data);
  if (this.hashMode) return this;
  if (outputEnc) {
    outData = this._toString(outData, outputEnc);
  }
  return outData;
};
CipherBase.prototype.setAutoPadding = function () {};
CipherBase.prototype.getAuthTag = function () {
  throw new Error('trying to get auth tag in unsupported state');
};
CipherBase.prototype.setAuthTag = function () {
  throw new Error('trying to set auth tag in unsupported state');
};
CipherBase.prototype.setAAD = function () {
  throw new Error('trying to set aad in unsupported state');
};
CipherBase.prototype._transform = function (data, _, next) {
  var err;
  try {
    if (this.hashMode) {
      this._update(data);
    } else {
      this.push(this._update(data));
    }
  } catch (e) {
    err = e;
  } finally {
    next(err);
  }
};
CipherBase.prototype._flush = function (done) {
  var err;
  try {
    this.push(this.__final());
  } catch (e) {
    err = e;
  }
  done(err);
};
CipherBase.prototype._finalOrDigest = function (outputEnc) {
  var outData = this.__final() || Buffer.alloc(0);
  if (outputEnc) {
    outData = this._toString(outData, outputEnc, true);
  }
  return outData;
};
CipherBase.prototype._toString = function (value, enc, fin) {
  if (!this._decoder) {
    this._decoder = new StringDecoder(enc);
    this._encoding = enc;
  }
  if (this._encoding !== enc) throw new Error('can\'t switch encodings');
  var out = this._decoder.write(value);
  if (fin) {
    out += this._decoder.end();
  }
  return out;
};
module.exports = CipherBase;

/***/ }),

/***/ 8861:
/*!**********************************************!*\
  !*** ../node_modules/create-hash/browser.js ***!
  \**********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


var inherits = __webpack_require__(/*! inherits */ 7694);
var MD5 = __webpack_require__(/*! md5.js */ 5106);
var RIPEMD160 = __webpack_require__(/*! ripemd160 */ 9797);
var sha = __webpack_require__(/*! sha.js */ 1239);
var Base = __webpack_require__(/*! cipher-base */ 7017);
function Hash(hash) {
  Base.call(this, 'digest');
  this._hash = hash;
}
inherits(Hash, Base);
Hash.prototype._update = function (data) {
  this._hash.update(data);
};
Hash.prototype._final = function () {
  return this._hash.digest();
};
module.exports = function createHash(alg) {
  alg = alg.toLowerCase();
  if (alg === 'md5') return new MD5();
  if (alg === 'rmd160' || alg === 'ripemd160') return new RIPEMD160();
  return new Hash(sha(alg));
};

/***/ }),

/***/ 1653:
/*!******************************************!*\
  !*** ../node_modules/create-hash/md5.js ***!
  \******************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var MD5 = __webpack_require__(/*! md5.js */ 5106);
module.exports = function (buffer) {
  return new MD5().update(buffer).digest();
};

/***/ }),

/***/ 9959:
/*!**********************************************!*\
  !*** ../node_modules/create-hmac/browser.js ***!
  \**********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


var inherits = __webpack_require__(/*! inherits */ 7694);
var Legacy = __webpack_require__(/*! ./legacy */ 8359);
var Base = __webpack_require__(/*! cipher-base */ 7017);
var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
var md5 = __webpack_require__(/*! create-hash/md5 */ 1653);
var RIPEMD160 = __webpack_require__(/*! ripemd160 */ 9797);
var sha = __webpack_require__(/*! sha.js */ 1239);
var ZEROS = Buffer.alloc(128);
function Hmac(alg, key) {
  Base.call(this, 'digest');
  if (typeof key === 'string') {
    key = Buffer.from(key);
  }
  var blocksize = alg === 'sha512' || alg === 'sha384' ? 128 : 64;
  this._alg = alg;
  this._key = key;
  if (key.length > blocksize) {
    var hash = alg === 'rmd160' ? new RIPEMD160() : sha(alg);
    key = hash.update(key).digest();
  } else if (key.length < blocksize) {
    key = Buffer.concat([key, ZEROS], blocksize);
  }
  var ipad = this._ipad = Buffer.allocUnsafe(blocksize);
  var opad = this._opad = Buffer.allocUnsafe(blocksize);
  for (var i = 0; i < blocksize; i++) {
    ipad[i] = key[i] ^ 0x36;
    opad[i] = key[i] ^ 0x5C;
  }
  this._hash = alg === 'rmd160' ? new RIPEMD160() : sha(alg);
  this._hash.update(ipad);
}
inherits(Hmac, Base);
Hmac.prototype._update = function (data) {
  this._hash.update(data);
};
Hmac.prototype._final = function () {
  var h = this._hash.digest();
  var hash = this._alg === 'rmd160' ? new RIPEMD160() : sha(this._alg);
  return hash.update(this._opad).update(h).digest();
};
module.exports = function createHmac(alg, key) {
  alg = alg.toLowerCase();
  if (alg === 'rmd160' || alg === 'ripemd160') {
    return new Hmac('rmd160', key);
  }
  if (alg === 'md5') {
    return new Legacy(md5, key);
  }
  return new Hmac(alg, key);
};

/***/ }),

/***/ 8359:
/*!*********************************************!*\
  !*** ../node_modules/create-hmac/legacy.js ***!
  \*********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


var inherits = __webpack_require__(/*! inherits */ 7694);
var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
var Base = __webpack_require__(/*! cipher-base */ 7017);
var ZEROS = Buffer.alloc(128);
var blocksize = 64;
function Hmac(alg, key) {
  Base.call(this, 'digest');
  if (typeof key === 'string') {
    key = Buffer.from(key);
  }
  this._alg = alg;
  this._key = key;
  if (key.length > blocksize) {
    key = alg(key);
  } else if (key.length < blocksize) {
    key = Buffer.concat([key, ZEROS], blocksize);
  }
  var ipad = this._ipad = Buffer.allocUnsafe(blocksize);
  var opad = this._opad = Buffer.allocUnsafe(blocksize);
  for (var i = 0; i < blocksize; i++) {
    ipad[i] = key[i] ^ 0x36;
    opad[i] = key[i] ^ 0x5C;
  }
  this._hash = [ipad];
}
inherits(Hmac, Base);
Hmac.prototype._update = function (data) {
  this._hash.push(data);
};
Hmac.prototype._final = function () {
  var h = this._alg(Buffer.concat(this._hash));
  return this._alg(Buffer.concat([this._opad, h]));
};
module.exports = Hmac;

/***/ }),

/***/ 7529:
/*!******************************************************!*\
  !*** ../node_modules/css-loader/dist/runtime/api.js ***!
  \******************************************************/
/***/ ((module) => {

"use strict";


/*
  MIT License http://www.opensource.org/licenses/mit-license.php
  Author Tobias Koppers @sokra
*/
module.exports = function (cssWithMappingToString) {
  var list = [];

  // return the list of modules as css string
  list.toString = function toString() {
    return this.map(function (item) {
      var content = "";
      var needLayer = typeof item[5] !== "undefined";
      if (item[4]) {
        content += "@supports (".concat(item[4], ") {");
      }
      if (item[2]) {
        content += "@media ".concat(item[2], " {");
      }
      if (needLayer) {
        content += "@layer".concat(item[5].length > 0 ? " ".concat(item[5]) : "", " {");
      }
      content += cssWithMappingToString(item);
      if (needLayer) {
        content += "}";
      }
      if (item[2]) {
        content += "}";
      }
      if (item[4]) {
        content += "}";
      }
      return content;
    }).join("");
  };

  // import a list of modules into the list
  list.i = function i(modules, media, dedupe, supports, layer) {
    if (typeof modules === "string") {
      modules = [[null, modules, undefined]];
    }
    var alreadyImportedModules = {};
    if (dedupe) {
      for (var k = 0; k < this.length; k++) {
        var id = this[k][0];
        if (id != null) {
          alreadyImportedModules[id] = true;
        }
      }
    }
    for (var _k = 0; _k < modules.length; _k++) {
      var item = [].concat(modules[_k]);
      if (dedupe && alreadyImportedModules[item[0]]) {
        continue;
      }
      if (typeof layer !== "undefined") {
        if (typeof item[5] === "undefined") {
          item[5] = layer;
        } else {
          item[1] = "@layer".concat(item[5].length > 0 ? " ".concat(item[5]) : "", " {").concat(item[1], "}");
          item[5] = layer;
        }
      }
      if (media) {
        if (!item[2]) {
          item[2] = media;
        } else {
          item[1] = "@media ".concat(item[2], " {").concat(item[1], "}");
          item[2] = media;
        }
      }
      if (supports) {
        if (!item[4]) {
          item[4] = "".concat(supports);
        } else {
          item[1] = "@supports (".concat(item[4], ") {").concat(item[1], "}");
          item[4] = supports;
        }
      }
      list.push(item);
    }
  };
  return list;
};

/***/ }),

/***/ 230:
/*!*************************************************************!*\
  !*** ../node_modules/css-loader/dist/runtime/sourceMaps.js ***!
  \*************************************************************/
/***/ ((module) => {

"use strict";


module.exports = function (item) {
  var content = item[1];
  var cssMapping = item[3];
  if (!cssMapping) {
    return content;
  }
  if (typeof btoa === "function") {
    var base64 = btoa(unescape(encodeURIComponent(JSON.stringify(cssMapping))));
    var data = "sourceMappingURL=data:application/json;charset=utf-8;base64,".concat(base64);
    var sourceMapping = "/*# ".concat(data, " */");
    return [content].concat([sourceMapping]).join("\n");
  }
  return [content].join("\n");
};

/***/ }),

/***/ 3225:
/*!************************************************!*\
  !*** ../node_modules/elliptic/lib/elliptic.js ***!
  \************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


var elliptic = exports;
elliptic.version = (__webpack_require__(/*! ../package.json */ 312)/* .version */ .i8);
elliptic.utils = __webpack_require__(/*! ./elliptic/utils */ 8619);
elliptic.rand = __webpack_require__(/*! brorand */ 3796);
elliptic.curve = __webpack_require__(/*! ./elliptic/curve */ 1364);
elliptic.curves = __webpack_require__(/*! ./elliptic/curves */ 4710);

// Protocols
elliptic.ec = __webpack_require__(/*! ./elliptic/ec */ 738);
elliptic.eddsa = __webpack_require__(/*! ./elliptic/eddsa */ 229);

/***/ }),

/***/ 978:
/*!***********************************************************!*\
  !*** ../node_modules/elliptic/lib/elliptic/curve/base.js ***!
  \***********************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


var BN = __webpack_require__(/*! bn.js */ 1046);
var utils = __webpack_require__(/*! ../utils */ 8619);
var getNAF = utils.getNAF;
var getJSF = utils.getJSF;
var assert = utils.assert;
function BaseCurve(type, conf) {
  this.type = type;
  this.p = new BN(conf.p, 16);

  // Use Montgomery, when there is no fast reduction for the prime
  this.red = conf.prime ? BN.red(conf.prime) : BN.mont(this.p);

  // Useful for many curves
  this.zero = new BN(0).toRed(this.red);
  this.one = new BN(1).toRed(this.red);
  this.two = new BN(2).toRed(this.red);

  // Curve configuration, optional
  this.n = conf.n && new BN(conf.n, 16);
  this.g = conf.g && this.pointFromJSON(conf.g, conf.gRed);

  // Temporary arrays
  this._wnafT1 = new Array(4);
  this._wnafT2 = new Array(4);
  this._wnafT3 = new Array(4);
  this._wnafT4 = new Array(4);
  this._bitLength = this.n ? this.n.bitLength() : 0;

  // Generalized Greg Maxwell's trick
  var adjustCount = this.n && this.p.div(this.n);
  if (!adjustCount || adjustCount.cmpn(100) > 0) {
    this.redN = null;
  } else {
    this._maxwellTrick = true;
    this.redN = this.n.toRed(this.red);
  }
}
module.exports = BaseCurve;
BaseCurve.prototype.point = function point() {
  throw new Error('Not implemented');
};
BaseCurve.prototype.validate = function validate() {
  throw new Error('Not implemented');
};
BaseCurve.prototype._fixedNafMul = function _fixedNafMul(p, k) {
  assert(p.precomputed);
  var doubles = p._getDoubles();
  var naf = getNAF(k, 1, this._bitLength);
  var I = (1 << doubles.step + 1) - (doubles.step % 2 === 0 ? 2 : 1);
  I /= 3;

  // Translate into more windowed form
  var repr = [];
  var j;
  var nafW;
  for (j = 0; j < naf.length; j += doubles.step) {
    nafW = 0;
    for (var l = j + doubles.step - 1; l >= j; l--) nafW = (nafW << 1) + naf[l];
    repr.push(nafW);
  }
  var a = this.jpoint(null, null, null);
  var b = this.jpoint(null, null, null);
  for (var i = I; i > 0; i--) {
    for (j = 0; j < repr.length; j++) {
      nafW = repr[j];
      if (nafW === i) b = b.mixedAdd(doubles.points[j]);else if (nafW === -i) b = b.mixedAdd(doubles.points[j].neg());
    }
    a = a.add(b);
  }
  return a.toP();
};
BaseCurve.prototype._wnafMul = function _wnafMul(p, k) {
  var w = 4;

  // Precompute window
  var nafPoints = p._getNAFPoints(w);
  w = nafPoints.wnd;
  var wnd = nafPoints.points;

  // Get NAF form
  var naf = getNAF(k, w, this._bitLength);

  // Add `this`*(N+1) for every w-NAF index
  var acc = this.jpoint(null, null, null);
  for (var i = naf.length - 1; i >= 0; i--) {
    // Count zeroes
    for (var l = 0; i >= 0 && naf[i] === 0; i--) l++;
    if (i >= 0) l++;
    acc = acc.dblp(l);
    if (i < 0) break;
    var z = naf[i];
    assert(z !== 0);
    if (p.type === 'affine') {
      // J +- P
      if (z > 0) acc = acc.mixedAdd(wnd[z - 1 >> 1]);else acc = acc.mixedAdd(wnd[-z - 1 >> 1].neg());
    } else {
      // J +- J
      if (z > 0) acc = acc.add(wnd[z - 1 >> 1]);else acc = acc.add(wnd[-z - 1 >> 1].neg());
    }
  }
  return p.type === 'affine' ? acc.toP() : acc;
};
BaseCurve.prototype._wnafMulAdd = function _wnafMulAdd(defW, points, coeffs, len, jacobianResult) {
  var wndWidth = this._wnafT1;
  var wnd = this._wnafT2;
  var naf = this._wnafT3;

  // Fill all arrays
  var max = 0;
  var i;
  var j;
  var p;
  for (i = 0; i < len; i++) {
    p = points[i];
    var nafPoints = p._getNAFPoints(defW);
    wndWidth[i] = nafPoints.wnd;
    wnd[i] = nafPoints.points;
  }

  // Comb small window NAFs
  for (i = len - 1; i >= 1; i -= 2) {
    var a = i - 1;
    var b = i;
    if (wndWidth[a] !== 1 || wndWidth[b] !== 1) {
      naf[a] = getNAF(coeffs[a], wndWidth[a], this._bitLength);
      naf[b] = getNAF(coeffs[b], wndWidth[b], this._bitLength);
      max = Math.max(naf[a].length, max);
      max = Math.max(naf[b].length, max);
      continue;
    }
    var comb = [points[a], /* 1 */
    null, /* 3 */
    null, /* 5 */
    points[b] /* 7 */];

    // Try to avoid Projective points, if possible
    if (points[a].y.cmp(points[b].y) === 0) {
      comb[1] = points[a].add(points[b]);
      comb[2] = points[a].toJ().mixedAdd(points[b].neg());
    } else if (points[a].y.cmp(points[b].y.redNeg()) === 0) {
      comb[1] = points[a].toJ().mixedAdd(points[b]);
      comb[2] = points[a].add(points[b].neg());
    } else {
      comb[1] = points[a].toJ().mixedAdd(points[b]);
      comb[2] = points[a].toJ().mixedAdd(points[b].neg());
    }
    var index = [-3, /* -1 -1 */
    -1, /* -1 0 */
    -5, /* -1 1 */
    -7, /* 0 -1 */
    0, /* 0 0 */
    7, /* 0 1 */
    5, /* 1 -1 */
    1, /* 1 0 */
    3 /* 1 1 */];

    var jsf = getJSF(coeffs[a], coeffs[b]);
    max = Math.max(jsf[0].length, max);
    naf[a] = new Array(max);
    naf[b] = new Array(max);
    for (j = 0; j < max; j++) {
      var ja = jsf[0][j] | 0;
      var jb = jsf[1][j] | 0;
      naf[a][j] = index[(ja + 1) * 3 + (jb + 1)];
      naf[b][j] = 0;
      wnd[a] = comb;
    }
  }
  var acc = this.jpoint(null, null, null);
  var tmp = this._wnafT4;
  for (i = max; i >= 0; i--) {
    var k = 0;
    while (i >= 0) {
      var zero = true;
      for (j = 0; j < len; j++) {
        tmp[j] = naf[j][i] | 0;
        if (tmp[j] !== 0) zero = false;
      }
      if (!zero) break;
      k++;
      i--;
    }
    if (i >= 0) k++;
    acc = acc.dblp(k);
    if (i < 0) break;
    for (j = 0; j < len; j++) {
      var z = tmp[j];
      p;
      if (z === 0) continue;else if (z > 0) p = wnd[j][z - 1 >> 1];else if (z < 0) p = wnd[j][-z - 1 >> 1].neg();
      if (p.type === 'affine') acc = acc.mixedAdd(p);else acc = acc.add(p);
    }
  }
  // Zeroify references
  for (i = 0; i < len; i++) wnd[i] = null;
  if (jacobianResult) return acc;else return acc.toP();
};
function BasePoint(curve, type) {
  this.curve = curve;
  this.type = type;
  this.precomputed = null;
}
BaseCurve.BasePoint = BasePoint;
BasePoint.prototype.eq = function eq( /*other*/
) {
  throw new Error('Not implemented');
};
BasePoint.prototype.validate = function validate() {
  return this.curve.validate(this);
};
BaseCurve.prototype.decodePoint = function decodePoint(bytes, enc) {
  bytes = utils.toArray(bytes, enc);
  var len = this.p.byteLength();

  // uncompressed, hybrid-odd, hybrid-even
  if ((bytes[0] === 0x04 || bytes[0] === 0x06 || bytes[0] === 0x07) && bytes.length - 1 === 2 * len) {
    if (bytes[0] === 0x06) assert(bytes[bytes.length - 1] % 2 === 0);else if (bytes[0] === 0x07) assert(bytes[bytes.length - 1] % 2 === 1);
    var res = this.point(bytes.slice(1, 1 + len), bytes.slice(1 + len, 1 + 2 * len));
    return res;
  } else if ((bytes[0] === 0x02 || bytes[0] === 0x03) && bytes.length - 1 === len) {
    return this.pointFromX(bytes.slice(1, 1 + len), bytes[0] === 0x03);
  }
  throw new Error('Unknown point format');
};
BasePoint.prototype.encodeCompressed = function encodeCompressed(enc) {
  return this.encode(enc, true);
};
BasePoint.prototype._encode = function _encode(compact) {
  var len = this.curve.p.byteLength();
  var x = this.getX().toArray('be', len);
  if (compact) return [this.getY().isEven() ? 0x02 : 0x03].concat(x);
  return [0x04].concat(x, this.getY().toArray('be', len));
};
BasePoint.prototype.encode = function encode(enc, compact) {
  return utils.encode(this._encode(compact), enc);
};
BasePoint.prototype.precompute = function precompute(power) {
  if (this.precomputed) return this;
  var precomputed = {
    doubles: null,
    naf: null,
    beta: null
  };
  precomputed.naf = this._getNAFPoints(8);
  precomputed.doubles = this._getDoubles(4, power);
  precomputed.beta = this._getBeta();
  this.precomputed = precomputed;
  return this;
};
BasePoint.prototype._hasDoubles = function _hasDoubles(k) {
  if (!this.precomputed) return false;
  var doubles = this.precomputed.doubles;
  if (!doubles) return false;
  return doubles.points.length >= Math.ceil((k.bitLength() + 1) / doubles.step);
};
BasePoint.prototype._getDoubles = function _getDoubles(step, power) {
  if (this.precomputed && this.precomputed.doubles) return this.precomputed.doubles;
  var doubles = [this];
  var acc = this;
  for (var i = 0; i < power; i += step) {
    for (var j = 0; j < step; j++) acc = acc.dbl();
    doubles.push(acc);
  }
  return {
    step: step,
    points: doubles
  };
};
BasePoint.prototype._getNAFPoints = function _getNAFPoints(wnd) {
  if (this.precomputed && this.precomputed.naf) return this.precomputed.naf;
  var res = [this];
  var max = (1 << wnd) - 1;
  var dbl = max === 1 ? null : this.dbl();
  for (var i = 1; i < max; i++) res[i] = res[i - 1].add(dbl);
  return {
    wnd: wnd,
    points: res
  };
};
BasePoint.prototype._getBeta = function _getBeta() {
  return null;
};
BasePoint.prototype.dblp = function dblp(k) {
  var r = this;
  for (var i = 0; i < k; i++) r = r.dbl();
  return r;
};

/***/ }),

/***/ 5295:
/*!**************************************************************!*\
  !*** ../node_modules/elliptic/lib/elliptic/curve/edwards.js ***!
  \**************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


var utils = __webpack_require__(/*! ../utils */ 8619);
var BN = __webpack_require__(/*! bn.js */ 1046);
var inherits = __webpack_require__(/*! inherits */ 7694);
var Base = __webpack_require__(/*! ./base */ 978);
var assert = utils.assert;
function EdwardsCurve(conf) {
  // NOTE: Important as we are creating point in Base.call()
  this.twisted = (conf.a | 0) !== 1;
  this.mOneA = this.twisted && (conf.a | 0) === -1;
  this.extended = this.mOneA;
  Base.call(this, 'edwards', conf);
  this.a = new BN(conf.a, 16).umod(this.red.m);
  this.a = this.a.toRed(this.red);
  this.c = new BN(conf.c, 16).toRed(this.red);
  this.c2 = this.c.redSqr();
  this.d = new BN(conf.d, 16).toRed(this.red);
  this.dd = this.d.redAdd(this.d);
  assert(!this.twisted || this.c.fromRed().cmpn(1) === 0);
  this.oneC = (conf.c | 0) === 1;
}
inherits(EdwardsCurve, Base);
module.exports = EdwardsCurve;
EdwardsCurve.prototype._mulA = function _mulA(num) {
  if (this.mOneA) return num.redNeg();else return this.a.redMul(num);
};
EdwardsCurve.prototype._mulC = function _mulC(num) {
  if (this.oneC) return num;else return this.c.redMul(num);
};

// Just for compatibility with Short curve
EdwardsCurve.prototype.jpoint = function jpoint(x, y, z, t) {
  return this.point(x, y, z, t);
};
EdwardsCurve.prototype.pointFromX = function pointFromX(x, odd) {
  x = new BN(x, 16);
  if (!x.red) x = x.toRed(this.red);
  var x2 = x.redSqr();
  var rhs = this.c2.redSub(this.a.redMul(x2));
  var lhs = this.one.redSub(this.c2.redMul(this.d).redMul(x2));
  var y2 = rhs.redMul(lhs.redInvm());
  var y = y2.redSqrt();
  if (y.redSqr().redSub(y2).cmp(this.zero) !== 0) throw new Error('invalid point');
  var isOdd = y.fromRed().isOdd();
  if (odd && !isOdd || !odd && isOdd) y = y.redNeg();
  return this.point(x, y);
};
EdwardsCurve.prototype.pointFromY = function pointFromY(y, odd) {
  y = new BN(y, 16);
  if (!y.red) y = y.toRed(this.red);

  // x^2 = (y^2 - c^2) / (c^2 d y^2 - a)
  var y2 = y.redSqr();
  var lhs = y2.redSub(this.c2);
  var rhs = y2.redMul(this.d).redMul(this.c2).redSub(this.a);
  var x2 = lhs.redMul(rhs.redInvm());
  if (x2.cmp(this.zero) === 0) {
    if (odd) throw new Error('invalid point');else return this.point(this.zero, y);
  }
  var x = x2.redSqrt();
  if (x.redSqr().redSub(x2).cmp(this.zero) !== 0) throw new Error('invalid point');
  if (x.fromRed().isOdd() !== odd) x = x.redNeg();
  return this.point(x, y);
};
EdwardsCurve.prototype.validate = function validate(point) {
  if (point.isInfinity()) return true;

  // Curve: A * X^2 + Y^2 = C^2 * (1 + D * X^2 * Y^2)
  point.normalize();
  var x2 = point.x.redSqr();
  var y2 = point.y.redSqr();
  var lhs = x2.redMul(this.a).redAdd(y2);
  var rhs = this.c2.redMul(this.one.redAdd(this.d.redMul(x2).redMul(y2)));
  return lhs.cmp(rhs) === 0;
};
function Point(curve, x, y, z, t) {
  Base.BasePoint.call(this, curve, 'projective');
  if (x === null && y === null && z === null) {
    this.x = this.curve.zero;
    this.y = this.curve.one;
    this.z = this.curve.one;
    this.t = this.curve.zero;
    this.zOne = true;
  } else {
    this.x = new BN(x, 16);
    this.y = new BN(y, 16);
    this.z = z ? new BN(z, 16) : this.curve.one;
    this.t = t && new BN(t, 16);
    if (!this.x.red) this.x = this.x.toRed(this.curve.red);
    if (!this.y.red) this.y = this.y.toRed(this.curve.red);
    if (!this.z.red) this.z = this.z.toRed(this.curve.red);
    if (this.t && !this.t.red) this.t = this.t.toRed(this.curve.red);
    this.zOne = this.z === this.curve.one;

    // Use extended coordinates
    if (this.curve.extended && !this.t) {
      this.t = this.x.redMul(this.y);
      if (!this.zOne) this.t = this.t.redMul(this.z.redInvm());
    }
  }
}
inherits(Point, Base.BasePoint);
EdwardsCurve.prototype.pointFromJSON = function pointFromJSON(obj) {
  return Point.fromJSON(this, obj);
};
EdwardsCurve.prototype.point = function point(x, y, z, t) {
  return new Point(this, x, y, z, t);
};
Point.fromJSON = function fromJSON(curve, obj) {
  return new Point(curve, obj[0], obj[1], obj[2]);
};
Point.prototype.inspect = function inspect() {
  if (this.isInfinity()) return '<EC Point Infinity>';
  return '<EC Point x: ' + this.x.fromRed().toString(16, 2) + ' y: ' + this.y.fromRed().toString(16, 2) + ' z: ' + this.z.fromRed().toString(16, 2) + '>';
};
Point.prototype.isInfinity = function isInfinity() {
  // XXX This code assumes that zero is always zero in red
  return this.x.cmpn(0) === 0 && (this.y.cmp(this.z) === 0 || this.zOne && this.y.cmp(this.curve.c) === 0);
};
Point.prototype._extDbl = function _extDbl() {
  // hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html
  //     #doubling-dbl-2008-hwcd
  // 4M + 4S

  // A = X1^2
  var a = this.x.redSqr();
  // B = Y1^2
  var b = this.y.redSqr();
  // C = 2 * Z1^2
  var c = this.z.redSqr();
  c = c.redIAdd(c);
  // D = a * A
  var d = this.curve._mulA(a);
  // E = (X1 + Y1)^2 - A - B
  var e = this.x.redAdd(this.y).redSqr().redISub(a).redISub(b);
  // G = D + B
  var g = d.redAdd(b);
  // F = G - C
  var f = g.redSub(c);
  // H = D - B
  var h = d.redSub(b);
  // X3 = E * F
  var nx = e.redMul(f);
  // Y3 = G * H
  var ny = g.redMul(h);
  // T3 = E * H
  var nt = e.redMul(h);
  // Z3 = F * G
  var nz = f.redMul(g);
  return this.curve.point(nx, ny, nz, nt);
};
Point.prototype._projDbl = function _projDbl() {
  // hyperelliptic.org/EFD/g1p/auto-twisted-projective.html
  //     #doubling-dbl-2008-bbjlp
  //     #doubling-dbl-2007-bl
  // and others
  // Generally 3M + 4S or 2M + 4S

  // B = (X1 + Y1)^2
  var b = this.x.redAdd(this.y).redSqr();
  // C = X1^2
  var c = this.x.redSqr();
  // D = Y1^2
  var d = this.y.redSqr();
  var nx;
  var ny;
  var nz;
  var e;
  var h;
  var j;
  if (this.curve.twisted) {
    // E = a * C
    e = this.curve._mulA(c);
    // F = E + D
    var f = e.redAdd(d);
    if (this.zOne) {
      // X3 = (B - C - D) * (F - 2)
      nx = b.redSub(c).redSub(d).redMul(f.redSub(this.curve.two));
      // Y3 = F * (E - D)
      ny = f.redMul(e.redSub(d));
      // Z3 = F^2 - 2 * F
      nz = f.redSqr().redSub(f).redSub(f);
    } else {
      // H = Z1^2
      h = this.z.redSqr();
      // J = F - 2 * H
      j = f.redSub(h).redISub(h);
      // X3 = (B-C-D)*J
      nx = b.redSub(c).redISub(d).redMul(j);
      // Y3 = F * (E - D)
      ny = f.redMul(e.redSub(d));
      // Z3 = F * J
      nz = f.redMul(j);
    }
  } else {
    // E = C + D
    e = c.redAdd(d);
    // H = (c * Z1)^2
    h = this.curve._mulC(this.z).redSqr();
    // J = E - 2 * H
    j = e.redSub(h).redSub(h);
    // X3 = c * (B - E) * J
    nx = this.curve._mulC(b.redISub(e)).redMul(j);
    // Y3 = c * E * (C - D)
    ny = this.curve._mulC(e).redMul(c.redISub(d));
    // Z3 = E * J
    nz = e.redMul(j);
  }
  return this.curve.point(nx, ny, nz);
};
Point.prototype.dbl = function dbl() {
  if (this.isInfinity()) return this;

  // Double in extended coordinates
  if (this.curve.extended) return this._extDbl();else return this._projDbl();
};
Point.prototype._extAdd = function _extAdd(p) {
  // hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html
  //     #addition-add-2008-hwcd-3
  // 8M

  // A = (Y1 - X1) * (Y2 - X2)
  var a = this.y.redSub(this.x).redMul(p.y.redSub(p.x));
  // B = (Y1 + X1) * (Y2 + X2)
  var b = this.y.redAdd(this.x).redMul(p.y.redAdd(p.x));
  // C = T1 * k * T2
  var c = this.t.redMul(this.curve.dd).redMul(p.t);
  // D = Z1 * 2 * Z2
  var d = this.z.redMul(p.z.redAdd(p.z));
  // E = B - A
  var e = b.redSub(a);
  // F = D - C
  var f = d.redSub(c);
  // G = D + C
  var g = d.redAdd(c);
  // H = B + A
  var h = b.redAdd(a);
  // X3 = E * F
  var nx = e.redMul(f);
  // Y3 = G * H
  var ny = g.redMul(h);
  // T3 = E * H
  var nt = e.redMul(h);
  // Z3 = F * G
  var nz = f.redMul(g);
  return this.curve.point(nx, ny, nz, nt);
};
Point.prototype._projAdd = function _projAdd(p) {
  // hyperelliptic.org/EFD/g1p/auto-twisted-projective.html
  //     #addition-add-2008-bbjlp
  //     #addition-add-2007-bl
  // 10M + 1S

  // A = Z1 * Z2
  var a = this.z.redMul(p.z);
  // B = A^2
  var b = a.redSqr();
  // C = X1 * X2
  var c = this.x.redMul(p.x);
  // D = Y1 * Y2
  var d = this.y.redMul(p.y);
  // E = d * C * D
  var e = this.curve.d.redMul(c).redMul(d);
  // F = B - E
  var f = b.redSub(e);
  // G = B + E
  var g = b.redAdd(e);
  // X3 = A * F * ((X1 + Y1) * (X2 + Y2) - C - D)
  var tmp = this.x.redAdd(this.y).redMul(p.x.redAdd(p.y)).redISub(c).redISub(d);
  var nx = a.redMul(f).redMul(tmp);
  var ny;
  var nz;
  if (this.curve.twisted) {
    // Y3 = A * G * (D - a * C)
    ny = a.redMul(g).redMul(d.redSub(this.curve._mulA(c)));
    // Z3 = F * G
    nz = f.redMul(g);
  } else {
    // Y3 = A * G * (D - C)
    ny = a.redMul(g).redMul(d.redSub(c));
    // Z3 = c * F * G
    nz = this.curve._mulC(f).redMul(g);
  }
  return this.curve.point(nx, ny, nz);
};
Point.prototype.add = function add(p) {
  if (this.isInfinity()) return p;
  if (p.isInfinity()) return this;
  if (this.curve.extended) return this._extAdd(p);else return this._projAdd(p);
};
Point.prototype.mul = function mul(k) {
  if (this._hasDoubles(k)) return this.curve._fixedNafMul(this, k);else return this.curve._wnafMul(this, k);
};
Point.prototype.mulAdd = function mulAdd(k1, p, k2) {
  return this.curve._wnafMulAdd(1, [this, p], [k1, k2], 2, false);
};
Point.prototype.jmulAdd = function jmulAdd(k1, p, k2) {
  return this.curve._wnafMulAdd(1, [this, p], [k1, k2], 2, true);
};
Point.prototype.normalize = function normalize() {
  if (this.zOne) return this;

  // Normalize coordinates
  var zi = this.z.redInvm();
  this.x = this.x.redMul(zi);
  this.y = this.y.redMul(zi);
  if (this.t) this.t = this.t.redMul(zi);
  this.z = this.curve.one;
  this.zOne = true;
  return this;
};
Point.prototype.neg = function neg() {
  return this.curve.point(this.x.redNeg(), this.y, this.z, this.t && this.t.redNeg());
};
Point.prototype.getX = function getX() {
  this.normalize();
  return this.x.fromRed();
};
Point.prototype.getY = function getY() {
  this.normalize();
  return this.y.fromRed();
};
Point.prototype.eq = function eq(other) {
  return this === other || this.getX().cmp(other.getX()) === 0 && this.getY().cmp(other.getY()) === 0;
};
Point.prototype.eqXToP = function eqXToP(x) {
  var rx = x.toRed(this.curve.red).redMul(this.z);
  if (this.x.cmp(rx) === 0) return true;
  var xc = x.clone();
  var t = this.curve.redN.redMul(this.z);
  for (;;) {
    xc.iadd(this.curve.n);
    if (xc.cmp(this.curve.p) >= 0) return false;
    rx.redIAdd(t);
    if (this.x.cmp(rx) === 0) return true;
  }
};

// Compatibility with BaseCurve
Point.prototype.toP = Point.prototype.normalize;
Point.prototype.mixedAdd = Point.prototype.add;

/***/ }),

/***/ 1364:
/*!************************************************************!*\
  !*** ../node_modules/elliptic/lib/elliptic/curve/index.js ***!
  \************************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


var curve = exports;
curve.base = __webpack_require__(/*! ./base */ 978);
curve.short = __webpack_require__(/*! ./short */ 5431);
curve.mont = __webpack_require__(/*! ./mont */ 1921);
curve.edwards = __webpack_require__(/*! ./edwards */ 5295);

/***/ }),

/***/ 1921:
/*!***********************************************************!*\
  !*** ../node_modules/elliptic/lib/elliptic/curve/mont.js ***!
  \***********************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


var BN = __webpack_require__(/*! bn.js */ 1046);
var inherits = __webpack_require__(/*! inherits */ 7694);
var Base = __webpack_require__(/*! ./base */ 978);
var utils = __webpack_require__(/*! ../utils */ 8619);
function MontCurve(conf) {
  Base.call(this, 'mont', conf);
  this.a = new BN(conf.a, 16).toRed(this.red);
  this.b = new BN(conf.b, 16).toRed(this.red);
  this.i4 = new BN(4).toRed(this.red).redInvm();
  this.two = new BN(2).toRed(this.red);
  this.a24 = this.i4.redMul(this.a.redAdd(this.two));
}
inherits(MontCurve, Base);
module.exports = MontCurve;
MontCurve.prototype.validate = function validate(point) {
  var x = point.normalize().x;
  var x2 = x.redSqr();
  var rhs = x2.redMul(x).redAdd(x2.redMul(this.a)).redAdd(x);
  var y = rhs.redSqrt();
  return y.redSqr().cmp(rhs) === 0;
};
function Point(curve, x, z) {
  Base.BasePoint.call(this, curve, 'projective');
  if (x === null && z === null) {
    this.x = this.curve.one;
    this.z = this.curve.zero;
  } else {
    this.x = new BN(x, 16);
    this.z = new BN(z, 16);
    if (!this.x.red) this.x = this.x.toRed(this.curve.red);
    if (!this.z.red) this.z = this.z.toRed(this.curve.red);
  }
}
inherits(Point, Base.BasePoint);
MontCurve.prototype.decodePoint = function decodePoint(bytes, enc) {
  return this.point(utils.toArray(bytes, enc), 1);
};
MontCurve.prototype.point = function point(x, z) {
  return new Point(this, x, z);
};
MontCurve.prototype.pointFromJSON = function pointFromJSON(obj) {
  return Point.fromJSON(this, obj);
};
Point.prototype.precompute = function precompute() {
  // No-op
};
Point.prototype._encode = function _encode() {
  return this.getX().toArray('be', this.curve.p.byteLength());
};
Point.fromJSON = function fromJSON(curve, obj) {
  return new Point(curve, obj[0], obj[1] || curve.one);
};
Point.prototype.inspect = function inspect() {
  if (this.isInfinity()) return '<EC Point Infinity>';
  return '<EC Point x: ' + this.x.fromRed().toString(16, 2) + ' z: ' + this.z.fromRed().toString(16, 2) + '>';
};
Point.prototype.isInfinity = function isInfinity() {
  // XXX This code assumes that zero is always zero in red
  return this.z.cmpn(0) === 0;
};
Point.prototype.dbl = function dbl() {
  // http://hyperelliptic.org/EFD/g1p/auto-montgom-xz.html#doubling-dbl-1987-m-3
  // 2M + 2S + 4A

  // A = X1 + Z1
  var a = this.x.redAdd(this.z);
  // AA = A^2
  var aa = a.redSqr();
  // B = X1 - Z1
  var b = this.x.redSub(this.z);
  // BB = B^2
  var bb = b.redSqr();
  // C = AA - BB
  var c = aa.redSub(bb);
  // X3 = AA * BB
  var nx = aa.redMul(bb);
  // Z3 = C * (BB + A24 * C)
  var nz = c.redMul(bb.redAdd(this.curve.a24.redMul(c)));
  return this.curve.point(nx, nz);
};
Point.prototype.add = function add() {
  throw new Error('Not supported on Montgomery curve');
};
Point.prototype.diffAdd = function diffAdd(p, diff) {
  // http://hyperelliptic.org/EFD/g1p/auto-montgom-xz.html#diffadd-dadd-1987-m-3
  // 4M + 2S + 6A

  // A = X2 + Z2
  var a = this.x.redAdd(this.z);
  // B = X2 - Z2
  var b = this.x.redSub(this.z);
  // C = X3 + Z3
  var c = p.x.redAdd(p.z);
  // D = X3 - Z3
  var d = p.x.redSub(p.z);
  // DA = D * A
  var da = d.redMul(a);
  // CB = C * B
  var cb = c.redMul(b);
  // X5 = Z1 * (DA + CB)^2
  var nx = diff.z.redMul(da.redAdd(cb).redSqr());
  // Z5 = X1 * (DA - CB)^2
  var nz = diff.x.redMul(da.redISub(cb).redSqr());
  return this.curve.point(nx, nz);
};
Point.prototype.mul = function mul(k) {
  var t = k.clone();
  var a = this; // (N / 2) * Q + Q
  var b = this.curve.point(null, null); // (N / 2) * Q
  var c = this; // Q

  for (var bits = []; t.cmpn(0) !== 0; t.iushrn(1)) bits.push(t.andln(1));
  for (var i = bits.length - 1; i >= 0; i--) {
    if (bits[i] === 0) {
      // N * Q + Q = ((N / 2) * Q + Q)) + (N / 2) * Q
      a = a.diffAdd(b, c);
      // N * Q = 2 * ((N / 2) * Q + Q))
      b = b.dbl();
    } else {
      // N * Q = ((N / 2) * Q + Q) + ((N / 2) * Q)
      b = a.diffAdd(b, c);
      // N * Q + Q = 2 * ((N / 2) * Q + Q)
      a = a.dbl();
    }
  }
  return b;
};
Point.prototype.mulAdd = function mulAdd() {
  throw new Error('Not supported on Montgomery curve');
};
Point.prototype.jumlAdd = function jumlAdd() {
  throw new Error('Not supported on Montgomery curve');
};
Point.prototype.eq = function eq(other) {
  return this.getX().cmp(other.getX()) === 0;
};
Point.prototype.normalize = function normalize() {
  this.x = this.x.redMul(this.z.redInvm());
  this.z = this.curve.one;
  return this;
};
Point.prototype.getX = function getX() {
  // Normalize coordinates
  this.normalize();
  return this.x.fromRed();
};

/***/ }),

/***/ 5431:
/*!************************************************************!*\
  !*** ../node_modules/elliptic/lib/elliptic/curve/short.js ***!
  \************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


var utils = __webpack_require__(/*! ../utils */ 8619);
var BN = __webpack_require__(/*! bn.js */ 1046);
var inherits = __webpack_require__(/*! inherits */ 7694);
var Base = __webpack_require__(/*! ./base */ 978);
var assert = utils.assert;
function ShortCurve(conf) {
  Base.call(this, 'short', conf);
  this.a = new BN(conf.a, 16).toRed(this.red);
  this.b = new BN(conf.b, 16).toRed(this.red);
  this.tinv = this.two.redInvm();
  this.zeroA = this.a.fromRed().cmpn(0) === 0;
  this.threeA = this.a.fromRed().sub(this.p).cmpn(-3) === 0;

  // If the curve is endomorphic, precalculate beta and lambda
  this.endo = this._getEndomorphism(conf);
  this._endoWnafT1 = new Array(4);
  this._endoWnafT2 = new Array(4);
}
inherits(ShortCurve, Base);
module.exports = ShortCurve;
ShortCurve.prototype._getEndomorphism = function _getEndomorphism(conf) {
  // No efficient endomorphism
  if (!this.zeroA || !this.g || !this.n || this.p.modn(3) !== 1) return;

  // Compute beta and lambda, that lambda * P = (beta * Px; Py)
  var beta;
  var lambda;
  if (conf.beta) {
    beta = new BN(conf.beta, 16).toRed(this.red);
  } else {
    var betas = this._getEndoRoots(this.p);
    // Choose the smallest beta
    beta = betas[0].cmp(betas[1]) < 0 ? betas[0] : betas[1];
    beta = beta.toRed(this.red);
  }
  if (conf.lambda) {
    lambda = new BN(conf.lambda, 16);
  } else {
    // Choose the lambda that is matching selected beta
    var lambdas = this._getEndoRoots(this.n);
    if (this.g.mul(lambdas[0]).x.cmp(this.g.x.redMul(beta)) === 0) {
      lambda = lambdas[0];
    } else {
      lambda = lambdas[1];
      assert(this.g.mul(lambda).x.cmp(this.g.x.redMul(beta)) === 0);
    }
  }

  // Get basis vectors, used for balanced length-two representation
  var basis;
  if (conf.basis) {
    basis = conf.basis.map(function (vec) {
      return {
        a: new BN(vec.a, 16),
        b: new BN(vec.b, 16)
      };
    });
  } else {
    basis = this._getEndoBasis(lambda);
  }
  return {
    beta: beta,
    lambda: lambda,
    basis: basis
  };
};
ShortCurve.prototype._getEndoRoots = function _getEndoRoots(num) {
  // Find roots of for x^2 + x + 1 in F
  // Root = (-1 +- Sqrt(-3)) / 2
  //
  var red = num === this.p ? this.red : BN.mont(num);
  var tinv = new BN(2).toRed(red).redInvm();
  var ntinv = tinv.redNeg();
  var s = new BN(3).toRed(red).redNeg().redSqrt().redMul(tinv);
  var l1 = ntinv.redAdd(s).fromRed();
  var l2 = ntinv.redSub(s).fromRed();
  return [l1, l2];
};
ShortCurve.prototype._getEndoBasis = function _getEndoBasis(lambda) {
  // aprxSqrt >= sqrt(this.n)
  var aprxSqrt = this.n.ushrn(Math.floor(this.n.bitLength() / 2));

  // 3.74
  // Run EGCD, until r(L + 1) < aprxSqrt
  var u = lambda;
  var v = this.n.clone();
  var x1 = new BN(1);
  var y1 = new BN(0);
  var x2 = new BN(0);
  var y2 = new BN(1);

  // NOTE: all vectors are roots of: a + b * lambda = 0 (mod n)
  var a0;
  var b0;
  // First vector
  var a1;
  var b1;
  // Second vector
  var a2;
  var b2;
  var prevR;
  var i = 0;
  var r;
  var x;
  while (u.cmpn(0) !== 0) {
    var q = v.div(u);
    r = v.sub(q.mul(u));
    x = x2.sub(q.mul(x1));
    var y = y2.sub(q.mul(y1));
    if (!a1 && r.cmp(aprxSqrt) < 0) {
      a0 = prevR.neg();
      b0 = x1;
      a1 = r.neg();
      b1 = x;
    } else if (a1 && ++i === 2) {
      break;
    }
    prevR = r;
    v = u;
    u = r;
    x2 = x1;
    x1 = x;
    y2 = y1;
    y1 = y;
  }
  a2 = r.neg();
  b2 = x;
  var len1 = a1.sqr().add(b1.sqr());
  var len2 = a2.sqr().add(b2.sqr());
  if (len2.cmp(len1) >= 0) {
    a2 = a0;
    b2 = b0;
  }

  // Normalize signs
  if (a1.negative) {
    a1 = a1.neg();
    b1 = b1.neg();
  }
  if (a2.negative) {
    a2 = a2.neg();
    b2 = b2.neg();
  }
  return [{
    a: a1,
    b: b1
  }, {
    a: a2,
    b: b2
  }];
};
ShortCurve.prototype._endoSplit = function _endoSplit(k) {
  var basis = this.endo.basis;
  var v1 = basis[0];
  var v2 = basis[1];
  var c1 = v2.b.mul(k).divRound(this.n);
  var c2 = v1.b.neg().mul(k).divRound(this.n);
  var p1 = c1.mul(v1.a);
  var p2 = c2.mul(v2.a);
  var q1 = c1.mul(v1.b);
  var q2 = c2.mul(v2.b);

  // Calculate answer
  var k1 = k.sub(p1).sub(p2);
  var k2 = q1.add(q2).neg();
  return {
    k1: k1,
    k2: k2
  };
};
ShortCurve.prototype.pointFromX = function pointFromX(x, odd) {
  x = new BN(x, 16);
  if (!x.red) x = x.toRed(this.red);
  var y2 = x.redSqr().redMul(x).redIAdd(x.redMul(this.a)).redIAdd(this.b);
  var y = y2.redSqrt();
  if (y.redSqr().redSub(y2).cmp(this.zero) !== 0) throw new Error('invalid point');

  // XXX Is there any way to tell if the number is odd without converting it
  // to non-red form?
  var isOdd = y.fromRed().isOdd();
  if (odd && !isOdd || !odd && isOdd) y = y.redNeg();
  return this.point(x, y);
};
ShortCurve.prototype.validate = function validate(point) {
  if (point.inf) return true;
  var x = point.x;
  var y = point.y;
  var ax = this.a.redMul(x);
  var rhs = x.redSqr().redMul(x).redIAdd(ax).redIAdd(this.b);
  return y.redSqr().redISub(rhs).cmpn(0) === 0;
};
ShortCurve.prototype._endoWnafMulAdd = function _endoWnafMulAdd(points, coeffs, jacobianResult) {
  var npoints = this._endoWnafT1;
  var ncoeffs = this._endoWnafT2;
  for (var i = 0; i < points.length; i++) {
    var split = this._endoSplit(coeffs[i]);
    var p = points[i];
    var beta = p._getBeta();
    if (split.k1.negative) {
      split.k1.ineg();
      p = p.neg(true);
    }
    if (split.k2.negative) {
      split.k2.ineg();
      beta = beta.neg(true);
    }
    npoints[i * 2] = p;
    npoints[i * 2 + 1] = beta;
    ncoeffs[i * 2] = split.k1;
    ncoeffs[i * 2 + 1] = split.k2;
  }
  var res = this._wnafMulAdd(1, npoints, ncoeffs, i * 2, jacobianResult);

  // Clean-up references to points and coefficients
  for (var j = 0; j < i * 2; j++) {
    npoints[j] = null;
    ncoeffs[j] = null;
  }
  return res;
};
function Point(curve, x, y, isRed) {
  Base.BasePoint.call(this, curve, 'affine');
  if (x === null && y === null) {
    this.x = null;
    this.y = null;
    this.inf = true;
  } else {
    this.x = new BN(x, 16);
    this.y = new BN(y, 16);
    // Force redgomery representation when loading from JSON
    if (isRed) {
      this.x.forceRed(this.curve.red);
      this.y.forceRed(this.curve.red);
    }
    if (!this.x.red) this.x = this.x.toRed(this.curve.red);
    if (!this.y.red) this.y = this.y.toRed(this.curve.red);
    this.inf = false;
  }
}
inherits(Point, Base.BasePoint);
ShortCurve.prototype.point = function point(x, y, isRed) {
  return new Point(this, x, y, isRed);
};
ShortCurve.prototype.pointFromJSON = function pointFromJSON(obj, red) {
  return Point.fromJSON(this, obj, red);
};
Point.prototype._getBeta = function _getBeta() {
  if (!this.curve.endo) return;
  var pre = this.precomputed;
  if (pre && pre.beta) return pre.beta;
  var beta = this.curve.point(this.x.redMul(this.curve.endo.beta), this.y);
  if (pre) {
    var curve = this.curve;
    var endoMul = function (p) {
      return curve.point(p.x.redMul(curve.endo.beta), p.y);
    };
    pre.beta = beta;
    beta.precomputed = {
      beta: null,
      naf: pre.naf && {
        wnd: pre.naf.wnd,
        points: pre.naf.points.map(endoMul)
      },
      doubles: pre.doubles && {
        step: pre.doubles.step,
        points: pre.doubles.points.map(endoMul)
      }
    };
  }
  return beta;
};
Point.prototype.toJSON = function toJSON() {
  if (!this.precomputed) return [this.x, this.y];
  return [this.x, this.y, this.precomputed && {
    doubles: this.precomputed.doubles && {
      step: this.precomputed.doubles.step,
      points: this.precomputed.doubles.points.slice(1)
    },
    naf: this.precomputed.naf && {
      wnd: this.precomputed.naf.wnd,
      points: this.precomputed.naf.points.slice(1)
    }
  }];
};
Point.fromJSON = function fromJSON(curve, obj, red) {
  if (typeof obj === 'string') obj = JSON.parse(obj);
  var res = curve.point(obj[0], obj[1], red);
  if (!obj[2]) return res;
  function obj2point(obj) {
    return curve.point(obj[0], obj[1], red);
  }
  var pre = obj[2];
  res.precomputed = {
    beta: null,
    doubles: pre.doubles && {
      step: pre.doubles.step,
      points: [res].concat(pre.doubles.points.map(obj2point))
    },
    naf: pre.naf && {
      wnd: pre.naf.wnd,
      points: [res].concat(pre.naf.points.map(obj2point))
    }
  };
  return res;
};
Point.prototype.inspect = function inspect() {
  if (this.isInfinity()) return '<EC Point Infinity>';
  return '<EC Point x: ' + this.x.fromRed().toString(16, 2) + ' y: ' + this.y.fromRed().toString(16, 2) + '>';
};
Point.prototype.isInfinity = function isInfinity() {
  return this.inf;
};
Point.prototype.add = function add(p) {
  // O + P = P
  if (this.inf) return p;

  // P + O = P
  if (p.inf) return this;

  // P + P = 2P
  if (this.eq(p)) return this.dbl();

  // P + (-P) = O
  if (this.neg().eq(p)) return this.curve.point(null, null);

  // P + Q = O
  if (this.x.cmp(p.x) === 0) return this.curve.point(null, null);
  var c = this.y.redSub(p.y);
  if (c.cmpn(0) !== 0) c = c.redMul(this.x.redSub(p.x).redInvm());
  var nx = c.redSqr().redISub(this.x).redISub(p.x);
  var ny = c.redMul(this.x.redSub(nx)).redISub(this.y);
  return this.curve.point(nx, ny);
};
Point.prototype.dbl = function dbl() {
  if (this.inf) return this;

  // 2P = O
  var ys1 = this.y.redAdd(this.y);
  if (ys1.cmpn(0) === 0) return this.curve.point(null, null);
  var a = this.curve.a;
  var x2 = this.x.redSqr();
  var dyinv = ys1.redInvm();
  var c = x2.redAdd(x2).redIAdd(x2).redIAdd(a).redMul(dyinv);
  var nx = c.redSqr().redISub(this.x.redAdd(this.x));
  var ny = c.redMul(this.x.redSub(nx)).redISub(this.y);
  return this.curve.point(nx, ny);
};
Point.prototype.getX = function getX() {
  return this.x.fromRed();
};
Point.prototype.getY = function getY() {
  return this.y.fromRed();
};
Point.prototype.mul = function mul(k) {
  k = new BN(k, 16);
  if (this.isInfinity()) return this;else if (this._hasDoubles(k)) return this.curve._fixedNafMul(this, k);else if (this.curve.endo) return this.curve._endoWnafMulAdd([this], [k]);else return this.curve._wnafMul(this, k);
};
Point.prototype.mulAdd = function mulAdd(k1, p2, k2) {
  var points = [this, p2];
  var coeffs = [k1, k2];
  if (this.curve.endo) return this.curve._endoWnafMulAdd(points, coeffs);else return this.curve._wnafMulAdd(1, points, coeffs, 2);
};
Point.prototype.jmulAdd = function jmulAdd(k1, p2, k2) {
  var points = [this, p2];
  var coeffs = [k1, k2];
  if (this.curve.endo) return this.curve._endoWnafMulAdd(points, coeffs, true);else return this.curve._wnafMulAdd(1, points, coeffs, 2, true);
};
Point.prototype.eq = function eq(p) {
  return this === p || this.inf === p.inf && (this.inf || this.x.cmp(p.x) === 0 && this.y.cmp(p.y) === 0);
};
Point.prototype.neg = function neg(_precompute) {
  if (this.inf) return this;
  var res = this.curve.point(this.x, this.y.redNeg());
  if (_precompute && this.precomputed) {
    var pre = this.precomputed;
    var negate = function (p) {
      return p.neg();
    };
    res.precomputed = {
      naf: pre.naf && {
        wnd: pre.naf.wnd,
        points: pre.naf.points.map(negate)
      },
      doubles: pre.doubles && {
        step: pre.doubles.step,
        points: pre.doubles.points.map(negate)
      }
    };
  }
  return res;
};
Point.prototype.toJ = function toJ() {
  if (this.inf) return this.curve.jpoint(null, null, null);
  var res = this.curve.jpoint(this.x, this.y, this.curve.one);
  return res;
};
function JPoint(curve, x, y, z) {
  Base.BasePoint.call(this, curve, 'jacobian');
  if (x === null && y === null && z === null) {
    this.x = this.curve.one;
    this.y = this.curve.one;
    this.z = new BN(0);
  } else {
    this.x = new BN(x, 16);
    this.y = new BN(y, 16);
    this.z = new BN(z, 16);
  }
  if (!this.x.red) this.x = this.x.toRed(this.curve.red);
  if (!this.y.red) this.y = this.y.toRed(this.curve.red);
  if (!this.z.red) this.z = this.z.toRed(this.curve.red);
  this.zOne = this.z === this.curve.one;
}
inherits(JPoint, Base.BasePoint);
ShortCurve.prototype.jpoint = function jpoint(x, y, z) {
  return new JPoint(this, x, y, z);
};
JPoint.prototype.toP = function toP() {
  if (this.isInfinity()) return this.curve.point(null, null);
  var zinv = this.z.redInvm();
  var zinv2 = zinv.redSqr();
  var ax = this.x.redMul(zinv2);
  var ay = this.y.redMul(zinv2).redMul(zinv);
  return this.curve.point(ax, ay);
};
JPoint.prototype.neg = function neg() {
  return this.curve.jpoint(this.x, this.y.redNeg(), this.z);
};
JPoint.prototype.add = function add(p) {
  // O + P = P
  if (this.isInfinity()) return p;

  // P + O = P
  if (p.isInfinity()) return this;

  // 12M + 4S + 7A
  var pz2 = p.z.redSqr();
  var z2 = this.z.redSqr();
  var u1 = this.x.redMul(pz2);
  var u2 = p.x.redMul(z2);
  var s1 = this.y.redMul(pz2.redMul(p.z));
  var s2 = p.y.redMul(z2.redMul(this.z));
  var h = u1.redSub(u2);
  var r = s1.redSub(s2);
  if (h.cmpn(0) === 0) {
    if (r.cmpn(0) !== 0) return this.curve.jpoint(null, null, null);else return this.dbl();
  }
  var h2 = h.redSqr();
  var h3 = h2.redMul(h);
  var v = u1.redMul(h2);
  var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v);
  var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3));
  var nz = this.z.redMul(p.z).redMul(h);
  return this.curve.jpoint(nx, ny, nz);
};
JPoint.prototype.mixedAdd = function mixedAdd(p) {
  // O + P = P
  if (this.isInfinity()) return p.toJ();

  // P + O = P
  if (p.isInfinity()) return this;

  // 8M + 3S + 7A
  var z2 = this.z.redSqr();
  var u1 = this.x;
  var u2 = p.x.redMul(z2);
  var s1 = this.y;
  var s2 = p.y.redMul(z2).redMul(this.z);
  var h = u1.redSub(u2);
  var r = s1.redSub(s2);
  if (h.cmpn(0) === 0) {
    if (r.cmpn(0) !== 0) return this.curve.jpoint(null, null, null);else return this.dbl();
  }
  var h2 = h.redSqr();
  var h3 = h2.redMul(h);
  var v = u1.redMul(h2);
  var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v);
  var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3));
  var nz = this.z.redMul(h);
  return this.curve.jpoint(nx, ny, nz);
};
JPoint.prototype.dblp = function dblp(pow) {
  if (pow === 0) return this;
  if (this.isInfinity()) return this;
  if (!pow) return this.dbl();
  var i;
  if (this.curve.zeroA || this.curve.threeA) {
    var r = this;
    for (i = 0; i < pow; i++) r = r.dbl();
    return r;
  }

  // 1M + 2S + 1A + N * (4S + 5M + 8A)
  // N = 1 => 6M + 6S + 9A
  var a = this.curve.a;
  var tinv = this.curve.tinv;
  var jx = this.x;
  var jy = this.y;
  var jz = this.z;
  var jz4 = jz.redSqr().redSqr();

  // Reuse results
  var jyd = jy.redAdd(jy);
  for (i = 0; i < pow; i++) {
    var jx2 = jx.redSqr();
    var jyd2 = jyd.redSqr();
    var jyd4 = jyd2.redSqr();
    var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4));
    var t1 = jx.redMul(jyd2);
    var nx = c.redSqr().redISub(t1.redAdd(t1));
    var t2 = t1.redISub(nx);
    var dny = c.redMul(t2);
    dny = dny.redIAdd(dny).redISub(jyd4);
    var nz = jyd.redMul(jz);
    if (i + 1 < pow) jz4 = jz4.redMul(jyd4);
    jx = nx;
    jz = nz;
    jyd = dny;
  }
  return this.curve.jpoint(jx, jyd.redMul(tinv), jz);
};
JPoint.prototype.dbl = function dbl() {
  if (this.isInfinity()) return this;
  if (this.curve.zeroA) return this._zeroDbl();else if (this.curve.threeA) return this._threeDbl();else return this._dbl();
};
JPoint.prototype._zeroDbl = function _zeroDbl() {
  var nx;
  var ny;
  var nz;
  // Z = 1
  if (this.zOne) {
    // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html
    //     #doubling-mdbl-2007-bl
    // 1M + 5S + 14A

    // XX = X1^2
    var xx = this.x.redSqr();
    // YY = Y1^2
    var yy = this.y.redSqr();
    // YYYY = YY^2
    var yyyy = yy.redSqr();
    // S = 2 * ((X1 + YY)^2 - XX - YYYY)
    var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);
    s = s.redIAdd(s);
    // M = 3 * XX + a; a = 0
    var m = xx.redAdd(xx).redIAdd(xx);
    // T = M ^ 2 - 2*S
    var t = m.redSqr().redISub(s).redISub(s);

    // 8 * YYYY
    var yyyy8 = yyyy.redIAdd(yyyy);
    yyyy8 = yyyy8.redIAdd(yyyy8);
    yyyy8 = yyyy8.redIAdd(yyyy8);

    // X3 = T
    nx = t;
    // Y3 = M * (S - T) - 8 * YYYY
    ny = m.redMul(s.redISub(t)).redISub(yyyy8);
    // Z3 = 2*Y1
    nz = this.y.redAdd(this.y);
  } else {
    // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html
    //     #doubling-dbl-2009-l
    // 2M + 5S + 13A

    // A = X1^2
    var a = this.x.redSqr();
    // B = Y1^2
    var b = this.y.redSqr();
    // C = B^2
    var c = b.redSqr();
    // D = 2 * ((X1 + B)^2 - A - C)
    var d = this.x.redAdd(b).redSqr().redISub(a).redISub(c);
    d = d.redIAdd(d);
    // E = 3 * A
    var e = a.redAdd(a).redIAdd(a);
    // F = E^2
    var f = e.redSqr();

    // 8 * C
    var c8 = c.redIAdd(c);
    c8 = c8.redIAdd(c8);
    c8 = c8.redIAdd(c8);

    // X3 = F - 2 * D
    nx = f.redISub(d).redISub(d);
    // Y3 = E * (D - X3) - 8 * C
    ny = e.redMul(d.redISub(nx)).redISub(c8);
    // Z3 = 2 * Y1 * Z1
    nz = this.y.redMul(this.z);
    nz = nz.redIAdd(nz);
  }
  return this.curve.jpoint(nx, ny, nz);
};
JPoint.prototype._threeDbl = function _threeDbl() {
  var nx;
  var ny;
  var nz;
  // Z = 1
  if (this.zOne) {
    // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html
    //     #doubling-mdbl-2007-bl
    // 1M + 5S + 15A

    // XX = X1^2
    var xx = this.x.redSqr();
    // YY = Y1^2
    var yy = this.y.redSqr();
    // YYYY = YY^2
    var yyyy = yy.redSqr();
    // S = 2 * ((X1 + YY)^2 - XX - YYYY)
    var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);
    s = s.redIAdd(s);
    // M = 3 * XX + a
    var m = xx.redAdd(xx).redIAdd(xx).redIAdd(this.curve.a);
    // T = M^2 - 2 * S
    var t = m.redSqr().redISub(s).redISub(s);
    // X3 = T
    nx = t;
    // Y3 = M * (S - T) - 8 * YYYY
    var yyyy8 = yyyy.redIAdd(yyyy);
    yyyy8 = yyyy8.redIAdd(yyyy8);
    yyyy8 = yyyy8.redIAdd(yyyy8);
    ny = m.redMul(s.redISub(t)).redISub(yyyy8);
    // Z3 = 2 * Y1
    nz = this.y.redAdd(this.y);
  } else {
    // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html#doubling-dbl-2001-b
    // 3M + 5S

    // delta = Z1^2
    var delta = this.z.redSqr();
    // gamma = Y1^2
    var gamma = this.y.redSqr();
    // beta = X1 * gamma
    var beta = this.x.redMul(gamma);
    // alpha = 3 * (X1 - delta) * (X1 + delta)
    var alpha = this.x.redSub(delta).redMul(this.x.redAdd(delta));
    alpha = alpha.redAdd(alpha).redIAdd(alpha);
    // X3 = alpha^2 - 8 * beta
    var beta4 = beta.redIAdd(beta);
    beta4 = beta4.redIAdd(beta4);
    var beta8 = beta4.redAdd(beta4);
    nx = alpha.redSqr().redISub(beta8);
    // Z3 = (Y1 + Z1)^2 - gamma - delta
    nz = this.y.redAdd(this.z).redSqr().redISub(gamma).redISub(delta);
    // Y3 = alpha * (4 * beta - X3) - 8 * gamma^2
    var ggamma8 = gamma.redSqr();
    ggamma8 = ggamma8.redIAdd(ggamma8);
    ggamma8 = ggamma8.redIAdd(ggamma8);
    ggamma8 = ggamma8.redIAdd(ggamma8);
    ny = alpha.redMul(beta4.redISub(nx)).redISub(ggamma8);
  }
  return this.curve.jpoint(nx, ny, nz);
};
JPoint.prototype._dbl = function _dbl() {
  var a = this.curve.a;

  // 4M + 6S + 10A
  var jx = this.x;
  var jy = this.y;
  var jz = this.z;
  var jz4 = jz.redSqr().redSqr();
  var jx2 = jx.redSqr();
  var jy2 = jy.redSqr();
  var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4));
  var jxd4 = jx.redAdd(jx);
  jxd4 = jxd4.redIAdd(jxd4);
  var t1 = jxd4.redMul(jy2);
  var nx = c.redSqr().redISub(t1.redAdd(t1));
  var t2 = t1.redISub(nx);
  var jyd8 = jy2.redSqr();
  jyd8 = jyd8.redIAdd(jyd8);
  jyd8 = jyd8.redIAdd(jyd8);
  jyd8 = jyd8.redIAdd(jyd8);
  var ny = c.redMul(t2).redISub(jyd8);
  var nz = jy.redAdd(jy).redMul(jz);
  return this.curve.jpoint(nx, ny, nz);
};
JPoint.prototype.trpl = function trpl() {
  if (!this.curve.zeroA) return this.dbl().add(this);

  // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#tripling-tpl-2007-bl
  // 5M + 10S + ...

  // XX = X1^2
  var xx = this.x.redSqr();
  // YY = Y1^2
  var yy = this.y.redSqr();
  // ZZ = Z1^2
  var zz = this.z.redSqr();
  // YYYY = YY^2
  var yyyy = yy.redSqr();
  // M = 3 * XX + a * ZZ2; a = 0
  var m = xx.redAdd(xx).redIAdd(xx);
  // MM = M^2
  var mm = m.redSqr();
  // E = 6 * ((X1 + YY)^2 - XX - YYYY) - MM
  var e = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);
  e = e.redIAdd(e);
  e = e.redAdd(e).redIAdd(e);
  e = e.redISub(mm);
  // EE = E^2
  var ee = e.redSqr();
  // T = 16*YYYY
  var t = yyyy.redIAdd(yyyy);
  t = t.redIAdd(t);
  t = t.redIAdd(t);
  t = t.redIAdd(t);
  // U = (M + E)^2 - MM - EE - T
  var u = m.redIAdd(e).redSqr().redISub(mm).redISub(ee).redISub(t);
  // X3 = 4 * (X1 * EE - 4 * YY * U)
  var yyu4 = yy.redMul(u);
  yyu4 = yyu4.redIAdd(yyu4);
  yyu4 = yyu4.redIAdd(yyu4);
  var nx = this.x.redMul(ee).redISub(yyu4);
  nx = nx.redIAdd(nx);
  nx = nx.redIAdd(nx);
  // Y3 = 8 * Y1 * (U * (T - U) - E * EE)
  var ny = this.y.redMul(u.redMul(t.redISub(u)).redISub(e.redMul(ee)));
  ny = ny.redIAdd(ny);
  ny = ny.redIAdd(ny);
  ny = ny.redIAdd(ny);
  // Z3 = (Z1 + E)^2 - ZZ - EE
  var nz = this.z.redAdd(e).redSqr().redISub(zz).redISub(ee);
  return this.curve.jpoint(nx, ny, nz);
};
JPoint.prototype.mul = function mul(k, kbase) {
  k = new BN(k, kbase);
  return this.curve._wnafMul(this, k);
};
JPoint.prototype.eq = function eq(p) {
  if (p.type === 'affine') return this.eq(p.toJ());
  if (this === p) return true;

  // x1 * z2^2 == x2 * z1^2
  var z2 = this.z.redSqr();
  var pz2 = p.z.redSqr();
  if (this.x.redMul(pz2).redISub(p.x.redMul(z2)).cmpn(0) !== 0) return false;

  // y1 * z2^3 == y2 * z1^3
  var z3 = z2.redMul(this.z);
  var pz3 = pz2.redMul(p.z);
  return this.y.redMul(pz3).redISub(p.y.redMul(z3)).cmpn(0) === 0;
};
JPoint.prototype.eqXToP = function eqXToP(x) {
  var zs = this.z.redSqr();
  var rx = x.toRed(this.curve.red).redMul(zs);
  if (this.x.cmp(rx) === 0) return true;
  var xc = x.clone();
  var t = this.curve.redN.redMul(zs);
  for (;;) {
    xc.iadd(this.curve.n);
    if (xc.cmp(this.curve.p) >= 0) return false;
    rx.redIAdd(t);
    if (this.x.cmp(rx) === 0) return true;
  }
};
JPoint.prototype.inspect = function inspect() {
  if (this.isInfinity()) return '<EC JPoint Infinity>';
  return '<EC JPoint x: ' + this.x.toString(16, 2) + ' y: ' + this.y.toString(16, 2) + ' z: ' + this.z.toString(16, 2) + '>';
};
JPoint.prototype.isInfinity = function isInfinity() {
  // XXX This code assumes that zero is always zero in red
  return this.z.cmpn(0) === 0;
};

/***/ }),

/***/ 4710:
/*!*******************************************************!*\
  !*** ../node_modules/elliptic/lib/elliptic/curves.js ***!
  \*******************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


var curves = exports;
var hash = __webpack_require__(/*! hash.js */ 8313);
var curve = __webpack_require__(/*! ./curve */ 1364);
var utils = __webpack_require__(/*! ./utils */ 8619);
var assert = utils.assert;
function PresetCurve(options) {
  if (options.type === 'short') this.curve = new curve.short(options);else if (options.type === 'edwards') this.curve = new curve.edwards(options);else this.curve = new curve.mont(options);
  this.g = this.curve.g;
  this.n = this.curve.n;
  this.hash = options.hash;
  assert(this.g.validate(), 'Invalid curve');
  assert(this.g.mul(this.n).isInfinity(), 'Invalid curve, G*N != O');
}
curves.PresetCurve = PresetCurve;
function defineCurve(name, options) {
  Object.defineProperty(curves, name, {
    configurable: true,
    enumerable: true,
    get: function () {
      var curve = new PresetCurve(options);
      Object.defineProperty(curves, name, {
        configurable: true,
        enumerable: true,
        value: curve
      });
      return curve;
    }
  });
}
defineCurve('p192', {
  type: 'short',
  prime: 'p192',
  p: 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff',
  a: 'ffffffff ffffffff ffffffff fffffffe ffffffff fffffffc',
  b: '64210519 e59c80e7 0fa7e9ab 72243049 feb8deec c146b9b1',
  n: 'ffffffff ffffffff ffffffff 99def836 146bc9b1 b4d22831',
  hash: hash.sha256,
  gRed: false,
  g: ['188da80e b03090f6 7cbf20eb 43a18800 f4ff0afd 82ff1012', '07192b95 ffc8da78 631011ed 6b24cdd5 73f977a1 1e794811']
});
defineCurve('p224', {
  type: 'short',
  prime: 'p224',
  p: 'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001',
  a: 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff fffffffe',
  b: 'b4050a85 0c04b3ab f5413256 5044b0b7 d7bfd8ba 270b3943 2355ffb4',
  n: 'ffffffff ffffffff ffffffff ffff16a2 e0b8f03e 13dd2945 5c5c2a3d',
  hash: hash.sha256,
  gRed: false,
  g: ['b70e0cbd 6bb4bf7f 321390b9 4a03c1d3 56c21122 343280d6 115c1d21', 'bd376388 b5f723fb 4c22dfe6 cd4375a0 5a074764 44d58199 85007e34']
});
defineCurve('p256', {
  type: 'short',
  prime: null,
  p: 'ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff ffffffff',
  a: 'ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff fffffffc',
  b: '5ac635d8 aa3a93e7 b3ebbd55 769886bc 651d06b0 cc53b0f6 3bce3c3e 27d2604b',
  n: 'ffffffff 00000000 ffffffff ffffffff bce6faad a7179e84 f3b9cac2 fc632551',
  hash: hash.sha256,
  gRed: false,
  g: ['6b17d1f2 e12c4247 f8bce6e5 63a440f2 77037d81 2deb33a0 f4a13945 d898c296', '4fe342e2 fe1a7f9b 8ee7eb4a 7c0f9e16 2bce3357 6b315ece cbb64068 37bf51f5']
});
defineCurve('p384', {
  type: 'short',
  prime: null,
  p: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' + 'fffffffe ffffffff 00000000 00000000 ffffffff',
  a: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' + 'fffffffe ffffffff 00000000 00000000 fffffffc',
  b: 'b3312fa7 e23ee7e4 988e056b e3f82d19 181d9c6e fe814112 0314088f ' + '5013875a c656398d 8a2ed19d 2a85c8ed d3ec2aef',
  n: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff c7634d81 ' + 'f4372ddf 581a0db2 48b0a77a ecec196a ccc52973',
  hash: hash.sha384,
  gRed: false,
  g: ['aa87ca22 be8b0537 8eb1c71e f320ad74 6e1d3b62 8ba79b98 59f741e0 82542a38 ' + '5502f25d bf55296c 3a545e38 72760ab7', '3617de4a 96262c6f 5d9e98bf 9292dc29 f8f41dbd 289a147c e9da3113 b5f0b8c0 ' + '0a60b1ce 1d7e819d 7a431d7c 90ea0e5f']
});
defineCurve('p521', {
  type: 'short',
  prime: null,
  p: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' + 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' + 'ffffffff ffffffff ffffffff ffffffff ffffffff',
  a: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' + 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' + 'ffffffff ffffffff ffffffff ffffffff fffffffc',
  b: '00000051 953eb961 8e1c9a1f 929a21a0 b68540ee a2da725b ' + '99b315f3 b8b48991 8ef109e1 56193951 ec7e937b 1652c0bd ' + '3bb1bf07 3573df88 3d2c34f1 ef451fd4 6b503f00',
  n: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' + 'ffffffff ffffffff fffffffa 51868783 bf2f966b 7fcc0148 ' + 'f709a5d0 3bb5c9b8 899c47ae bb6fb71e 91386409',
  hash: hash.sha512,
  gRed: false,
  g: ['000000c6 858e06b7 0404e9cd 9e3ecb66 2395b442 9c648139 ' + '053fb521 f828af60 6b4d3dba a14b5e77 efe75928 fe1dc127 ' + 'a2ffa8de 3348b3c1 856a429b f97e7e31 c2e5bd66', '00000118 39296a78 9a3bc004 5c8a5fb4 2c7d1bd9 98f54449 ' + '579b4468 17afbd17 273e662c 97ee7299 5ef42640 c550b901 ' + '3fad0761 353c7086 a272c240 88be9476 9fd16650']
});
defineCurve('curve25519', {
  type: 'mont',
  prime: 'p25519',
  p: '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed',
  a: '76d06',
  b: '1',
  n: '1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed',
  hash: hash.sha256,
  gRed: false,
  g: ['9']
});
defineCurve('ed25519', {
  type: 'edwards',
  prime: 'p25519',
  p: '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed',
  a: '-1',
  c: '1',
  // -121665 * (121666^(-1)) (mod P)
  d: '52036cee2b6ffe73 8cc740797779e898 00700a4d4141d8ab 75eb4dca135978a3',
  n: '1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed',
  hash: hash.sha256,
  gRed: false,
  g: ['216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a',
  // 4/5
  '6666666666666666666666666666666666666666666666666666666666666658']
});
var pre;
try {
  pre = __webpack_require__(/*! ./precomputed/secp256k1 */ 3729);
} catch (e) {
  pre = undefined;
}
defineCurve('secp256k1', {
  type: 'short',
  prime: 'k256',
  p: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f',
  a: '0',
  b: '7',
  n: 'ffffffff ffffffff ffffffff fffffffe baaedce6 af48a03b bfd25e8c d0364141',
  h: '1',
  hash: hash.sha256,
  // Precomputed endomorphism
  beta: '7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee',
  lambda: '5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72',
  basis: [{
    a: '3086d221a7d46bcde86c90e49284eb15',
    b: '-e4437ed6010e88286f547fa90abfe4c3'
  }, {
    a: '114ca50f7a8e2f3f657c1108d9d44cfd8',
    b: '3086d221a7d46bcde86c90e49284eb15'
  }],
  gRed: false,
  g: ['79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798', '483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8', pre]
});

/***/ }),

/***/ 738:
/*!*********************************************************!*\
  !*** ../node_modules/elliptic/lib/elliptic/ec/index.js ***!
  \*********************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


var BN = __webpack_require__(/*! bn.js */ 1046);
var HmacDRBG = __webpack_require__(/*! hmac-drbg */ 1904);
var utils = __webpack_require__(/*! ../utils */ 8619);
var curves = __webpack_require__(/*! ../curves */ 4710);
var rand = __webpack_require__(/*! brorand */ 3796);
var assert = utils.assert;
var KeyPair = __webpack_require__(/*! ./key */ 2073);
var Signature = __webpack_require__(/*! ./signature */ 8970);
function EC(options) {
  if (!(this instanceof EC)) return new EC(options);

  // Shortcut `elliptic.ec(curve-name)`
  if (typeof options === 'string') {
    assert(Object.prototype.hasOwnProperty.call(curves, options), 'Unknown curve ' + options);
    options = curves[options];
  }

  // Shortcut for `elliptic.ec(elliptic.curves.curveName)`
  if (options instanceof curves.PresetCurve) options = {
    curve: options
  };
  this.curve = options.curve.curve;
  this.n = this.curve.n;
  this.nh = this.n.ushrn(1);
  this.g = this.curve.g;

  // Point on curve
  this.g = options.curve.g;
  this.g.precompute(options.curve.n.bitLength() + 1);

  // Hash for function for DRBG
  this.hash = options.hash || options.curve.hash;
}
module.exports = EC;
EC.prototype.keyPair = function keyPair(options) {
  return new KeyPair(this, options);
};
EC.prototype.keyFromPrivate = function keyFromPrivate(priv, enc) {
  return KeyPair.fromPrivate(this, priv, enc);
};
EC.prototype.keyFromPublic = function keyFromPublic(pub, enc) {
  return KeyPair.fromPublic(this, pub, enc);
};
EC.prototype.genKeyPair = function genKeyPair(options) {
  if (!options) options = {};

  // Instantiate Hmac_DRBG
  var drbg = new HmacDRBG({
    hash: this.hash,
    pers: options.pers,
    persEnc: options.persEnc || 'utf8',
    entropy: options.entropy || rand(this.hash.hmacStrength),
    entropyEnc: options.entropy && options.entropyEnc || 'utf8',
    nonce: this.n.toArray()
  });
  var bytes = this.n.byteLength();
  var ns2 = this.n.sub(new BN(2));
  for (;;) {
    var priv = new BN(drbg.generate(bytes));
    if (priv.cmp(ns2) > 0) continue;
    priv.iaddn(1);
    return this.keyFromPrivate(priv);
  }
};
EC.prototype._truncateToN = function _truncateToN(msg, truncOnly) {
  var delta = msg.byteLength() * 8 - this.n.bitLength();
  if (delta > 0) msg = msg.ushrn(delta);
  if (!truncOnly && msg.cmp(this.n) >= 0) return msg.sub(this.n);else return msg;
};
EC.prototype.sign = function sign(msg, key, enc, options) {
  if (typeof enc === 'object') {
    options = enc;
    enc = null;
  }
  if (!options) options = {};
  key = this.keyFromPrivate(key, enc);
  msg = this._truncateToN(new BN(msg, 16));

  // Zero-extend key to provide enough entropy
  var bytes = this.n.byteLength();
  var bkey = key.getPrivate().toArray('be', bytes);

  // Zero-extend nonce to have the same byte size as N
  var nonce = msg.toArray('be', bytes);

  // Instantiate Hmac_DRBG
  var drbg = new HmacDRBG({
    hash: this.hash,
    entropy: bkey,
    nonce: nonce,
    pers: options.pers,
    persEnc: options.persEnc || 'utf8'
  });

  // Number of bytes to generate
  var ns1 = this.n.sub(new BN(1));
  for (var iter = 0;; iter++) {
    var k = options.k ? options.k(iter) : new BN(drbg.generate(this.n.byteLength()));
    k = this._truncateToN(k, true);
    if (k.cmpn(1) <= 0 || k.cmp(ns1) >= 0) continue;
    var kp = this.g.mul(k);
    if (kp.isInfinity()) continue;
    var kpX = kp.getX();
    var r = kpX.umod(this.n);
    if (r.cmpn(0) === 0) continue;
    var s = k.invm(this.n).mul(r.mul(key.getPrivate()).iadd(msg));
    s = s.umod(this.n);
    if (s.cmpn(0) === 0) continue;
    var recoveryParam = (kp.getY().isOdd() ? 1 : 0) | (kpX.cmp(r) !== 0 ? 2 : 0);

    // Use complement of `s`, if it is > `n / 2`
    if (options.canonical && s.cmp(this.nh) > 0) {
      s = this.n.sub(s);
      recoveryParam ^= 1;
    }
    return new Signature({
      r: r,
      s: s,
      recoveryParam: recoveryParam
    });
  }
};
EC.prototype.verify = function verify(msg, signature, key, enc) {
  msg = this._truncateToN(new BN(msg, 16));
  key = this.keyFromPublic(key, enc);
  signature = new Signature(signature, 'hex');

  // Perform primitive values validation
  var r = signature.r;
  var s = signature.s;
  if (r.cmpn(1) < 0 || r.cmp(this.n) >= 0) return false;
  if (s.cmpn(1) < 0 || s.cmp(this.n) >= 0) return false;

  // Validate signature
  var sinv = s.invm(this.n);
  var u1 = sinv.mul(msg).umod(this.n);
  var u2 = sinv.mul(r).umod(this.n);
  var p;
  if (!this.curve._maxwellTrick) {
    p = this.g.mulAdd(u1, key.getPublic(), u2);
    if (p.isInfinity()) return false;
    return p.getX().umod(this.n).cmp(r) === 0;
  }

  // NOTE: Greg Maxwell's trick, inspired by:
  // https://git.io/vad3K

  p = this.g.jmulAdd(u1, key.getPublic(), u2);
  if (p.isInfinity()) return false;

  // Compare `p.x` of Jacobian point with `r`,
  // this will do `p.x == r * p.z^2` instead of multiplying `p.x` by the
  // inverse of `p.z^2`
  return p.eqXToP(r);
};
EC.prototype.recoverPubKey = function (msg, signature, j, enc) {
  assert((3 & j) === j, 'The recovery param is more than two bits');
  signature = new Signature(signature, enc);
  var n = this.n;
  var e = new BN(msg);
  var r = signature.r;
  var s = signature.s;

  // A set LSB signifies that the y-coordinate is odd
  var isYOdd = j & 1;
  var isSecondKey = j >> 1;
  if (r.cmp(this.curve.p.umod(this.curve.n)) >= 0 && isSecondKey) throw new Error('Unable to find sencond key candinate');

  // 1.1. Let x = r + jn.
  if (isSecondKey) r = this.curve.pointFromX(r.add(this.curve.n), isYOdd);else r = this.curve.pointFromX(r, isYOdd);
  var rInv = signature.r.invm(n);
  var s1 = n.sub(e).mul(rInv).umod(n);
  var s2 = s.mul(rInv).umod(n);

  // 1.6.1 Compute Q = r^-1 (sR -  eG)
  //               Q = r^-1 (sR + -eG)
  return this.g.mulAdd(s1, r, s2);
};
EC.prototype.getKeyRecoveryParam = function (e, signature, Q, enc) {
  signature = new Signature(signature, enc);
  if (signature.recoveryParam !== null) return signature.recoveryParam;
  for (var i = 0; i < 4; i++) {
    var Qprime;
    try {
      Qprime = this.recoverPubKey(e, signature, i);
    } catch (e) {
      continue;
    }
    if (Qprime.eq(Q)) return i;
  }
  throw new Error('Unable to find valid recovery factor');
};

/***/ }),

/***/ 2073:
/*!*******************************************************!*\
  !*** ../node_modules/elliptic/lib/elliptic/ec/key.js ***!
  \*******************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


var BN = __webpack_require__(/*! bn.js */ 1046);
var utils = __webpack_require__(/*! ../utils */ 8619);
var assert = utils.assert;
function KeyPair(ec, options) {
  this.ec = ec;
  this.priv = null;
  this.pub = null;

  // KeyPair(ec, { priv: ..., pub: ... })
  if (options.priv) this._importPrivate(options.priv, options.privEnc);
  if (options.pub) this._importPublic(options.pub, options.pubEnc);
}
module.exports = KeyPair;
KeyPair.fromPublic = function fromPublic(ec, pub, enc) {
  if (pub instanceof KeyPair) return pub;
  return new KeyPair(ec, {
    pub: pub,
    pubEnc: enc
  });
};
KeyPair.fromPrivate = function fromPrivate(ec, priv, enc) {
  if (priv instanceof KeyPair) return priv;
  return new KeyPair(ec, {
    priv: priv,
    privEnc: enc
  });
};
KeyPair.prototype.validate = function validate() {
  var pub = this.getPublic();
  if (pub.isInfinity()) return {
    result: false,
    reason: 'Invalid public key'
  };
  if (!pub.validate()) return {
    result: false,
    reason: 'Public key is not a point'
  };
  if (!pub.mul(this.ec.curve.n).isInfinity()) return {
    result: false,
    reason: 'Public key * N != O'
  };
  return {
    result: true,
    reason: null
  };
};
KeyPair.prototype.getPublic = function getPublic(compact, enc) {
  // compact is optional argument
  if (typeof compact === 'string') {
    enc = compact;
    compact = null;
  }
  if (!this.pub) this.pub = this.ec.g.mul(this.priv);
  if (!enc) return this.pub;
  return this.pub.encode(enc, compact);
};
KeyPair.prototype.getPrivate = function getPrivate(enc) {
  if (enc === 'hex') return this.priv.toString(16, 2);else return this.priv;
};
KeyPair.prototype._importPrivate = function _importPrivate(key, enc) {
  this.priv = new BN(key, enc || 16);

  // Ensure that the priv won't be bigger than n, otherwise we may fail
  // in fixed multiplication method
  this.priv = this.priv.umod(this.ec.curve.n);
};
KeyPair.prototype._importPublic = function _importPublic(key, enc) {
  if (key.x || key.y) {
    // Montgomery points only have an `x` coordinate.
    // Weierstrass/Edwards points on the other hand have both `x` and
    // `y` coordinates.
    if (this.ec.curve.type === 'mont') {
      assert(key.x, 'Need x coordinate');
    } else if (this.ec.curve.type === 'short' || this.ec.curve.type === 'edwards') {
      assert(key.x && key.y, 'Need both x and y coordinate');
    }
    this.pub = this.ec.curve.point(key.x, key.y);
    return;
  }
  this.pub = this.ec.curve.decodePoint(key, enc);
};

// ECDH
KeyPair.prototype.derive = function derive(pub) {
  if (!pub.validate()) {
    assert(pub.validate(), 'public point not validated');
  }
  return pub.mul(this.priv).getX();
};

// ECDSA
KeyPair.prototype.sign = function sign(msg, enc, options) {
  return this.ec.sign(msg, this, enc, options);
};
KeyPair.prototype.verify = function verify(msg, signature) {
  return this.ec.verify(msg, signature, this);
};
KeyPair.prototype.inspect = function inspect() {
  return '<Key priv: ' + (this.priv && this.priv.toString(16, 2)) + ' pub: ' + (this.pub && this.pub.inspect()) + ' >';
};

/***/ }),

/***/ 8970:
/*!*************************************************************!*\
  !*** ../node_modules/elliptic/lib/elliptic/ec/signature.js ***!
  \*************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


var BN = __webpack_require__(/*! bn.js */ 1046);
var utils = __webpack_require__(/*! ../utils */ 8619);
var assert = utils.assert;
function Signature(options, enc) {
  if (options instanceof Signature) return options;
  if (this._importDER(options, enc)) return;
  assert(options.r && options.s, 'Signature without r or s');
  this.r = new BN(options.r, 16);
  this.s = new BN(options.s, 16);
  if (options.recoveryParam === undefined) this.recoveryParam = null;else this.recoveryParam = options.recoveryParam;
}
module.exports = Signature;
function Position() {
  this.place = 0;
}
function getLength(buf, p) {
  var initial = buf[p.place++];
  if (!(initial & 0x80)) {
    return initial;
  }
  var octetLen = initial & 0xf;

  // Indefinite length or overflow
  if (octetLen === 0 || octetLen > 4) {
    return false;
  }
  var val = 0;
  for (var i = 0, off = p.place; i < octetLen; i++, off++) {
    val <<= 8;
    val |= buf[off];
    val >>>= 0;
  }

  // Leading zeroes
  if (val <= 0x7f) {
    return false;
  }
  p.place = off;
  return val;
}
function rmPadding(buf) {
  var i = 0;
  var len = buf.length - 1;
  while (!buf[i] && !(buf[i + 1] & 0x80) && i < len) {
    i++;
  }
  if (i === 0) {
    return buf;
  }
  return buf.slice(i);
}
Signature.prototype._importDER = function _importDER(data, enc) {
  data = utils.toArray(data, enc);
  var p = new Position();
  if (data[p.place++] !== 0x30) {
    return false;
  }
  var len = getLength(data, p);
  if (len === false) {
    return false;
  }
  if (len + p.place !== data.length) {
    return false;
  }
  if (data[p.place++] !== 0x02) {
    return false;
  }
  var rlen = getLength(data, p);
  if (rlen === false) {
    return false;
  }
  var r = data.slice(p.place, rlen + p.place);
  p.place += rlen;
  if (data[p.place++] !== 0x02) {
    return false;
  }
  var slen = getLength(data, p);
  if (slen === false) {
    return false;
  }
  if (data.length !== slen + p.place) {
    return false;
  }
  var s = data.slice(p.place, slen + p.place);
  if (r[0] === 0) {
    if (r[1] & 0x80) {
      r = r.slice(1);
    } else {
      // Leading zeroes
      return false;
    }
  }
  if (s[0] === 0) {
    if (s[1] & 0x80) {
      s = s.slice(1);
    } else {
      // Leading zeroes
      return false;
    }
  }
  this.r = new BN(r);
  this.s = new BN(s);
  this.recoveryParam = null;
  return true;
};
function constructLength(arr, len) {
  if (len < 0x80) {
    arr.push(len);
    return;
  }
  var octets = 1 + (Math.log(len) / Math.LN2 >>> 3);
  arr.push(octets | 0x80);
  while (--octets) {
    arr.push(len >>> (octets << 3) & 0xff);
  }
  arr.push(len);
}
Signature.prototype.toDER = function toDER(enc) {
  var r = this.r.toArray();
  var s = this.s.toArray();

  // Pad values
  if (r[0] & 0x80) r = [0].concat(r);
  // Pad values
  if (s[0] & 0x80) s = [0].concat(s);
  r = rmPadding(r);
  s = rmPadding(s);
  while (!s[0] && !(s[1] & 0x80)) {
    s = s.slice(1);
  }
  var arr = [0x02];
  constructLength(arr, r.length);
  arr = arr.concat(r);
  arr.push(0x02);
  constructLength(arr, s.length);
  var backHalf = arr.concat(s);
  var res = [0x30];
  constructLength(res, backHalf.length);
  res = res.concat(backHalf);
  return utils.encode(res, enc);
};

/***/ }),

/***/ 229:
/*!************************************************************!*\
  !*** ../node_modules/elliptic/lib/elliptic/eddsa/index.js ***!
  \************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


var hash = __webpack_require__(/*! hash.js */ 8313);
var curves = __webpack_require__(/*! ../curves */ 4710);
var utils = __webpack_require__(/*! ../utils */ 8619);
var assert = utils.assert;
var parseBytes = utils.parseBytes;
var KeyPair = __webpack_require__(/*! ./key */ 6679);
var Signature = __webpack_require__(/*! ./signature */ 6650);
function EDDSA(curve) {
  assert(curve === 'ed25519', 'only tested with ed25519 so far');
  if (!(this instanceof EDDSA)) return new EDDSA(curve);
  curve = curves[curve].curve;
  this.curve = curve;
  this.g = curve.g;
  this.g.precompute(curve.n.bitLength() + 1);
  this.pointClass = curve.point().constructor;
  this.encodingLength = Math.ceil(curve.n.bitLength() / 8);
  this.hash = hash.sha512;
}
module.exports = EDDSA;

/**
* @param {Array|String} message - message bytes
* @param {Array|String|KeyPair} secret - secret bytes or a keypair
* @returns {Signature} - signature
*/
EDDSA.prototype.sign = function sign(message, secret) {
  message = parseBytes(message);
  var key = this.keyFromSecret(secret);
  var r = this.hashInt(key.messagePrefix(), message);
  var R = this.g.mul(r);
  var Rencoded = this.encodePoint(R);
  var s_ = this.hashInt(Rencoded, key.pubBytes(), message).mul(key.priv());
  var S = r.add(s_).umod(this.curve.n);
  return this.makeSignature({
    R: R,
    S: S,
    Rencoded: Rencoded
  });
};

/**
* @param {Array} message - message bytes
* @param {Array|String|Signature} sig - sig bytes
* @param {Array|String|Point|KeyPair} pub - public key
* @returns {Boolean} - true if public key matches sig of message
*/
EDDSA.prototype.verify = function verify(message, sig, pub) {
  message = parseBytes(message);
  sig = this.makeSignature(sig);
  var key = this.keyFromPublic(pub);
  var h = this.hashInt(sig.Rencoded(), key.pubBytes(), message);
  var SG = this.g.mul(sig.S());
  var RplusAh = sig.R().add(key.pub().mul(h));
  return RplusAh.eq(SG);
};
EDDSA.prototype.hashInt = function hashInt() {
  var hash = this.hash();
  for (var i = 0; i < arguments.length; i++) hash.update(arguments[i]);
  return utils.intFromLE(hash.digest()).umod(this.curve.n);
};
EDDSA.prototype.keyFromPublic = function keyFromPublic(pub) {
  return KeyPair.fromPublic(this, pub);
};
EDDSA.prototype.keyFromSecret = function keyFromSecret(secret) {
  return KeyPair.fromSecret(this, secret);
};
EDDSA.prototype.makeSignature = function makeSignature(sig) {
  if (sig instanceof Signature) return sig;
  return new Signature(this, sig);
};

/**
* * https://tools.ietf.org/html/draft-josefsson-eddsa-ed25519-03#section-5.2
*
* EDDSA defines methods for encoding and decoding points and integers. These are
* helper convenience methods, that pass along to utility functions implied
* parameters.
*
*/
EDDSA.prototype.encodePoint = function encodePoint(point) {
  var enc = point.getY().toArray('le', this.encodingLength);
  enc[this.encodingLength - 1] |= point.getX().isOdd() ? 0x80 : 0;
  return enc;
};
EDDSA.prototype.decodePoint = function decodePoint(bytes) {
  bytes = utils.parseBytes(bytes);
  var lastIx = bytes.length - 1;
  var normed = bytes.slice(0, lastIx).concat(bytes[lastIx] & ~0x80);
  var xIsOdd = (bytes[lastIx] & 0x80) !== 0;
  var y = utils.intFromLE(normed);
  return this.curve.pointFromY(y, xIsOdd);
};
EDDSA.prototype.encodeInt = function encodeInt(num) {
  return num.toArray('le', this.encodingLength);
};
EDDSA.prototype.decodeInt = function decodeInt(bytes) {
  return utils.intFromLE(bytes);
};
EDDSA.prototype.isPoint = function isPoint(val) {
  return val instanceof this.pointClass;
};

/***/ }),

/***/ 6679:
/*!**********************************************************!*\
  !*** ../node_modules/elliptic/lib/elliptic/eddsa/key.js ***!
  \**********************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


var utils = __webpack_require__(/*! ../utils */ 8619);
var assert = utils.assert;
var parseBytes = utils.parseBytes;
var cachedProperty = utils.cachedProperty;

/**
* @param {EDDSA} eddsa - instance
* @param {Object} params - public/private key parameters
*
* @param {Array<Byte>} [params.secret] - secret seed bytes
* @param {Point} [params.pub] - public key point (aka `A` in eddsa terms)
* @param {Array<Byte>} [params.pub] - public key point encoded as bytes
*
*/
function KeyPair(eddsa, params) {
  this.eddsa = eddsa;
  this._secret = parseBytes(params.secret);
  if (eddsa.isPoint(params.pub)) this._pub = params.pub;else this._pubBytes = parseBytes(params.pub);
}
KeyPair.fromPublic = function fromPublic(eddsa, pub) {
  if (pub instanceof KeyPair) return pub;
  return new KeyPair(eddsa, {
    pub: pub
  });
};
KeyPair.fromSecret = function fromSecret(eddsa, secret) {
  if (secret instanceof KeyPair) return secret;
  return new KeyPair(eddsa, {
    secret: secret
  });
};
KeyPair.prototype.secret = function secret() {
  return this._secret;
};
cachedProperty(KeyPair, 'pubBytes', function pubBytes() {
  return this.eddsa.encodePoint(this.pub());
});
cachedProperty(KeyPair, 'pub', function pub() {
  if (this._pubBytes) return this.eddsa.decodePoint(this._pubBytes);
  return this.eddsa.g.mul(this.priv());
});
cachedProperty(KeyPair, 'privBytes', function privBytes() {
  var eddsa = this.eddsa;
  var hash = this.hash();
  var lastIx = eddsa.encodingLength - 1;
  var a = hash.slice(0, eddsa.encodingLength);
  a[0] &= 248;
  a[lastIx] &= 127;
  a[lastIx] |= 64;
  return a;
});
cachedProperty(KeyPair, 'priv', function priv() {
  return this.eddsa.decodeInt(this.privBytes());
});
cachedProperty(KeyPair, 'hash', function hash() {
  return this.eddsa.hash().update(this.secret()).digest();
});
cachedProperty(KeyPair, 'messagePrefix', function messagePrefix() {
  return this.hash().slice(this.eddsa.encodingLength);
});
KeyPair.prototype.sign = function sign(message) {
  assert(this._secret, 'KeyPair can only verify');
  return this.eddsa.sign(message, this);
};
KeyPair.prototype.verify = function verify(message, sig) {
  return this.eddsa.verify(message, sig, this);
};
KeyPair.prototype.getSecret = function getSecret(enc) {
  assert(this._secret, 'KeyPair is public only');
  return utils.encode(this.secret(), enc);
};
KeyPair.prototype.getPublic = function getPublic(enc) {
  return utils.encode(this.pubBytes(), enc);
};
module.exports = KeyPair;

/***/ }),

/***/ 6650:
/*!****************************************************************!*\
  !*** ../node_modules/elliptic/lib/elliptic/eddsa/signature.js ***!
  \****************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


var BN = __webpack_require__(/*! bn.js */ 1046);
var utils = __webpack_require__(/*! ../utils */ 8619);
var assert = utils.assert;
var cachedProperty = utils.cachedProperty;
var parseBytes = utils.parseBytes;

/**
* @param {EDDSA} eddsa - eddsa instance
* @param {Array<Bytes>|Object} sig -
* @param {Array<Bytes>|Point} [sig.R] - R point as Point or bytes
* @param {Array<Bytes>|bn} [sig.S] - S scalar as bn or bytes
* @param {Array<Bytes>} [sig.Rencoded] - R point encoded
* @param {Array<Bytes>} [sig.Sencoded] - S scalar encoded
*/
function Signature(eddsa, sig) {
  this.eddsa = eddsa;
  if (typeof sig !== 'object') sig = parseBytes(sig);
  if (Array.isArray(sig)) {
    sig = {
      R: sig.slice(0, eddsa.encodingLength),
      S: sig.slice(eddsa.encodingLength)
    };
  }
  assert(sig.R && sig.S, 'Signature without R or S');
  if (eddsa.isPoint(sig.R)) this._R = sig.R;
  if (sig.S instanceof BN) this._S = sig.S;
  this._Rencoded = Array.isArray(sig.R) ? sig.R : sig.Rencoded;
  this._Sencoded = Array.isArray(sig.S) ? sig.S : sig.Sencoded;
}
cachedProperty(Signature, 'S', function S() {
  return this.eddsa.decodeInt(this.Sencoded());
});
cachedProperty(Signature, 'R', function R() {
  return this.eddsa.decodePoint(this.Rencoded());
});
cachedProperty(Signature, 'Rencoded', function Rencoded() {
  return this.eddsa.encodePoint(this.R());
});
cachedProperty(Signature, 'Sencoded', function Sencoded() {
  return this.eddsa.encodeInt(this.S());
});
Signature.prototype.toBytes = function toBytes() {
  return this.Rencoded().concat(this.Sencoded());
};
Signature.prototype.toHex = function toHex() {
  return utils.encode(this.toBytes(), 'hex').toUpperCase();
};
module.exports = Signature;

/***/ }),

/***/ 3729:
/*!**********************************************************************!*\
  !*** ../node_modules/elliptic/lib/elliptic/precomputed/secp256k1.js ***!
  \**********************************************************************/
/***/ ((module) => {

module.exports = {
  doubles: {
    step: 4,
    points: [['e60fce93b59e9ec53011aabc21c23e97b2a31369b87a5ae9c44ee89e2a6dec0a', 'f7e3507399e595929db99f34f57937101296891e44d23f0be1f32cce69616821'], ['8282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508', '11f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf'], ['175e159f728b865a72f99cc6c6fc846de0b93833fd2222ed73fce5b551e5b739', 'd3506e0d9e3c79eba4ef97a51ff71f5eacb5955add24345c6efa6ffee9fed695'], ['363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640', '4e273adfc732221953b445397f3363145b9a89008199ecb62003c7f3bee9de9'], ['8b4b5f165df3c2be8c6244b5b745638843e4a781a15bcd1b69f79a55dffdf80c', '4aad0a6f68d308b4b3fbd7813ab0da04f9e336546162ee56b3eff0c65fd4fd36'], ['723cbaa6e5db996d6bf771c00bd548c7b700dbffa6c0e77bcb6115925232fcda', '96e867b5595cc498a921137488824d6e2660a0653779494801dc069d9eb39f5f'], ['eebfa4d493bebf98ba5feec812c2d3b50947961237a919839a533eca0e7dd7fa', '5d9a8ca3970ef0f269ee7edaf178089d9ae4cdc3a711f712ddfd4fdae1de8999'], ['100f44da696e71672791d0a09b7bde459f1215a29b3c03bfefd7835b39a48db0', 'cdd9e13192a00b772ec8f3300c090666b7ff4a18ff5195ac0fbd5cd62bc65a09'], ['e1031be262c7ed1b1dc9227a4a04c017a77f8d4464f3b3852c8acde6e534fd2d', '9d7061928940405e6bb6a4176597535af292dd419e1ced79a44f18f29456a00d'], ['feea6cae46d55b530ac2839f143bd7ec5cf8b266a41d6af52d5e688d9094696d', 'e57c6b6c97dce1bab06e4e12bf3ecd5c981c8957cc41442d3155debf18090088'], ['da67a91d91049cdcb367be4be6ffca3cfeed657d808583de33fa978bc1ec6cb1', '9bacaa35481642bc41f463f7ec9780e5dec7adc508f740a17e9ea8e27a68be1d'], ['53904faa0b334cdda6e000935ef22151ec08d0f7bb11069f57545ccc1a37b7c0', '5bc087d0bc80106d88c9eccac20d3c1c13999981e14434699dcb096b022771c8'], ['8e7bcd0bd35983a7719cca7764ca906779b53a043a9b8bcaeff959f43ad86047', '10b7770b2a3da4b3940310420ca9514579e88e2e47fd68b3ea10047e8460372a'], ['385eed34c1cdff21e6d0818689b81bde71a7f4f18397e6690a841e1599c43862', '283bebc3e8ea23f56701de19e9ebf4576b304eec2086dc8cc0458fe5542e5453'], ['6f9d9b803ecf191637c73a4413dfa180fddf84a5947fbc9c606ed86c3fac3a7', '7c80c68e603059ba69b8e2a30e45c4d47ea4dd2f5c281002d86890603a842160'], ['3322d401243c4e2582a2147c104d6ecbf774d163db0f5e5313b7e0e742d0e6bd', '56e70797e9664ef5bfb019bc4ddaf9b72805f63ea2873af624f3a2e96c28b2a0'], ['85672c7d2de0b7da2bd1770d89665868741b3f9af7643397721d74d28134ab83', '7c481b9b5b43b2eb6374049bfa62c2e5e77f17fcc5298f44c8e3094f790313a6'], ['948bf809b1988a46b06c9f1919413b10f9226c60f668832ffd959af60c82a0a', '53a562856dcb6646dc6b74c5d1c3418c6d4dff08c97cd2bed4cb7f88d8c8e589'], ['6260ce7f461801c34f067ce0f02873a8f1b0e44dfc69752accecd819f38fd8e8', 'bc2da82b6fa5b571a7f09049776a1ef7ecd292238051c198c1a84e95b2b4ae17'], ['e5037de0afc1d8d43d8348414bbf4103043ec8f575bfdc432953cc8d2037fa2d', '4571534baa94d3b5f9f98d09fb990bddbd5f5b03ec481f10e0e5dc841d755bda'], ['e06372b0f4a207adf5ea905e8f1771b4e7e8dbd1c6a6c5b725866a0ae4fce725', '7a908974bce18cfe12a27bb2ad5a488cd7484a7787104870b27034f94eee31dd'], ['213c7a715cd5d45358d0bbf9dc0ce02204b10bdde2a3f58540ad6908d0559754', '4b6dad0b5ae462507013ad06245ba190bb4850f5f36a7eeddff2c27534b458f2'], ['4e7c272a7af4b34e8dbb9352a5419a87e2838c70adc62cddf0cc3a3b08fbd53c', '17749c766c9d0b18e16fd09f6def681b530b9614bff7dd33e0b3941817dcaae6'], ['fea74e3dbe778b1b10f238ad61686aa5c76e3db2be43057632427e2840fb27b6', '6e0568db9b0b13297cf674deccb6af93126b596b973f7b77701d3db7f23cb96f'], ['76e64113f677cf0e10a2570d599968d31544e179b760432952c02a4417bdde39', 'c90ddf8dee4e95cf577066d70681f0d35e2a33d2b56d2032b4b1752d1901ac01'], ['c738c56b03b2abe1e8281baa743f8f9a8f7cc643df26cbee3ab150242bcbb891', '893fb578951ad2537f718f2eacbfbbbb82314eef7880cfe917e735d9699a84c3'], ['d895626548b65b81e264c7637c972877d1d72e5f3a925014372e9f6588f6c14b', 'febfaa38f2bc7eae728ec60818c340eb03428d632bb067e179363ed75d7d991f'], ['b8da94032a957518eb0f6433571e8761ceffc73693e84edd49150a564f676e03', '2804dfa44805a1e4d7c99cc9762808b092cc584d95ff3b511488e4e74efdf6e7'], ['e80fea14441fb33a7d8adab9475d7fab2019effb5156a792f1a11778e3c0df5d', 'eed1de7f638e00771e89768ca3ca94472d155e80af322ea9fcb4291b6ac9ec78'], ['a301697bdfcd704313ba48e51d567543f2a182031efd6915ddc07bbcc4e16070', '7370f91cfb67e4f5081809fa25d40f9b1735dbf7c0a11a130c0d1a041e177ea1'], ['90ad85b389d6b936463f9d0512678de208cc330b11307fffab7ac63e3fb04ed4', 'e507a3620a38261affdcbd9427222b839aefabe1582894d991d4d48cb6ef150'], ['8f68b9d2f63b5f339239c1ad981f162ee88c5678723ea3351b7b444c9ec4c0da', '662a9f2dba063986de1d90c2b6be215dbbea2cfe95510bfdf23cbf79501fff82'], ['e4f3fb0176af85d65ff99ff9198c36091f48e86503681e3e6686fd5053231e11', '1e63633ad0ef4f1c1661a6d0ea02b7286cc7e74ec951d1c9822c38576feb73bc'], ['8c00fa9b18ebf331eb961537a45a4266c7034f2f0d4e1d0716fb6eae20eae29e', 'efa47267fea521a1a9dc343a3736c974c2fadafa81e36c54e7d2a4c66702414b'], ['e7a26ce69dd4829f3e10cec0a9e98ed3143d084f308b92c0997fddfc60cb3e41', '2a758e300fa7984b471b006a1aafbb18d0a6b2c0420e83e20e8a9421cf2cfd51'], ['b6459e0ee3662ec8d23540c223bcbdc571cbcb967d79424f3cf29eb3de6b80ef', '67c876d06f3e06de1dadf16e5661db3c4b3ae6d48e35b2ff30bf0b61a71ba45'], ['d68a80c8280bb840793234aa118f06231d6f1fc67e73c5a5deda0f5b496943e8', 'db8ba9fff4b586d00c4b1f9177b0e28b5b0e7b8f7845295a294c84266b133120'], ['324aed7df65c804252dc0270907a30b09612aeb973449cea4095980fc28d3d5d', '648a365774b61f2ff130c0c35aec1f4f19213b0c7e332843967224af96ab7c84'], ['4df9c14919cde61f6d51dfdbe5fee5dceec4143ba8d1ca888e8bd373fd054c96', '35ec51092d8728050974c23a1d85d4b5d506cdc288490192ebac06cad10d5d'], ['9c3919a84a474870faed8a9c1cc66021523489054d7f0308cbfc99c8ac1f98cd', 'ddb84f0f4a4ddd57584f044bf260e641905326f76c64c8e6be7e5e03d4fc599d'], ['6057170b1dd12fdf8de05f281d8e06bb91e1493a8b91d4cc5a21382120a959e5', '9a1af0b26a6a4807add9a2daf71df262465152bc3ee24c65e899be932385a2a8'], ['a576df8e23a08411421439a4518da31880cef0fba7d4df12b1a6973eecb94266', '40a6bf20e76640b2c92b97afe58cd82c432e10a7f514d9f3ee8be11ae1b28ec8'], ['7778a78c28dec3e30a05fe9629de8c38bb30d1f5cf9a3a208f763889be58ad71', '34626d9ab5a5b22ff7098e12f2ff580087b38411ff24ac563b513fc1fd9f43ac'], ['928955ee637a84463729fd30e7afd2ed5f96274e5ad7e5cb09eda9c06d903ac', 'c25621003d3f42a827b78a13093a95eeac3d26efa8a8d83fc5180e935bcd091f'], ['85d0fef3ec6db109399064f3a0e3b2855645b4a907ad354527aae75163d82751', '1f03648413a38c0be29d496e582cf5663e8751e96877331582c237a24eb1f962'], ['ff2b0dce97eece97c1c9b6041798b85dfdfb6d8882da20308f5404824526087e', '493d13fef524ba188af4c4dc54d07936c7b7ed6fb90e2ceb2c951e01f0c29907'], ['827fbbe4b1e880ea9ed2b2e6301b212b57f1ee148cd6dd28780e5e2cf856e241', 'c60f9c923c727b0b71bef2c67d1d12687ff7a63186903166d605b68baec293ec'], ['eaa649f21f51bdbae7be4ae34ce6e5217a58fdce7f47f9aa7f3b58fa2120e2b3', 'be3279ed5bbbb03ac69a80f89879aa5a01a6b965f13f7e59d47a5305ba5ad93d'], ['e4a42d43c5cf169d9391df6decf42ee541b6d8f0c9a137401e23632dda34d24f', '4d9f92e716d1c73526fc99ccfb8ad34ce886eedfa8d8e4f13a7f7131deba9414'], ['1ec80fef360cbdd954160fadab352b6b92b53576a88fea4947173b9d4300bf19', 'aeefe93756b5340d2f3a4958a7abbf5e0146e77f6295a07b671cdc1cc107cefd'], ['146a778c04670c2f91b00af4680dfa8bce3490717d58ba889ddb5928366642be', 'b318e0ec3354028add669827f9d4b2870aaa971d2f7e5ed1d0b297483d83efd0'], ['fa50c0f61d22e5f07e3acebb1aa07b128d0012209a28b9776d76a8793180eef9', '6b84c6922397eba9b72cd2872281a68a5e683293a57a213b38cd8d7d3f4f2811'], ['da1d61d0ca721a11b1a5bf6b7d88e8421a288ab5d5bba5220e53d32b5f067ec2', '8157f55a7c99306c79c0766161c91e2966a73899d279b48a655fba0f1ad836f1'], ['a8e282ff0c9706907215ff98e8fd416615311de0446f1e062a73b0610d064e13', '7f97355b8db81c09abfb7f3c5b2515888b679a3e50dd6bd6cef7c73111f4cc0c'], ['174a53b9c9a285872d39e56e6913cab15d59b1fa512508c022f382de8319497c', 'ccc9dc37abfc9c1657b4155f2c47f9e6646b3a1d8cb9854383da13ac079afa73'], ['959396981943785c3d3e57edf5018cdbe039e730e4918b3d884fdff09475b7ba', '2e7e552888c331dd8ba0386a4b9cd6849c653f64c8709385e9b8abf87524f2fd'], ['d2a63a50ae401e56d645a1153b109a8fcca0a43d561fba2dbb51340c9d82b151', 'e82d86fb6443fcb7565aee58b2948220a70f750af484ca52d4142174dcf89405'], ['64587e2335471eb890ee7896d7cfdc866bacbdbd3839317b3436f9b45617e073', 'd99fcdd5bf6902e2ae96dd6447c299a185b90a39133aeab358299e5e9faf6589'], ['8481bde0e4e4d885b3a546d3e549de042f0aa6cea250e7fd358d6c86dd45e458', '38ee7b8cba5404dd84a25bf39cecb2ca900a79c42b262e556d64b1b59779057e'], ['13464a57a78102aa62b6979ae817f4637ffcfed3c4b1ce30bcd6303f6caf666b', '69be159004614580ef7e433453ccb0ca48f300a81d0942e13f495a907f6ecc27'], ['bc4a9df5b713fe2e9aef430bcc1dc97a0cd9ccede2f28588cada3a0d2d83f366', 'd3a81ca6e785c06383937adf4b798caa6e8a9fbfa547b16d758d666581f33c1'], ['8c28a97bf8298bc0d23d8c749452a32e694b65e30a9472a3954ab30fe5324caa', '40a30463a3305193378fedf31f7cc0eb7ae784f0451cb9459e71dc73cbef9482'], ['8ea9666139527a8c1dd94ce4f071fd23c8b350c5a4bb33748c4ba111faccae0', '620efabbc8ee2782e24e7c0cfb95c5d735b783be9cf0f8e955af34a30e62b945'], ['dd3625faef5ba06074669716bbd3788d89bdde815959968092f76cc4eb9a9787', '7a188fa3520e30d461da2501045731ca941461982883395937f68d00c644a573'], ['f710d79d9eb962297e4f6232b40e8f7feb2bc63814614d692c12de752408221e', 'ea98e67232d3b3295d3b535532115ccac8612c721851617526ae47a9c77bfc82']]
  },
  naf: {
    wnd: 7,
    points: [['f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9', '388f7b0f632de8140fe337e62a37f3566500a99934c2231b6cb9fd7584b8e672'], ['2f8bde4d1a07209355b4a7250a5c5128e88b84bddc619ab7cba8d569b240efe4', 'd8ac222636e5e3d6d4dba9dda6c9c426f788271bab0d6840dca87d3aa6ac62d6'], ['5cbdf0646e5db4eaa398f365f2ea7a0e3d419b7e0330e39ce92bddedcac4f9bc', '6aebca40ba255960a3178d6d861a54dba813d0b813fde7b5a5082628087264da'], ['acd484e2f0c7f65309ad178a9f559abde09796974c57e714c35f110dfc27ccbe', 'cc338921b0a7d9fd64380971763b61e9add888a4375f8e0f05cc262ac64f9c37'], ['774ae7f858a9411e5ef4246b70c65aac5649980be5c17891bbec17895da008cb', 'd984a032eb6b5e190243dd56d7b7b365372db1e2dff9d6a8301d74c9c953c61b'], ['f28773c2d975288bc7d1d205c3748651b075fbc6610e58cddeeddf8f19405aa8', 'ab0902e8d880a89758212eb65cdaf473a1a06da521fa91f29b5cb52db03ed81'], ['d7924d4f7d43ea965a465ae3095ff41131e5946f3c85f79e44adbcf8e27e080e', '581e2872a86c72a683842ec228cc6defea40af2bd896d3a5c504dc9ff6a26b58'], ['defdea4cdb677750a420fee807eacf21eb9898ae79b9768766e4faa04a2d4a34', '4211ab0694635168e997b0ead2a93daeced1f4a04a95c0f6cfb199f69e56eb77'], ['2b4ea0a797a443d293ef5cff444f4979f06acfebd7e86d277475656138385b6c', '85e89bc037945d93b343083b5a1c86131a01f60c50269763b570c854e5c09b7a'], ['352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d5', '321eb4075348f534d59c18259dda3e1f4a1b3b2e71b1039c67bd3d8bcf81998c'], ['2fa2104d6b38d11b0230010559879124e42ab8dfeff5ff29dc9cdadd4ecacc3f', '2de1068295dd865b64569335bd5dd80181d70ecfc882648423ba76b532b7d67'], ['9248279b09b4d68dab21a9b066edda83263c3d84e09572e269ca0cd7f5453714', '73016f7bf234aade5d1aa71bdea2b1ff3fc0de2a887912ffe54a32ce97cb3402'], ['daed4f2be3a8bf278e70132fb0beb7522f570e144bf615c07e996d443dee8729', 'a69dce4a7d6c98e8d4a1aca87ef8d7003f83c230f3afa726ab40e52290be1c55'], ['c44d12c7065d812e8acf28d7cbb19f9011ecd9e9fdf281b0e6a3b5e87d22e7db', '2119a460ce326cdc76c45926c982fdac0e106e861edf61c5a039063f0e0e6482'], ['6a245bf6dc698504c89a20cfded60853152b695336c28063b61c65cbd269e6b4', 'e022cf42c2bd4a708b3f5126f16a24ad8b33ba48d0423b6efd5e6348100d8a82'], ['1697ffa6fd9de627c077e3d2fe541084ce13300b0bec1146f95ae57f0d0bd6a5', 'b9c398f186806f5d27561506e4557433a2cf15009e498ae7adee9d63d01b2396'], ['605bdb019981718b986d0f07e834cb0d9deb8360ffb7f61df982345ef27a7479', '2972d2de4f8d20681a78d93ec96fe23c26bfae84fb14db43b01e1e9056b8c49'], ['62d14dab4150bf497402fdc45a215e10dcb01c354959b10cfe31c7e9d87ff33d', '80fc06bd8cc5b01098088a1950eed0db01aa132967ab472235f5642483b25eaf'], ['80c60ad0040f27dade5b4b06c408e56b2c50e9f56b9b8b425e555c2f86308b6f', '1c38303f1cc5c30f26e66bad7fe72f70a65eed4cbe7024eb1aa01f56430bd57a'], ['7a9375ad6167ad54aa74c6348cc54d344cc5dc9487d847049d5eabb0fa03c8fb', 'd0e3fa9eca8726909559e0d79269046bdc59ea10c70ce2b02d499ec224dc7f7'], ['d528ecd9b696b54c907a9ed045447a79bb408ec39b68df504bb51f459bc3ffc9', 'eecf41253136e5f99966f21881fd656ebc4345405c520dbc063465b521409933'], ['49370a4b5f43412ea25f514e8ecdad05266115e4a7ecb1387231808f8b45963', '758f3f41afd6ed428b3081b0512fd62a54c3f3afbb5b6764b653052a12949c9a'], ['77f230936ee88cbbd73df930d64702ef881d811e0e1498e2f1c13eb1fc345d74', '958ef42a7886b6400a08266e9ba1b37896c95330d97077cbbe8eb3c7671c60d6'], ['f2dac991cc4ce4b9ea44887e5c7c0bce58c80074ab9d4dbaeb28531b7739f530', 'e0dedc9b3b2f8dad4da1f32dec2531df9eb5fbeb0598e4fd1a117dba703a3c37'], ['463b3d9f662621fb1b4be8fbbe2520125a216cdfc9dae3debcba4850c690d45b', '5ed430d78c296c3543114306dd8622d7c622e27c970a1de31cb377b01af7307e'], ['f16f804244e46e2a09232d4aff3b59976b98fac14328a2d1a32496b49998f247', 'cedabd9b82203f7e13d206fcdf4e33d92a6c53c26e5cce26d6579962c4e31df6'], ['caf754272dc84563b0352b7a14311af55d245315ace27c65369e15f7151d41d1', 'cb474660ef35f5f2a41b643fa5e460575f4fa9b7962232a5c32f908318a04476'], ['2600ca4b282cb986f85d0f1709979d8b44a09c07cb86d7c124497bc86f082120', '4119b88753c15bd6a693b03fcddbb45d5ac6be74ab5f0ef44b0be9475a7e4b40'], ['7635ca72d7e8432c338ec53cd12220bc01c48685e24f7dc8c602a7746998e435', '91b649609489d613d1d5e590f78e6d74ecfc061d57048bad9e76f302c5b9c61'], ['754e3239f325570cdbbf4a87deee8a66b7f2b33479d468fbc1a50743bf56cc18', '673fb86e5bda30fb3cd0ed304ea49a023ee33d0197a695d0c5d98093c536683'], ['e3e6bd1071a1e96aff57859c82d570f0330800661d1c952f9fe2694691d9b9e8', '59c9e0bba394e76f40c0aa58379a3cb6a5a2283993e90c4167002af4920e37f5'], ['186b483d056a033826ae73d88f732985c4ccb1f32ba35f4b4cc47fdcf04aa6eb', '3b952d32c67cf77e2e17446e204180ab21fb8090895138b4a4a797f86e80888b'], ['df9d70a6b9876ce544c98561f4be4f725442e6d2b737d9c91a8321724ce0963f', '55eb2dafd84d6ccd5f862b785dc39d4ab157222720ef9da217b8c45cf2ba2417'], ['5edd5cc23c51e87a497ca815d5dce0f8ab52554f849ed8995de64c5f34ce7143', 'efae9c8dbc14130661e8cec030c89ad0c13c66c0d17a2905cdc706ab7399a868'], ['290798c2b6476830da12fe02287e9e777aa3fba1c355b17a722d362f84614fba', 'e38da76dcd440621988d00bcf79af25d5b29c094db2a23146d003afd41943e7a'], ['af3c423a95d9f5b3054754efa150ac39cd29552fe360257362dfdecef4053b45', 'f98a3fd831eb2b749a93b0e6f35cfb40c8cd5aa667a15581bc2feded498fd9c6'], ['766dbb24d134e745cccaa28c99bf274906bb66b26dcf98df8d2fed50d884249a', '744b1152eacbe5e38dcc887980da38b897584a65fa06cedd2c924f97cbac5996'], ['59dbf46f8c94759ba21277c33784f41645f7b44f6c596a58ce92e666191abe3e', 'c534ad44175fbc300f4ea6ce648309a042ce739a7919798cd85e216c4a307f6e'], ['f13ada95103c4537305e691e74e9a4a8dd647e711a95e73cb62dc6018cfd87b8', 'e13817b44ee14de663bf4bc808341f326949e21a6a75c2570778419bdaf5733d'], ['7754b4fa0e8aced06d4167a2c59cca4cda1869c06ebadfb6488550015a88522c', '30e93e864e669d82224b967c3020b8fa8d1e4e350b6cbcc537a48b57841163a2'], ['948dcadf5990e048aa3874d46abef9d701858f95de8041d2a6828c99e2262519', 'e491a42537f6e597d5d28a3224b1bc25df9154efbd2ef1d2cbba2cae5347d57e'], ['7962414450c76c1689c7b48f8202ec37fb224cf5ac0bfa1570328a8a3d7c77ab', '100b610ec4ffb4760d5c1fc133ef6f6b12507a051f04ac5760afa5b29db83437'], ['3514087834964b54b15b160644d915485a16977225b8847bb0dd085137ec47ca', 'ef0afbb2056205448e1652c48e8127fc6039e77c15c2378b7e7d15a0de293311'], ['d3cc30ad6b483e4bc79ce2c9dd8bc54993e947eb8df787b442943d3f7b527eaf', '8b378a22d827278d89c5e9be8f9508ae3c2ad46290358630afb34db04eede0a4'], ['1624d84780732860ce1c78fcbfefe08b2b29823db913f6493975ba0ff4847610', '68651cf9b6da903e0914448c6cd9d4ca896878f5282be4c8cc06e2a404078575'], ['733ce80da955a8a26902c95633e62a985192474b5af207da6df7b4fd5fc61cd4', 'f5435a2bd2badf7d485a4d8b8db9fcce3e1ef8e0201e4578c54673bc1dc5ea1d'], ['15d9441254945064cf1a1c33bbd3b49f8966c5092171e699ef258dfab81c045c', 'd56eb30b69463e7234f5137b73b84177434800bacebfc685fc37bbe9efe4070d'], ['a1d0fcf2ec9de675b612136e5ce70d271c21417c9d2b8aaaac138599d0717940', 'edd77f50bcb5a3cab2e90737309667f2641462a54070f3d519212d39c197a629'], ['e22fbe15c0af8ccc5780c0735f84dbe9a790badee8245c06c7ca37331cb36980', 'a855babad5cd60c88b430a69f53a1a7a38289154964799be43d06d77d31da06'], ['311091dd9860e8e20ee13473c1155f5f69635e394704eaa74009452246cfa9b3', '66db656f87d1f04fffd1f04788c06830871ec5a64feee685bd80f0b1286d8374'], ['34c1fd04d301be89b31c0442d3e6ac24883928b45a9340781867d4232ec2dbdf', '9414685e97b1b5954bd46f730174136d57f1ceeb487443dc5321857ba73abee'], ['f219ea5d6b54701c1c14de5b557eb42a8d13f3abbcd08affcc2a5e6b049b8d63', '4cb95957e83d40b0f73af4544cccf6b1f4b08d3c07b27fb8d8c2962a400766d1'], ['d7b8740f74a8fbaab1f683db8f45de26543a5490bca627087236912469a0b448', 'fa77968128d9c92ee1010f337ad4717eff15db5ed3c049b3411e0315eaa4593b'], ['32d31c222f8f6f0ef86f7c98d3a3335ead5bcd32abdd94289fe4d3091aa824bf', '5f3032f5892156e39ccd3d7915b9e1da2e6dac9e6f26e961118d14b8462e1661'], ['7461f371914ab32671045a155d9831ea8793d77cd59592c4340f86cbc18347b5', '8ec0ba238b96bec0cbdddcae0aa442542eee1ff50c986ea6b39847b3cc092ff6'], ['ee079adb1df1860074356a25aa38206a6d716b2c3e67453d287698bad7b2b2d6', '8dc2412aafe3be5c4c5f37e0ecc5f9f6a446989af04c4e25ebaac479ec1c8c1e'], ['16ec93e447ec83f0467b18302ee620f7e65de331874c9dc72bfd8616ba9da6b5', '5e4631150e62fb40d0e8c2a7ca5804a39d58186a50e497139626778e25b0674d'], ['eaa5f980c245f6f038978290afa70b6bd8855897f98b6aa485b96065d537bd99', 'f65f5d3e292c2e0819a528391c994624d784869d7e6ea67fb18041024edc07dc'], ['78c9407544ac132692ee1910a02439958ae04877151342ea96c4b6b35a49f51', 'f3e0319169eb9b85d5404795539a5e68fa1fbd583c064d2462b675f194a3ddb4'], ['494f4be219a1a77016dcd838431aea0001cdc8ae7a6fc688726578d9702857a5', '42242a969283a5f339ba7f075e36ba2af925ce30d767ed6e55f4b031880d562c'], ['a598a8030da6d86c6bc7f2f5144ea549d28211ea58faa70ebf4c1e665c1fe9b5', '204b5d6f84822c307e4b4a7140737aec23fc63b65b35f86a10026dbd2d864e6b'], ['c41916365abb2b5d09192f5f2dbeafec208f020f12570a184dbadc3e58595997', '4f14351d0087efa49d245b328984989d5caf9450f34bfc0ed16e96b58fa9913'], ['841d6063a586fa475a724604da03bc5b92a2e0d2e0a36acfe4c73a5514742881', '73867f59c0659e81904f9a1c7543698e62562d6744c169ce7a36de01a8d6154'], ['5e95bb399a6971d376026947f89bde2f282b33810928be4ded112ac4d70e20d5', '39f23f366809085beebfc71181313775a99c9aed7d8ba38b161384c746012865'], ['36e4641a53948fd476c39f8a99fd974e5ec07564b5315d8bf99471bca0ef2f66', 'd2424b1b1abe4eb8164227b085c9aa9456ea13493fd563e06fd51cf5694c78fc'], ['336581ea7bfbbb290c191a2f507a41cf5643842170e914faeab27c2c579f726', 'ead12168595fe1be99252129b6e56b3391f7ab1410cd1e0ef3dcdcabd2fda224'], ['8ab89816dadfd6b6a1f2634fcf00ec8403781025ed6890c4849742706bd43ede', '6fdcef09f2f6d0a044e654aef624136f503d459c3e89845858a47a9129cdd24e'], ['1e33f1a746c9c5778133344d9299fcaa20b0938e8acff2544bb40284b8c5fb94', '60660257dd11b3aa9c8ed618d24edff2306d320f1d03010e33a7d2057f3b3b6'], ['85b7c1dcb3cec1b7ee7f30ded79dd20a0ed1f4cc18cbcfcfa410361fd8f08f31', '3d98a9cdd026dd43f39048f25a8847f4fcafad1895d7a633c6fed3c35e999511'], ['29df9fbd8d9e46509275f4b125d6d45d7fbe9a3b878a7af872a2800661ac5f51', 'b4c4fe99c775a606e2d8862179139ffda61dc861c019e55cd2876eb2a27d84b'], ['a0b1cae06b0a847a3fea6e671aaf8adfdfe58ca2f768105c8082b2e449fce252', 'ae434102edde0958ec4b19d917a6a28e6b72da1834aff0e650f049503a296cf2'], ['4e8ceafb9b3e9a136dc7ff67e840295b499dfb3b2133e4ba113f2e4c0e121e5', 'cf2174118c8b6d7a4b48f6d534ce5c79422c086a63460502b827ce62a326683c'], ['d24a44e047e19b6f5afb81c7ca2f69080a5076689a010919f42725c2b789a33b', '6fb8d5591b466f8fc63db50f1c0f1c69013f996887b8244d2cdec417afea8fa3'], ['ea01606a7a6c9cdd249fdfcfacb99584001edd28abbab77b5104e98e8e3b35d4', '322af4908c7312b0cfbfe369f7a7b3cdb7d4494bc2823700cfd652188a3ea98d'], ['af8addbf2b661c8a6c6328655eb96651252007d8c5ea31be4ad196de8ce2131f', '6749e67c029b85f52a034eafd096836b2520818680e26ac8f3dfbcdb71749700'], ['e3ae1974566ca06cc516d47e0fb165a674a3dabcfca15e722f0e3450f45889', '2aeabe7e4531510116217f07bf4d07300de97e4874f81f533420a72eeb0bd6a4'], ['591ee355313d99721cf6993ffed1e3e301993ff3ed258802075ea8ced397e246', 'b0ea558a113c30bea60fc4775460c7901ff0b053d25ca2bdeee98f1a4be5d196'], ['11396d55fda54c49f19aa97318d8da61fa8584e47b084945077cf03255b52984', '998c74a8cd45ac01289d5833a7beb4744ff536b01b257be4c5767bea93ea57a4'], ['3c5d2a1ba39c5a1790000738c9e0c40b8dcdfd5468754b6405540157e017aa7a', 'b2284279995a34e2f9d4de7396fc18b80f9b8b9fdd270f6661f79ca4c81bd257'], ['cc8704b8a60a0defa3a99a7299f2e9c3fbc395afb04ac078425ef8a1793cc030', 'bdd46039feed17881d1e0862db347f8cf395b74fc4bcdc4e940b74e3ac1f1b13'], ['c533e4f7ea8555aacd9777ac5cad29b97dd4defccc53ee7ea204119b2889b197', '6f0a256bc5efdf429a2fb6242f1a43a2d9b925bb4a4b3a26bb8e0f45eb596096'], ['c14f8f2ccb27d6f109f6d08d03cc96a69ba8c34eec07bbcf566d48e33da6593', 'c359d6923bb398f7fd4473e16fe1c28475b740dd098075e6c0e8649113dc3a38'], ['a6cbc3046bc6a450bac24789fa17115a4c9739ed75f8f21ce441f72e0b90e6ef', '21ae7f4680e889bb130619e2c0f95a360ceb573c70603139862afd617fa9b9f'], ['347d6d9a02c48927ebfb86c1359b1caf130a3c0267d11ce6344b39f99d43cc38', '60ea7f61a353524d1c987f6ecec92f086d565ab687870cb12689ff1e31c74448'], ['da6545d2181db8d983f7dcb375ef5866d47c67b1bf31c8cf855ef7437b72656a', '49b96715ab6878a79e78f07ce5680c5d6673051b4935bd897fea824b77dc208a'], ['c40747cc9d012cb1a13b8148309c6de7ec25d6945d657146b9d5994b8feb1111', '5ca560753be2a12fc6de6caf2cb489565db936156b9514e1bb5e83037e0fa2d4'], ['4e42c8ec82c99798ccf3a610be870e78338c7f713348bd34c8203ef4037f3502', '7571d74ee5e0fb92a7a8b33a07783341a5492144cc54bcc40a94473693606437'], ['3775ab7089bc6af823aba2e1af70b236d251cadb0c86743287522a1b3b0dedea', 'be52d107bcfa09d8bcb9736a828cfa7fac8db17bf7a76a2c42ad961409018cf7'], ['cee31cbf7e34ec379d94fb814d3d775ad954595d1314ba8846959e3e82f74e26', '8fd64a14c06b589c26b947ae2bcf6bfa0149ef0be14ed4d80f448a01c43b1c6d'], ['b4f9eaea09b6917619f6ea6a4eb5464efddb58fd45b1ebefcdc1a01d08b47986', '39e5c9925b5a54b07433a4f18c61726f8bb131c012ca542eb24a8ac07200682a'], ['d4263dfc3d2df923a0179a48966d30ce84e2515afc3dccc1b77907792ebcc60e', '62dfaf07a0f78feb30e30d6295853ce189e127760ad6cf7fae164e122a208d54'], ['48457524820fa65a4f8d35eb6930857c0032acc0a4a2de422233eeda897612c4', '25a748ab367979d98733c38a1fa1c2e7dc6cc07db2d60a9ae7a76aaa49bd0f77'], ['dfeeef1881101f2cb11644f3a2afdfc2045e19919152923f367a1767c11cceda', 'ecfb7056cf1de042f9420bab396793c0c390bde74b4bbdff16a83ae09a9a7517'], ['6d7ef6b17543f8373c573f44e1f389835d89bcbc6062ced36c82df83b8fae859', 'cd450ec335438986dfefa10c57fea9bcc521a0959b2d80bbf74b190dca712d10'], ['e75605d59102a5a2684500d3b991f2e3f3c88b93225547035af25af66e04541f', 'f5c54754a8f71ee540b9b48728473e314f729ac5308b06938360990e2bfad125'], ['eb98660f4c4dfaa06a2be453d5020bc99a0c2e60abe388457dd43fefb1ed620c', '6cb9a8876d9cb8520609af3add26cd20a0a7cd8a9411131ce85f44100099223e'], ['13e87b027d8514d35939f2e6892b19922154596941888336dc3563e3b8dba942', 'fef5a3c68059a6dec5d624114bf1e91aac2b9da568d6abeb2570d55646b8adf1'], ['ee163026e9fd6fe017c38f06a5be6fc125424b371ce2708e7bf4491691e5764a', '1acb250f255dd61c43d94ccc670d0f58f49ae3fa15b96623e5430da0ad6c62b2'], ['b268f5ef9ad51e4d78de3a750c2dc89b1e626d43505867999932e5db33af3d80', '5f310d4b3c99b9ebb19f77d41c1dee018cf0d34fd4191614003e945a1216e423'], ['ff07f3118a9df035e9fad85eb6c7bfe42b02f01ca99ceea3bf7ffdba93c4750d', '438136d603e858a3a5c440c38eccbaddc1d2942114e2eddd4740d098ced1f0d8'], ['8d8b9855c7c052a34146fd20ffb658bea4b9f69e0d825ebec16e8c3ce2b526a1', 'cdb559eedc2d79f926baf44fb84ea4d44bcf50fee51d7ceb30e2e7f463036758'], ['52db0b5384dfbf05bfa9d472d7ae26dfe4b851ceca91b1eba54263180da32b63', 'c3b997d050ee5d423ebaf66a6db9f57b3180c902875679de924b69d84a7b375'], ['e62f9490d3d51da6395efd24e80919cc7d0f29c3f3fa48c6fff543becbd43352', '6d89ad7ba4876b0b22c2ca280c682862f342c8591f1daf5170e07bfd9ccafa7d'], ['7f30ea2476b399b4957509c88f77d0191afa2ff5cb7b14fd6d8e7d65aaab1193', 'ca5ef7d4b231c94c3b15389a5f6311e9daff7bb67b103e9880ef4bff637acaec'], ['5098ff1e1d9f14fb46a210fada6c903fef0fb7b4a1dd1d9ac60a0361800b7a00', '9731141d81fc8f8084d37c6e7542006b3ee1b40d60dfe5362a5b132fd17ddc0'], ['32b78c7de9ee512a72895be6b9cbefa6e2f3c4ccce445c96b9f2c81e2778ad58', 'ee1849f513df71e32efc3896ee28260c73bb80547ae2275ba497237794c8753c'], ['e2cb74fddc8e9fbcd076eef2a7c72b0ce37d50f08269dfc074b581550547a4f7', 'd3aa2ed71c9dd2247a62df062736eb0baddea9e36122d2be8641abcb005cc4a4'], ['8438447566d4d7bedadc299496ab357426009a35f235cb141be0d99cd10ae3a8', 'c4e1020916980a4da5d01ac5e6ad330734ef0d7906631c4f2390426b2edd791f'], ['4162d488b89402039b584c6fc6c308870587d9c46f660b878ab65c82c711d67e', '67163e903236289f776f22c25fb8a3afc1732f2b84b4e95dbda47ae5a0852649'], ['3fad3fa84caf0f34f0f89bfd2dcf54fc175d767aec3e50684f3ba4a4bf5f683d', 'cd1bc7cb6cc407bb2f0ca647c718a730cf71872e7d0d2a53fa20efcdfe61826'], ['674f2600a3007a00568c1a7ce05d0816c1fb84bf1370798f1c69532faeb1a86b', '299d21f9413f33b3edf43b257004580b70db57da0b182259e09eecc69e0d38a5'], ['d32f4da54ade74abb81b815ad1fb3b263d82d6c692714bcff87d29bd5ee9f08f', 'f9429e738b8e53b968e99016c059707782e14f4535359d582fc416910b3eea87'], ['30e4e670435385556e593657135845d36fbb6931f72b08cb1ed954f1e3ce3ff6', '462f9bce619898638499350113bbc9b10a878d35da70740dc695a559eb88db7b'], ['be2062003c51cc3004682904330e4dee7f3dcd10b01e580bf1971b04d4cad297', '62188bc49d61e5428573d48a74e1c655b1c61090905682a0d5558ed72dccb9bc'], ['93144423ace3451ed29e0fb9ac2af211cb6e84a601df5993c419859fff5df04a', '7c10dfb164c3425f5c71a3f9d7992038f1065224f72bb9d1d902a6d13037b47c'], ['b015f8044f5fcbdcf21ca26d6c34fb8197829205c7b7d2a7cb66418c157b112c', 'ab8c1e086d04e813744a655b2df8d5f83b3cdc6faa3088c1d3aea1454e3a1d5f'], ['d5e9e1da649d97d89e4868117a465a3a4f8a18de57a140d36b3f2af341a21b52', '4cb04437f391ed73111a13cc1d4dd0db1693465c2240480d8955e8592f27447a'], ['d3ae41047dd7ca065dbf8ed77b992439983005cd72e16d6f996a5316d36966bb', 'bd1aeb21ad22ebb22a10f0303417c6d964f8cdd7df0aca614b10dc14d125ac46'], ['463e2763d885f958fc66cdd22800f0a487197d0a82e377b49f80af87c897b065', 'bfefacdb0e5d0fd7df3a311a94de062b26b80c61fbc97508b79992671ef7ca7f'], ['7985fdfd127c0567c6f53ec1bb63ec3158e597c40bfe747c83cddfc910641917', '603c12daf3d9862ef2b25fe1de289aed24ed291e0ec6708703a5bd567f32ed03'], ['74a1ad6b5f76e39db2dd249410eac7f99e74c59cb83d2d0ed5ff1543da7703e9', 'cc6157ef18c9c63cd6193d83631bbea0093e0968942e8c33d5737fd790e0db08'], ['30682a50703375f602d416664ba19b7fc9bab42c72747463a71d0896b22f6da3', '553e04f6b018b4fa6c8f39e7f311d3176290d0e0f19ca73f17714d9977a22ff8'], ['9e2158f0d7c0d5f26c3791efefa79597654e7a2b2464f52b1ee6c1347769ef57', '712fcdd1b9053f09003a3481fa7762e9ffd7c8ef35a38509e2fbf2629008373'], ['176e26989a43c9cfeba4029c202538c28172e566e3c4fce7322857f3be327d66', 'ed8cc9d04b29eb877d270b4878dc43c19aefd31f4eee09ee7b47834c1fa4b1c3'], ['75d46efea3771e6e68abb89a13ad747ecf1892393dfc4f1b7004788c50374da8', '9852390a99507679fd0b86fd2b39a868d7efc22151346e1a3ca4726586a6bed8'], ['809a20c67d64900ffb698c4c825f6d5f2310fb0451c869345b7319f645605721', '9e994980d9917e22b76b061927fa04143d096ccc54963e6a5ebfa5f3f8e286c1'], ['1b38903a43f7f114ed4500b4eac7083fdefece1cf29c63528d563446f972c180', '4036edc931a60ae889353f77fd53de4a2708b26b6f5da72ad3394119daf408f9']]
  }
};

/***/ }),

/***/ 8619:
/*!******************************************************!*\
  !*** ../node_modules/elliptic/lib/elliptic/utils.js ***!
  \******************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


var utils = exports;
var BN = __webpack_require__(/*! bn.js */ 1046);
var minAssert = __webpack_require__(/*! minimalistic-assert */ 5305);
var minUtils = __webpack_require__(/*! minimalistic-crypto-utils */ 8704);
utils.assert = minAssert;
utils.toArray = minUtils.toArray;
utils.zero2 = minUtils.zero2;
utils.toHex = minUtils.toHex;
utils.encode = minUtils.encode;

// Represent num in a w-NAF form
function getNAF(num, w, bits) {
  var naf = new Array(Math.max(num.bitLength(), bits) + 1);
  naf.fill(0);
  var ws = 1 << w + 1;
  var k = num.clone();
  for (var i = 0; i < naf.length; i++) {
    var z;
    var mod = k.andln(ws - 1);
    if (k.isOdd()) {
      if (mod > (ws >> 1) - 1) z = (ws >> 1) - mod;else z = mod;
      k.isubn(z);
    } else {
      z = 0;
    }
    naf[i] = z;
    k.iushrn(1);
  }
  return naf;
}
utils.getNAF = getNAF;

// Represent k1, k2 in a Joint Sparse Form
function getJSF(k1, k2) {
  var jsf = [[], []];
  k1 = k1.clone();
  k2 = k2.clone();
  var d1 = 0;
  var d2 = 0;
  var m8;
  while (k1.cmpn(-d1) > 0 || k2.cmpn(-d2) > 0) {
    // First phase
    var m14 = k1.andln(3) + d1 & 3;
    var m24 = k2.andln(3) + d2 & 3;
    if (m14 === 3) m14 = -1;
    if (m24 === 3) m24 = -1;
    var u1;
    if ((m14 & 1) === 0) {
      u1 = 0;
    } else {
      m8 = k1.andln(7) + d1 & 7;
      if ((m8 === 3 || m8 === 5) && m24 === 2) u1 = -m14;else u1 = m14;
    }
    jsf[0].push(u1);
    var u2;
    if ((m24 & 1) === 0) {
      u2 = 0;
    } else {
      m8 = k2.andln(7) + d2 & 7;
      if ((m8 === 3 || m8 === 5) && m14 === 2) u2 = -m24;else u2 = m24;
    }
    jsf[1].push(u2);

    // Second phase
    if (2 * d1 === u1 + 1) d1 = 1 - d1;
    if (2 * d2 === u2 + 1) d2 = 1 - d2;
    k1.iushrn(1);
    k2.iushrn(1);
  }
  return jsf;
}
utils.getJSF = getJSF;
function cachedProperty(obj, name, computer) {
  var key = '_' + name;
  obj.prototype[name] = function cachedProperty() {
    return this[key] !== undefined ? this[key] : this[key] = computer.call(this);
  };
}
utils.cachedProperty = cachedProperty;
function parseBytes(bytes) {
  return typeof bytes === 'string' ? utils.toArray(bytes, 'hex') : bytes;
}
utils.parseBytes = parseBytes;
function intFromLE(bytes) {
  return new BN(bytes, 'hex', 'le');
}
utils.intFromLE = intFromLE;

/***/ }),

/***/ 3325:
/*!***********************************************!*\
  !*** ../node_modules/evp_bytestokey/index.js ***!
  \***********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
var MD5 = __webpack_require__(/*! md5.js */ 5106);

/* eslint-disable camelcase */
function EVP_BytesToKey(password, salt, keyBits, ivLen) {
  if (!Buffer.isBuffer(password)) password = Buffer.from(password, 'binary');
  if (salt) {
    if (!Buffer.isBuffer(salt)) salt = Buffer.from(salt, 'binary');
    if (salt.length !== 8) throw new RangeError('salt should be Buffer with 8 byte length');
  }
  var keyLen = keyBits / 8;
  var key = Buffer.alloc(keyLen);
  var iv = Buffer.alloc(ivLen || 0);
  var tmp = Buffer.alloc(0);
  while (keyLen > 0 || ivLen > 0) {
    var hash = new MD5();
    hash.update(tmp);
    hash.update(password);
    if (salt) hash.update(salt);
    tmp = hash.digest();
    var used = 0;
    if (keyLen > 0) {
      var keyStart = key.length - keyLen;
      used = Math.min(keyLen, tmp.length);
      tmp.copy(key, keyStart, 0, used);
      keyLen -= used;
    }
    if (used < tmp.length && ivLen > 0) {
      var ivStart = iv.length - ivLen;
      var length = Math.min(ivLen, tmp.length - used);
      tmp.copy(iv, ivStart, used, used + length);
      ivLen -= length;
    }
  }
  tmp.fill(0);
  return {
    key: key,
    iv: iv
  };
}
module.exports = EVP_BytesToKey;

/***/ }),

/***/ 1668:
/*!******************************************!*\
  !*** ../node_modules/hash-base/index.js ***!
  \******************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
var Transform = (__webpack_require__(/*! readable-stream */ 5979).Transform);
var inherits = __webpack_require__(/*! inherits */ 7694);
function throwIfNotStringOrBuffer(val, prefix) {
  if (!Buffer.isBuffer(val) && typeof val !== 'string') {
    throw new TypeError(prefix + ' must be a string or a buffer');
  }
}
function HashBase(blockSize) {
  Transform.call(this);
  this._block = Buffer.allocUnsafe(blockSize);
  this._blockSize = blockSize;
  this._blockOffset = 0;
  this._length = [0, 0, 0, 0];
  this._finalized = false;
}
inherits(HashBase, Transform);
HashBase.prototype._transform = function (chunk, encoding, callback) {
  var error = null;
  try {
    this.update(chunk, encoding);
  } catch (err) {
    error = err;
  }
  callback(error);
};
HashBase.prototype._flush = function (callback) {
  var error = null;
  try {
    this.push(this.digest());
  } catch (err) {
    error = err;
  }
  callback(error);
};
HashBase.prototype.update = function (data, encoding) {
  throwIfNotStringOrBuffer(data, 'Data');
  if (this._finalized) throw new Error('Digest already called');
  if (!Buffer.isBuffer(data)) data = Buffer.from(data, encoding);

  // consume data
  var block = this._block;
  var offset = 0;
  while (this._blockOffset + data.length - offset >= this._blockSize) {
    for (var i = this._blockOffset; i < this._blockSize;) block[i++] = data[offset++];
    this._update();
    this._blockOffset = 0;
  }
  while (offset < data.length) block[this._blockOffset++] = data[offset++];

  // update length
  for (var j = 0, carry = data.length * 8; carry > 0; ++j) {
    this._length[j] += carry;
    carry = this._length[j] / 0x0100000000 | 0;
    if (carry > 0) this._length[j] -= 0x0100000000 * carry;
  }
  return this;
};
HashBase.prototype._update = function () {
  throw new Error('_update is not implemented');
};
HashBase.prototype.digest = function (encoding) {
  if (this._finalized) throw new Error('Digest already called');
  this._finalized = true;
  var digest = this._digest();
  if (encoding !== undefined) digest = digest.toString(encoding);

  // reset state
  this._block.fill(0);
  this._blockOffset = 0;
  for (var i = 0; i < 4; ++i) this._length[i] = 0;
  return digest;
};
HashBase.prototype._digest = function () {
  throw new Error('_digest is not implemented');
};
module.exports = HashBase;

/***/ }),

/***/ 8313:
/*!*******************************************!*\
  !*** ../node_modules/hash.js/lib/hash.js ***!
  \*******************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

var hash = exports;
hash.utils = __webpack_require__(/*! ./hash/utils */ 2282);
hash.common = __webpack_require__(/*! ./hash/common */ 7064);
hash.sha = __webpack_require__(/*! ./hash/sha */ 5158);
hash.ripemd = __webpack_require__(/*! ./hash/ripemd */ 481);
hash.hmac = __webpack_require__(/*! ./hash/hmac */ 4879);

// Proxy hash functions to the main object
hash.sha1 = hash.sha.sha1;
hash.sha256 = hash.sha.sha256;
hash.sha224 = hash.sha.sha224;
hash.sha384 = hash.sha.sha384;
hash.sha512 = hash.sha.sha512;
hash.ripemd160 = hash.ripemd.ripemd160;

/***/ }),

/***/ 7064:
/*!**************************************************!*\
  !*** ../node_modules/hash.js/lib/hash/common.js ***!
  \**************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


var utils = __webpack_require__(/*! ./utils */ 2282);
var assert = __webpack_require__(/*! minimalistic-assert */ 5305);
function BlockHash() {
  this.pending = null;
  this.pendingTotal = 0;
  this.blockSize = this.constructor.blockSize;
  this.outSize = this.constructor.outSize;
  this.hmacStrength = this.constructor.hmacStrength;
  this.padLength = this.constructor.padLength / 8;
  this.endian = 'big';
  this._delta8 = this.blockSize / 8;
  this._delta32 = this.blockSize / 32;
}
exports.BlockHash = BlockHash;
BlockHash.prototype.update = function update(msg, enc) {
  // Convert message to array, pad it, and join into 32bit blocks
  msg = utils.toArray(msg, enc);
  if (!this.pending) this.pending = msg;else this.pending = this.pending.concat(msg);
  this.pendingTotal += msg.length;

  // Enough data, try updating
  if (this.pending.length >= this._delta8) {
    msg = this.pending;

    // Process pending data in blocks
    var r = msg.length % this._delta8;
    this.pending = msg.slice(msg.length - r, msg.length);
    if (this.pending.length === 0) this.pending = null;
    msg = utils.join32(msg, 0, msg.length - r, this.endian);
    for (var i = 0; i < msg.length; i += this._delta32) this._update(msg, i, i + this._delta32);
  }
  return this;
};
BlockHash.prototype.digest = function digest(enc) {
  this.update(this._pad());
  assert(this.pending === null);
  return this._digest(enc);
};
BlockHash.prototype._pad = function pad() {
  var len = this.pendingTotal;
  var bytes = this._delta8;
  var k = bytes - (len + this.padLength) % bytes;
  var res = new Array(k + this.padLength);
  res[0] = 0x80;
  for (var i = 1; i < k; i++) res[i] = 0;

  // Append length
  len <<= 3;
  if (this.endian === 'big') {
    for (var t = 8; t < this.padLength; t++) res[i++] = 0;
    res[i++] = 0;
    res[i++] = 0;
    res[i++] = 0;
    res[i++] = 0;
    res[i++] = len >>> 24 & 0xff;
    res[i++] = len >>> 16 & 0xff;
    res[i++] = len >>> 8 & 0xff;
    res[i++] = len & 0xff;
  } else {
    res[i++] = len & 0xff;
    res[i++] = len >>> 8 & 0xff;
    res[i++] = len >>> 16 & 0xff;
    res[i++] = len >>> 24 & 0xff;
    res[i++] = 0;
    res[i++] = 0;
    res[i++] = 0;
    res[i++] = 0;
    for (t = 8; t < this.padLength; t++) res[i++] = 0;
  }
  return res;
};

/***/ }),

/***/ 4879:
/*!************************************************!*\
  !*** ../node_modules/hash.js/lib/hash/hmac.js ***!
  \************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


var utils = __webpack_require__(/*! ./utils */ 2282);
var assert = __webpack_require__(/*! minimalistic-assert */ 5305);
function Hmac(hash, key, enc) {
  if (!(this instanceof Hmac)) return new Hmac(hash, key, enc);
  this.Hash = hash;
  this.blockSize = hash.blockSize / 8;
  this.outSize = hash.outSize / 8;
  this.inner = null;
  this.outer = null;
  this._init(utils.toArray(key, enc));
}
module.exports = Hmac;
Hmac.prototype._init = function init(key) {
  // Shorten key, if needed
  if (key.length > this.blockSize) key = new this.Hash().update(key).digest();
  assert(key.length <= this.blockSize);

  // Add padding to key
  for (var i = key.length; i < this.blockSize; i++) key.push(0);
  for (i = 0; i < key.length; i++) key[i] ^= 0x36;
  this.inner = new this.Hash().update(key);

  // 0x36 ^ 0x5c = 0x6a
  for (i = 0; i < key.length; i++) key[i] ^= 0x6a;
  this.outer = new this.Hash().update(key);
};
Hmac.prototype.update = function update(msg, enc) {
  this.inner.update(msg, enc);
  return this;
};
Hmac.prototype.digest = function digest(enc) {
  this.outer.update(this.inner.digest());
  return this.outer.digest(enc);
};

/***/ }),

/***/ 481:
/*!**************************************************!*\
  !*** ../node_modules/hash.js/lib/hash/ripemd.js ***!
  \**************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


var utils = __webpack_require__(/*! ./utils */ 2282);
var common = __webpack_require__(/*! ./common */ 7064);
var rotl32 = utils.rotl32;
var sum32 = utils.sum32;
var sum32_3 = utils.sum32_3;
var sum32_4 = utils.sum32_4;
var BlockHash = common.BlockHash;
function RIPEMD160() {
  if (!(this instanceof RIPEMD160)) return new RIPEMD160();
  BlockHash.call(this);
  this.h = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0];
  this.endian = 'little';
}
utils.inherits(RIPEMD160, BlockHash);
exports.ripemd160 = RIPEMD160;
RIPEMD160.blockSize = 512;
RIPEMD160.outSize = 160;
RIPEMD160.hmacStrength = 192;
RIPEMD160.padLength = 64;
RIPEMD160.prototype._update = function update(msg, start) {
  var A = this.h[0];
  var B = this.h[1];
  var C = this.h[2];
  var D = this.h[3];
  var E = this.h[4];
  var Ah = A;
  var Bh = B;
  var Ch = C;
  var Dh = D;
  var Eh = E;
  for (var j = 0; j < 80; j++) {
    var T = sum32(rotl32(sum32_4(A, f(j, B, C, D), msg[r[j] + start], K(j)), s[j]), E);
    A = E;
    E = D;
    D = rotl32(C, 10);
    C = B;
    B = T;
    T = sum32(rotl32(sum32_4(Ah, f(79 - j, Bh, Ch, Dh), msg[rh[j] + start], Kh(j)), sh[j]), Eh);
    Ah = Eh;
    Eh = Dh;
    Dh = rotl32(Ch, 10);
    Ch = Bh;
    Bh = T;
  }
  T = sum32_3(this.h[1], C, Dh);
  this.h[1] = sum32_3(this.h[2], D, Eh);
  this.h[2] = sum32_3(this.h[3], E, Ah);
  this.h[3] = sum32_3(this.h[4], A, Bh);
  this.h[4] = sum32_3(this.h[0], B, Ch);
  this.h[0] = T;
};
RIPEMD160.prototype._digest = function digest(enc) {
  if (enc === 'hex') return utils.toHex32(this.h, 'little');else return utils.split32(this.h, 'little');
};
function f(j, x, y, z) {
  if (j <= 15) return x ^ y ^ z;else if (j <= 31) return x & y | ~x & z;else if (j <= 47) return (x | ~y) ^ z;else if (j <= 63) return x & z | y & ~z;else return x ^ (y | ~z);
}
function K(j) {
  if (j <= 15) return 0x00000000;else if (j <= 31) return 0x5a827999;else if (j <= 47) return 0x6ed9eba1;else if (j <= 63) return 0x8f1bbcdc;else return 0xa953fd4e;
}
function Kh(j) {
  if (j <= 15) return 0x50a28be6;else if (j <= 31) return 0x5c4dd124;else if (j <= 47) return 0x6d703ef3;else if (j <= 63) return 0x7a6d76e9;else return 0x00000000;
}
var r = [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 rh = [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 s = [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 sh = [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];

/***/ }),

/***/ 5158:
/*!***********************************************!*\
  !*** ../node_modules/hash.js/lib/hash/sha.js ***!
  \***********************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


exports.sha1 = __webpack_require__(/*! ./sha/1 */ 421);
exports.sha224 = __webpack_require__(/*! ./sha/224 */ 7489);
exports.sha256 = __webpack_require__(/*! ./sha/256 */ 3022);
exports.sha384 = __webpack_require__(/*! ./sha/384 */ 6582);
exports.sha512 = __webpack_require__(/*! ./sha/512 */ 2666);

/***/ }),

/***/ 421:
/*!*************************************************!*\
  !*** ../node_modules/hash.js/lib/hash/sha/1.js ***!
  \*************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


var utils = __webpack_require__(/*! ../utils */ 2282);
var common = __webpack_require__(/*! ../common */ 7064);
var shaCommon = __webpack_require__(/*! ./common */ 5489);
var rotl32 = utils.rotl32;
var sum32 = utils.sum32;
var sum32_5 = utils.sum32_5;
var ft_1 = shaCommon.ft_1;
var BlockHash = common.BlockHash;
var sha1_K = [0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xCA62C1D6];
function SHA1() {
  if (!(this instanceof SHA1)) return new SHA1();
  BlockHash.call(this);
  this.h = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0];
  this.W = new Array(80);
}
utils.inherits(SHA1, BlockHash);
module.exports = SHA1;
SHA1.blockSize = 512;
SHA1.outSize = 160;
SHA1.hmacStrength = 80;
SHA1.padLength = 64;
SHA1.prototype._update = function _update(msg, start) {
  var W = this.W;
  for (var i = 0; i < 16; i++) W[i] = msg[start + i];
  for (; i < W.length; i++) W[i] = rotl32(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16], 1);
  var a = this.h[0];
  var b = this.h[1];
  var c = this.h[2];
  var d = this.h[3];
  var e = this.h[4];
  for (i = 0; i < W.length; i++) {
    var s = ~~(i / 20);
    var t = sum32_5(rotl32(a, 5), ft_1(s, b, c, d), e, W[i], sha1_K[s]);
    e = d;
    d = c;
    c = rotl32(b, 30);
    b = a;
    a = t;
  }
  this.h[0] = sum32(this.h[0], a);
  this.h[1] = sum32(this.h[1], b);
  this.h[2] = sum32(this.h[2], c);
  this.h[3] = sum32(this.h[3], d);
  this.h[4] = sum32(this.h[4], e);
};
SHA1.prototype._digest = function digest(enc) {
  if (enc === 'hex') return utils.toHex32(this.h, 'big');else return utils.split32(this.h, 'big');
};

/***/ }),

/***/ 7489:
/*!***************************************************!*\
  !*** ../node_modules/hash.js/lib/hash/sha/224.js ***!
  \***************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


var utils = __webpack_require__(/*! ../utils */ 2282);
var SHA256 = __webpack_require__(/*! ./256 */ 3022);
function SHA224() {
  if (!(this instanceof SHA224)) return new SHA224();
  SHA256.call(this);
  this.h = [0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4];
}
utils.inherits(SHA224, SHA256);
module.exports = SHA224;
SHA224.blockSize = 512;
SHA224.outSize = 224;
SHA224.hmacStrength = 192;
SHA224.padLength = 64;
SHA224.prototype._digest = function digest(enc) {
  // Just truncate output
  if (enc === 'hex') return utils.toHex32(this.h.slice(0, 7), 'big');else return utils.split32(this.h.slice(0, 7), 'big');
};

/***/ }),

/***/ 3022:
/*!***************************************************!*\
  !*** ../node_modules/hash.js/lib/hash/sha/256.js ***!
  \***************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


var utils = __webpack_require__(/*! ../utils */ 2282);
var common = __webpack_require__(/*! ../common */ 7064);
var shaCommon = __webpack_require__(/*! ./common */ 5489);
var assert = __webpack_require__(/*! minimalistic-assert */ 5305);
var sum32 = utils.sum32;
var sum32_4 = utils.sum32_4;
var sum32_5 = utils.sum32_5;
var ch32 = shaCommon.ch32;
var maj32 = shaCommon.maj32;
var s0_256 = shaCommon.s0_256;
var s1_256 = shaCommon.s1_256;
var g0_256 = shaCommon.g0_256;
var g1_256 = shaCommon.g1_256;
var BlockHash = common.BlockHash;
var sha256_K = [0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2];
function SHA256() {
  if (!(this instanceof SHA256)) return new SHA256();
  BlockHash.call(this);
  this.h = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19];
  this.k = sha256_K;
  this.W = new Array(64);
}
utils.inherits(SHA256, BlockHash);
module.exports = SHA256;
SHA256.blockSize = 512;
SHA256.outSize = 256;
SHA256.hmacStrength = 192;
SHA256.padLength = 64;
SHA256.prototype._update = function _update(msg, start) {
  var W = this.W;
  for (var i = 0; i < 16; i++) W[i] = msg[start + i];
  for (; i < W.length; i++) W[i] = sum32_4(g1_256(W[i - 2]), W[i - 7], g0_256(W[i - 15]), W[i - 16]);
  var a = this.h[0];
  var b = this.h[1];
  var c = this.h[2];
  var d = this.h[3];
  var e = this.h[4];
  var f = this.h[5];
  var g = this.h[6];
  var h = this.h[7];
  assert(this.k.length === W.length);
  for (i = 0; i < W.length; i++) {
    var T1 = sum32_5(h, s1_256(e), ch32(e, f, g), this.k[i], W[i]);
    var T2 = sum32(s0_256(a), maj32(a, b, c));
    h = g;
    g = f;
    f = e;
    e = sum32(d, T1);
    d = c;
    c = b;
    b = a;
    a = sum32(T1, T2);
  }
  this.h[0] = sum32(this.h[0], a);
  this.h[1] = sum32(this.h[1], b);
  this.h[2] = sum32(this.h[2], c);
  this.h[3] = sum32(this.h[3], d);
  this.h[4] = sum32(this.h[4], e);
  this.h[5] = sum32(this.h[5], f);
  this.h[6] = sum32(this.h[6], g);
  this.h[7] = sum32(this.h[7], h);
};
SHA256.prototype._digest = function digest(enc) {
  if (enc === 'hex') return utils.toHex32(this.h, 'big');else return utils.split32(this.h, 'big');
};

/***/ }),

/***/ 6582:
/*!***************************************************!*\
  !*** ../node_modules/hash.js/lib/hash/sha/384.js ***!
  \***************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


var utils = __webpack_require__(/*! ../utils */ 2282);
var SHA512 = __webpack_require__(/*! ./512 */ 2666);
function SHA384() {
  if (!(this instanceof SHA384)) return new SHA384();
  SHA512.call(this);
  this.h = [0xcbbb9d5d, 0xc1059ed8, 0x629a292a, 0x367cd507, 0x9159015a, 0x3070dd17, 0x152fecd8, 0xf70e5939, 0x67332667, 0xffc00b31, 0x8eb44a87, 0x68581511, 0xdb0c2e0d, 0x64f98fa7, 0x47b5481d, 0xbefa4fa4];
}
utils.inherits(SHA384, SHA512);
module.exports = SHA384;
SHA384.blockSize = 1024;
SHA384.outSize = 384;
SHA384.hmacStrength = 192;
SHA384.padLength = 128;
SHA384.prototype._digest = function digest(enc) {
  if (enc === 'hex') return utils.toHex32(this.h.slice(0, 12), 'big');else return utils.split32(this.h.slice(0, 12), 'big');
};

/***/ }),

/***/ 2666:
/*!***************************************************!*\
  !*** ../node_modules/hash.js/lib/hash/sha/512.js ***!
  \***************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


var utils = __webpack_require__(/*! ../utils */ 2282);
var common = __webpack_require__(/*! ../common */ 7064);
var assert = __webpack_require__(/*! minimalistic-assert */ 5305);
var rotr64_hi = utils.rotr64_hi;
var rotr64_lo = utils.rotr64_lo;
var shr64_hi = utils.shr64_hi;
var shr64_lo = utils.shr64_lo;
var sum64 = utils.sum64;
var sum64_hi = utils.sum64_hi;
var sum64_lo = utils.sum64_lo;
var sum64_4_hi = utils.sum64_4_hi;
var sum64_4_lo = utils.sum64_4_lo;
var sum64_5_hi = utils.sum64_5_hi;
var sum64_5_lo = utils.sum64_5_lo;
var BlockHash = common.BlockHash;
var sha512_K = [0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd, 0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc, 0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019, 0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118, 0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe, 0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2, 0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1, 0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694, 0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3, 0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65, 0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483, 0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5, 0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210, 0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4, 0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725, 0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70, 0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926, 0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df, 0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8, 0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b, 0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001, 0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30, 0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910, 0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8, 0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53, 0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8, 0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb, 0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3, 0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60, 0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec, 0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9, 0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b, 0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207, 0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178, 0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6, 0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b, 0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493, 0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c, 0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a, 0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817];
function SHA512() {
  if (!(this instanceof SHA512)) return new SHA512();
  BlockHash.call(this);
  this.h = [0x6a09e667, 0xf3bcc908, 0xbb67ae85, 0x84caa73b, 0x3c6ef372, 0xfe94f82b, 0xa54ff53a, 0x5f1d36f1, 0x510e527f, 0xade682d1, 0x9b05688c, 0x2b3e6c1f, 0x1f83d9ab, 0xfb41bd6b, 0x5be0cd19, 0x137e2179];
  this.k = sha512_K;
  this.W = new Array(160);
}
utils.inherits(SHA512, BlockHash);
module.exports = SHA512;
SHA512.blockSize = 1024;
SHA512.outSize = 512;
SHA512.hmacStrength = 192;
SHA512.padLength = 128;
SHA512.prototype._prepareBlock = function _prepareBlock(msg, start) {
  var W = this.W;

  // 32 x 32bit words
  for (var i = 0; i < 32; i++) W[i] = msg[start + i];
  for (; i < W.length; i += 2) {
    var c0_hi = g1_512_hi(W[i - 4], W[i - 3]); // i - 2
    var c0_lo = g1_512_lo(W[i - 4], W[i - 3]);
    var c1_hi = W[i - 14]; // i - 7
    var c1_lo = W[i - 13];
    var c2_hi = g0_512_hi(W[i - 30], W[i - 29]); // i - 15
    var c2_lo = g0_512_lo(W[i - 30], W[i - 29]);
    var c3_hi = W[i - 32]; // i - 16
    var c3_lo = W[i - 31];
    W[i] = sum64_4_hi(c0_hi, c0_lo, c1_hi, c1_lo, c2_hi, c2_lo, c3_hi, c3_lo);
    W[i + 1] = sum64_4_lo(c0_hi, c0_lo, c1_hi, c1_lo, c2_hi, c2_lo, c3_hi, c3_lo);
  }
};
SHA512.prototype._update = function _update(msg, start) {
  this._prepareBlock(msg, start);
  var W = this.W;
  var ah = this.h[0];
  var al = this.h[1];
  var bh = this.h[2];
  var bl = this.h[3];
  var ch = this.h[4];
  var cl = this.h[5];
  var dh = this.h[6];
  var dl = this.h[7];
  var eh = this.h[8];
  var el = this.h[9];
  var fh = this.h[10];
  var fl = this.h[11];
  var gh = this.h[12];
  var gl = this.h[13];
  var hh = this.h[14];
  var hl = this.h[15];
  assert(this.k.length === W.length);
  for (var i = 0; i < W.length; i += 2) {
    var c0_hi = hh;
    var c0_lo = hl;
    var c1_hi = s1_512_hi(eh, el);
    var c1_lo = s1_512_lo(eh, el);
    var c2_hi = ch64_hi(eh, el, fh, fl, gh, gl);
    var c2_lo = ch64_lo(eh, el, fh, fl, gh, gl);
    var c3_hi = this.k[i];
    var c3_lo = this.k[i + 1];
    var c4_hi = W[i];
    var c4_lo = W[i + 1];
    var T1_hi = sum64_5_hi(c0_hi, c0_lo, c1_hi, c1_lo, c2_hi, c2_lo, c3_hi, c3_lo, c4_hi, c4_lo);
    var T1_lo = sum64_5_lo(c0_hi, c0_lo, c1_hi, c1_lo, c2_hi, c2_lo, c3_hi, c3_lo, c4_hi, c4_lo);
    c0_hi = s0_512_hi(ah, al);
    c0_lo = s0_512_lo(ah, al);
    c1_hi = maj64_hi(ah, al, bh, bl, ch, cl);
    c1_lo = maj64_lo(ah, al, bh, bl, ch, cl);
    var T2_hi = sum64_hi(c0_hi, c0_lo, c1_hi, c1_lo);
    var T2_lo = sum64_lo(c0_hi, c0_lo, c1_hi, c1_lo);
    hh = gh;
    hl = gl;
    gh = fh;
    gl = fl;
    fh = eh;
    fl = el;
    eh = sum64_hi(dh, dl, T1_hi, T1_lo);
    el = sum64_lo(dl, dl, T1_hi, T1_lo);
    dh = ch;
    dl = cl;
    ch = bh;
    cl = bl;
    bh = ah;
    bl = al;
    ah = sum64_hi(T1_hi, T1_lo, T2_hi, T2_lo);
    al = sum64_lo(T1_hi, T1_lo, T2_hi, T2_lo);
  }
  sum64(this.h, 0, ah, al);
  sum64(this.h, 2, bh, bl);
  sum64(this.h, 4, ch, cl);
  sum64(this.h, 6, dh, dl);
  sum64(this.h, 8, eh, el);
  sum64(this.h, 10, fh, fl);
  sum64(this.h, 12, gh, gl);
  sum64(this.h, 14, hh, hl);
};
SHA512.prototype._digest = function digest(enc) {
  if (enc === 'hex') return utils.toHex32(this.h, 'big');else return utils.split32(this.h, 'big');
};
function ch64_hi(xh, xl, yh, yl, zh) {
  var r = xh & yh ^ ~xh & zh;
  if (r < 0) r += 0x100000000;
  return r;
}
function ch64_lo(xh, xl, yh, yl, zh, zl) {
  var r = xl & yl ^ ~xl & zl;
  if (r < 0) r += 0x100000000;
  return r;
}
function maj64_hi(xh, xl, yh, yl, zh) {
  var r = xh & yh ^ xh & zh ^ yh & zh;
  if (r < 0) r += 0x100000000;
  return r;
}
function maj64_lo(xh, xl, yh, yl, zh, zl) {
  var r = xl & yl ^ xl & zl ^ yl & zl;
  if (r < 0) r += 0x100000000;
  return r;
}
function s0_512_hi(xh, xl) {
  var c0_hi = rotr64_hi(xh, xl, 28);
  var c1_hi = rotr64_hi(xl, xh, 2); // 34
  var c2_hi = rotr64_hi(xl, xh, 7); // 39

  var r = c0_hi ^ c1_hi ^ c2_hi;
  if (r < 0) r += 0x100000000;
  return r;
}
function s0_512_lo(xh, xl) {
  var c0_lo = rotr64_lo(xh, xl, 28);
  var c1_lo = rotr64_lo(xl, xh, 2); // 34
  var c2_lo = rotr64_lo(xl, xh, 7); // 39

  var r = c0_lo ^ c1_lo ^ c2_lo;
  if (r < 0) r += 0x100000000;
  return r;
}
function s1_512_hi(xh, xl) {
  var c0_hi = rotr64_hi(xh, xl, 14);
  var c1_hi = rotr64_hi(xh, xl, 18);
  var c2_hi = rotr64_hi(xl, xh, 9); // 41

  var r = c0_hi ^ c1_hi ^ c2_hi;
  if (r < 0) r += 0x100000000;
  return r;
}
function s1_512_lo(xh, xl) {
  var c0_lo = rotr64_lo(xh, xl, 14);
  var c1_lo = rotr64_lo(xh, xl, 18);
  var c2_lo = rotr64_lo(xl, xh, 9); // 41

  var r = c0_lo ^ c1_lo ^ c2_lo;
  if (r < 0) r += 0x100000000;
  return r;
}
function g0_512_hi(xh, xl) {
  var c0_hi = rotr64_hi(xh, xl, 1);
  var c1_hi = rotr64_hi(xh, xl, 8);
  var c2_hi = shr64_hi(xh, xl, 7);
  var r = c0_hi ^ c1_hi ^ c2_hi;
  if (r < 0) r += 0x100000000;
  return r;
}
function g0_512_lo(xh, xl) {
  var c0_lo = rotr64_lo(xh, xl, 1);
  var c1_lo = rotr64_lo(xh, xl, 8);
  var c2_lo = shr64_lo(xh, xl, 7);
  var r = c0_lo ^ c1_lo ^ c2_lo;
  if (r < 0) r += 0x100000000;
  return r;
}
function g1_512_hi(xh, xl) {
  var c0_hi = rotr64_hi(xh, xl, 19);
  var c1_hi = rotr64_hi(xl, xh, 29); // 61
  var c2_hi = shr64_hi(xh, xl, 6);
  var r = c0_hi ^ c1_hi ^ c2_hi;
  if (r < 0) r += 0x100000000;
  return r;
}
function g1_512_lo(xh, xl) {
  var c0_lo = rotr64_lo(xh, xl, 19);
  var c1_lo = rotr64_lo(xl, xh, 29); // 61
  var c2_lo = shr64_lo(xh, xl, 6);
  var r = c0_lo ^ c1_lo ^ c2_lo;
  if (r < 0) r += 0x100000000;
  return r;
}

/***/ }),

/***/ 5489:
/*!******************************************************!*\
  !*** ../node_modules/hash.js/lib/hash/sha/common.js ***!
  \******************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


var utils = __webpack_require__(/*! ../utils */ 2282);
var rotr32 = utils.rotr32;
function ft_1(s, x, y, z) {
  if (s === 0) return ch32(x, y, z);
  if (s === 1 || s === 3) return p32(x, y, z);
  if (s === 2) return maj32(x, y, z);
}
exports.ft_1 = ft_1;
function ch32(x, y, z) {
  return x & y ^ ~x & z;
}
exports.ch32 = ch32;
function maj32(x, y, z) {
  return x & y ^ x & z ^ y & z;
}
exports.maj32 = maj32;
function p32(x, y, z) {
  return x ^ y ^ z;
}
exports.p32 = p32;
function s0_256(x) {
  return rotr32(x, 2) ^ rotr32(x, 13) ^ rotr32(x, 22);
}
exports.s0_256 = s0_256;
function s1_256(x) {
  return rotr32(x, 6) ^ rotr32(x, 11) ^ rotr32(x, 25);
}
exports.s1_256 = s1_256;
function g0_256(x) {
  return rotr32(x, 7) ^ rotr32(x, 18) ^ x >>> 3;
}
exports.g0_256 = g0_256;
function g1_256(x) {
  return rotr32(x, 17) ^ rotr32(x, 19) ^ x >>> 10;
}
exports.g1_256 = g1_256;

/***/ }),

/***/ 2282:
/*!*************************************************!*\
  !*** ../node_modules/hash.js/lib/hash/utils.js ***!
  \*************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


var assert = __webpack_require__(/*! minimalistic-assert */ 5305);
var inherits = __webpack_require__(/*! inherits */ 7694);
exports.inherits = inherits;
function isSurrogatePair(msg, i) {
  if ((msg.charCodeAt(i) & 0xFC00) !== 0xD800) {
    return false;
  }
  if (i < 0 || i + 1 >= msg.length) {
    return false;
  }
  return (msg.charCodeAt(i + 1) & 0xFC00) === 0xDC00;
}
function toArray(msg, enc) {
  if (Array.isArray(msg)) return msg.slice();
  if (!msg) return [];
  var res = [];
  if (typeof msg === 'string') {
    if (!enc) {
      // Inspired by stringToUtf8ByteArray() in closure-library by Google
      // https://github.com/google/closure-library/blob/8598d87242af59aac233270742c8984e2b2bdbe0/closure/goog/crypt/crypt.js#L117-L143
      // Apache License 2.0
      // https://github.com/google/closure-library/blob/master/LICENSE
      var p = 0;
      for (var i = 0; i < msg.length; i++) {
        var c = msg.charCodeAt(i);
        if (c < 128) {
          res[p++] = c;
        } else if (c < 2048) {
          res[p++] = c >> 6 | 192;
          res[p++] = c & 63 | 128;
        } else if (isSurrogatePair(msg, i)) {
          c = 0x10000 + ((c & 0x03FF) << 10) + (msg.charCodeAt(++i) & 0x03FF);
          res[p++] = c >> 18 | 240;
          res[p++] = c >> 12 & 63 | 128;
          res[p++] = c >> 6 & 63 | 128;
          res[p++] = c & 63 | 128;
        } else {
          res[p++] = c >> 12 | 224;
          res[p++] = c >> 6 & 63 | 128;
          res[p++] = c & 63 | 128;
        }
      }
    } else if (enc === 'hex') {
      msg = msg.replace(/[^a-z0-9]+/ig, '');
      if (msg.length % 2 !== 0) msg = '0' + msg;
      for (i = 0; i < msg.length; i += 2) res.push(parseInt(msg[i] + msg[i + 1], 16));
    }
  } else {
    for (i = 0; i < msg.length; i++) res[i] = msg[i] | 0;
  }
  return res;
}
exports.toArray = toArray;
function toHex(msg) {
  var res = '';
  for (var i = 0; i < msg.length; i++) res += zero2(msg[i].toString(16));
  return res;
}
exports.toHex = toHex;
function htonl(w) {
  var res = w >>> 24 | w >>> 8 & 0xff00 | w << 8 & 0xff0000 | (w & 0xff) << 24;
  return res >>> 0;
}
exports.htonl = htonl;
function toHex32(msg, endian) {
  var res = '';
  for (var i = 0; i < msg.length; i++) {
    var w = msg[i];
    if (endian === 'little') w = htonl(w);
    res += zero8(w.toString(16));
  }
  return res;
}
exports.toHex32 = toHex32;
function zero2(word) {
  if (word.length === 1) return '0' + word;else return word;
}
exports.zero2 = zero2;
function zero8(word) {
  if (word.length === 7) return '0' + word;else if (word.length === 6) return '00' + word;else if (word.length === 5) return '000' + word;else if (word.length === 4) return '0000' + word;else if (word.length === 3) return '00000' + word;else if (word.length === 2) return '000000' + word;else if (word.length === 1) return '0000000' + word;else return word;
}
exports.zero8 = zero8;
function join32(msg, start, end, endian) {
  var len = end - start;
  assert(len % 4 === 0);
  var res = new Array(len / 4);
  for (var i = 0, k = start; i < res.length; i++, k += 4) {
    var w;
    if (endian === 'big') w = msg[k] << 24 | msg[k + 1] << 16 | msg[k + 2] << 8 | msg[k + 3];else w = msg[k + 3] << 24 | msg[k + 2] << 16 | msg[k + 1] << 8 | msg[k];
    res[i] = w >>> 0;
  }
  return res;
}
exports.join32 = join32;
function split32(msg, endian) {
  var res = new Array(msg.length * 4);
  for (var i = 0, k = 0; i < msg.length; i++, k += 4) {
    var m = msg[i];
    if (endian === 'big') {
      res[k] = m >>> 24;
      res[k + 1] = m >>> 16 & 0xff;
      res[k + 2] = m >>> 8 & 0xff;
      res[k + 3] = m & 0xff;
    } else {
      res[k + 3] = m >>> 24;
      res[k + 2] = m >>> 16 & 0xff;
      res[k + 1] = m >>> 8 & 0xff;
      res[k] = m & 0xff;
    }
  }
  return res;
}
exports.split32 = split32;
function rotr32(w, b) {
  return w >>> b | w << 32 - b;
}
exports.rotr32 = rotr32;
function rotl32(w, b) {
  return w << b | w >>> 32 - b;
}
exports.rotl32 = rotl32;
function sum32(a, b) {
  return a + b >>> 0;
}
exports.sum32 = sum32;
function sum32_3(a, b, c) {
  return a + b + c >>> 0;
}
exports.sum32_3 = sum32_3;
function sum32_4(a, b, c, d) {
  return a + b + c + d >>> 0;
}
exports.sum32_4 = sum32_4;
function sum32_5(a, b, c, d, e) {
  return a + b + c + d + e >>> 0;
}
exports.sum32_5 = sum32_5;
function sum64(buf, pos, ah, al) {
  var bh = buf[pos];
  var bl = buf[pos + 1];
  var lo = al + bl >>> 0;
  var hi = (lo < al ? 1 : 0) + ah + bh;
  buf[pos] = hi >>> 0;
  buf[pos + 1] = lo;
}
exports.sum64 = sum64;
function sum64_hi(ah, al, bh, bl) {
  var lo = al + bl >>> 0;
  var hi = (lo < al ? 1 : 0) + ah + bh;
  return hi >>> 0;
}
exports.sum64_hi = sum64_hi;
function sum64_lo(ah, al, bh, bl) {
  var lo = al + bl;
  return lo >>> 0;
}
exports.sum64_lo = sum64_lo;
function sum64_4_hi(ah, al, bh, bl, ch, cl, dh, dl) {
  var carry = 0;
  var lo = al;
  lo = lo + bl >>> 0;
  carry += lo < al ? 1 : 0;
  lo = lo + cl >>> 0;
  carry += lo < cl ? 1 : 0;
  lo = lo + dl >>> 0;
  carry += lo < dl ? 1 : 0;
  var hi = ah + bh + ch + dh + carry;
  return hi >>> 0;
}
exports.sum64_4_hi = sum64_4_hi;
function sum64_4_lo(ah, al, bh, bl, ch, cl, dh, dl) {
  var lo = al + bl + cl + dl;
  return lo >>> 0;
}
exports.sum64_4_lo = sum64_4_lo;
function sum64_5_hi(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
  var carry = 0;
  var lo = al;
  lo = lo + bl >>> 0;
  carry += lo < al ? 1 : 0;
  lo = lo + cl >>> 0;
  carry += lo < cl ? 1 : 0;
  lo = lo + dl >>> 0;
  carry += lo < dl ? 1 : 0;
  lo = lo + el >>> 0;
  carry += lo < el ? 1 : 0;
  var hi = ah + bh + ch + dh + eh + carry;
  return hi >>> 0;
}
exports.sum64_5_hi = sum64_5_hi;
function sum64_5_lo(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
  var lo = al + bl + cl + dl + el;
  return lo >>> 0;
}
exports.sum64_5_lo = sum64_5_lo;
function rotr64_hi(ah, al, num) {
  var r = al << 32 - num | ah >>> num;
  return r >>> 0;
}
exports.rotr64_hi = rotr64_hi;
function rotr64_lo(ah, al, num) {
  var r = ah << 32 - num | al >>> num;
  return r >>> 0;
}
exports.rotr64_lo = rotr64_lo;
function shr64_hi(ah, al, num) {
  return ah >>> num;
}
exports.shr64_hi = shr64_hi;
function shr64_lo(ah, al, num) {
  var r = ah << 32 - num | al >>> num;
  return r >>> 0;
}
exports.shr64_lo = shr64_lo;

/***/ }),

/***/ 1904:
/*!**************************************************!*\
  !*** ../node_modules/hmac-drbg/lib/hmac-drbg.js ***!
  \**************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


var hash = __webpack_require__(/*! hash.js */ 8313);
var utils = __webpack_require__(/*! minimalistic-crypto-utils */ 8704);
var assert = __webpack_require__(/*! minimalistic-assert */ 5305);
function HmacDRBG(options) {
  if (!(this instanceof HmacDRBG)) return new HmacDRBG(options);
  this.hash = options.hash;
  this.predResist = !!options.predResist;
  this.outLen = this.hash.outSize;
  this.minEntropy = options.minEntropy || this.hash.hmacStrength;
  this._reseed = null;
  this.reseedInterval = null;
  this.K = null;
  this.V = null;
  var entropy = utils.toArray(options.entropy, options.entropyEnc || 'hex');
  var nonce = utils.toArray(options.nonce, options.nonceEnc || 'hex');
  var pers = utils.toArray(options.pers, options.persEnc || 'hex');
  assert(entropy.length >= this.minEntropy / 8, 'Not enough entropy. Minimum is: ' + this.minEntropy + ' bits');
  this._init(entropy, nonce, pers);
}
module.exports = HmacDRBG;
HmacDRBG.prototype._init = function init(entropy, nonce, pers) {
  var seed = entropy.concat(nonce).concat(pers);
  this.K = new Array(this.outLen / 8);
  this.V = new Array(this.outLen / 8);
  for (var i = 0; i < this.V.length; i++) {
    this.K[i] = 0x00;
    this.V[i] = 0x01;
  }
  this._update(seed);
  this._reseed = 1;
  this.reseedInterval = 0x1000000000000; // 2^48
};

HmacDRBG.prototype._hmac = function hmac() {
  return new hash.hmac(this.hash, this.K);
};
HmacDRBG.prototype._update = function update(seed) {
  var kmac = this._hmac().update(this.V).update([0x00]);
  if (seed) kmac = kmac.update(seed);
  this.K = kmac.digest();
  this.V = this._hmac().update(this.V).digest();
  if (!seed) return;
  this.K = this._hmac().update(this.V).update([0x01]).update(seed).digest();
  this.V = this._hmac().update(this.V).digest();
};
HmacDRBG.prototype.reseed = function reseed(entropy, entropyEnc, add, addEnc) {
  // Optional entropy enc
  if (typeof entropyEnc !== 'string') {
    addEnc = add;
    add = entropyEnc;
    entropyEnc = null;
  }
  entropy = utils.toArray(entropy, entropyEnc);
  add = utils.toArray(add, addEnc);
  assert(entropy.length >= this.minEntropy / 8, 'Not enough entropy. Minimum is: ' + this.minEntropy + ' bits');
  this._update(entropy.concat(add || []));
  this._reseed = 1;
};
HmacDRBG.prototype.generate = function generate(len, enc, add, addEnc) {
  if (this._reseed > this.reseedInterval) throw new Error('Reseed is required');

  // Optional encoding
  if (typeof enc !== 'string') {
    addEnc = add;
    add = enc;
    enc = null;
  }

  // Optional additional data
  if (add) {
    add = utils.toArray(add, addEnc || 'hex');
    this._update(add);
  }
  var temp = [];
  while (temp.length < len) {
    this.V = this._hmac().update(this.V).digest();
    temp = temp.concat(this.V);
  }
  var res = temp.slice(0, len);
  this._update(add);
  this._reseed++;
  return utils.encode(res, enc);
};

/***/ }),

/***/ 5106:
/*!***************************************!*\
  !*** ../node_modules/md5.js/index.js ***!
  \***************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


var inherits = __webpack_require__(/*! inherits */ 7694);
var HashBase = __webpack_require__(/*! hash-base */ 1668);
var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
var ARRAY16 = new Array(16);
function MD5() {
  HashBase.call(this, 64);

  // state
  this._a = 0x67452301;
  this._b = 0xefcdab89;
  this._c = 0x98badcfe;
  this._d = 0x10325476;
}
inherits(MD5, HashBase);
MD5.prototype._update = function () {
  var M = ARRAY16;
  for (var i = 0; i < 16; ++i) M[i] = this._block.readInt32LE(i * 4);
  var a = this._a;
  var b = this._b;
  var c = this._c;
  var d = this._d;
  a = fnF(a, b, c, d, M[0], 0xd76aa478, 7);
  d = fnF(d, a, b, c, M[1], 0xe8c7b756, 12);
  c = fnF(c, d, a, b, M[2], 0x242070db, 17);
  b = fnF(b, c, d, a, M[3], 0xc1bdceee, 22);
  a = fnF(a, b, c, d, M[4], 0xf57c0faf, 7);
  d = fnF(d, a, b, c, M[5], 0x4787c62a, 12);
  c = fnF(c, d, a, b, M[6], 0xa8304613, 17);
  b = fnF(b, c, d, a, M[7], 0xfd469501, 22);
  a = fnF(a, b, c, d, M[8], 0x698098d8, 7);
  d = fnF(d, a, b, c, M[9], 0x8b44f7af, 12);
  c = fnF(c, d, a, b, M[10], 0xffff5bb1, 17);
  b = fnF(b, c, d, a, M[11], 0x895cd7be, 22);
  a = fnF(a, b, c, d, M[12], 0x6b901122, 7);
  d = fnF(d, a, b, c, M[13], 0xfd987193, 12);
  c = fnF(c, d, a, b, M[14], 0xa679438e, 17);
  b = fnF(b, c, d, a, M[15], 0x49b40821, 22);
  a = fnG(a, b, c, d, M[1], 0xf61e2562, 5);
  d = fnG(d, a, b, c, M[6], 0xc040b340, 9);
  c = fnG(c, d, a, b, M[11], 0x265e5a51, 14);
  b = fnG(b, c, d, a, M[0], 0xe9b6c7aa, 20);
  a = fnG(a, b, c, d, M[5], 0xd62f105d, 5);
  d = fnG(d, a, b, c, M[10], 0x02441453, 9);
  c = fnG(c, d, a, b, M[15], 0xd8a1e681, 14);
  b = fnG(b, c, d, a, M[4], 0xe7d3fbc8, 20);
  a = fnG(a, b, c, d, M[9], 0x21e1cde6, 5);
  d = fnG(d, a, b, c, M[14], 0xc33707d6, 9);
  c = fnG(c, d, a, b, M[3], 0xf4d50d87, 14);
  b = fnG(b, c, d, a, M[8], 0x455a14ed, 20);
  a = fnG(a, b, c, d, M[13], 0xa9e3e905, 5);
  d = fnG(d, a, b, c, M[2], 0xfcefa3f8, 9);
  c = fnG(c, d, a, b, M[7], 0x676f02d9, 14);
  b = fnG(b, c, d, a, M[12], 0x8d2a4c8a, 20);
  a = fnH(a, b, c, d, M[5], 0xfffa3942, 4);
  d = fnH(d, a, b, c, M[8], 0x8771f681, 11);
  c = fnH(c, d, a, b, M[11], 0x6d9d6122, 16);
  b = fnH(b, c, d, a, M[14], 0xfde5380c, 23);
  a = fnH(a, b, c, d, M[1], 0xa4beea44, 4);
  d = fnH(d, a, b, c, M[4], 0x4bdecfa9, 11);
  c = fnH(c, d, a, b, M[7], 0xf6bb4b60, 16);
  b = fnH(b, c, d, a, M[10], 0xbebfbc70, 23);
  a = fnH(a, b, c, d, M[13], 0x289b7ec6, 4);
  d = fnH(d, a, b, c, M[0], 0xeaa127fa, 11);
  c = fnH(c, d, a, b, M[3], 0xd4ef3085, 16);
  b = fnH(b, c, d, a, M[6], 0x04881d05, 23);
  a = fnH(a, b, c, d, M[9], 0xd9d4d039, 4);
  d = fnH(d, a, b, c, M[12], 0xe6db99e5, 11);
  c = fnH(c, d, a, b, M[15], 0x1fa27cf8, 16);
  b = fnH(b, c, d, a, M[2], 0xc4ac5665, 23);
  a = fnI(a, b, c, d, M[0], 0xf4292244, 6);
  d = fnI(d, a, b, c, M[7], 0x432aff97, 10);
  c = fnI(c, d, a, b, M[14], 0xab9423a7, 15);
  b = fnI(b, c, d, a, M[5], 0xfc93a039, 21);
  a = fnI(a, b, c, d, M[12], 0x655b59c3, 6);
  d = fnI(d, a, b, c, M[3], 0x8f0ccc92, 10);
  c = fnI(c, d, a, b, M[10], 0xffeff47d, 15);
  b = fnI(b, c, d, a, M[1], 0x85845dd1, 21);
  a = fnI(a, b, c, d, M[8], 0x6fa87e4f, 6);
  d = fnI(d, a, b, c, M[15], 0xfe2ce6e0, 10);
  c = fnI(c, d, a, b, M[6], 0xa3014314, 15);
  b = fnI(b, c, d, a, M[13], 0x4e0811a1, 21);
  a = fnI(a, b, c, d, M[4], 0xf7537e82, 6);
  d = fnI(d, a, b, c, M[11], 0xbd3af235, 10);
  c = fnI(c, d, a, b, M[2], 0x2ad7d2bb, 15);
  b = fnI(b, c, d, a, M[9], 0xeb86d391, 21);
  this._a = this._a + a | 0;
  this._b = this._b + b | 0;
  this._c = this._c + c | 0;
  this._d = this._d + d | 0;
};
MD5.prototype._digest = function () {
  // create padding and handle blocks
  this._block[this._blockOffset++] = 0x80;
  if (this._blockOffset > 56) {
    this._block.fill(0, this._blockOffset, 64);
    this._update();
    this._blockOffset = 0;
  }
  this._block.fill(0, this._blockOffset, 56);
  this._block.writeUInt32LE(this._length[0], 56);
  this._block.writeUInt32LE(this._length[1], 60);
  this._update();

  // produce result
  var buffer = Buffer.allocUnsafe(16);
  buffer.writeInt32LE(this._a, 0);
  buffer.writeInt32LE(this._b, 4);
  buffer.writeInt32LE(this._c, 8);
  buffer.writeInt32LE(this._d, 12);
  return buffer;
};
function rotl(x, n) {
  return x << n | x >>> 32 - n;
}
function fnF(a, b, c, d, m, k, s) {
  return rotl(a + (b & c | ~b & d) + m + k | 0, s) + b | 0;
}
function fnG(a, b, c, d, m, k, s) {
  return rotl(a + (b & d | c & ~d) + m + k | 0, s) + b | 0;
}
function fnH(a, b, c, d, m, k, s) {
  return rotl(a + (b ^ c ^ d) + m + k | 0, s) + b | 0;
}
function fnI(a, b, c, d, m, k, s) {
  return rotl(a + (c ^ (b | ~d)) + m + k | 0, s) + b | 0;
}
module.exports = MD5;

/***/ }),

/***/ 5305:
/*!****************************************************!*\
  !*** ../node_modules/minimalistic-assert/index.js ***!
  \****************************************************/
/***/ ((module) => {

module.exports = assert;
function assert(val, msg) {
  if (!val) throw new Error(msg || 'Assertion failed');
}
assert.equal = function assertEqual(l, r, msg) {
  if (l != r) throw new Error(msg || 'Assertion failed: ' + l + ' != ' + r);
};

/***/ }),

/***/ 8704:
/*!**************************************************************!*\
  !*** ../node_modules/minimalistic-crypto-utils/lib/utils.js ***!
  \**************************************************************/
/***/ ((__unused_webpack_module, exports) => {

"use strict";


var utils = exports;
function toArray(msg, enc) {
  if (Array.isArray(msg)) return msg.slice();
  if (!msg) return [];
  var res = [];
  if (typeof msg !== 'string') {
    for (var i = 0; i < msg.length; i++) res[i] = msg[i] | 0;
    return res;
  }
  if (enc === 'hex') {
    msg = msg.replace(/[^a-z0-9]+/ig, '');
    if (msg.length % 2 !== 0) msg = '0' + msg;
    for (var i = 0; i < msg.length; i += 2) res.push(parseInt(msg[i] + msg[i + 1], 16));
  } else {
    for (var i = 0; i < msg.length; i++) {
      var c = msg.charCodeAt(i);
      var hi = c >> 8;
      var lo = c & 0xff;
      if (hi) res.push(hi, lo);else res.push(lo);
    }
  }
  return res;
}
utils.toArray = toArray;
function zero2(word) {
  if (word.length === 1) return '0' + word;else return word;
}
utils.zero2 = zero2;
function toHex(msg) {
  var res = '';
  for (var i = 0; i < msg.length; i++) res += zero2(msg[i].toString(16));
  return res;
}
utils.toHex = toHex;
utils.encode = function encode(arr, enc) {
  if (enc === 'hex') return toHex(arr);else return arr;
};

/***/ }),

/***/ 9632:
/*!******************************************!*\
  !*** ../node_modules/parse-asn1/asn1.js ***!
  \******************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";
// from https://github.com/indutny/self-signed/blob/gh-pages/lib/asn1.js
// Fedor, you are amazing.


var asn1 = __webpack_require__(/*! asn1.js */ 4908);
exports.certificate = __webpack_require__(/*! ./certificate */ 78);
var RSAPrivateKey = asn1.define('RSAPrivateKey', function () {
  this.seq().obj(this.key('version').int(), this.key('modulus').int(), this.key('publicExponent').int(), this.key('privateExponent').int(), this.key('prime1').int(), this.key('prime2').int(), this.key('exponent1').int(), this.key('exponent2').int(), this.key('coefficient').int());
});
exports.RSAPrivateKey = RSAPrivateKey;
var RSAPublicKey = asn1.define('RSAPublicKey', function () {
  this.seq().obj(this.key('modulus').int(), this.key('publicExponent').int());
});
exports.RSAPublicKey = RSAPublicKey;
var PublicKey = asn1.define('SubjectPublicKeyInfo', function () {
  this.seq().obj(this.key('algorithm').use(AlgorithmIdentifier), this.key('subjectPublicKey').bitstr());
});
exports.PublicKey = PublicKey;
var AlgorithmIdentifier = asn1.define('AlgorithmIdentifier', function () {
  this.seq().obj(this.key('algorithm').objid(), this.key('none').null_().optional(), this.key('curve').objid().optional(), this.key('params').seq().obj(this.key('p').int(), this.key('q').int(), this.key('g').int()).optional());
});
var PrivateKeyInfo = asn1.define('PrivateKeyInfo', function () {
  this.seq().obj(this.key('version').int(), this.key('algorithm').use(AlgorithmIdentifier), this.key('subjectPrivateKey').octstr());
});
exports.PrivateKey = PrivateKeyInfo;
var EncryptedPrivateKeyInfo = asn1.define('EncryptedPrivateKeyInfo', function () {
  this.seq().obj(this.key('algorithm').seq().obj(this.key('id').objid(), this.key('decrypt').seq().obj(this.key('kde').seq().obj(this.key('id').objid(), this.key('kdeparams').seq().obj(this.key('salt').octstr(), this.key('iters').int())), this.key('cipher').seq().obj(this.key('algo').objid(), this.key('iv').octstr()))), this.key('subjectPrivateKey').octstr());
});
exports.EncryptedPrivateKey = EncryptedPrivateKeyInfo;
var DSAPrivateKey = asn1.define('DSAPrivateKey', function () {
  this.seq().obj(this.key('version').int(), this.key('p').int(), this.key('q').int(), this.key('g').int(), this.key('pub_key').int(), this.key('priv_key').int());
});
exports.DSAPrivateKey = DSAPrivateKey;
exports.DSAparam = asn1.define('DSAparam', function () {
  this.int();
});
var ECPrivateKey = asn1.define('ECPrivateKey', function () {
  this.seq().obj(this.key('version').int(), this.key('privateKey').octstr(), this.key('parameters').optional().explicit(0).use(ECParameters), this.key('publicKey').optional().explicit(1).bitstr());
});
exports.ECPrivateKey = ECPrivateKey;
var ECParameters = asn1.define('ECParameters', function () {
  this.choice({
    namedCurve: this.objid()
  });
});
exports.signature = asn1.define('signature', function () {
  this.seq().obj(this.key('r').int(), this.key('s').int());
});

/***/ }),

/***/ 78:
/*!*************************************************!*\
  !*** ../node_modules/parse-asn1/certificate.js ***!
  \*************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";
// from https://github.com/Rantanen/node-dtls/blob/25a7dc861bda38cfeac93a723500eea4f0ac2e86/Certificate.js
// thanks to @Rantanen



var asn = __webpack_require__(/*! asn1.js */ 4908);
var Time = asn.define('Time', function () {
  this.choice({
    utcTime: this.utctime(),
    generalTime: this.gentime()
  });
});
var AttributeTypeValue = asn.define('AttributeTypeValue', function () {
  this.seq().obj(this.key('type').objid(), this.key('value').any());
});
var AlgorithmIdentifier = asn.define('AlgorithmIdentifier', function () {
  this.seq().obj(this.key('algorithm').objid(), this.key('parameters').optional(), this.key('curve').objid().optional());
});
var SubjectPublicKeyInfo = asn.define('SubjectPublicKeyInfo', function () {
  this.seq().obj(this.key('algorithm').use(AlgorithmIdentifier), this.key('subjectPublicKey').bitstr());
});
var RelativeDistinguishedName = asn.define('RelativeDistinguishedName', function () {
  this.setof(AttributeTypeValue);
});
var RDNSequence = asn.define('RDNSequence', function () {
  this.seqof(RelativeDistinguishedName);
});
var Name = asn.define('Name', function () {
  this.choice({
    rdnSequence: this.use(RDNSequence)
  });
});
var Validity = asn.define('Validity', function () {
  this.seq().obj(this.key('notBefore').use(Time), this.key('notAfter').use(Time));
});
var Extension = asn.define('Extension', function () {
  this.seq().obj(this.key('extnID').objid(), this.key('critical').bool().def(false), this.key('extnValue').octstr());
});
var TBSCertificate = asn.define('TBSCertificate', function () {
  this.seq().obj(this.key('version').explicit(0).int().optional(), this.key('serialNumber').int(), this.key('signature').use(AlgorithmIdentifier), this.key('issuer').use(Name), this.key('validity').use(Validity), this.key('subject').use(Name), this.key('subjectPublicKeyInfo').use(SubjectPublicKeyInfo), this.key('issuerUniqueID').implicit(1).bitstr().optional(), this.key('subjectUniqueID').implicit(2).bitstr().optional(), this.key('extensions').explicit(3).seqof(Extension).optional());
});
var X509Certificate = asn.define('X509Certificate', function () {
  this.seq().obj(this.key('tbsCertificate').use(TBSCertificate), this.key('signatureAlgorithm').use(AlgorithmIdentifier), this.key('signatureValue').bitstr());
});
module.exports = X509Certificate;

/***/ }),

/***/ 9864:
/*!*********************************************!*\
  !*** ../node_modules/parse-asn1/fixProc.js ***!
  \*********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// adapted from https://github.com/apatil/pemstrip
var findProc = /Proc-Type: 4,ENCRYPTED[\n\r]+DEK-Info: AES-((?:128)|(?:192)|(?:256))-CBC,([0-9A-H]+)[\n\r]+([0-9A-z\n\r+/=]+)[\n\r]+/m;
var startRegex = /^-----BEGIN ((?:.*? KEY)|CERTIFICATE)-----/m;
var fullRegex = /^-----BEGIN ((?:.*? KEY)|CERTIFICATE)-----([0-9A-z\n\r+/=]+)-----END \1-----$/m;
var evp = __webpack_require__(/*! evp_bytestokey */ 3325);
var ciphers = __webpack_require__(/*! browserify-aes */ 7590);
var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
module.exports = function (okey, password) {
  var key = okey.toString();
  var match = key.match(findProc);
  var decrypted;
  if (!match) {
    var match2 = key.match(fullRegex);
    decrypted = Buffer.from(match2[2].replace(/[\r\n]/g, ''), 'base64');
  } else {
    var suite = 'aes' + match[1];
    var iv = Buffer.from(match[2], 'hex');
    var cipherText = Buffer.from(match[3].replace(/[\r\n]/g, ''), 'base64');
    var cipherKey = evp(password, iv.slice(0, 8), parseInt(match[1], 10)).key;
    var out = [];
    var cipher = ciphers.createDecipheriv(suite, cipherKey, iv);
    out.push(cipher.update(cipherText));
    out.push(cipher.final());
    decrypted = Buffer.concat(out);
  }
  var tag = key.match(startRegex)[1];
  return {
    tag: tag,
    data: decrypted
  };
};

/***/ }),

/***/ 5656:
/*!*******************************************!*\
  !*** ../node_modules/parse-asn1/index.js ***!
  \*******************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var asn1 = __webpack_require__(/*! ./asn1 */ 9632);
var aesid = __webpack_require__(/*! ./aesid.json */ 8850);
var fixProc = __webpack_require__(/*! ./fixProc */ 9864);
var ciphers = __webpack_require__(/*! browserify-aes */ 7590);
var compat = __webpack_require__(/*! pbkdf2 */ 9253);
var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
module.exports = parseKeys;
function parseKeys(buffer) {
  var password;
  if (typeof buffer === 'object' && !Buffer.isBuffer(buffer)) {
    password = buffer.passphrase;
    buffer = buffer.key;
  }
  if (typeof buffer === 'string') {
    buffer = Buffer.from(buffer);
  }
  var stripped = fixProc(buffer, password);
  var type = stripped.tag;
  var data = stripped.data;
  var subtype, ndata;
  switch (type) {
    case 'CERTIFICATE':
      ndata = asn1.certificate.decode(data, 'der').tbsCertificate.subjectPublicKeyInfo;
    // falls through
    case 'PUBLIC KEY':
      if (!ndata) {
        ndata = asn1.PublicKey.decode(data, 'der');
      }
      subtype = ndata.algorithm.algorithm.join('.');
      switch (subtype) {
        case '1.2.840.113549.1.1.1':
          return asn1.RSAPublicKey.decode(ndata.subjectPublicKey.data, 'der');
        case '1.2.840.10045.2.1':
          ndata.subjectPrivateKey = ndata.subjectPublicKey;
          return {
            type: 'ec',
            data: ndata
          };
        case '1.2.840.10040.4.1':
          ndata.algorithm.params.pub_key = asn1.DSAparam.decode(ndata.subjectPublicKey.data, 'der');
          return {
            type: 'dsa',
            data: ndata.algorithm.params
          };
        default:
          throw new Error('unknown key id ' + subtype);
      }
    // throw new Error('unknown key type ' + type)
    case 'ENCRYPTED PRIVATE KEY':
      data = asn1.EncryptedPrivateKey.decode(data, 'der');
      data = decrypt(data, password);
    // falls through
    case 'PRIVATE KEY':
      ndata = asn1.PrivateKey.decode(data, 'der');
      subtype = ndata.algorithm.algorithm.join('.');
      switch (subtype) {
        case '1.2.840.113549.1.1.1':
          return asn1.RSAPrivateKey.decode(ndata.subjectPrivateKey, 'der');
        case '1.2.840.10045.2.1':
          return {
            curve: ndata.algorithm.curve,
            privateKey: asn1.ECPrivateKey.decode(ndata.subjectPrivateKey, 'der').privateKey
          };
        case '1.2.840.10040.4.1':
          ndata.algorithm.params.priv_key = asn1.DSAparam.decode(ndata.subjectPrivateKey, 'der');
          return {
            type: 'dsa',
            params: ndata.algorithm.params
          };
        default:
          throw new Error('unknown key id ' + subtype);
      }
    // throw new Error('unknown key type ' + type)
    case 'RSA PUBLIC KEY':
      return asn1.RSAPublicKey.decode(data, 'der');
    case 'RSA PRIVATE KEY':
      return asn1.RSAPrivateKey.decode(data, 'der');
    case 'DSA PRIVATE KEY':
      return {
        type: 'dsa',
        params: asn1.DSAPrivateKey.decode(data, 'der')
      };
    case 'EC PRIVATE KEY':
      data = asn1.ECPrivateKey.decode(data, 'der');
      return {
        curve: data.parameters.value,
        privateKey: data.privateKey
      };
    default:
      throw new Error('unknown key type ' + type);
  }
}
parseKeys.signature = asn1.signature;
function decrypt(data, password) {
  var salt = data.algorithm.decrypt.kde.kdeparams.salt;
  var iters = parseInt(data.algorithm.decrypt.kde.kdeparams.iters.toString(), 10);
  var algo = aesid[data.algorithm.decrypt.cipher.algo.join('.')];
  var iv = data.algorithm.decrypt.cipher.iv;
  var cipherText = data.subjectPrivateKey;
  var keylen = parseInt(algo.split('-')[1], 10) / 8;
  var key = compat.pbkdf2Sync(password, salt, iters, keylen, 'sha1');
  var cipher = ciphers.createDecipheriv(algo, key, iv);
  var out = [];
  out.push(cipher.update(cipherText));
  out.push(cipher.final());
  return Buffer.concat(out);
}

/***/ }),

/***/ 9253:
/*!***************************************!*\
  !*** ../node_modules/pbkdf2/index.js ***!
  \***************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

var native = __webpack_require__(/*! crypto */ 6113);
var checkParameters = __webpack_require__(/*! ./lib/precondition */ 7518);
var defaultEncoding = __webpack_require__(/*! ./lib/default-encoding */ 2669);
var toBuffer = __webpack_require__(/*! ./lib/to-buffer */ 9572);
function nativePBKDF2(password, salt, iterations, keylen, digest, callback) {
  checkParameters(iterations, keylen);
  password = toBuffer(password, defaultEncoding, 'Password');
  salt = toBuffer(salt, defaultEncoding, 'Salt');
  if (typeof digest === 'function') {
    callback = digest;
    digest = 'sha1';
  }
  if (typeof callback !== 'function') throw new Error('No callback provided to pbkdf2');
  return native.pbkdf2(password, salt, iterations, keylen, digest, callback);
}
function nativePBKDF2Sync(password, salt, iterations, keylen, digest) {
  checkParameters(iterations, keylen);
  password = toBuffer(password, defaultEncoding, 'Password');
  salt = toBuffer(salt, defaultEncoding, 'Salt');
  digest = digest || 'sha1';
  return native.pbkdf2Sync(password, salt, iterations, keylen, digest);
}

/* istanbul ignore next */
if (!native.pbkdf2Sync || native.pbkdf2Sync.toString().indexOf('keylen, digest') === -1) {
  exports.pbkdf2Sync = __webpack_require__(/*! ./lib/sync */ 863);
  exports.pbkdf2 = __webpack_require__(/*! ./lib/async */ 2476);

  // native
} else {
  exports.pbkdf2Sync = nativePBKDF2Sync;
  exports.pbkdf2 = nativePBKDF2;
}

/***/ }),

/***/ 2476:
/*!*******************************************!*\
  !*** ../node_modules/pbkdf2/lib/async.js ***!
  \*******************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
var checkParameters = __webpack_require__(/*! ./precondition */ 7518);
var defaultEncoding = __webpack_require__(/*! ./default-encoding */ 2669);
var sync = __webpack_require__(/*! ./sync */ 863);
var toBuffer = __webpack_require__(/*! ./to-buffer */ 9572);
var ZERO_BUF;
var subtle = global.crypto && global.crypto.subtle;
var toBrowser = {
  sha: 'SHA-1',
  'sha-1': 'SHA-1',
  sha1: 'SHA-1',
  sha256: 'SHA-256',
  'sha-256': 'SHA-256',
  sha384: 'SHA-384',
  'sha-384': 'SHA-384',
  'sha-512': 'SHA-512',
  sha512: 'SHA-512'
};
var checks = [];
function checkNative(algo) {
  if (global.process && !global.process.browser) {
    return Promise.resolve(false);
  }
  if (!subtle || !subtle.importKey || !subtle.deriveBits) {
    return Promise.resolve(false);
  }
  if (checks[algo] !== undefined) {
    return checks[algo];
  }
  ZERO_BUF = ZERO_BUF || Buffer.alloc(8);
  var prom = browserPbkdf2(ZERO_BUF, ZERO_BUF, 10, 128, algo).then(function () {
    return true;
  }).catch(function () {
    return false;
  });
  checks[algo] = prom;
  return prom;
}
var nextTick;
function getNextTick() {
  if (nextTick) {
    return nextTick;
  }
  if (global.process && global.process.nextTick) {
    nextTick = global.process.nextTick;
  } else if (global.queueMicrotask) {
    nextTick = global.queueMicrotask;
  } else if (global.setImmediate) {
    nextTick = global.setImmediate;
  } else {
    nextTick = global.setTimeout;
  }
  return nextTick;
}
function browserPbkdf2(password, salt, iterations, length, algo) {
  return subtle.importKey('raw', password, {
    name: 'PBKDF2'
  }, false, ['deriveBits']).then(function (key) {
    return subtle.deriveBits({
      name: 'PBKDF2',
      salt: salt,
      iterations: iterations,
      hash: {
        name: algo
      }
    }, key, length << 3);
  }).then(function (res) {
    return Buffer.from(res);
  });
}
function resolvePromise(promise, callback) {
  promise.then(function (out) {
    getNextTick()(function () {
      callback(null, out);
    });
  }, function (e) {
    getNextTick()(function () {
      callback(e);
    });
  });
}
module.exports = function (password, salt, iterations, keylen, digest, callback) {
  if (typeof digest === 'function') {
    callback = digest;
    digest = undefined;
  }
  digest = digest || 'sha1';
  var algo = toBrowser[digest.toLowerCase()];
  if (!algo || typeof global.Promise !== 'function') {
    getNextTick()(function () {
      var out;
      try {
        out = sync(password, salt, iterations, keylen, digest);
      } catch (e) {
        return callback(e);
      }
      callback(null, out);
    });
    return;
  }
  checkParameters(iterations, keylen);
  password = toBuffer(password, defaultEncoding, 'Password');
  salt = toBuffer(salt, defaultEncoding, 'Salt');
  if (typeof callback !== 'function') throw new Error('No callback provided to pbkdf2');
  resolvePromise(checkNative(algo).then(function (resp) {
    if (resp) return browserPbkdf2(password, salt, iterations, keylen, algo);
    return sync(password, salt, iterations, keylen, digest);
  }), callback);
};

/***/ }),

/***/ 2669:
/*!******************************************************!*\
  !*** ../node_modules/pbkdf2/lib/default-encoding.js ***!
  \******************************************************/
/***/ ((module) => {

var defaultEncoding;
/* istanbul ignore next */
if (global.process && global.process.browser) {
  defaultEncoding = 'utf-8';
} else if (global.process && global.process.version) {
  var pVersionMajor = parseInt(process.version.split('.')[0].slice(1), 10);
  defaultEncoding = pVersionMajor >= 6 ? 'utf-8' : 'binary';
} else {
  defaultEncoding = 'utf-8';
}
module.exports = defaultEncoding;

/***/ }),

/***/ 7518:
/*!**************************************************!*\
  !*** ../node_modules/pbkdf2/lib/precondition.js ***!
  \**************************************************/
/***/ ((module) => {

var MAX_ALLOC = Math.pow(2, 30) - 1; // default in iojs

module.exports = function (iterations, keylen) {
  if (typeof iterations !== 'number') {
    throw new TypeError('Iterations not a number');
  }
  if (iterations < 0) {
    throw new TypeError('Bad iterations');
  }
  if (typeof keylen !== 'number') {
    throw new TypeError('Key length not a number');
  }
  if (keylen < 0 || keylen > MAX_ALLOC || keylen !== keylen) {
    /* eslint no-self-compare: 0 */
    throw new TypeError('Bad key length');
  }
};

/***/ }),

/***/ 863:
/*!******************************************!*\
  !*** ../node_modules/pbkdf2/lib/sync.js ***!
  \******************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var sizes = {
  md5: 16,
  sha1: 20,
  sha224: 28,
  sha256: 32,
  sha384: 48,
  sha512: 64,
  rmd160: 20,
  ripemd160: 20
};
var createHmac = __webpack_require__(/*! create-hmac */ 9959);
var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
var checkParameters = __webpack_require__(/*! ./precondition */ 7518);
var defaultEncoding = __webpack_require__(/*! ./default-encoding */ 2669);
var toBuffer = __webpack_require__(/*! ./to-buffer */ 9572);
function pbkdf2(password, salt, iterations, keylen, digest) {
  checkParameters(iterations, keylen);
  password = toBuffer(password, defaultEncoding, 'Password');
  salt = toBuffer(salt, defaultEncoding, 'Salt');
  digest = digest || 'sha1';
  var DK = Buffer.allocUnsafe(keylen);
  var block1 = Buffer.allocUnsafe(salt.length + 4);
  salt.copy(block1, 0, 0, salt.length);
  var destPos = 0;
  var hLen = sizes[digest];
  var l = Math.ceil(keylen / hLen);
  for (var i = 1; i <= l; i++) {
    block1.writeUInt32BE(i, salt.length);
    var T = createHmac(digest, password).update(block1).digest();
    var U = T;
    for (var j = 1; j < iterations; j++) {
      U = createHmac(digest, password).update(U).digest();
      for (var k = 0; k < hLen; k++) T[k] ^= U[k];
    }
    T.copy(DK, destPos);
    destPos += hLen;
  }
  return DK;
}
module.exports = pbkdf2;

/***/ }),

/***/ 9572:
/*!***********************************************!*\
  !*** ../node_modules/pbkdf2/lib/to-buffer.js ***!
  \***********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
module.exports = function (thing, encoding, name) {
  if (Buffer.isBuffer(thing)) {
    return thing;
  } else if (typeof thing === 'string') {
    return Buffer.from(thing, encoding);
  } else if (ArrayBuffer.isView(thing)) {
    return Buffer.from(thing.buffer);
  } else {
    throw new TypeError(name + ' must be a string, a Buffer, a typed array or a DataView');
  }
};

/***/ }),

/***/ 316:
/*!**********************************************!*\
  !*** ../node_modules/randombytes/browser.js ***!
  \**********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


// limit of Crypto.getRandomValues()
// https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues
var MAX_BYTES = 65536;

// Node supports requesting up to this number of bytes
// https://github.com/nodejs/node/blob/master/lib/internal/crypto/random.js#L48
var MAX_UINT32 = 4294967295;
function oldBrowser() {
  throw new Error('Secure random number generation is not supported by this browser.\nUse Chrome, Firefox or Internet Explorer 11');
}
var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
var crypto = global.crypto || global.msCrypto;
if (crypto && crypto.getRandomValues) {
  module.exports = randomBytes;
} else {
  module.exports = oldBrowser;
}
function randomBytes(size, cb) {
  // phantomjs needs to throw
  if (size > MAX_UINT32) throw new RangeError('requested too many random bytes');
  var bytes = Buffer.allocUnsafe(size);
  if (size > 0) {
    // getRandomValues fails on IE if size == 0
    if (size > MAX_BYTES) {
      // this is the max bytes crypto.getRandomValues
      // can do at once see https://developer.mozilla.org/en-US/docs/Web/API/window.crypto.getRandomValues
      for (var generated = 0; generated < size; generated += MAX_BYTES) {
        // buffer.slice automatically checks if the end is past the end of
        // the buffer so we don't have to here
        crypto.getRandomValues(bytes.slice(generated, generated + MAX_BYTES));
      }
    } else {
      crypto.getRandomValues(bytes);
    }
  }
  if (typeof cb === 'function') {
    return process.nextTick(function () {
      cb(null, bytes);
    });
  }
  return bytes;
}

/***/ }),

/***/ 9797:
/*!******************************************!*\
  !*** ../node_modules/ripemd160/index.js ***!
  \******************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


var Buffer = (__webpack_require__(/*! buffer */ 4300).Buffer);
var inherits = __webpack_require__(/*! inherits */ 7694);
var HashBase = __webpack_require__(/*! hash-base */ 1668);
var ARRAY16 = new Array(16);
var zl = [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 = [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 = [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 = [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 = [0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e];
var hr = [0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000];
function RIPEMD160() {
  HashBase.call(this, 64);

  // state
  this._a = 0x67452301;
  this._b = 0xefcdab89;
  this._c = 0x98badcfe;
  this._d = 0x10325476;
  this._e = 0xc3d2e1f0;
}
inherits(RIPEMD160, HashBase);
RIPEMD160.prototype._update = function () {
  var words = ARRAY16;
  for (var j = 0; j < 16; ++j) words[j] = this._block.readInt32LE(j * 4);
  var al = this._a | 0;
  var bl = this._b | 0;
  var cl = this._c | 0;
  var dl = this._d | 0;
  var el = this._e | 0;
  var ar = this._a | 0;
  var br = this._b | 0;
  var cr = this._c | 0;
  var dr = this._d | 0;
  var er = this._e | 0;

  // computation
  for (var i = 0; i < 80; i += 1) {
    var tl;
    var tr;
    if (i < 16) {
      tl = fn1(al, bl, cl, dl, el, words[zl[i]], hl[0], sl[i]);
      tr = fn5(ar, br, cr, dr, er, words[zr[i]], hr[0], sr[i]);
    } else if (i < 32) {
      tl = fn2(al, bl, cl, dl, el, words[zl[i]], hl[1], sl[i]);
      tr = fn4(ar, br, cr, dr, er, words[zr[i]], hr[1], sr[i]);
    } else if (i < 48) {
      tl = fn3(al, bl, cl, dl, el, words[zl[i]], hl[2], sl[i]);
      tr = fn3(ar, br, cr, dr, er, words[zr[i]], hr[2], sr[i]);
    } else if (i < 64) {
      tl = fn4(al, bl, cl, dl, el, words[zl[i]], hl[3], sl[i]);
      tr = fn2(ar, br, cr, dr, er, words[zr[i]], hr[3], sr[i]);
    } else {
      // if (i<80) {
      tl = fn5(al, bl, cl, dl, el, words[zl[i]], hl[4], sl[i]);
      tr = fn1(ar, br, cr, dr, er, words[zr[i]], hr[4], sr[i]);
    }
    al = el;
    el = dl;
    dl = rotl(cl, 10);
    cl = bl;
    bl = tl;
    ar = er;
    er = dr;
    dr = rotl(cr, 10);
    cr = br;
    br = tr;
  }

  // update state
  var t = this._b + cl + dr | 0;
  this._b = this._c + dl + er | 0;
  this._c = this._d + el + ar | 0;
  this._d = this._e + al + br | 0;
  this._e = this._a + bl + cr | 0;
  this._a = t;
};
RIPEMD160.prototype._digest = function () {
  // create padding and handle blocks
  this._block[this._blockOffset++] = 0x80;
  if (this._blockOffset > 56) {
    this._block.fill(0, this._blockOffset, 64);
    this._update();
    this._blockOffset = 0;
  }
  this._block.fill(0, this._blockOffset, 56);
  this._block.writeUInt32LE(this._length[0], 56);
  this._block.writeUInt32LE(this._length[1], 60);
  this._update();

  // produce result
  var buffer = Buffer.alloc ? Buffer.alloc(20) : new Buffer(20);
  buffer.writeInt32LE(this._a, 0);
  buffer.writeInt32LE(this._b, 4);
  buffer.writeInt32LE(this._c, 8);
  buffer.writeInt32LE(this._d, 12);
  buffer.writeInt32LE(this._e, 16);
  return buffer;
};
function rotl(x, n) {
  return x << n | x >>> 32 - n;
}
function fn1(a, b, c, d, e, m, k, s) {
  return rotl(a + (b ^ c ^ d) + m + k | 0, s) + e | 0;
}
function fn2(a, b, c, d, e, m, k, s) {
  return rotl(a + (b & c | ~b & d) + m + k | 0, s) + e | 0;
}
function fn3(a, b, c, d, e, m, k, s) {
  return rotl(a + ((b | ~c) ^ d) + m + k | 0, s) + e | 0;
}
function fn4(a, b, c, d, e, m, k, s) {
  return rotl(a + (b & d | c & ~d) + m + k | 0, s) + e | 0;
}
function fn5(a, b, c, d, e, m, k, s) {
  return rotl(a + (b ^ (c | ~d)) + m + k | 0, s) + e | 0;
}
module.exports = RIPEMD160;

/***/ }),

/***/ 1511:
/*!**************************************!*\
  !*** ../node_modules/sha.js/hash.js ***!
  \**************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);

// prototype class for hash functions
function Hash(blockSize, finalSize) {
  this._block = Buffer.alloc(blockSize);
  this._finalSize = finalSize;
  this._blockSize = blockSize;
  this._len = 0;
}
Hash.prototype.update = function (data, enc) {
  if (typeof data === 'string') {
    enc = enc || 'utf8';
    data = Buffer.from(data, enc);
  }
  var block = this._block;
  var blockSize = this._blockSize;
  var length = data.length;
  var accum = this._len;
  for (var offset = 0; offset < length;) {
    var assigned = accum % blockSize;
    var remainder = Math.min(length - offset, blockSize - assigned);
    for (var i = 0; i < remainder; i++) {
      block[assigned + i] = data[offset + i];
    }
    accum += remainder;
    offset += remainder;
    if (accum % blockSize === 0) {
      this._update(block);
    }
  }
  this._len += length;
  return this;
};
Hash.prototype.digest = function (enc) {
  var rem = this._len % this._blockSize;
  this._block[rem] = 0x80;

  // zero (rem + 1) trailing bits, where (rem + 1) is the smallest
  // non-negative solution to the equation (length + 1 + (rem + 1)) === finalSize mod blockSize
  this._block.fill(0, rem + 1);
  if (rem >= this._finalSize) {
    this._update(this._block);
    this._block.fill(0);
  }
  var bits = this._len * 8;

  // uint32
  if (bits <= 0xffffffff) {
    this._block.writeUInt32BE(bits, this._blockSize - 4);

    // uint64
  } else {
    var lowBits = (bits & 0xffffffff) >>> 0;
    var highBits = (bits - lowBits) / 0x100000000;
    this._block.writeUInt32BE(highBits, this._blockSize - 8);
    this._block.writeUInt32BE(lowBits, this._blockSize - 4);
  }
  this._update(this._block);
  var hash = this._hash();
  return enc ? hash.toString(enc) : hash;
};
Hash.prototype._update = function () {
  throw new Error('_update must be implemented by subclass');
};
module.exports = Hash;

/***/ }),

/***/ 1239:
/*!***************************************!*\
  !*** ../node_modules/sha.js/index.js ***!
  \***************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var exports = module.exports = function SHA(algorithm) {
  algorithm = algorithm.toLowerCase();
  var Algorithm = exports[algorithm];
  if (!Algorithm) throw new Error(algorithm + ' is not supported (we accept pull requests)');
  return new Algorithm();
};
exports.sha = __webpack_require__(/*! ./sha */ 486);
exports.sha1 = __webpack_require__(/*! ./sha1 */ 2915);
exports.sha224 = __webpack_require__(/*! ./sha224 */ 4095);
exports.sha256 = __webpack_require__(/*! ./sha256 */ 9997);
exports.sha384 = __webpack_require__(/*! ./sha384 */ 9548);
exports.sha512 = __webpack_require__(/*! ./sha512 */ 4532);

/***/ }),

/***/ 486:
/*!*************************************!*\
  !*** ../node_modules/sha.js/sha.js ***!
  \*************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

/*
 * A JavaScript implementation of the Secure Hash Algorithm, SHA-0, as defined
 * in FIPS PUB 180-1
 * This source code is derived from sha1.js of the same repository.
 * The difference between SHA-0 and SHA-1 is just a bitwise rotate left
 * operation was added.
 */

var inherits = __webpack_require__(/*! inherits */ 7694);
var Hash = __webpack_require__(/*! ./hash */ 1511);
var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
var K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0];
var W = new Array(80);
function Sha() {
  this.init();
  this._w = W;
  Hash.call(this, 64, 56);
}
inherits(Sha, Hash);
Sha.prototype.init = function () {
  this._a = 0x67452301;
  this._b = 0xefcdab89;
  this._c = 0x98badcfe;
  this._d = 0x10325476;
  this._e = 0xc3d2e1f0;
  return this;
};
function rotl5(num) {
  return num << 5 | num >>> 27;
}
function rotl30(num) {
  return num << 30 | num >>> 2;
}
function ft(s, b, c, d) {
  if (s === 0) return b & c | ~b & d;
  if (s === 2) return b & c | b & d | c & d;
  return b ^ c ^ d;
}
Sha.prototype._update = function (M) {
  var W = this._w;
  var a = this._a | 0;
  var b = this._b | 0;
  var c = this._c | 0;
  var d = this._d | 0;
  var e = this._e | 0;
  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4);
  for (; i < 80; ++i) W[i] = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];
  for (var j = 0; j < 80; ++j) {
    var s = ~~(j / 20);
    var t = rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s] | 0;
    e = d;
    d = c;
    c = rotl30(b);
    b = a;
    a = t;
  }
  this._a = a + this._a | 0;
  this._b = b + this._b | 0;
  this._c = c + this._c | 0;
  this._d = d + this._d | 0;
  this._e = e + this._e | 0;
};
Sha.prototype._hash = function () {
  var H = Buffer.allocUnsafe(20);
  H.writeInt32BE(this._a | 0, 0);
  H.writeInt32BE(this._b | 0, 4);
  H.writeInt32BE(this._c | 0, 8);
  H.writeInt32BE(this._d | 0, 12);
  H.writeInt32BE(this._e | 0, 16);
  return H;
};
module.exports = Sha;

/***/ }),

/***/ 2915:
/*!**************************************!*\
  !*** ../node_modules/sha.js/sha1.js ***!
  \**************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

/*
 * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
 * in FIPS PUB 180-1
 * Version 2.1a Copyright Paul Johnston 2000 - 2002.
 * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
 * Distributed under the BSD License
 * See http://pajhome.org.uk/crypt/md5 for details.
 */

var inherits = __webpack_require__(/*! inherits */ 7694);
var Hash = __webpack_require__(/*! ./hash */ 1511);
var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
var K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0];
var W = new Array(80);
function Sha1() {
  this.init();
  this._w = W;
  Hash.call(this, 64, 56);
}
inherits(Sha1, Hash);
Sha1.prototype.init = function () {
  this._a = 0x67452301;
  this._b = 0xefcdab89;
  this._c = 0x98badcfe;
  this._d = 0x10325476;
  this._e = 0xc3d2e1f0;
  return this;
};
function rotl1(num) {
  return num << 1 | num >>> 31;
}
function rotl5(num) {
  return num << 5 | num >>> 27;
}
function rotl30(num) {
  return num << 30 | num >>> 2;
}
function ft(s, b, c, d) {
  if (s === 0) return b & c | ~b & d;
  if (s === 2) return b & c | b & d | c & d;
  return b ^ c ^ d;
}
Sha1.prototype._update = function (M) {
  var W = this._w;
  var a = this._a | 0;
  var b = this._b | 0;
  var c = this._c | 0;
  var d = this._d | 0;
  var e = this._e | 0;
  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4);
  for (; i < 80; ++i) W[i] = rotl1(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16]);
  for (var j = 0; j < 80; ++j) {
    var s = ~~(j / 20);
    var t = rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s] | 0;
    e = d;
    d = c;
    c = rotl30(b);
    b = a;
    a = t;
  }
  this._a = a + this._a | 0;
  this._b = b + this._b | 0;
  this._c = c + this._c | 0;
  this._d = d + this._d | 0;
  this._e = e + this._e | 0;
};
Sha1.prototype._hash = function () {
  var H = Buffer.allocUnsafe(20);
  H.writeInt32BE(this._a | 0, 0);
  H.writeInt32BE(this._b | 0, 4);
  H.writeInt32BE(this._c | 0, 8);
  H.writeInt32BE(this._d | 0, 12);
  H.writeInt32BE(this._e | 0, 16);
  return H;
};
module.exports = Sha1;

/***/ }),

/***/ 4095:
/*!****************************************!*\
  !*** ../node_modules/sha.js/sha224.js ***!
  \****************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

/**
 * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
 * in FIPS 180-2
 * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
 * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
 *
 */

var inherits = __webpack_require__(/*! inherits */ 7694);
var Sha256 = __webpack_require__(/*! ./sha256 */ 9997);
var Hash = __webpack_require__(/*! ./hash */ 1511);
var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
var W = new Array(64);
function Sha224() {
  this.init();
  this._w = W; // new Array(64)

  Hash.call(this, 64, 56);
}
inherits(Sha224, Sha256);
Sha224.prototype.init = function () {
  this._a = 0xc1059ed8;
  this._b = 0x367cd507;
  this._c = 0x3070dd17;
  this._d = 0xf70e5939;
  this._e = 0xffc00b31;
  this._f = 0x68581511;
  this._g = 0x64f98fa7;
  this._h = 0xbefa4fa4;
  return this;
};
Sha224.prototype._hash = function () {
  var H = Buffer.allocUnsafe(28);
  H.writeInt32BE(this._a, 0);
  H.writeInt32BE(this._b, 4);
  H.writeInt32BE(this._c, 8);
  H.writeInt32BE(this._d, 12);
  H.writeInt32BE(this._e, 16);
  H.writeInt32BE(this._f, 20);
  H.writeInt32BE(this._g, 24);
  return H;
};
module.exports = Sha224;

/***/ }),

/***/ 9997:
/*!****************************************!*\
  !*** ../node_modules/sha.js/sha256.js ***!
  \****************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

/**
 * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
 * in FIPS 180-2
 * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
 * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
 *
 */

var inherits = __webpack_require__(/*! inherits */ 7694);
var Hash = __webpack_require__(/*! ./hash */ 1511);
var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
var K = [0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5, 0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5, 0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3, 0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174, 0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC, 0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA, 0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7, 0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967, 0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13, 0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85, 0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3, 0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070, 0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5, 0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3, 0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208, 0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2];
var W = new Array(64);
function Sha256() {
  this.init();
  this._w = W; // new Array(64)

  Hash.call(this, 64, 56);
}
inherits(Sha256, Hash);
Sha256.prototype.init = function () {
  this._a = 0x6a09e667;
  this._b = 0xbb67ae85;
  this._c = 0x3c6ef372;
  this._d = 0xa54ff53a;
  this._e = 0x510e527f;
  this._f = 0x9b05688c;
  this._g = 0x1f83d9ab;
  this._h = 0x5be0cd19;
  return this;
};
function ch(x, y, z) {
  return z ^ x & (y ^ z);
}
function maj(x, y, z) {
  return x & y | z & (x | y);
}
function sigma0(x) {
  return (x >>> 2 | x << 30) ^ (x >>> 13 | x << 19) ^ (x >>> 22 | x << 10);
}
function sigma1(x) {
  return (x >>> 6 | x << 26) ^ (x >>> 11 | x << 21) ^ (x >>> 25 | x << 7);
}
function gamma0(x) {
  return (x >>> 7 | x << 25) ^ (x >>> 18 | x << 14) ^ x >>> 3;
}
function gamma1(x) {
  return (x >>> 17 | x << 15) ^ (x >>> 19 | x << 13) ^ x >>> 10;
}
Sha256.prototype._update = function (M) {
  var W = this._w;
  var a = this._a | 0;
  var b = this._b | 0;
  var c = this._c | 0;
  var d = this._d | 0;
  var e = this._e | 0;
  var f = this._f | 0;
  var g = this._g | 0;
  var h = this._h | 0;
  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4);
  for (; i < 64; ++i) W[i] = gamma1(W[i - 2]) + W[i - 7] + gamma0(W[i - 15]) + W[i - 16] | 0;
  for (var j = 0; j < 64; ++j) {
    var T1 = h + sigma1(e) + ch(e, f, g) + K[j] + W[j] | 0;
    var T2 = sigma0(a) + maj(a, b, c) | 0;
    h = g;
    g = f;
    f = e;
    e = d + T1 | 0;
    d = c;
    c = b;
    b = a;
    a = T1 + T2 | 0;
  }
  this._a = a + this._a | 0;
  this._b = b + this._b | 0;
  this._c = c + this._c | 0;
  this._d = d + this._d | 0;
  this._e = e + this._e | 0;
  this._f = f + this._f | 0;
  this._g = g + this._g | 0;
  this._h = h + this._h | 0;
};
Sha256.prototype._hash = function () {
  var H = Buffer.allocUnsafe(32);
  H.writeInt32BE(this._a, 0);
  H.writeInt32BE(this._b, 4);
  H.writeInt32BE(this._c, 8);
  H.writeInt32BE(this._d, 12);
  H.writeInt32BE(this._e, 16);
  H.writeInt32BE(this._f, 20);
  H.writeInt32BE(this._g, 24);
  H.writeInt32BE(this._h, 28);
  return H;
};
module.exports = Sha256;

/***/ }),

/***/ 9548:
/*!****************************************!*\
  !*** ../node_modules/sha.js/sha384.js ***!
  \****************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var inherits = __webpack_require__(/*! inherits */ 7694);
var SHA512 = __webpack_require__(/*! ./sha512 */ 4532);
var Hash = __webpack_require__(/*! ./hash */ 1511);
var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
var W = new Array(160);
function Sha384() {
  this.init();
  this._w = W;
  Hash.call(this, 128, 112);
}
inherits(Sha384, SHA512);
Sha384.prototype.init = function () {
  this._ah = 0xcbbb9d5d;
  this._bh = 0x629a292a;
  this._ch = 0x9159015a;
  this._dh = 0x152fecd8;
  this._eh = 0x67332667;
  this._fh = 0x8eb44a87;
  this._gh = 0xdb0c2e0d;
  this._hh = 0x47b5481d;
  this._al = 0xc1059ed8;
  this._bl = 0x367cd507;
  this._cl = 0x3070dd17;
  this._dl = 0xf70e5939;
  this._el = 0xffc00b31;
  this._fl = 0x68581511;
  this._gl = 0x64f98fa7;
  this._hl = 0xbefa4fa4;
  return this;
};
Sha384.prototype._hash = function () {
  var H = Buffer.allocUnsafe(48);
  function writeInt64BE(h, l, offset) {
    H.writeInt32BE(h, offset);
    H.writeInt32BE(l, offset + 4);
  }
  writeInt64BE(this._ah, this._al, 0);
  writeInt64BE(this._bh, this._bl, 8);
  writeInt64BE(this._ch, this._cl, 16);
  writeInt64BE(this._dh, this._dl, 24);
  writeInt64BE(this._eh, this._el, 32);
  writeInt64BE(this._fh, this._fl, 40);
  return H;
};
module.exports = Sha384;

/***/ }),

/***/ 4532:
/*!****************************************!*\
  !*** ../node_modules/sha.js/sha512.js ***!
  \****************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var inherits = __webpack_require__(/*! inherits */ 7694);
var Hash = __webpack_require__(/*! ./hash */ 1511);
var Buffer = (__webpack_require__(/*! safe-buffer */ 6565).Buffer);
var K = [0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd, 0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc, 0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019, 0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118, 0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe, 0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2, 0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1, 0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694, 0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3, 0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65, 0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483, 0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5, 0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210, 0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4, 0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725, 0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70, 0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926, 0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df, 0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8, 0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b, 0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001, 0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30, 0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910, 0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8, 0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53, 0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8, 0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb, 0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3, 0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60, 0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec, 0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9, 0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b, 0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207, 0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178, 0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6, 0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b, 0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493, 0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c, 0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a, 0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817];
var W = new Array(160);
function Sha512() {
  this.init();
  this._w = W;
  Hash.call(this, 128, 112);
}
inherits(Sha512, Hash);
Sha512.prototype.init = function () {
  this._ah = 0x6a09e667;
  this._bh = 0xbb67ae85;
  this._ch = 0x3c6ef372;
  this._dh = 0xa54ff53a;
  this._eh = 0x510e527f;
  this._fh = 0x9b05688c;
  this._gh = 0x1f83d9ab;
  this._hh = 0x5be0cd19;
  this._al = 0xf3bcc908;
  this._bl = 0x84caa73b;
  this._cl = 0xfe94f82b;
  this._dl = 0x5f1d36f1;
  this._el = 0xade682d1;
  this._fl = 0x2b3e6c1f;
  this._gl = 0xfb41bd6b;
  this._hl = 0x137e2179;
  return this;
};
function Ch(x, y, z) {
  return z ^ x & (y ^ z);
}
function maj(x, y, z) {
  return x & y | z & (x | y);
}
function sigma0(x, xl) {
  return (x >>> 28 | xl << 4) ^ (xl >>> 2 | x << 30) ^ (xl >>> 7 | x << 25);
}
function sigma1(x, xl) {
  return (x >>> 14 | xl << 18) ^ (x >>> 18 | xl << 14) ^ (xl >>> 9 | x << 23);
}
function Gamma0(x, xl) {
  return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ x >>> 7;
}
function Gamma0l(x, xl) {
  return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7 | xl << 25);
}
function Gamma1(x, xl) {
  return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ x >>> 6;
}
function Gamma1l(x, xl) {
  return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6 | xl << 26);
}
function getCarry(a, b) {
  return a >>> 0 < b >>> 0 ? 1 : 0;
}
Sha512.prototype._update = function (M) {
  var W = this._w;
  var ah = this._ah | 0;
  var bh = this._bh | 0;
  var ch = this._ch | 0;
  var dh = this._dh | 0;
  var eh = this._eh | 0;
  var fh = this._fh | 0;
  var gh = this._gh | 0;
  var hh = this._hh | 0;
  var al = this._al | 0;
  var bl = this._bl | 0;
  var cl = this._cl | 0;
  var dl = this._dl | 0;
  var el = this._el | 0;
  var fl = this._fl | 0;
  var gl = this._gl | 0;
  var hl = this._hl | 0;
  for (var i = 0; i < 32; i += 2) {
    W[i] = M.readInt32BE(i * 4);
    W[i + 1] = M.readInt32BE(i * 4 + 4);
  }
  for (; i < 160; i += 2) {
    var xh = W[i - 15 * 2];
    var xl = W[i - 15 * 2 + 1];
    var gamma0 = Gamma0(xh, xl);
    var gamma0l = Gamma0l(xl, xh);
    xh = W[i - 2 * 2];
    xl = W[i - 2 * 2 + 1];
    var gamma1 = Gamma1(xh, xl);
    var gamma1l = Gamma1l(xl, xh);

    // W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]
    var Wi7h = W[i - 7 * 2];
    var Wi7l = W[i - 7 * 2 + 1];
    var Wi16h = W[i - 16 * 2];
    var Wi16l = W[i - 16 * 2 + 1];
    var Wil = gamma0l + Wi7l | 0;
    var Wih = gamma0 + Wi7h + getCarry(Wil, gamma0l) | 0;
    Wil = Wil + gamma1l | 0;
    Wih = Wih + gamma1 + getCarry(Wil, gamma1l) | 0;
    Wil = Wil + Wi16l | 0;
    Wih = Wih + Wi16h + getCarry(Wil, Wi16l) | 0;
    W[i] = Wih;
    W[i + 1] = Wil;
  }
  for (var j = 0; j < 160; j += 2) {
    Wih = W[j];
    Wil = W[j + 1];
    var majh = maj(ah, bh, ch);
    var majl = maj(al, bl, cl);
    var sigma0h = sigma0(ah, al);
    var sigma0l = sigma0(al, ah);
    var sigma1h = sigma1(eh, el);
    var sigma1l = sigma1(el, eh);

    // t1 = h + sigma1 + ch + K[j] + W[j]
    var Kih = K[j];
    var Kil = K[j + 1];
    var chh = Ch(eh, fh, gh);
    var chl = Ch(el, fl, gl);
    var t1l = hl + sigma1l | 0;
    var t1h = hh + sigma1h + getCarry(t1l, hl) | 0;
    t1l = t1l + chl | 0;
    t1h = t1h + chh + getCarry(t1l, chl) | 0;
    t1l = t1l + Kil | 0;
    t1h = t1h + Kih + getCarry(t1l, Kil) | 0;
    t1l = t1l + Wil | 0;
    t1h = t1h + Wih + getCarry(t1l, Wil) | 0;

    // t2 = sigma0 + maj
    var t2l = sigma0l + majl | 0;
    var t2h = sigma0h + majh + getCarry(t2l, sigma0l) | 0;
    hh = gh;
    hl = gl;
    gh = fh;
    gl = fl;
    fh = eh;
    fl = el;
    el = dl + t1l | 0;
    eh = dh + t1h + getCarry(el, dl) | 0;
    dh = ch;
    dl = cl;
    ch = bh;
    cl = bl;
    bh = ah;
    bl = al;
    al = t1l + t2l | 0;
    ah = t1h + t2h + getCarry(al, t1l) | 0;
  }
  this._al = this._al + al | 0;
  this._bl = this._bl + bl | 0;
  this._cl = this._cl + cl | 0;
  this._dl = this._dl + dl | 0;
  this._el = this._el + el | 0;
  this._fl = this._fl + fl | 0;
  this._gl = this._gl + gl | 0;
  this._hl = this._hl + hl | 0;
  this._ah = this._ah + ah + getCarry(this._al, al) | 0;
  this._bh = this._bh + bh + getCarry(this._bl, bl) | 0;
  this._ch = this._ch + ch + getCarry(this._cl, cl) | 0;
  this._dh = this._dh + dh + getCarry(this._dl, dl) | 0;
  this._eh = this._eh + eh + getCarry(this._el, el) | 0;
  this._fh = this._fh + fh + getCarry(this._fl, fl) | 0;
  this._gh = this._gh + gh + getCarry(this._gl, gl) | 0;
  this._hh = this._hh + hh + getCarry(this._hl, hl) | 0;
};
Sha512.prototype._hash = function () {
  var H = Buffer.allocUnsafe(64);
  function writeInt64BE(h, l, offset) {
    H.writeInt32BE(h, offset);
    H.writeInt32BE(l, offset + 4);
  }
  writeInt64BE(this._ah, this._al, 0);
  writeInt64BE(this._bh, this._bl, 8);
  writeInt64BE(this._ch, this._cl, 16);
  writeInt64BE(this._dh, this._dl, 24);
  writeInt64BE(this._eh, this._el, 32);
  writeInt64BE(this._fh, this._fl, 40);
  writeInt64BE(this._gh, this._gl, 48);
  writeInt64BE(this._hh, this._hl, 56);
  return H;
};
module.exports = Sha512;

/***/ }),

/***/ 6830:
/*!********************************************!*\
  !*** ../node_modules/shell-quote/index.js ***!
  \********************************************/
/***/ ((__unused_webpack_module, exports) => {

"use strict";
var __webpack_unused_export__;


__webpack_unused_export__ = function (xs) {
  return xs.map(function (s) {
    if (s && typeof s === 'object') {
      return s.op.replace(/(.)/g, '\\$1');
    } else if (/["\s]/.test(s) && !/'/.test(s)) {
      return "'" + s.replace(/(['\\])/g, '\\$1') + "'";
    } else if (/["'\s]/.test(s)) {
      return '"' + s.replace(/(["\\$`!])/g, '\\$1') + '"';
    }
    return String(s).replace(/([A-Za-z]:)?([#!"$&'()*,:;<=>?@[\\\]^`{|}])/g, '$1\\$2');
  }).join(' ');
};

// '<(' is process substitution operator and
// can be parsed the same as control operator
var CONTROL = '(?:' + ['\\|\\|', '\\&\\&', ';;', '\\|\\&', '\\<\\(', '>>', '>\\&', '[&;()|<>]'].join('|') + ')';
var META = '|&;()<> \\t';
var BAREWORD = '(\\\\[\'"' + META + ']|[^\\s\'"' + META + '])+';
var SINGLE_QUOTE = '"((\\\\"|[^"])*?)"';
var DOUBLE_QUOTE = '\'((\\\\\'|[^\'])*?)\'';
var TOKEN = '';
for (var i = 0; i < 4; i++) {
  TOKEN += (Math.pow(16, 8) * Math.random()).toString(16);
}
function parse(s, env, opts) {
  var chunker = new RegExp(['(' + CONTROL + ')',
  // control chars
  '(' + BAREWORD + '|' + SINGLE_QUOTE + '|' + DOUBLE_QUOTE + ')*'].join('|'), 'g');
  var match = s.match(chunker).filter(Boolean);
  if (!match) {
    return [];
  }
  if (!env) {
    env = {};
  }
  if (!opts) {
    opts = {};
  }
  var commented = false;
  function getVar(_, pre, key) {
    var r = typeof env === 'function' ? env(key) : env[key];
    if (r === undefined && key != '') {
      r = '';
    } else if (r === undefined) {
      r = '$';
    }
    if (typeof r === 'object') {
      return pre + TOKEN + JSON.stringify(r) + TOKEN;
    }
    return pre + r;
  }
  return match.map(function (s, j) {
    if (commented) {
      return void undefined;
    }
    if (RegExp('^' + CONTROL + '$').test(s)) {
      return {
        op: s
      };
    }

    // Hand-written scanner/parser for Bash quoting rules:
    //
    // 1. inside single quotes, all characters are printed literally.
    // 2. inside double quotes, all characters are printed literally
    //    except variables prefixed by '$' and backslashes followed by
    //    either a double quote or another backslash.
    // 3. outside of any quotes, backslashes are treated as escape
    //    characters and not printed (unless they are themselves escaped)
    // 4. quote context can switch mid-token if there is no whitespace
    //     between the two quote contexts (e.g. all'one'"token" parses as
    //     "allonetoken")
    var SQ = "'";
    var DQ = '"';
    var DS = '$';
    var BS = opts.escape || '\\';
    var quote = false;
    var esc = false;
    var out = '';
    var isGlob = false;
    var i;
    function parseEnvVar() {
      i += 1;
      var varend;
      var varname;
      // debugger
      if (s.charAt(i) === '{') {
        i += 1;
        if (s.charAt(i) === '}') {
          throw new Error('Bad substitution: ' + s.substr(i - 2, 3));
        }
        varend = s.indexOf('}', i);
        if (varend < 0) {
          throw new Error('Bad substitution: ' + s.substr(i));
        }
        varname = s.substr(i, varend - i);
        i = varend;
      } else if (/[*@#?$!_-]/.test(s.charAt(i))) {
        varname = s.charAt(i);
        i += 1;
      } else {
        varend = s.substr(i).match(/[^\w\d_]/);
        if (!varend) {
          varname = s.substr(i);
          i = s.length;
        } else {
          varname = s.substr(i, varend.index);
          i += varend.index - 1;
        }
      }
      return getVar(null, '', varname);
    }
    for (i = 0; i < s.length; i++) {
      var c = s.charAt(i);
      isGlob = isGlob || !quote && (c === '*' || c === '?');
      if (esc) {
        out += c;
        esc = false;
      } else if (quote) {
        if (c === quote) {
          quote = false;
        } else if (quote == SQ) {
          out += c;
        } else {
          // Double quote
          if (c === BS) {
            i += 1;
            c = s.charAt(i);
            if (c === DQ || c === BS || c === DS) {
              out += c;
            } else {
              out += BS + c;
            }
          } else if (c === DS) {
            out += parseEnvVar();
          } else {
            out += c;
          }
        }
      } else if (c === DQ || c === SQ) {
        quote = c;
      } else if (RegExp('^' + CONTROL + '$').test(c)) {
        return {
          op: s
        };
      } else if (/^#$/.test(c)) {
        commented = true;
        if (out.length) {
          return [out, {
            comment: s.slice(i + 1) + match.slice(j + 1).join(' ')
          }];
        }
        return [{
          comment: s.slice(i + 1) + match.slice(j + 1).join(' ')
        }];
      } else if (c === BS) {
        esc = true;
      } else if (c === DS) {
        out += parseEnvVar();
      } else {
        out += c;
      }
    }
    if (isGlob) {
      return {
        op: 'glob',
        pattern: out
      };
    }
    return out;
  }).reduce(function (prev, arg) {
    // finalize parsed aruments
    if (arg === undefined) {
      return prev;
    }
    return prev.concat(arg);
  }, []);
}
exports.Q = function (s, env, opts) {
  var mapped = parse(s, env, opts);
  if (typeof env !== 'function') {
    return mapped;
  }
  return mapped.reduce(function (acc, s) {
    if (typeof s === 'object') {
      return acc.concat(s);
    }
    var xs = s.split(RegExp('(' + TOKEN + '.*?' + TOKEN + ')', 'g'));
    if (xs.length === 1) {
      return acc.concat(xs[0]);
    }
    return acc.concat(xs.filter(Boolean).map(function (x) {
      if (RegExp('^' + TOKEN).test(x)) {
        return JSON.parse(x.split(TOKEN)[1]);
      }
      return x;
    }));
  }, []);
};

/***/ }),

/***/ 4165:
/*!*******************************************!*\
  !*** ../node_modules/ssh2/lib/Channel.js ***!
  \*******************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


const {
  Duplex: DuplexStream,
  Readable: ReadableStream,
  Writable: WritableStream
} = __webpack_require__(/*! stream */ 3978);
const {
  CHANNEL_EXTENDED_DATATYPE: {
    STDERR
  }
} = __webpack_require__(/*! ./protocol/constants.js */ 7816);
const {
  bufferSlice
} = __webpack_require__(/*! ./protocol/utils.js */ 3549);
const PACKET_SIZE = 32 * 1024;
const MAX_WINDOW = 2 * 1024 * 1024;
const WINDOW_THRESHOLD = MAX_WINDOW / 2;
class ClientStderr extends ReadableStream {
  constructor(channel, streamOpts) {
    super(streamOpts);
    this._channel = channel;
  }
  _read(n) {
    if (this._channel._waitChanDrain) {
      this._channel._waitChanDrain = false;
      if (this._channel.incoming.window <= WINDOW_THRESHOLD) windowAdjust(this._channel);
    }
  }
}
class ServerStderr extends WritableStream {
  constructor(channel) {
    super({
      highWaterMark: MAX_WINDOW
    });
    this._channel = channel;
  }
  _write(data, encoding, cb) {
    const channel = this._channel;
    const protocol = channel._client._protocol;
    const outgoing = channel.outgoing;
    const packetSize = outgoing.packetSize;
    const id = outgoing.id;
    let window = outgoing.window;
    const len = data.length;
    let p = 0;
    if (outgoing.state !== 'open') return;
    while (len - p > 0 && window > 0) {
      let sliceLen = len - p;
      if (sliceLen > window) sliceLen = window;
      if (sliceLen > packetSize) sliceLen = packetSize;
      if (p === 0 && sliceLen === len) protocol.channelExtData(id, data, STDERR);else protocol.channelExtData(id, bufferSlice(data, p, p + sliceLen), STDERR);
      p += sliceLen;
      window -= sliceLen;
    }
    outgoing.window = window;
    if (len - p > 0) {
      if (window === 0) channel._waitWindow = true;
      if (p > 0) channel._chunkErr = bufferSlice(data, p, len);else channel._chunkErr = data;
      channel._chunkcbErr = cb;
      return;
    }
    cb();
  }
}
class Channel extends DuplexStream {
  constructor(client, info, opts) {
    const streamOpts = {
      highWaterMark: MAX_WINDOW,
      allowHalfOpen: !opts || opts && opts.allowHalfOpen !== false,
      emitClose: false
    };
    super(streamOpts);
    this.allowHalfOpen = streamOpts.allowHalfOpen;
    const server = !!(opts && opts.server);
    this.server = server;
    this.type = info.type;
    this.subtype = undefined;

    /*
      incoming and outgoing contain these properties:
      {
        id: undefined,
        window: undefined,
        packetSize: undefined,
        state: 'closed'
      }
    */
    this.incoming = info.incoming;
    this.outgoing = info.outgoing;
    this._callbacks = [];
    this._client = client;
    this._hasX11 = false;
    this._exit = {
      code: undefined,
      signal: undefined,
      dump: undefined,
      desc: undefined
    };
    this.stdin = this.stdout = this;
    if (server) this.stderr = new ServerStderr(this);else this.stderr = new ClientStderr(this, streamOpts);

    // Outgoing data
    this._waitWindow = false; // SSH-level backpressure

    // Incoming data
    this._waitChanDrain = false; // Channel Readable side backpressure

    this._chunk = undefined;
    this._chunkcb = undefined;
    this._chunkErr = undefined;
    this._chunkcbErr = undefined;
    this.on('finish', onFinish).on('prefinish', onFinish); // For node v0.11+

    this.on('end', onEnd).on('close', onEnd);
  }
  _read(n) {
    if (this._waitChanDrain) {
      this._waitChanDrain = false;
      if (this.incoming.window <= WINDOW_THRESHOLD) windowAdjust(this);
    }
  }
  _write(data, encoding, cb) {
    const protocol = this._client._protocol;
    const outgoing = this.outgoing;
    const packetSize = outgoing.packetSize;
    const id = outgoing.id;
    let window = outgoing.window;
    const len = data.length;
    let p = 0;
    if (outgoing.state !== 'open') return;
    while (len - p > 0 && window > 0) {
      let sliceLen = len - p;
      if (sliceLen > window) sliceLen = window;
      if (sliceLen > packetSize) sliceLen = packetSize;
      if (p === 0 && sliceLen === len) protocol.channelData(id, data);else protocol.channelData(id, bufferSlice(data, p, p + sliceLen));
      p += sliceLen;
      window -= sliceLen;
    }
    outgoing.window = window;
    if (len - p > 0) {
      if (window === 0) this._waitWindow = true;
      if (p > 0) this._chunk = bufferSlice(data, p, len);else this._chunk = data;
      this._chunkcb = cb;
      return;
    }
    cb();
  }
  eof() {
    if (this.outgoing.state === 'open') {
      this.outgoing.state = 'eof';
      this._client._protocol.channelEOF(this.outgoing.id);
    }
  }
  close() {
    if (this.outgoing.state === 'open' || this.outgoing.state === 'eof') {
      this.outgoing.state = 'closing';
      this._client._protocol.channelClose(this.outgoing.id);
    }
  }
  destroy() {
    this.end();
    this.close();
    return this;
  }

  // Session type-specific methods =============================================
  setWindow(rows, cols, height, width) {
    if (this.server) throw new Error('Client-only method called in server mode');
    if (this.type === 'session' && (this.subtype === 'shell' || this.subtype === 'exec') && this.writable && this.outgoing.state === 'open') {
      this._client._protocol.windowChange(this.outgoing.id, rows, cols, height, width);
    }
  }
  signal(signalName) {
    if (this.server) throw new Error('Client-only method called in server mode');
    if (this.type === 'session' && this.writable && this.outgoing.state === 'open') {
      this._client._protocol.signal(this.outgoing.id, signalName);
    }
  }
  exit(statusOrSignal, coreDumped, msg) {
    if (!this.server) throw new Error('Server-only method called in client mode');
    if (this.type === 'session' && this.writable && this.outgoing.state === 'open') {
      if (typeof statusOrSignal === 'number') {
        this._client._protocol.exitStatus(this.outgoing.id, statusOrSignal);
      } else {
        this._client._protocol.exitSignal(this.outgoing.id, statusOrSignal, coreDumped, msg);
      }
    }
  }
}
function onFinish() {
  this.eof();
  if (this.server || !this.allowHalfOpen) this.close();
  this.writable = false;
}
function onEnd() {
  this.readable = false;
}
function windowAdjust(self) {
  if (self.outgoing.state === 'closed') return;
  const amt = MAX_WINDOW - self.incoming.window;
  if (amt <= 0) return;
  self.incoming.window += amt;
  self._client._protocol.channelWindowAdjust(self.outgoing.id, amt);
}
module.exports = {
  Channel,
  MAX_WINDOW,
  PACKET_SIZE,
  windowAdjust,
  WINDOW_THRESHOLD
};

/***/ }),

/***/ 6505:
/*!*****************************************!*\
  !*** ../node_modules/ssh2/lib/agent.js ***!
  \*****************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


const {
  Socket
} = __webpack_require__(/*! net */ 1548);
const {
  Duplex
} = __webpack_require__(/*! stream */ 3978);
const {
  resolve
} = __webpack_require__(/*! path */ 3056);
const {
  readFile
} = __webpack_require__(/*! fs */ 2089);
const {
  execFile,
  spawn
} = __webpack_require__(/*! child_process */ 7198);
const {
  isParsedKey,
  parseKey
} = __webpack_require__(/*! ./protocol/keyParser.js */ 9934);
const {
  makeBufferParser,
  readUInt32BE,
  writeUInt32BE,
  writeUInt32LE
} = __webpack_require__(/*! ./protocol/utils.js */ 3549);
function once(cb) {
  let called = false;
  return (...args) => {
    if (called) return;
    called = true;
    cb(...args);
  };
}
function concat(buf1, buf2) {
  const combined = Buffer.allocUnsafe(buf1.length + buf2.length);
  buf1.copy(combined, 0);
  buf2.copy(combined, buf1.length);
  return combined;
}
function noop() {}
const EMPTY_BUF = Buffer.alloc(0);
const binaryParser = makeBufferParser();
class BaseAgent {
  getIdentities(cb) {
    cb(new Error('Missing getIdentities() implementation'));
  }
  sign(pubKey, data, options, cb) {
    if (typeof options === 'function') cb = options;
    cb(new Error('Missing sign() implementation'));
  }
}
class OpenSSHAgent extends BaseAgent {
  constructor(socketPath) {
    super();
    this.socketPath = socketPath;
  }
  getStream(cb) {
    cb = once(cb);
    const sock = new Socket();
    sock.on('connect', () => {
      cb(null, sock);
    });
    sock.on('close', onFail).on('end', onFail).on('error', onFail);
    sock.connect(this.socketPath);
    function onFail() {
      try {
        sock.destroy();
      } catch {}
      cb(new Error('Failed to connect to agent'));
    }
  }
  getIdentities(cb) {
    cb = once(cb);
    this.getStream((err, stream) => {
      function onFail(err) {
        if (stream) {
          try {
            stream.destroy();
          } catch {}
        }
        if (!err) err = new Error('Failed to retrieve identities from agent');
        cb(err);
      }
      if (err) return onFail(err);
      const protocol = new AgentProtocol(true);
      protocol.on('error', onFail);
      protocol.pipe(stream).pipe(protocol);
      stream.on('close', onFail).on('end', onFail).on('error', onFail);
      protocol.getIdentities((err, keys) => {
        if (err) return onFail(err);
        try {
          stream.destroy();
        } catch {}
        cb(null, keys);
      });
    });
  }
  sign(pubKey, data, options, cb) {
    if (typeof options === 'function') {
      cb = options;
      options = undefined;
    } else if (typeof options !== 'object' || options === null) {
      options = undefined;
    }
    cb = once(cb);
    this.getStream((err, stream) => {
      function onFail(err) {
        if (stream) {
          try {
            stream.destroy();
          } catch {}
        }
        if (!err) err = new Error('Failed to sign data with agent');
        cb(err);
      }
      if (err) return onFail(err);
      const protocol = new AgentProtocol(true);
      protocol.on('error', onFail);
      protocol.pipe(stream).pipe(protocol);
      stream.on('close', onFail).on('end', onFail).on('error', onFail);
      protocol.sign(pubKey, data, options, (err, sig) => {
        if (err) return onFail(err);
        try {
          stream.destroy();
        } catch {}
        cb(null, sig);
      });
    });
  }
}
const PageantAgent = (() => {
  const RET_ERR_BADARGS = 10;
  const RET_ERR_UNAVAILABLE = 11;
  const RET_ERR_NOMAP = 12;
  const RET_ERR_BINSTDIN = 13;
  const RET_ERR_BINSTDOUT = 14;
  const RET_ERR_BADLEN = 15;
  const EXEPATH = resolve(__dirname, '..', 'util/pagent.exe');
  const ERROR = {
    [RET_ERR_BADARGS]: new Error('Invalid pagent.exe arguments'),
    [RET_ERR_UNAVAILABLE]: new Error('Pageant is not running'),
    [RET_ERR_NOMAP]: new Error('pagent.exe could not create an mmap'),
    [RET_ERR_BINSTDIN]: new Error('pagent.exe could not set mode for stdin'),
    [RET_ERR_BINSTDOUT]: new Error('pagent.exe could not set mode for stdout'),
    [RET_ERR_BADLEN]: new Error('pagent.exe did not get expected input payload')
  };
  function destroy(stream) {
    stream.buffer = null;
    if (stream.proc) {
      stream.proc.kill();
      stream.proc = undefined;
    }
  }
  class PageantSocket extends Duplex {
    constructor() {
      super();
      this.proc = undefined;
      this.buffer = null;
    }
    _read(n) {}
    _write(data, encoding, cb) {
      if (this.buffer === null) {
        this.buffer = data;
      } else {
        const newBuffer = Buffer.allocUnsafe(this.buffer.length + data.length);
        this.buffer.copy(newBuffer, 0);
        data.copy(newBuffer, this.buffer.length);
        this.buffer = newBuffer;
      }
      // Wait for at least all length bytes
      if (this.buffer.length < 4) return cb();
      const len = readUInt32BE(this.buffer, 0);
      // Make sure we have a full message before querying pageant
      if (this.buffer.length - 4 < len) return cb();
      data = this.buffer.slice(0, 4 + len);
      if (this.buffer.length > 4 + len) return cb(new Error('Unexpected multiple agent requests'));
      this.buffer = null;
      let error;
      const proc = this.proc = spawn(EXEPATH, [data.length]);
      proc.stdout.on('data', data => {
        this.push(data);
      });
      proc.on('error', err => {
        error = err;
        cb(error);
      });
      proc.on('close', code => {
        this.proc = undefined;
        if (!error) {
          if (error = ERROR[code]) return cb(error);
          cb();
        }
      });
      proc.stdin.end(data);
    }
    _final(cb) {
      destroy(this);
      cb();
    }
    _destroy(err, cb) {
      destroy(this);
      cb();
    }
  }
  return class PageantAgent extends OpenSSHAgent {
    getStream(cb) {
      cb(null, new PageantSocket());
    }
  };
})();
const CygwinAgent = (() => {
  const RE_CYGWIN_SOCK = /^!<socket >(\d+) s ([A-Z0-9]{8}-[A-Z0-9]{8}-[A-Z0-9]{8}-[A-Z0-9]{8})/;
  return class CygwinAgent extends OpenSSHAgent {
    getStream(cb) {
      cb = once(cb);

      // The cygwin ssh-agent connection process looks like this:
      //   1. Read the "socket" as a file to get the underlying TCP port and a
      //      special "secret" that must be sent to the TCP server.
      //   2. Connect to the server listening on localhost at the TCP port.
      //   3. Send the "secret" to the server.
      //   4. The server sends back the same "secret".
      //   5. Send three 32-bit integer values of zero. This is ordinarily the
      //      pid, uid, and gid of this process, but cygwin will actually
      //      send us the correct values as a response.
      //   6. The server sends back the pid, uid, gid.
      //   7. Disconnect.
      //   8. Repeat steps 2-6, except send the received pid, uid, and gid in
      //      step 5 instead of zeroes.
      //   9. Connection is ready to be used.

      let socketPath = this.socketPath;
      let triedCygpath = false;
      readFile(socketPath, function readCygsocket(err, data) {
        if (err) {
          if (triedCygpath) return cb(new Error('Invalid cygwin unix socket path'));

          // Try using `cygpath` to convert a possible *nix-style path to the
          // real Windows path before giving up ...
          execFile('cygpath', ['-w', socketPath], (err, stdout, stderr) => {
            if (err || stdout.length === 0) return cb(new Error('Invalid cygwin unix socket path'));
            triedCygpath = true;
            socketPath = stdout.toString().replace(/[\r\n]/g, '');
            readFile(socketPath, readCygsocket);
          });
          return;
        }
        const m = RE_CYGWIN_SOCK.exec(data.toString('ascii'));
        if (!m) return cb(new Error('Malformed cygwin unix socket file'));
        let state;
        let bc = 0;
        let isRetrying = false;
        const inBuf = [];
        let sock;

        // Use 0 for pid, uid, and gid to ensure we get an error and also
        // a valid uid and gid from cygwin so that we don't have to figure it
        // out ourselves
        let credsBuf = Buffer.alloc(12);

        // Parse cygwin unix socket file contents
        const port = parseInt(m[1], 10);
        const secret = m[2].replace(/-/g, '');
        const secretBuf = Buffer.allocUnsafe(16);
        for (let i = 0, j = 0; j < 32; ++i, j += 2) secretBuf[i] = parseInt(secret.substring(j, j + 2), 16);

        // Convert to host order (always LE for Windows)
        for (let i = 0; i < 16; i += 4) writeUInt32LE(secretBuf, readUInt32BE(secretBuf, i), i);
        tryConnect();
        function _onconnect() {
          bc = 0;
          state = 'secret';
          sock.write(secretBuf);
        }
        function _ondata(data) {
          bc += data.length;
          if (state === 'secret') {
            // The secret we sent is echoed back to us by cygwin, not sure of
            // the reason for that, but we ignore it nonetheless ...
            if (bc === 16) {
              bc = 0;
              state = 'creds';
              sock.write(credsBuf);
            }
            return;
          }
          if (state === 'creds') {
            // If this is the first attempt, make sure to gather the valid
            // uid and gid for our next attempt
            if (!isRetrying) inBuf.push(data);
            if (bc === 12) {
              sock.removeListener('connect', _onconnect);
              sock.removeListener('data', _ondata);
              sock.removeListener('error', onFail);
              sock.removeListener('end', onFail);
              sock.removeListener('close', onFail);
              if (isRetrying) return cb(null, sock);
              isRetrying = true;
              credsBuf = Buffer.concat(inBuf);
              writeUInt32LE(credsBuf, process.pid, 0);
              sock.on('error', () => {});
              sock.destroy();
              tryConnect();
            }
          }
        }
        function onFail() {
          cb(new Error('Problem negotiating cygwin unix socket security'));
        }
        function tryConnect() {
          sock = new Socket();
          sock.on('connect', _onconnect);
          sock.on('data', _ondata);
          sock.on('error', onFail);
          sock.on('end', onFail);
          sock.on('close', onFail);
          sock.connect(port);
        }
      });
    }
  };
})();

// Format of `//./pipe/ANYTHING`, with forward slashes and backward slashes
// being interchangeable
const WINDOWS_PIPE_REGEX = /^[/\\][/\\]\.[/\\]pipe[/\\].+/;
function createAgent(path) {
  if (process.platform === 'win32' && !WINDOWS_PIPE_REGEX.test(path)) {
    return path === 'pageant' ? new PageantAgent() : new CygwinAgent(path);
  }
  return new OpenSSHAgent(path);
}
const AgentProtocol = (() => {
  // Client->Server messages
  const SSH_AGENTC_REQUEST_IDENTITIES = 11;
  const SSH_AGENTC_SIGN_REQUEST = 13;
  // const SSH_AGENTC_ADD_IDENTITY = 17;
  // const SSH_AGENTC_REMOVE_IDENTITY = 18;
  // const SSH_AGENTC_REMOVE_ALL_IDENTITIES = 19;
  // const SSH_AGENTC_ADD_SMARTCARD_KEY = 20;
  // const SSH_AGENTC_REMOVE_SMARTCARD_KEY = 21;
  // const SSH_AGENTC_LOCK = 22;
  // const SSH_AGENTC_UNLOCK = 23;
  // const SSH_AGENTC_ADD_ID_CONSTRAINED = 25;
  // const SSH_AGENTC_ADD_SMARTCARD_KEY_CONSTRAINED = 26;
  // const SSH_AGENTC_EXTENSION = 27;
  // Server->Client messages
  const SSH_AGENT_FAILURE = 5;
  // const SSH_AGENT_SUCCESS = 6;
  const SSH_AGENT_IDENTITIES_ANSWER = 12;
  const SSH_AGENT_SIGN_RESPONSE = 14;
  // const SSH_AGENT_EXTENSION_FAILURE = 28;

  // const SSH_AGENT_CONSTRAIN_LIFETIME = 1;
  // const SSH_AGENT_CONSTRAIN_CONFIRM = 2;
  // const SSH_AGENT_CONSTRAIN_EXTENSION = 255;

  const SSH_AGENT_RSA_SHA2_256 = 1 << 1;
  const SSH_AGENT_RSA_SHA2_512 = 1 << 2;
  const ROLE_CLIENT = 0;
  const ROLE_SERVER = 1;

  // Ensures that responses get sent back in the same order the requests were
  // received
  function processResponses(protocol) {
    let ret;
    while (protocol[SYM_REQS].length) {
      const nextResponse = protocol[SYM_REQS][0][SYM_RESP];
      if (nextResponse === undefined) break;
      protocol[SYM_REQS].shift();
      ret = protocol.push(nextResponse);
    }
    return ret;
  }
  const SYM_TYPE = Symbol('Inbound Request Type');
  const SYM_RESP = Symbol('Inbound Request Response');
  const SYM_CTX = Symbol('Inbound Request Context');
  class AgentInboundRequest {
    constructor(type, ctx) {
      this[SYM_TYPE] = type;
      this[SYM_RESP] = undefined;
      this[SYM_CTX] = ctx;
    }
    hasResponded() {
      return this[SYM_RESP] !== undefined;
    }
    getType() {
      return this[SYM_TYPE];
    }
    getContext() {
      return this[SYM_CTX];
    }
  }
  function respond(protocol, req, data) {
    req[SYM_RESP] = data;
    return processResponses(protocol);
  }
  function cleanup(protocol) {
    protocol[SYM_BUFFER] = null;
    if (protocol[SYM_MODE] === ROLE_CLIENT) {
      const reqs = protocol[SYM_REQS];
      if (reqs && reqs.length) {
        protocol[SYM_REQS] = [];
        for (const req of reqs) req.cb(new Error('No reply from server'));
      }
    }

    // Node streams hackery to make streams do the "right thing"
    try {
      protocol.end();
    } catch {}
    setImmediate(() => {
      if (!protocol[SYM_ENDED]) protocol.emit('end');
      if (!protocol[SYM_CLOSED]) protocol.emit('close');
    });
  }
  function onClose() {
    this[SYM_CLOSED] = true;
  }
  function onEnd() {
    this[SYM_ENDED] = true;
  }
  const SYM_REQS = Symbol('Requests');
  const SYM_MODE = Symbol('Agent Protocol Role');
  const SYM_BUFFER = Symbol('Agent Protocol Buffer');
  const SYM_MSGLEN = Symbol('Agent Protocol Current Message Length');
  const SYM_CLOSED = Symbol('Agent Protocol Closed');
  const SYM_ENDED = Symbol('Agent Protocol Ended');
  // Implementation based on:
  // https://tools.ietf.org/html/draft-miller-ssh-agent-04
  return class AgentProtocol extends Duplex {
    /*
        Notes:
          - `constraint` type consists of:
               byte                    constraint_type
               byte[]                  constraint_data
            where `constraint_type` is one of:
              * SSH_AGENT_CONSTRAIN_LIFETIME
                - `constraint_data` consists of:
                     uint32                  seconds
              * SSH_AGENT_CONSTRAIN_CONFIRM
                - `constraint_data` N/A
              * SSH_AGENT_CONSTRAIN_EXTENSION
                - `constraint_data` consists of:
                     string                  extension name
                     byte[]                  extension-specific details
    */

    constructor(isClient) {
      super({
        autoDestroy: true,
        emitClose: false
      });
      this[SYM_MODE] = isClient ? ROLE_CLIENT : ROLE_SERVER;
      this[SYM_REQS] = [];
      this[SYM_BUFFER] = null;
      this[SYM_MSGLEN] = -1;
      this.once('end', onEnd);
      this.once('close', onClose);
    }
    _read(n) {}
    _write(data, encoding, cb) {
      /*
          Messages are of the format:
            uint32                    message length
            byte                      message type
            byte[message length - 1]  message contents
      */
      if (this[SYM_BUFFER] === null) this[SYM_BUFFER] = data;else this[SYM_BUFFER] = concat(this[SYM_BUFFER], data);
      let buffer = this[SYM_BUFFER];
      let bufferLen = buffer.length;
      let p = 0;
      while (p < bufferLen) {
        // Wait for length + type
        if (bufferLen < 5) break;
        if (this[SYM_MSGLEN] === -1) this[SYM_MSGLEN] = readUInt32BE(buffer, p);

        // Check if we have the entire message
        if (bufferLen < 4 + this[SYM_MSGLEN]) break;
        const msgType = buffer[p += 4];
        ++p;
        if (this[SYM_MODE] === ROLE_CLIENT) {
          if (this[SYM_REQS].length === 0) return cb(new Error('Received unexpected message from server'));
          const req = this[SYM_REQS].shift();
          switch (msgType) {
            case SSH_AGENT_FAILURE:
              req.cb(new Error('Agent responded with failure'));
              break;
            case SSH_AGENT_IDENTITIES_ANSWER:
              {
                if (req.type !== SSH_AGENTC_REQUEST_IDENTITIES) return cb(new Error('Agent responded with wrong message type'));

                /*
                   byte        SSH_AGENT_IDENTITIES_ANSWER
                   uint32      nkeys
                   where `nkeys` is 0 or more of:
                   string      key blob
                   string      comment
                */

                binaryParser.init(buffer, p);
                const numKeys = binaryParser.readUInt32BE();
                if (numKeys === undefined) {
                  binaryParser.clear();
                  return cb(new Error('Malformed agent response'));
                }
                const keys = [];
                for (let i = 0; i < numKeys; ++i) {
                  let pubKey = binaryParser.readString();
                  if (pubKey === undefined) {
                    binaryParser.clear();
                    return cb(new Error('Malformed agent response'));
                  }
                  const comment = binaryParser.readString(true);
                  if (comment === undefined) {
                    binaryParser.clear();
                    return cb(new Error('Malformed agent response'));
                  }
                  pubKey = parseKey(pubKey);
                  // We continue parsing the packet if we encounter an error
                  // in case the error is due to the key being an unsupported
                  // type
                  if (pubKey instanceof Error) continue;
                  pubKey.comment = pubKey.comment || comment;
                  keys.push(pubKey);
                }
                p = binaryParser.pos();
                binaryParser.clear();
                req.cb(null, keys);
                break;
              }
            case SSH_AGENT_SIGN_RESPONSE:
              {
                if (req.type !== SSH_AGENTC_SIGN_REQUEST) return cb(new Error('Agent responded with wrong message type'));

                /*
                   byte        SSH_AGENT_SIGN_RESPONSE
                   string      signature
                */

                binaryParser.init(buffer, p);
                let signature = binaryParser.readString();
                p = binaryParser.pos();
                binaryParser.clear();
                if (signature === undefined) return cb(new Error('Malformed agent response'));

                // We strip the algorithm from OpenSSH's output and assume it's
                // using the algorithm we specified. This makes it easier on
                // custom Agent implementations so they don't have to construct
                // the correct binary format for a (OpenSSH-style) signature.

                // TODO: verify signature type based on key and options used
                // during initial sign request
                binaryParser.init(signature, 0);
                binaryParser.readString(true);
                signature = binaryParser.readString();
                binaryParser.clear();
                if (signature === undefined) return cb(new Error('Malformed OpenSSH signature format'));
                req.cb(null, signature);
                break;
              }
            default:
              return cb(new Error('Agent responded with unsupported message type'));
          }
        } else {
          switch (msgType) {
            case SSH_AGENTC_REQUEST_IDENTITIES:
              {
                const req = new AgentInboundRequest(msgType);
                this[SYM_REQS].push(req);
                /*
                  byte        SSH_AGENTC_REQUEST_IDENTITIES
                */
                this.emit('identities', req);
                break;
              }
            case SSH_AGENTC_SIGN_REQUEST:
              {
                /*
                  byte        SSH_AGENTC_SIGN_REQUEST
                  string      key_blob
                  string      data
                  uint32      flags
                */
                binaryParser.init(buffer, p);
                let pubKey = binaryParser.readString();
                const data = binaryParser.readString();
                const flagsVal = binaryParser.readUInt32BE();
                p = binaryParser.pos();
                binaryParser.clear();
                if (flagsVal === undefined) {
                  const req = new AgentInboundRequest(msgType);
                  this[SYM_REQS].push(req);
                  return this.failureReply(req);
                }
                pubKey = parseKey(pubKey);
                if (pubKey instanceof Error) {
                  const req = new AgentInboundRequest(msgType);
                  this[SYM_REQS].push(req);
                  return this.failureReply(req);
                }
                const flags = {
                  hash: undefined
                };
                let ctx;
                if (pubKey.type === 'ssh-rsa') {
                  if (flagsVal & SSH_AGENT_RSA_SHA2_256) {
                    ctx = 'rsa-sha2-256';
                    flags.hash = 'sha256';
                  } else if (flagsVal & SSH_AGENT_RSA_SHA2_512) {
                    ctx = 'rsa-sha2-512';
                    flags.hash = 'sha512';
                  }
                }
                if (ctx === undefined) ctx = pubKey.type;
                const req = new AgentInboundRequest(msgType, ctx);
                this[SYM_REQS].push(req);
                this.emit('sign', req, pubKey, data, flags);
                break;
              }
            default:
              {
                const req = new AgentInboundRequest(msgType);
                this[SYM_REQS].push(req);
                this.failureReply(req);
              }
          }
        }

        // Get ready for next message
        this[SYM_MSGLEN] = -1;
        if (p === bufferLen) {
          // Nothing left to process for now
          this[SYM_BUFFER] = null;
          break;
        } else {
          this[SYM_BUFFER] = buffer = buffer.slice(p);
          bufferLen = buffer.length;
          p = 0;
        }
      }
      cb();
    }
    _destroy(err, cb) {
      cleanup(this);
      cb();
    }
    _final(cb) {
      cleanup(this);
      cb();
    }

    // Client->Server messages =================================================
    sign(pubKey, data, options, cb) {
      if (this[SYM_MODE] !== ROLE_CLIENT) throw new Error('Client-only method called with server role');
      if (typeof options === 'function') {
        cb = options;
        options = undefined;
      } else if (typeof options !== 'object' || options === null) {
        options = undefined;
      }
      let flags = 0;
      pubKey = parseKey(pubKey);
      if (pubKey instanceof Error) throw new Error('Invalid public key argument');
      if (pubKey.type === 'ssh-rsa' && options) {
        switch (options.hash) {
          case 'sha256':
            flags = SSH_AGENT_RSA_SHA2_256;
            break;
          case 'sha512':
            flags = SSH_AGENT_RSA_SHA2_512;
            break;
        }
      }
      pubKey = pubKey.getPublicSSH();

      /*
        byte        SSH_AGENTC_SIGN_REQUEST
        string      key_blob
        string      data
        uint32      flags
      */
      const type = SSH_AGENTC_SIGN_REQUEST;
      const keyLen = pubKey.length;
      const dataLen = data.length;
      let p = 0;
      const buf = Buffer.allocUnsafe(4 + 1 + 4 + keyLen + 4 + dataLen + 4);
      writeUInt32BE(buf, buf.length - 4, p);
      buf[p += 4] = type;
      writeUInt32BE(buf, keyLen, ++p);
      pubKey.copy(buf, p += 4);
      writeUInt32BE(buf, dataLen, p += keyLen);
      data.copy(buf, p += 4);
      writeUInt32BE(buf, flags, p += dataLen);
      if (typeof cb !== 'function') cb = noop;
      this[SYM_REQS].push({
        type,
        cb
      });
      return this.push(buf);
    }
    getIdentities(cb) {
      if (this[SYM_MODE] !== ROLE_CLIENT) throw new Error('Client-only method called with server role');

      /*
        byte        SSH_AGENTC_REQUEST_IDENTITIES
      */
      const type = SSH_AGENTC_REQUEST_IDENTITIES;
      let p = 0;
      const buf = Buffer.allocUnsafe(4 + 1);
      writeUInt32BE(buf, buf.length - 4, p);
      buf[p += 4] = type;
      if (typeof cb !== 'function') cb = noop;
      this[SYM_REQS].push({
        type,
        cb
      });
      return this.push(buf);
    }

    // Server->Client messages =================================================
    failureReply(req) {
      if (this[SYM_MODE] !== ROLE_SERVER) throw new Error('Server-only method called with client role');
      if (!(req instanceof AgentInboundRequest)) throw new Error('Wrong request argument');
      if (req.hasResponded()) return true;
      let p = 0;
      const buf = Buffer.allocUnsafe(4 + 1);
      writeUInt32BE(buf, buf.length - 4, p);
      buf[p += 4] = SSH_AGENT_FAILURE;
      return respond(this, req, buf);
    }
    getIdentitiesReply(req, keys) {
      if (this[SYM_MODE] !== ROLE_SERVER) throw new Error('Server-only method called with client role');
      if (!(req instanceof AgentInboundRequest)) throw new Error('Wrong request argument');
      if (req.hasResponded()) return true;

      /*
         byte        SSH_AGENT_IDENTITIES_ANSWER
         uint32      nkeys
         where `nkeys` is 0 or more of:
         string      key blob
         string      comment
      */

      if (req.getType() !== SSH_AGENTC_REQUEST_IDENTITIES) throw new Error('Invalid response to request');
      if (!Array.isArray(keys)) throw new Error('Keys argument must be an array');
      let totalKeysLen = 4; // Include `nkeys` size

      const newKeys = [];
      for (let i = 0; i < keys.length; ++i) {
        const entry = keys[i];
        if (typeof entry !== 'object' || entry === null) throw new Error(`Invalid key entry: ${entry}`);
        let pubKey;
        let comment;
        if (isParsedKey(entry)) {
          pubKey = entry;
        } else if (isParsedKey(entry.pubKey)) {
          pubKey = entry.pubKey;
        } else {
          if (typeof entry.pubKey !== 'object' || entry.pubKey === null) continue;
          ({
            pubKey,
            comment
          } = entry.pubKey);
          pubKey = parseKey(pubKey);
          if (pubKey instanceof Error) continue; // TODO: add debug output
        }

        comment = pubKey.comment || comment;
        pubKey = pubKey.getPublicSSH();
        totalKeysLen += 4 + pubKey.length;
        if (comment && typeof comment === 'string') comment = Buffer.from(comment);else if (!Buffer.isBuffer(comment)) comment = EMPTY_BUF;
        totalKeysLen += 4 + comment.length;
        newKeys.push({
          pubKey,
          comment
        });
      }
      let p = 0;
      const buf = Buffer.allocUnsafe(4 + 1 + totalKeysLen);
      writeUInt32BE(buf, buf.length - 4, p);
      buf[p += 4] = SSH_AGENT_IDENTITIES_ANSWER;
      writeUInt32BE(buf, newKeys.length, ++p);
      p += 4;
      for (let i = 0; i < newKeys.length; ++i) {
        const {
          pubKey,
          comment
        } = newKeys[i];
        writeUInt32BE(buf, pubKey.length, p);
        pubKey.copy(buf, p += 4);
        writeUInt32BE(buf, comment.length, p += pubKey.length);
        p += 4;
        if (comment.length) {
          comment.copy(buf, p);
          p += comment.length;
        }
      }
      return respond(this, req, buf);
    }
    signReply(req, signature) {
      if (this[SYM_MODE] !== ROLE_SERVER) throw new Error('Server-only method called with client role');
      if (!(req instanceof AgentInboundRequest)) throw new Error('Wrong request argument');
      if (req.hasResponded()) return true;

      /*
         byte        SSH_AGENT_SIGN_RESPONSE
         string      signature
      */

      if (req.getType() !== SSH_AGENTC_SIGN_REQUEST) throw new Error('Invalid response to request');
      if (!Buffer.isBuffer(signature)) throw new Error('Signature argument must be a Buffer');
      if (signature.length === 0) throw new Error('Signature argument must be non-empty');

      /*
        OpenSSH agent signatures are encoded as:
           string    signature format identifier (as specified by the
                    public key/certificate format)
          byte[n]   signature blob in format specific encoding.
            - This is actually a `string` for: rsa, dss, ecdsa, and ed25519
              types
      */

      let p = 0;
      const sigFormat = req.getContext();
      const sigFormatLen = Buffer.byteLength(sigFormat);
      const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + sigFormatLen + 4 + signature.length);
      writeUInt32BE(buf, buf.length - 4, p);
      buf[p += 4] = SSH_AGENT_SIGN_RESPONSE;
      writeUInt32BE(buf, 4 + sigFormatLen + 4 + signature.length, ++p);
      writeUInt32BE(buf, sigFormatLen, p += 4);
      buf.utf8Write(sigFormat, p += 4, sigFormatLen);
      writeUInt32BE(buf, signature.length, p += sigFormatLen);
      signature.copy(buf, p += 4);
      return respond(this, req, buf);
    }
  };
})();
const SYM_AGENT = Symbol('Agent');
const SYM_AGENT_KEYS = Symbol('Agent Keys');
const SYM_AGENT_KEYS_IDX = Symbol('Agent Keys Index');
const SYM_AGENT_CBS = Symbol('Agent Init Callbacks');
class AgentContext {
  constructor(agent) {
    if (typeof agent === 'string') agent = createAgent(agent);else if (!isAgent(agent)) throw new Error('Invalid agent argument');
    this[SYM_AGENT] = agent;
    this[SYM_AGENT_KEYS] = null;
    this[SYM_AGENT_KEYS_IDX] = -1;
    this[SYM_AGENT_CBS] = null;
  }
  init(cb) {
    if (typeof cb !== 'function') cb = noop;
    if (this[SYM_AGENT_KEYS] === null) {
      if (this[SYM_AGENT_CBS] === null) {
        this[SYM_AGENT_CBS] = [cb];
        const doCbs = (...args) => {
          process.nextTick(() => {
            const cbs = this[SYM_AGENT_CBS];
            this[SYM_AGENT_CBS] = null;
            for (const cb of cbs) cb(...args);
          });
        };
        this[SYM_AGENT].getIdentities(once((err, keys) => {
          if (err) return doCbs(err);
          if (!Array.isArray(keys)) {
            return doCbs(new Error('Agent implementation failed to provide keys'));
          }
          const newKeys = [];
          for (let key of keys) {
            key = parseKey(key);
            if (key instanceof Error) {
              // TODO: add debug output
              continue;
            }
            newKeys.push(key);
          }
          this[SYM_AGENT_KEYS] = newKeys;
          this[SYM_AGENT_KEYS_IDX] = -1;
          doCbs();
        }));
      } else {
        this[SYM_AGENT_CBS].push(cb);
      }
    } else {
      process.nextTick(cb);
    }
  }
  nextKey() {
    if (this[SYM_AGENT_KEYS] === null || ++this[SYM_AGENT_KEYS_IDX] >= this[SYM_AGENT_KEYS].length) {
      return false;
    }
    return this[SYM_AGENT_KEYS][this[SYM_AGENT_KEYS_IDX]];
  }
  currentKey() {
    if (this[SYM_AGENT_KEYS] === null || this[SYM_AGENT_KEYS_IDX] >= this[SYM_AGENT_KEYS].length) {
      return null;
    }
    return this[SYM_AGENT_KEYS][this[SYM_AGENT_KEYS_IDX]];
  }
  pos() {
    if (this[SYM_AGENT_KEYS] === null || this[SYM_AGENT_KEYS_IDX] >= this[SYM_AGENT_KEYS].length) {
      return -1;
    }
    return this[SYM_AGENT_KEYS_IDX];
  }
  reset() {
    this[SYM_AGENT_KEYS_IDX] = -1;
  }
  sign(...args) {
    this[SYM_AGENT].sign(...args);
  }
}
function isAgent(val) {
  return val instanceof BaseAgent;
}
module.exports = {
  AgentContext,
  AgentProtocol,
  BaseAgent,
  createAgent,
  CygwinAgent,
  isAgent,
  OpenSSHAgent,
  PageantAgent
};

/***/ }),

/***/ 1175:
/*!******************************************!*\
  !*** ../node_modules/ssh2/lib/client.js ***!
  \******************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";
// TODO:
//    * add `.connected` or similar property to allow immediate connection
//      status checking
//    * add/improve debug output during user authentication phase


const {
  createHash,
  getHashes,
  randomFillSync
} = __webpack_require__(/*! crypto */ 6113);
const {
  Socket
} = __webpack_require__(/*! net */ 1548);
const {
  lookup: dnsLookup
} = __webpack_require__(/*! dns */ 9523);
const EventEmitter = __webpack_require__(/*! events */ 2361);
const HASHES = getHashes();
const {
  COMPAT,
  CHANNEL_EXTENDED_DATATYPE: {
    STDERR
  },
  CHANNEL_OPEN_FAILURE,
  DEFAULT_CIPHER,
  DEFAULT_COMPRESSION,
  DEFAULT_KEX,
  DEFAULT_MAC,
  DEFAULT_SERVER_HOST_KEY,
  DISCONNECT_REASON,
  DISCONNECT_REASON_BY_VALUE,
  SUPPORTED_CIPHER,
  SUPPORTED_COMPRESSION,
  SUPPORTED_KEX,
  SUPPORTED_MAC,
  SUPPORTED_SERVER_HOST_KEY
} = __webpack_require__(/*! ./protocol/constants.js */ 7816);
const {
  init: cryptoInit
} = __webpack_require__(/*! ./protocol/crypto.js */ 6173);
const Protocol = __webpack_require__(/*! ./protocol/Protocol.js */ 1551);
const {
  parseKey
} = __webpack_require__(/*! ./protocol/keyParser.js */ 9934);
const {
  SFTP
} = __webpack_require__(/*! ./protocol/SFTP.js */ 287);
const {
  bufferCopy,
  makeBufferParser,
  makeError,
  readUInt32BE,
  sigSSHToASN1,
  writeUInt32BE
} = __webpack_require__(/*! ./protocol/utils.js */ 3549);
const {
  AgentContext,
  createAgent,
  isAgent
} = __webpack_require__(/*! ./agent.js */ 6505);
const {
  Channel,
  MAX_WINDOW,
  PACKET_SIZE,
  windowAdjust,
  WINDOW_THRESHOLD
} = __webpack_require__(/*! ./Channel.js */ 4165);
const {
  ChannelManager,
  generateAlgorithmList,
  isWritable,
  onChannelOpenFailure,
  onCHANNEL_CLOSE
} = __webpack_require__(/*! ./utils.js */ 7601);
const bufferParser = makeBufferParser();
const sigParser = makeBufferParser();
const RE_OPENSSH = /^OpenSSH_(?:(?![0-4])\d)|(?:\d{2,})/;
const noop = err => {};
class Client extends EventEmitter {
  constructor() {
    super();
    this.config = {
      host: undefined,
      port: undefined,
      localAddress: undefined,
      localPort: undefined,
      forceIPv4: undefined,
      forceIPv6: undefined,
      keepaliveCountMax: undefined,
      keepaliveInterval: undefined,
      readyTimeout: undefined,
      ident: undefined,
      username: undefined,
      password: undefined,
      privateKey: undefined,
      tryKeyboard: undefined,
      agent: undefined,
      allowAgentFwd: undefined,
      authHandler: undefined,
      hostHashAlgo: undefined,
      hostHashCb: undefined,
      strictVendor: undefined,
      debug: undefined
    };
    this._agent = undefined;
    this._readyTimeout = undefined;
    this._chanMgr = undefined;
    this._callbacks = undefined;
    this._forwarding = undefined;
    this._forwardingUnix = undefined;
    this._acceptX11 = undefined;
    this._agentFwdEnabled = undefined;
    this._remoteVer = undefined;
    this._protocol = undefined;
    this._sock = undefined;
    this._resetKA = undefined;
  }
  connect(cfg) {
    if (this._sock && isWritable(this._sock)) {
      this.once('close', () => {
        this.connect(cfg);
      });
      this.end();
      return this;
    }
    this.config.host = cfg.hostname || cfg.host || 'localhost';
    this.config.port = cfg.port || 22;
    this.config.localAddress = typeof cfg.localAddress === 'string' ? cfg.localAddress : undefined;
    this.config.localPort = typeof cfg.localPort === 'string' || typeof cfg.localPort === 'number' ? cfg.localPort : undefined;
    this.config.forceIPv4 = cfg.forceIPv4 || false;
    this.config.forceIPv6 = cfg.forceIPv6 || false;
    this.config.keepaliveCountMax = typeof cfg.keepaliveCountMax === 'number' && cfg.keepaliveCountMax >= 0 ? cfg.keepaliveCountMax : 3;
    this.config.keepaliveInterval = typeof cfg.keepaliveInterval === 'number' && cfg.keepaliveInterval > 0 ? cfg.keepaliveInterval : 0;
    this.config.readyTimeout = typeof cfg.readyTimeout === 'number' && cfg.readyTimeout >= 0 ? cfg.readyTimeout : 20000;
    this.config.ident = typeof cfg.ident === 'string' || Buffer.isBuffer(cfg.ident) ? cfg.ident : undefined;
    const algorithms = {
      kex: undefined,
      serverHostKey: undefined,
      cs: {
        cipher: undefined,
        mac: undefined,
        compress: undefined,
        lang: []
      },
      sc: undefined
    };
    let allOfferDefaults = true;
    if (typeof cfg.algorithms === 'object' && cfg.algorithms !== null) {
      algorithms.kex = generateAlgorithmList(cfg.algorithms.kex, DEFAULT_KEX, SUPPORTED_KEX);
      if (algorithms.kex !== DEFAULT_KEX) allOfferDefaults = false;
      algorithms.serverHostKey = generateAlgorithmList(cfg.algorithms.serverHostKey, DEFAULT_SERVER_HOST_KEY, SUPPORTED_SERVER_HOST_KEY);
      if (algorithms.serverHostKey !== DEFAULT_SERVER_HOST_KEY) allOfferDefaults = false;
      algorithms.cs.cipher = generateAlgorithmList(cfg.algorithms.cipher, DEFAULT_CIPHER, SUPPORTED_CIPHER);
      if (algorithms.cs.cipher !== DEFAULT_CIPHER) allOfferDefaults = false;
      algorithms.cs.mac = generateAlgorithmList(cfg.algorithms.hmac, DEFAULT_MAC, SUPPORTED_MAC);
      if (algorithms.cs.mac !== DEFAULT_MAC) allOfferDefaults = false;
      algorithms.cs.compress = generateAlgorithmList(cfg.algorithms.compress, DEFAULT_COMPRESSION, SUPPORTED_COMPRESSION);
      if (algorithms.cs.compress !== DEFAULT_COMPRESSION) allOfferDefaults = false;
      if (!allOfferDefaults) algorithms.sc = algorithms.cs;
    }
    if (typeof cfg.username === 'string') this.config.username = cfg.username;else if (typeof cfg.user === 'string') this.config.username = cfg.user;else throw new Error('Invalid username');
    this.config.password = typeof cfg.password === 'string' ? cfg.password : undefined;
    this.config.privateKey = typeof cfg.privateKey === 'string' || Buffer.isBuffer(cfg.privateKey) ? cfg.privateKey : undefined;
    this.config.localHostname = typeof cfg.localHostname === 'string' ? cfg.localHostname : undefined;
    this.config.localUsername = typeof cfg.localUsername === 'string' ? cfg.localUsername : undefined;
    this.config.tryKeyboard = cfg.tryKeyboard === true;
    if (typeof cfg.agent === 'string' && cfg.agent.length) this.config.agent = createAgent(cfg.agent);else if (isAgent(cfg.agent)) this.config.agent = cfg.agent;else this.config.agent = undefined;
    this.config.allowAgentFwd = cfg.agentForward === true && this.config.agent !== undefined;
    let authHandler = this.config.authHandler = typeof cfg.authHandler === 'function' || Array.isArray(cfg.authHandler) ? cfg.authHandler : undefined;
    this.config.strictVendor = typeof cfg.strictVendor === 'boolean' ? cfg.strictVendor : true;
    const debug = this.config.debug = typeof cfg.debug === 'function' ? cfg.debug : undefined;
    if (cfg.agentForward === true && !this.config.allowAgentFwd) {
      throw new Error('You must set a valid agent path to allow agent forwarding');
    }
    let callbacks = this._callbacks = [];
    this._chanMgr = new ChannelManager(this);
    this._forwarding = {};
    this._forwardingUnix = {};
    this._acceptX11 = 0;
    this._agentFwdEnabled = false;
    this._agent = this.config.agent ? this.config.agent : undefined;
    this._remoteVer = undefined;
    let privateKey;
    if (this.config.privateKey) {
      privateKey = parseKey(this.config.privateKey, cfg.passphrase);
      if (privateKey instanceof Error) throw new Error(`Cannot parse privateKey: ${privateKey.message}`);
      if (Array.isArray(privateKey)) {
        // OpenSSH's newer format only stores 1 key for now
        privateKey = privateKey[0];
      }
      if (privateKey.getPrivatePEM() === null) {
        throw new Error('privateKey value does not contain a (valid) private key');
      }
    }
    let hostVerifier;
    if (typeof cfg.hostVerifier === 'function') {
      const hashCb = cfg.hostVerifier;
      let hasher;
      if (HASHES.indexOf(cfg.hostHash) !== -1) {
        // Default to old behavior of hashing on user's behalf
        hasher = createHash(cfg.hostHash);
      }
      hostVerifier = (key, verify) => {
        if (hasher) {
          hasher.update(key);
          key = hasher.digest('hex');
        }
        const ret = hashCb(key, verify);
        if (ret !== undefined) verify(ret);
      };
    }
    const sock = this._sock = cfg.sock || new Socket();
    let ready = false;
    let sawHeader = false;
    if (this._protocol) this._protocol.cleanup();
    const DEBUG_HANDLER = !debug ? undefined : (p, display, msg) => {
      debug(`Debug output from server: ${JSON.stringify(msg)}`);
    };
    const proto = this._protocol = new Protocol({
      ident: this.config.ident,
      offer: allOfferDefaults ? undefined : algorithms,
      onWrite: data => {
        if (isWritable(sock)) sock.write(data);
      },
      onError: err => {
        if (err.level === 'handshake') clearTimeout(this._readyTimeout);
        if (!proto._destruct) sock.removeAllListeners('data');
        this.emit('error', err);
        try {
          sock.end();
        } catch {}
      },
      onHeader: header => {
        sawHeader = true;
        this._remoteVer = header.versions.software;
        if (header.greeting) this.emit('greeting', header.greeting);
      },
      onHandshakeComplete: negotiated => {
        this.emit('handshake', negotiated);
        if (!ready) {
          ready = true;
          proto.service('ssh-userauth');
        }
      },
      debug,
      hostVerifier,
      messageHandlers: {
        DEBUG: DEBUG_HANDLER,
        DISCONNECT: (p, reason, desc) => {
          if (reason !== DISCONNECT_REASON.BY_APPLICATION) {
            if (!desc) {
              desc = DISCONNECT_REASON_BY_VALUE[reason];
              if (desc === undefined) desc = `Unexpected disconnection reason: ${reason}`;
            }
            const err = new Error(desc);
            err.code = reason;
            this.emit('error', err);
          }
          sock.end();
        },
        SERVICE_ACCEPT: (p, name) => {
          if (name === 'ssh-userauth') tryNextAuth();
        },
        USERAUTH_BANNER: (p, msg) => {
          this.emit('banner', msg);
        },
        USERAUTH_SUCCESS: p => {
          // Start keepalive mechanism
          resetKA();
          clearTimeout(this._readyTimeout);
          this.emit('ready');
        },
        USERAUTH_FAILURE: (p, authMethods, partialSuccess) => {
          if (curAuth.type === 'agent') {
            const pos = curAuth.agentCtx.pos();
            debug && debug(`Client: Agent key #${pos + 1} failed`);
            return tryNextAgentKey();
          }
          debug && debug(`Client: ${curAuth.type} auth failed`);
          curPartial = partialSuccess;
          curAuthsLeft = authMethods;
          tryNextAuth();
        },
        USERAUTH_PASSWD_CHANGEREQ: (p, prompt) => {
          if (curAuth.type === 'password') {
            // TODO: support a `changePrompt()` on `curAuth` that defaults to
            // emitting 'change password' as before
            this.emit('change password', prompt, newPassword => {
              proto.authPassword(this.config.username, this.config.password, newPassword);
            });
          }
        },
        USERAUTH_PK_OK: p => {
          if (curAuth.type === 'agent') {
            const key = curAuth.agentCtx.currentKey();
            proto.authPK(curAuth.username, key, (buf, cb) => {
              const options = {};
              if (key.type === 'ssh-rsa') {
                if (this._protocol._remoteHostKeyAlgorithms.includes('rsa-sha2-512')) {
                  options.hash = 'sha512';
                } else if (this._protocol._remoteHostKeyAlgorithms.includes('rsa-sha2-256')) {
                  options.hash = 'sha256';
                }
              }
              curAuth.agentCtx.sign(key, buf, options, (err, signed) => {
                if (err) {
                  err.level = 'agent';
                  this.emit('error', err);
                } else {
                  return cb(signed);
                }
                tryNextAgentKey();
              });
            });
          } else if (curAuth.type === 'publickey') {
            proto.authPK(curAuth.username, curAuth.key, (buf, cb) => {
              let signatureAlgo;
              if (curAuth.key.type === 'ssh-rsa') {
                if (this._protocol._remoteHostKeyAlgorithms.includes('rsa-sha2-512')) {
                  signatureAlgo = 'sha512';
                } else if (this._protocol._remoteHostKeyAlgorithms.includes('rsa-sha2-256')) {
                  signatureAlgo = 'sha256';
                }
              }
              const signature = curAuth.key.sign(buf, signatureAlgo);
              if (signature instanceof Error) {
                signature.message = `Error signing data with key: ${signature.message}`;
                signature.level = 'client-authentication';
                this.emit('error', signature);
                return tryNextAuth();
              }
              cb(signature);
            });
          }
        },
        USERAUTH_INFO_REQUEST: (p, name, instructions, prompts) => {
          if (curAuth.type === 'keyboard-interactive') {
            const nprompts = Array.isArray(prompts) ? prompts.length : 0;
            if (nprompts === 0) {
              debug && debug('Client: Sending automatic USERAUTH_INFO_RESPONSE');
              proto.authInfoRes();
              return;
            }
            // We sent a keyboard-interactive user authentication request and
            // now the server is sending us the prompts we need to present to
            // the user
            curAuth.prompt(name, instructions, '', prompts, answers => {
              proto.authInfoRes(answers);
            });
          }
        },
        REQUEST_SUCCESS: (p, data) => {
          if (callbacks.length) callbacks.shift()(false, data);
        },
        REQUEST_FAILURE: p => {
          if (callbacks.length) callbacks.shift()(true);
        },
        GLOBAL_REQUEST: (p, name, wantReply, data) => {
          switch (name) {
            case 'hostkeys-00@openssh.com':
              // Automatically verify keys before passing to end user
              hostKeysProve(this, data, (err, keys) => {
                if (err) return;
                this.emit('hostkeys', keys);
              });
              if (wantReply) proto.requestSuccess();
              break;
            default:
              // Auto-reject all other global requests, this can be especially
              // useful if the server is sending us dummy keepalive global
              // requests
              if (wantReply) proto.requestFailure();
          }
        },
        CHANNEL_OPEN: (p, info) => {
          // Handle incoming requests from server, typically a forwarded TCP or
          // X11 connection
          onCHANNEL_OPEN(this, info);
        },
        CHANNEL_OPEN_CONFIRMATION: (p, info) => {
          const channel = this._chanMgr.get(info.recipient);
          if (typeof channel !== 'function') return;
          const isSFTP = channel.type === 'sftp';
          const type = isSFTP ? 'session' : channel.type;
          const chanInfo = {
            type,
            incoming: {
              id: info.recipient,
              window: MAX_WINDOW,
              packetSize: PACKET_SIZE,
              state: 'open'
            },
            outgoing: {
              id: info.sender,
              window: info.window,
              packetSize: info.packetSize,
              state: 'open'
            }
          };
          const instance = isSFTP ? new SFTP(this, chanInfo, {
            debug
          }) : new Channel(this, chanInfo);
          this._chanMgr.update(info.recipient, instance);
          channel(undefined, instance);
        },
        CHANNEL_OPEN_FAILURE: (p, recipient, reason, description) => {
          const channel = this._chanMgr.get(recipient);
          if (typeof channel !== 'function') return;
          const info = {
            reason,
            description
          };
          onChannelOpenFailure(this, recipient, info, channel);
        },
        CHANNEL_DATA: (p, recipient, data) => {
          const channel = this._chanMgr.get(recipient);
          if (typeof channel !== 'object' || channel === null) return;

          // The remote party should not be sending us data if there is no
          // window space available ...
          // TODO: raise error on data with not enough window?
          if (channel.incoming.window === 0) return;
          channel.incoming.window -= data.length;
          if (channel.push(data) === false) {
            channel._waitChanDrain = true;
            return;
          }
          if (channel.incoming.window <= WINDOW_THRESHOLD) windowAdjust(channel);
        },
        CHANNEL_EXTENDED_DATA: (p, recipient, data, type) => {
          if (type !== STDERR) return;
          const channel = this._chanMgr.get(recipient);
          if (typeof channel !== 'object' || channel === null) return;

          // The remote party should not be sending us data if there is no
          // window space available ...
          // TODO: raise error on data with not enough window?
          if (channel.incoming.window === 0) return;
          channel.incoming.window -= data.length;
          if (!channel.stderr.push(data)) {
            channel._waitChanDrain = true;
            return;
          }
          if (channel.incoming.window <= WINDOW_THRESHOLD) windowAdjust(channel);
        },
        CHANNEL_WINDOW_ADJUST: (p, recipient, amount) => {
          const channel = this._chanMgr.get(recipient);
          if (typeof channel !== 'object' || channel === null) return;

          // The other side is allowing us to send `amount` more bytes of data
          channel.outgoing.window += amount;
          if (channel._waitWindow) {
            channel._waitWindow = false;
            if (channel._chunk) {
              channel._write(channel._chunk, null, channel._chunkcb);
            } else if (channel._chunkcb) {
              channel._chunkcb();
            } else if (channel._chunkErr) {
              channel.stderr._write(channel._chunkErr, null, channel._chunkcbErr);
            } else if (channel._chunkcbErr) {
              channel._chunkcbErr();
            }
          }
        },
        CHANNEL_SUCCESS: (p, recipient) => {
          const channel = this._chanMgr.get(recipient);
          if (typeof channel !== 'object' || channel === null) return;
          this._resetKA();
          if (channel._callbacks.length) channel._callbacks.shift()(false);
        },
        CHANNEL_FAILURE: (p, recipient) => {
          const channel = this._chanMgr.get(recipient);
          if (typeof channel !== 'object' || channel === null) return;
          this._resetKA();
          if (channel._callbacks.length) channel._callbacks.shift()(true);
        },
        CHANNEL_REQUEST: (p, recipient, type, wantReply, data) => {
          const channel = this._chanMgr.get(recipient);
          if (typeof channel !== 'object' || channel === null) return;
          const exit = channel._exit;
          if (exit.code !== undefined) return;
          switch (type) {
            case 'exit-status':
              channel.emit('exit', exit.code = data);
              return;
            case 'exit-signal':
              channel.emit('exit', exit.code = null, exit.signal = `SIG${data.signal}`, exit.dump = data.coreDumped, exit.desc = data.errorMessage);
              return;
          }

          // Keepalive request? OpenSSH will send one as a channel request if
          // there is a channel open

          if (wantReply) p.channelFailure(channel.outgoing.id);
        },
        CHANNEL_EOF: (p, recipient) => {
          const channel = this._chanMgr.get(recipient);
          if (typeof channel !== 'object' || channel === null) return;
          if (channel.incoming.state !== 'open') return;
          channel.incoming.state = 'eof';
          if (channel.readable) channel.push(null);
          if (channel.stderr.readable) channel.stderr.push(null);
        },
        CHANNEL_CLOSE: (p, recipient) => {
          onCHANNEL_CLOSE(this, recipient, this._chanMgr.get(recipient));
        }
      }
    });
    sock.pause();

    // TODO: check keepalive implementation
    // Keepalive-related
    const kainterval = this.config.keepaliveInterval;
    const kacountmax = this.config.keepaliveCountMax;
    let kacount = 0;
    let katimer;
    const sendKA = () => {
      if (++kacount > kacountmax) {
        clearInterval(katimer);
        if (sock.readable) {
          const err = new Error('Keepalive timeout');
          err.level = 'client-timeout';
          this.emit('error', err);
          sock.destroy();
        }
        return;
      }
      if (isWritable(sock)) {
        // Append dummy callback to keep correct callback order
        callbacks.push(resetKA);
        proto.ping();
      } else {
        clearInterval(katimer);
      }
    };
    function resetKA() {
      if (kainterval > 0) {
        kacount = 0;
        clearInterval(katimer);
        if (isWritable(sock)) katimer = setInterval(sendKA, kainterval);
      }
    }
    this._resetKA = resetKA;
    const onDone = (() => {
      let called = false;
      return () => {
        if (called) return;
        called = true;
        if (wasConnected && !sawHeader) {
          const err = makeError('Connection lost before handshake', 'protocol', true);
          this.emit('error', err);
        }
      };
    })();
    const onConnect = (() => {
      let called = false;
      return () => {
        if (called) return;
        called = true;
        wasConnected = true;
        debug && debug('Socket connected');
        this.emit('connect');
        cryptoInit.then(() => {
          proto.start();
          sock.on('data', data => {
            try {
              proto.parse(data, 0, data.length);
            } catch (ex) {
              this.emit('error', ex);
              try {
                if (isWritable(sock)) sock.end();
              } catch {}
            }
          });

          // Drain stderr if we are connection hopping using an exec stream
          if (sock.stderr && typeof sock.stderr.resume === 'function') sock.stderr.resume();
          sock.resume();
        }).catch(err => {
          this.emit('error', err);
          try {
            if (isWritable(sock)) sock.end();
          } catch {}
        });
      };
    })();
    let wasConnected = false;
    sock.on('connect', onConnect).on('timeout', () => {
      this.emit('timeout');
    }).on('error', err => {
      debug && debug(`Socket error: ${err.message}`);
      clearTimeout(this._readyTimeout);
      err.level = 'client-socket';
      this.emit('error', err);
    }).on('end', () => {
      debug && debug('Socket ended');
      onDone();
      proto.cleanup();
      clearTimeout(this._readyTimeout);
      clearInterval(katimer);
      this.emit('end');
    }).on('close', () => {
      debug && debug('Socket closed');
      onDone();
      proto.cleanup();
      clearTimeout(this._readyTimeout);
      clearInterval(katimer);
      this.emit('close');

      // Notify outstanding channel requests of disconnection ...
      const callbacks_ = callbacks;
      callbacks = this._callbacks = [];
      const err = new Error('No response from server');
      for (let i = 0; i < callbacks_.length; ++i) callbacks_[i](err);

      // Simulate error for any channels waiting to be opened
      this._chanMgr.cleanup(err);
    });

    // Begin authentication handling ===========================================
    let curAuth;
    let curPartial = null;
    let curAuthsLeft = null;
    const authsAllowed = ['none'];
    if (this.config.password !== undefined) authsAllowed.push('password');
    if (privateKey !== undefined) authsAllowed.push('publickey');
    if (this._agent !== undefined) authsAllowed.push('agent');
    if (this.config.tryKeyboard) authsAllowed.push('keyboard-interactive');
    if (privateKey !== undefined && this.config.localHostname !== undefined && this.config.localUsername !== undefined) {
      authsAllowed.push('hostbased');
    }
    if (Array.isArray(authHandler)) authHandler = makeSimpleAuthHandler(authHandler);else if (typeof authHandler !== 'function') authHandler = makeSimpleAuthHandler(authsAllowed);
    let hasSentAuth = false;
    const doNextAuth = nextAuth => {
      if (hasSentAuth) return;
      hasSentAuth = true;
      if (nextAuth === false) {
        const err = new Error('All configured authentication methods failed');
        err.level = 'client-authentication';
        this.emit('error', err);
        this.end();
        return;
      }
      if (typeof nextAuth === 'string') {
        // Remain backwards compatible with original `authHandler()` usage,
        // which only supported passing names of next method to try using data
        // from the `connect()` config object

        const type = nextAuth;
        if (authsAllowed.indexOf(type) === -1) return skipAuth(`Authentication method not allowed: ${type}`);
        const username = this.config.username;
        switch (type) {
          case 'password':
            nextAuth = {
              type,
              username,
              password: this.config.password
            };
            break;
          case 'publickey':
            nextAuth = {
              type,
              username,
              key: privateKey
            };
            break;
          case 'hostbased':
            nextAuth = {
              type,
              username,
              key: privateKey,
              localHostname: this.config.localHostname,
              localUsername: this.config.localUsername
            };
            break;
          case 'agent':
            nextAuth = {
              type,
              username,
              agentCtx: new AgentContext(this._agent)
            };
            break;
          case 'keyboard-interactive':
            nextAuth = {
              type,
              username,
              prompt: (...args) => this.emit('keyboard-interactive', ...args)
            };
            break;
          case 'none':
            nextAuth = {
              type,
              username
            };
            break;
          default:
            return skipAuth(`Skipping unsupported authentication method: ${nextAuth}`);
        }
      } else if (typeof nextAuth !== 'object' || nextAuth === null) {
        return skipAuth(`Skipping invalid authentication attempt: ${nextAuth}`);
      } else {
        const username = nextAuth.username;
        if (typeof username !== 'string') {
          return skipAuth(`Skipping invalid authentication attempt: ${nextAuth}`);
        }
        const type = nextAuth.type;
        switch (type) {
          case 'password':
            {
              const {
                password
              } = nextAuth;
              if (typeof password !== 'string' && !Buffer.isBuffer(password)) return skipAuth('Skipping invalid password auth attempt');
              nextAuth = {
                type,
                username,
                password
              };
              break;
            }
          case 'publickey':
            {
              const key = parseKey(nextAuth.key, nextAuth.passphrase);
              if (key instanceof Error) return skipAuth('Skipping invalid key auth attempt');
              if (!key.isPrivateKey()) return skipAuth('Skipping non-private key');
              nextAuth = {
                type,
                username,
                key
              };
              break;
            }
          case 'hostbased':
            {
              const {
                localHostname,
                localUsername
              } = nextAuth;
              const key = parseKey(nextAuth.key, nextAuth.passphrase);
              if (key instanceof Error || typeof localHostname !== 'string' || typeof localUsername !== 'string') {
                return skipAuth('Skipping invalid hostbased auth attempt');
              }
              if (!key.isPrivateKey()) return skipAuth('Skipping non-private key');
              nextAuth = {
                type,
                username,
                key,
                localHostname,
                localUsername
              };
              break;
            }
          case 'agent':
            {
              let agent = nextAuth.agent;
              if (typeof agent === 'string' && agent.length) {
                agent = createAgent(agent);
              } else if (!isAgent(agent)) {
                return skipAuth(`Skipping invalid agent: ${nextAuth.agent}`);
              }
              nextAuth = {
                type,
                username,
                agentCtx: new AgentContext(agent)
              };
              break;
            }
          case 'keyboard-interactive':
            {
              const {
                prompt
              } = nextAuth;
              if (typeof prompt !== 'function') {
                return skipAuth('Skipping invalid keyboard-interactive auth attempt');
              }
              nextAuth = {
                type,
                username,
                prompt
              };
              break;
            }
          case 'none':
            nextAuth = {
              type,
              username
            };
            break;
          default:
            return skipAuth(`Skipping unsupported authentication method: ${nextAuth}`);
        }
      }
      curAuth = nextAuth;

      // Begin authentication method's process
      try {
        const username = curAuth.username;
        switch (curAuth.type) {
          case 'password':
            proto.authPassword(username, curAuth.password);
            break;
          case 'publickey':
            proto.authPK(username, curAuth.key);
            break;
          case 'hostbased':
            proto.authHostbased(username, curAuth.key, curAuth.localHostname, curAuth.localUsername, (buf, cb) => {
              const signature = curAuth.key.sign(buf);
              if (signature instanceof Error) {
                signature.message = `Error while signing with key: ${signature.message}`;
                signature.level = 'client-authentication';
                this.emit('error', signature);
                return tryNextAuth();
              }
              cb(signature);
            });
            break;
          case 'agent':
            curAuth.agentCtx.init(err => {
              if (err) {
                err.level = 'agent';
                this.emit('error', err);
                return tryNextAuth();
              }
              tryNextAgentKey();
            });
            break;
          case 'keyboard-interactive':
            proto.authKeyboard(username);
            break;
          case 'none':
            proto.authNone(username);
            break;
        }
      } finally {
        hasSentAuth = false;
      }
    };
    function skipAuth(msg) {
      debug && debug(msg);
      process.nextTick(tryNextAuth);
    }
    function tryNextAuth() {
      hasSentAuth = false;
      const auth = authHandler(curAuthsLeft, curPartial, doNextAuth);
      if (hasSentAuth || auth === undefined) return;
      doNextAuth(auth);
    }
    const tryNextAgentKey = () => {
      if (curAuth.type === 'agent') {
        const key = curAuth.agentCtx.nextKey();
        if (key === false) {
          debug && debug('Agent: No more keys left to try');
          debug && debug('Client: agent auth failed');
          tryNextAuth();
        } else {
          const pos = curAuth.agentCtx.pos();
          debug && debug(`Agent: Trying key #${pos + 1}`);
          proto.authPK(curAuth.username, key);
        }
      }
    };
    const startTimeout = () => {
      if (this.config.readyTimeout > 0) {
        this._readyTimeout = setTimeout(() => {
          const err = new Error('Timed out while waiting for handshake');
          err.level = 'client-timeout';
          this.emit('error', err);
          sock.destroy();
        }, this.config.readyTimeout);
      }
    };
    if (!cfg.sock) {
      let host = this.config.host;
      const forceIPv4 = this.config.forceIPv4;
      const forceIPv6 = this.config.forceIPv6;
      debug && debug(`Client: Trying ${host} on port ${this.config.port} ...`);
      const doConnect = () => {
        startTimeout();
        sock.connect({
          host,
          port: this.config.port,
          localAddress: this.config.localAddress,
          localPort: this.config.localPort
        });
        sock.setNoDelay(true);
        sock.setMaxListeners(0);
        sock.setTimeout(typeof cfg.timeout === 'number' ? cfg.timeout : 0);
      };
      if (!forceIPv4 && !forceIPv6 || forceIPv4 && forceIPv6) {
        doConnect();
      } else {
        dnsLookup(host, forceIPv4 ? 4 : 6, (err, address, family) => {
          if (err) {
            const type = forceIPv4 ? 'IPv4' : 'IPv6';
            const error = new Error(`Error while looking up ${type} address for '${host}': ${err}`);
            clearTimeout(this._readyTimeout);
            error.level = 'client-dns';
            this.emit('error', error);
            this.emit('close');
            return;
          }
          host = address;
          doConnect();
        });
      }
    } else {
      // Custom socket passed in
      startTimeout();
      if (typeof sock.connecting === 'boolean') {
        // net.Socket

        if (!sock.connecting) {
          // Already connected
          onConnect();
        }
      } else {
        // Assume socket/stream is already "connected"
        onConnect();
      }
    }
    return this;
  }
  end() {
    if (this._sock && isWritable(this._sock)) {
      this._protocol.disconnect(DISCONNECT_REASON.BY_APPLICATION);
      this._sock.end();
    }
    return this;
  }
  destroy() {
    this._sock && isWritable(this._sock) && this._sock.destroy();
    return this;
  }
  exec(cmd, opts, cb) {
    if (!this._sock || !isWritable(this._sock)) throw new Error('Not connected');
    if (typeof opts === 'function') {
      cb = opts;
      opts = {};
    }
    const extraOpts = {
      allowHalfOpen: opts.allowHalfOpen !== false
    };
    openChannel(this, 'session', extraOpts, (err, chan) => {
      if (err) {
        cb(err);
        return;
      }
      const todo = [];
      function reqCb(err) {
        if (err) {
          chan.close();
          cb(err);
          return;
        }
        if (todo.length) todo.shift()();
      }
      if (this.config.allowAgentFwd === true || opts && opts.agentForward === true && this._agent !== undefined) {
        todo.push(() => reqAgentFwd(chan, reqCb));
      }
      if (typeof opts === 'object' && opts !== null) {
        if (typeof opts.env === 'object' && opts.env !== null) reqEnv(chan, opts.env);
        if (typeof opts.pty === 'object' && opts.pty !== null || opts.pty === true) {
          todo.push(() => reqPty(chan, opts.pty, reqCb));
        }
        if (typeof opts.x11 === 'object' && opts.x11 !== null || opts.x11 === 'number' || opts.x11 === true) {
          todo.push(() => reqX11(chan, opts.x11, reqCb));
        }
      }
      todo.push(() => reqExec(chan, cmd, opts, cb));
      todo.shift()();
    });
    return this;
  }
  shell(wndopts, opts, cb) {
    if (!this._sock || !isWritable(this._sock)) throw new Error('Not connected');
    if (typeof wndopts === 'function') {
      cb = wndopts;
      wndopts = opts = undefined;
    } else if (typeof opts === 'function') {
      cb = opts;
      opts = undefined;
    }
    if (wndopts && (wndopts.x11 !== undefined || wndopts.env !== undefined)) {
      opts = wndopts;
      wndopts = undefined;
    }
    openChannel(this, 'session', (err, chan) => {
      if (err) {
        cb(err);
        return;
      }
      const todo = [];
      function reqCb(err) {
        if (err) {
          chan.close();
          cb(err);
          return;
        }
        if (todo.length) todo.shift()();
      }
      if (this.config.allowAgentFwd === true || opts && opts.agentForward === true && this._agent !== undefined) {
        todo.push(() => reqAgentFwd(chan, reqCb));
      }
      if (wndopts !== false) todo.push(() => reqPty(chan, wndopts, reqCb));
      if (typeof opts === 'object' && opts !== null) {
        if (typeof opts.env === 'object' && opts.env !== null) reqEnv(chan, opts.env);
        if (typeof opts.x11 === 'object' && opts.x11 !== null || opts.x11 === 'number' || opts.x11 === true) {
          todo.push(() => reqX11(chan, opts.x11, reqCb));
        }
      }
      todo.push(() => reqShell(chan, cb));
      todo.shift()();
    });
    return this;
  }
  subsys(name, cb) {
    if (!this._sock || !isWritable(this._sock)) throw new Error('Not connected');
    openChannel(this, 'session', (err, chan) => {
      if (err) {
        cb(err);
        return;
      }
      reqSubsystem(chan, name, (err, stream) => {
        if (err) {
          cb(err);
          return;
        }
        cb(undefined, stream);
      });
    });
    return this;
  }
  forwardIn(bindAddr, bindPort, cb) {
    if (!this._sock || !isWritable(this._sock)) throw new Error('Not connected');

    // Send a request for the server to start forwarding TCP connections to us
    // on a particular address and port

    const wantReply = typeof cb === 'function';
    if (wantReply) {
      this._callbacks.push((had_err, data) => {
        if (had_err) {
          cb(had_err !== true ? had_err : new Error(`Unable to bind to ${bindAddr}:${bindPort}`));
          return;
        }
        let realPort = bindPort;
        if (bindPort === 0 && data && data.length >= 4) {
          realPort = readUInt32BE(data, 0);
          if (!(this._protocol._compatFlags & COMPAT.DYN_RPORT_BUG)) bindPort = realPort;
        }
        this._forwarding[`${bindAddr}:${bindPort}`] = realPort;
        cb(undefined, realPort);
      });
    }
    this._protocol.tcpipForward(bindAddr, bindPort, wantReply);
    return this;
  }
  unforwardIn(bindAddr, bindPort, cb) {
    if (!this._sock || !isWritable(this._sock)) throw new Error('Not connected');

    // Send a request to stop forwarding us new connections for a particular
    // address and port

    const wantReply = typeof cb === 'function';
    if (wantReply) {
      this._callbacks.push(had_err => {
        if (had_err) {
          cb(had_err !== true ? had_err : new Error(`Unable to unbind from ${bindAddr}:${bindPort}`));
          return;
        }
        delete this._forwarding[`${bindAddr}:${bindPort}`];
        cb();
      });
    }
    this._protocol.cancelTcpipForward(bindAddr, bindPort, wantReply);
    return this;
  }
  forwardOut(srcIP, srcPort, dstIP, dstPort, cb) {
    if (!this._sock || !isWritable(this._sock)) throw new Error('Not connected');

    // Send a request to forward a TCP connection to the server

    const cfg = {
      srcIP: srcIP,
      srcPort: srcPort,
      dstIP: dstIP,
      dstPort: dstPort
    };
    if (typeof cb !== 'function') cb = noop;
    openChannel(this, 'direct-tcpip', cfg, cb);
    return this;
  }
  openssh_noMoreSessions(cb) {
    if (!this._sock || !isWritable(this._sock)) throw new Error('Not connected');
    const wantReply = typeof cb === 'function';
    if (!this.config.strictVendor || this.config.strictVendor && RE_OPENSSH.test(this._remoteVer)) {
      if (wantReply) {
        this._callbacks.push(had_err => {
          if (had_err) {
            cb(had_err !== true ? had_err : new Error('Unable to disable future sessions'));
            return;
          }
          cb();
        });
      }
      this._protocol.openssh_noMoreSessions(wantReply);
      return this;
    }
    if (!wantReply) return this;
    process.nextTick(cb, new Error('strictVendor enabled and server is not OpenSSH or compatible version'));
    return this;
  }
  openssh_forwardInStreamLocal(socketPath, cb) {
    if (!this._sock || !isWritable(this._sock)) throw new Error('Not connected');
    const wantReply = typeof cb === 'function';
    if (!this.config.strictVendor || this.config.strictVendor && RE_OPENSSH.test(this._remoteVer)) {
      if (wantReply) {
        this._callbacks.push(had_err => {
          if (had_err) {
            cb(had_err !== true ? had_err : new Error(`Unable to bind to ${socketPath}`));
            return;
          }
          this._forwardingUnix[socketPath] = true;
          cb();
        });
      }
      this._protocol.openssh_streamLocalForward(socketPath, wantReply);
      return this;
    }
    if (!wantReply) return this;
    process.nextTick(cb, new Error('strictVendor enabled and server is not OpenSSH or compatible version'));
    return this;
  }
  openssh_unforwardInStreamLocal(socketPath, cb) {
    if (!this._sock || !isWritable(this._sock)) throw new Error('Not connected');
    const wantReply = typeof cb === 'function';
    if (!this.config.strictVendor || this.config.strictVendor && RE_OPENSSH.test(this._remoteVer)) {
      if (wantReply) {
        this._callbacks.push(had_err => {
          if (had_err) {
            cb(had_err !== true ? had_err : new Error(`Unable to unbind from ${socketPath}`));
            return;
          }
          delete this._forwardingUnix[socketPath];
          cb();
        });
      }
      this._protocol.openssh_cancelStreamLocalForward(socketPath, wantReply);
      return this;
    }
    if (!wantReply) return this;
    process.nextTick(cb, new Error('strictVendor enabled and server is not OpenSSH or compatible version'));
    return this;
  }
  openssh_forwardOutStreamLocal(socketPath, cb) {
    if (!this._sock || !isWritable(this._sock)) throw new Error('Not connected');
    if (typeof cb !== 'function') cb = noop;
    if (!this.config.strictVendor || this.config.strictVendor && RE_OPENSSH.test(this._remoteVer)) {
      openChannel(this, 'direct-streamlocal@openssh.com', {
        socketPath
      }, cb);
      return this;
    }
    process.nextTick(cb, new Error('strictVendor enabled and server is not OpenSSH or compatible version'));
    return this;
  }
  sftp(cb) {
    if (!this._sock || !isWritable(this._sock)) throw new Error('Not connected');
    openChannel(this, 'sftp', (err, sftp) => {
      if (err) {
        cb(err);
        return;
      }
      reqSubsystem(sftp, 'sftp', (err, sftp_) => {
        if (err) {
          cb(err);
          return;
        }
        function removeListeners() {
          sftp.removeListener('ready', onReady);
          sftp.removeListener('error', onError);
          sftp.removeListener('exit', onExit);
          sftp.removeListener('close', onExit);
        }
        function onReady() {
          // TODO: do not remove exit/close in case remote end closes the
          // channel abruptly and we need to notify outstanding callbacks
          removeListeners();
          cb(undefined, sftp);
        }
        function onError(err) {
          removeListeners();
          cb(err);
        }
        function onExit(code, signal) {
          removeListeners();
          let msg;
          if (typeof code === 'number') msg = `Received exit code ${code} while establishing SFTP session`;else if (signal !== undefined) msg = `Received signal ${signal} while establishing SFTP session`;else msg = 'Received unexpected SFTP session termination';
          const err = new Error(msg);
          err.code = code;
          err.signal = signal;
          cb(err);
        }
        sftp.on('ready', onReady).on('error', onError).on('exit', onExit).on('close', onExit);
        sftp._init();
      });
    });
    return this;
  }
}
function openChannel(self, type, opts, cb) {
  // Ask the server to open a channel for some purpose
  // (e.g. session (sftp, exec, shell), or forwarding a TCP connection
  const initWindow = MAX_WINDOW;
  const maxPacket = PACKET_SIZE;
  if (typeof opts === 'function') {
    cb = opts;
    opts = {};
  }
  const wrapper = (err, stream) => {
    cb(err, stream);
  };
  wrapper.type = type;
  const localChan = self._chanMgr.add(wrapper);
  if (localChan === -1) {
    cb(new Error('No free channels available'));
    return;
  }
  switch (type) {
    case 'session':
    case 'sftp':
      self._protocol.session(localChan, initWindow, maxPacket);
      break;
    case 'direct-tcpip':
      self._protocol.directTcpip(localChan, initWindow, maxPacket, opts);
      break;
    case 'direct-streamlocal@openssh.com':
      self._protocol.openssh_directStreamLocal(localChan, initWindow, maxPacket, opts);
      break;
    default:
      throw new Error(`Unsupported channel type: ${type}`);
  }
}
function reqX11(chan, screen, cb) {
  // Asks server to start sending us X11 connections
  const cfg = {
    single: false,
    protocol: 'MIT-MAGIC-COOKIE-1',
    cookie: undefined,
    screen: 0
  };
  if (typeof screen === 'function') {
    cb = screen;
  } else if (typeof screen === 'object' && screen !== null) {
    if (typeof screen.single === 'boolean') cfg.single = screen.single;
    if (typeof screen.screen === 'number') cfg.screen = screen.screen;
    if (typeof screen.protocol === 'string') cfg.protocol = screen.protocol;
    if (typeof screen.cookie === 'string') cfg.cookie = screen.cookie;else if (Buffer.isBuffer(screen.cookie)) cfg.cookie = screen.cookie.hexSlice(0, screen.cookie.length);
  }
  if (cfg.cookie === undefined) cfg.cookie = randomCookie();
  const wantReply = typeof cb === 'function';
  if (chan.outgoing.state !== 'open') {
    if (wantReply) cb(new Error('Channel is not open'));
    return;
  }
  if (wantReply) {
    chan._callbacks.push(had_err => {
      if (had_err) {
        cb(had_err !== true ? had_err : new Error('Unable to request X11'));
        return;
      }
      chan._hasX11 = true;
      ++chan._client._acceptX11;
      chan.once('close', () => {
        if (chan._client._acceptX11) --chan._client._acceptX11;
      });
      cb();
    });
  }
  chan._client._protocol.x11Forward(chan.outgoing.id, cfg, wantReply);
}
function reqPty(chan, opts, cb) {
  let rows = 24;
  let cols = 80;
  let width = 640;
  let height = 480;
  let term = 'vt100';
  let modes = null;
  if (typeof opts === 'function') {
    cb = opts;
  } else if (typeof opts === 'object' && opts !== null) {
    if (typeof opts.rows === 'number') rows = opts.rows;
    if (typeof opts.cols === 'number') cols = opts.cols;
    if (typeof opts.width === 'number') width = opts.width;
    if (typeof opts.height === 'number') height = opts.height;
    if (typeof opts.term === 'string') term = opts.term;
    if (typeof opts.modes === 'object') modes = opts.modes;
  }
  const wantReply = typeof cb === 'function';
  if (chan.outgoing.state !== 'open') {
    if (wantReply) cb(new Error('Channel is not open'));
    return;
  }
  if (wantReply) {
    chan._callbacks.push(had_err => {
      if (had_err) {
        cb(had_err !== true ? had_err : new Error('Unable to request a pseudo-terminal'));
        return;
      }
      cb();
    });
  }
  chan._client._protocol.pty(chan.outgoing.id, rows, cols, height, width, term, modes, wantReply);
}
function reqAgentFwd(chan, cb) {
  const wantReply = typeof cb === 'function';
  if (chan.outgoing.state !== 'open') {
    wantReply && cb(new Error('Channel is not open'));
    return;
  }
  if (chan._client._agentFwdEnabled) {
    wantReply && cb(false);
    return;
  }
  chan._client._agentFwdEnabled = true;
  chan._callbacks.push(had_err => {
    if (had_err) {
      chan._client._agentFwdEnabled = false;
      if (wantReply) {
        cb(had_err !== true ? had_err : new Error('Unable to request agent forwarding'));
      }
      return;
    }
    if (wantReply) cb();
  });
  chan._client._protocol.openssh_agentForward(chan.outgoing.id, true);
}
function reqShell(chan, cb) {
  if (chan.outgoing.state !== 'open') {
    cb(new Error('Channel is not open'));
    return;
  }
  chan._callbacks.push(had_err => {
    if (had_err) {
      cb(had_err !== true ? had_err : new Error('Unable to open shell'));
      return;
    }
    chan.subtype = 'shell';
    cb(undefined, chan);
  });
  chan._client._protocol.shell(chan.outgoing.id, true);
}
function reqExec(chan, cmd, opts, cb) {
  if (chan.outgoing.state !== 'open') {
    cb(new Error('Channel is not open'));
    return;
  }
  chan._callbacks.push(had_err => {
    if (had_err) {
      cb(had_err !== true ? had_err : new Error('Unable to exec'));
      return;
    }
    chan.subtype = 'exec';
    chan.allowHalfOpen = opts.allowHalfOpen !== false;
    cb(undefined, chan);
  });
  chan._client._protocol.exec(chan.outgoing.id, cmd, true);
}
function reqEnv(chan, env) {
  if (chan.outgoing.state !== 'open') return;
  const keys = Object.keys(env || {});
  for (let i = 0; i < keys.length; ++i) {
    const key = keys[i];
    const val = env[key];
    chan._client._protocol.env(chan.outgoing.id, key, val, false);
  }
}
function reqSubsystem(chan, name, cb) {
  if (chan.outgoing.state !== 'open') {
    cb(new Error('Channel is not open'));
    return;
  }
  chan._callbacks.push(had_err => {
    if (had_err) {
      cb(had_err !== true ? had_err : new Error(`Unable to start subsystem: ${name}`));
      return;
    }
    chan.subtype = 'subsystem';
    cb(undefined, chan);
  });
  chan._client._protocol.subsystem(chan.outgoing.id, name, true);
}

// TODO: inline implementation into single call site
function onCHANNEL_OPEN(self, info) {
  // The server is trying to open a channel with us, this is usually when
  // we asked the server to forward us connections on some port and now they
  // are asking us to accept/deny an incoming connection on their side

  let localChan = -1;
  let reason;
  const accept = () => {
    const chanInfo = {
      type: info.type,
      incoming: {
        id: localChan,
        window: MAX_WINDOW,
        packetSize: PACKET_SIZE,
        state: 'open'
      },
      outgoing: {
        id: info.sender,
        window: info.window,
        packetSize: info.packetSize,
        state: 'open'
      }
    };
    const stream = new Channel(self, chanInfo);
    self._chanMgr.update(localChan, stream);
    self._protocol.channelOpenConfirm(info.sender, localChan, MAX_WINDOW, PACKET_SIZE);
    return stream;
  };
  const reject = () => {
    if (reason === undefined) {
      if (localChan === -1) reason = CHANNEL_OPEN_FAILURE.RESOURCE_SHORTAGE;else reason = CHANNEL_OPEN_FAILURE.CONNECT_FAILED;
    }
    if (localChan !== -1) self._chanMgr.remove(localChan);
    self._protocol.channelOpenFail(info.sender, reason, '');
  };
  const reserveChannel = () => {
    localChan = self._chanMgr.add();
    if (localChan === -1) {
      reason = CHANNEL_OPEN_FAILURE.RESOURCE_SHORTAGE;
      if (self.config.debug) {
        self.config.debug('Client: Automatic rejection of incoming channel open: ' + 'no channels available');
      }
    }
    return localChan !== -1;
  };
  const data = info.data;
  switch (info.type) {
    case 'forwarded-tcpip':
      {
        const val = self._forwarding[`${data.destIP}:${data.destPort}`];
        if (val !== undefined && reserveChannel()) {
          if (data.destPort === 0) data.destPort = val;
          self.emit('tcp connection', data, accept, reject);
          return;
        }
        break;
      }
    case 'forwarded-streamlocal@openssh.com':
      if (self._forwardingUnix[data.socketPath] !== undefined && reserveChannel()) {
        self.emit('unix connection', data, accept, reject);
        return;
      }
      break;
    case 'auth-agent@openssh.com':
      if (self._agentFwdEnabled && typeof self._agent.getStream === 'function' && reserveChannel()) {
        self._agent.getStream((err, stream) => {
          if (err) return reject();
          const upstream = accept();
          upstream.pipe(stream).pipe(upstream);
        });
        return;
      }
      break;
    case 'x11':
      if (self._acceptX11 !== 0 && reserveChannel()) {
        self.emit('x11', data, accept, reject);
        return;
      }
      break;
    default:
      // Automatically reject any unsupported channel open requests
      reason = CHANNEL_OPEN_FAILURE.UNKNOWN_CHANNEL_TYPE;
      if (self.config.debug) {
        self.config.debug('Client: Automatic rejection of unsupported incoming channel open ' + `type: ${info.type}`);
      }
  }
  if (reason === undefined) {
    reason = CHANNEL_OPEN_FAILURE.ADMINISTRATIVELY_PROHIBITED;
    if (self.config.debug) {
      self.config.debug('Client: Automatic rejection of unexpected incoming channel open for: ' + info.type);
    }
  }
  reject();
}
const randomCookie = (() => {
  const buffer = Buffer.allocUnsafe(16);
  return () => {
    randomFillSync(buffer, 0, 16);
    return buffer.hexSlice(0, 16);
  };
})();
function makeSimpleAuthHandler(authList) {
  if (!Array.isArray(authList)) throw new Error('authList must be an array');
  let a = 0;
  return (authsLeft, partialSuccess, cb) => {
    if (a === authList.length) return false;
    return authList[a++];
  };
}
function hostKeysProve(client, keys_, cb) {
  if (!client._sock || !isWritable(client._sock)) return;
  if (typeof cb !== 'function') cb = noop;
  if (!Array.isArray(keys_)) throw new TypeError('Invalid keys argument type');
  const keys = [];
  for (const key of keys_) {
    const parsed = parseKey(key);
    if (parsed instanceof Error) throw parsed;
    keys.push(parsed);
  }
  if (!client.config.strictVendor || client.config.strictVendor && RE_OPENSSH.test(client._remoteVer)) {
    client._callbacks.push((had_err, data) => {
      if (had_err) {
        cb(had_err !== true ? had_err : new Error('Server failed to prove supplied keys'));
        return;
      }

      // TODO: move all of this parsing/verifying logic out of the client?
      const ret = [];
      let keyIdx = 0;
      bufferParser.init(data, 0);
      while (bufferParser.avail()) {
        if (keyIdx === keys.length) break;
        const key = keys[keyIdx++];
        const keyPublic = key.getPublicSSH();
        const sigEntry = bufferParser.readString();
        sigParser.init(sigEntry, 0);
        const type = sigParser.readString(true);
        let value = sigParser.readString();
        let algo;
        if (type !== key.type) {
          if (key.type === 'ssh-rsa') {
            switch (type) {
              case 'rsa-sha2-256':
                algo = 'sha256';
                break;
              case 'rsa-sha2-512':
                algo = 'sha512';
                break;
              default:
                continue;
            }
          } else {
            continue;
          }
        }
        const sessionID = client._protocol._kex.sessionID;
        const verifyData = Buffer.allocUnsafe(4 + 29 + 4 + sessionID.length + 4 + keyPublic.length);
        let p = 0;
        writeUInt32BE(verifyData, 29, p);
        verifyData.utf8Write('hostkeys-prove-00@openssh.com', p += 4, 29);
        writeUInt32BE(verifyData, sessionID.length, p += 29);
        bufferCopy(sessionID, verifyData, 0, sessionID.length, p += 4);
        writeUInt32BE(verifyData, keyPublic.length, p += sessionID.length);
        bufferCopy(keyPublic, verifyData, 0, keyPublic.length, p += 4);
        if (!(value = sigSSHToASN1(value, type))) continue;
        if (key.verify(verifyData, value, algo) === true) ret.push(key);
      }
      sigParser.clear();
      bufferParser.clear();
      cb(null, ret);
    });
    client._protocol.openssh_hostKeysProve(keys);
    return;
  }
  process.nextTick(cb, new Error('strictVendor enabled and server is not OpenSSH or compatible version'));
}
module.exports = Client;

/***/ }),

/***/ 790:
/*!***********************************************!*\
  !*** ../node_modules/ssh2/lib/http-agents.js ***!
  \***********************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


const {
  Agent: HttpAgent
} = __webpack_require__(/*! http */ 3685);
const {
  Agent: HttpsAgent
} = __webpack_require__(/*! https */ 5687);
const {
  connect: tlsConnect
} = __webpack_require__(/*! tls */ 4404);
let Client;
for (const ctor of [HttpAgent, HttpsAgent]) {
  class SSHAgent extends ctor {
    constructor(connectCfg, agentOptions) {
      super(agentOptions);
      this._connectCfg = connectCfg;
      this._defaultSrcIP = agentOptions && agentOptions.srcIP || 'localhost';
    }
    createConnection(options, cb) {
      const srcIP = options && options.localAddress || this._defaultSrcIP;
      const srcPort = options && options.localPort || 0;
      const dstIP = options.host;
      const dstPort = options.port;
      if (Client === undefined) Client = __webpack_require__(/*! ./client.js */ 1175);
      const client = new Client();
      let triedForward = false;
      client.on('ready', () => {
        client.forwardOut(srcIP, srcPort, dstIP, dstPort, (err, stream) => {
          triedForward = true;
          if (err) {
            client.end();
            return cb(err);
          }
          stream.once('close', () => client.end());
          cb(null, decorateStream(stream, ctor, options));
        });
      }).on('error', cb).on('close', () => {
        if (!triedForward) cb(new Error('Unexpected connection close'));
      }).connect(this._connectCfg);
    }
  }
  exports[ctor === HttpAgent ? 'SSHTTPAgent' : 'SSHTTPSAgent'] = SSHAgent;
}
function noop() {}
function decorateStream(stream, ctor, options) {
  if (ctor === HttpAgent) {
    // HTTP
    stream.setKeepAlive = noop;
    stream.setNoDelay = noop;
    stream.setTimeout = noop;
    stream.ref = noop;
    stream.unref = noop;
    stream.destroySoon = stream.destroy;
    return stream;
  }

  // HTTPS
  options.socket = stream;
  const wrapped = tlsConnect(options);

  // This is a workaround for a regression in node v12.16.3+
  // https://github.com/nodejs/node/issues/35904
  const onClose = (() => {
    let called = false;
    return () => {
      if (called) return;
      called = true;
      if (stream.isPaused()) stream.resume();
    };
  })();
  // 'end' listener is needed because 'close' is not emitted in some scenarios
  // in node v12.x for some unknown reason
  wrapped.on('end', onClose).on('close', onClose);
  return wrapped;
}

/***/ }),

/***/ 9647:
/*!*****************************************!*\
  !*** ../node_modules/ssh2/lib/index.js ***!
  \*****************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


const {
  AgentProtocol,
  BaseAgent,
  createAgent,
  CygwinAgent,
  OpenSSHAgent,
  PageantAgent
} = __webpack_require__(/*! ./agent.js */ 6505);
const {
  SSHTTPAgent: HTTPAgent,
  SSHTTPSAgent: HTTPSAgent
} = __webpack_require__(/*! ./http-agents.js */ 790);
const {
  parseKey
} = __webpack_require__(/*! ./protocol/keyParser.js */ 9934);
const {
  flagsToString,
  OPEN_MODE,
  STATUS_CODE,
  stringToFlags
} = __webpack_require__(/*! ./protocol/SFTP.js */ 287);
module.exports = {
  AgentProtocol,
  BaseAgent,
  createAgent,
  Client: __webpack_require__(/*! ./client.js */ 1175),
  CygwinAgent,
  HTTPAgent,
  HTTPSAgent,
  OpenSSHAgent,
  PageantAgent,
  Server: __webpack_require__(/*! ./server.js */ 6313),
  utils: {
    parseKey,
    sftp: {
      flagsToString,
      OPEN_MODE,
      STATUS_CODE,
      stringToFlags
    }
  }
};

/***/ }),

/***/ 1551:
/*!*****************************************************!*\
  !*** ../node_modules/ssh2/lib/protocol/Protocol.js ***!
  \*****************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";
/*
  TODO:
    * Replace `buffer._pos` usage in keyParser.js and elsewhere
    * Utilize optional "writev" support when writing packets from
      cipher.encrypt()
    * Built-in support for automatic re-keying, on by default
    * Revisit receiving unexpected/unknown packets
      * Error (fatal or otherwise) or ignore or pass on to user (in some or all
        cases)?
      * Including server/client check for single directional packet types?
      * Check packets for validity or bail as early as possible?
    * Automatic re-key every 2**31 packets after the last key exchange (sent or
      received), as suggested by RFC4344. OpenSSH currently does this.
    * Automatic re-key every so many blocks depending on cipher. RFC4344:
         Because of a birthday property of block ciphers and some modes of
         operation, implementations must be careful not to encrypt too many
         blocks with the same encryption key.

         Let L be the block length (in bits) of an SSH encryption method's
         block cipher (e.g., 128 for AES).  If L is at least 128, then, after
         rekeying, an SSH implementation SHOULD NOT encrypt more than 2**(L/4)
         blocks before rekeying again.  If L is at least 128, then SSH
         implementations should also attempt to force a rekey before receiving
         more than 2**(L/4) blocks.  If L is less than 128 (which is the case
         for older ciphers such as 3DES, Blowfish, CAST-128, and IDEA), then,
         although it may be too expensive to rekey every 2**(L/4) blocks, it
         is still advisable for SSH implementations to follow the original
         recommendation in [RFC4253]: rekey at least once for every gigabyte
         of transmitted data.

         Note that if L is less than or equal to 128, then the recommendation
         in this subsection supersedes the recommendation in Section 3.1.  If
         an SSH implementation uses a block cipher with a larger block size
         (e.g., Rijndael with 256-bit blocks), then the recommendations in
         Section 3.1 may supersede the recommendations in this subsection
         (depending on the lengths of the packets).
*/



const {
  inspect
} = __webpack_require__(/*! util */ 3837);
const {
  bindingAvailable,
  NullCipher,
  NullDecipher
} = __webpack_require__(/*! ./crypto.js */ 6173);
const {
  COMPAT_CHECKS,
  DISCONNECT_REASON,
  MESSAGE,
  SIGNALS,
  TERMINAL_MODE
} = __webpack_require__(/*! ./constants.js */ 7816);
const {
  DEFAULT_KEXINIT,
  KexInit,
  kexinit,
  onKEXPayload
} = __webpack_require__(/*! ./kex.js */ 3027);
const {
  parseKey
} = __webpack_require__(/*! ./keyParser.js */ 9934);
const MESSAGE_HANDLERS = __webpack_require__(/*! ./handlers.js */ 9775);
const {
  bufferCopy,
  bufferFill,
  bufferSlice,
  convertSignature,
  sendPacket,
  writeUInt32BE
} = __webpack_require__(/*! ./utils.js */ 3549);
const {
  PacketReader,
  PacketWriter,
  ZlibPacketReader,
  ZlibPacketWriter
} = __webpack_require__(/*! ./zlib.js */ 6719);
const MODULE_VER = (__webpack_require__(/*! ../../package.json */ 2291)/* .version */ .i8);
const VALID_DISCONNECT_REASONS = new Map(Object.values(DISCONNECT_REASON).map(n => [n, 1]));
const IDENT_RAW = Buffer.from(`SSH-2.0-ssh2js${MODULE_VER}`);
const IDENT = Buffer.from(`${IDENT_RAW}\r\n`);
const MAX_LINE_LEN = 8192;
const MAX_LINES = 1024;
const PING_PAYLOAD = Buffer.from([MESSAGE.GLOBAL_REQUEST,
// "keepalive@openssh.com"
0, 0, 0, 21, 107, 101, 101, 112, 97, 108, 105, 118, 101, 64, 111, 112, 101, 110, 115, 115, 104, 46, 99, 111, 109,
// Request a reply
1]);
const NO_TERMINAL_MODES_BUFFER = Buffer.from([TERMINAL_MODE.TTY_OP_END]);
function noop() {}

/*
  Inbound:
    * kexinit payload (needed only until exchange hash is generated)
    * raw ident
    * rekey packet queue
    * expected packet (implemented as separate _parse() function?)
  Outbound:
    * kexinit payload (needed only until exchange hash is generated)
    * rekey packet queue
    * kex secret (needed only until NEWKEYS)
    * exchange hash (needed only until NEWKEYS)
    * session ID (set to exchange hash from initial handshake)
*/
class Protocol {
  constructor(config) {
    const onWrite = config.onWrite;
    if (typeof onWrite !== 'function') throw new Error('Missing onWrite function');
    this._onWrite = data => {
      onWrite(data);
    };
    const onError = config.onError;
    if (typeof onError !== 'function') throw new Error('Missing onError function');
    this._onError = err => {
      onError(err);
    };
    const debug = config.debug;
    this._debug = typeof debug === 'function' ? msg => {
      debug(msg);
    } : undefined;
    const onHeader = config.onHeader;
    this._onHeader = typeof onHeader === 'function' ? (...args) => {
      onHeader(...args);
    } : noop;
    const onPacket = config.onPacket;
    this._onPacket = typeof onPacket === 'function' ? () => {
      onPacket();
    } : noop;
    let onHandshakeComplete = config.onHandshakeComplete;
    if (typeof onHandshakeComplete !== 'function') onHandshakeComplete = noop;
    this._onHandshakeComplete = (...args) => {
      this._debug && this._debug('Handshake completed');

      // Process packets queued during a rekey where necessary
      const oldQueue = this._queue;
      if (oldQueue) {
        this._queue = undefined;
        this._debug && this._debug(`Draining outbound queue (${oldQueue.length}) ...`);
        for (let i = 0; i < oldQueue.length; ++i) {
          const data = oldQueue[i];
          // data === payload only

          // XXX: hacky
          let finalized = this._packetRW.write.finalize(data);
          if (finalized === data) {
            const packet = this._cipher.allocPacket(data.length);
            packet.set(data, 5);
            finalized = packet;
          }
          sendPacket(this, finalized);
        }
        this._debug && this._debug('... finished draining outbound queue');
      }
      onHandshakeComplete(...args);
    };
    this._queue = undefined;
    const messageHandlers = config.messageHandlers;
    if (typeof messageHandlers === 'object' && messageHandlers !== null) this._handlers = messageHandlers;else this._handlers = {};
    this._onPayload = onPayload.bind(this);
    this._server = !!config.server;
    this._banner = undefined;
    let greeting;
    if (this._server) {
      if (typeof config.hostKeys !== 'object' || config.hostKeys === null) throw new Error('Missing server host key(s)');
      this._hostKeys = config.hostKeys;

      // Greeting displayed before the ssh identification string is sent, this
      // is usually ignored by most clients
      if (typeof config.greeting === 'string' && config.greeting.length) {
        greeting = config.greeting.slice(-2) === '\r\n' ? config.greeting : `${config.greeting}\r\n`;
      }

      // Banner shown after the handshake completes, but before user
      // authentication begins
      if (typeof config.banner === 'string' && config.banner.length) {
        this._banner = config.banner.slice(-2) === '\r\n' ? config.banner : `${config.banner}\r\n`;
      }
    } else {
      this._hostKeys = undefined;
    }
    let offer = config.offer;
    if (typeof offer !== 'object' || offer === null) offer = DEFAULT_KEXINIT;else if (offer.constructor !== KexInit) offer = new KexInit(offer);
    this._kex = undefined;
    this._kexinit = undefined;
    this._offer = offer;
    this._cipher = new NullCipher(0, this._onWrite);
    this._decipher = undefined;
    this._skipNextInboundPacket = false;
    this._packetRW = {
      read: new PacketReader(),
      write: new PacketWriter(this)
    };
    this._hostVerifier = !this._server && typeof config.hostVerifier === 'function' ? config.hostVerifier : undefined;
    this._parse = parseHeader;
    this._buffer = undefined;
    this._authsQueue = [];
    this._authenticated = false;
    this._remoteIdentRaw = undefined;
    let sentIdent;
    if (typeof config.ident === 'string') {
      this._identRaw = Buffer.from(`SSH-2.0-${config.ident}`);
      sentIdent = Buffer.allocUnsafe(this._identRaw.length + 2);
      sentIdent.set(this._identRaw, 0);
      sentIdent[sentIdent.length - 2] = 13; // '\r'
      sentIdent[sentIdent.length - 1] = 10; // '\n'
    } else if (Buffer.isBuffer(config.ident)) {
      const fullIdent = Buffer.allocUnsafe(8 + config.ident.length);
      fullIdent.latin1Write('SSH-2.0-', 0, 8);
      fullIdent.set(config.ident, 8);
      this._identRaw = fullIdent;
      sentIdent = Buffer.allocUnsafe(fullIdent.length + 2);
      sentIdent.set(fullIdent, 0);
      sentIdent[sentIdent.length - 2] = 13; // '\r'
      sentIdent[sentIdent.length - 1] = 10; // '\n'
    } else {
      this._identRaw = IDENT_RAW;
      sentIdent = IDENT;
    }
    this._compatFlags = 0;
    if (this._debug) {
      if (bindingAvailable) this._debug('Custom crypto binding available');else this._debug('Custom crypto binding not available');
    }
    this._debug && this._debug(`Local ident: ${inspect(this._identRaw.toString())}`);
    this.start = () => {
      this.start = undefined;
      if (greeting) this._onWrite(greeting);
      this._onWrite(sentIdent);
    };
  }
  _destruct(reason) {
    this._packetRW.read.cleanup();
    this._packetRW.write.cleanup();
    this._cipher && this._cipher.free();
    this._decipher && this._decipher.free();
    if (typeof reason !== 'string' || reason.length === 0) reason = 'fatal error';
    this.parse = () => {
      throw new Error(`Instance unusable after ${reason}`);
    };
    this._onWrite = () => {
      throw new Error(`Instance unusable after ${reason}`);
    };
    this._destruct = undefined;
  }
  cleanup() {
    this._destruct && this._destruct();
  }
  parse(chunk, i, len) {
    while (i < len) i = this._parse(chunk, i, len);
  }

  // Protocol message API

  // ===========================================================================
  // Common/Shared =============================================================
  // ===========================================================================

  // Global
  // ------
  disconnect(reason) {
    const pktLen = 1 + 4 + 4 + 4;
    // We don't use _packetRW.write.* here because we need to make sure that
    // we always get a full packet allocated because this message can be sent
    // at any time -- even during a key exchange
    let p = this._packetRW.write.allocStartKEX;
    const packet = this._packetRW.write.alloc(pktLen, true);
    const end = p + pktLen;
    if (!VALID_DISCONNECT_REASONS.has(reason)) reason = DISCONNECT_REASON.PROTOCOL_ERROR;
    packet[p] = MESSAGE.DISCONNECT;
    writeUInt32BE(packet, reason, ++p);
    packet.fill(0, p += 4, end);
    this._debug && this._debug(`Outbound: Sending DISCONNECT (${reason})`);
    sendPacket(this, this._packetRW.write.finalize(packet, true), true);
  }
  ping() {
    const p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(PING_PAYLOAD.length);
    packet.set(PING_PAYLOAD, p);
    this._debug && this._debug('Outbound: Sending ping (GLOBAL_REQUEST: keepalive@openssh.com)');
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  rekey() {
    if (this._kexinit === undefined) {
      this._debug && this._debug('Outbound: Initiated explicit rekey');
      this._queue = [];
      kexinit(this);
    } else {
      this._debug && this._debug('Outbound: Ignoring rekey during handshake');
    }
  }

  // 'ssh-connection' service-specific
  // ---------------------------------
  requestSuccess(data) {
    let p = this._packetRW.write.allocStart;
    let packet;
    if (Buffer.isBuffer(data)) {
      packet = this._packetRW.write.alloc(1 + data.length);
      packet[p] = MESSAGE.REQUEST_SUCCESS;
      packet.set(data, ++p);
    } else {
      packet = this._packetRW.write.alloc(1);
      packet[p] = MESSAGE.REQUEST_SUCCESS;
    }
    this._debug && this._debug('Outbound: Sending REQUEST_SUCCESS');
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  requestFailure() {
    const p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1);
    packet[p] = MESSAGE.REQUEST_FAILURE;
    this._debug && this._debug('Outbound: Sending REQUEST_FAILURE');
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  channelSuccess(chan) {
    // Does not consume window space

    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4);
    packet[p] = MESSAGE.CHANNEL_SUCCESS;
    writeUInt32BE(packet, chan, ++p);
    this._debug && this._debug(`Outbound: Sending CHANNEL_SUCCESS (r:${chan})`);
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  channelFailure(chan) {
    // Does not consume window space

    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4);
    packet[p] = MESSAGE.CHANNEL_FAILURE;
    writeUInt32BE(packet, chan, ++p);
    this._debug && this._debug(`Outbound: Sending CHANNEL_FAILURE (r:${chan})`);
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  channelEOF(chan) {
    // Does not consume window space

    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4);
    packet[p] = MESSAGE.CHANNEL_EOF;
    writeUInt32BE(packet, chan, ++p);
    this._debug && this._debug(`Outbound: Sending CHANNEL_EOF (r:${chan})`);
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  channelClose(chan) {
    // Does not consume window space

    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4);
    packet[p] = MESSAGE.CHANNEL_CLOSE;
    writeUInt32BE(packet, chan, ++p);
    this._debug && this._debug(`Outbound: Sending CHANNEL_CLOSE (r:${chan})`);
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  channelWindowAdjust(chan, amount) {
    // Does not consume window space

    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + 4);
    packet[p] = MESSAGE.CHANNEL_WINDOW_ADJUST;
    writeUInt32BE(packet, chan, ++p);
    writeUInt32BE(packet, amount, p += 4);
    this._debug && this._debug(`Outbound: Sending CHANNEL_WINDOW_ADJUST (r:${chan}, ${amount})`);
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  channelData(chan, data) {
    const isBuffer = Buffer.isBuffer(data);
    const dataLen = isBuffer ? data.length : Buffer.byteLength(data);
    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + 4 + dataLen);
    packet[p] = MESSAGE.CHANNEL_DATA;
    writeUInt32BE(packet, chan, ++p);
    writeUInt32BE(packet, dataLen, p += 4);
    if (isBuffer) packet.set(data, p += 4);else packet.utf8Write(data, p += 4, dataLen);
    this._debug && this._debug(`Outbound: Sending CHANNEL_DATA (r:${chan}, ${dataLen})`);
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  channelExtData(chan, data, type) {
    const isBuffer = Buffer.isBuffer(data);
    const dataLen = isBuffer ? data.length : Buffer.byteLength(data);
    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + 4 + 4 + dataLen);
    packet[p] = MESSAGE.CHANNEL_EXTENDED_DATA;
    writeUInt32BE(packet, chan, ++p);
    writeUInt32BE(packet, type, p += 4);
    writeUInt32BE(packet, dataLen, p += 4);
    if (isBuffer) packet.set(data, p += 4);else packet.utf8Write(data, p += 4, dataLen);
    this._debug && this._debug(`Outbound: Sending CHANNEL_EXTENDED_DATA (r:${chan})`);
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  channelOpenConfirm(remote, local, initWindow, maxPacket) {
    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + 4 + 4 + 4);
    packet[p] = MESSAGE.CHANNEL_OPEN_CONFIRMATION;
    writeUInt32BE(packet, remote, ++p);
    writeUInt32BE(packet, local, p += 4);
    writeUInt32BE(packet, initWindow, p += 4);
    writeUInt32BE(packet, maxPacket, p += 4);
    this._debug && this._debug(`Outbound: Sending CHANNEL_OPEN_CONFIRMATION (r:${remote}, l:${local})`);
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  channelOpenFail(remote, reason, desc) {
    if (typeof desc !== 'string') desc = '';
    const descLen = Buffer.byteLength(desc);
    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + 4 + 4 + descLen + 4);
    packet[p] = MESSAGE.CHANNEL_OPEN_FAILURE;
    writeUInt32BE(packet, remote, ++p);
    writeUInt32BE(packet, reason, p += 4);
    writeUInt32BE(packet, descLen, p += 4);
    p += 4;
    if (descLen) {
      packet.utf8Write(desc, p, descLen);
      p += descLen;
    }
    writeUInt32BE(packet, 0, p); // Empty language tag

    this._debug && this._debug(`Outbound: Sending CHANNEL_OPEN_FAILURE (r:${remote})`);
    sendPacket(this, this._packetRW.write.finalize(packet));
  }

  // ===========================================================================
  // Client-specific ===========================================================
  // ===========================================================================

  // Global
  // ------
  service(name) {
    if (this._server) throw new Error('Client-only method called in server mode');
    const nameLen = Buffer.byteLength(name);
    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + nameLen);
    packet[p] = MESSAGE.SERVICE_REQUEST;
    writeUInt32BE(packet, nameLen, ++p);
    packet.utf8Write(name, p += 4, nameLen);
    this._debug && this._debug(`Outbound: Sending SERVICE_REQUEST (${name})`);
    sendPacket(this, this._packetRW.write.finalize(packet));
  }

  // 'ssh-userauth' service-specific
  // -------------------------------
  authPassword(username, password, newPassword) {
    if (this._server) throw new Error('Client-only method called in server mode');
    const userLen = Buffer.byteLength(username);
    const passLen = Buffer.byteLength(password);
    const newPassLen = newPassword ? Buffer.byteLength(newPassword) : 0;
    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + userLen + 4 + 14 + 4 + 8 + 1 + 4 + passLen + (newPassword ? 4 + newPassLen : 0));
    packet[p] = MESSAGE.USERAUTH_REQUEST;
    writeUInt32BE(packet, userLen, ++p);
    packet.utf8Write(username, p += 4, userLen);
    writeUInt32BE(packet, 14, p += userLen);
    packet.utf8Write('ssh-connection', p += 4, 14);
    writeUInt32BE(packet, 8, p += 14);
    packet.utf8Write('password', p += 4, 8);
    packet[p += 8] = newPassword ? 1 : 0;
    writeUInt32BE(packet, passLen, ++p);
    if (Buffer.isBuffer(password)) bufferCopy(password, packet, 0, passLen, p += 4);else packet.utf8Write(password, p += 4, passLen);
    if (newPassword) {
      writeUInt32BE(packet, newPassLen, p += passLen);
      if (Buffer.isBuffer(newPassword)) bufferCopy(newPassword, packet, 0, newPassLen, p += 4);else packet.utf8Write(newPassword, p += 4, newPassLen);
      this._debug && this._debug('Outbound: Sending USERAUTH_REQUEST (changed password)');
    } else {
      this._debug && this._debug('Outbound: Sending USERAUTH_REQUEST (password)');
    }
    this._authsQueue.push('password');
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  authPK(username, pubKey, cbSign) {
    if (this._server) throw new Error('Client-only method called in server mode');
    pubKey = parseKey(pubKey);
    if (pubKey instanceof Error) throw new Error('Invalid key');
    let keyType = pubKey.type;
    if (keyType === 'ssh-rsa') {
      for (const algo of ['rsa-sha2-512', 'rsa-sha2-256']) {
        if (this._remoteHostKeyAlgorithms.includes(algo)) {
          keyType = algo;
          break;
        }
      }
    }
    pubKey = pubKey.getPublicSSH();
    const userLen = Buffer.byteLength(username);
    const algoLen = Buffer.byteLength(keyType);
    const pubKeyLen = pubKey.length;
    const sessionID = this._kex.sessionID;
    const sesLen = sessionID.length;
    const payloadLen = (cbSign ? 4 + sesLen : 0) + 1 + 4 + userLen + 4 + 14 + 4 + 9 + 1 + 4 + algoLen + 4 + pubKeyLen;
    let packet;
    let p;
    if (cbSign) {
      packet = Buffer.allocUnsafe(payloadLen);
      p = 0;
      writeUInt32BE(packet, sesLen, p);
      packet.set(sessionID, p += 4);
      p += sesLen;
    } else {
      packet = this._packetRW.write.alloc(payloadLen);
      p = this._packetRW.write.allocStart;
    }
    packet[p] = MESSAGE.USERAUTH_REQUEST;
    writeUInt32BE(packet, userLen, ++p);
    packet.utf8Write(username, p += 4, userLen);
    writeUInt32BE(packet, 14, p += userLen);
    packet.utf8Write('ssh-connection', p += 4, 14);
    writeUInt32BE(packet, 9, p += 14);
    packet.utf8Write('publickey', p += 4, 9);
    packet[p += 9] = cbSign ? 1 : 0;
    writeUInt32BE(packet, algoLen, ++p);
    packet.utf8Write(keyType, p += 4, algoLen);
    writeUInt32BE(packet, pubKeyLen, p += algoLen);
    packet.set(pubKey, p += 4);
    if (!cbSign) {
      this._authsQueue.push('publickey');
      this._debug && this._debug('Outbound: Sending USERAUTH_REQUEST (publickey -- check)');
      sendPacket(this, this._packetRW.write.finalize(packet));
      return;
    }
    cbSign(packet, signature => {
      signature = convertSignature(signature, keyType);
      if (signature === false) throw new Error('Error while converting handshake signature');
      const sigLen = signature.length;
      p = this._packetRW.write.allocStart;
      packet = this._packetRW.write.alloc(1 + 4 + userLen + 4 + 14 + 4 + 9 + 1 + 4 + algoLen + 4 + pubKeyLen + 4 + 4 + algoLen + 4 + sigLen);

      // TODO: simply copy from original "packet" to new `packet` to avoid
      // having to write each individual field a second time?
      packet[p] = MESSAGE.USERAUTH_REQUEST;
      writeUInt32BE(packet, userLen, ++p);
      packet.utf8Write(username, p += 4, userLen);
      writeUInt32BE(packet, 14, p += userLen);
      packet.utf8Write('ssh-connection', p += 4, 14);
      writeUInt32BE(packet, 9, p += 14);
      packet.utf8Write('publickey', p += 4, 9);
      packet[p += 9] = 1;
      writeUInt32BE(packet, algoLen, ++p);
      packet.utf8Write(keyType, p += 4, algoLen);
      writeUInt32BE(packet, pubKeyLen, p += algoLen);
      packet.set(pubKey, p += 4);
      writeUInt32BE(packet, 4 + algoLen + 4 + sigLen, p += pubKeyLen);
      writeUInt32BE(packet, algoLen, p += 4);
      packet.utf8Write(keyType, p += 4, algoLen);
      writeUInt32BE(packet, sigLen, p += algoLen);
      packet.set(signature, p += 4);

      // Servers shouldn't send packet type 60 in response to signed publickey
      // attempts, but if they do, interpret as type 60.
      this._authsQueue.push('publickey');
      this._debug && this._debug('Outbound: Sending USERAUTH_REQUEST (publickey)');
      sendPacket(this, this._packetRW.write.finalize(packet));
    });
  }
  authHostbased(username, pubKey, hostname, userlocal, cbSign) {
    // TODO: Make DRY by sharing similar code with authPK()
    if (this._server) throw new Error('Client-only method called in server mode');
    pubKey = parseKey(pubKey);
    if (pubKey instanceof Error) throw new Error('Invalid key');
    const keyType = pubKey.type;
    pubKey = pubKey.getPublicSSH();
    const userLen = Buffer.byteLength(username);
    const algoLen = Buffer.byteLength(keyType);
    const pubKeyLen = pubKey.length;
    const sessionID = this._kex.sessionID;
    const sesLen = sessionID.length;
    const hostnameLen = Buffer.byteLength(hostname);
    const userlocalLen = Buffer.byteLength(userlocal);
    const data = Buffer.allocUnsafe(4 + sesLen + 1 + 4 + userLen + 4 + 14 + 4 + 9 + 4 + algoLen + 4 + pubKeyLen + 4 + hostnameLen + 4 + userlocalLen);
    let p = 0;
    writeUInt32BE(data, sesLen, p);
    data.set(sessionID, p += 4);
    data[p += sesLen] = MESSAGE.USERAUTH_REQUEST;
    writeUInt32BE(data, userLen, ++p);
    data.utf8Write(username, p += 4, userLen);
    writeUInt32BE(data, 14, p += userLen);
    data.utf8Write('ssh-connection', p += 4, 14);
    writeUInt32BE(data, 9, p += 14);
    data.utf8Write('hostbased', p += 4, 9);
    writeUInt32BE(data, algoLen, p += 9);
    data.utf8Write(keyType, p += 4, algoLen);
    writeUInt32BE(data, pubKeyLen, p += algoLen);
    data.set(pubKey, p += 4);
    writeUInt32BE(data, hostnameLen, p += pubKeyLen);
    data.utf8Write(hostname, p += 4, hostnameLen);
    writeUInt32BE(data, userlocalLen, p += hostnameLen);
    data.utf8Write(userlocal, p += 4, userlocalLen);
    cbSign(data, signature => {
      signature = convertSignature(signature, keyType);
      if (!signature) throw new Error('Error while converting handshake signature');
      const sigLen = signature.length;
      const reqDataLen = data.length - sesLen - 4;
      p = this._packetRW.write.allocStart;
      const packet = this._packetRW.write.alloc(reqDataLen + 4 + 4 + algoLen + 4 + sigLen);
      bufferCopy(data, packet, 4 + sesLen, data.length, p);
      writeUInt32BE(packet, 4 + algoLen + 4 + sigLen, p += reqDataLen);
      writeUInt32BE(packet, algoLen, p += 4);
      packet.utf8Write(keyType, p += 4, algoLen);
      writeUInt32BE(packet, sigLen, p += algoLen);
      packet.set(signature, p += 4);
      this._authsQueue.push('hostbased');
      this._debug && this._debug('Outbound: Sending USERAUTH_REQUEST (hostbased)');
      sendPacket(this, this._packetRW.write.finalize(packet));
    });
  }
  authKeyboard(username) {
    if (this._server) throw new Error('Client-only method called in server mode');
    const userLen = Buffer.byteLength(username);
    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + userLen + 4 + 14 + 4 + 20 + 4 + 4);
    packet[p] = MESSAGE.USERAUTH_REQUEST;
    writeUInt32BE(packet, userLen, ++p);
    packet.utf8Write(username, p += 4, userLen);
    writeUInt32BE(packet, 14, p += userLen);
    packet.utf8Write('ssh-connection', p += 4, 14);
    writeUInt32BE(packet, 20, p += 14);
    packet.utf8Write('keyboard-interactive', p += 4, 20);
    writeUInt32BE(packet, 0, p += 20);
    writeUInt32BE(packet, 0, p += 4);
    this._authsQueue.push('keyboard-interactive');
    this._debug && this._debug('Outbound: Sending USERAUTH_REQUEST (keyboard-interactive)');
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  authNone(username) {
    if (this._server) throw new Error('Client-only method called in server mode');
    const userLen = Buffer.byteLength(username);
    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + userLen + 4 + 14 + 4 + 4);
    packet[p] = MESSAGE.USERAUTH_REQUEST;
    writeUInt32BE(packet, userLen, ++p);
    packet.utf8Write(username, p += 4, userLen);
    writeUInt32BE(packet, 14, p += userLen);
    packet.utf8Write('ssh-connection', p += 4, 14);
    writeUInt32BE(packet, 4, p += 14);
    packet.utf8Write('none', p += 4, 4);
    this._authsQueue.push('none');
    this._debug && this._debug('Outbound: Sending USERAUTH_REQUEST (none)');
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  authInfoRes(responses) {
    if (this._server) throw new Error('Client-only method called in server mode');
    let responsesTotalLen = 0;
    let responseLens;
    if (responses) {
      responseLens = new Array(responses.length);
      for (let i = 0; i < responses.length; ++i) {
        const len = Buffer.byteLength(responses[i]);
        responseLens[i] = len;
        responsesTotalLen += 4 + len;
      }
    }
    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + responsesTotalLen);
    packet[p] = MESSAGE.USERAUTH_INFO_RESPONSE;
    if (responses) {
      writeUInt32BE(packet, responses.length, ++p);
      p += 4;
      for (let i = 0; i < responses.length; ++i) {
        const len = responseLens[i];
        writeUInt32BE(packet, len, p);
        p += 4;
        if (len) {
          packet.utf8Write(responses[i], p, len);
          p += len;
        }
      }
    } else {
      writeUInt32BE(packet, 0, ++p);
    }
    this._debug && this._debug('Outbound: Sending USERAUTH_INFO_RESPONSE');
    sendPacket(this, this._packetRW.write.finalize(packet));
  }

  // 'ssh-connection' service-specific
  // ---------------------------------
  tcpipForward(bindAddr, bindPort, wantReply) {
    if (this._server) throw new Error('Client-only method called in server mode');
    const addrLen = Buffer.byteLength(bindAddr);
    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + 13 + 1 + 4 + addrLen + 4);
    packet[p] = MESSAGE.GLOBAL_REQUEST;
    writeUInt32BE(packet, 13, ++p);
    packet.utf8Write('tcpip-forward', p += 4, 13);
    packet[p += 13] = wantReply === undefined || wantReply === true ? 1 : 0;
    writeUInt32BE(packet, addrLen, ++p);
    packet.utf8Write(bindAddr, p += 4, addrLen);
    writeUInt32BE(packet, bindPort, p += addrLen);
    this._debug && this._debug('Outbound: Sending GLOBAL_REQUEST (tcpip-forward)');
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  cancelTcpipForward(bindAddr, bindPort, wantReply) {
    if (this._server) throw new Error('Client-only method called in server mode');
    const addrLen = Buffer.byteLength(bindAddr);
    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + 20 + 1 + 4 + addrLen + 4);
    packet[p] = MESSAGE.GLOBAL_REQUEST;
    writeUInt32BE(packet, 20, ++p);
    packet.utf8Write('cancel-tcpip-forward', p += 4, 20);
    packet[p += 20] = wantReply === undefined || wantReply === true ? 1 : 0;
    writeUInt32BE(packet, addrLen, ++p);
    packet.utf8Write(bindAddr, p += 4, addrLen);
    writeUInt32BE(packet, bindPort, p += addrLen);
    this._debug && this._debug('Outbound: Sending GLOBAL_REQUEST (cancel-tcpip-forward)');
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  openssh_streamLocalForward(socketPath, wantReply) {
    if (this._server) throw new Error('Client-only method called in server mode');
    const socketPathLen = Buffer.byteLength(socketPath);
    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + 31 + 1 + 4 + socketPathLen);
    packet[p] = MESSAGE.GLOBAL_REQUEST;
    writeUInt32BE(packet, 31, ++p);
    packet.utf8Write('streamlocal-forward@openssh.com', p += 4, 31);
    packet[p += 31] = wantReply === undefined || wantReply === true ? 1 : 0;
    writeUInt32BE(packet, socketPathLen, ++p);
    packet.utf8Write(socketPath, p += 4, socketPathLen);
    this._debug && this._debug('Outbound: Sending GLOBAL_REQUEST (streamlocal-forward@openssh.com)');
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  openssh_cancelStreamLocalForward(socketPath, wantReply) {
    if (this._server) throw new Error('Client-only method called in server mode');
    const socketPathLen = Buffer.byteLength(socketPath);
    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + 38 + 1 + 4 + socketPathLen);
    packet[p] = MESSAGE.GLOBAL_REQUEST;
    writeUInt32BE(packet, 38, ++p);
    packet.utf8Write('cancel-streamlocal-forward@openssh.com', p += 4, 38);
    packet[p += 38] = wantReply === undefined || wantReply === true ? 1 : 0;
    writeUInt32BE(packet, socketPathLen, ++p);
    packet.utf8Write(socketPath, p += 4, socketPathLen);
    if (this._debug) {
      this._debug('Outbound: Sending GLOBAL_REQUEST ' + '(cancel-streamlocal-forward@openssh.com)');
    }
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  directTcpip(chan, initWindow, maxPacket, cfg) {
    if (this._server) throw new Error('Client-only method called in server mode');
    const srcLen = Buffer.byteLength(cfg.srcIP);
    const dstLen = Buffer.byteLength(cfg.dstIP);
    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + 12 + 4 + 4 + 4 + 4 + srcLen + 4 + 4 + dstLen + 4);
    packet[p] = MESSAGE.CHANNEL_OPEN;
    writeUInt32BE(packet, 12, ++p);
    packet.utf8Write('direct-tcpip', p += 4, 12);
    writeUInt32BE(packet, chan, p += 12);
    writeUInt32BE(packet, initWindow, p += 4);
    writeUInt32BE(packet, maxPacket, p += 4);
    writeUInt32BE(packet, dstLen, p += 4);
    packet.utf8Write(cfg.dstIP, p += 4, dstLen);
    writeUInt32BE(packet, cfg.dstPort, p += dstLen);
    writeUInt32BE(packet, srcLen, p += 4);
    packet.utf8Write(cfg.srcIP, p += 4, srcLen);
    writeUInt32BE(packet, cfg.srcPort, p += srcLen);
    this._debug && this._debug(`Outbound: Sending CHANNEL_OPEN (r:${chan}, direct-tcpip)`);
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  openssh_directStreamLocal(chan, initWindow, maxPacket, cfg) {
    if (this._server) throw new Error('Client-only method called in server mode');
    const pathLen = Buffer.byteLength(cfg.socketPath);
    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + 30 + 4 + 4 + 4 + 4 + pathLen + 4 + 4);
    packet[p] = MESSAGE.CHANNEL_OPEN;
    writeUInt32BE(packet, 30, ++p);
    packet.utf8Write('direct-streamlocal@openssh.com', p += 4, 30);
    writeUInt32BE(packet, chan, p += 30);
    writeUInt32BE(packet, initWindow, p += 4);
    writeUInt32BE(packet, maxPacket, p += 4);
    writeUInt32BE(packet, pathLen, p += 4);
    packet.utf8Write(cfg.socketPath, p += 4, pathLen);

    // zero-fill reserved fields (string and uint32)
    bufferFill(packet, 0, p += pathLen, p + 8);
    if (this._debug) {
      this._debug('Outbound: Sending CHANNEL_OPEN ' + `(r:${chan}, direct-streamlocal@openssh.com)`);
    }
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  openssh_noMoreSessions(wantReply) {
    if (this._server) throw new Error('Client-only method called in server mode');
    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + 28 + 1);
    packet[p] = MESSAGE.GLOBAL_REQUEST;
    writeUInt32BE(packet, 28, ++p);
    packet.utf8Write('no-more-sessions@openssh.com', p += 4, 28);
    packet[p += 28] = wantReply === undefined || wantReply === true ? 1 : 0;
    this._debug && this._debug('Outbound: Sending GLOBAL_REQUEST (no-more-sessions@openssh.com)');
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  session(chan, initWindow, maxPacket) {
    if (this._server) throw new Error('Client-only method called in server mode');

    // Does not consume window space

    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + 7 + 4 + 4 + 4);
    packet[p] = MESSAGE.CHANNEL_OPEN;
    writeUInt32BE(packet, 7, ++p);
    packet.utf8Write('session', p += 4, 7);
    writeUInt32BE(packet, chan, p += 7);
    writeUInt32BE(packet, initWindow, p += 4);
    writeUInt32BE(packet, maxPacket, p += 4);
    this._debug && this._debug(`Outbound: Sending CHANNEL_OPEN (r:${chan}, session)`);
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  windowChange(chan, rows, cols, height, width) {
    if (this._server) throw new Error('Client-only method called in server mode');

    // Does not consume window space

    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + 4 + 13 + 1 + 4 + 4 + 4 + 4);
    packet[p] = MESSAGE.CHANNEL_REQUEST;
    writeUInt32BE(packet, chan, ++p);
    writeUInt32BE(packet, 13, p += 4);
    packet.utf8Write('window-change', p += 4, 13);
    packet[p += 13] = 0;
    writeUInt32BE(packet, cols, ++p);
    writeUInt32BE(packet, rows, p += 4);
    writeUInt32BE(packet, width, p += 4);
    writeUInt32BE(packet, height, p += 4);
    this._debug && this._debug(`Outbound: Sending CHANNEL_REQUEST (r:${chan}, window-change)`);
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  pty(chan, rows, cols, height, width, term, modes, wantReply) {
    if (this._server) throw new Error('Client-only method called in server mode');

    // Does not consume window space

    if (!term || !term.length) term = 'vt100';
    if (modes && !Buffer.isBuffer(modes) && !Array.isArray(modes) && typeof modes === 'object' && modes !== null) {
      modes = modesToBytes(modes);
    }
    if (!modes || !modes.length) modes = NO_TERMINAL_MODES_BUFFER;
    const termLen = term.length;
    const modesLen = modes.length;
    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + 4 + 7 + 1 + 4 + termLen + 4 + 4 + 4 + 4 + 4 + modesLen);
    packet[p] = MESSAGE.CHANNEL_REQUEST;
    writeUInt32BE(packet, chan, ++p);
    writeUInt32BE(packet, 7, p += 4);
    packet.utf8Write('pty-req', p += 4, 7);
    packet[p += 7] = wantReply === undefined || wantReply === true ? 1 : 0;
    writeUInt32BE(packet, termLen, ++p);
    packet.utf8Write(term, p += 4, termLen);
    writeUInt32BE(packet, cols, p += termLen);
    writeUInt32BE(packet, rows, p += 4);
    writeUInt32BE(packet, width, p += 4);
    writeUInt32BE(packet, height, p += 4);
    writeUInt32BE(packet, modesLen, p += 4);
    p += 4;
    if (Array.isArray(modes)) {
      for (let i = 0; i < modesLen; ++i) packet[p++] = modes[i];
    } else if (Buffer.isBuffer(modes)) {
      packet.set(modes, p);
    }
    this._debug && this._debug(`Outbound: Sending CHANNEL_REQUEST (r:${chan}, pty-req)`);
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  shell(chan, wantReply) {
    if (this._server) throw new Error('Client-only method called in server mode');

    // Does not consume window space

    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + 4 + 5 + 1);
    packet[p] = MESSAGE.CHANNEL_REQUEST;
    writeUInt32BE(packet, chan, ++p);
    writeUInt32BE(packet, 5, p += 4);
    packet.utf8Write('shell', p += 4, 5);
    packet[p += 5] = wantReply === undefined || wantReply === true ? 1 : 0;
    this._debug && this._debug(`Outbound: Sending CHANNEL_REQUEST (r:${chan}, shell)`);
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  exec(chan, cmd, wantReply) {
    if (this._server) throw new Error('Client-only method called in server mode');

    // Does not consume window space

    const isBuf = Buffer.isBuffer(cmd);
    const cmdLen = isBuf ? cmd.length : Buffer.byteLength(cmd);
    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + 4 + 4 + 1 + 4 + cmdLen);
    packet[p] = MESSAGE.CHANNEL_REQUEST;
    writeUInt32BE(packet, chan, ++p);
    writeUInt32BE(packet, 4, p += 4);
    packet.utf8Write('exec', p += 4, 4);
    packet[p += 4] = wantReply === undefined || wantReply === true ? 1 : 0;
    writeUInt32BE(packet, cmdLen, ++p);
    if (isBuf) packet.set(cmd, p += 4);else packet.utf8Write(cmd, p += 4, cmdLen);
    this._debug && this._debug(`Outbound: Sending CHANNEL_REQUEST (r:${chan}, exec: ${cmd})`);
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  signal(chan, signal) {
    if (this._server) throw new Error('Client-only method called in server mode');

    // Does not consume window space

    const origSignal = signal;
    signal = signal.toUpperCase();
    if (signal.slice(0, 3) === 'SIG') signal = signal.slice(3);
    if (SIGNALS[signal] !== 1) throw new Error(`Invalid signal: ${origSignal}`);
    const signalLen = signal.length;
    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + 4 + 6 + 1 + 4 + signalLen);
    packet[p] = MESSAGE.CHANNEL_REQUEST;
    writeUInt32BE(packet, chan, ++p);
    writeUInt32BE(packet, 6, p += 4);
    packet.utf8Write('signal', p += 4, 6);
    packet[p += 6] = 0;
    writeUInt32BE(packet, signalLen, ++p);
    packet.utf8Write(signal, p += 4, signalLen);
    this._debug && this._debug(`Outbound: Sending CHANNEL_REQUEST (r:${chan}, signal: ${signal})`);
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  env(chan, key, val, wantReply) {
    if (this._server) throw new Error('Client-only method called in server mode');

    // Does not consume window space

    const keyLen = Buffer.byteLength(key);
    const isBuf = Buffer.isBuffer(val);
    const valLen = isBuf ? val.length : Buffer.byteLength(val);
    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + 4 + 3 + 1 + 4 + keyLen + 4 + valLen);
    packet[p] = MESSAGE.CHANNEL_REQUEST;
    writeUInt32BE(packet, chan, ++p);
    writeUInt32BE(packet, 3, p += 4);
    packet.utf8Write('env', p += 4, 3);
    packet[p += 3] = wantReply === undefined || wantReply === true ? 1 : 0;
    writeUInt32BE(packet, keyLen, ++p);
    packet.utf8Write(key, p += 4, keyLen);
    writeUInt32BE(packet, valLen, p += keyLen);
    if (isBuf) packet.set(val, p += 4);else packet.utf8Write(val, p += 4, valLen);
    this._debug && this._debug(`Outbound: Sending CHANNEL_REQUEST (r:${chan}, env: ${key}=${val})`);
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  x11Forward(chan, cfg, wantReply) {
    if (this._server) throw new Error('Client-only method called in server mode');

    // Does not consume window space

    const protocol = cfg.protocol;
    const cookie = cfg.cookie;
    const isBufProto = Buffer.isBuffer(protocol);
    const protoLen = isBufProto ? protocol.length : Buffer.byteLength(protocol);
    const isBufCookie = Buffer.isBuffer(cookie);
    const cookieLen = isBufCookie ? cookie.length : Buffer.byteLength(cookie);
    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + 4 + 7 + 1 + 1 + 4 + protoLen + 4 + cookieLen + 4);
    packet[p] = MESSAGE.CHANNEL_REQUEST;
    writeUInt32BE(packet, chan, ++p);
    writeUInt32BE(packet, 7, p += 4);
    packet.utf8Write('x11-req', p += 4, 7);
    packet[p += 7] = wantReply === undefined || wantReply === true ? 1 : 0;
    packet[++p] = cfg.single ? 1 : 0;
    writeUInt32BE(packet, protoLen, ++p);
    if (isBufProto) packet.set(protocol, p += 4);else packet.utf8Write(protocol, p += 4, protoLen);
    writeUInt32BE(packet, cookieLen, p += protoLen);
    if (isBufCookie) packet.set(cookie, p += 4);else packet.latin1Write(cookie, p += 4, cookieLen);
    writeUInt32BE(packet, cfg.screen || 0, p += cookieLen);
    this._debug && this._debug(`Outbound: Sending CHANNEL_REQUEST (r:${chan}, x11-req)`);
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  subsystem(chan, name, wantReply) {
    if (this._server) throw new Error('Client-only method called in server mode');

    // Does not consume window space
    const nameLen = Buffer.byteLength(name);
    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + 4 + 9 + 1 + 4 + nameLen);
    packet[p] = MESSAGE.CHANNEL_REQUEST;
    writeUInt32BE(packet, chan, ++p);
    writeUInt32BE(packet, 9, p += 4);
    packet.utf8Write('subsystem', p += 4, 9);
    packet[p += 9] = wantReply === undefined || wantReply === true ? 1 : 0;
    writeUInt32BE(packet, nameLen, ++p);
    packet.utf8Write(name, p += 4, nameLen);
    this._debug && this._debug(`Outbound: Sending CHANNEL_REQUEST (r:${chan}, subsystem: ${name})`);
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  openssh_agentForward(chan, wantReply) {
    if (this._server) throw new Error('Client-only method called in server mode');

    // Does not consume window space

    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + 4 + 26 + 1);
    packet[p] = MESSAGE.CHANNEL_REQUEST;
    writeUInt32BE(packet, chan, ++p);
    writeUInt32BE(packet, 26, p += 4);
    packet.utf8Write('auth-agent-req@openssh.com', p += 4, 26);
    packet[p += 26] = wantReply === undefined || wantReply === true ? 1 : 0;
    if (this._debug) {
      this._debug('Outbound: Sending CHANNEL_REQUEST ' + `(r:${chan}, auth-agent-req@openssh.com)`);
    }
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  openssh_hostKeysProve(keys) {
    if (this._server) throw new Error('Client-only method called in server mode');
    let keysTotal = 0;
    const publicKeys = [];
    for (const key of keys) {
      const publicKey = key.getPublicSSH();
      keysTotal += 4 + publicKey.length;
      publicKeys.push(publicKey);
    }
    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + 29 + 1 + keysTotal);
    packet[p] = MESSAGE.GLOBAL_REQUEST;
    writeUInt32BE(packet, 29, ++p);
    packet.utf8Write('hostkeys-prove-00@openssh.com', p += 4, 29);
    packet[p += 29] = 1; // want reply

    ++p;
    for (const buf of publicKeys) {
      writeUInt32BE(packet, buf.length, p);
      bufferCopy(buf, packet, 0, buf.length, p += 4);
      p += buf.length;
    }
    if (this._debug) {
      this._debug('Outbound: Sending GLOBAL_REQUEST (hostkeys-prove-00@openssh.com)');
    }
    sendPacket(this, this._packetRW.write.finalize(packet));
  }

  // ===========================================================================
  // Server-specific ===========================================================
  // ===========================================================================

  // Global
  // ------
  serviceAccept(svcName) {
    if (!this._server) throw new Error('Server-only method called in client mode');
    const svcNameLen = Buffer.byteLength(svcName);
    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + svcNameLen);
    packet[p] = MESSAGE.SERVICE_ACCEPT;
    writeUInt32BE(packet, svcNameLen, ++p);
    packet.utf8Write(svcName, p += 4, svcNameLen);
    this._debug && this._debug(`Outbound: Sending SERVICE_ACCEPT (${svcName})`);
    sendPacket(this, this._packetRW.write.finalize(packet));
    if (this._server && this._banner && svcName === 'ssh-userauth') {
      const banner = this._banner;
      this._banner = undefined; // Prevent banner from being displayed again
      const bannerLen = Buffer.byteLength(banner);
      p = this._packetRW.write.allocStart;
      const packet = this._packetRW.write.alloc(1 + 4 + bannerLen + 4);
      packet[p] = MESSAGE.USERAUTH_BANNER;
      writeUInt32BE(packet, bannerLen, ++p);
      packet.utf8Write(banner, p += 4, bannerLen);
      writeUInt32BE(packet, 0, p += bannerLen); // Empty language tag

      this._debug && this._debug('Outbound: Sending USERAUTH_BANNER');
      sendPacket(this, this._packetRW.write.finalize(packet));
    }
  }
  // 'ssh-connection' service-specific
  forwardedTcpip(chan, initWindow, maxPacket, cfg) {
    if (!this._server) throw new Error('Server-only method called in client mode');
    const boundAddrLen = Buffer.byteLength(cfg.boundAddr);
    const remoteAddrLen = Buffer.byteLength(cfg.remoteAddr);
    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + 15 + 4 + 4 + 4 + 4 + boundAddrLen + 4 + 4 + remoteAddrLen + 4);
    packet[p] = MESSAGE.CHANNEL_OPEN;
    writeUInt32BE(packet, 15, ++p);
    packet.utf8Write('forwarded-tcpip', p += 4, 15);
    writeUInt32BE(packet, chan, p += 15);
    writeUInt32BE(packet, initWindow, p += 4);
    writeUInt32BE(packet, maxPacket, p += 4);
    writeUInt32BE(packet, boundAddrLen, p += 4);
    packet.utf8Write(cfg.boundAddr, p += 4, boundAddrLen);
    writeUInt32BE(packet, cfg.boundPort, p += boundAddrLen);
    writeUInt32BE(packet, remoteAddrLen, p += 4);
    packet.utf8Write(cfg.remoteAddr, p += 4, remoteAddrLen);
    writeUInt32BE(packet, cfg.remotePort, p += remoteAddrLen);
    this._debug && this._debug(`Outbound: Sending CHANNEL_OPEN (r:${chan}, forwarded-tcpip)`);
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  x11(chan, initWindow, maxPacket, cfg) {
    if (!this._server) throw new Error('Server-only method called in client mode');
    const addrLen = Buffer.byteLength(cfg.originAddr);
    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + 3 + 4 + 4 + 4 + 4 + addrLen + 4);
    packet[p] = MESSAGE.CHANNEL_OPEN;
    writeUInt32BE(packet, 3, ++p);
    packet.utf8Write('x11', p += 4, 3);
    writeUInt32BE(packet, chan, p += 3);
    writeUInt32BE(packet, initWindow, p += 4);
    writeUInt32BE(packet, maxPacket, p += 4);
    writeUInt32BE(packet, addrLen, p += 4);
    packet.utf8Write(cfg.originAddr, p += 4, addrLen);
    writeUInt32BE(packet, cfg.originPort, p += addrLen);
    this._debug && this._debug(`Outbound: Sending CHANNEL_OPEN (r:${chan}, x11)`);
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  openssh_authAgent(chan, initWindow, maxPacket) {
    if (!this._server) throw new Error('Server-only method called in client mode');
    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + 22 + 4 + 4 + 4);
    packet[p] = MESSAGE.CHANNEL_OPEN;
    writeUInt32BE(packet, 22, ++p);
    packet.utf8Write('auth-agent@openssh.com', p += 4, 22);
    writeUInt32BE(packet, chan, p += 22);
    writeUInt32BE(packet, initWindow, p += 4);
    writeUInt32BE(packet, maxPacket, p += 4);
    this._debug && this._debug(`Outbound: Sending CHANNEL_OPEN (r:${chan}, auth-agent@openssh.com)`);
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  openssh_forwardedStreamLocal(chan, initWindow, maxPacket, cfg) {
    if (!this._server) throw new Error('Server-only method called in client mode');
    const pathLen = Buffer.byteLength(cfg.socketPath);
    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + 33 + 4 + 4 + 4 + 4 + pathLen + 4);
    packet[p] = MESSAGE.CHANNEL_OPEN;
    writeUInt32BE(packet, 33, ++p);
    packet.utf8Write('forwarded-streamlocal@openssh.com', p += 4, 33);
    writeUInt32BE(packet, chan, p += 33);
    writeUInt32BE(packet, initWindow, p += 4);
    writeUInt32BE(packet, maxPacket, p += 4);
    writeUInt32BE(packet, pathLen, p += 4);
    packet.utf8Write(cfg.socketPath, p += 4, pathLen);
    writeUInt32BE(packet, 0, p += pathLen);
    if (this._debug) {
      this._debug('Outbound: Sending CHANNEL_OPEN ' + `(r:${chan}, forwarded-streamlocal@openssh.com)`);
    }
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  exitStatus(chan, status) {
    if (!this._server) throw new Error('Server-only method called in client mode');

    // Does not consume window space
    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + 4 + 11 + 1 + 4);
    packet[p] = MESSAGE.CHANNEL_REQUEST;
    writeUInt32BE(packet, chan, ++p);
    writeUInt32BE(packet, 11, p += 4);
    packet.utf8Write('exit-status', p += 4, 11);
    packet[p += 11] = 0;
    writeUInt32BE(packet, status, ++p);
    this._debug && this._debug(`Outbound: Sending CHANNEL_REQUEST (r:${chan}, exit-status: ${status})`);
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  exitSignal(chan, name, coreDumped, msg) {
    if (!this._server) throw new Error('Server-only method called in client mode');

    // Does not consume window space

    const origSignal = name;
    if (typeof origSignal !== 'string' || !origSignal) throw new Error(`Invalid signal: ${origSignal}`);
    let signal = name.toUpperCase();
    if (signal.slice(0, 3) === 'SIG') signal = signal.slice(3);
    if (SIGNALS[signal] !== 1) throw new Error(`Invalid signal: ${origSignal}`);
    const nameLen = Buffer.byteLength(signal);
    const msgLen = msg ? Buffer.byteLength(msg) : 0;
    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + 4 + 11 + 1 + 4 + nameLen + 1 + 4 + msgLen + 4);
    packet[p] = MESSAGE.CHANNEL_REQUEST;
    writeUInt32BE(packet, chan, ++p);
    writeUInt32BE(packet, 11, p += 4);
    packet.utf8Write('exit-signal', p += 4, 11);
    packet[p += 11] = 0;
    writeUInt32BE(packet, nameLen, ++p);
    packet.utf8Write(signal, p += 4, nameLen);
    packet[p += nameLen] = coreDumped ? 1 : 0;
    writeUInt32BE(packet, msgLen, ++p);
    p += 4;
    if (msgLen) {
      packet.utf8Write(msg, p, msgLen);
      p += msgLen;
    }
    writeUInt32BE(packet, 0, p);
    this._debug && this._debug(`Outbound: Sending CHANNEL_REQUEST (r:${chan}, exit-signal: ${name})`);
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  // 'ssh-userauth' service-specific
  authFailure(authMethods, isPartial) {
    if (!this._server) throw new Error('Server-only method called in client mode');
    if (this._authsQueue.length === 0) throw new Error('No auth in progress');
    let methods;
    if (typeof authMethods === 'boolean') {
      isPartial = authMethods;
      authMethods = undefined;
    }
    if (authMethods) {
      methods = [];
      for (let i = 0; i < authMethods.length; ++i) {
        if (authMethods[i].toLowerCase() === 'none') continue;
        methods.push(authMethods[i]);
      }
      methods = methods.join(',');
    } else {
      methods = '';
    }
    const methodsLen = methods.length;
    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + methodsLen + 1);
    packet[p] = MESSAGE.USERAUTH_FAILURE;
    writeUInt32BE(packet, methodsLen, ++p);
    packet.utf8Write(methods, p += 4, methodsLen);
    packet[p += methodsLen] = isPartial === true ? 1 : 0;
    this._authsQueue.shift();
    this._debug && this._debug('Outbound: Sending USERAUTH_FAILURE');
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  authSuccess() {
    if (!this._server) throw new Error('Server-only method called in client mode');
    if (this._authsQueue.length === 0) throw new Error('No auth in progress');
    const p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1);
    packet[p] = MESSAGE.USERAUTH_SUCCESS;
    this._authsQueue.shift();
    this._authenticated = true;
    this._debug && this._debug('Outbound: Sending USERAUTH_SUCCESS');
    sendPacket(this, this._packetRW.write.finalize(packet));
    if (this._kex.negotiated.cs.compress === 'zlib@openssh.com') this._packetRW.read = new ZlibPacketReader();
    if (this._kex.negotiated.sc.compress === 'zlib@openssh.com') this._packetRW.write = new ZlibPacketWriter(this);
  }
  authPKOK(keyAlgo, key) {
    if (!this._server) throw new Error('Server-only method called in client mode');
    if (this._authsQueue.length === 0 || this._authsQueue[0] !== 'publickey') throw new Error('"publickey" auth not in progress');

    // TODO: support parsed key for `key`

    const keyAlgoLen = Buffer.byteLength(keyAlgo);
    const keyLen = key.length;
    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + keyAlgoLen + 4 + keyLen);
    packet[p] = MESSAGE.USERAUTH_PK_OK;
    writeUInt32BE(packet, keyAlgoLen, ++p);
    packet.utf8Write(keyAlgo, p += 4, keyAlgoLen);
    writeUInt32BE(packet, keyLen, p += keyAlgoLen);
    packet.set(key, p += 4);
    this._authsQueue.shift();
    this._debug && this._debug('Outbound: Sending USERAUTH_PK_OK');
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  authPasswdChg(prompt) {
    if (!this._server) throw new Error('Server-only method called in client mode');
    const promptLen = Buffer.byteLength(prompt);
    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + promptLen + 4);
    packet[p] = MESSAGE.USERAUTH_PASSWD_CHANGEREQ;
    writeUInt32BE(packet, promptLen, ++p);
    packet.utf8Write(prompt, p += 4, promptLen);
    writeUInt32BE(packet, 0, p += promptLen); // Empty language tag

    this._debug && this._debug('Outbound: Sending USERAUTH_PASSWD_CHANGEREQ');
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
  authInfoReq(name, instructions, prompts) {
    if (!this._server) throw new Error('Server-only method called in client mode');
    let promptsLen = 0;
    const nameLen = name ? Buffer.byteLength(name) : 0;
    const instrLen = instructions ? Buffer.byteLength(instructions) : 0;
    for (let i = 0; i < prompts.length; ++i) promptsLen += 4 + Buffer.byteLength(prompts[i].prompt) + 1;
    let p = this._packetRW.write.allocStart;
    const packet = this._packetRW.write.alloc(1 + 4 + nameLen + 4 + instrLen + 4 + 4 + promptsLen);
    packet[p] = MESSAGE.USERAUTH_INFO_REQUEST;
    writeUInt32BE(packet, nameLen, ++p);
    p += 4;
    if (name) {
      packet.utf8Write(name, p, nameLen);
      p += nameLen;
    }
    writeUInt32BE(packet, instrLen, p);
    p += 4;
    if (instructions) {
      packet.utf8Write(instructions, p, instrLen);
      p += instrLen;
    }
    writeUInt32BE(packet, 0, p);
    writeUInt32BE(packet, prompts.length, p += 4);
    p += 4;
    for (let i = 0; i < prompts.length; ++i) {
      const prompt = prompts[i];
      const promptLen = Buffer.byteLength(prompt.prompt);
      writeUInt32BE(packet, promptLen, p);
      p += 4;
      if (promptLen) {
        packet.utf8Write(prompt.prompt, p, promptLen);
        p += promptLen;
      }
      packet[p++] = prompt.echo ? 1 : 0;
    }
    this._debug && this._debug('Outbound: Sending USERAUTH_INFO_REQUEST');
    sendPacket(this, this._packetRW.write.finalize(packet));
  }
}

// SSH-protoversion-softwareversion (SP comments) CR LF
const RE_IDENT = /^SSH-(2\.0|1\.99)-([^ ]+)(?: (.*))?$/;

// TODO: optimize this by starting n bytes from the end of this._buffer instead
// of the beginning
function parseHeader(chunk, p, len) {
  let data;
  let chunkOffset;
  if (this._buffer) {
    data = Buffer.allocUnsafe(this._buffer.length + (len - p));
    data.set(this._buffer, 0);
    if (p === 0) {
      data.set(chunk, this._buffer.length);
    } else {
      data.set(new Uint8Array(chunk.buffer, chunk.byteOffset + p, len - p), this._buffer.length);
    }
    chunkOffset = this._buffer.length;
    p = 0;
  } else {
    data = chunk;
    chunkOffset = 0;
  }
  const op = p;
  let start = p;
  let end = p;
  let needNL = false;
  let lineLen = 0;
  let lines = 0;
  for (; p < data.length; ++p) {
    const ch = data[p];
    if (ch === 13 /* '\r' */) {
      needNL = true;
      continue;
    }
    if (ch === 10 /* '\n' */) {
      if (end > start && end - start > 4 && data[start] === 83 /* 'S' */ && data[start + 1] === 83 /* 'S' */ && data[start + 2] === 72 /* 'H' */ && data[start + 3] === 45 /* '-' */) {
        const full = data.latin1Slice(op, end + 1);
        const identRaw = start === op ? full : full.slice(start - op);
        const m = RE_IDENT.exec(identRaw);
        if (!m) throw new Error('Invalid identification string');
        const header = {
          greeting: start === op ? '' : full.slice(0, start - op),
          identRaw,
          versions: {
            protocol: m[1],
            software: m[2]
          },
          comments: m[3]
        };

        // Needed during handshake
        this._remoteIdentRaw = Buffer.from(identRaw);
        this._debug && this._debug(`Remote ident: ${inspect(identRaw)}`);
        this._compatFlags = getCompatFlags(header);
        this._buffer = undefined;
        this._decipher = new NullDecipher(0, onKEXPayload.bind(this, {
          firstPacket: true
        }));
        this._parse = parsePacket;
        this._onHeader(header);
        if (!this._destruct) {
          // We disconnected inside _onHeader
          return len;
        }
        kexinit(this);
        return p + 1 - chunkOffset;
      }

      // Only allow pre-ident greetings when we're a client
      if (this._server) throw new Error('Greetings from clients not permitted');
      if (++lines > MAX_LINES) throw new Error('Max greeting lines exceeded');
      needNL = false;
      start = p + 1;
      lineLen = 0;
    } else if (needNL) {
      throw new Error('Invalid header: expected newline');
    } else if (++lineLen >= MAX_LINE_LEN) {
      throw new Error('Header line too long');
    }
    end = p;
  }
  if (!this._buffer) this._buffer = bufferSlice(data, op);
  return p - chunkOffset;
}
function parsePacket(chunk, p, len) {
  return this._decipher.decrypt(chunk, p, len);
}
function onPayload(payload) {
  // XXX: move this to the Decipher implementations?

  this._onPacket();
  if (payload.length === 0) {
    this._debug && this._debug('Inbound: Skipping empty packet payload');
    return;
  }
  payload = this._packetRW.read.read(payload);
  const type = payload[0];
  if (type === MESSAGE.USERAUTH_SUCCESS && !this._server && !this._authenticated) {
    this._authenticated = true;
    if (this._kex.negotiated.cs.compress === 'zlib@openssh.com') this._packetRW.write = new ZlibPacketWriter(this);
    if (this._kex.negotiated.sc.compress === 'zlib@openssh.com') this._packetRW.read = new ZlibPacketReader();
  }
  const handler = MESSAGE_HANDLERS[type];
  if (handler === undefined) {
    this._debug && this._debug(`Inbound: Unsupported message type: ${type}`);
    return;
  }
  return handler(this, payload);
}
function getCompatFlags(header) {
  const software = header.versions.software;
  let flags = 0;
  for (const rule of COMPAT_CHECKS) {
    if (typeof rule[0] === 'string') {
      if (software === rule[0]) flags |= rule[1];
    } else if (rule[0].test(software)) {
      flags |= rule[1];
    }
  }
  return flags;
}
function modesToBytes(modes) {
  const keys = Object.keys(modes);
  const bytes = Buffer.allocUnsafe(5 * keys.length + 1);
  let b = 0;
  for (let i = 0; i < keys.length; ++i) {
    const key = keys[i];
    if (key === 'TTY_OP_END') continue;
    const opcode = TERMINAL_MODE[key];
    if (opcode === undefined) continue;
    const val = modes[key];
    if (typeof val === 'number' && isFinite(val)) {
      bytes[b++] = opcode;
      bytes[b++] = val >>> 24;
      bytes[b++] = val >>> 16;
      bytes[b++] = val >>> 8;
      bytes[b++] = val;
    }
  }
  bytes[b++] = TERMINAL_MODE.TTY_OP_END;
  if (b < bytes.length) return bufferSlice(bytes, 0, b);
  return bytes;
}
module.exports = Protocol;

/***/ }),

/***/ 287:
/*!*************************************************!*\
  !*** ../node_modules/ssh2/lib/protocol/SFTP.js ***!
  \*************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


const EventEmitter = __webpack_require__(/*! events */ 2361);
const fs = __webpack_require__(/*! fs */ 2089);
const {
  constants
} = fs;
const {
  Readable: ReadableStream,
  Writable: WritableStream
} = __webpack_require__(/*! stream */ 3978);
const {
  inherits,
  isDate
} = __webpack_require__(/*! util */ 3837);
const FastBuffer = Buffer[Symbol.species];
const {
  bufferCopy,
  bufferSlice,
  makeBufferParser,
  writeUInt32BE
} = __webpack_require__(/*! ./utils.js */ 3549);
const ATTR = {
  SIZE: 0x00000001,
  UIDGID: 0x00000002,
  PERMISSIONS: 0x00000004,
  ACMODTIME: 0x00000008,
  EXTENDED: 0x80000000
};

// Large enough to store all possible attributes
const ATTRS_BUF = Buffer.alloc(28);
const STATUS_CODE = {
  OK: 0,
  EOF: 1,
  NO_SUCH_FILE: 2,
  PERMISSION_DENIED: 3,
  FAILURE: 4,
  BAD_MESSAGE: 5,
  NO_CONNECTION: 6,
  CONNECTION_LOST: 7,
  OP_UNSUPPORTED: 8
};
const VALID_STATUS_CODES = new Map(Object.values(STATUS_CODE).map(n => [n, 1]));
const STATUS_CODE_STR = {
  [STATUS_CODE.OK]: 'No error',
  [STATUS_CODE.EOF]: 'End of file',
  [STATUS_CODE.NO_SUCH_FILE]: 'No such file or directory',
  [STATUS_CODE.PERMISSION_DENIED]: 'Permission denied',
  [STATUS_CODE.FAILURE]: 'Failure',
  [STATUS_CODE.BAD_MESSAGE]: 'Bad message',
  [STATUS_CODE.NO_CONNECTION]: 'No connection',
  [STATUS_CODE.CONNECTION_LOST]: 'Connection lost',
  [STATUS_CODE.OP_UNSUPPORTED]: 'Operation unsupported'
};
const REQUEST = {
  INIT: 1,
  OPEN: 3,
  CLOSE: 4,
  READ: 5,
  WRITE: 6,
  LSTAT: 7,
  FSTAT: 8,
  SETSTAT: 9,
  FSETSTAT: 10,
  OPENDIR: 11,
  READDIR: 12,
  REMOVE: 13,
  MKDIR: 14,
  RMDIR: 15,
  REALPATH: 16,
  STAT: 17,
  RENAME: 18,
  READLINK: 19,
  SYMLINK: 20,
  EXTENDED: 200
};
const RESPONSE = {
  VERSION: 2,
  STATUS: 101,
  HANDLE: 102,
  DATA: 103,
  NAME: 104,
  ATTRS: 105,
  EXTENDED: 201
};
const OPEN_MODE = {
  READ: 0x00000001,
  WRITE: 0x00000002,
  APPEND: 0x00000004,
  CREAT: 0x00000008,
  TRUNC: 0x00000010,
  EXCL: 0x00000020
};
const PKT_RW_OVERHEAD = 2 * 1024;
const MAX_REQID = 2 ** 32 - 1;
const CLIENT_VERSION_BUFFER = Buffer.from([0, 0, 0, 5 /* length */, REQUEST.INIT, 0, 0, 0, 3 /* version */]);

const SERVER_VERSION_BUFFER = Buffer.from([0, 0, 0, 5 /* length */, RESPONSE.VERSION, 0, 0, 0, 3 /* version */]);

const RE_OPENSSH = /^SSH-2.0-(?:OpenSSH|dropbear)/;
const OPENSSH_MAX_PKT_LEN = 256 * 1024;
const bufferParser = makeBufferParser();
const fakeStderr = {
  readable: false,
  writable: false,
  push: data => {},
  once: () => {},
  on: () => {},
  emit: () => {},
  end: () => {}
};
function noop() {}

// Emulates enough of `Channel` to be able to be used as a drop-in replacement
// in order to process incoming data with as little overhead as possible
class SFTP extends EventEmitter {
  constructor(client, chanInfo, cfg) {
    super();
    if (typeof cfg !== 'object' || !cfg) cfg = {};
    const remoteIdentRaw = client._protocol._remoteIdentRaw;
    this.server = !!cfg.server;
    this._debug = typeof cfg.debug === 'function' ? cfg.debug : undefined;
    this._isOpenSSH = remoteIdentRaw && RE_OPENSSH.test(remoteIdentRaw);
    this._version = -1;
    this._extensions = {};
    this._biOpt = cfg.biOpt;
    this._pktLenBytes = 0;
    this._pktLen = 0;
    this._pktPos = 0;
    this._pktType = 0;
    this._pktData = undefined;
    this._writeReqid = -1;
    this._requests = {};
    this._maxInPktLen = OPENSSH_MAX_PKT_LEN;
    this._maxOutPktLen = 34000;
    this._maxReadLen = (this._isOpenSSH ? OPENSSH_MAX_PKT_LEN : 34000) - PKT_RW_OVERHEAD;
    this._maxWriteLen = (this._isOpenSSH ? OPENSSH_MAX_PKT_LEN : 34000) - PKT_RW_OVERHEAD;
    this.maxOpenHandles = undefined;

    // Channel compatibility
    this._client = client;
    this._protocol = client._protocol;
    this._callbacks = [];
    this._hasX11 = false;
    this._exit = {
      code: undefined,
      signal: undefined,
      dump: undefined,
      desc: undefined
    };
    this._waitWindow = false; // SSH-level backpressure
    this._chunkcb = undefined;
    this._buffer = [];
    this.type = chanInfo.type;
    this.subtype = undefined;
    this.incoming = chanInfo.incoming;
    this.outgoing = chanInfo.outgoing;
    this.stderr = fakeStderr;
    this.readable = true;
  }

  // This handles incoming data to parse
  push(data) {
    if (data === null) {
      cleanupRequests(this);
      if (!this.readable) return;
      // No more incoming data from the remote side
      this.readable = false;
      this.emit('end');
      return;
    }
    /*
        uint32             length
        byte               type
        byte[length - 1]   data payload
    */
    let p = 0;
    while (p < data.length) {
      if (this._pktLenBytes < 4) {
        let nb = Math.min(4 - this._pktLenBytes, data.length - p);
        this._pktLenBytes += nb;
        while (nb--) this._pktLen = (this._pktLen << 8) + data[p++];
        if (this._pktLenBytes < 4) return;
        if (this._pktLen === 0) return doFatalSFTPError(this, 'Invalid packet length');
        if (this._pktLen > this._maxInPktLen) {
          const max = this._maxInPktLen;
          return doFatalSFTPError(this, `Packet length ${this._pktLen} exceeds max length of ${max}`);
        }
        if (p >= data.length) return;
      }
      if (this._pktPos < this._pktLen) {
        const nb = Math.min(this._pktLen - this._pktPos, data.length - p);
        if (p !== 0 || nb !== data.length) {
          if (nb === this._pktLen) {
            this._pkt = new FastBuffer(data.buffer, data.byteOffset + p, nb);
          } else {
            if (!this._pkt) this._pkt = Buffer.allocUnsafe(this._pktLen);
            this._pkt.set(new Uint8Array(data.buffer, data.byteOffset + p, nb), this._pktPos);
          }
        } else if (nb === this._pktLen) {
          this._pkt = data;
        } else {
          if (!this._pkt) this._pkt = Buffer.allocUnsafe(this._pktLen);
          this._pkt.set(data, this._pktPos);
        }
        p += nb;
        this._pktPos += nb;
        if (this._pktPos < this._pktLen) return;
      }
      const type = this._pkt[0];
      const payload = this._pkt;

      // Prepare for next packet
      this._pktLen = 0;
      this._pktLenBytes = 0;
      this._pkt = undefined;
      this._pktPos = 0;
      const handler = this.server ? SERVER_HANDLERS[type] : CLIENT_HANDLERS[type];
      if (!handler) return doFatalSFTPError(this, `Unknown packet type ${type}`);
      if (this._version === -1) {
        if (this.server) {
          if (type !== REQUEST.INIT) return doFatalSFTPError(this, `Expected INIT packet, got ${type}`);
        } else if (type !== RESPONSE.VERSION) {
          return doFatalSFTPError(this, `Expected VERSION packet, got ${type}`);
        }
      }
      if (handler(this, payload) === false) return;
    }
  }
  end() {
    this.destroy();
  }
  destroy() {
    if (this.outgoing.state === 'open' || this.outgoing.state === 'eof') {
      this.outgoing.state = 'closing';
      this._protocol.channelClose(this.outgoing.id);
    }
  }
  _init() {
    this._init = noop;
    if (!this.server) sendOrBuffer(this, CLIENT_VERSION_BUFFER);
  }

  // ===========================================================================
  // Client-specific ===========================================================
  // ===========================================================================
  createReadStream(path, options) {
    if (this.server) throw new Error('Client-only method called in server mode');
    return new ReadStream(this, path, options);
  }
  createWriteStream(path, options) {
    if (this.server) throw new Error('Client-only method called in server mode');
    return new WriteStream(this, path, options);
  }
  open(path, flags_, attrs, cb) {
    if (this.server) throw new Error('Client-only method called in server mode');
    if (typeof attrs === 'function') {
      cb = attrs;
      attrs = undefined;
    }
    const flags = typeof flags_ === 'number' ? flags_ : stringToFlags(flags_);
    if (flags === null) throw new Error(`Unknown flags string: ${flags_}`);
    let attrsFlags = 0;
    let attrsLen = 0;
    if (typeof attrs === 'string' || typeof attrs === 'number') attrs = {
      mode: attrs
    };
    if (typeof attrs === 'object' && attrs !== null) {
      attrs = attrsToBytes(attrs);
      attrsFlags = attrs.flags;
      attrsLen = attrs.nb;
    }

    /*
      uint32        id
      string        filename
      uint32        pflags
      ATTRS         attrs
    */
    const pathLen = Buffer.byteLength(path);
    let p = 9;
    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + pathLen + 4 + 4 + attrsLen);
    writeUInt32BE(buf, buf.length - 4, 0);
    buf[4] = REQUEST.OPEN;
    const reqid = this._writeReqid = this._writeReqid + 1 & MAX_REQID;
    writeUInt32BE(buf, reqid, 5);
    writeUInt32BE(buf, pathLen, p);
    buf.utf8Write(path, p += 4, pathLen);
    writeUInt32BE(buf, flags, p += pathLen);
    writeUInt32BE(buf, attrsFlags, p += 4);
    if (attrsLen) {
      p += 4;
      if (attrsLen === ATTRS_BUF.length) buf.set(ATTRS_BUF, p);else bufferCopy(ATTRS_BUF, buf, 0, attrsLen, p);
      p += attrsLen;
    }
    this._requests[reqid] = {
      cb
    };
    const isBuffered = sendOrBuffer(this, buf);
    this._debug && this._debug(`SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} OPEN`);
  }
  close(handle, cb) {
    if (this.server) throw new Error('Client-only method called in server mode');
    if (!Buffer.isBuffer(handle)) throw new Error('handle is not a Buffer');

    /*
      uint32     id
      string     handle
    */
    const handleLen = handle.length;
    let p = 9;
    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + handleLen);
    writeUInt32BE(buf, buf.length - 4, 0);
    buf[4] = REQUEST.CLOSE;
    const reqid = this._writeReqid = this._writeReqid + 1 & MAX_REQID;
    writeUInt32BE(buf, reqid, 5);
    writeUInt32BE(buf, handleLen, p);
    buf.set(handle, p += 4);
    this._requests[reqid] = {
      cb
    };
    const isBuffered = sendOrBuffer(this, buf);
    this._debug && this._debug(`SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} CLOSE`);
  }
  read(handle, buf, off, len, position, cb) {
    if (this.server) throw new Error('Client-only method called in server mode');
    if (!Buffer.isBuffer(handle)) throw new Error('handle is not a Buffer');
    if (!Buffer.isBuffer(buf)) throw new Error('buffer is not a Buffer');
    if (off >= buf.length) throw new Error('offset is out of bounds');
    if (off + len > buf.length) throw new Error('length extends beyond buffer');
    if (position === null) throw new Error('null position currently unsupported');
    read_(this, handle, buf, off, len, position, cb);
  }
  readData(handle, buf, off, len, position, cb) {
    // Backwards compatibility
    this.read(handle, buf, off, len, position, cb);
  }
  write(handle, buf, off, len, position, cb) {
    if (this.server) throw new Error('Client-only method called in server mode');
    if (!Buffer.isBuffer(handle)) throw new Error('handle is not a Buffer');
    if (!Buffer.isBuffer(buf)) throw new Error('buffer is not a Buffer');
    if (off > buf.length) throw new Error('offset is out of bounds');
    if (off + len > buf.length) throw new Error('length extends beyond buffer');
    if (position === null) throw new Error('null position currently unsupported');
    if (!len) {
      cb && process.nextTick(cb, undefined, 0);
      return;
    }
    const maxDataLen = this._maxWriteLen;
    const overflow = Math.max(len - maxDataLen, 0);
    const origPosition = position;
    if (overflow) len = maxDataLen;

    /*
      uint32     id
      string     handle
      uint64     offset
      string     data
    */
    const handleLen = handle.length;
    let p = 9;
    const out = Buffer.allocUnsafe(4 + 1 + 4 + 4 + handleLen + 8 + 4 + len);
    writeUInt32BE(out, out.length - 4, 0);
    out[4] = REQUEST.WRITE;
    const reqid = this._writeReqid = this._writeReqid + 1 & MAX_REQID;
    writeUInt32BE(out, reqid, 5);
    writeUInt32BE(out, handleLen, p);
    out.set(handle, p += 4);
    p += handleLen;
    for (let i = 7; i >= 0; --i) {
      out[p + i] = position & 0xFF;
      position /= 256;
    }
    writeUInt32BE(out, len, p += 8);
    bufferCopy(buf, out, off, off + len, p += 4);
    this._requests[reqid] = {
      cb: err => {
        if (err) {
          if (typeof cb === 'function') cb(err);
        } else if (overflow) {
          this.write(handle, buf, off + len, overflow, origPosition + len, cb);
        } else if (typeof cb === 'function') {
          cb(undefined, off + len);
        }
      }
    };
    const isSent = sendOrBuffer(this, out);
    if (this._debug) {
      const how = isSent ? 'Sent' : 'Buffered';
      this._debug(`SFTP: Outbound: ${how} WRITE (id:${reqid})`);
    }
  }
  writeData(handle, buf, off, len, position, cb) {
    // Backwards compatibility
    this.write(handle, buf, off, len, position, cb);
  }
  fastGet(remotePath, localPath, opts, cb) {
    if (this.server) throw new Error('Client-only method called in server mode');
    fastXfer(this, fs, remotePath, localPath, opts, cb);
  }
  fastPut(localPath, remotePath, opts, cb) {
    if (this.server) throw new Error('Client-only method called in server mode');
    fastXfer(fs, this, localPath, remotePath, opts, cb);
  }
  readFile(path, options, callback_) {
    if (this.server) throw new Error('Client-only method called in server mode');
    let callback;
    if (typeof callback_ === 'function') {
      callback = callback_;
    } else if (typeof options === 'function') {
      callback = options;
      options = undefined;
    }
    if (typeof options === 'string') options = {
      encoding: options,
      flag: 'r'
    };else if (!options) options = {
      encoding: null,
      flag: 'r'
    };else if (typeof options !== 'object') throw new TypeError('Bad arguments');
    const encoding = options.encoding;
    if (encoding && !Buffer.isEncoding(encoding)) throw new Error(`Unknown encoding: ${encoding}`);

    // First stat the file, so we know the size.
    let size;
    let buffer; // Single buffer with file data
    let buffers; // List for when size is unknown
    let pos = 0;
    let handle;

    // SFTPv3 does not support using -1 for read position, so we have to track
    // read position manually
    let bytesRead = 0;
    const flag = options.flag || 'r';
    const read = () => {
      if (size === 0) {
        buffer = Buffer.allocUnsafe(8192);
        this.read(handle, buffer, 0, 8192, bytesRead, afterRead);
      } else {
        this.read(handle, buffer, pos, size - pos, bytesRead, afterRead);
      }
    };
    const afterRead = (er, nbytes) => {
      let eof;
      if (er) {
        eof = er.code === STATUS_CODE.EOF;
        if (!eof) {
          return this.close(handle, () => {
            return callback && callback(er);
          });
        }
      } else {
        eof = false;
      }
      if (eof || size === 0 && nbytes === 0) return close();
      bytesRead += nbytes;
      pos += nbytes;
      if (size !== 0) {
        if (pos === size) close();else read();
      } else {
        // Unknown size, just read until we don't get bytes.
        buffers.push(bufferSlice(buffer, 0, nbytes));
        read();
      }
    };
    afterRead._wantEOFError = true;
    const close = () => {
      this.close(handle, er => {
        if (size === 0) {
          // Collect the data into the buffers list.
          buffer = Buffer.concat(buffers, pos);
        } else if (pos < size) {
          buffer = bufferSlice(buffer, 0, pos);
        }
        if (encoding) buffer = buffer.toString(encoding);
        return callback && callback(er, buffer);
      });
    };
    this.open(path, flag, 0o666, (er, handle_) => {
      if (er) return callback && callback(er);
      handle = handle_;
      const tryStat = (er, st) => {
        if (er) {
          // Try stat() for sftp servers that may not support fstat() for
          // whatever reason
          this.stat(path, (er_, st_) => {
            if (er_) {
              return this.close(handle, () => {
                callback && callback(er);
              });
            }
            tryStat(null, st_);
          });
          return;
        }
        size = st.size || 0;
        if (size === 0) {
          // The kernel lies about many files.
          // Go ahead and try to read some bytes.
          buffers = [];
          return read();
        }
        buffer = Buffer.allocUnsafe(size);
        read();
      };
      this.fstat(handle, tryStat);
    });
  }
  writeFile(path, data, options, callback_) {
    if (this.server) throw new Error('Client-only method called in server mode');
    let callback;
    if (typeof callback_ === 'function') {
      callback = callback_;
    } else if (typeof options === 'function') {
      callback = options;
      options = undefined;
    }
    if (typeof options === 'string') options = {
      encoding: options,
      mode: 0o666,
      flag: 'w'
    };else if (!options) options = {
      encoding: 'utf8',
      mode: 0o666,
      flag: 'w'
    };else if (typeof options !== 'object') throw new TypeError('Bad arguments');
    if (options.encoding && !Buffer.isEncoding(options.encoding)) throw new Error(`Unknown encoding: ${options.encoding}`);
    const flag = options.flag || 'w';
    this.open(path, flag, options.mode, (openErr, handle) => {
      if (openErr) {
        callback && callback(openErr);
      } else {
        const buffer = Buffer.isBuffer(data) ? data : Buffer.from('' + data, options.encoding || 'utf8');
        const position = /a/.test(flag) ? null : 0;

        // SFTPv3 does not support the notion of 'current position'
        // (null position), so we just attempt to append to the end of the file
        // instead
        if (position === null) {
          const tryStat = (er, st) => {
            if (er) {
              // Try stat() for sftp servers that may not support fstat() for
              // whatever reason
              this.stat(path, (er_, st_) => {
                if (er_) {
                  return this.close(handle, () => {
                    callback && callback(er);
                  });
                }
                tryStat(null, st_);
              });
              return;
            }
            writeAll(this, handle, buffer, 0, buffer.length, st.size, callback);
          };
          this.fstat(handle, tryStat);
          return;
        }
        writeAll(this, handle, buffer, 0, buffer.length, position, callback);
      }
    });
  }
  appendFile(path, data, options, callback_) {
    if (this.server) throw new Error('Client-only method called in server mode');
    let callback;
    if (typeof callback_ === 'function') {
      callback = callback_;
    } else if (typeof options === 'function') {
      callback = options;
      options = undefined;
    }
    if (typeof options === 'string') options = {
      encoding: options,
      mode: 0o666,
      flag: 'a'
    };else if (!options) options = {
      encoding: 'utf8',
      mode: 0o666,
      flag: 'a'
    };else if (typeof options !== 'object') throw new TypeError('Bad arguments');
    if (!options.flag) options = Object.assign({
      flag: 'a'
    }, options);
    this.writeFile(path, data, options, callback);
  }
  exists(path, cb) {
    if (this.server) throw new Error('Client-only method called in server mode');
    this.stat(path, err => {
      cb && cb(err ? false : true);
    });
  }
  unlink(filename, cb) {
    if (this.server) throw new Error('Client-only method called in server mode');

    /*
      uint32     id
      string     filename
    */
    const fnameLen = Buffer.byteLength(filename);
    let p = 9;
    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + fnameLen);
    writeUInt32BE(buf, buf.length - 4, 0);
    buf[4] = REQUEST.REMOVE;
    const reqid = this._writeReqid = this._writeReqid + 1 & MAX_REQID;
    writeUInt32BE(buf, reqid, 5);
    writeUInt32BE(buf, fnameLen, p);
    buf.utf8Write(filename, p += 4, fnameLen);
    this._requests[reqid] = {
      cb
    };
    const isBuffered = sendOrBuffer(this, buf);
    this._debug && this._debug(`SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} REMOVE`);
  }
  rename(oldPath, newPath, cb) {
    if (this.server) throw new Error('Client-only method called in server mode');

    /*
      uint32     id
      string     oldpath
      string     newpath
    */
    const oldLen = Buffer.byteLength(oldPath);
    const newLen = Buffer.byteLength(newPath);
    let p = 9;
    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + oldLen + 4 + newLen);
    writeUInt32BE(buf, buf.length - 4, 0);
    buf[4] = REQUEST.RENAME;
    const reqid = this._writeReqid = this._writeReqid + 1 & MAX_REQID;
    writeUInt32BE(buf, reqid, 5);
    writeUInt32BE(buf, oldLen, p);
    buf.utf8Write(oldPath, p += 4, oldLen);
    writeUInt32BE(buf, newLen, p += oldLen);
    buf.utf8Write(newPath, p += 4, newLen);
    this._requests[reqid] = {
      cb
    };
    const isBuffered = sendOrBuffer(this, buf);
    this._debug && this._debug(`SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} RENAME`);
  }
  mkdir(path, attrs, cb) {
    if (this.server) throw new Error('Client-only method called in server mode');
    let flags = 0;
    let attrsLen = 0;
    if (typeof attrs === 'function') {
      cb = attrs;
      attrs = undefined;
    }
    if (typeof attrs === 'object' && attrs !== null) {
      attrs = attrsToBytes(attrs);
      flags = attrs.flags;
      attrsLen = attrs.nb;
    }

    /*
      uint32     id
      string     path
      ATTRS      attrs
    */
    const pathLen = Buffer.byteLength(path);
    let p = 9;
    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + pathLen + 4 + attrsLen);
    writeUInt32BE(buf, buf.length - 4, 0);
    buf[4] = REQUEST.MKDIR;
    const reqid = this._writeReqid = this._writeReqid + 1 & MAX_REQID;
    writeUInt32BE(buf, reqid, 5);
    writeUInt32BE(buf, pathLen, p);
    buf.utf8Write(path, p += 4, pathLen);
    writeUInt32BE(buf, flags, p += pathLen);
    if (attrsLen) {
      p += 4;
      if (attrsLen === ATTRS_BUF.length) buf.set(ATTRS_BUF, p);else bufferCopy(ATTRS_BUF, buf, 0, attrsLen, p);
      p += attrsLen;
    }
    this._requests[reqid] = {
      cb
    };
    const isBuffered = sendOrBuffer(this, buf);
    this._debug && this._debug(`SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} MKDIR`);
  }
  rmdir(path, cb) {
    if (this.server) throw new Error('Client-only method called in server mode');

    /*
      uint32     id
      string     path
    */
    const pathLen = Buffer.byteLength(path);
    let p = 9;
    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + pathLen);
    writeUInt32BE(buf, buf.length - 4, 0);
    buf[4] = REQUEST.RMDIR;
    const reqid = this._writeReqid = this._writeReqid + 1 & MAX_REQID;
    writeUInt32BE(buf, reqid, 5);
    writeUInt32BE(buf, pathLen, p);
    buf.utf8Write(path, p += 4, pathLen);
    this._requests[reqid] = {
      cb
    };
    const isBuffered = sendOrBuffer(this, buf);
    this._debug && this._debug(`SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} RMDIR`);
  }
  readdir(where, opts, cb) {
    if (this.server) throw new Error('Client-only method called in server mode');
    if (typeof opts === 'function') {
      cb = opts;
      opts = {};
    }
    if (typeof opts !== 'object' || opts === null) opts = {};
    const doFilter = opts && opts.full ? false : true;
    if (!Buffer.isBuffer(where) && typeof where !== 'string') throw new Error('missing directory handle or path');
    if (typeof where === 'string') {
      const entries = [];
      let e = 0;
      const reread = (err, handle) => {
        if (err) return cb(err);
        this.readdir(handle, opts, (err, list) => {
          const eof = err && err.code === STATUS_CODE.EOF;
          if (err && !eof) return this.close(handle, () => cb(err));
          if (eof) {
            return this.close(handle, err => {
              if (err) return cb(err);
              cb(undefined, entries);
            });
          }
          for (let i = 0; i < list.length; ++i, ++e) entries[e] = list[i];
          reread(undefined, handle);
        });
      };
      return this.opendir(where, reread);
    }

    /*
      uint32     id
      string     handle
    */
    const handleLen = where.length;
    let p = 9;
    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + handleLen);
    writeUInt32BE(buf, buf.length - 4, 0);
    buf[4] = REQUEST.READDIR;
    const reqid = this._writeReqid = this._writeReqid + 1 & MAX_REQID;
    writeUInt32BE(buf, reqid, 5);
    writeUInt32BE(buf, handleLen, p);
    buf.set(where, p += 4);
    this._requests[reqid] = {
      cb: doFilter ? (err, list) => {
        if (typeof cb !== 'function') return;
        if (err) return cb(err);
        for (let i = list.length - 1; i >= 0; --i) {
          if (list[i].filename === '.' || list[i].filename === '..') list.splice(i, 1);
        }
        cb(undefined, list);
      } : cb
    };
    const isBuffered = sendOrBuffer(this, buf);
    this._debug && this._debug(`SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} READDIR`);
  }
  fstat(handle, cb) {
    if (this.server) throw new Error('Client-only method called in server mode');
    if (!Buffer.isBuffer(handle)) throw new Error('handle is not a Buffer');

    /*
      uint32     id
      string     handle
    */
    const handleLen = handle.length;
    let p = 9;
    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + handleLen);
    writeUInt32BE(buf, buf.length - 4, 0);
    buf[4] = REQUEST.FSTAT;
    const reqid = this._writeReqid = this._writeReqid + 1 & MAX_REQID;
    writeUInt32BE(buf, reqid, 5);
    writeUInt32BE(buf, handleLen, p);
    buf.set(handle, p += 4);
    this._requests[reqid] = {
      cb
    };
    const isBuffered = sendOrBuffer(this, buf);
    this._debug && this._debug(`SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} FSTAT`);
  }
  stat(path, cb) {
    if (this.server) throw new Error('Client-only method called in server mode');

    /*
      uint32     id
      string     path
    */
    const pathLen = Buffer.byteLength(path);
    let p = 9;
    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + pathLen);
    writeUInt32BE(buf, buf.length - 4, 0);
    buf[4] = REQUEST.STAT;
    const reqid = this._writeReqid = this._writeReqid + 1 & MAX_REQID;
    writeUInt32BE(buf, reqid, 5);
    writeUInt32BE(buf, pathLen, p);
    buf.utf8Write(path, p += 4, pathLen);
    this._requests[reqid] = {
      cb
    };
    const isBuffered = sendOrBuffer(this, buf);
    this._debug && this._debug(`SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} STAT`);
  }
  lstat(path, cb) {
    if (this.server) throw new Error('Client-only method called in server mode');

    /*
      uint32     id
      string     path
    */
    const pathLen = Buffer.byteLength(path);
    let p = 9;
    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + pathLen);
    writeUInt32BE(buf, buf.length - 4, 0);
    buf[4] = REQUEST.LSTAT;
    const reqid = this._writeReqid = this._writeReqid + 1 & MAX_REQID;
    writeUInt32BE(buf, reqid, 5);
    writeUInt32BE(buf, pathLen, p);
    buf.utf8Write(path, p += 4, pathLen);
    this._requests[reqid] = {
      cb
    };
    const isBuffered = sendOrBuffer(this, buf);
    this._debug && this._debug(`SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} LSTAT`);
  }
  opendir(path, cb) {
    if (this.server) throw new Error('Client-only method called in server mode');

    /*
      uint32     id
      string     path
    */
    const pathLen = Buffer.byteLength(path);
    let p = 9;
    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + pathLen);
    writeUInt32BE(buf, buf.length - 4, 0);
    buf[4] = REQUEST.OPENDIR;
    const reqid = this._writeReqid = this._writeReqid + 1 & MAX_REQID;
    writeUInt32BE(buf, reqid, 5);
    writeUInt32BE(buf, pathLen, p);
    buf.utf8Write(path, p += 4, pathLen);
    this._requests[reqid] = {
      cb
    };
    const isBuffered = sendOrBuffer(this, buf);
    this._debug && this._debug(`SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} OPENDIR`);
  }
  setstat(path, attrs, cb) {
    if (this.server) throw new Error('Client-only method called in server mode');
    let flags = 0;
    let attrsLen = 0;
    if (typeof attrs === 'object' && attrs !== null) {
      attrs = attrsToBytes(attrs);
      flags = attrs.flags;
      attrsLen = attrs.nb;
    } else if (typeof attrs === 'function') {
      cb = attrs;
    }

    /*
      uint32     id
      string     path
      ATTRS      attrs
    */
    const pathLen = Buffer.byteLength(path);
    let p = 9;
    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + pathLen + 4 + attrsLen);
    writeUInt32BE(buf, buf.length - 4, 0);
    buf[4] = REQUEST.SETSTAT;
    const reqid = this._writeReqid = this._writeReqid + 1 & MAX_REQID;
    writeUInt32BE(buf, reqid, 5);
    writeUInt32BE(buf, pathLen, p);
    buf.utf8Write(path, p += 4, pathLen);
    writeUInt32BE(buf, flags, p += pathLen);
    if (attrsLen) {
      p += 4;
      if (attrsLen === ATTRS_BUF.length) buf.set(ATTRS_BUF, p);else bufferCopy(ATTRS_BUF, buf, 0, attrsLen, p);
      p += attrsLen;
    }
    this._requests[reqid] = {
      cb
    };
    const isBuffered = sendOrBuffer(this, buf);
    this._debug && this._debug(`SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} SETSTAT`);
  }
  fsetstat(handle, attrs, cb) {
    if (this.server) throw new Error('Client-only method called in server mode');
    if (!Buffer.isBuffer(handle)) throw new Error('handle is not a Buffer');
    let flags = 0;
    let attrsLen = 0;
    if (typeof attrs === 'object' && attrs !== null) {
      attrs = attrsToBytes(attrs);
      flags = attrs.flags;
      attrsLen = attrs.nb;
    } else if (typeof attrs === 'function') {
      cb = attrs;
    }

    /*
      uint32     id
      string     handle
      ATTRS      attrs
    */
    const handleLen = handle.length;
    let p = 9;
    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + handleLen + 4 + attrsLen);
    writeUInt32BE(buf, buf.length - 4, 0);
    buf[4] = REQUEST.FSETSTAT;
    const reqid = this._writeReqid = this._writeReqid + 1 & MAX_REQID;
    writeUInt32BE(buf, reqid, 5);
    writeUInt32BE(buf, handleLen, p);
    buf.set(handle, p += 4);
    writeUInt32BE(buf, flags, p += handleLen);
    if (attrsLen) {
      p += 4;
      if (attrsLen === ATTRS_BUF.length) buf.set(ATTRS_BUF, p);else bufferCopy(ATTRS_BUF, buf, 0, attrsLen, p);
      p += attrsLen;
    }
    this._requests[reqid] = {
      cb
    };
    const isBuffered = sendOrBuffer(this, buf);
    this._debug && this._debug(`SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} FSETSTAT`);
  }
  futimes(handle, atime, mtime, cb) {
    return this.fsetstat(handle, {
      atime: toUnixTimestamp(atime),
      mtime: toUnixTimestamp(mtime)
    }, cb);
  }
  utimes(path, atime, mtime, cb) {
    return this.setstat(path, {
      atime: toUnixTimestamp(atime),
      mtime: toUnixTimestamp(mtime)
    }, cb);
  }
  fchown(handle, uid, gid, cb) {
    return this.fsetstat(handle, {
      uid: uid,
      gid: gid
    }, cb);
  }
  chown(path, uid, gid, cb) {
    return this.setstat(path, {
      uid: uid,
      gid: gid
    }, cb);
  }
  fchmod(handle, mode, cb) {
    return this.fsetstat(handle, {
      mode: mode
    }, cb);
  }
  chmod(path, mode, cb) {
    return this.setstat(path, {
      mode: mode
    }, cb);
  }
  readlink(path, cb) {
    if (this.server) throw new Error('Client-only method called in server mode');

    /*
      uint32     id
      string     path
    */
    const pathLen = Buffer.byteLength(path);
    let p = 9;
    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + pathLen);
    writeUInt32BE(buf, buf.length - 4, 0);
    buf[4] = REQUEST.READLINK;
    const reqid = this._writeReqid = this._writeReqid + 1 & MAX_REQID;
    writeUInt32BE(buf, reqid, 5);
    writeUInt32BE(buf, pathLen, p);
    buf.utf8Write(path, p += 4, pathLen);
    this._requests[reqid] = {
      cb: (err, names) => {
        if (typeof cb !== 'function') return;
        if (err) return cb(err);
        if (!names || !names.length) return cb(new Error('Response missing link info'));
        cb(undefined, names[0].filename);
      }
    };
    const isBuffered = sendOrBuffer(this, buf);
    this._debug && this._debug(`SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} READLINK`);
  }
  symlink(targetPath, linkPath, cb) {
    if (this.server) throw new Error('Client-only method called in server mode');

    /*
      uint32     id
      string     linkpath
      string     targetpath
    */
    const linkLen = Buffer.byteLength(linkPath);
    const targetLen = Buffer.byteLength(targetPath);
    let p = 9;
    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + linkLen + 4 + targetLen);
    writeUInt32BE(buf, buf.length - 4, 0);
    buf[4] = REQUEST.SYMLINK;
    const reqid = this._writeReqid = this._writeReqid + 1 & MAX_REQID;
    writeUInt32BE(buf, reqid, 5);
    if (this._isOpenSSH) {
      // OpenSSH has linkpath and targetpath positions switched
      writeUInt32BE(buf, targetLen, p);
      buf.utf8Write(targetPath, p += 4, targetLen);
      writeUInt32BE(buf, linkLen, p += targetLen);
      buf.utf8Write(linkPath, p += 4, linkLen);
    } else {
      writeUInt32BE(buf, linkLen, p);
      buf.utf8Write(linkPath, p += 4, linkLen);
      writeUInt32BE(buf, targetLen, p += linkLen);
      buf.utf8Write(targetPath, p += 4, targetLen);
    }
    this._requests[reqid] = {
      cb
    };
    const isBuffered = sendOrBuffer(this, buf);
    this._debug && this._debug(`SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} SYMLINK`);
  }
  realpath(path, cb) {
    if (this.server) throw new Error('Client-only method called in server mode');

    /*
      uint32     id
      string     path
    */
    const pathLen = Buffer.byteLength(path);
    let p = 9;
    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + pathLen);
    writeUInt32BE(buf, buf.length - 4, 0);
    buf[4] = REQUEST.REALPATH;
    const reqid = this._writeReqid = this._writeReqid + 1 & MAX_REQID;
    writeUInt32BE(buf, reqid, 5);
    writeUInt32BE(buf, pathLen, p);
    buf.utf8Write(path, p += 4, pathLen);
    this._requests[reqid] = {
      cb: (err, names) => {
        if (typeof cb !== 'function') return;
        if (err) return cb(err);
        if (!names || !names.length) return cb(new Error('Response missing path info'));
        cb(undefined, names[0].filename);
      }
    };
    const isBuffered = sendOrBuffer(this, buf);
    this._debug && this._debug(`SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} REALPATH`);
  }
  // extended requests
  ext_openssh_rename(oldPath, newPath, cb) {
    if (this.server) throw new Error('Client-only method called in server mode');
    const ext = this._extensions['posix-rename@openssh.com'];
    if (!ext || ext !== '1') throw new Error('Server does not support this extended request');

    /*
      uint32    id
      string    "posix-rename@openssh.com"
      string    oldpath
      string    newpath
    */
    const oldLen = Buffer.byteLength(oldPath);
    const newLen = Buffer.byteLength(newPath);
    let p = 9;
    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + 24 + 4 + oldLen + 4 + newLen);
    writeUInt32BE(buf, buf.length - 4, 0);
    buf[4] = REQUEST.EXTENDED;
    const reqid = this._writeReqid = this._writeReqid + 1 & MAX_REQID;
    writeUInt32BE(buf, reqid, 5);
    writeUInt32BE(buf, 24, p);
    buf.utf8Write('posix-rename@openssh.com', p += 4, 24);
    writeUInt32BE(buf, oldLen, p += 24);
    buf.utf8Write(oldPath, p += 4, oldLen);
    writeUInt32BE(buf, newLen, p += oldLen);
    buf.utf8Write(newPath, p += 4, newLen);
    this._requests[reqid] = {
      cb
    };
    const isBuffered = sendOrBuffer(this, buf);
    if (this._debug) {
      const which = isBuffered ? 'Buffered' : 'Sending';
      this._debug(`SFTP: Outbound: ${which} posix-rename@openssh.com`);
    }
  }
  ext_openssh_statvfs(path, cb) {
    if (this.server) throw new Error('Client-only method called in server mode');
    const ext = this._extensions['statvfs@openssh.com'];
    if (!ext || ext !== '2') throw new Error('Server does not support this extended request');

    /*
      uint32    id
      string    "statvfs@openssh.com"
      string    path
    */
    const pathLen = Buffer.byteLength(path);
    let p = 9;
    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + 19 + 4 + pathLen);
    writeUInt32BE(buf, buf.length - 4, 0);
    buf[4] = REQUEST.EXTENDED;
    const reqid = this._writeReqid = this._writeReqid + 1 & MAX_REQID;
    writeUInt32BE(buf, reqid, 5);
    writeUInt32BE(buf, 19, p);
    buf.utf8Write('statvfs@openssh.com', p += 4, 19);
    writeUInt32BE(buf, pathLen, p += 19);
    buf.utf8Write(path, p += 4, pathLen);
    this._requests[reqid] = {
      extended: 'statvfs@openssh.com',
      cb
    };
    const isBuffered = sendOrBuffer(this, buf);
    if (this._debug) {
      const which = isBuffered ? 'Buffered' : 'Sending';
      this._debug(`SFTP: Outbound: ${which} statvfs@openssh.com`);
    }
  }
  ext_openssh_fstatvfs(handle, cb) {
    if (this.server) throw new Error('Client-only method called in server mode');
    const ext = this._extensions['fstatvfs@openssh.com'];
    if (!ext || ext !== '2') throw new Error('Server does not support this extended request');
    if (!Buffer.isBuffer(handle)) throw new Error('handle is not a Buffer');

    /*
      uint32    id
      string    "fstatvfs@openssh.com"
      string    handle
    */
    const handleLen = handle.length;
    let p = 9;
    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + 20 + 4 + handleLen);
    writeUInt32BE(buf, buf.length - 4, 0);
    buf[4] = REQUEST.EXTENDED;
    const reqid = this._writeReqid = this._writeReqid + 1 & MAX_REQID;
    writeUInt32BE(buf, reqid, 5);
    writeUInt32BE(buf, 20, p);
    buf.utf8Write('fstatvfs@openssh.com', p += 4, 20);
    writeUInt32BE(buf, handleLen, p += 20);
    buf.set(handle, p += 4);
    this._requests[reqid] = {
      extended: 'fstatvfs@openssh.com',
      cb
    };
    const isBuffered = sendOrBuffer(this, buf);
    if (this._debug) {
      const which = isBuffered ? 'Buffered' : 'Sending';
      this._debug(`SFTP: Outbound: ${which} fstatvfs@openssh.com`);
    }
  }
  ext_openssh_hardlink(oldPath, newPath, cb) {
    if (this.server) throw new Error('Client-only method called in server mode');
    const ext = this._extensions['hardlink@openssh.com'];
    if (ext !== '1') throw new Error('Server does not support this extended request');

    /*
      uint32    id
      string    "hardlink@openssh.com"
      string    oldpath
      string    newpath
    */
    const oldLen = Buffer.byteLength(oldPath);
    const newLen = Buffer.byteLength(newPath);
    let p = 9;
    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + 20 + 4 + oldLen + 4 + newLen);
    writeUInt32BE(buf, buf.length - 4, 0);
    buf[4] = REQUEST.EXTENDED;
    const reqid = this._writeReqid = this._writeReqid + 1 & MAX_REQID;
    writeUInt32BE(buf, reqid, 5);
    writeUInt32BE(buf, 20, p);
    buf.utf8Write('hardlink@openssh.com', p += 4, 20);
    writeUInt32BE(buf, oldLen, p += 20);
    buf.utf8Write(oldPath, p += 4, oldLen);
    writeUInt32BE(buf, newLen, p += oldLen);
    buf.utf8Write(newPath, p += 4, newLen);
    this._requests[reqid] = {
      cb
    };
    const isBuffered = sendOrBuffer(this, buf);
    if (this._debug) {
      const which = isBuffered ? 'Buffered' : 'Sending';
      this._debug(`SFTP: Outbound: ${which} hardlink@openssh.com`);
    }
  }
  ext_openssh_fsync(handle, cb) {
    if (this.server) throw new Error('Client-only method called in server mode');
    const ext = this._extensions['fsync@openssh.com'];
    if (ext !== '1') throw new Error('Server does not support this extended request');
    if (!Buffer.isBuffer(handle)) throw new Error('handle is not a Buffer');

    /*
      uint32    id
      string    "fsync@openssh.com"
      string    handle
    */
    const handleLen = handle.length;
    let p = 9;
    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + 17 + 4 + handleLen);
    writeUInt32BE(buf, buf.length - 4, 0);
    buf[4] = REQUEST.EXTENDED;
    const reqid = this._writeReqid = this._writeReqid + 1 & MAX_REQID;
    writeUInt32BE(buf, reqid, 5);
    writeUInt32BE(buf, 17, p);
    buf.utf8Write('fsync@openssh.com', p += 4, 17);
    writeUInt32BE(buf, handleLen, p += 17);
    buf.set(handle, p += 4);
    this._requests[reqid] = {
      cb
    };
    const isBuffered = sendOrBuffer(this, buf);
    this._debug && this._debug(`SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} fsync@openssh.com`);
  }
  ext_openssh_lsetstat(path, attrs, cb) {
    if (this.server) throw new Error('Client-only method called in server mode');
    const ext = this._extensions['lsetstat@openssh.com'];
    if (ext !== '1') throw new Error('Server does not support this extended request');
    let flags = 0;
    let attrsLen = 0;
    if (typeof attrs === 'object' && attrs !== null) {
      attrs = attrsToBytes(attrs);
      flags = attrs.flags;
      attrsLen = attrs.nb;
    } else if (typeof attrs === 'function') {
      cb = attrs;
    }

    /*
      uint32    id
      string    "lsetstat@openssh.com"
      string    path
      ATTRS     attrs
    */
    const pathLen = Buffer.byteLength(path);
    let p = 9;
    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + 20 + 4 + pathLen + 4 + attrsLen);
    writeUInt32BE(buf, buf.length - 4, 0);
    buf[4] = REQUEST.EXTENDED;
    const reqid = this._writeReqid = this._writeReqid + 1 & MAX_REQID;
    writeUInt32BE(buf, reqid, 5);
    writeUInt32BE(buf, 20, p);
    buf.utf8Write('lsetstat@openssh.com', p += 4, 20);
    writeUInt32BE(buf, pathLen, p += 20);
    buf.utf8Write(path, p += 4, pathLen);
    writeUInt32BE(buf, flags, p += pathLen);
    if (attrsLen) {
      p += 4;
      if (attrsLen === ATTRS_BUF.length) buf.set(ATTRS_BUF, p);else bufferCopy(ATTRS_BUF, buf, 0, attrsLen, p);
      p += attrsLen;
    }
    this._requests[reqid] = {
      cb
    };
    const isBuffered = sendOrBuffer(this, buf);
    if (this._debug) {
      const status = isBuffered ? 'Buffered' : 'Sending';
      this._debug(`SFTP: Outbound: ${status} lsetstat@openssh.com`);
    }
  }
  ext_openssh_expandPath(path, cb) {
    if (this.server) throw new Error('Client-only method called in server mode');
    const ext = this._extensions['expand-path@openssh.com'];
    if (ext !== '1') throw new Error('Server does not support this extended request');

    /*
      uint32    id
      string    "expand-path@openssh.com"
      string    path
    */
    const pathLen = Buffer.byteLength(path);
    let p = 9;
    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + 23 + 4 + pathLen);
    writeUInt32BE(buf, buf.length - 4, 0);
    buf[4] = REQUEST.EXTENDED;
    const reqid = this._writeReqid = this._writeReqid + 1 & MAX_REQID;
    writeUInt32BE(buf, reqid, 5);
    writeUInt32BE(buf, 23, p);
    buf.utf8Write('expand-path@openssh.com', p += 4, 23);
    writeUInt32BE(buf, pathLen, p += 20);
    buf.utf8Write(path, p += 4, pathLen);
    this._requests[reqid] = {
      cb
    };
    const isBuffered = sendOrBuffer(this, buf);
    if (this._debug) {
      const status = isBuffered ? 'Buffered' : 'Sending';
      this._debug(`SFTP: Outbound: ${status} expand-path@openssh.com`);
    }
  }
  ext_copy_data(srcHandle, srcOffset, len, dstHandle, dstOffset, cb) {
    if (this.server) throw new Error('Client-only method called in server mode');
    const ext = this._extensions['copy-data'];
    if (ext !== '1') throw new Error('Server does not support this extended request');
    if (!Buffer.isBuffer(srcHandle)) throw new Error('Source handle is not a Buffer');
    if (!Buffer.isBuffer(dstHandle)) throw new Error('Destination handle is not a Buffer');

    /*
      uint32    id
      string    "copy-data"
      string    read-from-handle
      uint64    read-from-offset
      uint64    read-data-length
      string    write-to-handle
      uint64    write-to-offset
    */
    let p = 0;
    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + 9 + 4 + srcHandle.length + 8 + 8 + 4 + dstHandle.length + 8);
    writeUInt32BE(buf, buf.length - 4, p);
    p += 4;
    buf[p] = REQUEST.EXTENDED;
    ++p;
    const reqid = this._writeReqid = this._writeReqid + 1 & MAX_REQID;
    writeUInt32BE(buf, reqid, p);
    p += 4;
    writeUInt32BE(buf, 9, p);
    p += 4;
    buf.utf8Write('copy-data', p, 9);
    p += 9;
    writeUInt32BE(buf, srcHandle.length, p);
    p += 4;
    buf.set(srcHandle, p);
    p += srcHandle.length;
    for (let i = 7; i >= 0; --i) {
      buf[p + i] = srcOffset & 0xFF;
      srcOffset /= 256;
    }
    p += 8;
    for (let i = 7; i >= 0; --i) {
      buf[p + i] = len & 0xFF;
      len /= 256;
    }
    p += 8;
    writeUInt32BE(buf, dstHandle.length, p);
    p += 4;
    buf.set(dstHandle, p);
    p += dstHandle.length;
    for (let i = 7; i >= 0; --i) {
      buf[p + i] = dstOffset & 0xFF;
      dstOffset /= 256;
    }
    this._requests[reqid] = {
      cb
    };
    const isBuffered = sendOrBuffer(this, buf);
    if (this._debug) {
      const status = isBuffered ? 'Buffered' : 'Sending';
      this._debug(`SFTP: Outbound: ${status} copy-data`);
    }
  }
  // ===========================================================================
  // Server-specific ===========================================================
  // ===========================================================================
  handle(reqid, handle) {
    if (!this.server) throw new Error('Server-only method called in client mode');
    if (!Buffer.isBuffer(handle)) throw new Error('handle is not a Buffer');
    const handleLen = handle.length;
    if (handleLen > 256) throw new Error('handle too large (> 256 bytes)');
    let p = 9;
    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + handleLen);
    writeUInt32BE(buf, buf.length - 4, 0);
    buf[4] = RESPONSE.HANDLE;
    writeUInt32BE(buf, reqid, 5);
    writeUInt32BE(buf, handleLen, p);
    if (handleLen) buf.set(handle, p += 4);
    const isBuffered = sendOrBuffer(this, buf);
    this._debug && this._debug(`SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} HANDLE`);
  }
  status(reqid, code, message) {
    if (!this.server) throw new Error('Server-only method called in client mode');
    if (!VALID_STATUS_CODES.has(code)) throw new Error(`Bad status code: ${code}`);
    message || (message = '');
    const msgLen = Buffer.byteLength(message);
    let p = 9;
    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + 4 + msgLen + 4);
    writeUInt32BE(buf, buf.length - 4, 0);
    buf[4] = RESPONSE.STATUS;
    writeUInt32BE(buf, reqid, 5);
    writeUInt32BE(buf, code, p);
    writeUInt32BE(buf, msgLen, p += 4);
    p += 4;
    if (msgLen) {
      buf.utf8Write(message, p, msgLen);
      p += msgLen;
    }
    writeUInt32BE(buf, 0, p); // Empty language tag

    const isBuffered = sendOrBuffer(this, buf);
    this._debug && this._debug(`SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} STATUS`);
  }
  data(reqid, data, encoding) {
    if (!this.server) throw new Error('Server-only method called in client mode');
    const isBuffer = Buffer.isBuffer(data);
    if (!isBuffer && typeof data !== 'string') throw new Error('data is not a Buffer or string');
    let isUTF8;
    if (!isBuffer && !encoding) {
      encoding = undefined;
      isUTF8 = true;
    }
    const dataLen = isBuffer ? data.length : Buffer.byteLength(data, encoding);
    let p = 9;
    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + dataLen);
    writeUInt32BE(buf, buf.length - 4, 0);
    buf[4] = RESPONSE.DATA;
    writeUInt32BE(buf, reqid, 5);
    writeUInt32BE(buf, dataLen, p);
    if (dataLen) {
      if (isBuffer) buf.set(data, p += 4);else if (isUTF8) buf.utf8Write(data, p += 4, dataLen);else buf.write(data, p += 4, dataLen, encoding);
    }
    const isBuffered = sendOrBuffer(this, buf);
    this._debug && this._debug(`SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} DATA`);
  }
  name(reqid, names) {
    if (!this.server) throw new Error('Server-only method called in client mode');
    if (!Array.isArray(names)) {
      if (typeof names !== 'object' || names === null) throw new Error('names is not an object or array');
      names = [names];
    }
    const count = names.length;
    let namesLen = 0;
    let nameAttrs;
    const attrs = [];
    for (let i = 0; i < count; ++i) {
      const name = names[i];
      const filename = !name || !name.filename || typeof name.filename !== 'string' ? '' : name.filename;
      namesLen += 4 + Buffer.byteLength(filename);
      const longname = !name || !name.longname || typeof name.longname !== 'string' ? '' : name.longname;
      namesLen += 4 + Buffer.byteLength(longname);
      if (typeof name.attrs === 'object' && name.attrs !== null) {
        nameAttrs = attrsToBytes(name.attrs);
        namesLen += 4 + nameAttrs.nb;
        if (nameAttrs.nb) {
          let bytes;
          if (nameAttrs.nb === ATTRS_BUF.length) {
            bytes = new Uint8Array(ATTRS_BUF);
          } else {
            bytes = new Uint8Array(nameAttrs.nb);
            bufferCopy(ATTRS_BUF, bytes, 0, nameAttrs.nb, 0);
          }
          nameAttrs.bytes = bytes;
        }
        attrs.push(nameAttrs);
      } else {
        namesLen += 4;
        attrs.push(null);
      }
    }
    let p = 9;
    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + namesLen);
    writeUInt32BE(buf, buf.length - 4, 0);
    buf[4] = RESPONSE.NAME;
    writeUInt32BE(buf, reqid, 5);
    writeUInt32BE(buf, count, p);
    p += 4;
    for (let i = 0; i < count; ++i) {
      const name = names[i];
      {
        const filename = !name || !name.filename || typeof name.filename !== 'string' ? '' : name.filename;
        const len = Buffer.byteLength(filename);
        writeUInt32BE(buf, len, p);
        p += 4;
        if (len) {
          buf.utf8Write(filename, p, len);
          p += len;
        }
      }
      {
        const longname = !name || !name.longname || typeof name.longname !== 'string' ? '' : name.longname;
        const len = Buffer.byteLength(longname);
        writeUInt32BE(buf, len, p);
        p += 4;
        if (len) {
          buf.utf8Write(longname, p, len);
          p += len;
        }
      }
      const attr = attrs[i];
      if (attr) {
        writeUInt32BE(buf, attr.flags, p);
        p += 4;
        if (attr.flags && attr.bytes) {
          buf.set(attr.bytes, p);
          p += attr.nb;
        }
      } else {
        writeUInt32BE(buf, 0, p);
        p += 4;
      }
    }
    const isBuffered = sendOrBuffer(this, buf);
    this._debug && this._debug(`SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} NAME`);
  }
  attrs(reqid, attrs) {
    if (!this.server) throw new Error('Server-only method called in client mode');
    if (typeof attrs !== 'object' || attrs === null) throw new Error('attrs is not an object');
    attrs = attrsToBytes(attrs);
    const flags = attrs.flags;
    const attrsLen = attrs.nb;
    let p = 9;
    const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + attrsLen);
    writeUInt32BE(buf, buf.length - 4, 0);
    buf[4] = RESPONSE.ATTRS;
    writeUInt32BE(buf, reqid, 5);
    writeUInt32BE(buf, flags, p);
    if (attrsLen) {
      p += 4;
      if (attrsLen === ATTRS_BUF.length) buf.set(ATTRS_BUF, p);else bufferCopy(ATTRS_BUF, buf, 0, attrsLen, p);
      p += attrsLen;
    }
    const isBuffered = sendOrBuffer(this, buf);
    this._debug && this._debug(`SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} ATTRS`);
  }
}
function tryCreateBuffer(size) {
  try {
    return Buffer.allocUnsafe(size);
  } catch (ex) {
    return ex;
  }
}
function read_(self, handle, buf, off, len, position, cb, req_) {
  const maxDataLen = self._maxReadLen;
  const overflow = Math.max(len - maxDataLen, 0);
  if (overflow) len = maxDataLen;

  /*
    uint32     id
    string     handle
    uint64     offset
    uint32     len
  */
  const handleLen = handle.length;
  let p = 9;
  let pos = position;
  const out = Buffer.allocUnsafe(4 + 1 + 4 + 4 + handleLen + 8 + 4);
  writeUInt32BE(out, out.length - 4, 0);
  out[4] = REQUEST.READ;
  const reqid = self._writeReqid = self._writeReqid + 1 & MAX_REQID;
  writeUInt32BE(out, reqid, 5);
  writeUInt32BE(out, handleLen, p);
  out.set(handle, p += 4);
  p += handleLen;
  for (let i = 7; i >= 0; --i) {
    out[p + i] = pos & 0xFF;
    pos /= 256;
  }
  writeUInt32BE(out, len, p += 8);
  if (typeof cb !== 'function') cb = noop;
  const req = req_ || {
    nb: 0,
    position,
    off,
    origOff: off,
    len: undefined,
    overflow: undefined,
    cb: (err, data, nb) => {
      const len = req.len;
      const overflow = req.overflow;
      if (err) {
        if (cb._wantEOFError || err.code !== STATUS_CODE.EOF) return cb(err);
      } else if (nb > len) {
        return cb(new Error('Received more data than requested'));
      } else if (nb === len && overflow) {
        req.nb += nb;
        req.position += nb;
        req.off += nb;
        read_(self, handle, buf, req.off, overflow, req.position, cb, req);
        return;
      }
      nb = nb || 0;
      if (req.origOff === 0 && buf.length === req.nb) data = buf;else data = bufferSlice(buf, req.origOff, req.origOff + req.nb + nb);
      cb(undefined, req.nb + nb, data, req.position);
    },
    buffer: undefined
  };
  req.len = len;
  req.overflow = overflow;

  // TODO: avoid creating multiple buffer slices when we need to re-call read_()
  // because of overflow
  req.buffer = bufferSlice(buf, off, off + len);
  self._requests[reqid] = req;
  const isBuffered = sendOrBuffer(self, out);
  self._debug && self._debug(`SFTP: Outbound: ${isBuffered ? 'Buffered' : 'Sending'} READ`);
}
function fastXfer(src, dst, srcPath, dstPath, opts, cb) {
  let concurrency = 64;
  let chunkSize = 32768;
  let onstep;
  let mode;
  let fileSize;
  if (typeof opts === 'function') {
    cb = opts;
  } else if (typeof opts === 'object' && opts !== null) {
    if (typeof opts.concurrency === 'number' && opts.concurrency > 0 && !isNaN(opts.concurrency)) {
      concurrency = opts.concurrency;
    }
    if (typeof opts.chunkSize === 'number' && opts.chunkSize > 0 && !isNaN(opts.chunkSize)) {
      chunkSize = opts.chunkSize;
    }
    if (typeof opts.fileSize === 'number' && opts.fileSize > 0 && !isNaN(opts.fileSize)) {
      fileSize = opts.fileSize;
    }
    if (typeof opts.step === 'function') onstep = opts.step;
    if (typeof opts.mode === 'string' || typeof opts.mode === 'number') mode = modeNum(opts.mode);
  }

  // Internal state variables
  let fsize;
  let pdst = 0;
  let total = 0;
  let hadError = false;
  let srcHandle;
  let dstHandle;
  let readbuf;
  let bufsize = chunkSize * concurrency;
  function onerror(err) {
    if (hadError) return;
    hadError = true;
    let left = 0;
    let cbfinal;
    if (srcHandle || dstHandle) {
      cbfinal = () => {
        if (--left === 0) cb(err);
      };
      if (srcHandle && (src === fs || src.outgoing.state === 'open')) ++left;
      if (dstHandle && (dst === fs || dst.outgoing.state === 'open')) ++left;
      if (srcHandle && (src === fs || src.outgoing.state === 'open')) src.close(srcHandle, cbfinal);
      if (dstHandle && (dst === fs || dst.outgoing.state === 'open')) dst.close(dstHandle, cbfinal);
    } else {
      cb(err);
    }
  }
  src.open(srcPath, 'r', (err, sourceHandle) => {
    if (err) return onerror(err);
    srcHandle = sourceHandle;
    if (fileSize === undefined) src.fstat(srcHandle, tryStat);else tryStat(null, {
      size: fileSize
    });
    function tryStat(err, attrs) {
      if (err) {
        if (src !== fs) {
          // Try stat() for sftp servers that may not support fstat() for
          // whatever reason
          src.stat(srcPath, (err_, attrs_) => {
            if (err_) return onerror(err);
            tryStat(null, attrs_);
          });
          return;
        }
        return onerror(err);
      }
      fsize = attrs.size;
      dst.open(dstPath, 'w', (err, destHandle) => {
        if (err) return onerror(err);
        dstHandle = destHandle;
        if (fsize <= 0) return onerror();

        // Use less memory where possible
        while (bufsize > fsize) {
          if (concurrency === 1) {
            bufsize = fsize;
            break;
          }
          bufsize -= chunkSize;
          --concurrency;
        }
        readbuf = tryCreateBuffer(bufsize);
        if (readbuf instanceof Error) return onerror(readbuf);
        if (mode !== undefined) {
          dst.fchmod(dstHandle, mode, function tryAgain(err) {
            if (err) {
              // Try chmod() for sftp servers that may not support fchmod()
              // for whatever reason
              dst.chmod(dstPath, mode, err_ => tryAgain());
              return;
            }
            startReads();
          });
        } else {
          startReads();
        }
        function onread(err, nb, data, dstpos, datapos, origChunkLen) {
          if (err) return onerror(err);
          datapos = datapos || 0;
          dst.write(dstHandle, readbuf, datapos, nb, dstpos, writeCb);
          function writeCb(err) {
            if (err) return onerror(err);
            total += nb;
            onstep && onstep(total, nb, fsize);
            if (nb < origChunkLen) return singleRead(datapos, dstpos + nb, origChunkLen - nb);
            if (total === fsize) {
              dst.close(dstHandle, err => {
                dstHandle = undefined;
                if (err) return onerror(err);
                src.close(srcHandle, err => {
                  srcHandle = undefined;
                  if (err) return onerror(err);
                  cb();
                });
              });
              return;
            }
            if (pdst >= fsize) return;
            const chunk = pdst + chunkSize > fsize ? fsize - pdst : chunkSize;
            singleRead(datapos, pdst, chunk);
            pdst += chunk;
          }
        }
        function makeCb(psrc, pdst, chunk) {
          return (err, nb, data) => {
            onread(err, nb, data, pdst, psrc, chunk);
          };
        }
        function singleRead(psrc, pdst, chunk) {
          src.read(srcHandle, readbuf, psrc, chunk, pdst, makeCb(psrc, pdst, chunk));
        }
        function startReads() {
          let reads = 0;
          let psrc = 0;
          while (pdst < fsize && reads < concurrency) {
            const chunk = pdst + chunkSize > fsize ? fsize - pdst : chunkSize;
            singleRead(psrc, pdst, chunk);
            psrc += chunk;
            pdst += chunk;
            ++reads;
          }
        }
      });
    }
  });
}
function writeAll(sftp, handle, buffer, offset, length, position, callback_) {
  const callback = typeof callback_ === 'function' ? callback_ : undefined;
  sftp.write(handle, buffer, offset, length, position, (writeErr, written) => {
    if (writeErr) {
      return sftp.close(handle, () => {
        callback && callback(writeErr);
      });
    }
    if (written === length) {
      sftp.close(handle, callback);
    } else {
      offset += written;
      length -= written;
      position += written;
      writeAll(sftp, handle, buffer, offset, length, position, callback);
    }
  });
}
class Stats {
  constructor(initial) {
    this.mode = initial && initial.mode;
    this.uid = initial && initial.uid;
    this.gid = initial && initial.gid;
    this.size = initial && initial.size;
    this.atime = initial && initial.atime;
    this.mtime = initial && initial.mtime;
    this.extended = initial && initial.extended;
  }
  isDirectory() {
    return (this.mode & constants.S_IFMT) === constants.S_IFDIR;
  }
  isFile() {
    return (this.mode & constants.S_IFMT) === constants.S_IFREG;
  }
  isBlockDevice() {
    return (this.mode & constants.S_IFMT) === constants.S_IFBLK;
  }
  isCharacterDevice() {
    return (this.mode & constants.S_IFMT) === constants.S_IFCHR;
  }
  isSymbolicLink() {
    return (this.mode & constants.S_IFMT) === constants.S_IFLNK;
  }
  isFIFO() {
    return (this.mode & constants.S_IFMT) === constants.S_IFIFO;
  }
  isSocket() {
    return (this.mode & constants.S_IFMT) === constants.S_IFSOCK;
  }
}
function attrsToBytes(attrs) {
  let flags = 0;
  let nb = 0;
  if (typeof attrs === 'object' && attrs !== null) {
    if (typeof attrs.size === 'number') {
      flags |= ATTR.SIZE;
      const val = attrs.size;
      // Big Endian
      ATTRS_BUF[nb++] = val / 72057594037927940; // 2**56
      ATTRS_BUF[nb++] = val / 281474976710656; // 2**48
      ATTRS_BUF[nb++] = val / 1099511627776; // 2**40
      ATTRS_BUF[nb++] = val / 4294967296; // 2**32
      ATTRS_BUF[nb++] = val / 16777216; // 2**24
      ATTRS_BUF[nb++] = val / 65536; // 2**16
      ATTRS_BUF[nb++] = val / 256; // 2**8
      ATTRS_BUF[nb++] = val;
    }
    if (typeof attrs.uid === 'number' && typeof attrs.gid === 'number') {
      flags |= ATTR.UIDGID;
      const uid = attrs.uid;
      const gid = attrs.gid;
      // Big Endian
      ATTRS_BUF[nb++] = uid >>> 24;
      ATTRS_BUF[nb++] = uid >>> 16;
      ATTRS_BUF[nb++] = uid >>> 8;
      ATTRS_BUF[nb++] = uid;
      ATTRS_BUF[nb++] = gid >>> 24;
      ATTRS_BUF[nb++] = gid >>> 16;
      ATTRS_BUF[nb++] = gid >>> 8;
      ATTRS_BUF[nb++] = gid;
    }
    if (typeof attrs.mode === 'number' || typeof attrs.mode === 'string') {
      const mode = modeNum(attrs.mode);
      flags |= ATTR.PERMISSIONS;
      // Big Endian
      ATTRS_BUF[nb++] = mode >>> 24;
      ATTRS_BUF[nb++] = mode >>> 16;
      ATTRS_BUF[nb++] = mode >>> 8;
      ATTRS_BUF[nb++] = mode;
    }
    if ((typeof attrs.atime === 'number' || isDate(attrs.atime)) && (typeof attrs.mtime === 'number' || isDate(attrs.mtime))) {
      const atime = toUnixTimestamp(attrs.atime);
      const mtime = toUnixTimestamp(attrs.mtime);
      flags |= ATTR.ACMODTIME;
      // Big Endian
      ATTRS_BUF[nb++] = atime >>> 24;
      ATTRS_BUF[nb++] = atime >>> 16;
      ATTRS_BUF[nb++] = atime >>> 8;
      ATTRS_BUF[nb++] = atime;
      ATTRS_BUF[nb++] = mtime >>> 24;
      ATTRS_BUF[nb++] = mtime >>> 16;
      ATTRS_BUF[nb++] = mtime >>> 8;
      ATTRS_BUF[nb++] = mtime;
    }
    // TODO: extended attributes
  }

  return {
    flags,
    nb
  };
}
function toUnixTimestamp(time) {
  // eslint-disable-next-line no-self-compare
  if (typeof time === 'number' && time === time)
    // Valid, non-NaN number
    return time;
  if (isDate(time)) return parseInt(time.getTime() / 1000, 10);
  throw new Error(`Cannot parse time: ${time}`);
}
function modeNum(mode) {
  // eslint-disable-next-line no-self-compare
  if (typeof mode === 'number' && mode === mode)
    // Valid, non-NaN number
    return mode;
  if (typeof mode === 'string') return modeNum(parseInt(mode, 8));
  throw new Error(`Cannot parse mode: ${mode}`);
}
const stringFlagMap = {
  'r': OPEN_MODE.READ,
  'r+': OPEN_MODE.READ | OPEN_MODE.WRITE,
  'w': OPEN_MODE.TRUNC | OPEN_MODE.CREAT | OPEN_MODE.WRITE,
  'wx': OPEN_MODE.TRUNC | OPEN_MODE.CREAT | OPEN_MODE.WRITE | OPEN_MODE.EXCL,
  'xw': OPEN_MODE.TRUNC | OPEN_MODE.CREAT | OPEN_MODE.WRITE | OPEN_MODE.EXCL,
  'w+': OPEN_MODE.TRUNC | OPEN_MODE.CREAT | OPEN_MODE.READ | OPEN_MODE.WRITE,
  'wx+': OPEN_MODE.TRUNC | OPEN_MODE.CREAT | OPEN_MODE.READ | OPEN_MODE.WRITE | OPEN_MODE.EXCL,
  'xw+': OPEN_MODE.TRUNC | OPEN_MODE.CREAT | OPEN_MODE.READ | OPEN_MODE.WRITE | OPEN_MODE.EXCL,
  'a': OPEN_MODE.APPEND | OPEN_MODE.CREAT | OPEN_MODE.WRITE,
  'ax': OPEN_MODE.APPEND | OPEN_MODE.CREAT | OPEN_MODE.WRITE | OPEN_MODE.EXCL,
  'xa': OPEN_MODE.APPEND | OPEN_MODE.CREAT | OPEN_MODE.WRITE | OPEN_MODE.EXCL,
  'a+': OPEN_MODE.APPEND | OPEN_MODE.CREAT | OPEN_MODE.READ | OPEN_MODE.WRITE,
  'ax+': OPEN_MODE.APPEND | OPEN_MODE.CREAT | OPEN_MODE.READ | OPEN_MODE.WRITE | OPEN_MODE.EXCL,
  'xa+': OPEN_MODE.APPEND | OPEN_MODE.CREAT | OPEN_MODE.READ | OPEN_MODE.WRITE | OPEN_MODE.EXCL
};
function stringToFlags(str) {
  const flags = stringFlagMap[str];
  return flags !== undefined ? flags : null;
}
const flagsToString = (() => {
  const stringFlagMapKeys = Object.keys(stringFlagMap);
  return flags => {
    for (let i = 0; i < stringFlagMapKeys.length; ++i) {
      const key = stringFlagMapKeys[i];
      if (stringFlagMap[key] === flags) return key;
    }
    return null;
  };
})();
function readAttrs(biOpt) {
  /*
    uint32   flags
    uint64   size           present only if flag SSH_FILEXFER_ATTR_SIZE
    uint32   uid            present only if flag SSH_FILEXFER_ATTR_UIDGID
    uint32   gid            present only if flag SSH_FILEXFER_ATTR_UIDGID
    uint32   permissions    present only if flag SSH_FILEXFER_ATTR_PERMISSIONS
    uint32   atime          present only if flag SSH_FILEXFER_ACMODTIME
    uint32   mtime          present only if flag SSH_FILEXFER_ACMODTIME
    uint32   extended_count present only if flag SSH_FILEXFER_ATTR_EXTENDED
    string   extended_type
    string   extended_data
    ...      more extended data (extended_type - extended_data pairs),
               so that number of pairs equals extended_count
  */
  const flags = bufferParser.readUInt32BE();
  if (flags === undefined) return;
  const attrs = new Stats();
  if (flags & ATTR.SIZE) {
    const size = bufferParser.readUInt64BE(biOpt);
    if (size === undefined) return;
    attrs.size = size;
  }
  if (flags & ATTR.UIDGID) {
    const uid = bufferParser.readUInt32BE();
    const gid = bufferParser.readUInt32BE();
    if (gid === undefined) return;
    attrs.uid = uid;
    attrs.gid = gid;
  }
  if (flags & ATTR.PERMISSIONS) {
    const mode = bufferParser.readUInt32BE();
    if (mode === undefined) return;
    attrs.mode = mode;
  }
  if (flags & ATTR.ACMODTIME) {
    const atime = bufferParser.readUInt32BE();
    const mtime = bufferParser.readUInt32BE();
    if (mtime === undefined) return;
    attrs.atime = atime;
    attrs.mtime = mtime;
  }
  if (flags & ATTR.EXTENDED) {
    const count = bufferParser.readUInt32BE();
    if (count === undefined) return;
    const extended = {};
    for (let i = 0; i < count; ++i) {
      const type = bufferParser.readString(true);
      const data = bufferParser.readString();
      if (data === undefined) return;
      extended[type] = data;
    }
    attrs.extended = extended;
  }
  return attrs;
}
function sendOrBuffer(sftp, payload) {
  const ret = tryWritePayload(sftp, payload);
  if (ret !== undefined) {
    sftp._buffer.push(ret);
    return false;
  }
  return true;
}
function tryWritePayload(sftp, payload) {
  const outgoing = sftp.outgoing;
  if (outgoing.state !== 'open') return;
  if (outgoing.window === 0) {
    sftp._waitWindow = true;
    sftp._chunkcb = drainBuffer;
    return payload;
  }
  let ret;
  const len = payload.length;
  let p = 0;
  while (len - p > 0 && outgoing.window > 0) {
    const actualLen = Math.min(len - p, outgoing.window, outgoing.packetSize);
    outgoing.window -= actualLen;
    if (outgoing.window === 0) {
      sftp._waitWindow = true;
      sftp._chunkcb = drainBuffer;
    }
    if (p === 0 && actualLen === len) {
      sftp._protocol.channelData(sftp.outgoing.id, payload);
    } else {
      sftp._protocol.channelData(sftp.outgoing.id, bufferSlice(payload, p, p + actualLen));
    }
    p += actualLen;
  }
  if (len - p > 0) {
    if (p > 0) ret = bufferSlice(payload, p, len);else ret = payload; // XXX: should never get here?
  }

  return ret;
}
function drainBuffer() {
  this._chunkcb = undefined;
  const buffer = this._buffer;
  let i = 0;
  while (i < buffer.length) {
    const payload = buffer[i];
    const ret = tryWritePayload(this, payload);
    if (ret !== undefined) {
      if (ret !== payload) buffer[i] = ret;
      if (i > 0) this._buffer = buffer.slice(i);
      return;
    }
    ++i;
  }
  if (i > 0) this._buffer = [];
}
function doFatalSFTPError(sftp, msg, noDebug) {
  const err = new Error(msg);
  err.level = 'sftp-protocol';
  if (!noDebug && sftp._debug) sftp._debug(`SFTP: Inbound: ${msg}`);
  sftp.emit('error', err);
  sftp.destroy();
  cleanupRequests(sftp);
  return false;
}
function cleanupRequests(sftp) {
  const keys = Object.keys(sftp._requests);
  if (keys.length === 0) return;
  const reqs = sftp._requests;
  sftp._requests = {};
  const err = new Error('No response from server');
  for (let i = 0; i < keys.length; ++i) {
    const req = reqs[keys[i]];
    if (typeof req.cb === 'function') req.cb(err);
  }
}
function requestLimits(sftp, cb) {
  /*
    uint32    id
    string    "limits@openssh.com"
  */
  let p = 9;
  const buf = Buffer.allocUnsafe(4 + 1 + 4 + 4 + 18);
  writeUInt32BE(buf, buf.length - 4, 0);
  buf[4] = REQUEST.EXTENDED;
  const reqid = sftp._writeReqid = sftp._writeReqid + 1 & MAX_REQID;
  writeUInt32BE(buf, reqid, 5);
  writeUInt32BE(buf, 18, p);
  buf.utf8Write('limits@openssh.com', p += 4, 18);
  sftp._requests[reqid] = {
    extended: 'limits@openssh.com',
    cb
  };
  const isBuffered = sendOrBuffer(sftp, buf);
  if (sftp._debug) {
    const which = isBuffered ? 'Buffered' : 'Sending';
    sftp._debug(`SFTP: Outbound: ${which} limits@openssh.com`);
  }
}
const CLIENT_HANDLERS = {
  [RESPONSE.VERSION]: (sftp, payload) => {
    if (sftp._version !== -1) return doFatalSFTPError(sftp, 'Duplicate VERSION packet');
    const extensions = {};

    /*
      uint32 version
      <extension data>
    */
    bufferParser.init(payload, 1);
    let version = bufferParser.readUInt32BE();
    while (bufferParser.avail()) {
      const extName = bufferParser.readString(true);
      const extData = bufferParser.readString(true);
      if (extData === undefined) {
        version = undefined;
        break;
      }
      extensions[extName] = extData;
    }
    bufferParser.clear();
    if (version === undefined) return doFatalSFTPError(sftp, 'Malformed VERSION packet');
    if (sftp._debug) {
      const names = Object.keys(extensions);
      if (names.length) {
        sftp._debug(`SFTP: Inbound: Received VERSION (v${version}, exts:${names})`);
      } else {
        sftp._debug(`SFTP: Inbound: Received VERSION (v${version})`);
      }
    }
    sftp._version = version;
    sftp._extensions = extensions;
    if (extensions['limits@openssh.com'] === '1') {
      return requestLimits(sftp, (err, limits) => {
        if (!err) {
          if (limits.maxPktLen > 0) sftp._maxOutPktLen = limits.maxPktLen;
          if (limits.maxReadLen > 0) sftp._maxReadLen = limits.maxReadLen;
          if (limits.maxWriteLen > 0) sftp._maxWriteLen = limits.maxWriteLen;
          sftp.maxOpenHandles = limits.maxOpenHandles > 0 ? limits.maxOpenHandles : Infinity;
        }
        sftp.emit('ready');
      });
    }
    sftp.emit('ready');
  },
  [RESPONSE.STATUS]: (sftp, payload) => {
    bufferParser.init(payload, 1);
    const reqID = bufferParser.readUInt32BE();
    /*
      uint32     error/status code
      string     error message (ISO-10646 UTF-8)
      string     language tag
    */
    const errorCode = bufferParser.readUInt32BE();
    const errorMsg = bufferParser.readString(true);
    bufferParser.clear();

    // Note: we avoid checking that the error message and language tag are in
    // the packet because there are some broken implementations that incorrectly
    // omit them. The language tag in general was never really used amongst ssh
    // implementations, so in the case of a missing error message we just
    // default to something sensible.

    if (sftp._debug) {
      const jsonMsg = JSON.stringify(errorMsg);
      sftp._debug(`SFTP: Inbound: Received STATUS (id:${reqID}, ${errorCode}, ${jsonMsg})`);
    }
    const req = sftp._requests[reqID];
    delete sftp._requests[reqID];
    if (req && typeof req.cb === 'function') {
      if (errorCode === STATUS_CODE.OK) {
        req.cb();
        return;
      }
      const err = new Error(errorMsg || STATUS_CODE_STR[errorCode] || 'Unknown status');
      err.code = errorCode;
      req.cb(err);
    }
  },
  [RESPONSE.HANDLE]: (sftp, payload) => {
    bufferParser.init(payload, 1);
    const reqID = bufferParser.readUInt32BE();
    /*
      string     handle
    */
    const handle = bufferParser.readString();
    bufferParser.clear();
    if (handle === undefined) {
      if (reqID !== undefined) delete sftp._requests[reqID];
      return doFatalSFTPError(sftp, 'Malformed HANDLE packet');
    }
    sftp._debug && sftp._debug(`SFTP: Inbound: Received HANDLE (id:${reqID})`);
    const req = sftp._requests[reqID];
    delete sftp._requests[reqID];
    if (req && typeof req.cb === 'function') req.cb(undefined, handle);
  },
  [RESPONSE.DATA]: (sftp, payload) => {
    bufferParser.init(payload, 1);
    const reqID = bufferParser.readUInt32BE();
    let req;
    if (reqID !== undefined) {
      req = sftp._requests[reqID];
      delete sftp._requests[reqID];
    }
    /*
      string     data
    */
    if (req && typeof req.cb === 'function') {
      if (req.buffer) {
        // We have already pre-allocated space to store the data

        const nb = bufferParser.readString(req.buffer);
        bufferParser.clear();
        if (nb !== undefined) {
          sftp._debug && sftp._debug(`SFTP: Inbound: Received DATA (id:${reqID}, ${nb})`);
          req.cb(undefined, req.buffer, nb);
          return;
        }
      } else {
        const data = bufferParser.readString();
        bufferParser.clear();
        if (data !== undefined) {
          sftp._debug && sftp._debug(`SFTP: Inbound: Received DATA (id:${reqID}, ${data.length})`);
          req.cb(undefined, data);
          return;
        }
      }
    } else {
      const nb = bufferParser.skipString();
      bufferParser.clear();
      if (nb !== undefined) {
        sftp._debug && sftp._debug(`SFTP: Inbound: Received DATA (id:${reqID}, ${nb})`);
        return;
      }
    }
    return doFatalSFTPError(sftp, 'Malformed DATA packet');
  },
  [RESPONSE.NAME]: (sftp, payload) => {
    bufferParser.init(payload, 1);
    const reqID = bufferParser.readUInt32BE();
    let req;
    if (reqID !== undefined) {
      req = sftp._requests[reqID];
      delete sftp._requests[reqID];
    }
    /*
      uint32     count
      repeats count times:
              string     filename
              string     longname
              ATTRS      attrs
    */
    const count = bufferParser.readUInt32BE();
    if (count !== undefined) {
      let names = [];
      for (let i = 0; i < count; ++i) {
        // We are going to assume UTF-8 for filenames despite the SFTPv3
        // spec not specifying an encoding because the specs for newer
        // versions of the protocol all explicitly specify UTF-8 for
        // filenames
        const filename = bufferParser.readString(true);

        // `longname` only exists in SFTPv3 and since it typically will
        // contain the filename, we assume it is also UTF-8
        const longname = bufferParser.readString(true);
        const attrs = readAttrs(sftp._biOpt);
        if (attrs === undefined) {
          names = undefined;
          break;
        }
        names.push({
          filename,
          longname,
          attrs
        });
      }
      if (names !== undefined) {
        sftp._debug && sftp._debug(`SFTP: Inbound: Received NAME (id:${reqID}, ${names.length})`);
        bufferParser.clear();
        if (req && typeof req.cb === 'function') req.cb(undefined, names);
        return;
      }
    }
    bufferParser.clear();
    return doFatalSFTPError(sftp, 'Malformed NAME packet');
  },
  [RESPONSE.ATTRS]: (sftp, payload) => {
    bufferParser.init(payload, 1);
    const reqID = bufferParser.readUInt32BE();
    let req;
    if (reqID !== undefined) {
      req = sftp._requests[reqID];
      delete sftp._requests[reqID];
    }
    /*
      ATTRS      attrs
    */
    const attrs = readAttrs(sftp._biOpt);
    bufferParser.clear();
    if (attrs !== undefined) {
      sftp._debug && sftp._debug(`SFTP: Inbound: Received ATTRS (id:${reqID})`);
      if (req && typeof req.cb === 'function') req.cb(undefined, attrs);
      return;
    }
    return doFatalSFTPError(sftp, 'Malformed ATTRS packet');
  },
  [RESPONSE.EXTENDED]: (sftp, payload) => {
    bufferParser.init(payload, 1);
    const reqID = bufferParser.readUInt32BE();
    if (reqID !== undefined) {
      const req = sftp._requests[reqID];
      if (req) {
        delete sftp._requests[reqID];
        switch (req.extended) {
          case 'statvfs@openssh.com':
          case 'fstatvfs@openssh.com':
            {
              /*
                uint64    f_bsize   // file system block size
                uint64    f_frsize  // fundamental fs block size
                uint64    f_blocks  // number of blocks (unit f_frsize)
                uint64    f_bfree   // free blocks in file system
                uint64    f_bavail  // free blocks for non-root
                uint64    f_files   // total file inodes
                uint64    f_ffree   // free file inodes
                uint64    f_favail  // free file inodes for to non-root
                uint64    f_fsid    // file system id
                uint64    f_flag    // bit mask of f_flag values
                uint64    f_namemax // maximum filename length
              */
              const biOpt = sftp._biOpt;
              const stats = {
                f_bsize: bufferParser.readUInt64BE(biOpt),
                f_frsize: bufferParser.readUInt64BE(biOpt),
                f_blocks: bufferParser.readUInt64BE(biOpt),
                f_bfree: bufferParser.readUInt64BE(biOpt),
                f_bavail: bufferParser.readUInt64BE(biOpt),
                f_files: bufferParser.readUInt64BE(biOpt),
                f_ffree: bufferParser.readUInt64BE(biOpt),
                f_favail: bufferParser.readUInt64BE(biOpt),
                f_sid: bufferParser.readUInt64BE(biOpt),
                f_flag: bufferParser.readUInt64BE(biOpt),
                f_namemax: bufferParser.readUInt64BE(biOpt)
              };
              if (stats.f_namemax === undefined) break;
              if (sftp._debug) {
                sftp._debug('SFTP: Inbound: Received EXTENDED_REPLY ' + `(id:${reqID}, ${req.extended})`);
              }
              bufferParser.clear();
              if (typeof req.cb === 'function') req.cb(undefined, stats);
              return;
            }
          case 'limits@openssh.com':
            {
              /*
                uint64          max-packet-length
                uint64          max-read-length
                uint64          max-write-length
                uint64          max-open-handles
              */
              const limits = {
                maxPktLen: bufferParser.readUInt64BE(),
                maxReadLen: bufferParser.readUInt64BE(),
                maxWriteLen: bufferParser.readUInt64BE(),
                maxOpenHandles: bufferParser.readUInt64BE()
              };
              if (limits.maxOpenHandles === undefined) break;
              if (sftp._debug) {
                sftp._debug('SFTP: Inbound: Received EXTENDED_REPLY ' + `(id:${reqID}, ${req.extended})`);
              }
              bufferParser.clear();
              if (typeof req.cb === 'function') req.cb(undefined, limits);
              return;
            }
          default:
            // Unknown extended request
            sftp._debug && sftp._debug(`SFTP: Inbound: Received EXTENDED_REPLY (id:${reqID}, ???)`);
            bufferParser.clear();
            if (typeof req.cb === 'function') req.cb();
            return;
        }
      } else {
        sftp._debug && sftp._debug(`SFTP: Inbound: Received EXTENDED_REPLY (id:${reqID}, ???)`);
        bufferParser.clear();
        return;
      }
    }
    bufferParser.clear();
    return doFatalSFTPError(sftp, 'Malformed EXTENDED_REPLY packet');
  }
};
const SERVER_HANDLERS = {
  [REQUEST.INIT]: (sftp, payload) => {
    if (sftp._version !== -1) return doFatalSFTPError(sftp, 'Duplicate INIT packet');
    const extensions = {};

    /*
      uint32 version
      <extension data>
    */
    bufferParser.init(payload, 1);
    let version = bufferParser.readUInt32BE();
    while (bufferParser.avail()) {
      const extName = bufferParser.readString(true);
      const extData = bufferParser.readString(true);
      if (extData === undefined) {
        version = undefined;
        break;
      }
      extensions[extName] = extData;
    }
    bufferParser.clear();
    if (version === undefined) return doFatalSFTPError(sftp, 'Malformed INIT packet');
    if (sftp._debug) {
      const names = Object.keys(extensions);
      if (names.length) {
        sftp._debug(`SFTP: Inbound: Received INIT (v${version}, exts:${names})`);
      } else {
        sftp._debug(`SFTP: Inbound: Received INIT (v${version})`);
      }
    }
    sendOrBuffer(sftp, SERVER_VERSION_BUFFER);
    sftp._version = version;
    sftp._extensions = extensions;
    sftp.emit('ready');
  },
  [REQUEST.OPEN]: (sftp, payload) => {
    bufferParser.init(payload, 1);
    const reqID = bufferParser.readUInt32BE();
    /*
      string        filename
      uint32        pflags
      ATTRS         attrs
    */
    const filename = bufferParser.readString(true);
    const pflags = bufferParser.readUInt32BE();
    const attrs = readAttrs(sftp._biOpt);
    bufferParser.clear();
    if (attrs === undefined) return doFatalSFTPError(sftp, 'Malformed OPEN packet');
    sftp._debug && sftp._debug(`SFTP: Inbound: Received OPEN (id:${reqID})`);
    if (!sftp.emit('OPEN', reqID, filename, pflags, attrs)) {
      // Automatically reject request if no handler for request type
      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
    }
  },
  [REQUEST.CLOSE]: (sftp, payload) => {
    bufferParser.init(payload, 1);
    const reqID = bufferParser.readUInt32BE();
    /*
      string        handle
    */
    const handle = bufferParser.readString();
    bufferParser.clear();
    if (handle === undefined || handle.length > 256) return doFatalSFTPError(sftp, 'Malformed CLOSE packet');
    sftp._debug && sftp._debug(`SFTP: Inbound: Received CLOSE (id:${reqID})`);
    if (!sftp.emit('CLOSE', reqID, handle)) {
      // Automatically reject request if no handler for request type
      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
    }
  },
  [REQUEST.READ]: (sftp, payload) => {
    bufferParser.init(payload, 1);
    const reqID = bufferParser.readUInt32BE();
    /*
      string     handle
      uint64     offset
      uint32     len
    */
    const handle = bufferParser.readString();
    const offset = bufferParser.readUInt64BE(sftp._biOpt);
    const len = bufferParser.readUInt32BE();
    bufferParser.clear();
    if (len === undefined || handle.length > 256) return doFatalSFTPError(sftp, 'Malformed READ packet');
    sftp._debug && sftp._debug(`SFTP: Inbound: Received READ (id:${reqID})`);
    if (!sftp.emit('READ', reqID, handle, offset, len)) {
      // Automatically reject request if no handler for request type
      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
    }
  },
  [REQUEST.WRITE]: (sftp, payload) => {
    bufferParser.init(payload, 1);
    const reqID = bufferParser.readUInt32BE();
    /*
      string     handle
      uint64     offset
      string     data
    */
    const handle = bufferParser.readString();
    const offset = bufferParser.readUInt64BE(sftp._biOpt);
    const data = bufferParser.readString();
    bufferParser.clear();
    if (data === undefined || handle.length > 256) return doFatalSFTPError(sftp, 'Malformed WRITE packet');
    sftp._debug && sftp._debug(`SFTP: Inbound: Received WRITE (id:${reqID})`);
    if (!sftp.emit('WRITE', reqID, handle, offset, data)) {
      // Automatically reject request if no handler for request type
      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
    }
  },
  [REQUEST.LSTAT]: (sftp, payload) => {
    bufferParser.init(payload, 1);
    const reqID = bufferParser.readUInt32BE();
    /*
      string     path
    */
    const path = bufferParser.readString(true);
    bufferParser.clear();
    if (path === undefined) return doFatalSFTPError(sftp, 'Malformed LSTAT packet');
    sftp._debug && sftp._debug(`SFTP: Inbound: Received LSTAT (id:${reqID})`);
    if (!sftp.emit('LSTAT', reqID, path)) {
      // Automatically reject request if no handler for request type
      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
    }
  },
  [REQUEST.FSTAT]: (sftp, payload) => {
    bufferParser.init(payload, 1);
    const reqID = bufferParser.readUInt32BE();
    /*
      string        handle
    */
    const handle = bufferParser.readString();
    bufferParser.clear();
    if (handle === undefined || handle.length > 256) return doFatalSFTPError(sftp, 'Malformed FSTAT packet');
    sftp._debug && sftp._debug(`SFTP: Inbound: Received FSTAT (id:${reqID})`);
    if (!sftp.emit('FSTAT', reqID, handle)) {
      // Automatically reject request if no handler for request type
      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
    }
  },
  [REQUEST.SETSTAT]: (sftp, payload) => {
    bufferParser.init(payload, 1);
    const reqID = bufferParser.readUInt32BE();
    /*
      string     path
      ATTRS      attrs
    */
    const path = bufferParser.readString(true);
    const attrs = readAttrs(sftp._biOpt);
    bufferParser.clear();
    if (attrs === undefined) return doFatalSFTPError(sftp, 'Malformed SETSTAT packet');
    sftp._debug && sftp._debug(`SFTP: Inbound: Received SETSTAT (id:${reqID})`);
    if (!sftp.emit('SETSTAT', reqID, path, attrs)) {
      // Automatically reject request if no handler for request type
      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
    }
  },
  [REQUEST.FSETSTAT]: (sftp, payload) => {
    bufferParser.init(payload, 1);
    const reqID = bufferParser.readUInt32BE();
    /*
      string     handle
      ATTRS      attrs
    */
    const handle = bufferParser.readString();
    const attrs = readAttrs(sftp._biOpt);
    bufferParser.clear();
    if (attrs === undefined || handle.length > 256) return doFatalSFTPError(sftp, 'Malformed FSETSTAT packet');
    sftp._debug && sftp._debug(`SFTP: Inbound: Received FSETSTAT (id:${reqID})`);
    if (!sftp.emit('FSETSTAT', reqID, handle, attrs)) {
      // Automatically reject request if no handler for request type
      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
    }
  },
  [REQUEST.OPENDIR]: (sftp, payload) => {
    bufferParser.init(payload, 1);
    const reqID = bufferParser.readUInt32BE();
    /*
      string     path
    */
    const path = bufferParser.readString(true);
    bufferParser.clear();
    if (path === undefined) return doFatalSFTPError(sftp, 'Malformed OPENDIR packet');
    sftp._debug && sftp._debug(`SFTP: Inbound: Received OPENDIR (id:${reqID})`);
    if (!sftp.emit('OPENDIR', reqID, path)) {
      // Automatically reject request if no handler for request type
      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
    }
  },
  [REQUEST.READDIR]: (sftp, payload) => {
    bufferParser.init(payload, 1);
    const reqID = bufferParser.readUInt32BE();
    /*
      string        handle
    */
    const handle = bufferParser.readString();
    bufferParser.clear();
    if (handle === undefined || handle.length > 256) return doFatalSFTPError(sftp, 'Malformed READDIR packet');
    sftp._debug && sftp._debug(`SFTP: Inbound: Received READDIR (id:${reqID})`);
    if (!sftp.emit('READDIR', reqID, handle)) {
      // Automatically reject request if no handler for request type
      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
    }
  },
  [REQUEST.REMOVE]: (sftp, payload) => {
    bufferParser.init(payload, 1);
    const reqID = bufferParser.readUInt32BE();
    /*
      string     path
    */
    const path = bufferParser.readString(true);
    bufferParser.clear();
    if (path === undefined) return doFatalSFTPError(sftp, 'Malformed REMOVE packet');
    sftp._debug && sftp._debug(`SFTP: Inbound: Received REMOVE (id:${reqID})`);
    if (!sftp.emit('REMOVE', reqID, path)) {
      // Automatically reject request if no handler for request type
      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
    }
  },
  [REQUEST.MKDIR]: (sftp, payload) => {
    bufferParser.init(payload, 1);
    const reqID = bufferParser.readUInt32BE();
    /*
      string     path
      ATTRS      attrs
    */
    const path = bufferParser.readString(true);
    const attrs = readAttrs(sftp._biOpt);
    bufferParser.clear();
    if (attrs === undefined) return doFatalSFTPError(sftp, 'Malformed MKDIR packet');
    sftp._debug && sftp._debug(`SFTP: Inbound: Received MKDIR (id:${reqID})`);
    if (!sftp.emit('MKDIR', reqID, path, attrs)) {
      // Automatically reject request if no handler for request type
      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
    }
  },
  [REQUEST.RMDIR]: (sftp, payload) => {
    bufferParser.init(payload, 1);
    const reqID = bufferParser.readUInt32BE();
    /*
      string     path
    */
    const path = bufferParser.readString(true);
    bufferParser.clear();
    if (path === undefined) return doFatalSFTPError(sftp, 'Malformed RMDIR packet');
    sftp._debug && sftp._debug(`SFTP: Inbound: Received RMDIR (id:${reqID})`);
    if (!sftp.emit('RMDIR', reqID, path)) {
      // Automatically reject request if no handler for request type
      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
    }
  },
  [REQUEST.REALPATH]: (sftp, payload) => {
    bufferParser.init(payload, 1);
    const reqID = bufferParser.readUInt32BE();
    /*
      string     path
    */
    const path = bufferParser.readString(true);
    bufferParser.clear();
    if (path === undefined) return doFatalSFTPError(sftp, 'Malformed REALPATH packet');
    sftp._debug && sftp._debug(`SFTP: Inbound: Received REALPATH (id:${reqID})`);
    if (!sftp.emit('REALPATH', reqID, path)) {
      // Automatically reject request if no handler for request type
      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
    }
  },
  [REQUEST.STAT]: (sftp, payload) => {
    bufferParser.init(payload, 1);
    const reqID = bufferParser.readUInt32BE();
    /*
      string     path
    */
    const path = bufferParser.readString(true);
    bufferParser.clear();
    if (path === undefined) return doFatalSFTPError(sftp, 'Malformed STAT packet');
    sftp._debug && sftp._debug(`SFTP: Inbound: Received STAT (id:${reqID})`);
    if (!sftp.emit('STAT', reqID, path)) {
      // Automatically reject request if no handler for request type
      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
    }
  },
  [REQUEST.RENAME]: (sftp, payload) => {
    bufferParser.init(payload, 1);
    const reqID = bufferParser.readUInt32BE();
    /*
      string     oldpath
      string     newpath
    */
    const oldPath = bufferParser.readString(true);
    const newPath = bufferParser.readString(true);
    bufferParser.clear();
    if (newPath === undefined) return doFatalSFTPError(sftp, 'Malformed RENAME packet');
    sftp._debug && sftp._debug(`SFTP: Inbound: Received RENAME (id:${reqID})`);
    if (!sftp.emit('RENAME', reqID, oldPath, newPath)) {
      // Automatically reject request if no handler for request type
      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
    }
  },
  [REQUEST.READLINK]: (sftp, payload) => {
    bufferParser.init(payload, 1);
    const reqID = bufferParser.readUInt32BE();
    /*
      string     path
    */
    const path = bufferParser.readString(true);
    bufferParser.clear();
    if (path === undefined) return doFatalSFTPError(sftp, 'Malformed READLINK packet');
    sftp._debug && sftp._debug(`SFTP: Inbound: Received READLINK (id:${reqID})`);
    if (!sftp.emit('READLINK', reqID, path)) {
      // Automatically reject request if no handler for request type
      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
    }
  },
  [REQUEST.SYMLINK]: (sftp, payload) => {
    bufferParser.init(payload, 1);
    const reqID = bufferParser.readUInt32BE();
    /*
      string     linkpath
      string     targetpath
    */
    const linkPath = bufferParser.readString(true);
    const targetPath = bufferParser.readString(true);
    bufferParser.clear();
    if (targetPath === undefined) return doFatalSFTPError(sftp, 'Malformed SYMLINK packet');
    sftp._debug && sftp._debug(`SFTP: Inbound: Received SYMLINK (id:${reqID})`);
    let handled;
    if (sftp._isOpenSSH) {
      // OpenSSH has linkpath and targetpath positions switched
      handled = sftp.emit('SYMLINK', reqID, targetPath, linkPath);
    } else {
      handled = sftp.emit('SYMLINK', reqID, linkPath, targetPath);
    }
    if (!handled) {
      // Automatically reject request if no handler for request type
      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
    }
  },
  [REQUEST.EXTENDED]: (sftp, payload) => {
    bufferParser.init(payload, 1);
    const reqID = bufferParser.readUInt32BE();
    /*
      string     extended-request
      ... any request-specific data ...
    */
    const extName = bufferParser.readString(true);
    if (extName === undefined) {
      bufferParser.clear();
      return doFatalSFTPError(sftp, 'Malformed EXTENDED packet');
    }
    let extData;
    if (bufferParser.avail()) extData = bufferParser.readRaw();
    bufferParser.clear();
    sftp._debug && sftp._debug(`SFTP: Inbound: Received EXTENDED (id:${reqID})`);
    if (!sftp.emit('EXTENDED', reqID, extName, extData)) {
      // Automatically reject request if no handler for request type
      sftp.status(reqID, STATUS_CODE.OP_UNSUPPORTED);
    }
  }
};

// =============================================================================
// ReadStream/WriteStream-related ==============================================
// =============================================================================
const {
  ERR_INVALID_ARG_TYPE,
  ERR_OUT_OF_RANGE,
  validateNumber
} = __webpack_require__(/*! ./node-fs-compat */ 3281);
const kMinPoolSpace = 128;
let pool;
// It can happen that we expect to read a large chunk of data, and reserve
// a large chunk of the pool accordingly, but the read() call only filled
// a portion of it. If a concurrently executing read() then uses the same pool,
// the "reserved" portion cannot be used, so we allow it to be re-used as a
// new pool later.
const poolFragments = [];
function allocNewPool(poolSize) {
  if (poolFragments.length > 0) pool = poolFragments.pop();else pool = Buffer.allocUnsafe(poolSize);
  pool.used = 0;
}

// Check the `this.start` and `this.end` of stream.
function checkPosition(pos, name) {
  if (!Number.isSafeInteger(pos)) {
    validateNumber(pos, name);
    if (!Number.isInteger(pos)) throw new ERR_OUT_OF_RANGE(name, 'an integer', pos);
    throw new ERR_OUT_OF_RANGE(name, '>= 0 and <= 2 ** 53 - 1', pos);
  }
  if (pos < 0) throw new ERR_OUT_OF_RANGE(name, '>= 0 and <= 2 ** 53 - 1', pos);
}
function roundUpToMultipleOf8(n) {
  return n + 7 & ~7; // Align to 8 byte boundary.
}

function ReadStream(sftp, path, options) {
  if (options === undefined) options = {};else if (typeof options === 'string') options = {
    encoding: options
  };else if (options === null || typeof options !== 'object') throw new TypeError('"options" argument must be a string or an object');else options = Object.create(options);

  // A little bit bigger buffer and water marks by default
  if (options.highWaterMark === undefined) options.highWaterMark = 64 * 1024;

  // For backwards compat do not emit close on destroy.
  options.emitClose = false;
  options.autoDestroy = false; // Node 14 major change.

  ReadableStream.call(this, options);
  this.path = path;
  this.flags = options.flags === undefined ? 'r' : options.flags;
  this.mode = options.mode === undefined ? 0o666 : options.mode;
  this.start = options.start;
  this.end = options.end;
  this.autoClose = options.autoClose === undefined ? true : options.autoClose;
  this.pos = 0;
  this.bytesRead = 0;
  this.isClosed = false;
  this.handle = options.handle === undefined ? null : options.handle;
  this.sftp = sftp;
  this._opening = false;
  if (this.start !== undefined) {
    checkPosition(this.start, 'start');
    this.pos = this.start;
  }
  if (this.end === undefined) {
    this.end = Infinity;
  } else if (this.end !== Infinity) {
    checkPosition(this.end, 'end');
    if (this.start !== undefined && this.start > this.end) {
      throw new ERR_OUT_OF_RANGE('start', `<= "end" (here: ${this.end})`, this.start);
    }
  }
  this.on('end', function () {
    if (this.autoClose) this.destroy();
  });
  if (!Buffer.isBuffer(this.handle)) this.open();
}
inherits(ReadStream, ReadableStream);
ReadStream.prototype.open = function () {
  if (this._opening) return;
  this._opening = true;
  this.sftp.open(this.path, this.flags, this.mode, (er, handle) => {
    this._opening = false;
    if (er) {
      this.emit('error', er);
      if (this.autoClose) this.destroy();
      return;
    }
    this.handle = handle;
    this.emit('open', handle);
    this.emit('ready');
    // Start the flow of data.
    this.read();
  });
};
ReadStream.prototype._read = function (n) {
  if (!Buffer.isBuffer(this.handle)) return this.once('open', () => this._read(n));

  // XXX: safe to remove this?
  if (this.destroyed) return;
  if (!pool || pool.length - pool.used < kMinPoolSpace) {
    // Discard the old pool.
    allocNewPool(this.readableHighWaterMark || this._readableState.highWaterMark);
  }

  // Grab another reference to the pool in the case that while we're
  // in the thread pool another read() finishes up the pool, and
  // allocates a new one.
  const thisPool = pool;
  let toRead = Math.min(pool.length - pool.used, n);
  const start = pool.used;
  if (this.end !== undefined) toRead = Math.min(this.end - this.pos + 1, toRead);

  // Already read everything we were supposed to read!
  // treat as EOF.
  if (toRead <= 0) return this.push(null);

  // the actual read.
  this.sftp.read(this.handle, pool, pool.used, toRead, this.pos, (er, bytesRead) => {
    if (er) {
      this.emit('error', er);
      if (this.autoClose) this.destroy();
      return;
    }
    let b = null;

    // Now that we know how much data we have actually read, re-wind the
    // 'used' field if we can, and otherwise allow the remainder of our
    // reservation to be used as a new pool later.
    if (start + toRead === thisPool.used && thisPool === pool) {
      thisPool.used = roundUpToMultipleOf8(thisPool.used + bytesRead - toRead);
    } else {
      // Round down to the next lowest multiple of 8 to ensure the new pool
      // fragment start and end positions are aligned to an 8 byte boundary.
      const alignedEnd = start + toRead & ~7;
      const alignedStart = roundUpToMultipleOf8(start + bytesRead);
      if (alignedEnd - alignedStart >= kMinPoolSpace) poolFragments.push(thisPool.slice(alignedStart, alignedEnd));
    }
    if (bytesRead > 0) {
      this.bytesRead += bytesRead;
      b = thisPool.slice(start, start + bytesRead);
    }

    // Move the pool positions, and internal position for reading.
    this.pos += bytesRead;
    this.push(b);
  });
  pool.used = roundUpToMultipleOf8(pool.used + toRead);
};
ReadStream.prototype._destroy = function (err, cb) {
  if (this._opening && !Buffer.isBuffer(this.handle)) {
    this.once('open', closeStream.bind(null, this, cb, err));
    return;
  }
  closeStream(this, cb, err);
  this.handle = null;
  this._opening = false;
};
function closeStream(stream, cb, err) {
  if (!stream.handle) return onclose();
  stream.sftp.close(stream.handle, onclose);
  function onclose(er) {
    er = er || err;
    cb(er);
    stream.isClosed = true;
    if (!er) stream.emit('close');
  }
}
ReadStream.prototype.close = function (cb) {
  this.destroy(null, cb);
};
Object.defineProperty(ReadStream.prototype, 'pending', {
  get() {
    return this.handle === null;
  },
  configurable: true
});

// TODO: add `concurrency` setting to allow more than one in-flight WRITE
// request to server to improve throughput
function WriteStream(sftp, path, options) {
  if (options === undefined) options = {};else if (typeof options === 'string') options = {
    encoding: options
  };else if (options === null || typeof options !== 'object') throw new TypeError('"options" argument must be a string or an object');else options = Object.create(options);

  // For backwards compat do not emit close on destroy.
  options.emitClose = false;
  options.autoDestroy = false; // Node 14 major change.

  WritableStream.call(this, options);
  this.path = path;
  this.flags = options.flags === undefined ? 'w' : options.flags;
  this.mode = options.mode === undefined ? 0o666 : options.mode;
  this.start = options.start;
  this.autoClose = options.autoClose === undefined ? true : options.autoClose;
  this.pos = 0;
  this.bytesWritten = 0;
  this.isClosed = false;
  this.handle = options.handle === undefined ? null : options.handle;
  this.sftp = sftp;
  this._opening = false;
  if (this.start !== undefined) {
    checkPosition(this.start, 'start');
    this.pos = this.start;
  }
  if (options.encoding) this.setDefaultEncoding(options.encoding);

  // Node v6.x only
  this.on('finish', function () {
    if (this._writableState.finalCalled) return;
    if (this.autoClose) this.destroy();
  });
  if (!Buffer.isBuffer(this.handle)) this.open();
}
inherits(WriteStream, WritableStream);
WriteStream.prototype._final = function (cb) {
  if (this.autoClose) this.destroy();
  cb();
};
WriteStream.prototype.open = function () {
  if (this._opening) return;
  this._opening = true;
  this.sftp.open(this.path, this.flags, this.mode, (er, handle) => {
    this._opening = false;
    if (er) {
      this.emit('error', er);
      if (this.autoClose) this.destroy();
      return;
    }
    this.handle = handle;
    const tryAgain = err => {
      if (err) {
        // Try chmod() for sftp servers that may not support fchmod() for
        // whatever reason
        this.sftp.chmod(this.path, this.mode, err_ => tryAgain());
        return;
      }

      // SFTPv3 requires absolute offsets, no matter the open flag used
      if (this.flags[0] === 'a') {
        const tryStat = (err, st) => {
          if (err) {
            // Try stat() for sftp servers that may not support fstat() for
            // whatever reason
            this.sftp.stat(this.path, (err_, st_) => {
              if (err_) {
                this.destroy();
                this.emit('error', err);
                return;
              }
              tryStat(null, st_);
            });
            return;
          }
          this.pos = st.size;
          this.emit('open', handle);
          this.emit('ready');
        };
        this.sftp.fstat(handle, tryStat);
        return;
      }
      this.emit('open', handle);
      this.emit('ready');
    };
    this.sftp.fchmod(handle, this.mode, tryAgain);
  });
};
WriteStream.prototype._write = function (data, encoding, cb) {
  if (!Buffer.isBuffer(data)) {
    const err = new ERR_INVALID_ARG_TYPE('data', 'Buffer', data);
    return this.emit('error', err);
  }
  if (!Buffer.isBuffer(this.handle)) {
    return this.once('open', function () {
      this._write(data, encoding, cb);
    });
  }
  this.sftp.write(this.handle, data, 0, data.length, this.pos, (er, bytes) => {
    if (er) {
      if (this.autoClose) this.destroy();
      return cb(er);
    }
    this.bytesWritten += bytes;
    cb();
  });
  this.pos += data.length;
};
WriteStream.prototype._writev = function (data, cb) {
  if (!Buffer.isBuffer(this.handle)) {
    return this.once('open', function () {
      this._writev(data, cb);
    });
  }
  const sftp = this.sftp;
  const handle = this.handle;
  let writesLeft = data.length;
  const onwrite = (er, bytes) => {
    if (er) {
      this.destroy();
      return cb(er);
    }
    this.bytesWritten += bytes;
    if (--writesLeft === 0) cb();
  };

  // TODO: try to combine chunks to reduce number of requests to the server?
  for (let i = 0; i < data.length; ++i) {
    const chunk = data[i].chunk;
    sftp.write(handle, chunk, 0, chunk.length, this.pos, onwrite);
    this.pos += chunk.length;
  }
};
if (typeof WritableStream.prototype.destroy !== 'function') WriteStream.prototype.destroy = ReadStream.prototype.destroy;
WriteStream.prototype._destroy = ReadStream.prototype._destroy;
WriteStream.prototype.close = function (cb) {
  if (cb) {
    if (this.isClosed) {
      process.nextTick(cb);
      return;
    }
    this.on('close', cb);
  }

  // If we are not autoClosing, we should call
  // destroy on 'finish'.
  if (!this.autoClose) this.on('finish', this.destroy.bind(this));
  this.end();
};

// There is no shutdown() for files.
WriteStream.prototype.destroySoon = WriteStream.prototype.end;
Object.defineProperty(WriteStream.prototype, 'pending', {
  get() {
    return this.handle === null;
  },
  configurable: true
});
// =============================================================================

module.exports = {
  flagsToString,
  OPEN_MODE,
  SFTP,
  Stats,
  STATUS_CODE,
  stringToFlags
};

/***/ }),

/***/ 7816:
/*!******************************************************!*\
  !*** ../node_modules/ssh2/lib/protocol/constants.js ***!
  \******************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


const crypto = __webpack_require__(/*! crypto */ 6113);
let cpuInfo;
try {
  cpuInfo = __webpack_require__(/*! cpu-features */ 7493)();
} catch {}
const {
  bindingAvailable,
  CIPHER_INFO,
  MAC_INFO
} = __webpack_require__(/*! ./crypto.js */ 6173);
const eddsaSupported = (() => {
  if (typeof crypto.sign === 'function' && typeof crypto.verify === 'function') {
    const key = '-----BEGIN PRIVATE KEY-----\r\nMC4CAQAwBQYDK2VwBCIEIHKj+sVa9WcD' + '/q2DJUJaf43Kptc8xYuUQA4bOFj9vC8T\r\n-----END PRIVATE KEY-----';
    const data = Buffer.from('a');
    let sig;
    let verified;
    try {
      sig = crypto.sign(null, data, key);
      verified = crypto.verify(null, data, key, sig);
    } catch {}
    return Buffer.isBuffer(sig) && sig.length === 64 && verified === true;
  }
  return false;
})();
const curve25519Supported = typeof crypto.diffieHellman === 'function' && typeof crypto.generateKeyPairSync === 'function' && typeof crypto.createPublicKey === 'function';
const DEFAULT_KEX = [
// https://tools.ietf.org/html/rfc5656#section-10.1
'ecdh-sha2-nistp256', 'ecdh-sha2-nistp384', 'ecdh-sha2-nistp521',
// https://tools.ietf.org/html/rfc4419#section-4
'diffie-hellman-group-exchange-sha256',
// https://tools.ietf.org/html/rfc8268
'diffie-hellman-group14-sha256', 'diffie-hellman-group15-sha512', 'diffie-hellman-group16-sha512', 'diffie-hellman-group17-sha512', 'diffie-hellman-group18-sha512'];
if (curve25519Supported) {
  DEFAULT_KEX.unshift('curve25519-sha256');
  DEFAULT_KEX.unshift('curve25519-sha256@libssh.org');
}
const SUPPORTED_KEX = DEFAULT_KEX.concat([
// https://tools.ietf.org/html/rfc4419#section-4
'diffie-hellman-group-exchange-sha1', 'diffie-hellman-group14-sha1',
// REQUIRED
'diffie-hellman-group1-sha1' // REQUIRED
]);

const DEFAULT_SERVER_HOST_KEY = ['ecdsa-sha2-nistp256', 'ecdsa-sha2-nistp384', 'ecdsa-sha2-nistp521', 'rsa-sha2-512',
// RFC 8332
'rsa-sha2-256',
// RFC 8332
'ssh-rsa'];
if (eddsaSupported) DEFAULT_SERVER_HOST_KEY.unshift('ssh-ed25519');
const SUPPORTED_SERVER_HOST_KEY = DEFAULT_SERVER_HOST_KEY.concat(['ssh-dss']);
const canUseCipher = (() => {
  const ciphers = crypto.getCiphers();
  return name => ciphers.includes(CIPHER_INFO[name].sslName);
})();
let DEFAULT_CIPHER = [
// http://tools.ietf.org/html/rfc5647
'aes128-gcm@openssh.com', 'aes256-gcm@openssh.com',
// http://tools.ietf.org/html/rfc4344#section-4
'aes128-ctr', 'aes192-ctr', 'aes256-ctr'];
if (cpuInfo && cpuInfo.flags && !cpuInfo.flags.aes) {
  // We know for sure the CPU does not support AES acceleration
  if (bindingAvailable) DEFAULT_CIPHER.unshift('chacha20-poly1305@openssh.com');else DEFAULT_CIPHER.push('chacha20-poly1305@openssh.com');
} else if (bindingAvailable && cpuInfo && cpuInfo.arch === 'x86') {
  // Places chacha20-poly1305 immediately after GCM ciphers since GCM ciphers
  // seem to outperform it on x86, but it seems to be faster than CTR ciphers
  DEFAULT_CIPHER.splice(4, 0, 'chacha20-poly1305@openssh.com');
} else {
  DEFAULT_CIPHER.push('chacha20-poly1305@openssh.com');
}
DEFAULT_CIPHER = DEFAULT_CIPHER.filter(canUseCipher);
const SUPPORTED_CIPHER = DEFAULT_CIPHER.concat(['aes256-cbc', 'aes192-cbc', 'aes128-cbc', 'blowfish-cbc', '3des-cbc', 'aes128-gcm', 'aes256-gcm',
// http://tools.ietf.org/html/rfc4345#section-4:
'arcfour256', 'arcfour128', 'cast128-cbc', 'arcfour'].filter(canUseCipher));
const canUseMAC = (() => {
  const hashes = crypto.getHashes();
  return name => hashes.includes(MAC_INFO[name].sslName);
})();
const DEFAULT_MAC = ['hmac-sha2-256-etm@openssh.com', 'hmac-sha2-512-etm@openssh.com', 'hmac-sha1-etm@openssh.com', 'hmac-sha2-256', 'hmac-sha2-512', 'hmac-sha1'].filter(canUseMAC);
const SUPPORTED_MAC = DEFAULT_MAC.concat(['hmac-md5', 'hmac-sha2-256-96',
// first 96 bits of HMAC-SHA256
'hmac-sha2-512-96',
// first 96 bits of HMAC-SHA512
'hmac-ripemd160', 'hmac-sha1-96',
// first 96 bits of HMAC-SHA1
'hmac-md5-96' // first 96 bits of HMAC-MD5
].filter(canUseMAC));
const DEFAULT_COMPRESSION = ['none', 'zlib@openssh.com',
// ZLIB (LZ77) compression, except
// compression/decompression does not start until after
// successful user authentication
'zlib' // ZLIB (LZ77) compression
];

const SUPPORTED_COMPRESSION = DEFAULT_COMPRESSION.concat([]);
const COMPAT = {
  BAD_DHGEX: 1 << 0,
  OLD_EXIT: 1 << 1,
  DYN_RPORT_BUG: 1 << 2,
  BUG_DHGEX_LARGE: 1 << 3
};
module.exports = {
  MESSAGE: {
    // Transport layer protocol -- generic (1-19)
    DISCONNECT: 1,
    IGNORE: 2,
    UNIMPLEMENTED: 3,
    DEBUG: 4,
    SERVICE_REQUEST: 5,
    SERVICE_ACCEPT: 6,
    // Transport layer protocol -- algorithm negotiation (20-29)
    KEXINIT: 20,
    NEWKEYS: 21,
    // Transport layer protocol -- key exchange method-specific (30-49)
    KEXDH_INIT: 30,
    KEXDH_REPLY: 31,
    KEXDH_GEX_GROUP: 31,
    KEXDH_GEX_INIT: 32,
    KEXDH_GEX_REPLY: 33,
    KEXDH_GEX_REQUEST: 34,
    KEXECDH_INIT: 30,
    KEXECDH_REPLY: 31,
    // User auth protocol -- generic (50-59)
    USERAUTH_REQUEST: 50,
    USERAUTH_FAILURE: 51,
    USERAUTH_SUCCESS: 52,
    USERAUTH_BANNER: 53,
    // User auth protocol -- user auth method-specific (60-79)
    USERAUTH_PASSWD_CHANGEREQ: 60,
    USERAUTH_PK_OK: 60,
    USERAUTH_INFO_REQUEST: 60,
    USERAUTH_INFO_RESPONSE: 61,
    // Connection protocol -- generic (80-89)
    GLOBAL_REQUEST: 80,
    REQUEST_SUCCESS: 81,
    REQUEST_FAILURE: 82,
    // Connection protocol -- channel-related (90-127)
    CHANNEL_OPEN: 90,
    CHANNEL_OPEN_CONFIRMATION: 91,
    CHANNEL_OPEN_FAILURE: 92,
    CHANNEL_WINDOW_ADJUST: 93,
    CHANNEL_DATA: 94,
    CHANNEL_EXTENDED_DATA: 95,
    CHANNEL_EOF: 96,
    CHANNEL_CLOSE: 97,
    CHANNEL_REQUEST: 98,
    CHANNEL_SUCCESS: 99,
    CHANNEL_FAILURE: 100

    // Reserved for client protocols (128-191)

    // Local extensions (192-155)
  },

  DISCONNECT_REASON: {
    HOST_NOT_ALLOWED_TO_CONNECT: 1,
    PROTOCOL_ERROR: 2,
    KEY_EXCHANGE_FAILED: 3,
    RESERVED: 4,
    MAC_ERROR: 5,
    COMPRESSION_ERROR: 6,
    SERVICE_NOT_AVAILABLE: 7,
    PROTOCOL_VERSION_NOT_SUPPORTED: 8,
    HOST_KEY_NOT_VERIFIABLE: 9,
    CONNECTION_LOST: 10,
    BY_APPLICATION: 11,
    TOO_MANY_CONNECTIONS: 12,
    AUTH_CANCELED_BY_USER: 13,
    NO_MORE_AUTH_METHODS_AVAILABLE: 14,
    ILLEGAL_USER_NAME: 15
  },
  DISCONNECT_REASON_STR: undefined,
  CHANNEL_OPEN_FAILURE: {
    ADMINISTRATIVELY_PROHIBITED: 1,
    CONNECT_FAILED: 2,
    UNKNOWN_CHANNEL_TYPE: 3,
    RESOURCE_SHORTAGE: 4
  },
  TERMINAL_MODE: {
    TTY_OP_END: 0,
    // Indicates end of options.
    VINTR: 1,
    // Interrupt character; 255 if none. Similarly for the
    //  other characters.  Not all of these characters are
    //  supported on all systems.
    VQUIT: 2,
    // The quit character (sends SIGQUIT signal on POSIX
    //  systems).
    VERASE: 3,
    // Erase the character to left of the cursor.
    VKILL: 4,
    // Kill the current input line.
    VEOF: 5,
    // End-of-file character (sends EOF from the
    //  terminal).
    VEOL: 6,
    // End-of-line character in addition to carriage
    //  return and/or linefeed.
    VEOL2: 7,
    // Additional end-of-line character.
    VSTART: 8,
    // Continues paused output (normally control-Q).
    VSTOP: 9,
    // Pauses output (normally control-S).
    VSUSP: 10,
    // Suspends the current program.
    VDSUSP: 11,
    // Another suspend character.
    VREPRINT: 12,
    // Reprints the current input line.
    VWERASE: 13,
    // Erases a word left of cursor.
    VLNEXT: 14,
    // Enter the next character typed literally, even if
    //  it is a special character
    VFLUSH: 15,
    // Character to flush output.
    VSWTCH: 16,
    // Switch to a different shell layer.
    VSTATUS: 17,
    // Prints system status line (load, command, pid,
    //  etc).
    VDISCARD: 18,
    // Toggles the flushing of terminal output.
    IGNPAR: 30,
    // The ignore parity flag.  The parameter SHOULD be 0
    //  if this flag is FALSE, and 1 if it is TRUE.
    PARMRK: 31,
    // Mark parity and framing errors.
    INPCK: 32,
    // Enable checking of parity errors.
    ISTRIP: 33,
    // Strip 8th bit off characters.
    INLCR: 34,
    // Map NL into CR on input.
    IGNCR: 35,
    // Ignore CR on input.
    ICRNL: 36,
    // Map CR to NL on input.
    IUCLC: 37,
    // Translate uppercase characters to lowercase.
    IXON: 38,
    // Enable output flow control.
    IXANY: 39,
    // Any char will restart after stop.
    IXOFF: 40,
    // Enable input flow control.
    IMAXBEL: 41,
    // Ring bell on input queue full.
    ISIG: 50,
    // Enable signals INTR, QUIT, [D]SUSP.
    ICANON: 51,
    // Canonicalize input lines.
    XCASE: 52,
    // Enable input and output of uppercase characters by
    //  preceding their lowercase equivalents with "\".
    ECHO: 53,
    // Enable echoing.
    ECHOE: 54,
    // Visually erase chars.
    ECHOK: 55,
    // Kill character discards current line.
    ECHONL: 56,
    // Echo NL even if ECHO is off.
    NOFLSH: 57,
    // Don't flush after interrupt.
    TOSTOP: 58,
    // Stop background jobs from output.
    IEXTEN: 59,
    // Enable extensions.
    ECHOCTL: 60,
    // Echo control characters as ^(Char).
    ECHOKE: 61,
    // Visual erase for line kill.
    PENDIN: 62,
    // Retype pending input.
    OPOST: 70,
    // Enable output processing.
    OLCUC: 71,
    // Convert lowercase to uppercase.
    ONLCR: 72,
    // Map NL to CR-NL.
    OCRNL: 73,
    // Translate carriage return to newline (output).
    ONOCR: 74,
    // Translate newline to carriage return-newline
    //  (output).
    ONLRET: 75,
    // Newline performs a carriage return (output).
    CS7: 90,
    // 7 bit mode.
    CS8: 91,
    // 8 bit mode.
    PARENB: 92,
    // Parity enable.
    PARODD: 93,
    // Odd parity, else even.
    TTY_OP_ISPEED: 128,
    // Specifies the input baud rate in bits per second.
    TTY_OP_OSPEED: 129 // Specifies the output baud rate in bits per second.
  },

  CHANNEL_EXTENDED_DATATYPE: {
    STDERR: 1
  },
  SIGNALS: ['ABRT', 'ALRM', 'FPE', 'HUP', 'ILL', 'INT', 'QUIT', 'SEGV', 'TERM', 'USR1', 'USR2', 'KILL', 'PIPE'].reduce((cur, val) => ({
    ...cur,
    [val]: 1
  }), {}),
  COMPAT,
  COMPAT_CHECKS: [['Cisco-1.25', COMPAT.BAD_DHGEX], [/^Cisco-1\./, COMPAT.BUG_DHGEX_LARGE], [/^[0-9.]+$/, COMPAT.OLD_EXIT],
  // old SSH.com implementations
  [/^OpenSSH_5\.\d+/, COMPAT.DYN_RPORT_BUG]],
  // KEX proposal-related
  DEFAULT_KEX,
  SUPPORTED_KEX,
  DEFAULT_SERVER_HOST_KEY,
  SUPPORTED_SERVER_HOST_KEY,
  DEFAULT_CIPHER,
  SUPPORTED_CIPHER,
  DEFAULT_MAC,
  SUPPORTED_MAC,
  DEFAULT_COMPRESSION,
  SUPPORTED_COMPRESSION,
  curve25519Supported,
  eddsaSupported
};
module.exports.DISCONNECT_REASON_BY_VALUE = Array.from(Object.entries(module.exports.DISCONNECT_REASON)).reduce((obj, [key, value]) => ({
  ...obj,
  [value]: key
}), {});

/***/ }),

/***/ 6173:
/*!***************************************************!*\
  !*** ../node_modules/ssh2/lib/protocol/crypto.js ***!
  \***************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";
// TODO:
//    * make max packet size configurable
//    * if decompression is enabled, use `._packet` in decipher instances as
//      input to (sync) zlib inflater with appropriate offset and length to
//      avoid an additional copy of payload data before inflation
//    * factor decompression status into packet length checks


const {
  createCipheriv,
  createDecipheriv,
  createHmac,
  randomFillSync,
  timingSafeEqual
} = __webpack_require__(/*! crypto */ 6113);
const {
  readUInt32BE,
  writeUInt32BE
} = __webpack_require__(/*! ./utils.js */ 3549);
const FastBuffer = Buffer[Symbol.species];
const MAX_SEQNO = 2 ** 32 - 1;
const EMPTY_BUFFER = Buffer.alloc(0);
const BUF_INT = Buffer.alloc(4);
const DISCARD_CACHE = new Map();
const MAX_PACKET_SIZE = 35000;
let binding;
let AESGCMCipher;
let ChaChaPolyCipher;
let GenericCipher;
let AESGCMDecipher;
let ChaChaPolyDecipher;
let GenericDecipher;
try {
  binding = __webpack_require__(/*! ./crypto/build/Release/sshcrypto.node */ 1497);
  ({
    AESGCMCipher,
    ChaChaPolyCipher,
    GenericCipher,
    AESGCMDecipher,
    ChaChaPolyDecipher,
    GenericDecipher
  } = binding);
} catch {}
const CIPHER_STREAM = 1 << 0;
const CIPHER_INFO = (() => {
  function info(sslName, blockLen, keyLen, ivLen, authLen, discardLen, flags) {
    return {
      sslName,
      blockLen,
      keyLen,
      ivLen: ivLen !== 0 || flags & CIPHER_STREAM ? ivLen : blockLen,
      authLen,
      discardLen,
      stream: !!(flags & CIPHER_STREAM)
    };
  }
  return {
    'chacha20-poly1305@openssh.com': info('chacha20', 8, 64, 0, 16, 0, CIPHER_STREAM),
    'aes128-gcm': info('aes-128-gcm', 16, 16, 12, 16, 0, CIPHER_STREAM),
    'aes256-gcm': info('aes-256-gcm', 16, 32, 12, 16, 0, CIPHER_STREAM),
    'aes128-gcm@openssh.com': info('aes-128-gcm', 16, 16, 12, 16, 0, CIPHER_STREAM),
    'aes256-gcm@openssh.com': info('aes-256-gcm', 16, 32, 12, 16, 0, CIPHER_STREAM),
    'aes128-cbc': info('aes-128-cbc', 16, 16, 0, 0, 0, 0),
    'aes192-cbc': info('aes-192-cbc', 16, 24, 0, 0, 0, 0),
    'aes256-cbc': info('aes-256-cbc', 16, 32, 0, 0, 0, 0),
    'rijndael-cbc@lysator.liu.se': info('aes-256-cbc', 16, 32, 0, 0, 0, 0),
    '3des-cbc': info('des-ede3-cbc', 8, 24, 0, 0, 0, 0),
    'blowfish-cbc': info('bf-cbc', 8, 16, 0, 0, 0, 0),
    'idea-cbc': info('idea-cbc', 8, 16, 0, 0, 0, 0),
    'cast128-cbc': info('cast-cbc', 8, 16, 0, 0, 0, 0),
    'aes128-ctr': info('aes-128-ctr', 16, 16, 16, 0, 0, CIPHER_STREAM),
    'aes192-ctr': info('aes-192-ctr', 16, 24, 16, 0, 0, CIPHER_STREAM),
    'aes256-ctr': info('aes-256-ctr', 16, 32, 16, 0, 0, CIPHER_STREAM),
    '3des-ctr': info('des-ede3', 8, 24, 8, 0, 0, CIPHER_STREAM),
    'blowfish-ctr': info('bf-ecb', 8, 16, 8, 0, 0, CIPHER_STREAM),
    'cast128-ctr': info('cast5-ecb', 8, 16, 8, 0, 0, CIPHER_STREAM),
    /* The "arcfour128" algorithm is the RC4 cipher, as described in
       [SCHNEIER], using a 128-bit key.  The first 1536 bytes of keystream
       generated by the cipher MUST be discarded, and the first byte of the
       first encrypted packet MUST be encrypted using the 1537th byte of
       keystream.
        -- http://tools.ietf.org/html/rfc4345#section-4 */
    'arcfour': info('rc4', 8, 16, 0, 0, 1536, CIPHER_STREAM),
    'arcfour128': info('rc4', 8, 16, 0, 0, 1536, CIPHER_STREAM),
    'arcfour256': info('rc4', 8, 32, 0, 0, 1536, CIPHER_STREAM),
    'arcfour512': info('rc4', 8, 64, 0, 0, 1536, CIPHER_STREAM)
  };
})();
const MAC_INFO = (() => {
  function info(sslName, len, actualLen, isETM) {
    return {
      sslName,
      len,
      actualLen,
      isETM
    };
  }
  return {
    'hmac-md5': info('md5', 16, 16, false),
    'hmac-md5-96': info('md5', 16, 12, false),
    'hmac-ripemd160': info('ripemd160', 20, 20, false),
    'hmac-sha1': info('sha1', 20, 20, false),
    'hmac-sha1-etm@openssh.com': info('sha1', 20, 20, true),
    'hmac-sha1-96': info('sha1', 20, 12, false),
    'hmac-sha2-256': info('sha256', 32, 32, false),
    'hmac-sha2-256-etm@openssh.com': info('sha256', 32, 32, true),
    'hmac-sha2-256-96': info('sha256', 32, 12, false),
    'hmac-sha2-512': info('sha512', 64, 64, false),
    'hmac-sha2-512-etm@openssh.com': info('sha512', 64, 64, true),
    'hmac-sha2-512-96': info('sha512', 64, 12, false)
  };
})();

// Should only_be used during the initial handshake
class NullCipher {
  constructor(seqno, onWrite) {
    this.outSeqno = seqno;
    this._onWrite = onWrite;
    this._dead = false;
  }
  free() {
    this._dead = true;
  }
  allocPacket(payloadLen) {
    let pktLen = 4 + 1 + payloadLen;
    let padLen = 8 - (pktLen & 8 - 1);
    if (padLen < 4) padLen += 8;
    pktLen += padLen;
    const packet = Buffer.allocUnsafe(pktLen);
    writeUInt32BE(packet, pktLen - 4, 0);
    packet[4] = padLen;
    randomFillSync(packet, 5 + payloadLen, padLen);
    return packet;
  }
  encrypt(packet) {
    // `packet` === unencrypted packet

    if (this._dead) return;
    this._onWrite(packet);
    this.outSeqno = this.outSeqno + 1 >>> 0;
  }
}
const POLY1305_ZEROS = Buffer.alloc(32);
const POLY1305_OUT_COMPUTE = Buffer.alloc(16);
let POLY1305_WASM_MODULE;
let POLY1305_RESULT_MALLOC;
let poly1305_auth;
class ChaChaPolyCipherNative {
  constructor(config) {
    const enc = config.outbound;
    this.outSeqno = enc.seqno;
    this._onWrite = enc.onWrite;
    this._encKeyMain = enc.cipherKey.slice(0, 32);
    this._encKeyPktLen = enc.cipherKey.slice(32);
    this._dead = false;
  }
  free() {
    this._dead = true;
  }
  allocPacket(payloadLen) {
    let pktLen = 4 + 1 + payloadLen;
    let padLen = 8 - (pktLen - 4 & 8 - 1);
    if (padLen < 4) padLen += 8;
    pktLen += padLen;
    const packet = Buffer.allocUnsafe(pktLen);
    writeUInt32BE(packet, pktLen - 4, 0);
    packet[4] = padLen;
    randomFillSync(packet, 5 + payloadLen, padLen);
    return packet;
  }
  encrypt(packet) {
    // `packet` === unencrypted packet

    if (this._dead) return;

    // Generate Poly1305 key
    POLY1305_OUT_COMPUTE[0] = 0; // Set counter to 0 (little endian)
    writeUInt32BE(POLY1305_OUT_COMPUTE, this.outSeqno, 12);
    const polyKey = createCipheriv('chacha20', this._encKeyMain, POLY1305_OUT_COMPUTE).update(POLY1305_ZEROS);

    // Encrypt packet length
    const pktLenEnc = createCipheriv('chacha20', this._encKeyPktLen, POLY1305_OUT_COMPUTE).update(packet.slice(0, 4));
    this._onWrite(pktLenEnc);

    // Encrypt rest of packet
    POLY1305_OUT_COMPUTE[0] = 1; // Set counter to 1 (little endian)
    const payloadEnc = createCipheriv('chacha20', this._encKeyMain, POLY1305_OUT_COMPUTE).update(packet.slice(4));
    this._onWrite(payloadEnc);

    // Calculate Poly1305 MAC
    poly1305_auth(POLY1305_RESULT_MALLOC, pktLenEnc, pktLenEnc.length, payloadEnc, payloadEnc.length, polyKey);
    const mac = Buffer.allocUnsafe(16);
    mac.set(new Uint8Array(POLY1305_WASM_MODULE.HEAPU8.buffer, POLY1305_RESULT_MALLOC, 16), 0);
    this._onWrite(mac);
    this.outSeqno = this.outSeqno + 1 >>> 0;
  }
}
class ChaChaPolyCipherBinding {
  constructor(config) {
    const enc = config.outbound;
    this.outSeqno = enc.seqno;
    this._onWrite = enc.onWrite;
    this._instance = new ChaChaPolyCipher(enc.cipherKey);
    this._dead = false;
  }
  free() {
    this._dead = true;
    this._instance.free();
  }
  allocPacket(payloadLen) {
    let pktLen = 4 + 1 + payloadLen;
    let padLen = 8 - (pktLen - 4 & 8 - 1);
    if (padLen < 4) padLen += 8;
    pktLen += padLen;
    const packet = Buffer.allocUnsafe(pktLen + 16 /* MAC */);

    writeUInt32BE(packet, pktLen - 4, 0);
    packet[4] = padLen;
    randomFillSync(packet, 5 + payloadLen, padLen);
    return packet;
  }
  encrypt(packet) {
    // `packet` === unencrypted packet

    if (this._dead) return;

    // Encrypts in-place
    this._instance.encrypt(packet, this.outSeqno);
    this._onWrite(packet);
    this.outSeqno = this.outSeqno + 1 >>> 0;
  }
}
class AESGCMCipherNative {
  constructor(config) {
    const enc = config.outbound;
    this.outSeqno = enc.seqno;
    this._onWrite = enc.onWrite;
    this._encSSLName = enc.cipherInfo.sslName;
    this._encKey = enc.cipherKey;
    this._encIV = enc.cipherIV;
    this._dead = false;
  }
  free() {
    this._dead = true;
  }
  allocPacket(payloadLen) {
    let pktLen = 4 + 1 + payloadLen;
    let padLen = 16 - (pktLen - 4 & 16 - 1);
    if (padLen < 4) padLen += 16;
    pktLen += padLen;
    const packet = Buffer.allocUnsafe(pktLen);
    writeUInt32BE(packet, pktLen - 4, 0);
    packet[4] = padLen;
    randomFillSync(packet, 5 + payloadLen, padLen);
    return packet;
  }
  encrypt(packet) {
    // `packet` === unencrypted packet

    if (this._dead) return;
    const cipher = createCipheriv(this._encSSLName, this._encKey, this._encIV);
    cipher.setAutoPadding(false);
    const lenData = packet.slice(0, 4);
    cipher.setAAD(lenData);
    this._onWrite(lenData);

    // Encrypt pad length, payload, and padding
    const encrypted = cipher.update(packet.slice(4));
    this._onWrite(encrypted);
    const final = cipher.final();
    // XXX: final.length === 0 always?
    if (final.length) this._onWrite(final);

    // Generate MAC
    const tag = cipher.getAuthTag();
    this._onWrite(tag);

    // Increment counter in IV by 1 for next packet
    ivIncrement(this._encIV);
    this.outSeqno = this.outSeqno + 1 >>> 0;
  }
}
class AESGCMCipherBinding {
  constructor(config) {
    const enc = config.outbound;
    this.outSeqno = enc.seqno;
    this._onWrite = enc.onWrite;
    this._instance = new AESGCMCipher(enc.cipherInfo.sslName, enc.cipherKey, enc.cipherIV);
    this._dead = false;
  }
  free() {
    this._dead = true;
    this._instance.free();
  }
  allocPacket(payloadLen) {
    let pktLen = 4 + 1 + payloadLen;
    let padLen = 16 - (pktLen - 4 & 16 - 1);
    if (padLen < 4) padLen += 16;
    pktLen += padLen;
    const packet = Buffer.allocUnsafe(pktLen + 16 /* authTag */);

    writeUInt32BE(packet, pktLen - 4, 0);
    packet[4] = padLen;
    randomFillSync(packet, 5 + payloadLen, padLen);
    return packet;
  }
  encrypt(packet) {
    // `packet` === unencrypted packet

    if (this._dead) return;

    // Encrypts in-place
    this._instance.encrypt(packet);
    this._onWrite(packet);
    this.outSeqno = this.outSeqno + 1 >>> 0;
  }
}
class GenericCipherNative {
  constructor(config) {
    const enc = config.outbound;
    this.outSeqno = enc.seqno;
    this._onWrite = enc.onWrite;
    this._encBlockLen = enc.cipherInfo.blockLen;
    this._cipherInstance = createCipheriv(enc.cipherInfo.sslName, enc.cipherKey, enc.cipherIV);
    this._macSSLName = enc.macInfo.sslName;
    this._macKey = enc.macKey;
    this._macActualLen = enc.macInfo.actualLen;
    this._macETM = enc.macInfo.isETM;
    this._aadLen = this._macETM ? 4 : 0;
    this._dead = false;
    const discardLen = enc.cipherInfo.discardLen;
    if (discardLen) {
      let discard = DISCARD_CACHE.get(discardLen);
      if (discard === undefined) {
        discard = Buffer.alloc(discardLen);
        DISCARD_CACHE.set(discardLen, discard);
      }
      this._cipherInstance.update(discard);
    }
  }
  free() {
    this._dead = true;
  }
  allocPacket(payloadLen) {
    const blockLen = this._encBlockLen;
    let pktLen = 4 + 1 + payloadLen;
    let padLen = blockLen - (pktLen - this._aadLen & blockLen - 1);
    if (padLen < 4) padLen += blockLen;
    pktLen += padLen;
    const packet = Buffer.allocUnsafe(pktLen);
    writeUInt32BE(packet, pktLen - 4, 0);
    packet[4] = padLen;
    randomFillSync(packet, 5 + payloadLen, padLen);
    return packet;
  }
  encrypt(packet) {
    // `packet` === unencrypted packet

    if (this._dead) return;
    let mac;
    if (this._macETM) {
      // Encrypt pad length, payload, and padding
      const lenBytes = new Uint8Array(packet.buffer, packet.byteOffset, 4);
      const encrypted = this._cipherInstance.update(new Uint8Array(packet.buffer, packet.byteOffset + 4, packet.length - 4));
      this._onWrite(lenBytes);
      this._onWrite(encrypted);

      // TODO: look into storing seqno as 4-byte buffer and incrementing like we
      // do for AES-GCM IVs to avoid having to (re)write all 4 bytes every time
      mac = createHmac(this._macSSLName, this._macKey);
      writeUInt32BE(BUF_INT, this.outSeqno, 0);
      mac.update(BUF_INT);
      mac.update(lenBytes);
      mac.update(encrypted);
    } else {
      // Encrypt length field, pad length, payload, and padding
      const encrypted = this._cipherInstance.update(packet);
      this._onWrite(encrypted);

      // TODO: look into storing seqno as 4-byte buffer and incrementing like we
      // do for AES-GCM IVs to avoid having to (re)write all 4 bytes every time
      mac = createHmac(this._macSSLName, this._macKey);
      writeUInt32BE(BUF_INT, this.outSeqno, 0);
      mac.update(BUF_INT);
      mac.update(packet);
    }
    let digest = mac.digest();
    if (digest.length > this._macActualLen) digest = digest.slice(0, this._macActualLen);
    this._onWrite(digest);
    this.outSeqno = this.outSeqno + 1 >>> 0;
  }
}
class GenericCipherBinding {
  constructor(config) {
    const enc = config.outbound;
    this.outSeqno = enc.seqno;
    this._onWrite = enc.onWrite;
    this._encBlockLen = enc.cipherInfo.blockLen;
    this._macLen = enc.macInfo.len;
    this._macActualLen = enc.macInfo.actualLen;
    this._aadLen = enc.macInfo.isETM ? 4 : 0;
    this._instance = new GenericCipher(enc.cipherInfo.sslName, enc.cipherKey, enc.cipherIV, enc.macInfo.sslName, enc.macKey, enc.macInfo.isETM);
    this._dead = false;
  }
  free() {
    this._dead = true;
    this._instance.free();
  }
  allocPacket(payloadLen) {
    const blockLen = this._encBlockLen;
    let pktLen = 4 + 1 + payloadLen;
    let padLen = blockLen - (pktLen - this._aadLen & blockLen - 1);
    if (padLen < 4) padLen += blockLen;
    pktLen += padLen;
    const packet = Buffer.allocUnsafe(pktLen + this._macLen);
    writeUInt32BE(packet, pktLen - 4, 0);
    packet[4] = padLen;
    randomFillSync(packet, 5 + payloadLen, padLen);
    return packet;
  }
  encrypt(packet) {
    // `packet` === unencrypted packet

    if (this._dead) return;

    // Encrypts in-place
    this._instance.encrypt(packet, this.outSeqno);
    if (this._macActualLen < this._macLen) {
      packet = new FastBuffer(packet.buffer, packet.byteOffset, packet.length - (this._macLen - this._macActualLen));
    }
    this._onWrite(packet);
    this.outSeqno = this.outSeqno + 1 >>> 0;
  }
}
class NullDecipher {
  constructor(seqno, onPayload) {
    this.inSeqno = seqno;
    this._onPayload = onPayload;
    this._len = 0;
    this._lenBytes = 0;
    this._packet = null;
    this._packetPos = 0;
  }
  free() {}
  decrypt(data, p, dataLen) {
    while (p < dataLen) {
      // Read packet length
      if (this._lenBytes < 4) {
        let nb = Math.min(4 - this._lenBytes, dataLen - p);
        this._lenBytes += nb;
        while (nb--) this._len = (this._len << 8) + data[p++];
        if (this._lenBytes < 4) return;
        if (this._len > MAX_PACKET_SIZE || this._len < 8 || (4 + this._len & 7) !== 0) {
          throw new Error('Bad packet length');
        }
        if (p >= dataLen) return;
      }

      // Read padding length, payload, and padding
      if (this._packetPos < this._len) {
        const nb = Math.min(this._len - this._packetPos, dataLen - p);
        let chunk;
        if (p !== 0 || nb !== dataLen) chunk = new Uint8Array(data.buffer, data.byteOffset + p, nb);else chunk = data;
        if (nb === this._len) {
          this._packet = chunk;
        } else {
          if (!this._packet) this._packet = Buffer.allocUnsafe(this._len);
          this._packet.set(chunk, this._packetPos);
        }
        p += nb;
        this._packetPos += nb;
        if (this._packetPos < this._len) return;
      }
      const payload = !this._packet ? EMPTY_BUFFER : new FastBuffer(this._packet.buffer, this._packet.byteOffset + 1, this._packet.length - this._packet[0] - 1);

      // Prepare for next packet
      this.inSeqno = this.inSeqno + 1 >>> 0;
      this._len = 0;
      this._lenBytes = 0;
      this._packet = null;
      this._packetPos = 0;
      {
        const ret = this._onPayload(payload);
        if (ret !== undefined) return ret === false ? p : ret;
      }
    }
  }
}
class ChaChaPolyDecipherNative {
  constructor(config) {
    const dec = config.inbound;
    this.inSeqno = dec.seqno;
    this._onPayload = dec.onPayload;
    this._decKeyMain = dec.decipherKey.slice(0, 32);
    this._decKeyPktLen = dec.decipherKey.slice(32);
    this._len = 0;
    this._lenBuf = Buffer.alloc(4);
    this._lenPos = 0;
    this._packet = null;
    this._pktLen = 0;
    this._mac = Buffer.allocUnsafe(16);
    this._calcMac = Buffer.allocUnsafe(16);
    this._macPos = 0;
  }
  free() {}
  decrypt(data, p, dataLen) {
    // `data` === encrypted data

    while (p < dataLen) {
      // Read packet length
      if (this._lenPos < 4) {
        let nb = Math.min(4 - this._lenPos, dataLen - p);
        while (nb--) this._lenBuf[this._lenPos++] = data[p++];
        if (this._lenPos < 4) return;
        POLY1305_OUT_COMPUTE[0] = 0; // Set counter to 0 (little endian)
        writeUInt32BE(POLY1305_OUT_COMPUTE, this.inSeqno, 12);
        const decLenBytes = createDecipheriv('chacha20', this._decKeyPktLen, POLY1305_OUT_COMPUTE).update(this._lenBuf);
        this._len = readUInt32BE(decLenBytes, 0);
        if (this._len > MAX_PACKET_SIZE || this._len < 8 || (this._len & 7) !== 0) {
          throw new Error('Bad packet length');
        }
      }

      // Read padding length, payload, and padding
      if (this._pktLen < this._len) {
        if (p >= dataLen) return;
        const nb = Math.min(this._len - this._pktLen, dataLen - p);
        let encrypted;
        if (p !== 0 || nb !== dataLen) encrypted = new Uint8Array(data.buffer, data.byteOffset + p, nb);else encrypted = data;
        if (nb === this._len) {
          this._packet = encrypted;
        } else {
          if (!this._packet) this._packet = Buffer.allocUnsafe(this._len);
          this._packet.set(encrypted, this._pktLen);
        }
        p += nb;
        this._pktLen += nb;
        if (this._pktLen < this._len || p >= dataLen) return;
      }

      // Read Poly1305 MAC
      {
        const nb = Math.min(16 - this._macPos, dataLen - p);
        // TODO: avoid copying if entire MAC is in current chunk
        if (p !== 0 || nb !== dataLen) {
          this._mac.set(new Uint8Array(data.buffer, data.byteOffset + p, nb), this._macPos);
        } else {
          this._mac.set(data, this._macPos);
        }
        p += nb;
        this._macPos += nb;
        if (this._macPos < 16) return;
      }

      // Generate Poly1305 key
      POLY1305_OUT_COMPUTE[0] = 0; // Set counter to 0 (little endian)
      writeUInt32BE(POLY1305_OUT_COMPUTE, this.inSeqno, 12);
      const polyKey = createCipheriv('chacha20', this._decKeyMain, POLY1305_OUT_COMPUTE).update(POLY1305_ZEROS);

      // Calculate and compare Poly1305 MACs
      poly1305_auth(POLY1305_RESULT_MALLOC, this._lenBuf, 4, this._packet, this._packet.length, polyKey);
      this._calcMac.set(new Uint8Array(POLY1305_WASM_MODULE.HEAPU8.buffer, POLY1305_RESULT_MALLOC, 16), 0);
      if (!timingSafeEqual(this._calcMac, this._mac)) throw new Error('Invalid MAC');

      // Decrypt packet
      POLY1305_OUT_COMPUTE[0] = 1; // Set counter to 1 (little endian)
      const packet = createDecipheriv('chacha20', this._decKeyMain, POLY1305_OUT_COMPUTE).update(this._packet);
      const payload = new FastBuffer(packet.buffer, packet.byteOffset + 1, packet.length - packet[0] - 1);

      // Prepare for next packet
      this.inSeqno = this.inSeqno + 1 >>> 0;
      this._len = 0;
      this._lenPos = 0;
      this._packet = null;
      this._pktLen = 0;
      this._macPos = 0;
      {
        const ret = this._onPayload(payload);
        if (ret !== undefined) return ret === false ? p : ret;
      }
    }
  }
}
class ChaChaPolyDecipherBinding {
  constructor(config) {
    const dec = config.inbound;
    this.inSeqno = dec.seqno;
    this._onPayload = dec.onPayload;
    this._instance = new ChaChaPolyDecipher(dec.decipherKey);
    this._len = 0;
    this._lenBuf = Buffer.alloc(4);
    this._lenPos = 0;
    this._packet = null;
    this._pktLen = 0;
    this._mac = Buffer.allocUnsafe(16);
    this._macPos = 0;
  }
  free() {
    this._instance.free();
  }
  decrypt(data, p, dataLen) {
    // `data` === encrypted data

    while (p < dataLen) {
      // Read packet length
      if (this._lenPos < 4) {
        let nb = Math.min(4 - this._lenPos, dataLen - p);
        while (nb--) this._lenBuf[this._lenPos++] = data[p++];
        if (this._lenPos < 4) return;
        this._len = this._instance.decryptLen(this._lenBuf, this.inSeqno);
        if (this._len > MAX_PACKET_SIZE || this._len < 8 || (this._len & 7) !== 0) {
          throw new Error('Bad packet length');
        }
        if (p >= dataLen) return;
      }

      // Read padding length, payload, and padding
      if (this._pktLen < this._len) {
        const nb = Math.min(this._len - this._pktLen, dataLen - p);
        let encrypted;
        if (p !== 0 || nb !== dataLen) encrypted = new Uint8Array(data.buffer, data.byteOffset + p, nb);else encrypted = data;
        if (nb === this._len) {
          this._packet = encrypted;
        } else {
          if (!this._packet) this._packet = Buffer.allocUnsafe(this._len);
          this._packet.set(encrypted, this._pktLen);
        }
        p += nb;
        this._pktLen += nb;
        if (this._pktLen < this._len || p >= dataLen) return;
      }

      // Read Poly1305 MAC
      {
        const nb = Math.min(16 - this._macPos, dataLen - p);
        // TODO: avoid copying if entire MAC is in current chunk
        if (p !== 0 || nb !== dataLen) {
          this._mac.set(new Uint8Array(data.buffer, data.byteOffset + p, nb), this._macPos);
        } else {
          this._mac.set(data, this._macPos);
        }
        p += nb;
        this._macPos += nb;
        if (this._macPos < 16) return;
      }
      this._instance.decrypt(this._packet, this._mac, this.inSeqno);
      const payload = new FastBuffer(this._packet.buffer, this._packet.byteOffset + 1, this._packet.length - this._packet[0] - 1);

      // Prepare for next packet
      this.inSeqno = this.inSeqno + 1 >>> 0;
      this._len = 0;
      this._lenPos = 0;
      this._packet = null;
      this._pktLen = 0;
      this._macPos = 0;
      {
        const ret = this._onPayload(payload);
        if (ret !== undefined) return ret === false ? p : ret;
      }
    }
  }
}
class AESGCMDecipherNative {
  constructor(config) {
    const dec = config.inbound;
    this.inSeqno = dec.seqno;
    this._onPayload = dec.onPayload;
    this._decipherInstance = null;
    this._decipherSSLName = dec.decipherInfo.sslName;
    this._decipherKey = dec.decipherKey;
    this._decipherIV = dec.decipherIV;
    this._len = 0;
    this._lenBytes = 0;
    this._packet = null;
    this._packetPos = 0;
    this._pktLen = 0;
    this._tag = Buffer.allocUnsafe(16);
    this._tagPos = 0;
  }
  free() {}
  decrypt(data, p, dataLen) {
    // `data` === encrypted data

    while (p < dataLen) {
      // Read packet length (unencrypted, but AAD)
      if (this._lenBytes < 4) {
        let nb = Math.min(4 - this._lenBytes, dataLen - p);
        this._lenBytes += nb;
        while (nb--) this._len = (this._len << 8) + data[p++];
        if (this._lenBytes < 4) return;
        if (this._len + 20 > MAX_PACKET_SIZE || this._len < 16 || (this._len & 15) !== 0) {
          throw new Error('Bad packet length');
        }
        this._decipherInstance = createDecipheriv(this._decipherSSLName, this._decipherKey, this._decipherIV);
        this._decipherInstance.setAutoPadding(false);
        this._decipherInstance.setAAD(intToBytes(this._len));
      }

      // Read padding length, payload, and padding
      if (this._pktLen < this._len) {
        if (p >= dataLen) return;
        const nb = Math.min(this._len - this._pktLen, dataLen - p);
        let decrypted;
        if (p !== 0 || nb !== dataLen) {
          decrypted = this._decipherInstance.update(new Uint8Array(data.buffer, data.byteOffset + p, nb));
        } else {
          decrypted = this._decipherInstance.update(data);
        }
        if (decrypted.length) {
          if (nb === this._len) {
            this._packet = decrypted;
          } else {
            if (!this._packet) this._packet = Buffer.allocUnsafe(this._len);
            this._packet.set(decrypted, this._packetPos);
          }
          this._packetPos += decrypted.length;
        }
        p += nb;
        this._pktLen += nb;
        if (this._pktLen < this._len || p >= dataLen) return;
      }

      // Read authentication tag
      {
        const nb = Math.min(16 - this._tagPos, dataLen - p);
        if (p !== 0 || nb !== dataLen) {
          this._tag.set(new Uint8Array(data.buffer, data.byteOffset + p, nb), this._tagPos);
        } else {
          this._tag.set(data, this._tagPos);
        }
        p += nb;
        this._tagPos += nb;
        if (this._tagPos < 16) return;
      }
      {
        // Verify authentication tag
        this._decipherInstance.setAuthTag(this._tag);
        const decrypted = this._decipherInstance.final();

        // XXX: this should never output any data since stream ciphers always
        // return data from .update() and block ciphers must end on a multiple
        // of the block length, which would have caused an exception to be
        // thrown if the total input was not...
        if (decrypted.length) {
          if (this._packet) this._packet.set(decrypted, this._packetPos);else this._packet = decrypted;
        }
      }
      const payload = !this._packet ? EMPTY_BUFFER : new FastBuffer(this._packet.buffer, this._packet.byteOffset + 1, this._packet.length - this._packet[0] - 1);

      // Prepare for next packet
      this.inSeqno = this.inSeqno + 1 >>> 0;
      ivIncrement(this._decipherIV);
      this._len = 0;
      this._lenBytes = 0;
      this._packet = null;
      this._packetPos = 0;
      this._pktLen = 0;
      this._tagPos = 0;
      {
        const ret = this._onPayload(payload);
        if (ret !== undefined) return ret === false ? p : ret;
      }
    }
  }
}
class AESGCMDecipherBinding {
  constructor(config) {
    const dec = config.inbound;
    this.inSeqno = dec.seqno;
    this._onPayload = dec.onPayload;
    this._instance = new AESGCMDecipher(dec.decipherInfo.sslName, dec.decipherKey, dec.decipherIV);
    this._len = 0;
    this._lenBytes = 0;
    this._packet = null;
    this._pktLen = 0;
    this._tag = Buffer.allocUnsafe(16);
    this._tagPos = 0;
  }
  free() {}
  decrypt(data, p, dataLen) {
    // `data` === encrypted data

    while (p < dataLen) {
      // Read packet length (unencrypted, but AAD)
      if (this._lenBytes < 4) {
        let nb = Math.min(4 - this._lenBytes, dataLen - p);
        this._lenBytes += nb;
        while (nb--) this._len = (this._len << 8) + data[p++];
        if (this._lenBytes < 4) return;
        if (this._len + 20 > MAX_PACKET_SIZE || this._len < 16 || (this._len & 15) !== 0) {
          throw new Error(`Bad packet length: ${this._len}`);
        }
      }

      // Read padding length, payload, and padding
      if (this._pktLen < this._len) {
        if (p >= dataLen) return;
        const nb = Math.min(this._len - this._pktLen, dataLen - p);
        let encrypted;
        if (p !== 0 || nb !== dataLen) encrypted = new Uint8Array(data.buffer, data.byteOffset + p, nb);else encrypted = data;
        if (nb === this._len) {
          this._packet = encrypted;
        } else {
          if (!this._packet) this._packet = Buffer.allocUnsafe(this._len);
          this._packet.set(encrypted, this._pktLen);
        }
        p += nb;
        this._pktLen += nb;
        if (this._pktLen < this._len || p >= dataLen) return;
      }

      // Read authentication tag
      {
        const nb = Math.min(16 - this._tagPos, dataLen - p);
        if (p !== 0 || nb !== dataLen) {
          this._tag.set(new Uint8Array(data.buffer, data.byteOffset + p, nb), this._tagPos);
        } else {
          this._tag.set(data, this._tagPos);
        }
        p += nb;
        this._tagPos += nb;
        if (this._tagPos < 16) return;
      }
      this._instance.decrypt(this._packet, this._len, this._tag);
      const payload = new FastBuffer(this._packet.buffer, this._packet.byteOffset + 1, this._packet.length - this._packet[0] - 1);

      // Prepare for next packet
      this.inSeqno = this.inSeqno + 1 >>> 0;
      this._len = 0;
      this._lenBytes = 0;
      this._packet = null;
      this._pktLen = 0;
      this._tagPos = 0;
      {
        const ret = this._onPayload(payload);
        if (ret !== undefined) return ret === false ? p : ret;
      }
    }
  }
}

// TODO: test incremental .update()s vs. copying to _packet and doing a single
// .update() after entire packet read -- a single .update() would allow
// verifying MAC before decrypting for ETM MACs
class GenericDecipherNative {
  constructor(config) {
    const dec = config.inbound;
    this.inSeqno = dec.seqno;
    this._onPayload = dec.onPayload;
    this._decipherInstance = createDecipheriv(dec.decipherInfo.sslName, dec.decipherKey, dec.decipherIV);
    this._decipherInstance.setAutoPadding(false);
    this._block = Buffer.allocUnsafe(dec.macInfo.isETM ? 4 : dec.decipherInfo.blockLen);
    this._blockSize = dec.decipherInfo.blockLen;
    this._blockPos = 0;
    this._len = 0;
    this._packet = null;
    this._packetPos = 0;
    this._pktLen = 0;
    this._mac = Buffer.allocUnsafe(dec.macInfo.actualLen);
    this._macPos = 0;
    this._macSSLName = dec.macInfo.sslName;
    this._macKey = dec.macKey;
    this._macActualLen = dec.macInfo.actualLen;
    this._macETM = dec.macInfo.isETM;
    this._macInstance = null;
    const discardLen = dec.decipherInfo.discardLen;
    if (discardLen) {
      let discard = DISCARD_CACHE.get(discardLen);
      if (discard === undefined) {
        discard = Buffer.alloc(discardLen);
        DISCARD_CACHE.set(discardLen, discard);
      }
      this._decipherInstance.update(discard);
    }
  }
  free() {}
  decrypt(data, p, dataLen) {
    // `data` === encrypted data

    while (p < dataLen) {
      // Read first encrypted block
      if (this._blockPos < this._block.length) {
        const nb = Math.min(this._block.length - this._blockPos, dataLen - p);
        if (p !== 0 || nb !== dataLen || nb < data.length) {
          this._block.set(new Uint8Array(data.buffer, data.byteOffset + p, nb), this._blockPos);
        } else {
          this._block.set(data, this._blockPos);
        }
        p += nb;
        this._blockPos += nb;
        if (this._blockPos < this._block.length) return;
        let decrypted;
        let need;
        if (this._macETM) {
          this._len = need = readUInt32BE(this._block, 0);
        } else {
          // Decrypt first block to get packet length
          decrypted = this._decipherInstance.update(this._block);
          this._len = readUInt32BE(decrypted, 0);
          need = 4 + this._len - this._blockSize;
        }
        if (this._len > MAX_PACKET_SIZE || this._len < 5 || (need & this._blockSize - 1) !== 0) {
          throw new Error('Bad packet length');
        }

        // Create MAC up front to calculate in parallel with decryption
        this._macInstance = createHmac(this._macSSLName, this._macKey);
        writeUInt32BE(BUF_INT, this.inSeqno, 0);
        this._macInstance.update(BUF_INT);
        if (this._macETM) {
          this._macInstance.update(this._block);
        } else {
          this._macInstance.update(new Uint8Array(decrypted.buffer, decrypted.byteOffset, 4));
          this._pktLen = decrypted.length - 4;
          this._packetPos = this._pktLen;
          this._packet = Buffer.allocUnsafe(this._len);
          this._packet.set(new Uint8Array(decrypted.buffer, decrypted.byteOffset + 4, this._packetPos), 0);
        }
        if (p >= dataLen) return;
      }

      // Read padding length, payload, and padding
      if (this._pktLen < this._len) {
        const nb = Math.min(this._len - this._pktLen, dataLen - p);
        let encrypted;
        if (p !== 0 || nb !== dataLen) encrypted = new Uint8Array(data.buffer, data.byteOffset + p, nb);else encrypted = data;
        if (this._macETM) this._macInstance.update(encrypted);
        const decrypted = this._decipherInstance.update(encrypted);
        if (decrypted.length) {
          if (nb === this._len) {
            this._packet = decrypted;
          } else {
            if (!this._packet) this._packet = Buffer.allocUnsafe(this._len);
            this._packet.set(decrypted, this._packetPos);
          }
          this._packetPos += decrypted.length;
        }
        p += nb;
        this._pktLen += nb;
        if (this._pktLen < this._len || p >= dataLen) return;
      }

      // Read MAC
      {
        const nb = Math.min(this._macActualLen - this._macPos, dataLen - p);
        if (p !== 0 || nb !== dataLen) {
          this._mac.set(new Uint8Array(data.buffer, data.byteOffset + p, nb), this._macPos);
        } else {
          this._mac.set(data, this._macPos);
        }
        p += nb;
        this._macPos += nb;
        if (this._macPos < this._macActualLen) return;
      }

      // Verify MAC
      if (!this._macETM) this._macInstance.update(this._packet);
      let calculated = this._macInstance.digest();
      if (this._macActualLen < calculated.length) {
        calculated = new Uint8Array(calculated.buffer, calculated.byteOffset, this._macActualLen);
      }
      if (!timingSafeEquals(calculated, this._mac)) throw new Error('Invalid MAC');
      const payload = new FastBuffer(this._packet.buffer, this._packet.byteOffset + 1, this._packet.length - this._packet[0] - 1);

      // Prepare for next packet
      this.inSeqno = this.inSeqno + 1 >>> 0;
      this._blockPos = 0;
      this._len = 0;
      this._packet = null;
      this._packetPos = 0;
      this._pktLen = 0;
      this._macPos = 0;
      this._macInstance = null;
      {
        const ret = this._onPayload(payload);
        if (ret !== undefined) return ret === false ? p : ret;
      }
    }
  }
}
class GenericDecipherBinding {
  constructor(config) {
    const dec = config.inbound;
    this.inSeqno = dec.seqno;
    this._onPayload = dec.onPayload;
    this._instance = new GenericDecipher(dec.decipherInfo.sslName, dec.decipherKey, dec.decipherIV, dec.macInfo.sslName, dec.macKey, dec.macInfo.isETM, dec.macInfo.actualLen);
    this._block = Buffer.allocUnsafe(dec.macInfo.isETM || dec.decipherInfo.stream ? 4 : dec.decipherInfo.blockLen);
    this._blockPos = 0;
    this._len = 0;
    this._packet = null;
    this._pktLen = 0;
    this._mac = Buffer.allocUnsafe(dec.macInfo.actualLen);
    this._macPos = 0;
    this._macActualLen = dec.macInfo.actualLen;
    this._macETM = dec.macInfo.isETM;
  }
  free() {
    this._instance.free();
  }
  decrypt(data, p, dataLen) {
    // `data` === encrypted data

    while (p < dataLen) {
      // Read first encrypted block
      if (this._blockPos < this._block.length) {
        const nb = Math.min(this._block.length - this._blockPos, dataLen - p);
        if (p !== 0 || nb !== dataLen || nb < data.length) {
          this._block.set(new Uint8Array(data.buffer, data.byteOffset + p, nb), this._blockPos);
        } else {
          this._block.set(data, this._blockPos);
        }
        p += nb;
        this._blockPos += nb;
        if (this._blockPos < this._block.length) return;
        let need;
        if (this._macETM) {
          this._len = need = readUInt32BE(this._block, 0);
        } else {
          // Decrypt first block to get packet length
          this._instance.decryptBlock(this._block);
          this._len = readUInt32BE(this._block, 0);
          need = 4 + this._len - this._block.length;
        }
        if (this._len > MAX_PACKET_SIZE || this._len < 5 || (need & this._block.length - 1) !== 0) {
          throw new Error('Bad packet length');
        }
        if (!this._macETM) {
          this._pktLen = this._block.length - 4;
          if (this._pktLen) {
            this._packet = Buffer.allocUnsafe(this._len);
            this._packet.set(new Uint8Array(this._block.buffer, this._block.byteOffset + 4, this._pktLen), 0);
          }
        }
        if (p >= dataLen) return;
      }

      // Read padding length, payload, and padding
      if (this._pktLen < this._len) {
        const nb = Math.min(this._len - this._pktLen, dataLen - p);
        let encrypted;
        if (p !== 0 || nb !== dataLen) encrypted = new Uint8Array(data.buffer, data.byteOffset + p, nb);else encrypted = data;
        if (nb === this._len) {
          this._packet = encrypted;
        } else {
          if (!this._packet) this._packet = Buffer.allocUnsafe(this._len);
          this._packet.set(encrypted, this._pktLen);
        }
        p += nb;
        this._pktLen += nb;
        if (this._pktLen < this._len || p >= dataLen) return;
      }

      // Read MAC
      {
        const nb = Math.min(this._macActualLen - this._macPos, dataLen - p);
        if (p !== 0 || nb !== dataLen) {
          this._mac.set(new Uint8Array(data.buffer, data.byteOffset + p, nb), this._macPos);
        } else {
          this._mac.set(data, this._macPos);
        }
        p += nb;
        this._macPos += nb;
        if (this._macPos < this._macActualLen) return;
      }

      // Decrypt and verify MAC
      this._instance.decrypt(this._packet, this.inSeqno, this._block, this._mac);
      const payload = new FastBuffer(this._packet.buffer, this._packet.byteOffset + 1, this._packet.length - this._packet[0] - 1);

      // Prepare for next packet
      this.inSeqno = this.inSeqno + 1 >>> 0;
      this._blockPos = 0;
      this._len = 0;
      this._packet = null;
      this._pktLen = 0;
      this._macPos = 0;
      this._macInstance = null;
      {
        const ret = this._onPayload(payload);
        if (ret !== undefined) return ret === false ? p : ret;
      }
    }
  }
}

// Increments unsigned, big endian counter (last 8 bytes) of AES-GCM IV
function ivIncrement(iv) {
  // eslint-disable-next-line no-unused-expressions
  ++iv[11] >>> 8 && ++iv[10] >>> 8 && ++iv[9] >>> 8 && ++iv[8] >>> 8 && ++iv[7] >>> 8 && ++iv[6] >>> 8 && ++iv[5] >>> 8 && ++iv[4] >>> 8;
}
const intToBytes = (() => {
  const ret = Buffer.alloc(4);
  return n => {
    ret[0] = n >>> 24;
    ret[1] = n >>> 16;
    ret[2] = n >>> 8;
    ret[3] = n;
    return ret;
  };
})();
function timingSafeEquals(a, b) {
  if (a.length !== b.length) {
    timingSafeEqual(a, a);
    return false;
  }
  return timingSafeEqual(a, b);
}
function createCipher(config) {
  if (typeof config !== 'object' || config === null) throw new Error('Invalid config');
  if (typeof config.outbound !== 'object' || config.outbound === null) throw new Error('Invalid outbound');
  const outbound = config.outbound;
  if (typeof outbound.onWrite !== 'function') throw new Error('Invalid outbound.onWrite');
  if (typeof outbound.cipherInfo !== 'object' || outbound.cipherInfo === null) throw new Error('Invalid outbound.cipherInfo');
  if (!Buffer.isBuffer(outbound.cipherKey) || outbound.cipherKey.length !== outbound.cipherInfo.keyLen) {
    throw new Error('Invalid outbound.cipherKey');
  }
  if (outbound.cipherInfo.ivLen && (!Buffer.isBuffer(outbound.cipherIV) || outbound.cipherIV.length !== outbound.cipherInfo.ivLen)) {
    throw new Error('Invalid outbound.cipherIV');
  }
  if (typeof outbound.seqno !== 'number' || outbound.seqno < 0 || outbound.seqno > MAX_SEQNO) {
    throw new Error('Invalid outbound.seqno');
  }
  const forceNative = !!outbound.forceNative;
  switch (outbound.cipherInfo.sslName) {
    case 'aes-128-gcm':
    case 'aes-256-gcm':
      return AESGCMCipher && !forceNative ? new AESGCMCipherBinding(config) : new AESGCMCipherNative(config);
    case 'chacha20':
      return ChaChaPolyCipher && !forceNative ? new ChaChaPolyCipherBinding(config) : new ChaChaPolyCipherNative(config);
    default:
      {
        if (typeof outbound.macInfo !== 'object' || outbound.macInfo === null) throw new Error('Invalid outbound.macInfo');
        if (!Buffer.isBuffer(outbound.macKey) || outbound.macKey.length !== outbound.macInfo.len) {
          throw new Error('Invalid outbound.macKey');
        }
        return GenericCipher && !forceNative ? new GenericCipherBinding(config) : new GenericCipherNative(config);
      }
  }
}
function createDecipher(config) {
  if (typeof config !== 'object' || config === null) throw new Error('Invalid config');
  if (typeof config.inbound !== 'object' || config.inbound === null) throw new Error('Invalid inbound');
  const inbound = config.inbound;
  if (typeof inbound.onPayload !== 'function') throw new Error('Invalid inbound.onPayload');
  if (typeof inbound.decipherInfo !== 'object' || inbound.decipherInfo === null) {
    throw new Error('Invalid inbound.decipherInfo');
  }
  if (!Buffer.isBuffer(inbound.decipherKey) || inbound.decipherKey.length !== inbound.decipherInfo.keyLen) {
    throw new Error('Invalid inbound.decipherKey');
  }
  if (inbound.decipherInfo.ivLen && (!Buffer.isBuffer(inbound.decipherIV) || inbound.decipherIV.length !== inbound.decipherInfo.ivLen)) {
    throw new Error('Invalid inbound.decipherIV');
  }
  if (typeof inbound.seqno !== 'number' || inbound.seqno < 0 || inbound.seqno > MAX_SEQNO) {
    throw new Error('Invalid inbound.seqno');
  }
  const forceNative = !!inbound.forceNative;
  switch (inbound.decipherInfo.sslName) {
    case 'aes-128-gcm':
    case 'aes-256-gcm':
      return AESGCMDecipher && !forceNative ? new AESGCMDecipherBinding(config) : new AESGCMDecipherNative(config);
    case 'chacha20':
      return ChaChaPolyDecipher && !forceNative ? new ChaChaPolyDecipherBinding(config) : new ChaChaPolyDecipherNative(config);
    default:
      {
        if (typeof inbound.macInfo !== 'object' || inbound.macInfo === null) throw new Error('Invalid inbound.macInfo');
        if (!Buffer.isBuffer(inbound.macKey) || inbound.macKey.length !== inbound.macInfo.len) {
          throw new Error('Invalid inbound.macKey');
        }
        return GenericDecipher && !forceNative ? new GenericDecipherBinding(config) : new GenericDecipherNative(config);
      }
  }
}
module.exports = {
  CIPHER_INFO,
  MAC_INFO,
  bindingAvailable: !!binding,
  init: (() => {
    // eslint-disable-next-line no-async-promise-executor
    return new Promise(async (resolve, reject) => {
      try {
        POLY1305_WASM_MODULE = await __webpack_require__(/*! ./crypto/poly1305.js */ 2249)();
        POLY1305_RESULT_MALLOC = POLY1305_WASM_MODULE._malloc(16);
        poly1305_auth = POLY1305_WASM_MODULE.cwrap('poly1305_auth', null, ['number', 'array', 'number', 'array', 'number', 'array']);
      } catch (ex) {
        return reject(ex);
      }
      resolve();
    });
  })(),
  NullCipher,
  createCipher,
  NullDecipher,
  createDecipher
};

/***/ }),

/***/ 2249:
/*!************************************************************!*\
  !*** ../node_modules/ssh2/lib/protocol/crypto/poly1305.js ***!
  \************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var createPoly1305 = function () {
  var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined;
  if (true) _scriptDir = _scriptDir || __filename;
  return function (createPoly1305) {
    createPoly1305 = createPoly1305 || {};
    var b;
    b || (b = typeof createPoly1305 !== 'undefined' ? createPoly1305 : {});
    var q, r;
    b.ready = new Promise(function (a, c) {
      q = a;
      r = c;
    });
    var u = {},
      w;
    for (w in b) b.hasOwnProperty(w) && (u[w] = b[w]);
    var x = "object" === typeof window,
      y = "function" === typeof importScripts,
      z = "object" === typeof process && "object" === typeof process.versions && "string" === typeof process.versions.node,
      B = "",
      C,
      D,
      E,
      F,
      G;
    if (z) B = y ? (__webpack_require__(/*! path */ 3056).dirname)(B) + "/" : __dirname + "/", C = function (a, c) {
      var d = H(a);
      if (d) return c ? d : d.toString();
      F || (F = __webpack_require__(/*! fs */ 2089));
      G || (G = __webpack_require__(/*! path */ 3056));
      a = G.normalize(a);
      return F.readFileSync(a, c ? null : "utf8");
    }, E = function (a) {
      a = C(a, !0);
      a.buffer || (a = new Uint8Array(a));
      assert(a.buffer);
      return a;
    }, D = function (a, c, d) {
      var e = H(a);
      e && c(e);
      F || (F = __webpack_require__(/*! fs */ 2089));
      G || (G = __webpack_require__(/*! path */ 3056));
      a = G.normalize(a);
      F.readFile(a, function (f, l) {
        f ? d(f) : c(l.buffer);
      });
    }, 1 < process.argv.length && process.argv[1].replace(/\\/g, "/"), process.argv.slice(2), b.inspect = function () {
      return "[Emscripten Module object]";
    };else if (x || y) y ? B = self.location.href : "undefined" !== typeof document && document.currentScript && (B = document.currentScript.src), _scriptDir && (B = _scriptDir), 0 !== B.indexOf("blob:") ? B = B.substr(0, B.lastIndexOf("/") + 1) : B = "", C = function (a) {
      try {
        var c = new XMLHttpRequest();
        c.open("GET", a, !1);
        c.send(null);
        return c.responseText;
      } catch (f) {
        if (a = H(a)) {
          c = [];
          for (var d = 0; d < a.length; d++) {
            var e = a[d];
            255 < e && (ba && assert(!1, "Character code " + e + " (" + String.fromCharCode(e) + ")  at offset " + d + " not in 0x00-0xFF."), e &= 255);
            c.push(String.fromCharCode(e));
          }
          return c.join("");
        }
        throw f;
      }
    }, y && (E = function (a) {
      try {
        var c = new XMLHttpRequest();
        c.open("GET", a, !1);
        c.responseType = "arraybuffer";
        c.send(null);
        return new Uint8Array(c.response);
      } catch (d) {
        if (a = H(a)) return a;
        throw d;
      }
    }), D = function (a, c, d) {
      var e = new XMLHttpRequest();
      e.open("GET", a, !0);
      e.responseType = "arraybuffer";
      e.onload = function () {
        if (200 == e.status || 0 == e.status && e.response) c(e.response);else {
          var f = H(a);
          f ? c(f.buffer) : d();
        }
      };
      e.onerror = d;
      e.send(null);
    };
    b.print || console.log.bind(console);
    var I = b.printErr || console.warn.bind(console);
    for (w in u) u.hasOwnProperty(w) && (b[w] = u[w]);
    u = null;
    var J;
    b.wasmBinary && (J = b.wasmBinary);
    var noExitRuntime = b.noExitRuntime || !0;
    "object" !== typeof WebAssembly && K("no native wasm support detected");
    var L,
      M = !1;
    function assert(a, c) {
      a || K("Assertion failed: " + c);
    }
    function N(a) {
      var c = b["_" + a];
      assert(c, "Cannot call unknown function " + a + ", make sure it is exported");
      return c;
    }
    function ca(a, c, d, e) {
      var f = {
          string: function (g) {
            var p = 0;
            if (null !== g && void 0 !== g && 0 !== g) {
              var n = (g.length << 2) + 1;
              p = O(n);
              var k = p,
                h = P;
              if (0 < n) {
                n = k + n - 1;
                for (var v = 0; v < g.length; ++v) {
                  var m = g.charCodeAt(v);
                  if (55296 <= m && 57343 >= m) {
                    var oa = g.charCodeAt(++v);
                    m = 65536 + ((m & 1023) << 10) | oa & 1023;
                  }
                  if (127 >= m) {
                    if (k >= n) break;
                    h[k++] = m;
                  } else {
                    if (2047 >= m) {
                      if (k + 1 >= n) break;
                      h[k++] = 192 | m >> 6;
                    } else {
                      if (65535 >= m) {
                        if (k + 2 >= n) break;
                        h[k++] = 224 | m >> 12;
                      } else {
                        if (k + 3 >= n) break;
                        h[k++] = 240 | m >> 18;
                        h[k++] = 128 | m >> 12 & 63;
                      }
                      h[k++] = 128 | m >> 6 & 63;
                    }
                    h[k++] = 128 | m & 63;
                  }
                }
                h[k] = 0;
              }
            }
            return p;
          },
          array: function (g) {
            var p = O(g.length);
            Q.set(g, p);
            return p;
          }
        },
        l = N(a),
        A = [];
      a = 0;
      if (e) for (var t = 0; t < e.length; t++) {
        var aa = f[d[t]];
        aa ? (0 === a && (a = da()), A[t] = aa(e[t])) : A[t] = e[t];
      }
      d = l.apply(null, A);
      d = function (g) {
        if ("string" === c) {
          if (g) {
            for (var p = P, n = g + NaN, k = g; p[k] && !(k >= n);) ++k;
            if (16 < k - g && p.subarray && ea) g = ea.decode(p.subarray(g, k));else {
              for (n = ""; g < k;) {
                var h = p[g++];
                if (h & 128) {
                  var v = p[g++] & 63;
                  if (192 == (h & 224)) n += String.fromCharCode((h & 31) << 6 | v);else {
                    var m = p[g++] & 63;
                    h = 224 == (h & 240) ? (h & 15) << 12 | v << 6 | m : (h & 7) << 18 | v << 12 | m << 6 | p[g++] & 63;
                    65536 > h ? n += String.fromCharCode(h) : (h -= 65536, n += String.fromCharCode(55296 | h >> 10, 56320 | h & 1023));
                  }
                } else n += String.fromCharCode(h);
              }
              g = n;
            }
          } else g = "";
        } else g = "boolean" === c ? !!g : g;
        return g;
      }(d);
      0 !== a && fa(a);
      return d;
    }
    var ea = "undefined" !== typeof TextDecoder ? new TextDecoder("utf8") : void 0,
      ha,
      Q,
      P;
    function ia() {
      var a = L.buffer;
      ha = a;
      b.HEAP8 = Q = new Int8Array(a);
      b.HEAP16 = new Int16Array(a);
      b.HEAP32 = new Int32Array(a);
      b.HEAPU8 = P = new Uint8Array(a);
      b.HEAPU16 = new Uint16Array(a);
      b.HEAPU32 = new Uint32Array(a);
      b.HEAPF32 = new Float32Array(a);
      b.HEAPF64 = new Float64Array(a);
    }
    var R,
      ja = [],
      ka = [],
      la = [];
    function ma() {
      var a = b.preRun.shift();
      ja.unshift(a);
    }
    var S = 0,
      T = null,
      U = null;
    b.preloadedImages = {};
    b.preloadedAudios = {};
    function K(a) {
      if (b.onAbort) b.onAbort(a);
      I(a);
      M = !0;
      a = new WebAssembly.RuntimeError("abort(" + a + "). Build with -s ASSERTIONS=1 for more info.");
      r(a);
      throw a;
    }
    var V = "data:application/octet-stream;base64,",
      W;
    W = "data:application/octet-stream;base64, ";
    if (!W.startsWith(V)) {
      var na = W;
      W = b.locateFile ? b.locateFile(na, B) : B + na;
    }
    function pa() {
      var a = W;
      try {
        if (a == W && J) return new Uint8Array(J);
        var c = H(a);
        if (c) return c;
        if (E) return E(a);
        throw "both async and sync fetching of the wasm failed";
      } catch (d) {
        K(d);
      }
    }
    function qa() {
      if (!J && (x || y)) {
        if ("function" === typeof fetch && !W.startsWith("file://")) return fetch(W, {
          credentials: "same-origin"
        }).then(function (a) {
          if (!a.ok) throw "failed to load wasm binary file at '" + W + "'";
          return a.arrayBuffer();
        }).catch(function () {
          return pa();
        });
        if (D) return new Promise(function (a, c) {
          D(W, function (d) {
            a(new Uint8Array(d));
          }, c);
        });
      }
      return Promise.resolve().then(function () {
        return pa();
      });
    }
    function X(a) {
      for (; 0 < a.length;) {
        var c = a.shift();
        if ("function" == typeof c) c(b);else {
          var d = c.m;
          "number" === typeof d ? void 0 === c.l ? R.get(d)() : R.get(d)(c.l) : d(void 0 === c.l ? null : c.l);
        }
      }
    }
    var ba = !1,
      ra = "function" === typeof atob ? atob : function (a) {
        var c = "",
          d = 0;
        a = a.replace(/[^A-Za-z0-9\+\/=]/g, "");
        do {
          var e = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".indexOf(a.charAt(d++));
          var f = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".indexOf(a.charAt(d++));
          var l = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".indexOf(a.charAt(d++));
          var A = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".indexOf(a.charAt(d++));
          e = e << 2 | f >> 4;
          f = (f & 15) << 4 | l >> 2;
          var t = (l & 3) << 6 | A;
          c += String.fromCharCode(e);
          64 !== l && (c += String.fromCharCode(f));
          64 !== A && (c += String.fromCharCode(t));
        } while (d < a.length);
        return c;
      };
    function H(a) {
      if (a.startsWith(V)) {
        a = a.slice(V.length);
        if ("boolean" === typeof z && z) {
          var c = Buffer.from(a, "base64");
          c = new Uint8Array(c.buffer, c.byteOffset, c.byteLength);
        } else try {
          var d = ra(a),
            e = new Uint8Array(d.length);
          for (a = 0; a < d.length; ++a) e[a] = d.charCodeAt(a);
          c = e;
        } catch (f) {
          throw Error("Converting base64 string to bytes failed.");
        }
        return c;
      }
    }
    var sa = {
      a: function (a) {
        var c = P.length;
        a >>>= 0;
        if (2147483648 < a) return !1;
        for (var d = 1; 4 >= d; d *= 2) {
          var e = c * (1 + .2 / d);
          e = Math.min(e, a + 100663296);
          e = Math.max(a, e);
          0 < e % 65536 && (e += 65536 - e % 65536);
          a: {
            try {
              L.grow(Math.min(2147483648, e) - ha.byteLength + 65535 >>> 16);
              ia();
              var f = 1;
              break a;
            } catch (l) {}
            f = void 0;
          }
          if (f) return !0;
        }
        return !1;
      }
    };
    (function () {
      function a(f) {
        b.asm = f.exports;
        L = b.asm.b;
        ia();
        R = b.asm.j;
        ka.unshift(b.asm.c);
        S--;
        b.monitorRunDependencies && b.monitorRunDependencies(S);
        0 == S && (null !== T && (clearInterval(T), T = null), U && (f = U, U = null, f()));
      }
      function c(f) {
        a(f.instance);
      }
      function d(f) {
        return qa().then(function (l) {
          return WebAssembly.instantiate(l, e);
        }).then(f, function (l) {
          I("failed to asynchronously prepare wasm: " + l);
          K(l);
        });
      }
      var e = {
        a: sa
      };
      S++;
      b.monitorRunDependencies && b.monitorRunDependencies(S);
      if (b.instantiateWasm) try {
        return b.instantiateWasm(e, a);
      } catch (f) {
        return I("Module.instantiateWasm callback failed with error: " + f), !1;
      }
      (function () {
        return J || "function" !== typeof WebAssembly.instantiateStreaming || W.startsWith(V) || W.startsWith("file://") || "function" !== typeof fetch ? d(c) : fetch(W, {
          credentials: "same-origin"
        }).then(function (f) {
          return WebAssembly.instantiateStreaming(f, e).then(c, function (l) {
            I("wasm streaming compile failed: " + l);
            I("falling back to ArrayBuffer instantiation");
            return d(c);
          });
        });
      })().catch(r);
      return {};
    })();
    b.___wasm_call_ctors = function () {
      return (b.___wasm_call_ctors = b.asm.c).apply(null, arguments);
    };
    b._poly1305_auth = function () {
      return (b._poly1305_auth = b.asm.d).apply(null, arguments);
    };
    var da = b.stackSave = function () {
        return (da = b.stackSave = b.asm.e).apply(null, arguments);
      },
      fa = b.stackRestore = function () {
        return (fa = b.stackRestore = b.asm.f).apply(null, arguments);
      },
      O = b.stackAlloc = function () {
        return (O = b.stackAlloc = b.asm.g).apply(null, arguments);
      };
    b._malloc = function () {
      return (b._malloc = b.asm.h).apply(null, arguments);
    };
    b._free = function () {
      return (b._free = b.asm.i).apply(null, arguments);
    };
    b.cwrap = function (a, c, d, e) {
      d = d || [];
      var f = d.every(function (l) {
        return "number" === l;
      });
      return "string" !== c && f && !e ? N(a) : function () {
        return ca(a, c, d, arguments);
      };
    };
    var Y;
    U = function ta() {
      Y || Z();
      Y || (U = ta);
    };
    function Z() {
      function a() {
        if (!Y && (Y = !0, b.calledRun = !0, !M)) {
          X(ka);
          q(b);
          if (b.onRuntimeInitialized) b.onRuntimeInitialized();
          if (b.postRun) for ("function" == typeof b.postRun && (b.postRun = [b.postRun]); b.postRun.length;) {
            var c = b.postRun.shift();
            la.unshift(c);
          }
          X(la);
        }
      }
      if (!(0 < S)) {
        if (b.preRun) for ("function" == typeof b.preRun && (b.preRun = [b.preRun]); b.preRun.length;) ma();
        X(ja);
        0 < S || (b.setStatus ? (b.setStatus("Running..."), setTimeout(function () {
          setTimeout(function () {
            b.setStatus("");
          }, 1);
          a();
        }, 1)) : a());
      }
    }
    b.run = Z;
    if (b.preInit) for ("function" == typeof b.preInit && (b.preInit = [b.preInit]); 0 < b.preInit.length;) b.preInit.pop()();
    Z();
    return createPoly1305.ready;
  };
}();
if (true) module.exports = createPoly1305;else {}

/***/ }),

/***/ 9775:
/*!*****************************************************!*\
  !*** ../node_modules/ssh2/lib/protocol/handlers.js ***!
  \*****************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


const MESSAGE_HANDLERS = new Array(256);
[(__webpack_require__(/*! ./kex.js */ 3027).HANDLERS), __webpack_require__(/*! ./handlers.misc.js */ 1141)].forEach(handlers => {
  // eslint-disable-next-line prefer-const
  for (let [type, handler] of Object.entries(handlers)) {
    type = +type;
    if (isFinite(type) && type >= 0 && type < MESSAGE_HANDLERS.length) MESSAGE_HANDLERS[type] = handler;
  }
});
module.exports = MESSAGE_HANDLERS;

/***/ }),

/***/ 1141:
/*!**********************************************************!*\
  !*** ../node_modules/ssh2/lib/protocol/handlers.misc.js ***!
  \**********************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


const {
  bufferSlice,
  bufferParser,
  doFatalError,
  sigSSHToASN1,
  writeUInt32BE
} = __webpack_require__(/*! ./utils.js */ 3549);
const {
  CHANNEL_OPEN_FAILURE,
  COMPAT,
  MESSAGE,
  TERMINAL_MODE
} = __webpack_require__(/*! ./constants.js */ 7816);
const {
  parseKey
} = __webpack_require__(/*! ./keyParser.js */ 9934);
const TERMINAL_MODE_BY_VALUE = Array.from(Object.entries(TERMINAL_MODE)).reduce((obj, [key, value]) => ({
  ...obj,
  [key]: value
}), {});
module.exports = {
  // Transport layer protocol ==================================================
  [MESSAGE.DISCONNECT]: (self, payload) => {
    /*
      byte      SSH_MSG_DISCONNECT
      uint32    reason code
      string    description in ISO-10646 UTF-8 encoding
      string    language tag
    */
    bufferParser.init(payload, 1);
    const reason = bufferParser.readUInt32BE();
    const desc = bufferParser.readString(true);
    const lang = bufferParser.readString();
    bufferParser.clear();
    if (lang === undefined) {
      return doFatalError(self, 'Inbound: Malformed DISCONNECT packet');
    }
    self._debug && self._debug(`Inbound: Received DISCONNECT (${reason}, "${desc}")`);
    const handler = self._handlers.DISCONNECT;
    handler && handler(self, reason, desc);
  },
  [MESSAGE.IGNORE]: (self, payload) => {
    /*
      byte      SSH_MSG_IGNORE
      string    data
    */
    self._debug && self._debug('Inbound: Received IGNORE');
  },
  [MESSAGE.UNIMPLEMENTED]: (self, payload) => {
    /*
      byte      SSH_MSG_UNIMPLEMENTED
      uint32    packet sequence number of rejected message
    */
    bufferParser.init(payload, 1);
    const seqno = bufferParser.readUInt32BE();
    bufferParser.clear();
    if (seqno === undefined) {
      return doFatalError(self, 'Inbound: Malformed UNIMPLEMENTED packet');
    }
    self._debug && self._debug(`Inbound: Received UNIMPLEMENTED (seqno ${seqno})`);
  },
  [MESSAGE.DEBUG]: (self, payload) => {
    /*
      byte      SSH_MSG_DEBUG
      boolean   always_display
      string    message in ISO-10646 UTF-8 encoding [RFC3629]
      string    language tag [RFC3066]
    */
    bufferParser.init(payload, 1);
    const display = bufferParser.readBool();
    const msg = bufferParser.readString(true);
    const lang = bufferParser.readString();
    bufferParser.clear();
    if (lang === undefined) {
      return doFatalError(self, 'Inbound: Malformed DEBUG packet');
    }
    self._debug && self._debug('Inbound: Received DEBUG');
    const handler = self._handlers.DEBUG;
    handler && handler(self, display, msg);
  },
  [MESSAGE.SERVICE_REQUEST]: (self, payload) => {
    /*
      byte      SSH_MSG_SERVICE_REQUEST
      string    service name
    */
    bufferParser.init(payload, 1);
    const name = bufferParser.readString(true);
    bufferParser.clear();
    if (name === undefined) {
      return doFatalError(self, 'Inbound: Malformed SERVICE_REQUEST packet');
    }
    self._debug && self._debug(`Inbound: Received SERVICE_REQUEST (${name})`);
    const handler = self._handlers.SERVICE_REQUEST;
    handler && handler(self, name);
  },
  [MESSAGE.SERVICE_ACCEPT]: (self, payload) => {
    // S->C
    /*
      byte      SSH_MSG_SERVICE_ACCEPT
      string    service name
    */
    bufferParser.init(payload, 1);
    const name = bufferParser.readString(true);
    bufferParser.clear();
    if (name === undefined) {
      return doFatalError(self, 'Inbound: Malformed SERVICE_ACCEPT packet');
    }
    self._debug && self._debug(`Inbound: Received SERVICE_ACCEPT (${name})`);
    const handler = self._handlers.SERVICE_ACCEPT;
    handler && handler(self, name);
  },
  // User auth protocol -- generic =============================================
  [MESSAGE.USERAUTH_REQUEST]: (self, payload) => {
    /*
      byte      SSH_MSG_USERAUTH_REQUEST
      string    user name in ISO-10646 UTF-8 encoding [RFC3629]
      string    service name in US-ASCII
      string    method name in US-ASCII
      ....      method specific fields
    */
    bufferParser.init(payload, 1);
    const user = bufferParser.readString(true);
    const service = bufferParser.readString(true);
    const method = bufferParser.readString(true);
    let methodData;
    let methodDesc;
    switch (method) {
      case 'none':
        methodData = null;
        break;
      case 'password':
        {
          /*
            boolean   <new password follows (old) plaintext password?>
            string    plaintext password in ISO-10646 UTF-8 encoding [RFC3629]
           [string    new password]
          */
          const isChange = bufferParser.readBool();
          if (isChange !== undefined) {
            methodData = bufferParser.readString(true);
            if (methodData !== undefined && isChange) {
              const newPassword = bufferParser.readString(true);
              if (newPassword !== undefined) methodData = {
                oldPassword: methodData,
                newPassword
              };else methodData = undefined;
            }
          }
          break;
        }
      case 'publickey':
        {
          /*
            boolean   <signature follows public key blob?>
            string    public key algorithm name
            string    public key blob
           [string    signature]
          */
          const hasSig = bufferParser.readBool();
          if (hasSig !== undefined) {
            const keyAlgo = bufferParser.readString(true);
            const key = bufferParser.readString();
            if (hasSig) {
              const blobEnd = bufferParser.pos();
              let signature = bufferParser.readString();
              if (signature !== undefined) {
                if (signature.length > 4 + keyAlgo.length + 4 && signature.utf8Slice(4, 4 + keyAlgo.length) === keyAlgo) {
                  // Skip algoLen + algo + sigLen
                  signature = bufferSlice(signature, 4 + keyAlgo.length + 4);
                }
                signature = sigSSHToASN1(signature, keyAlgo);
                if (signature) {
                  const sessionID = self._kex.sessionID;
                  const blob = Buffer.allocUnsafe(4 + sessionID.length + blobEnd);
                  writeUInt32BE(blob, sessionID.length, 0);
                  blob.set(sessionID, 4);
                  blob.set(new Uint8Array(payload.buffer, payload.byteOffset, blobEnd), 4 + sessionID.length);
                  methodData = {
                    keyAlgo,
                    key,
                    signature,
                    blob
                  };
                }
              }
            } else {
              methodData = {
                keyAlgo,
                key
              };
              methodDesc = 'publickey -- check';
            }
          }
          break;
        }
      case 'hostbased':
        {
          /*
            string    public key algorithm for host key
            string    public host key and certificates for client host
            string    client host name expressed as the FQDN in US-ASCII
            string    user name on the client host in ISO-10646 UTF-8 encoding
                       [RFC3629]
            string    signature
          */
          const keyAlgo = bufferParser.readString(true);
          const key = bufferParser.readString();
          const localHostname = bufferParser.readString(true);
          const localUsername = bufferParser.readString(true);
          const blobEnd = bufferParser.pos();
          let signature = bufferParser.readString();
          if (signature !== undefined) {
            if (signature.length > 4 + keyAlgo.length + 4 && signature.utf8Slice(4, 4 + keyAlgo.length) === keyAlgo) {
              // Skip algoLen + algo + sigLen
              signature = bufferSlice(signature, 4 + keyAlgo.length + 4);
            }
            signature = sigSSHToASN1(signature, keyAlgo);
            if (signature !== undefined) {
              const sessionID = self._kex.sessionID;
              const blob = Buffer.allocUnsafe(4 + sessionID.length + blobEnd);
              writeUInt32BE(blob, sessionID.length, 0);
              blob.set(sessionID, 4);
              blob.set(new Uint8Array(payload.buffer, payload.byteOffset, blobEnd), 4 + sessionID.length);
              methodData = {
                keyAlgo,
                key,
                signature,
                blob,
                localHostname,
                localUsername
              };
            }
          }
          break;
        }
      case 'keyboard-interactive':
        /*
          string    language tag (as defined in [RFC-3066])
          string    submethods (ISO-10646 UTF-8)
        */
        // Skip/ignore language field -- it's deprecated in RFC 4256
        bufferParser.skipString();
        methodData = bufferParser.readList();
        break;
      default:
        if (method !== undefined) methodData = bufferParser.readRaw();
    }
    bufferParser.clear();
    if (methodData === undefined) {
      return doFatalError(self, 'Inbound: Malformed USERAUTH_REQUEST packet');
    }
    if (methodDesc === undefined) methodDesc = method;
    self._authsQueue.push(method);
    self._debug && self._debug(`Inbound: Received USERAUTH_REQUEST (${methodDesc})`);
    const handler = self._handlers.USERAUTH_REQUEST;
    handler && handler(self, user, service, method, methodData);
  },
  [MESSAGE.USERAUTH_FAILURE]: (self, payload) => {
    // S->C
    /*
      byte         SSH_MSG_USERAUTH_FAILURE
      name-list    authentications that can continue
      boolean      partial success
    */
    bufferParser.init(payload, 1);
    const authMethods = bufferParser.readList();
    const partialSuccess = bufferParser.readBool();
    bufferParser.clear();
    if (partialSuccess === undefined) {
      return doFatalError(self, 'Inbound: Malformed USERAUTH_FAILURE packet');
    }
    self._debug && self._debug(`Inbound: Received USERAUTH_FAILURE (${authMethods})`);
    self._authsQueue.shift();
    const handler = self._handlers.USERAUTH_FAILURE;
    handler && handler(self, authMethods, partialSuccess);
  },
  [MESSAGE.USERAUTH_SUCCESS]: (self, payload) => {
    // S->C
    /*
      byte      SSH_MSG_USERAUTH_SUCCESS
    */
    self._debug && self._debug('Inbound: Received USERAUTH_SUCCESS');
    self._authsQueue.shift();
    const handler = self._handlers.USERAUTH_SUCCESS;
    handler && handler(self);
  },
  [MESSAGE.USERAUTH_BANNER]: (self, payload) => {
    // S->C
    /*
      byte      SSH_MSG_USERAUTH_BANNER
      string    message in ISO-10646 UTF-8 encoding [RFC3629]
      string    language tag [RFC3066]
    */
    bufferParser.init(payload, 1);
    const msg = bufferParser.readString(true);
    const lang = bufferParser.readString();
    bufferParser.clear();
    if (lang === undefined) {
      return doFatalError(self, 'Inbound: Malformed USERAUTH_BANNER packet');
    }
    self._debug && self._debug('Inbound: Received USERAUTH_BANNER');
    const handler = self._handlers.USERAUTH_BANNER;
    handler && handler(self, msg);
  },
  // User auth protocol -- method-specific =====================================
  60: (self, payload) => {
    if (!self._authsQueue.length) {
      self._debug && self._debug('Inbound: Received payload type 60 without auth');
      return;
    }
    switch (self._authsQueue[0]) {
      case 'password':
        {
          // S->C
          /*
            byte      SSH_MSG_USERAUTH_PASSWD_CHANGEREQ
            string    prompt in ISO-10646 UTF-8 encoding [RFC3629]
            string    language tag [RFC3066]
          */
          bufferParser.init(payload, 1);
          const prompt = bufferParser.readString(true);
          const lang = bufferParser.readString();
          bufferParser.clear();
          if (lang === undefined) {
            return doFatalError(self, 'Inbound: Malformed USERAUTH_PASSWD_CHANGEREQ packet');
          }
          self._debug && self._debug('Inbound: Received USERAUTH_PASSWD_CHANGEREQ');
          const handler = self._handlers.USERAUTH_PASSWD_CHANGEREQ;
          handler && handler(self, prompt);
          break;
        }
      case 'publickey':
        {
          // S->C
          /*
            byte      SSH_MSG_USERAUTH_PK_OK
            string    public key algorithm name from the request
            string    public key blob from the request
          */
          bufferParser.init(payload, 1);
          const keyAlgo = bufferParser.readString(true);
          const key = bufferParser.readString();
          bufferParser.clear();
          if (key === undefined) {
            return doFatalError(self, 'Inbound: Malformed USERAUTH_PK_OK packet');
          }
          self._debug && self._debug('Inbound: Received USERAUTH_PK_OK');
          self._authsQueue.shift();
          const handler = self._handlers.USERAUTH_PK_OK;
          handler && handler(self, keyAlgo, key);
          break;
        }
      case 'keyboard-interactive':
        {
          // S->C
          /*
            byte      SSH_MSG_USERAUTH_INFO_REQUEST
            string    name (ISO-10646 UTF-8)
            string    instruction (ISO-10646 UTF-8)
            string    language tag (as defined in [RFC-3066])
            int       num-prompts
            string    prompt[1] (ISO-10646 UTF-8)
            boolean   echo[1]
            ...
            string    prompt[num-prompts] (ISO-10646 UTF-8)
            boolean   echo[num-prompts]
          */
          bufferParser.init(payload, 1);
          const name = bufferParser.readString(true);
          const instructions = bufferParser.readString(true);
          bufferParser.readString(); // skip lang
          const numPrompts = bufferParser.readUInt32BE();
          let prompts;
          if (numPrompts !== undefined) {
            prompts = new Array(numPrompts);
            let i;
            for (i = 0; i < numPrompts; ++i) {
              const prompt = bufferParser.readString(true);
              const echo = bufferParser.readBool();
              if (echo === undefined) break;
              prompts[i] = {
                prompt,
                echo
              };
            }
            if (i !== numPrompts) prompts = undefined;
          }
          bufferParser.clear();
          if (prompts === undefined) {
            return doFatalError(self, 'Inbound: Malformed USERAUTH_INFO_REQUEST packet');
          }
          self._debug && self._debug('Inbound: Received USERAUTH_INFO_REQUEST');
          const handler = self._handlers.USERAUTH_INFO_REQUEST;
          handler && handler(self, name, instructions, prompts);
          break;
        }
      default:
        self._debug && self._debug('Inbound: Received unexpected payload type 60');
    }
  },
  61: (self, payload) => {
    if (!self._authsQueue.length) {
      self._debug && self._debug('Inbound: Received payload type 61 without auth');
      return;
    }
    /*
      byte      SSH_MSG_USERAUTH_INFO_RESPONSE
      int       num-responses
      string    response[1] (ISO-10646 UTF-8)
      ...
      string    response[num-responses] (ISO-10646 UTF-8)
    */
    if (self._authsQueue[0] !== 'keyboard-interactive') {
      return doFatalError(self, 'Inbound: Received unexpected payload type 61');
    }
    bufferParser.init(payload, 1);
    const numResponses = bufferParser.readUInt32BE();
    let responses;
    if (numResponses !== undefined) {
      responses = new Array(numResponses);
      let i;
      for (i = 0; i < numResponses; ++i) {
        const response = bufferParser.readString(true);
        if (response === undefined) break;
        responses[i] = response;
      }
      if (i !== numResponses) responses = undefined;
    }
    bufferParser.clear();
    if (responses === undefined) {
      return doFatalError(self, 'Inbound: Malformed USERAUTH_INFO_RESPONSE packet');
    }
    self._debug && self._debug('Inbound: Received USERAUTH_INFO_RESPONSE');
    const handler = self._handlers.USERAUTH_INFO_RESPONSE;
    handler && handler(self, responses);
  },
  // Connection protocol -- generic ============================================
  [MESSAGE.GLOBAL_REQUEST]: (self, payload) => {
    /*
      byte      SSH_MSG_GLOBAL_REQUEST
      string    request name in US-ASCII only
      boolean   want reply
      ....      request-specific data follows
    */
    bufferParser.init(payload, 1);
    const name = bufferParser.readString(true);
    const wantReply = bufferParser.readBool();
    let data;
    if (wantReply !== undefined) {
      switch (name) {
        case 'tcpip-forward':
        case 'cancel-tcpip-forward':
          {
            /*
              string    address to bind (e.g., "0.0.0.0")
              uint32    port number to bind
            */
            const bindAddr = bufferParser.readString(true);
            const bindPort = bufferParser.readUInt32BE();
            if (bindPort !== undefined) data = {
              bindAddr,
              bindPort
            };
            break;
          }
        case 'streamlocal-forward@openssh.com':
        case 'cancel-streamlocal-forward@openssh.com':
          {
            /*
              string    socket path
            */
            const socketPath = bufferParser.readString(true);
            if (socketPath !== undefined) data = {
              socketPath
            };
            break;
          }
        case 'no-more-sessions@openssh.com':
          data = null;
          break;
        case 'hostkeys-00@openssh.com':
          {
            data = [];
            while (bufferParser.avail() > 0) {
              const keyRaw = bufferParser.readString();
              if (keyRaw === undefined) {
                data = undefined;
                break;
              }
              const key = parseKey(keyRaw);
              if (!(key instanceof Error)) data.push(key);
            }
            break;
          }
        default:
          data = bufferParser.readRaw();
      }
    }
    bufferParser.clear();
    if (data === undefined) {
      return doFatalError(self, 'Inbound: Malformed GLOBAL_REQUEST packet');
    }
    self._debug && self._debug(`Inbound: GLOBAL_REQUEST (${name})`);
    const handler = self._handlers.GLOBAL_REQUEST;
    if (handler) handler(self, name, wantReply, data);else self.requestFailure(); // Auto reject
  },

  [MESSAGE.REQUEST_SUCCESS]: (self, payload) => {
    /*
      byte      SSH_MSG_REQUEST_SUCCESS
      ....     response specific data
    */
    const data = payload.length > 1 ? bufferSlice(payload, 1) : null;
    self._debug && self._debug('Inbound: REQUEST_SUCCESS');
    const handler = self._handlers.REQUEST_SUCCESS;
    handler && handler(self, data);
  },
  [MESSAGE.REQUEST_FAILURE]: (self, payload) => {
    /*
      byte      SSH_MSG_REQUEST_FAILURE
    */
    self._debug && self._debug('Inbound: Received REQUEST_FAILURE');
    const handler = self._handlers.REQUEST_FAILURE;
    handler && handler(self);
  },
  // Connection protocol -- channel-related ====================================
  [MESSAGE.CHANNEL_OPEN]: (self, payload) => {
    /*
      byte      SSH_MSG_CHANNEL_OPEN
      string    channel type in US-ASCII only
      uint32    sender channel
      uint32    initial window size
      uint32    maximum packet size
      ....      channel type specific data follows
    */
    bufferParser.init(payload, 1);
    const type = bufferParser.readString(true);
    const sender = bufferParser.readUInt32BE();
    const window = bufferParser.readUInt32BE();
    const packetSize = bufferParser.readUInt32BE();
    let channelInfo;
    switch (type) {
      case 'forwarded-tcpip': // S->C
      case 'direct-tcpip':
        {
          // C->S
          /*
            string    address that was connected / host to connect
            uint32    port that was connected / port to connect
            string    originator IP address
            uint32    originator port
          */
          const destIP = bufferParser.readString(true);
          const destPort = bufferParser.readUInt32BE();
          const srcIP = bufferParser.readString(true);
          const srcPort = bufferParser.readUInt32BE();
          if (srcPort !== undefined) {
            channelInfo = {
              type,
              sender,
              window,
              packetSize,
              data: {
                destIP,
                destPort,
                srcIP,
                srcPort
              }
            };
          }
          break;
        }
      case 'forwarded-streamlocal@openssh.com': // S->C
      case 'direct-streamlocal@openssh.com':
        {
          // C->S
          /*
            string    socket path
            string    reserved for future use
             (direct-streamlocal@openssh.com additionally has:)
            uint32    reserved
          */
          const socketPath = bufferParser.readString(true);
          if (socketPath !== undefined) {
            channelInfo = {
              type,
              sender,
              window,
              packetSize,
              data: {
                socketPath
              }
            };
          }
          break;
        }
      case 'x11':
        {
          // S->C
          /*
            string    originator address (e.g., "192.168.7.38")
            uint32    originator port
          */
          const srcIP = bufferParser.readString(true);
          const srcPort = bufferParser.readUInt32BE();
          if (srcPort !== undefined) {
            channelInfo = {
              type,
              sender,
              window,
              packetSize,
              data: {
                srcIP,
                srcPort
              }
            };
          }
          break;
        }
      default:
        // Includes:
        //   'session' (C->S)
        //   'auth-agent@openssh.com' (S->C)
        channelInfo = {
          type,
          sender,
          window,
          packetSize,
          data: {}
        };
    }
    bufferParser.clear();
    if (channelInfo === undefined) {
      return doFatalError(self, 'Inbound: Malformed CHANNEL_OPEN packet');
    }
    self._debug && self._debug(`Inbound: CHANNEL_OPEN (s:${sender}, ${type})`);
    const handler = self._handlers.CHANNEL_OPEN;
    if (handler) {
      handler(self, channelInfo);
    } else {
      self.channelOpenFail(channelInfo.sender, CHANNEL_OPEN_FAILURE.ADMINISTRATIVELY_PROHIBITED, '', '');
    }
  },
  [MESSAGE.CHANNEL_OPEN_CONFIRMATION]: (self, payload) => {
    /*
      byte      SSH_MSG_CHANNEL_OPEN_CONFIRMATION
      uint32    recipient channel
      uint32    sender channel
      uint32    initial window size
      uint32    maximum packet size
      ....      channel type specific data follows
    */
    // "The 'recipient channel' is the channel number given in the
    // original open request, and 'sender channel' is the channel number
    // allocated by the other side."
    bufferParser.init(payload, 1);
    const recipient = bufferParser.readUInt32BE();
    const sender = bufferParser.readUInt32BE();
    const window = bufferParser.readUInt32BE();
    const packetSize = bufferParser.readUInt32BE();
    const data = bufferParser.avail() ? bufferParser.readRaw() : undefined;
    bufferParser.clear();
    if (packetSize === undefined) {
      return doFatalError(self, 'Inbound: Malformed CHANNEL_OPEN_CONFIRMATION packet');
    }
    self._debug && self._debug(`Inbound: CHANNEL_OPEN_CONFIRMATION (r:${recipient}, s:${sender})`);
    const handler = self._handlers.CHANNEL_OPEN_CONFIRMATION;
    if (handler) handler(self, {
      recipient,
      sender,
      window,
      packetSize,
      data
    });
  },
  [MESSAGE.CHANNEL_OPEN_FAILURE]: (self, payload) => {
    /*
      byte      SSH_MSG_CHANNEL_OPEN_FAILURE
      uint32    recipient channel
      uint32    reason code
      string    description in ISO-10646 UTF-8 encoding [RFC3629]
      string    language tag [RFC3066]
    */
    bufferParser.init(payload, 1);
    const recipient = bufferParser.readUInt32BE();
    const reason = bufferParser.readUInt32BE();
    const description = bufferParser.readString(true);
    const lang = bufferParser.readString();
    bufferParser.clear();
    if (lang === undefined) {
      return doFatalError(self, 'Inbound: Malformed CHANNEL_OPEN_FAILURE packet');
    }
    self._debug && self._debug(`Inbound: CHANNEL_OPEN_FAILURE (r:${recipient})`);
    const handler = self._handlers.CHANNEL_OPEN_FAILURE;
    handler && handler(self, recipient, reason, description);
  },
  [MESSAGE.CHANNEL_WINDOW_ADJUST]: (self, payload) => {
    /*
      byte      SSH_MSG_CHANNEL_WINDOW_ADJUST
      uint32    recipient channel
      uint32    bytes to add
    */
    bufferParser.init(payload, 1);
    const recipient = bufferParser.readUInt32BE();
    const bytesToAdd = bufferParser.readUInt32BE();
    bufferParser.clear();
    if (bytesToAdd === undefined) {
      return doFatalError(self, 'Inbound: Malformed CHANNEL_WINDOW_ADJUST packet');
    }
    self._debug && self._debug(`Inbound: CHANNEL_WINDOW_ADJUST (r:${recipient}, ${bytesToAdd})`);
    const handler = self._handlers.CHANNEL_WINDOW_ADJUST;
    handler && handler(self, recipient, bytesToAdd);
  },
  [MESSAGE.CHANNEL_DATA]: (self, payload) => {
    /*
      byte      SSH_MSG_CHANNEL_DATA
      uint32    recipient channel
      string    data
    */
    bufferParser.init(payload, 1);
    const recipient = bufferParser.readUInt32BE();
    const data = bufferParser.readString();
    bufferParser.clear();
    if (data === undefined) {
      return doFatalError(self, 'Inbound: Malformed CHANNEL_DATA packet');
    }
    self._debug && self._debug(`Inbound: CHANNEL_DATA (r:${recipient}, ${data.length})`);
    const handler = self._handlers.CHANNEL_DATA;
    handler && handler(self, recipient, data);
  },
  [MESSAGE.CHANNEL_EXTENDED_DATA]: (self, payload) => {
    /*
      byte      SSH_MSG_CHANNEL_EXTENDED_DATA
      uint32    recipient channel
      uint32    data_type_code
      string    data
    */
    bufferParser.init(payload, 1);
    const recipient = bufferParser.readUInt32BE();
    const type = bufferParser.readUInt32BE();
    const data = bufferParser.readString();
    bufferParser.clear();
    if (data === undefined) {
      return doFatalError(self, 'Inbound: Malformed CHANNEL_EXTENDED_DATA packet');
    }
    self._debug && self._debug(`Inbound: CHANNEL_EXTENDED_DATA (r:${recipient}, ${data.length})`);
    const handler = self._handlers.CHANNEL_EXTENDED_DATA;
    handler && handler(self, recipient, data, type);
  },
  [MESSAGE.CHANNEL_EOF]: (self, payload) => {
    /*
      byte      SSH_MSG_CHANNEL_EOF
      uint32    recipient channel
    */
    bufferParser.init(payload, 1);
    const recipient = bufferParser.readUInt32BE();
    bufferParser.clear();
    if (recipient === undefined) {
      return doFatalError(self, 'Inbound: Malformed CHANNEL_EOF packet');
    }
    self._debug && self._debug(`Inbound: CHANNEL_EOF (r:${recipient})`);
    const handler = self._handlers.CHANNEL_EOF;
    handler && handler(self, recipient);
  },
  [MESSAGE.CHANNEL_CLOSE]: (self, payload) => {
    /*
      byte      SSH_MSG_CHANNEL_CLOSE
      uint32    recipient channel
    */
    bufferParser.init(payload, 1);
    const recipient = bufferParser.readUInt32BE();
    bufferParser.clear();
    if (recipient === undefined) {
      return doFatalError(self, 'Inbound: Malformed CHANNEL_CLOSE packet');
    }
    self._debug && self._debug(`Inbound: CHANNEL_CLOSE (r:${recipient})`);
    const handler = self._handlers.CHANNEL_CLOSE;
    handler && handler(self, recipient);
  },
  [MESSAGE.CHANNEL_REQUEST]: (self, payload) => {
    /*
      byte      SSH_MSG_CHANNEL_REQUEST
      uint32    recipient channel
      string    request type in US-ASCII characters only
      boolean   want reply
      ....      type-specific data follows
    */
    bufferParser.init(payload, 1);
    const recipient = bufferParser.readUInt32BE();
    const type = bufferParser.readString(true);
    const wantReply = bufferParser.readBool();
    let data;
    if (wantReply !== undefined) {
      switch (type) {
        case 'exit-status':
          // S->C
          /*
            uint32    exit_status
          */
          data = bufferParser.readUInt32BE();
          self._debug && self._debug(`Inbound: CHANNEL_REQUEST (r:${recipient}, ${type}: ${data})`);
          break;
        case 'exit-signal':
          {
            // S->C
            /*
              string    signal name (without the "SIG" prefix)
              boolean   core dumped
              string    error message in ISO-10646 UTF-8 encoding
              string    language tag
            */
            let signal;
            let coreDumped;
            if (self._compatFlags & COMPAT.OLD_EXIT) {
              /*
                Instead of `signal name` and `core dumped`, we have just:
                  uint32  signal number
              */
              const num = bufferParser.readUInt32BE();
              switch (num) {
                case 1:
                  signal = 'HUP';
                  break;
                case 2:
                  signal = 'INT';
                  break;
                case 3:
                  signal = 'QUIT';
                  break;
                case 6:
                  signal = 'ABRT';
                  break;
                case 9:
                  signal = 'KILL';
                  break;
                case 14:
                  signal = 'ALRM';
                  break;
                case 15:
                  signal = 'TERM';
                  break;
                default:
                  if (num !== undefined) {
                    // Unknown or OS-specific
                    signal = `UNKNOWN (${num})`;
                  }
              }
              coreDumped = false;
            } else {
              signal = bufferParser.readString(true);
              coreDumped = bufferParser.readBool();
              if (coreDumped === undefined) signal = undefined;
            }
            const errorMessage = bufferParser.readString(true);
            if (bufferParser.skipString() !== undefined) data = {
              signal,
              coreDumped,
              errorMessage
            };
            self._debug && self._debug(`Inbound: CHANNEL_REQUEST (r:${recipient}, ${type}: ${signal})`);
            break;
          }
        case 'pty-req':
          {
            // C->S
            /*
              string    TERM environment variable value (e.g., vt100)
              uint32    terminal width, characters (e.g., 80)
              uint32    terminal height, rows (e.g., 24)
              uint32    terminal width, pixels (e.g., 640)
              uint32    terminal height, pixels (e.g., 480)
              string    encoded terminal modes
            */
            const term = bufferParser.readString(true);
            const cols = bufferParser.readUInt32BE();
            const rows = bufferParser.readUInt32BE();
            const width = bufferParser.readUInt32BE();
            const height = bufferParser.readUInt32BE();
            const modesBinary = bufferParser.readString();
            if (modesBinary !== undefined) {
              bufferParser.init(modesBinary, 1);
              let modes = {};
              while (bufferParser.avail()) {
                const opcode = bufferParser.readByte();
                if (opcode === TERMINAL_MODE.TTY_OP_END) break;
                const name = TERMINAL_MODE_BY_VALUE[opcode];
                const value = bufferParser.readUInt32BE();
                if (opcode === undefined || name === undefined || value === undefined) {
                  modes = undefined;
                  break;
                }
                modes[name] = value;
              }
              if (modes !== undefined) data = {
                term,
                cols,
                rows,
                width,
                height,
                modes
              };
            }
            self._debug && self._debug(`Inbound: CHANNEL_REQUEST (r:${recipient}, ${type})`);
            break;
          }
        case 'window-change':
          {
            // C->S
            /*
              uint32    terminal width, columns
              uint32    terminal height, rows
              uint32    terminal width, pixels
              uint32    terminal height, pixels
            */
            const cols = bufferParser.readUInt32BE();
            const rows = bufferParser.readUInt32BE();
            const width = bufferParser.readUInt32BE();
            const height = bufferParser.readUInt32BE();
            if (height !== undefined) data = {
              cols,
              rows,
              width,
              height
            };
            self._debug && self._debug(`Inbound: CHANNEL_REQUEST (r:${recipient}, ${type})`);
            break;
          }
        case 'x11-req':
          {
            // C->S
            /*
              boolean   single connection
              string    x11 authentication protocol
              string    x11 authentication cookie
              uint32    x11 screen number
            */
            const single = bufferParser.readBool();
            const protocol = bufferParser.readString(true);
            const cookie = bufferParser.readString();
            const screen = bufferParser.readUInt32BE();
            if (screen !== undefined) data = {
              single,
              protocol,
              cookie,
              screen
            };
            self._debug && self._debug(`Inbound: CHANNEL_REQUEST (r:${recipient}, ${type})`);
            break;
          }
        case 'env':
          {
            // C->S
            /*
              string    variable name
              string    variable value
            */
            const name = bufferParser.readString(true);
            const value = bufferParser.readString(true);
            if (value !== undefined) data = {
              name,
              value
            };
            if (self._debug) {
              self._debug(`Inbound: CHANNEL_REQUEST (r:${recipient}, ${type}: ` + `${name}=${value})`);
            }
            break;
          }
        case 'shell':
          // C->S
          data = null; // No extra data
          self._debug && self._debug(`Inbound: CHANNEL_REQUEST (r:${recipient}, ${type})`);
          break;
        case 'exec':
          // C->S
          /*
            string    command
          */
          data = bufferParser.readString(true);
          self._debug && self._debug(`Inbound: CHANNEL_REQUEST (r:${recipient}, ${type}: ${data})`);
          break;
        case 'subsystem':
          // C->S
          /*
            string    subsystem name
          */
          data = bufferParser.readString(true);
          self._debug && self._debug(`Inbound: CHANNEL_REQUEST (r:${recipient}, ${type}: ${data})`);
          break;
        case 'signal':
          // C->S
          /*
            string    signal name (without the "SIG" prefix)
          */
          data = bufferParser.readString(true);
          self._debug && self._debug(`Inbound: CHANNEL_REQUEST (r:${recipient}, ${type}: ${data})`);
          break;
        case 'xon-xoff':
          // C->S
          /*
            boolean   client can do
          */
          data = bufferParser.readBool();
          self._debug && self._debug(`Inbound: CHANNEL_REQUEST (r:${recipient}, ${type}: ${data})`);
          break;
        case 'auth-agent-req@openssh.com':
          // C-S
          data = null; // No extra data
          self._debug && self._debug(`Inbound: CHANNEL_REQUEST (r:${recipient}, ${type})`);
          break;
        default:
          data = bufferParser.avail() ? bufferParser.readRaw() : null;
          self._debug && self._debug(`Inbound: CHANNEL_REQUEST (r:${recipient}, ${type})`);
      }
    }
    bufferParser.clear();
    if (data === undefined) {
      return doFatalError(self, 'Inbound: Malformed CHANNEL_REQUEST packet');
    }
    const handler = self._handlers.CHANNEL_REQUEST;
    handler && handler(self, recipient, type, wantReply, data);
  },
  [MESSAGE.CHANNEL_SUCCESS]: (self, payload) => {
    /*
      byte      SSH_MSG_CHANNEL_SUCCESS
      uint32    recipient channel
    */
    bufferParser.init(payload, 1);
    const recipient = bufferParser.readUInt32BE();
    bufferParser.clear();
    if (recipient === undefined) {
      return doFatalError(self, 'Inbound: Malformed CHANNEL_SUCCESS packet');
    }
    self._debug && self._debug(`Inbound: CHANNEL_SUCCESS (r:${recipient})`);
    const handler = self._handlers.CHANNEL_SUCCESS;
    handler && handler(self, recipient);
  },
  [MESSAGE.CHANNEL_FAILURE]: (self, payload) => {
    /*
      byte      SSH_MSG_CHANNEL_FAILURE
      uint32    recipient channel
    */
    bufferParser.init(payload, 1);
    const recipient = bufferParser.readUInt32BE();
    bufferParser.clear();
    if (recipient === undefined) {
      return doFatalError(self, 'Inbound: Malformed CHANNEL_FAILURE packet');
    }
    self._debug && self._debug(`Inbound: CHANNEL_FAILURE (r:${recipient})`);
    const handler = self._handlers.CHANNEL_FAILURE;
    handler && handler(self, recipient);
  }
};

/***/ }),

/***/ 3027:
/*!************************************************!*\
  !*** ../node_modules/ssh2/lib/protocol/kex.js ***!
  \************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


const {
  createDiffieHellman,
  createDiffieHellmanGroup,
  createECDH,
  createHash,
  createPublicKey,
  diffieHellman,
  generateKeyPairSync,
  randomFillSync
} = __webpack_require__(/*! crypto */ 6113);
const {
  Ber
} = __webpack_require__(/*! asn1 */ 5593);
const {
  COMPAT,
  curve25519Supported,
  DEFAULT_KEX,
  DEFAULT_SERVER_HOST_KEY,
  DEFAULT_CIPHER,
  DEFAULT_MAC,
  DEFAULT_COMPRESSION,
  DISCONNECT_REASON,
  MESSAGE
} = __webpack_require__(/*! ./constants.js */ 7816);
const {
  CIPHER_INFO,
  createCipher,
  createDecipher,
  MAC_INFO
} = __webpack_require__(/*! ./crypto.js */ 6173);
const {
  parseDERKey
} = __webpack_require__(/*! ./keyParser.js */ 9934);
const {
  bufferFill,
  bufferParser,
  convertSignature,
  doFatalError,
  FastBuffer,
  sigSSHToASN1,
  writeUInt32BE
} = __webpack_require__(/*! ./utils.js */ 3549);
const {
  PacketReader,
  PacketWriter,
  ZlibPacketReader,
  ZlibPacketWriter
} = __webpack_require__(/*! ./zlib.js */ 6719);
let MESSAGE_HANDLERS;
const GEX_MIN_BITS = 2048; // RFC 8270
const GEX_MAX_BITS = 8192; // RFC 8270

const EMPTY_BUFFER = Buffer.alloc(0);

// Client/Server
function kexinit(self) {
  /*
    byte         SSH_MSG_KEXINIT
    byte[16]     cookie (random bytes)
    name-list    kex_algorithms
    name-list    server_host_key_algorithms
    name-list    encryption_algorithms_client_to_server
    name-list    encryption_algorithms_server_to_client
    name-list    mac_algorithms_client_to_server
    name-list    mac_algorithms_server_to_client
    name-list    compression_algorithms_client_to_server
    name-list    compression_algorithms_server_to_client
    name-list    languages_client_to_server
    name-list    languages_server_to_client
    boolean      first_kex_packet_follows
    uint32       0 (reserved for future extension)
  */

  let payload;
  if (self._compatFlags & COMPAT.BAD_DHGEX) {
    const entry = self._offer.lists.kex;
    let kex = entry.array;
    let found = false;
    for (let i = 0; i < kex.length; ++i) {
      if (kex[i].includes('group-exchange')) {
        if (!found) {
          found = true;
          // Copy array lazily
          kex = kex.slice();
        }
        kex.splice(i--, 1);
      }
    }
    if (found) {
      let len = 1 + 16 + self._offer.totalSize + 1 + 4;
      const newKexBuf = Buffer.from(kex.join(','));
      len -= entry.buffer.length - newKexBuf.length;
      const all = self._offer.lists.all;
      const rest = new Uint8Array(all.buffer, all.byteOffset + 4 + entry.buffer.length, all.length - (4 + entry.buffer.length));
      payload = Buffer.allocUnsafe(len);
      writeUInt32BE(payload, newKexBuf.length, 17);
      payload.set(newKexBuf, 17 + 4);
      payload.set(rest, 17 + 4 + newKexBuf.length);
    }
  }
  if (payload === undefined) {
    payload = Buffer.allocUnsafe(1 + 16 + self._offer.totalSize + 1 + 4);
    self._offer.copyAllTo(payload, 17);
  }
  self._debug && self._debug('Outbound: Sending KEXINIT');
  payload[0] = MESSAGE.KEXINIT;
  randomFillSync(payload, 1, 16);

  // Zero-fill first_kex_packet_follows and reserved bytes
  bufferFill(payload, 0, payload.length - 5);
  self._kexinit = payload;

  // Needed to correct the starting position in allocated "packets" when packets
  // will be buffered due to active key exchange
  self._packetRW.write.allocStart = 0;

  // TODO: only create single buffer and set _kexinit as slice of packet instead
  {
    const p = self._packetRW.write.allocStartKEX;
    const packet = self._packetRW.write.alloc(payload.length, true);
    packet.set(payload, p);
    self._cipher.encrypt(self._packetRW.write.finalize(packet, true));
  }
}
function handleKexInit(self, payload) {
  /*
    byte         SSH_MSG_KEXINIT
    byte[16]     cookie (random bytes)
    name-list    kex_algorithms
    name-list    server_host_key_algorithms
    name-list    encryption_algorithms_client_to_server
    name-list    encryption_algorithms_server_to_client
    name-list    mac_algorithms_client_to_server
    name-list    mac_algorithms_server_to_client
    name-list    compression_algorithms_client_to_server
    name-list    compression_algorithms_server_to_client
    name-list    languages_client_to_server
    name-list    languages_server_to_client
    boolean      first_kex_packet_follows
    uint32       0 (reserved for future extension)
  */
  const init = {
    kex: undefined,
    serverHostKey: undefined,
    cs: {
      cipher: undefined,
      mac: undefined,
      compress: undefined,
      lang: undefined
    },
    sc: {
      cipher: undefined,
      mac: undefined,
      compress: undefined,
      lang: undefined
    }
  };
  bufferParser.init(payload, 17);
  if ((init.kex = bufferParser.readList()) === undefined || (init.serverHostKey = bufferParser.readList()) === undefined || (init.cs.cipher = bufferParser.readList()) === undefined || (init.sc.cipher = bufferParser.readList()) === undefined || (init.cs.mac = bufferParser.readList()) === undefined || (init.sc.mac = bufferParser.readList()) === undefined || (init.cs.compress = bufferParser.readList()) === undefined || (init.sc.compress = bufferParser.readList()) === undefined || (init.cs.lang = bufferParser.readList()) === undefined || (init.sc.lang = bufferParser.readList()) === undefined) {
    bufferParser.clear();
    return doFatalError(self, 'Received malformed KEXINIT', 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
  }
  const pos = bufferParser.pos();
  const firstFollows = pos < payload.length && payload[pos] === 1;
  bufferParser.clear();
  const local = self._offer;
  const remote = init;
  self._remoteHostKeyAlgorithms = remote.serverHostKey;
  let localKex = local.lists.kex.array;
  if (self._compatFlags & COMPAT.BAD_DHGEX) {
    let found = false;
    for (let i = 0; i < localKex.length; ++i) {
      if (localKex[i].indexOf('group-exchange') !== -1) {
        if (!found) {
          found = true;
          // Copy array lazily
          localKex = localKex.slice();
        }
        localKex.splice(i--, 1);
      }
    }
  }
  let clientList;
  let serverList;
  let i;
  const debug = self._debug;
  debug && debug('Inbound: Handshake in progress');

  // Key exchange method =======================================================
  debug && debug(`Handshake: (local) KEX method: ${localKex}`);
  debug && debug(`Handshake: (remote) KEX method: ${remote.kex}`);
  if (self._server) {
    serverList = localKex;
    clientList = remote.kex;
  } else {
    serverList = remote.kex;
    clientList = localKex;
  }
  // Check for agreeable key exchange algorithm
  for (i = 0; i < clientList.length && serverList.indexOf(clientList[i]) === -1; ++i);
  if (i === clientList.length) {
    // No suitable match found!
    debug && debug('Handshake: No matching key exchange algorithm');
    return doFatalError(self, 'Handshake failed: no matching key exchange algorithm', 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
  }
  init.kex = clientList[i];
  debug && debug(`Handshake: KEX algorithm: ${clientList[i]}`);
  if (firstFollows && (!remote.kex.length || clientList[i] !== remote.kex[0])) {
    // Ignore next inbound packet, it was a wrong first guess at KEX algorithm
    self._skipNextInboundPacket = true;
  }

  // Server host key format ====================================================
  const localSrvHostKey = local.lists.serverHostKey.array;
  debug && debug(`Handshake: (local) Host key format: ${localSrvHostKey}`);
  debug && debug(`Handshake: (remote) Host key format: ${remote.serverHostKey}`);
  if (self._server) {
    serverList = localSrvHostKey;
    clientList = remote.serverHostKey;
  } else {
    serverList = remote.serverHostKey;
    clientList = localSrvHostKey;
  }
  // Check for agreeable server host key format
  for (i = 0; i < clientList.length && serverList.indexOf(clientList[i]) === -1; ++i);
  if (i === clientList.length) {
    // No suitable match found!
    debug && debug('Handshake: No matching host key format');
    return doFatalError(self, 'Handshake failed: no matching host key format', 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
  }
  init.serverHostKey = clientList[i];
  debug && debug(`Handshake: Host key format: ${clientList[i]}`);

  // Client->Server cipher =====================================================
  const localCSCipher = local.lists.cs.cipher.array;
  debug && debug(`Handshake: (local) C->S cipher: ${localCSCipher}`);
  debug && debug(`Handshake: (remote) C->S cipher: ${remote.cs.cipher}`);
  if (self._server) {
    serverList = localCSCipher;
    clientList = remote.cs.cipher;
  } else {
    serverList = remote.cs.cipher;
    clientList = localCSCipher;
  }
  // Check for agreeable client->server cipher
  for (i = 0; i < clientList.length && serverList.indexOf(clientList[i]) === -1; ++i);
  if (i === clientList.length) {
    // No suitable match found!
    debug && debug('Handshake: No matching C->S cipher');
    return doFatalError(self, 'Handshake failed: no matching C->S cipher', 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
  }
  init.cs.cipher = clientList[i];
  debug && debug(`Handshake: C->S Cipher: ${clientList[i]}`);

  // Server->Client cipher =====================================================
  const localSCCipher = local.lists.sc.cipher.array;
  debug && debug(`Handshake: (local) S->C cipher: ${localSCCipher}`);
  debug && debug(`Handshake: (remote) S->C cipher: ${remote.sc.cipher}`);
  if (self._server) {
    serverList = localSCCipher;
    clientList = remote.sc.cipher;
  } else {
    serverList = remote.sc.cipher;
    clientList = localSCCipher;
  }
  // Check for agreeable server->client cipher
  for (i = 0; i < clientList.length && serverList.indexOf(clientList[i]) === -1; ++i);
  if (i === clientList.length) {
    // No suitable match found!
    debug && debug('Handshake: No matching S->C cipher');
    return doFatalError(self, 'Handshake failed: no matching S->C cipher', 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
  }
  init.sc.cipher = clientList[i];
  debug && debug(`Handshake: S->C cipher: ${clientList[i]}`);

  // Client->Server MAC ========================================================
  const localCSMAC = local.lists.cs.mac.array;
  debug && debug(`Handshake: (local) C->S MAC: ${localCSMAC}`);
  debug && debug(`Handshake: (remote) C->S MAC: ${remote.cs.mac}`);
  if (CIPHER_INFO[init.cs.cipher].authLen > 0) {
    init.cs.mac = '';
    debug && debug('Handshake: C->S MAC: <implicit>');
  } else {
    if (self._server) {
      serverList = localCSMAC;
      clientList = remote.cs.mac;
    } else {
      serverList = remote.cs.mac;
      clientList = localCSMAC;
    }
    // Check for agreeable client->server hmac algorithm
    for (i = 0; i < clientList.length && serverList.indexOf(clientList[i]) === -1; ++i);
    if (i === clientList.length) {
      // No suitable match found!
      debug && debug('Handshake: No matching C->S MAC');
      return doFatalError(self, 'Handshake failed: no matching C->S MAC', 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
    }
    init.cs.mac = clientList[i];
    debug && debug(`Handshake: C->S MAC: ${clientList[i]}`);
  }

  // Server->Client MAC ========================================================
  const localSCMAC = local.lists.sc.mac.array;
  debug && debug(`Handshake: (local) S->C MAC: ${localSCMAC}`);
  debug && debug(`Handshake: (remote) S->C MAC: ${remote.sc.mac}`);
  if (CIPHER_INFO[init.sc.cipher].authLen > 0) {
    init.sc.mac = '';
    debug && debug('Handshake: S->C MAC: <implicit>');
  } else {
    if (self._server) {
      serverList = localSCMAC;
      clientList = remote.sc.mac;
    } else {
      serverList = remote.sc.mac;
      clientList = localSCMAC;
    }
    // Check for agreeable server->client hmac algorithm
    for (i = 0; i < clientList.length && serverList.indexOf(clientList[i]) === -1; ++i);
    if (i === clientList.length) {
      // No suitable match found!
      debug && debug('Handshake: No matching S->C MAC');
      return doFatalError(self, 'Handshake failed: no matching S->C MAC', 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
    }
    init.sc.mac = clientList[i];
    debug && debug(`Handshake: S->C MAC: ${clientList[i]}`);
  }

  // Client->Server compression ================================================
  const localCSCompress = local.lists.cs.compress.array;
  debug && debug(`Handshake: (local) C->S compression: ${localCSCompress}`);
  debug && debug(`Handshake: (remote) C->S compression: ${remote.cs.compress}`);
  if (self._server) {
    serverList = localCSCompress;
    clientList = remote.cs.compress;
  } else {
    serverList = remote.cs.compress;
    clientList = localCSCompress;
  }
  // Check for agreeable client->server compression algorithm
  for (i = 0; i < clientList.length && serverList.indexOf(clientList[i]) === -1; ++i);
  if (i === clientList.length) {
    // No suitable match found!
    debug && debug('Handshake: No matching C->S compression');
    return doFatalError(self, 'Handshake failed: no matching C->S compression', 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
  }
  init.cs.compress = clientList[i];
  debug && debug(`Handshake: C->S compression: ${clientList[i]}`);

  // Server->Client compression ================================================
  const localSCCompress = local.lists.sc.compress.array;
  debug && debug(`Handshake: (local) S->C compression: ${localSCCompress}`);
  debug && debug(`Handshake: (remote) S->C compression: ${remote.sc.compress}`);
  if (self._server) {
    serverList = localSCCompress;
    clientList = remote.sc.compress;
  } else {
    serverList = remote.sc.compress;
    clientList = localSCCompress;
  }
  // Check for agreeable server->client compression algorithm
  for (i = 0; i < clientList.length && serverList.indexOf(clientList[i]) === -1; ++i);
  if (i === clientList.length) {
    // No suitable match found!
    debug && debug('Handshake: No matching S->C compression');
    return doFatalError(self, 'Handshake failed: no matching S->C compression', 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
  }
  init.sc.compress = clientList[i];
  debug && debug(`Handshake: S->C compression: ${clientList[i]}`);
  init.cs.lang = '';
  init.sc.lang = '';

  // XXX: hack -- find a better way to do this
  if (self._kex) {
    if (!self._kexinit) {
      // We received a rekey request, but we haven't sent a KEXINIT in response
      // yet
      kexinit(self);
    }
    self._decipher._onPayload = onKEXPayload.bind(self, {
      firstPacket: false
    });
  }
  self._kex = createKeyExchange(init, self, payload);
  self._kex.start();
}
const createKeyExchange = (() => {
  function convertToMpint(buf) {
    let idx = 0;
    let length = buf.length;
    while (buf[idx] === 0x00) {
      ++idx;
      --length;
    }
    let newBuf;
    if (buf[idx] & 0x80) {
      newBuf = Buffer.allocUnsafe(1 + length);
      newBuf[0] = 0;
      buf.copy(newBuf, 1, idx);
      buf = newBuf;
    } else if (length !== buf.length) {
      newBuf = Buffer.allocUnsafe(length);
      buf.copy(newBuf, 0, idx);
      buf = newBuf;
    }
    return buf;
  }
  class KeyExchange {
    constructor(negotiated, protocol, remoteKexinit) {
      this._protocol = protocol;
      this.sessionID = protocol._kex ? protocol._kex.sessionID : undefined;
      this.negotiated = negotiated;
      this._step = 1;
      this._public = null;
      this._dh = null;
      this._sentNEWKEYS = false;
      this._receivedNEWKEYS = false;
      this._finished = false;
      this._hostVerified = false;

      // Data needed for initializing cipher/decipher/etc.
      this._kexinit = protocol._kexinit;
      this._remoteKexinit = remoteKexinit;
      this._identRaw = protocol._identRaw;
      this._remoteIdentRaw = protocol._remoteIdentRaw;
      this._hostKey = undefined;
      this._dhData = undefined;
      this._sig = undefined;
    }
    finish() {
      if (this._finished) return false;
      this._finished = true;
      const isServer = this._protocol._server;
      const negotiated = this.negotiated;
      const pubKey = this.convertPublicKey(this._dhData);
      let secret = this.computeSecret(this._dhData);
      if (secret instanceof Error) {
        secret.message = `Error while computing DH secret (${this.type}): ${secret.message}`;
        secret.level = 'handshake';
        return doFatalError(this._protocol, secret, DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
      }
      const hash = createHash(this.hashName);
      // V_C
      hashString(hash, isServer ? this._remoteIdentRaw : this._identRaw);
      // "V_S"
      hashString(hash, isServer ? this._identRaw : this._remoteIdentRaw);
      // "I_C"
      hashString(hash, isServer ? this._remoteKexinit : this._kexinit);
      // "I_S"
      hashString(hash, isServer ? this._kexinit : this._remoteKexinit);
      // "K_S"
      const serverPublicHostKey = isServer ? this._hostKey.getPublicSSH() : this._hostKey;
      hashString(hash, serverPublicHostKey);
      if (this.type === 'groupex') {
        // Group exchange-specific
        const params = this.getDHParams();
        const num = Buffer.allocUnsafe(4);
        // min (uint32)
        writeUInt32BE(num, this._minBits, 0);
        hash.update(num);
        // preferred (uint32)
        writeUInt32BE(num, this._prefBits, 0);
        hash.update(num);
        // max (uint32)
        writeUInt32BE(num, this._maxBits, 0);
        hash.update(num);
        // prime
        hashString(hash, params.prime);
        // generator
        hashString(hash, params.generator);
      }

      // method-specific data sent by client
      hashString(hash, isServer ? pubKey : this.getPublicKey());
      // method-specific data sent by server
      const serverPublicKey = isServer ? this.getPublicKey() : pubKey;
      hashString(hash, serverPublicKey);
      // shared secret ("K")
      hashString(hash, secret);

      // "H"
      const exchangeHash = hash.digest();
      if (!isServer) {
        bufferParser.init(this._sig, 0);
        const sigType = bufferParser.readString(true);
        if (!sigType) {
          return doFatalError(this._protocol, 'Malformed packet while reading signature', 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
        }
        if (sigType !== negotiated.serverHostKey) {
          return doFatalError(this._protocol, `Wrong signature type: ${sigType}, ` + `expected: ${negotiated.serverHostKey}`, 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
        }

        // "s"
        let sigValue = bufferParser.readString();
        bufferParser.clear();
        if (sigValue === undefined) {
          return doFatalError(this._protocol, 'Malformed packet while reading signature', 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
        }
        if (!(sigValue = sigSSHToASN1(sigValue, sigType))) {
          return doFatalError(this._protocol, 'Malformed signature', 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
        }
        let parsedHostKey;
        {
          bufferParser.init(this._hostKey, 0);
          const name = bufferParser.readString(true);
          const hostKey = this._hostKey.slice(bufferParser.pos());
          bufferParser.clear();
          parsedHostKey = parseDERKey(hostKey, name);
          if (parsedHostKey instanceof Error) {
            parsedHostKey.level = 'handshake';
            return doFatalError(this._protocol, parsedHostKey, DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
          }
        }
        let hashAlgo;
        // Check if we need to override the default hash algorithm
        switch (this.negotiated.serverHostKey) {
          case 'rsa-sha2-256':
            hashAlgo = 'sha256';
            break;
          case 'rsa-sha2-512':
            hashAlgo = 'sha512';
            break;
        }
        this._protocol._debug && this._protocol._debug('Verifying signature ...');
        const verified = parsedHostKey.verify(exchangeHash, sigValue, hashAlgo);
        if (verified !== true) {
          if (verified instanceof Error) {
            this._protocol._debug && this._protocol._debug(`Signature verification failed: ${verified.stack}`);
          } else {
            this._protocol._debug && this._protocol._debug('Signature verification failed');
          }
          return doFatalError(this._protocol, 'Handshake failed: signature verification failed', 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
        }
        this._protocol._debug && this._protocol._debug('Verified signature');
      } else {
        // Server

        let hashAlgo;
        // Check if we need to override the default hash algorithm
        switch (this.negotiated.serverHostKey) {
          case 'rsa-sha2-256':
            hashAlgo = 'sha256';
            break;
          case 'rsa-sha2-512':
            hashAlgo = 'sha512';
            break;
        }
        this._protocol._debug && this._protocol._debug('Generating signature ...');
        let signature = this._hostKey.sign(exchangeHash, hashAlgo);
        if (signature instanceof Error) {
          return doFatalError(this._protocol, 'Handshake failed: signature generation failed for ' + `${this._hostKey.type} host key: ${signature.message}`, 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
        }
        signature = convertSignature(signature, this._hostKey.type);
        if (signature === false) {
          return doFatalError(this._protocol, 'Handshake failed: signature conversion failed for ' + `${this._hostKey.type} host key`, 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
        }

        // Send KEX reply
        /*
          byte      SSH_MSG_KEXDH_REPLY
                      / SSH_MSG_KEX_DH_GEX_REPLY
                      / SSH_MSG_KEX_ECDH_REPLY
          string    server public host key and certificates (K_S)
          string    <method-specific data>
          string    signature of H
        */
        const sigType = this.negotiated.serverHostKey;
        const sigTypeLen = Buffer.byteLength(sigType);
        const sigLen = 4 + sigTypeLen + 4 + signature.length;
        let p = this._protocol._packetRW.write.allocStartKEX;
        const packet = this._protocol._packetRW.write.alloc(1 + 4 + serverPublicHostKey.length + 4 + serverPublicKey.length + 4 + sigLen, true);
        packet[p] = MESSAGE.KEXDH_REPLY;
        writeUInt32BE(packet, serverPublicHostKey.length, ++p);
        packet.set(serverPublicHostKey, p += 4);
        writeUInt32BE(packet, serverPublicKey.length, p += serverPublicHostKey.length);
        packet.set(serverPublicKey, p += 4);
        writeUInt32BE(packet, sigLen, p += serverPublicKey.length);
        writeUInt32BE(packet, sigTypeLen, p += 4);
        packet.utf8Write(sigType, p += 4, sigTypeLen);
        writeUInt32BE(packet, signature.length, p += sigTypeLen);
        packet.set(signature, p += 4);
        if (this._protocol._debug) {
          let type;
          switch (this.type) {
            case 'group':
              type = 'KEXDH_REPLY';
              break;
            case 'groupex':
              type = 'KEXDH_GEX_REPLY';
              break;
            default:
              type = 'KEXECDH_REPLY';
          }
          this._protocol._debug(`Outbound: Sending ${type}`);
        }
        this._protocol._cipher.encrypt(this._protocol._packetRW.write.finalize(packet, true));
      }
      trySendNEWKEYS(this);
      const completeHandshake = () => {
        if (!this.sessionID) this.sessionID = exchangeHash;
        {
          const newSecret = Buffer.allocUnsafe(4 + secret.length);
          writeUInt32BE(newSecret, secret.length, 0);
          newSecret.set(secret, 4);
          secret = newSecret;
        }

        // Initialize new ciphers, deciphers, etc.

        const csCipherInfo = CIPHER_INFO[negotiated.cs.cipher];
        const scCipherInfo = CIPHER_INFO[negotiated.sc.cipher];
        const csIV = generateKEXVal(csCipherInfo.ivLen, this.hashName, secret, exchangeHash, this.sessionID, 'A');
        const scIV = generateKEXVal(scCipherInfo.ivLen, this.hashName, secret, exchangeHash, this.sessionID, 'B');
        const csKey = generateKEXVal(csCipherInfo.keyLen, this.hashName, secret, exchangeHash, this.sessionID, 'C');
        const scKey = generateKEXVal(scCipherInfo.keyLen, this.hashName, secret, exchangeHash, this.sessionID, 'D');
        let csMacInfo;
        let csMacKey;
        if (!csCipherInfo.authLen) {
          csMacInfo = MAC_INFO[negotiated.cs.mac];
          csMacKey = generateKEXVal(csMacInfo.len, this.hashName, secret, exchangeHash, this.sessionID, 'E');
        }
        let scMacInfo;
        let scMacKey;
        if (!scCipherInfo.authLen) {
          scMacInfo = MAC_INFO[negotiated.sc.mac];
          scMacKey = generateKEXVal(scMacInfo.len, this.hashName, secret, exchangeHash, this.sessionID, 'F');
        }
        const config = {
          inbound: {
            onPayload: this._protocol._onPayload,
            seqno: this._protocol._decipher.inSeqno,
            decipherInfo: !isServer ? scCipherInfo : csCipherInfo,
            decipherIV: !isServer ? scIV : csIV,
            decipherKey: !isServer ? scKey : csKey,
            macInfo: !isServer ? scMacInfo : csMacInfo,
            macKey: !isServer ? scMacKey : csMacKey
          },
          outbound: {
            onWrite: this._protocol._onWrite,
            seqno: this._protocol._cipher.outSeqno,
            cipherInfo: isServer ? scCipherInfo : csCipherInfo,
            cipherIV: isServer ? scIV : csIV,
            cipherKey: isServer ? scKey : csKey,
            macInfo: isServer ? scMacInfo : csMacInfo,
            macKey: isServer ? scMacKey : csMacKey
          }
        };
        this._protocol._cipher && this._protocol._cipher.free();
        this._protocol._decipher && this._protocol._decipher.free();
        this._protocol._cipher = createCipher(config);
        this._protocol._decipher = createDecipher(config);
        const rw = {
          read: undefined,
          write: undefined
        };
        switch (negotiated.cs.compress) {
          case 'zlib':
            // starts immediately
            if (isServer) rw.read = new ZlibPacketReader();else rw.write = new ZlibPacketWriter(this._protocol);
            break;
          case 'zlib@openssh.com':
            // Starts after successful user authentication

            if (this._protocol._authenticated) {
              // If a rekey happens and this compression method is selected and
              // we already authenticated successfully, we need to start
              // immediately instead
              if (isServer) rw.read = new ZlibPacketReader();else rw.write = new ZlibPacketWriter(this._protocol);
              break;
            }
          // FALLTHROUGH
          default:
            // none -- never any compression/decompression

            if (isServer) rw.read = new PacketReader();else rw.write = new PacketWriter(this._protocol);
        }
        switch (negotiated.sc.compress) {
          case 'zlib':
            // starts immediately
            if (isServer) rw.write = new ZlibPacketWriter(this._protocol);else rw.read = new ZlibPacketReader();
            break;
          case 'zlib@openssh.com':
            // Starts after successful user authentication

            if (this._protocol._authenticated) {
              // If a rekey happens and this compression method is selected and
              // we already authenticated successfully, we need to start
              // immediately instead
              if (isServer) rw.write = new ZlibPacketWriter(this._protocol);else rw.read = new ZlibPacketReader();
              break;
            }
          // FALLTHROUGH
          default:
            // none -- never any compression/decompression

            if (isServer) rw.write = new PacketWriter(this._protocol);else rw.read = new PacketReader();
        }
        this._protocol._packetRW.read.cleanup();
        this._protocol._packetRW.write.cleanup();
        this._protocol._packetRW = rw;

        // Cleanup/reset various state
        this._public = null;
        this._dh = null;
        this._kexinit = this._protocol._kexinit = undefined;
        this._remoteKexinit = undefined;
        this._identRaw = undefined;
        this._remoteIdentRaw = undefined;
        this._hostKey = undefined;
        this._dhData = undefined;
        this._sig = undefined;
        this._protocol._onHandshakeComplete(negotiated);
        return false;
      };
      if (!isServer) return completeHandshake();
      this.finish = completeHandshake;
    }
    start() {
      if (!this._protocol._server) {
        if (this._protocol._debug) {
          let type;
          switch (this.type) {
            case 'group':
              type = 'KEXDH_INIT';
              break;
            default:
              type = 'KEXECDH_INIT';
          }
          this._protocol._debug(`Outbound: Sending ${type}`);
        }
        const pubKey = this.getPublicKey();
        let p = this._protocol._packetRW.write.allocStartKEX;
        const packet = this._protocol._packetRW.write.alloc(1 + 4 + pubKey.length, true);
        packet[p] = MESSAGE.KEXDH_INIT;
        writeUInt32BE(packet, pubKey.length, ++p);
        packet.set(pubKey, p += 4);
        this._protocol._cipher.encrypt(this._protocol._packetRW.write.finalize(packet, true));
      }
    }
    getPublicKey() {
      this.generateKeys();
      const key = this._public;
      if (key) return this.convertPublicKey(key);
    }
    convertPublicKey(key) {
      let newKey;
      let idx = 0;
      let len = key.length;
      while (key[idx] === 0x00) {
        ++idx;
        --len;
      }
      if (key[idx] & 0x80) {
        newKey = Buffer.allocUnsafe(1 + len);
        newKey[0] = 0;
        key.copy(newKey, 1, idx);
        return newKey;
      }
      if (len !== key.length) {
        newKey = Buffer.allocUnsafe(len);
        key.copy(newKey, 0, idx);
        key = newKey;
      }
      return key;
    }
    computeSecret(otherPublicKey) {
      this.generateKeys();
      try {
        return convertToMpint(this._dh.computeSecret(otherPublicKey));
      } catch (ex) {
        return ex;
      }
    }
    parse(payload) {
      const type = payload[0];
      switch (this._step) {
        case 1:
          if (this._protocol._server) {
            // Server
            if (type !== MESSAGE.KEXDH_INIT) {
              return doFatalError(this._protocol, `Received packet ${type} instead of ${MESSAGE.KEXDH_INIT}`, 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
            }
            this._protocol._debug && this._protocol._debug('Received DH Init');
            /*
              byte     SSH_MSG_KEXDH_INIT
                         / SSH_MSG_KEX_ECDH_INIT
              string   <method-specific data>
            */
            bufferParser.init(payload, 1);
            const dhData = bufferParser.readString();
            bufferParser.clear();
            if (dhData === undefined) {
              return doFatalError(this._protocol, 'Received malformed KEX*_INIT', 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
            }

            // Client public key
            this._dhData = dhData;
            let hostKey = this._protocol._hostKeys[this.negotiated.serverHostKey];
            if (Array.isArray(hostKey)) hostKey = hostKey[0];
            this._hostKey = hostKey;
            this.finish();
          } else {
            // Client
            if (type !== MESSAGE.KEXDH_REPLY) {
              return doFatalError(this._protocol, `Received packet ${type} instead of ${MESSAGE.KEXDH_REPLY}`, 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
            }
            this._protocol._debug && this._protocol._debug('Received DH Reply');
            /*
              byte      SSH_MSG_KEXDH_REPLY
                          / SSH_MSG_KEX_DH_GEX_REPLY
                          / SSH_MSG_KEX_ECDH_REPLY
              string    server public host key and certificates (K_S)
              string    <method-specific data>
              string    signature of H
            */
            bufferParser.init(payload, 1);
            let hostPubKey;
            let dhData;
            let sig;
            if ((hostPubKey = bufferParser.readString()) === undefined || (dhData = bufferParser.readString()) === undefined || (sig = bufferParser.readString()) === undefined) {
              bufferParser.clear();
              return doFatalError(this._protocol, 'Received malformed KEX*_REPLY', 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
            }
            bufferParser.clear();

            // Check that the host public key type matches what was negotiated
            // during KEXINIT swap
            bufferParser.init(hostPubKey, 0);
            const hostPubKeyType = bufferParser.readString(true);
            bufferParser.clear();
            if (hostPubKeyType === undefined) {
              return doFatalError(this._protocol, 'Received malformed host public key', 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
            }
            if (hostPubKeyType !== this.negotiated.serverHostKey) {
              // Check if we need to make an exception
              switch (this.negotiated.serverHostKey) {
                case 'rsa-sha2-256':
                case 'rsa-sha2-512':
                  if (hostPubKeyType === 'ssh-rsa') break;
                // FALLTHROUGH
                default:
                  return doFatalError(this._protocol, 'Host key does not match negotiated type', 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
              }
            }
            this._hostKey = hostPubKey;
            this._dhData = dhData;
            this._sig = sig;
            let checked = false;
            let ret;
            if (this._protocol._hostVerifier === undefined) {
              ret = true;
              this._protocol._debug && this._protocol._debug('Host accepted by default (no verification)');
            } else {
              ret = this._protocol._hostVerifier(hostPubKey, permitted => {
                if (checked) return;
                checked = true;
                if (permitted === false) {
                  this._protocol._debug && this._protocol._debug('Host denied (verification failed)');
                  return doFatalError(this._protocol, 'Host denied (verification failed)', 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
                }
                this._protocol._debug && this._protocol._debug('Host accepted (verified)');
                this._hostVerified = true;
                if (this._receivedNEWKEYS) this.finish();else trySendNEWKEYS(this);
              });
            }
            if (ret === undefined) {
              // Async host verification
              ++this._step;
              return;
            }
            checked = true;
            if (ret === false) {
              this._protocol._debug && this._protocol._debug('Host denied (verification failed)');
              return doFatalError(this._protocol, 'Host denied (verification failed)', 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
            }
            this._protocol._debug && this._protocol._debug('Host accepted (verified)');
            this._hostVerified = true;
            trySendNEWKEYS(this);
          }
          ++this._step;
          break;
        case 2:
          if (type !== MESSAGE.NEWKEYS) {
            return doFatalError(this._protocol, `Received packet ${type} instead of ${MESSAGE.NEWKEYS}`, 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
          }
          this._protocol._debug && this._protocol._debug('Inbound: NEWKEYS');
          this._receivedNEWKEYS = true;
          ++this._step;
          if (this._protocol._server || this._hostVerified) return this.finish();

          // Signal to current decipher that we need to change to a new decipher
          // for the next packet
          return false;
        default:
          return doFatalError(this._protocol, `Received unexpected packet ${type} after NEWKEYS`, 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
      }
    }
  }
  class Curve25519Exchange extends KeyExchange {
    constructor(hashName, ...args) {
      super(...args);
      this.type = '25519';
      this.hashName = hashName;
      this._keys = null;
    }
    generateKeys() {
      if (!this._keys) this._keys = generateKeyPairSync('x25519');
    }
    getPublicKey() {
      this.generateKeys();
      const key = this._keys.publicKey.export({
        type: 'spki',
        format: 'der'
      });
      return key.slice(-32); // HACK: avoids parsing DER/BER header
    }

    convertPublicKey(key) {
      let newKey;
      let idx = 0;
      let len = key.length;
      while (key[idx] === 0x00) {
        ++idx;
        --len;
      }
      if (key.length === 32) return key;
      if (len !== key.length) {
        newKey = Buffer.allocUnsafe(len);
        key.copy(newKey, 0, idx);
        key = newKey;
      }
      return key;
    }
    computeSecret(otherPublicKey) {
      this.generateKeys();
      try {
        const asnWriter = new Ber.Writer();
        asnWriter.startSequence();
        // algorithm
        asnWriter.startSequence();
        asnWriter.writeOID('1.3.101.110'); // id-X25519
        asnWriter.endSequence();

        // PublicKey
        asnWriter.startSequence(Ber.BitString);
        asnWriter.writeByte(0x00);
        // XXX: hack to write a raw buffer without a tag -- yuck
        asnWriter._ensure(otherPublicKey.length);
        otherPublicKey.copy(asnWriter._buf, asnWriter._offset, 0, otherPublicKey.length);
        asnWriter._offset += otherPublicKey.length;
        asnWriter.endSequence();
        asnWriter.endSequence();
        return convertToMpint(diffieHellman({
          privateKey: this._keys.privateKey,
          publicKey: createPublicKey({
            key: asnWriter.buffer,
            type: 'spki',
            format: 'der'
          })
        }));
      } catch (ex) {
        return ex;
      }
    }
  }
  class ECDHExchange extends KeyExchange {
    constructor(curveName, hashName, ...args) {
      super(...args);
      this.type = 'ecdh';
      this.curveName = curveName;
      this.hashName = hashName;
    }
    generateKeys() {
      if (!this._dh) {
        this._dh = createECDH(this.curveName);
        this._public = this._dh.generateKeys();
      }
    }
  }
  class DHGroupExchange extends KeyExchange {
    constructor(hashName, ...args) {
      super(...args);
      this.type = 'groupex';
      this.hashName = hashName;
      this._prime = null;
      this._generator = null;
      this._minBits = GEX_MIN_BITS;
      this._prefBits = dhEstimate(this.negotiated);
      if (this._protocol._compatFlags & COMPAT.BUG_DHGEX_LARGE) this._prefBits = Math.min(this._prefBits, 4096);
      this._maxBits = GEX_MAX_BITS;
    }
    start() {
      if (this._protocol._server) return;
      this._protocol._debug && this._protocol._debug('Outbound: Sending KEXDH_GEX_REQUEST');
      let p = this._protocol._packetRW.write.allocStartKEX;
      const packet = this._protocol._packetRW.write.alloc(1 + 4 + 4 + 4, true);
      packet[p] = MESSAGE.KEXDH_GEX_REQUEST;
      writeUInt32BE(packet, this._minBits, ++p);
      writeUInt32BE(packet, this._prefBits, p += 4);
      writeUInt32BE(packet, this._maxBits, p += 4);
      this._protocol._cipher.encrypt(this._protocol._packetRW.write.finalize(packet, true));
    }
    generateKeys() {
      if (!this._dh && this._prime && this._generator) {
        this._dh = createDiffieHellman(this._prime, this._generator);
        this._public = this._dh.generateKeys();
      }
    }
    setDHParams(prime, generator) {
      if (!Buffer.isBuffer(prime)) throw new Error('Invalid prime value');
      if (!Buffer.isBuffer(generator)) throw new Error('Invalid generator value');
      this._prime = prime;
      this._generator = generator;
    }
    getDHParams() {
      if (this._dh) {
        return {
          prime: convertToMpint(this._dh.getPrime()),
          generator: convertToMpint(this._dh.getGenerator())
        };
      }
    }
    parse(payload) {
      const type = payload[0];
      switch (this._step) {
        case 1:
          if (this._protocol._server) {
            if (type !== MESSAGE.KEXDH_GEX_REQUEST) {
              return doFatalError(this._protocol, `Received packet ${type} instead of ` + MESSAGE.KEXDH_GEX_REQUEST, 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
            }
            // TODO: allow user implementation to provide safe prime and
            // generator on demand to support group exchange on server side
            return doFatalError(this._protocol, 'Group exchange not implemented for server', 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
          }
          if (type !== MESSAGE.KEXDH_GEX_GROUP) {
            return doFatalError(this._protocol, `Received packet ${type} instead of ${MESSAGE.KEXDH_GEX_GROUP}`, 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
          }
          this._protocol._debug && this._protocol._debug('Received DH GEX Group');

          /*
            byte    SSH_MSG_KEX_DH_GEX_GROUP
            mpint   p, safe prime
            mpint   g, generator for subgroup in GF(p)
          */
          bufferParser.init(payload, 1);
          let prime;
          let gen;
          if ((prime = bufferParser.readString()) === undefined || (gen = bufferParser.readString()) === undefined) {
            bufferParser.clear();
            return doFatalError(this._protocol, 'Received malformed KEXDH_GEX_GROUP', 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
          }
          bufferParser.clear();

          // TODO: validate prime
          this.setDHParams(prime, gen);
          this.generateKeys();
          const pubkey = this.getPublicKey();
          this._protocol._debug && this._protocol._debug('Outbound: Sending KEXDH_GEX_INIT');
          let p = this._protocol._packetRW.write.allocStartKEX;
          const packet = this._protocol._packetRW.write.alloc(1 + 4 + pubkey.length, true);
          packet[p] = MESSAGE.KEXDH_GEX_INIT;
          writeUInt32BE(packet, pubkey.length, ++p);
          packet.set(pubkey, p += 4);
          this._protocol._cipher.encrypt(this._protocol._packetRW.write.finalize(packet, true));
          ++this._step;
          break;
        case 2:
          if (this._protocol._server) {
            if (type !== MESSAGE.KEXDH_GEX_INIT) {
              return doFatalError(this._protocol, `Received packet ${type} instead of ${MESSAGE.KEXDH_GEX_INIT}`, 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
            }
            this._protocol._debug && this._protocol._debug('Received DH GEX Init');
            return doFatalError(this._protocol, 'Group exchange not implemented for server', 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
          } else if (type !== MESSAGE.KEXDH_GEX_REPLY) {
            return doFatalError(this._protocol, `Received packet ${type} instead of ${MESSAGE.KEXDH_GEX_REPLY}`, 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
          }
          this._protocol._debug && this._protocol._debug('Received DH GEX Reply');
          this._step = 1;
          payload[0] = MESSAGE.KEXDH_REPLY;
          this.parse = KeyExchange.prototype.parse;
          this.parse(payload);
      }
    }
  }
  class DHExchange extends KeyExchange {
    constructor(groupName, hashName, ...args) {
      super(...args);
      this.type = 'group';
      this.groupName = groupName;
      this.hashName = hashName;
    }
    start() {
      if (!this._protocol._server) {
        this._protocol._debug && this._protocol._debug('Outbound: Sending KEXDH_INIT');
        const pubKey = this.getPublicKey();
        let p = this._protocol._packetRW.write.allocStartKEX;
        const packet = this._protocol._packetRW.write.alloc(1 + 4 + pubKey.length, true);
        packet[p] = MESSAGE.KEXDH_INIT;
        writeUInt32BE(packet, pubKey.length, ++p);
        packet.set(pubKey, p += 4);
        this._protocol._cipher.encrypt(this._protocol._packetRW.write.finalize(packet, true));
      }
    }
    generateKeys() {
      if (!this._dh) {
        this._dh = createDiffieHellmanGroup(this.groupName);
        this._public = this._dh.generateKeys();
      }
    }
    getDHParams() {
      if (this._dh) {
        return {
          prime: convertToMpint(this._dh.getPrime()),
          generator: convertToMpint(this._dh.getGenerator())
        };
      }
    }
  }
  return (negotiated, ...args) => {
    if (typeof negotiated !== 'object' || negotiated === null) throw new Error('Invalid negotiated argument');
    const kexType = negotiated.kex;
    if (typeof kexType === 'string') {
      args = [negotiated, ...args];
      switch (kexType) {
        case 'curve25519-sha256':
        case 'curve25519-sha256@libssh.org':
          if (!curve25519Supported) break;
          return new Curve25519Exchange('sha256', ...args);
        case 'ecdh-sha2-nistp256':
          return new ECDHExchange('prime256v1', 'sha256', ...args);
        case 'ecdh-sha2-nistp384':
          return new ECDHExchange('secp384r1', 'sha384', ...args);
        case 'ecdh-sha2-nistp521':
          return new ECDHExchange('secp521r1', 'sha512', ...args);
        case 'diffie-hellman-group1-sha1':
          return new DHExchange('modp2', 'sha1', ...args);
        case 'diffie-hellman-group14-sha1':
          return new DHExchange('modp14', 'sha1', ...args);
        case 'diffie-hellman-group14-sha256':
          return new DHExchange('modp14', 'sha256', ...args);
        case 'diffie-hellman-group15-sha512':
          return new DHExchange('modp15', 'sha512', ...args);
        case 'diffie-hellman-group16-sha512':
          return new DHExchange('modp16', 'sha512', ...args);
        case 'diffie-hellman-group17-sha512':
          return new DHExchange('modp17', 'sha512', ...args);
        case 'diffie-hellman-group18-sha512':
          return new DHExchange('modp18', 'sha512', ...args);
        case 'diffie-hellman-group-exchange-sha1':
          return new DHGroupExchange('sha1', ...args);
        case 'diffie-hellman-group-exchange-sha256':
          return new DHGroupExchange('sha256', ...args);
      }
      throw new Error(`Unsupported key exchange algorithm: ${kexType}`);
    }
    throw new Error(`Invalid key exchange type: ${kexType}`);
  };
})();
const KexInit = (() => {
  const KEX_PROPERTY_NAMES = ['kex', 'serverHostKey', ['cs', 'cipher'], ['sc', 'cipher'], ['cs', 'mac'], ['sc', 'mac'], ['cs', 'compress'], ['sc', 'compress'], ['cs', 'lang'], ['sc', 'lang']];
  return class KexInit {
    constructor(obj) {
      if (typeof obj !== 'object' || obj === null) throw new TypeError('Argument must be an object');
      const lists = {
        kex: undefined,
        serverHostKey: undefined,
        cs: {
          cipher: undefined,
          mac: undefined,
          compress: undefined,
          lang: undefined
        },
        sc: {
          cipher: undefined,
          mac: undefined,
          compress: undefined,
          lang: undefined
        },
        all: undefined
      };
      let totalSize = 0;
      for (const prop of KEX_PROPERTY_NAMES) {
        let base;
        let val;
        let desc;
        let key;
        if (typeof prop === 'string') {
          base = lists;
          val = obj[prop];
          desc = key = prop;
        } else {
          const parent = prop[0];
          base = lists[parent];
          key = prop[1];
          val = obj[parent][key];
          desc = `${parent}.${key}`;
        }
        const entry = {
          array: undefined,
          buffer: undefined
        };
        if (Buffer.isBuffer(val)) {
          entry.array = ('' + val).split(',');
          entry.buffer = val;
          totalSize += 4 + val.length;
        } else {
          if (typeof val === 'string') val = val.split(',');
          if (Array.isArray(val)) {
            entry.array = val;
            entry.buffer = Buffer.from(val.join(','));
          } else {
            throw new TypeError(`Invalid \`${desc}\` type: ${typeof val}`);
          }
          totalSize += 4 + entry.buffer.length;
        }
        base[key] = entry;
      }
      const all = Buffer.allocUnsafe(totalSize);
      lists.all = all;
      let allPos = 0;
      for (const prop of KEX_PROPERTY_NAMES) {
        let data;
        if (typeof prop === 'string') data = lists[prop].buffer;else data = lists[prop[0]][prop[1]].buffer;
        allPos = writeUInt32BE(all, data.length, allPos);
        all.set(data, allPos);
        allPos += data.length;
      }
      this.totalSize = totalSize;
      this.lists = lists;
    }
    copyAllTo(buf, offset) {
      const src = this.lists.all;
      if (typeof offset !== 'number') throw new TypeError(`Invalid offset value: ${typeof offset}`);
      if (buf.length - offset < src.length) throw new Error('Insufficient space to copy list');
      buf.set(src, offset);
      return src.length;
    }
  };
})();
const hashString = (() => {
  const LEN = Buffer.allocUnsafe(4);
  return (hash, buf) => {
    writeUInt32BE(LEN, buf.length, 0);
    hash.update(LEN);
    hash.update(buf);
  };
})();
function generateKEXVal(len, hashName, secret, exchangeHash, sessionID, char) {
  let ret;
  if (len) {
    let digest = createHash(hashName).update(secret).update(exchangeHash).update(char).update(sessionID).digest();
    while (digest.length < len) {
      const chunk = createHash(hashName).update(secret).update(exchangeHash).update(digest).digest();
      const extended = Buffer.allocUnsafe(digest.length + chunk.length);
      extended.set(digest, 0);
      extended.set(chunk, digest.length);
      digest = extended;
    }
    if (digest.length === len) ret = digest;else ret = new FastBuffer(digest.buffer, digest.byteOffset, len);
  } else {
    ret = EMPTY_BUFFER;
  }
  return ret;
}
function onKEXPayload(state, payload) {
  // XXX: move this to the Decipher implementations?
  if (payload.length === 0) {
    this._debug && this._debug('Inbound: Skipping empty packet payload');
    return;
  }
  if (this._skipNextInboundPacket) {
    this._skipNextInboundPacket = false;
    return;
  }
  payload = this._packetRW.read.read(payload);
  const type = payload[0];
  switch (type) {
    case MESSAGE.DISCONNECT:
    case MESSAGE.IGNORE:
    case MESSAGE.UNIMPLEMENTED:
    case MESSAGE.DEBUG:
      if (!MESSAGE_HANDLERS) MESSAGE_HANDLERS = __webpack_require__(/*! ./handlers.js */ 9775);
      return MESSAGE_HANDLERS[type](this, payload);
    case MESSAGE.KEXINIT:
      if (!state.firstPacket) {
        return doFatalError(this, 'Received extra KEXINIT during handshake', 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
      }
      state.firstPacket = false;
      return handleKexInit(this, payload);
    default:
      if (type < 20 || type > 49) {
        return doFatalError(this, `Received unexpected packet type ${type}`, 'handshake', DISCONNECT_REASON.KEY_EXCHANGE_FAILED);
      }
  }
  return this._kex.parse(payload);
}
function dhEstimate(neg) {
  const csCipher = CIPHER_INFO[neg.cs.cipher];
  const scCipher = CIPHER_INFO[neg.sc.cipher];
  // XXX: if OpenSSH's `umac-*` MACs are ever supported, their key lengths will
  // also need to be considered when calculating `bits`
  const bits = Math.max(0, csCipher.sslName === 'des-ede3-cbc' ? 14 : csCipher.keyLen, csCipher.blockLen, csCipher.ivLen, scCipher.sslName === 'des-ede3-cbc' ? 14 : scCipher.keyLen, scCipher.blockLen, scCipher.ivLen) * 8;
  if (bits <= 112) return 2048;
  if (bits <= 128) return 3072;
  if (bits <= 192) return 7680;
  return 8192;
}
function trySendNEWKEYS(kex) {
  if (!kex._sentNEWKEYS) {
    kex._protocol._debug && kex._protocol._debug('Outbound: Sending NEWKEYS');
    const p = kex._protocol._packetRW.write.allocStartKEX;
    const packet = kex._protocol._packetRW.write.alloc(1, true);
    packet[p] = MESSAGE.NEWKEYS;
    kex._protocol._cipher.encrypt(kex._protocol._packetRW.write.finalize(packet, true));
    kex._sentNEWKEYS = true;
  }
}
module.exports = {
  KexInit,
  kexinit,
  onKEXPayload,
  DEFAULT_KEXINIT: new KexInit({
    kex: DEFAULT_KEX,
    serverHostKey: DEFAULT_SERVER_HOST_KEY,
    cs: {
      cipher: DEFAULT_CIPHER,
      mac: DEFAULT_MAC,
      compress: DEFAULT_COMPRESSION,
      lang: []
    },
    sc: {
      cipher: DEFAULT_CIPHER,
      mac: DEFAULT_MAC,
      compress: DEFAULT_COMPRESSION,
      lang: []
    }
  }),
  HANDLERS: {
    [MESSAGE.KEXINIT]: handleKexInit
  }
};

/***/ }),

/***/ 9934:
/*!******************************************************!*\
  !*** ../node_modules/ssh2/lib/protocol/keyParser.js ***!
  \******************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";
// TODO:
//    * utilize `crypto.create(Private|Public)Key()` and `keyObject.export()`
//    * handle multi-line header values (OpenSSH)?
//    * more thorough validation?


const {
  createDecipheriv,
  createECDH,
  createHash,
  createHmac,
  createSign,
  createVerify,
  getCiphers,
  sign: sign_,
  verify: verify_
} = __webpack_require__(/*! crypto */ 6113);
const {
  createVerify: createVerifyDSS
} = __webpack_require__(/*! browserify-sign */ 6052);
const supportedOpenSSLCiphers = getCiphers();
const {
  Ber
} = __webpack_require__(/*! asn1 */ 5593);
const bcrypt_pbkdf = (__webpack_require__(/*! bcrypt-pbkdf */ 5116).pbkdf);
const {
  CIPHER_INFO
} = __webpack_require__(/*! ./crypto.js */ 6173);
const {
  eddsaSupported,
  SUPPORTED_CIPHER
} = __webpack_require__(/*! ./constants.js */ 7816);
const {
  bufferSlice,
  makeBufferParser,
  readString,
  readUInt32BE,
  writeUInt32BE
} = __webpack_require__(/*! ./utils.js */ 3549);
const SYM_HASH_ALGO = Symbol('Hash Algorithm');
const SYM_PRIV_PEM = Symbol('Private key PEM');
const SYM_PUB_PEM = Symbol('Public key PEM');
const SYM_PUB_SSH = Symbol('Public key SSH');
const SYM_DECRYPTED = Symbol('Decrypted Key');

// Create OpenSSL cipher name -> SSH cipher name conversion table
const CIPHER_INFO_OPENSSL = Object.create(null);
{
  const keys = Object.keys(CIPHER_INFO);
  for (let i = 0; i < keys.length; ++i) {
    const cipherName = CIPHER_INFO[keys[i]].sslName;
    if (!cipherName || CIPHER_INFO_OPENSSL[cipherName]) continue;
    CIPHER_INFO_OPENSSL[cipherName] = CIPHER_INFO[keys[i]];
  }
}
const binaryKeyParser = makeBufferParser();
function makePEM(type, data) {
  data = data.base64Slice(0, data.length);
  let formatted = data.replace(/.{64}/g, '$&\n');
  if (data.length & 63) formatted += '\n';
  return `-----BEGIN ${type} KEY-----\n${formatted}-----END ${type} KEY-----`;
}
function combineBuffers(buf1, buf2) {
  const result = Buffer.allocUnsafe(buf1.length + buf2.length);
  result.set(buf1, 0);
  result.set(buf2, buf1.length);
  return result;
}
function skipFields(buf, nfields) {
  const bufLen = buf.length;
  let pos = buf._pos || 0;
  for (let i = 0; i < nfields; ++i) {
    const left = bufLen - pos;
    if (pos >= bufLen || left < 4) return false;
    const len = readUInt32BE(buf, pos);
    if (left < 4 + len) return false;
    pos += 4 + len;
  }
  buf._pos = pos;
  return true;
}
function genOpenSSLRSAPub(n, e) {
  const asnWriter = new Ber.Writer();
  asnWriter.startSequence();
  // algorithm
  asnWriter.startSequence();
  asnWriter.writeOID('1.2.840.113549.1.1.1'); // rsaEncryption
  // algorithm parameters (RSA has none)
  asnWriter.writeNull();
  asnWriter.endSequence();

  // subjectPublicKey
  asnWriter.startSequence(Ber.BitString);
  asnWriter.writeByte(0x00);
  asnWriter.startSequence();
  asnWriter.writeBuffer(n, Ber.Integer);
  asnWriter.writeBuffer(e, Ber.Integer);
  asnWriter.endSequence();
  asnWriter.endSequence();
  asnWriter.endSequence();
  return makePEM('PUBLIC', asnWriter.buffer);
}
function genOpenSSHRSAPub(n, e) {
  const publicKey = Buffer.allocUnsafe(4 + 7 + 4 + e.length + 4 + n.length);
  writeUInt32BE(publicKey, 7, 0);
  publicKey.utf8Write('ssh-rsa', 4, 7);
  let i = 4 + 7;
  writeUInt32BE(publicKey, e.length, i);
  publicKey.set(e, i += 4);
  writeUInt32BE(publicKey, n.length, i += e.length);
  publicKey.set(n, i + 4);
  return publicKey;
}
const genOpenSSLRSAPriv = (() => {
  function genRSAASN1Buf(n, e, d, p, q, dmp1, dmq1, iqmp) {
    const asnWriter = new Ber.Writer();
    asnWriter.startSequence();
    asnWriter.writeInt(0x00, Ber.Integer);
    asnWriter.writeBuffer(n, Ber.Integer);
    asnWriter.writeBuffer(e, Ber.Integer);
    asnWriter.writeBuffer(d, Ber.Integer);
    asnWriter.writeBuffer(p, Ber.Integer);
    asnWriter.writeBuffer(q, Ber.Integer);
    asnWriter.writeBuffer(dmp1, Ber.Integer);
    asnWriter.writeBuffer(dmq1, Ber.Integer);
    asnWriter.writeBuffer(iqmp, Ber.Integer);
    asnWriter.endSequence();
    return asnWriter.buffer;
  }
  function bigIntFromBuffer(buf) {
    return BigInt(`0x${buf.hexSlice(0, buf.length)}`);
  }
  function bigIntToBuffer(bn) {
    let hex = bn.toString(16);
    if ((hex.length & 1) !== 0) {
      hex = `0${hex}`;
    } else {
      const sigbit = hex.charCodeAt(0);
      // BER/DER integers require leading zero byte to denote a positive value
      // when first byte >= 0x80
      if (sigbit === 56 /* '8' */ || sigbit === 57 /* '9' */ || sigbit >= 97 /* 'a' */ && sigbit <= 102 /* 'f' */) {
        hex = `00${hex}`;
      }
    }
    return Buffer.from(hex, 'hex');
  }
  return function genOpenSSLRSAPriv(n, e, d, iqmp, p, q) {
    const bn_d = bigIntFromBuffer(d);
    const dmp1 = bigIntToBuffer(bn_d % (bigIntFromBuffer(p) - 1n));
    const dmq1 = bigIntToBuffer(bn_d % (bigIntFromBuffer(q) - 1n));
    return makePEM('RSA PRIVATE', genRSAASN1Buf(n, e, d, p, q, dmp1, dmq1, iqmp));
  };
})();
function genOpenSSLDSAPub(p, q, g, y) {
  const asnWriter = new Ber.Writer();
  asnWriter.startSequence();
  // algorithm
  asnWriter.startSequence();
  asnWriter.writeOID('1.2.840.10040.4.1'); // id-dsa
  // algorithm parameters
  asnWriter.startSequence();
  asnWriter.writeBuffer(p, Ber.Integer);
  asnWriter.writeBuffer(q, Ber.Integer);
  asnWriter.writeBuffer(g, Ber.Integer);
  asnWriter.endSequence();
  asnWriter.endSequence();

  // subjectPublicKey
  asnWriter.startSequence(Ber.BitString);
  asnWriter.writeByte(0x00);
  asnWriter.writeBuffer(y, Ber.Integer);
  asnWriter.endSequence();
  asnWriter.endSequence();
  return makePEM('PUBLIC', asnWriter.buffer);
}
function genOpenSSHDSAPub(p, q, g, y) {
  const publicKey = Buffer.allocUnsafe(4 + 7 + 4 + p.length + 4 + q.length + 4 + g.length + 4 + y.length);
  writeUInt32BE(publicKey, 7, 0);
  publicKey.utf8Write('ssh-dss', 4, 7);
  let i = 4 + 7;
  writeUInt32BE(publicKey, p.length, i);
  publicKey.set(p, i += 4);
  writeUInt32BE(publicKey, q.length, i += p.length);
  publicKey.set(q, i += 4);
  writeUInt32BE(publicKey, g.length, i += q.length);
  publicKey.set(g, i += 4);
  writeUInt32BE(publicKey, y.length, i += g.length);
  publicKey.set(y, i + 4);
  return publicKey;
}
function genOpenSSLDSAPriv(p, q, g, y, x) {
  const asnWriter = new Ber.Writer();
  asnWriter.startSequence();
  asnWriter.writeInt(0x00, Ber.Integer);
  asnWriter.writeBuffer(p, Ber.Integer);
  asnWriter.writeBuffer(q, Ber.Integer);
  asnWriter.writeBuffer(g, Ber.Integer);
  asnWriter.writeBuffer(y, Ber.Integer);
  asnWriter.writeBuffer(x, Ber.Integer);
  asnWriter.endSequence();
  return makePEM('DSA PRIVATE', asnWriter.buffer);
}
function genOpenSSLEdPub(pub) {
  const asnWriter = new Ber.Writer();
  asnWriter.startSequence();
  // algorithm
  asnWriter.startSequence();
  asnWriter.writeOID('1.3.101.112'); // id-Ed25519
  asnWriter.endSequence();

  // PublicKey
  asnWriter.startSequence(Ber.BitString);
  asnWriter.writeByte(0x00);
  // XXX: hack to write a raw buffer without a tag -- yuck
  asnWriter._ensure(pub.length);
  asnWriter._buf.set(pub, asnWriter._offset);
  asnWriter._offset += pub.length;
  asnWriter.endSequence();
  asnWriter.endSequence();
  return makePEM('PUBLIC', asnWriter.buffer);
}
function genOpenSSHEdPub(pub) {
  const publicKey = Buffer.allocUnsafe(4 + 11 + 4 + pub.length);
  writeUInt32BE(publicKey, 11, 0);
  publicKey.utf8Write('ssh-ed25519', 4, 11);
  writeUInt32BE(publicKey, pub.length, 15);
  publicKey.set(pub, 19);
  return publicKey;
}
function genOpenSSLEdPriv(priv) {
  const asnWriter = new Ber.Writer();
  asnWriter.startSequence();
  // version
  asnWriter.writeInt(0x00, Ber.Integer);

  // algorithm
  asnWriter.startSequence();
  asnWriter.writeOID('1.3.101.112'); // id-Ed25519
  asnWriter.endSequence();

  // PrivateKey
  asnWriter.startSequence(Ber.OctetString);
  asnWriter.writeBuffer(priv, Ber.OctetString);
  asnWriter.endSequence();
  asnWriter.endSequence();
  return makePEM('PRIVATE', asnWriter.buffer);
}
function genOpenSSLECDSAPub(oid, Q) {
  const asnWriter = new Ber.Writer();
  asnWriter.startSequence();
  // algorithm
  asnWriter.startSequence();
  asnWriter.writeOID('1.2.840.10045.2.1'); // id-ecPublicKey
  // algorithm parameters (namedCurve)
  asnWriter.writeOID(oid);
  asnWriter.endSequence();

  // subjectPublicKey
  asnWriter.startSequence(Ber.BitString);
  asnWriter.writeByte(0x00);
  // XXX: hack to write a raw buffer without a tag -- yuck
  asnWriter._ensure(Q.length);
  asnWriter._buf.set(Q, asnWriter._offset);
  asnWriter._offset += Q.length;
  // end hack
  asnWriter.endSequence();
  asnWriter.endSequence();
  return makePEM('PUBLIC', asnWriter.buffer);
}
function genOpenSSHECDSAPub(oid, Q) {
  let curveName;
  switch (oid) {
    case '1.2.840.10045.3.1.7':
      // prime256v1/secp256r1
      curveName = 'nistp256';
      break;
    case '1.3.132.0.34':
      // secp384r1
      curveName = 'nistp384';
      break;
    case '1.3.132.0.35':
      // secp521r1
      curveName = 'nistp521';
      break;
    default:
      return;
  }
  const publicKey = Buffer.allocUnsafe(4 + 19 + 4 + 8 + 4 + Q.length);
  writeUInt32BE(publicKey, 19, 0);
  publicKey.utf8Write(`ecdsa-sha2-${curveName}`, 4, 19);
  writeUInt32BE(publicKey, 8, 23);
  publicKey.utf8Write(curveName, 27, 8);
  writeUInt32BE(publicKey, Q.length, 35);
  publicKey.set(Q, 39);
  return publicKey;
}
function genOpenSSLECDSAPriv(oid, pub, priv) {
  const asnWriter = new Ber.Writer();
  asnWriter.startSequence();
  // version
  asnWriter.writeInt(0x01, Ber.Integer);
  // privateKey
  asnWriter.writeBuffer(priv, Ber.OctetString);
  // parameters (optional)
  asnWriter.startSequence(0xA0);
  asnWriter.writeOID(oid);
  asnWriter.endSequence();
  // publicKey (optional)
  asnWriter.startSequence(0xA1);
  asnWriter.startSequence(Ber.BitString);
  asnWriter.writeByte(0x00);
  // XXX: hack to write a raw buffer without a tag -- yuck
  asnWriter._ensure(pub.length);
  asnWriter._buf.set(pub, asnWriter._offset);
  asnWriter._offset += pub.length;
  // end hack
  asnWriter.endSequence();
  asnWriter.endSequence();
  asnWriter.endSequence();
  return makePEM('EC PRIVATE', asnWriter.buffer);
}
function genOpenSSLECDSAPubFromPriv(curveName, priv) {
  const tempECDH = createECDH(curveName);
  tempECDH.setPrivateKey(priv);
  return tempECDH.getPublicKey();
}
const BaseKey = {
  sign: (() => {
    if (typeof sign_ === 'function') {
      return function sign(data, algo) {
        const pem = this[SYM_PRIV_PEM];
        if (pem === null) return new Error('No private key available');
        if (!algo || typeof algo !== 'string') algo = this[SYM_HASH_ALGO];
        try {
          return sign_(algo, data, pem);
        } catch (ex) {
          return ex;
        }
      };
    }
    return function sign(data, algo) {
      const pem = this[SYM_PRIV_PEM];
      if (pem === null) return new Error('No private key available');
      if (!algo || typeof algo !== 'string') algo = this[SYM_HASH_ALGO];
      const signature = createSign(algo);
      signature.update(data);
      try {
        return signature.sign(pem);
      } catch (ex) {
        return ex;
      }
    };
  })(),
  verify: (() => {
    if (typeof verify_ === 'function') {
      return function verify(data, signature, algo) {
        const pem = this[SYM_PUB_PEM];
        if (pem === null) return new Error('No public key available');
        if (!algo || typeof algo !== 'string') algo = this[SYM_HASH_ALGO];
        if (algo === 'dss1') {
          const verifier = createVerifyDSS('DSA-SHA1');
          verifier.update(data);
          try {
            return verifier.verify(pem, signature);
          } catch (ex) {
            return ex;
          }
        }
        try {
          return verify_(algo, data, pem, signature);
        } catch (ex) {
          return ex;
        }
      };
    }
    return function verify(data, signature, algo) {
      const pem = this[SYM_PUB_PEM];
      if (pem === null) return new Error('No public key available');
      if (!algo || typeof algo !== 'string') algo = this[SYM_HASH_ALGO];
      const verifier = createVerify(algo);
      verifier.update(data);
      try {
        return verifier.verify(pem, signature);
      } catch (ex) {
        return ex;
      }
    };
  })(),
  isPrivateKey: function isPrivateKey() {
    return this[SYM_PRIV_PEM] !== null;
  },
  getPrivatePEM: function getPrivatePEM() {
    return this[SYM_PRIV_PEM];
  },
  getPublicPEM: function getPublicPEM() {
    return this[SYM_PUB_PEM];
  },
  getPublicSSH: function getPublicSSH() {
    return this[SYM_PUB_SSH];
  },
  equals: function equals(key) {
    const parsed = parseKey(key);
    if (parsed instanceof Error) return false;
    return this.type === parsed.type && this[SYM_PRIV_PEM] === parsed[SYM_PRIV_PEM] && this[SYM_PUB_PEM] === parsed[SYM_PUB_PEM] && this[SYM_PUB_SSH] === parsed[SYM_PUB_SSH];
  }
};
function OpenSSH_Private(type, comment, privPEM, pubPEM, pubSSH, algo, decrypted) {
  this.type = type;
  this.comment = comment;
  this[SYM_PRIV_PEM] = privPEM;
  this[SYM_PUB_PEM] = pubPEM;
  this[SYM_PUB_SSH] = pubSSH;
  this[SYM_HASH_ALGO] = algo;
  this[SYM_DECRYPTED] = decrypted;
}
OpenSSH_Private.prototype = BaseKey;
{
  const regexp = /^-----BEGIN OPENSSH PRIVATE KEY-----(?:\r\n|\n)([\s\S]+)(?:\r\n|\n)-----END OPENSSH PRIVATE KEY-----$/;
  OpenSSH_Private.parse = (str, passphrase) => {
    const m = regexp.exec(str);
    if (m === null) return null;
    let ret;
    const data = Buffer.from(m[1], 'base64');
    if (data.length < 31)
      // magic (+ magic null term.) + minimum field lengths
      return new Error('Malformed OpenSSH private key');
    const magic = data.utf8Slice(0, 15);
    if (magic !== 'openssh-key-v1\0') return new Error(`Unsupported OpenSSH key magic: ${magic}`);
    const cipherName = readString(data, 15, true);
    if (cipherName === undefined) return new Error('Malformed OpenSSH private key');
    if (cipherName !== 'none' && SUPPORTED_CIPHER.indexOf(cipherName) === -1) return new Error(`Unsupported cipher for OpenSSH key: ${cipherName}`);
    const kdfName = readString(data, data._pos, true);
    if (kdfName === undefined) return new Error('Malformed OpenSSH private key');
    if (kdfName !== 'none') {
      if (cipherName === 'none') return new Error('Malformed OpenSSH private key');
      if (kdfName !== 'bcrypt') return new Error(`Unsupported kdf name for OpenSSH key: ${kdfName}`);
      if (!passphrase) {
        return new Error('Encrypted private OpenSSH key detected, but no passphrase given');
      }
    } else if (cipherName !== 'none') {
      return new Error('Malformed OpenSSH private key');
    }
    let encInfo;
    let cipherKey;
    let cipherIV;
    if (cipherName !== 'none') encInfo = CIPHER_INFO[cipherName];
    const kdfOptions = readString(data, data._pos);
    if (kdfOptions === undefined) return new Error('Malformed OpenSSH private key');
    if (kdfOptions.length) {
      switch (kdfName) {
        case 'none':
          return new Error('Malformed OpenSSH private key');
        case 'bcrypt':
          /*
            string salt
            uint32 rounds
          */
          const salt = readString(kdfOptions, 0);
          if (salt === undefined || kdfOptions._pos + 4 > kdfOptions.length) return new Error('Malformed OpenSSH private key');
          const rounds = readUInt32BE(kdfOptions, kdfOptions._pos);
          const gen = Buffer.allocUnsafe(encInfo.keyLen + encInfo.ivLen);
          const r = bcrypt_pbkdf(passphrase, passphrase.length, salt, salt.length, gen, gen.length, rounds);
          if (r !== 0) return new Error('Failed to generate information to decrypt key');
          cipherKey = bufferSlice(gen, 0, encInfo.keyLen);
          cipherIV = bufferSlice(gen, encInfo.keyLen, gen.length);
          break;
      }
    } else if (kdfName !== 'none') {
      return new Error('Malformed OpenSSH private key');
    }
    if (data._pos + 3 >= data.length) return new Error('Malformed OpenSSH private key');
    const keyCount = readUInt32BE(data, data._pos);
    data._pos += 4;
    if (keyCount > 0) {
      // TODO: place sensible limit on max `keyCount`

      // Read public keys first
      for (let i = 0; i < keyCount; ++i) {
        const pubData = readString(data, data._pos);
        if (pubData === undefined) return new Error('Malformed OpenSSH private key');
        const type = readString(pubData, 0, true);
        if (type === undefined) return new Error('Malformed OpenSSH private key');
      }
      let privBlob = readString(data, data._pos);
      if (privBlob === undefined) return new Error('Malformed OpenSSH private key');
      if (cipherKey !== undefined) {
        // Encrypted private key(s)
        if (privBlob.length < encInfo.blockLen || privBlob.length % encInfo.blockLen !== 0) {
          return new Error('Malformed OpenSSH private key');
        }
        try {
          const options = {
            authTagLength: encInfo.authLen
          };
          const decipher = createDecipheriv(encInfo.sslName, cipherKey, cipherIV, options);
          if (encInfo.authLen > 0) {
            if (data.length - data._pos < encInfo.authLen) return new Error('Malformed OpenSSH private key');
            decipher.setAuthTag(bufferSlice(data, data._pos, data._pos += encInfo.authLen));
          }
          privBlob = combineBuffers(decipher.update(privBlob), decipher.final());
        } catch (ex) {
          return ex;
        }
      }
      // Nothing should we follow the private key(s), except a possible
      // authentication tag for relevant ciphers
      if (data._pos !== data.length) return new Error('Malformed OpenSSH private key');
      ret = parseOpenSSHPrivKeys(privBlob, keyCount, cipherKey !== undefined);
    } else {
      ret = [];
    }
    if (ret instanceof Error) return ret;
    // This will need to change if/when OpenSSH ever starts storing multiple
    // keys in their key files
    return ret[0];
  };
  function parseOpenSSHPrivKeys(data, nkeys, decrypted) {
    const keys = [];
    /*
      uint32  checkint
      uint32  checkint
      string  privatekey1
      string  comment1
      string  privatekey2
      string  comment2
      ...
      string  privatekeyN
      string  commentN
      char  1
      char  2
      char  3
      ...
      char  padlen % 255
    */
    if (data.length < 8) return new Error('Malformed OpenSSH private key');
    const check1 = readUInt32BE(data, 0);
    const check2 = readUInt32BE(data, 4);
    if (check1 !== check2) {
      if (decrypted) {
        return new Error('OpenSSH key integrity check failed -- bad passphrase?');
      }
      return new Error('OpenSSH key integrity check failed');
    }
    data._pos = 8;
    let i;
    let oid;
    for (i = 0; i < nkeys; ++i) {
      let algo;
      let privPEM;
      let pubPEM;
      let pubSSH;
      // The OpenSSH documentation for the key format actually lies, the
      // entirety of the private key content is not contained with a string
      // field, it's actually the literal contents of the private key, so to be
      // able to find the end of the key data you need to know the layout/format
      // of each key type ...
      const type = readString(data, data._pos, true);
      if (type === undefined) return new Error('Malformed OpenSSH private key');
      switch (type) {
        case 'ssh-rsa':
          {
            /*
              string  n -- public
              string  e -- public
              string  d -- private
              string  iqmp -- private
              string  p -- private
              string  q -- private
            */
            const n = readString(data, data._pos);
            if (n === undefined) return new Error('Malformed OpenSSH private key');
            const e = readString(data, data._pos);
            if (e === undefined) return new Error('Malformed OpenSSH private key');
            const d = readString(data, data._pos);
            if (d === undefined) return new Error('Malformed OpenSSH private key');
            const iqmp = readString(data, data._pos);
            if (iqmp === undefined) return new Error('Malformed OpenSSH private key');
            const p = readString(data, data._pos);
            if (p === undefined) return new Error('Malformed OpenSSH private key');
            const q = readString(data, data._pos);
            if (q === undefined) return new Error('Malformed OpenSSH private key');
            pubPEM = genOpenSSLRSAPub(n, e);
            pubSSH = genOpenSSHRSAPub(n, e);
            privPEM = genOpenSSLRSAPriv(n, e, d, iqmp, p, q);
            algo = 'sha1';
            break;
          }
        case 'ssh-dss':
          {
            /*
              string  p -- public
              string  q -- public
              string  g -- public
              string  y -- public
              string  x -- private
            */
            const p = readString(data, data._pos);
            if (p === undefined) return new Error('Malformed OpenSSH private key');
            const q = readString(data, data._pos);
            if (q === undefined) return new Error('Malformed OpenSSH private key');
            const g = readString(data, data._pos);
            if (g === undefined) return new Error('Malformed OpenSSH private key');
            const y = readString(data, data._pos);
            if (y === undefined) return new Error('Malformed OpenSSH private key');
            const x = readString(data, data._pos);
            if (x === undefined) return new Error('Malformed OpenSSH private key');
            pubPEM = genOpenSSLDSAPub(p, q, g, y);
            pubSSH = genOpenSSHDSAPub(p, q, g, y);
            privPEM = genOpenSSLDSAPriv(p, q, g, y, x);
            algo = 'sha1';
            break;
          }
        case 'ssh-ed25519':
          {
            if (!eddsaSupported) return new Error(`Unsupported OpenSSH private key type: ${type}`);
            /*
              * string  public key
              * string  private key + public key
            */
            const edpub = readString(data, data._pos);
            if (edpub === undefined || edpub.length !== 32) return new Error('Malformed OpenSSH private key');
            const edpriv = readString(data, data._pos);
            if (edpriv === undefined || edpriv.length !== 64) return new Error('Malformed OpenSSH private key');
            pubPEM = genOpenSSLEdPub(edpub);
            pubSSH = genOpenSSHEdPub(edpub);
            privPEM = genOpenSSLEdPriv(bufferSlice(edpriv, 0, 32));
            algo = null;
            break;
          }
        case 'ecdsa-sha2-nistp256':
          algo = 'sha256';
          oid = '1.2.840.10045.3.1.7';
        // FALLTHROUGH
        case 'ecdsa-sha2-nistp384':
          if (algo === undefined) {
            algo = 'sha384';
            oid = '1.3.132.0.34';
          }
        // FALLTHROUGH
        case 'ecdsa-sha2-nistp521':
          {
            if (algo === undefined) {
              algo = 'sha512';
              oid = '1.3.132.0.35';
            }
            /*
              string  curve name
              string  Q -- public
              string  d -- private
            */
            // TODO: validate curve name against type
            if (!skipFields(data, 1))
              // Skip curve name
              return new Error('Malformed OpenSSH private key');
            const ecpub = readString(data, data._pos);
            if (ecpub === undefined) return new Error('Malformed OpenSSH private key');
            const ecpriv = readString(data, data._pos);
            if (ecpriv === undefined) return new Error('Malformed OpenSSH private key');
            pubPEM = genOpenSSLECDSAPub(oid, ecpub);
            pubSSH = genOpenSSHECDSAPub(oid, ecpub);
            privPEM = genOpenSSLECDSAPriv(oid, ecpub, ecpriv);
            break;
          }
        default:
          return new Error(`Unsupported OpenSSH private key type: ${type}`);
      }
      const privComment = readString(data, data._pos, true);
      if (privComment === undefined) return new Error('Malformed OpenSSH private key');
      keys.push(new OpenSSH_Private(type, privComment, privPEM, pubPEM, pubSSH, algo, decrypted));
    }
    let cnt = 0;
    for (i = data._pos; i < data.length; ++i) {
      if (data[i] !== ++cnt % 255) return new Error('Malformed OpenSSH private key');
    }
    return keys;
  }
}
function OpenSSH_Old_Private(type, comment, privPEM, pubPEM, pubSSH, algo, decrypted) {
  this.type = type;
  this.comment = comment;
  this[SYM_PRIV_PEM] = privPEM;
  this[SYM_PUB_PEM] = pubPEM;
  this[SYM_PUB_SSH] = pubSSH;
  this[SYM_HASH_ALGO] = algo;
  this[SYM_DECRYPTED] = decrypted;
}
OpenSSH_Old_Private.prototype = BaseKey;
{
  const regexp = /^-----BEGIN (RSA|DSA|EC) PRIVATE KEY-----(?:\r\n|\n)((?:[^:]+:\s*[\S].*(?:\r\n|\n))*)([\s\S]+)(?:\r\n|\n)-----END (RSA|DSA|EC) PRIVATE KEY-----$/;
  OpenSSH_Old_Private.parse = (str, passphrase) => {
    const m = regexp.exec(str);
    if (m === null) return null;
    let privBlob = Buffer.from(m[3], 'base64');
    let headers = m[2];
    let decrypted = false;
    if (headers !== undefined) {
      // encrypted key
      headers = headers.split(/\r\n|\n/g);
      for (let i = 0; i < headers.length; ++i) {
        const header = headers[i];
        let sepIdx = header.indexOf(':');
        if (header.slice(0, sepIdx) === 'DEK-Info') {
          const val = header.slice(sepIdx + 2);
          sepIdx = val.indexOf(',');
          if (sepIdx === -1) continue;
          const cipherName = val.slice(0, sepIdx).toLowerCase();
          if (supportedOpenSSLCiphers.indexOf(cipherName) === -1) {
            return new Error(`Cipher (${cipherName}) not supported ` + 'for encrypted OpenSSH private key');
          }
          const encInfo = CIPHER_INFO_OPENSSL[cipherName];
          if (!encInfo) {
            return new Error(`Cipher (${cipherName}) not supported ` + 'for encrypted OpenSSH private key');
          }
          const cipherIV = Buffer.from(val.slice(sepIdx + 1), 'hex');
          if (cipherIV.length !== encInfo.ivLen) return new Error('Malformed encrypted OpenSSH private key');
          if (!passphrase) {
            return new Error('Encrypted OpenSSH private key detected, but no passphrase given');
          }
          const ivSlice = bufferSlice(cipherIV, 0, 8);
          let cipherKey = createHash('md5').update(passphrase).update(ivSlice).digest();
          while (cipherKey.length < encInfo.keyLen) {
            cipherKey = combineBuffers(cipherKey, createHash('md5').update(cipherKey).update(passphrase).update(ivSlice).digest());
          }
          if (cipherKey.length > encInfo.keyLen) cipherKey = bufferSlice(cipherKey, 0, encInfo.keyLen);
          try {
            const decipher = createDecipheriv(cipherName, cipherKey, cipherIV);
            decipher.setAutoPadding(false);
            privBlob = combineBuffers(decipher.update(privBlob), decipher.final());
            decrypted = true;
          } catch (ex) {
            return ex;
          }
        }
      }
    }
    let type;
    let privPEM;
    let pubPEM;
    let pubSSH;
    let algo;
    let reader;
    let errMsg = 'Malformed OpenSSH private key';
    if (decrypted) errMsg += '. Bad passphrase?';
    switch (m[1]) {
      case 'RSA':
        type = 'ssh-rsa';
        privPEM = makePEM('RSA PRIVATE', privBlob);
        try {
          reader = new Ber.Reader(privBlob);
          reader.readSequence();
          reader.readInt(); // skip version
          const n = reader.readString(Ber.Integer, true);
          if (n === null) return new Error(errMsg);
          const e = reader.readString(Ber.Integer, true);
          if (e === null) return new Error(errMsg);
          pubPEM = genOpenSSLRSAPub(n, e);
          pubSSH = genOpenSSHRSAPub(n, e);
        } catch {
          return new Error(errMsg);
        }
        algo = 'sha1';
        break;
      case 'DSA':
        type = 'ssh-dss';
        privPEM = makePEM('DSA PRIVATE', privBlob);
        try {
          reader = new Ber.Reader(privBlob);
          reader.readSequence();
          reader.readInt(); // skip version
          const p = reader.readString(Ber.Integer, true);
          if (p === null) return new Error(errMsg);
          const q = reader.readString(Ber.Integer, true);
          if (q === null) return new Error(errMsg);
          const g = reader.readString(Ber.Integer, true);
          if (g === null) return new Error(errMsg);
          const y = reader.readString(Ber.Integer, true);
          if (y === null) return new Error(errMsg);
          pubPEM = genOpenSSLDSAPub(p, q, g, y);
          pubSSH = genOpenSSHDSAPub(p, q, g, y);
        } catch {
          return new Error(errMsg);
        }
        algo = 'sha1';
        break;
      case 'EC':
        let ecSSLName;
        let ecPriv;
        let ecOID;
        try {
          reader = new Ber.Reader(privBlob);
          reader.readSequence();
          reader.readInt(); // skip version
          ecPriv = reader.readString(Ber.OctetString, true);
          reader.readByte(); // Skip "complex" context type byte
          const offset = reader.readLength(); // Skip context length
          if (offset !== null) {
            reader._offset = offset;
            ecOID = reader.readOID();
            if (ecOID === null) return new Error(errMsg);
            switch (ecOID) {
              case '1.2.840.10045.3.1.7':
                // prime256v1/secp256r1
                ecSSLName = 'prime256v1';
                type = 'ecdsa-sha2-nistp256';
                algo = 'sha256';
                break;
              case '1.3.132.0.34':
                // secp384r1
                ecSSLName = 'secp384r1';
                type = 'ecdsa-sha2-nistp384';
                algo = 'sha384';
                break;
              case '1.3.132.0.35':
                // secp521r1
                ecSSLName = 'secp521r1';
                type = 'ecdsa-sha2-nistp521';
                algo = 'sha512';
                break;
              default:
                return new Error(`Unsupported private key EC OID: ${ecOID}`);
            }
          } else {
            return new Error(errMsg);
          }
        } catch {
          return new Error(errMsg);
        }
        privPEM = makePEM('EC PRIVATE', privBlob);
        const pubBlob = genOpenSSLECDSAPubFromPriv(ecSSLName, ecPriv);
        pubPEM = genOpenSSLECDSAPub(ecOID, pubBlob);
        pubSSH = genOpenSSHECDSAPub(ecOID, pubBlob);
        break;
    }
    return new OpenSSH_Old_Private(type, '', privPEM, pubPEM, pubSSH, algo, decrypted);
  };
}
function PPK_Private(type, comment, privPEM, pubPEM, pubSSH, algo, decrypted) {
  this.type = type;
  this.comment = comment;
  this[SYM_PRIV_PEM] = privPEM;
  this[SYM_PUB_PEM] = pubPEM;
  this[SYM_PUB_SSH] = pubSSH;
  this[SYM_HASH_ALGO] = algo;
  this[SYM_DECRYPTED] = decrypted;
}
PPK_Private.prototype = BaseKey;
{
  const EMPTY_PASSPHRASE = Buffer.alloc(0);
  const PPK_IV = Buffer.from([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
  const PPK_PP1 = Buffer.from([0, 0, 0, 0]);
  const PPK_PP2 = Buffer.from([0, 0, 0, 1]);
  const regexp = /^PuTTY-User-Key-File-2: (ssh-(?:rsa|dss))\r?\nEncryption: (aes256-cbc|none)\r?\nComment: ([^\r\n]*)\r?\nPublic-Lines: \d+\r?\n([\s\S]+?)\r?\nPrivate-Lines: \d+\r?\n([\s\S]+?)\r?\nPrivate-MAC: ([^\r\n]+)/;
  PPK_Private.parse = (str, passphrase) => {
    const m = regexp.exec(str);
    if (m === null) return null;
    // m[1] = key type
    // m[2] = encryption type
    // m[3] = comment
    // m[4] = base64-encoded public key data:
    //         for "ssh-rsa":
    //          string "ssh-rsa"
    //          mpint  e    (public exponent)
    //          mpint  n    (modulus)
    //         for "ssh-dss":
    //          string "ssh-dss"
    //          mpint p     (modulus)
    //          mpint q     (prime)
    //          mpint g     (base number)
    //          mpint y     (public key parameter: g^x mod p)
    // m[5] = base64-encoded private key data:
    //         for "ssh-rsa":
    //          mpint  d    (private exponent)
    //          mpint  p    (prime 1)
    //          mpint  q    (prime 2)
    //          mpint  iqmp ([inverse of q] mod p)
    //         for "ssh-dss":
    //          mpint x     (private key parameter)
    // m[6] = SHA1 HMAC over:
    //          string  name of algorithm ("ssh-dss", "ssh-rsa")
    //          string  encryption type
    //          string  comment
    //          string  public key data
    //          string  private-plaintext (including the final padding)
    const cipherName = m[2];
    const encrypted = cipherName !== 'none';
    if (encrypted && !passphrase) {
      return new Error('Encrypted PPK private key detected, but no passphrase given');
    }
    let privBlob = Buffer.from(m[5], 'base64');
    if (encrypted) {
      const encInfo = CIPHER_INFO[cipherName];
      let cipherKey = combineBuffers(createHash('sha1').update(PPK_PP1).update(passphrase).digest(), createHash('sha1').update(PPK_PP2).update(passphrase).digest());
      if (cipherKey.length > encInfo.keyLen) cipherKey = bufferSlice(cipherKey, 0, encInfo.keyLen);
      try {
        const decipher = createDecipheriv(encInfo.sslName, cipherKey, PPK_IV);
        decipher.setAutoPadding(false);
        privBlob = combineBuffers(decipher.update(privBlob), decipher.final());
      } catch (ex) {
        return ex;
      }
    }
    const type = m[1];
    const comment = m[3];
    const pubBlob = Buffer.from(m[4], 'base64');
    const mac = m[6];
    const typeLen = type.length;
    const cipherNameLen = cipherName.length;
    const commentLen = Buffer.byteLength(comment);
    const pubLen = pubBlob.length;
    const privLen = privBlob.length;
    const macData = Buffer.allocUnsafe(4 + typeLen + 4 + cipherNameLen + 4 + commentLen + 4 + pubLen + 4 + privLen);
    let p = 0;
    writeUInt32BE(macData, typeLen, p);
    macData.utf8Write(type, p += 4, typeLen);
    writeUInt32BE(macData, cipherNameLen, p += typeLen);
    macData.utf8Write(cipherName, p += 4, cipherNameLen);
    writeUInt32BE(macData, commentLen, p += cipherNameLen);
    macData.utf8Write(comment, p += 4, commentLen);
    writeUInt32BE(macData, pubLen, p += commentLen);
    macData.set(pubBlob, p += 4);
    writeUInt32BE(macData, privLen, p += pubLen);
    macData.set(privBlob, p + 4);
    if (!passphrase) passphrase = EMPTY_PASSPHRASE;
    const calcMAC = createHmac('sha1', createHash('sha1').update('putty-private-key-file-mac-key').update(passphrase).digest()).update(macData).digest('hex');
    if (calcMAC !== mac) {
      if (encrypted) {
        return new Error('PPK private key integrity check failed -- bad passphrase?');
      }
      return new Error('PPK private key integrity check failed');
    }
    let pubPEM;
    let pubSSH;
    let privPEM;
    pubBlob._pos = 0;
    skipFields(pubBlob, 1); // skip (duplicate) key type
    switch (type) {
      case 'ssh-rsa':
        {
          const e = readString(pubBlob, pubBlob._pos);
          if (e === undefined) return new Error('Malformed PPK public key');
          const n = readString(pubBlob, pubBlob._pos);
          if (n === undefined) return new Error('Malformed PPK public key');
          const d = readString(privBlob, 0);
          if (d === undefined) return new Error('Malformed PPK private key');
          const p = readString(privBlob, privBlob._pos);
          if (p === undefined) return new Error('Malformed PPK private key');
          const q = readString(privBlob, privBlob._pos);
          if (q === undefined) return new Error('Malformed PPK private key');
          const iqmp = readString(privBlob, privBlob._pos);
          if (iqmp === undefined) return new Error('Malformed PPK private key');
          pubPEM = genOpenSSLRSAPub(n, e);
          pubSSH = genOpenSSHRSAPub(n, e);
          privPEM = genOpenSSLRSAPriv(n, e, d, iqmp, p, q);
          break;
        }
      case 'ssh-dss':
        {
          const p = readString(pubBlob, pubBlob._pos);
          if (p === undefined) return new Error('Malformed PPK public key');
          const q = readString(pubBlob, pubBlob._pos);
          if (q === undefined) return new Error('Malformed PPK public key');
          const g = readString(pubBlob, pubBlob._pos);
          if (g === undefined) return new Error('Malformed PPK public key');
          const y = readString(pubBlob, pubBlob._pos);
          if (y === undefined) return new Error('Malformed PPK public key');
          const x = readString(privBlob, 0);
          if (x === undefined) return new Error('Malformed PPK private key');
          pubPEM = genOpenSSLDSAPub(p, q, g, y);
          pubSSH = genOpenSSHDSAPub(p, q, g, y);
          privPEM = genOpenSSLDSAPriv(p, q, g, y, x);
          break;
        }
    }
    return new PPK_Private(type, comment, privPEM, pubPEM, pubSSH, 'sha1', encrypted);
  };
}
function OpenSSH_Public(type, comment, pubPEM, pubSSH, algo) {
  this.type = type;
  this.comment = comment;
  this[SYM_PRIV_PEM] = null;
  this[SYM_PUB_PEM] = pubPEM;
  this[SYM_PUB_SSH] = pubSSH;
  this[SYM_HASH_ALGO] = algo;
  this[SYM_DECRYPTED] = false;
}
OpenSSH_Public.prototype = BaseKey;
{
  let regexp;
  if (eddsaSupported) regexp = /^(((?:ssh-(?:rsa|dss|ed25519))|ecdsa-sha2-nistp(?:256|384|521))(?:-cert-v0[01]@openssh.com)?) ([A-Z0-9a-z/+=]+)(?:$|\s+([\S].*)?)$/;else regexp = /^(((?:ssh-(?:rsa|dss))|ecdsa-sha2-nistp(?:256|384|521))(?:-cert-v0[01]@openssh.com)?) ([A-Z0-9a-z/+=]+)(?:$|\s+([\S].*)?)$/;
  OpenSSH_Public.parse = str => {
    const m = regexp.exec(str);
    if (m === null) return null;
    // m[1] = full type
    // m[2] = base type
    // m[3] = base64-encoded public key
    // m[4] = comment

    const fullType = m[1];
    const baseType = m[2];
    const data = Buffer.from(m[3], 'base64');
    const comment = m[4] || '';
    const type = readString(data, data._pos, true);
    if (type === undefined || type.indexOf(baseType) !== 0) return new Error('Malformed OpenSSH public key');
    return parseDER(data, baseType, comment, fullType);
  };
}
function RFC4716_Public(type, comment, pubPEM, pubSSH, algo) {
  this.type = type;
  this.comment = comment;
  this[SYM_PRIV_PEM] = null;
  this[SYM_PUB_PEM] = pubPEM;
  this[SYM_PUB_SSH] = pubSSH;
  this[SYM_HASH_ALGO] = algo;
  this[SYM_DECRYPTED] = false;
}
RFC4716_Public.prototype = BaseKey;
{
  const regexp = /^---- BEGIN SSH2 PUBLIC KEY ----(?:\r?\n)((?:.{0,72}\r?\n)+)---- END SSH2 PUBLIC KEY ----$/;
  const RE_DATA = /^[A-Z0-9a-z/+=\r\n]+$/;
  const RE_HEADER = /^([\x21-\x39\x3B-\x7E]{1,64}): ((?:[^\\]*\\\r?\n)*[^\r\n]+)\r?\n/gm;
  const RE_HEADER_ENDS = /\\\r?\n/g;
  RFC4716_Public.parse = str => {
    let m = regexp.exec(str);
    if (m === null) return null;
    const body = m[1];
    let dataStart = 0;
    let comment = '';
    while (m = RE_HEADER.exec(body)) {
      const headerName = m[1];
      const headerValue = m[2].replace(RE_HEADER_ENDS, '');
      if (headerValue.length > 1024) {
        RE_HEADER.lastIndex = 0;
        return new Error('Malformed RFC4716 public key');
      }
      dataStart = RE_HEADER.lastIndex;
      if (headerName.toLowerCase() === 'comment') {
        comment = headerValue;
        if (comment.length > 1 && comment.charCodeAt(0) === 34 /* '"' */ && comment.charCodeAt(comment.length - 1) === 34 /* '"' */) {
          comment = comment.slice(1, -1);
        }
      }
    }
    let data = body.slice(dataStart);
    if (!RE_DATA.test(data)) return new Error('Malformed RFC4716 public key');
    data = Buffer.from(data, 'base64');
    const type = readString(data, 0, true);
    if (type === undefined) return new Error('Malformed RFC4716 public key');
    let pubPEM = null;
    let pubSSH = null;
    switch (type) {
      case 'ssh-rsa':
        {
          const e = readString(data, data._pos);
          if (e === undefined) return new Error('Malformed RFC4716 public key');
          const n = readString(data, data._pos);
          if (n === undefined) return new Error('Malformed RFC4716 public key');
          pubPEM = genOpenSSLRSAPub(n, e);
          pubSSH = genOpenSSHRSAPub(n, e);
          break;
        }
      case 'ssh-dss':
        {
          const p = readString(data, data._pos);
          if (p === undefined) return new Error('Malformed RFC4716 public key');
          const q = readString(data, data._pos);
          if (q === undefined) return new Error('Malformed RFC4716 public key');
          const g = readString(data, data._pos);
          if (g === undefined) return new Error('Malformed RFC4716 public key');
          const y = readString(data, data._pos);
          if (y === undefined) return new Error('Malformed RFC4716 public key');
          pubPEM = genOpenSSLDSAPub(p, q, g, y);
          pubSSH = genOpenSSHDSAPub(p, q, g, y);
          break;
        }
      default:
        return new Error('Malformed RFC4716 public key');
    }
    return new RFC4716_Public(type, comment, pubPEM, pubSSH, 'sha1');
  };
}
function parseDER(data, baseType, comment, fullType) {
  if (!isSupportedKeyType(baseType)) return new Error(`Unsupported OpenSSH public key type: ${baseType}`);
  let algo;
  let oid;
  let pubPEM = null;
  let pubSSH = null;
  switch (baseType) {
    case 'ssh-rsa':
      {
        const e = readString(data, data._pos || 0);
        if (e === undefined) return new Error('Malformed OpenSSH public key');
        const n = readString(data, data._pos);
        if (n === undefined) return new Error('Malformed OpenSSH public key');
        pubPEM = genOpenSSLRSAPub(n, e);
        pubSSH = genOpenSSHRSAPub(n, e);
        algo = 'sha1';
        break;
      }
    case 'ssh-dss':
      {
        const p = readString(data, data._pos || 0);
        if (p === undefined) return new Error('Malformed OpenSSH public key');
        const q = readString(data, data._pos);
        if (q === undefined) return new Error('Malformed OpenSSH public key');
        const g = readString(data, data._pos);
        if (g === undefined) return new Error('Malformed OpenSSH public key');
        const y = readString(data, data._pos);
        if (y === undefined) return new Error('Malformed OpenSSH public key');
        pubPEM = genOpenSSLDSAPub(p, q, g, y);
        pubSSH = genOpenSSHDSAPub(p, q, g, y);
        algo = 'dss1';
        break;
      }
    case 'ssh-ed25519':
      {
        const edpub = readString(data, data._pos || 0);
        if (edpub === undefined || edpub.length !== 32) return new Error('Malformed OpenSSH public key');
        pubPEM = genOpenSSLEdPub(edpub);
        pubSSH = genOpenSSHEdPub(edpub);
        algo = null;
        break;
      }
    case 'ecdsa-sha2-nistp256':
      algo = 'sha256';
      oid = '1.2.840.10045.3.1.7';
    // FALLTHROUGH
    case 'ecdsa-sha2-nistp384':
      if (algo === undefined) {
        algo = 'sha384';
        oid = '1.3.132.0.34';
      }
    // FALLTHROUGH
    case 'ecdsa-sha2-nistp521':
      {
        if (algo === undefined) {
          algo = 'sha512';
          oid = '1.3.132.0.35';
        }
        // TODO: validate curve name against type
        if (!skipFields(data, 1))
          // Skip curve name
          return new Error('Malformed OpenSSH public key');
        const ecpub = readString(data, data._pos || 0);
        if (ecpub === undefined) return new Error('Malformed OpenSSH public key');
        pubPEM = genOpenSSLECDSAPub(oid, ecpub);
        pubSSH = genOpenSSHECDSAPub(oid, ecpub);
        break;
      }
    default:
      return new Error(`Unsupported OpenSSH public key type: ${baseType}`);
  }
  return new OpenSSH_Public(fullType, comment, pubPEM, pubSSH, algo);
}
function isSupportedKeyType(type) {
  switch (type) {
    case 'ssh-rsa':
    case 'ssh-dss':
    case 'ecdsa-sha2-nistp256':
    case 'ecdsa-sha2-nistp384':
    case 'ecdsa-sha2-nistp521':
      return true;
    case 'ssh-ed25519':
      if (eddsaSupported) return true;
    // FALLTHROUGH
    default:
      return false;
  }
}
function isParsedKey(val) {
  if (!val) return false;
  return typeof val[SYM_DECRYPTED] === 'boolean';
}
function parseKey(data, passphrase) {
  if (isParsedKey(data)) return data;
  let origBuffer;
  if (Buffer.isBuffer(data)) {
    origBuffer = data;
    data = data.utf8Slice(0, data.length).trim();
  } else if (typeof data === 'string') {
    data = data.trim();
  } else {
    return new Error('Key data must be a Buffer or string');
  }

  // eslint-disable-next-line eqeqeq
  if (passphrase != undefined) {
    if (typeof passphrase === 'string') passphrase = Buffer.from(passphrase);else if (!Buffer.isBuffer(passphrase)) return new Error('Passphrase must be a string or Buffer when supplied');
  }
  let ret;

  // First try as printable string format (e.g. PEM)

  // Private keys
  if ((ret = OpenSSH_Private.parse(data, passphrase)) !== null) return ret;
  if ((ret = OpenSSH_Old_Private.parse(data, passphrase)) !== null) return ret;
  if ((ret = PPK_Private.parse(data, passphrase)) !== null) return ret;

  // Public keys
  if ((ret = OpenSSH_Public.parse(data)) !== null) return ret;
  if ((ret = RFC4716_Public.parse(data)) !== null) return ret;

  // Finally try as a binary format if we were originally passed binary data
  if (origBuffer) {
    binaryKeyParser.init(origBuffer, 0);
    const type = binaryKeyParser.readString(true);
    if (type !== undefined) {
      data = binaryKeyParser.readRaw();
      if (data !== undefined) {
        ret = parseDER(data, type, '', type);
        // Ignore potentially useless errors in case the data was not actually
        // in the binary format
        if (ret instanceof Error) ret = null;
      }
    }
    binaryKeyParser.clear();
  }
  if (ret) return ret;
  return new Error('Unsupported key format');
}
module.exports = {
  isParsedKey,
  isSupportedKeyType,
  parseDERKey: (data, type) => parseDER(data, type, '', type),
  parseKey
};

/***/ }),

/***/ 3281:
/*!***********************************************************!*\
  !*** ../node_modules/ssh2/lib/protocol/node-fs-compat.js ***!
  \***********************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


const assert = __webpack_require__(/*! assert */ 9491);
const {
  inspect
} = __webpack_require__(/*! util */ 3837);

// Only use this for integers! Decimal numbers do not work with this function.
function addNumericalSeparator(val) {
  let res = '';
  let i = val.length;
  const start = val[0] === '-' ? 1 : 0;
  for (; i >= start + 4; i -= 3) res = `_${val.slice(i - 3, i)}${res}`;
  return `${val.slice(0, i)}${res}`;
}
function oneOf(expected, thing) {
  assert(typeof thing === 'string', '`thing` has to be of type string');
  if (Array.isArray(expected)) {
    const len = expected.length;
    assert(len > 0, 'At least one expected value needs to be specified');
    expected = expected.map(i => String(i));
    if (len > 2) {
      return `one of ${thing} ${expected.slice(0, len - 1).join(', ')}, or ` + expected[len - 1];
    } else if (len === 2) {
      return `one of ${thing} ${expected[0]} or ${expected[1]}`;
    }
    return `of ${thing} ${expected[0]}`;
  }
  return `of ${thing} ${String(expected)}`;
}
exports.ERR_INTERNAL_ASSERTION = class ERR_INTERNAL_ASSERTION extends Error {
  constructor(message) {
    super();
    Error.captureStackTrace(this, ERR_INTERNAL_ASSERTION);
    const suffix = 'This is caused by either a bug in ssh2 ' + 'or incorrect usage of ssh2 internals.\n' + 'Please open an issue with this stack trace at ' + 'https://github.com/mscdex/ssh2/issues\n';
    this.message = message === undefined ? suffix : `${message}\n${suffix}`;
  }
};
const MAX_32BIT_INT = 2 ** 32;
const MAX_32BIT_BIGINT = (() => {
  try {
    return new Function('return 2n ** 32n')();
  } catch {}
})();
exports.ERR_OUT_OF_RANGE = class ERR_OUT_OF_RANGE extends RangeError {
  constructor(str, range, input, replaceDefaultBoolean) {
    super();
    Error.captureStackTrace(this, ERR_OUT_OF_RANGE);
    assert(range, 'Missing "range" argument');
    let msg = replaceDefaultBoolean ? str : `The value of "${str}" is out of range.`;
    let received;
    if (Number.isInteger(input) && Math.abs(input) > MAX_32BIT_INT) {
      received = addNumericalSeparator(String(input));
    } else if (typeof input === 'bigint') {
      received = String(input);
      if (input > MAX_32BIT_BIGINT || input < -MAX_32BIT_BIGINT) received = addNumericalSeparator(received);
      received += 'n';
    } else {
      received = inspect(input);
    }
    msg += ` It must be ${range}. Received ${received}`;
    this.message = msg;
  }
};
class ERR_INVALID_ARG_TYPE extends TypeError {
  constructor(name, expected, actual) {
    super();
    Error.captureStackTrace(this, ERR_INVALID_ARG_TYPE);
    assert(typeof name === 'string', `'name' must be a string`);

    // determiner: 'must be' or 'must not be'
    let determiner;
    if (typeof expected === 'string' && expected.startsWith('not ')) {
      determiner = 'must not be';
      expected = expected.replace(/^not /, '');
    } else {
      determiner = 'must be';
    }
    let msg;
    if (name.endsWith(' argument')) {
      // For cases like 'first argument'
      msg = `The ${name} ${determiner} ${oneOf(expected, 'type')}`;
    } else {
      const type = name.includes('.') ? 'property' : 'argument';
      msg = `The "${name}" ${type} ${determiner} ${oneOf(expected, 'type')}`;
    }
    msg += `. Received type ${typeof actual}`;
    this.message = msg;
  }
}
exports.ERR_INVALID_ARG_TYPE = ERR_INVALID_ARG_TYPE;
exports.validateNumber = function validateNumber(value, name) {
  if (typeof value !== 'number') throw new ERR_INVALID_ARG_TYPE(name, 'number', value);
};

/***/ }),

/***/ 3549:
/*!**************************************************!*\
  !*** ../node_modules/ssh2/lib/protocol/utils.js ***!
  \**************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


const Ber = (__webpack_require__(/*! asn1 */ 5593).Ber);
let DISCONNECT_REASON;
const FastBuffer = Buffer[Symbol.species];
const TypedArrayFill = Object.getPrototypeOf(Uint8Array.prototype).fill;
function readUInt32BE(buf, offset) {
  return buf[offset++] * 16777216 + buf[offset++] * 65536 + buf[offset++] * 256 + buf[offset];
}
function bufferCopy(src, dest, srcStart, srcEnd, destStart) {
  if (!destStart) destStart = 0;
  if (srcEnd > src.length) srcEnd = src.length;
  let nb = srcEnd - srcStart;
  const destLeft = dest.length - destStart;
  if (nb > destLeft) nb = destLeft;
  dest.set(new Uint8Array(src.buffer, src.byteOffset + srcStart, nb), destStart);
  return nb;
}
function bufferSlice(buf, start, end) {
  if (end === undefined) end = buf.length;
  return new FastBuffer(buf.buffer, buf.byteOffset + start, end - start);
}
function makeBufferParser() {
  let pos = 0;
  let buffer;
  const self = {
    init: (buf, start) => {
      buffer = buf;
      pos = typeof start === 'number' ? start : 0;
    },
    pos: () => pos,
    length: () => buffer ? buffer.length : 0,
    avail: () => buffer && pos < buffer.length ? buffer.length - pos : 0,
    clear: () => {
      buffer = undefined;
    },
    readUInt32BE: () => {
      if (!buffer || pos + 3 >= buffer.length) return;
      return buffer[pos++] * 16777216 + buffer[pos++] * 65536 + buffer[pos++] * 256 + buffer[pos++];
    },
    readUInt64BE: behavior => {
      if (!buffer || pos + 7 >= buffer.length) return;
      switch (behavior) {
        case 'always':
          return BigInt(`0x${buffer.hexSlice(pos, pos += 8)}`);
        case 'maybe':
          if (buffer[pos] > 0x1F) return BigInt(`0x${buffer.hexSlice(pos, pos += 8)}`);
        // FALLTHROUGH
        default:
          return buffer[pos++] * 72057594037927940 + buffer[pos++] * 281474976710656 + buffer[pos++] * 1099511627776 + buffer[pos++] * 4294967296 + buffer[pos++] * 16777216 + buffer[pos++] * 65536 + buffer[pos++] * 256 + buffer[pos++];
      }
    },
    skip: n => {
      if (buffer && n > 0) pos += n;
    },
    skipString: () => {
      const len = self.readUInt32BE();
      if (len === undefined) return;
      pos += len;
      return pos <= buffer.length ? len : undefined;
    },
    readByte: () => {
      if (buffer && pos < buffer.length) return buffer[pos++];
    },
    readBool: () => {
      if (buffer && pos < buffer.length) return !!buffer[pos++];
    },
    readList: () => {
      const list = self.readString(true);
      if (list === undefined) return;
      return list ? list.split(',') : [];
    },
    readString: (dest, maxLen) => {
      if (typeof dest === 'number') {
        maxLen = dest;
        dest = undefined;
      }
      const len = self.readUInt32BE();
      if (len === undefined) return;
      if (buffer.length - pos < len || typeof maxLen === 'number' && len > maxLen) {
        return;
      }
      if (dest) {
        if (Buffer.isBuffer(dest)) return bufferCopy(buffer, dest, pos, pos += len);
        return buffer.utf8Slice(pos, pos += len);
      }
      return bufferSlice(buffer, pos, pos += len);
    },
    readRaw: len => {
      if (!buffer) return;
      if (typeof len !== 'number') return bufferSlice(buffer, pos, pos += buffer.length - pos);
      if (buffer.length - pos >= len) return bufferSlice(buffer, pos, pos += len);
    }
  };
  return self;
}
function makeError(msg, level, fatal) {
  const err = new Error(msg);
  if (typeof level === 'boolean') {
    fatal = level;
    err.level = 'protocol';
  } else {
    err.level = level || 'protocol';
  }
  err.fatal = !!fatal;
  return err;
}
function writeUInt32BE(buf, value, offset) {
  buf[offset++] = value >>> 24;
  buf[offset++] = value >>> 16;
  buf[offset++] = value >>> 8;
  buf[offset++] = value;
  return offset;
}
const utilBufferParser = makeBufferParser();
module.exports = {
  bufferCopy,
  bufferSlice,
  FastBuffer,
  bufferFill: (buf, value, start, end) => {
    return TypedArrayFill.call(buf, value, start, end);
  },
  makeError,
  doFatalError: (protocol, msg, level, reason) => {
    let err;
    if (DISCONNECT_REASON === undefined) ({
      DISCONNECT_REASON
    } = __webpack_require__(/*! ./constants.js */ 7816));
    if (msg instanceof Error) {
      // doFatalError(protocol, err[, reason])
      err = msg;
      if (typeof level !== 'number') reason = DISCONNECT_REASON.PROTOCOL_ERROR;else reason = level;
    } else {
      // doFatalError(protocol, msg[, level[, reason]])
      err = makeError(msg, level, true);
    }
    if (typeof reason !== 'number') reason = DISCONNECT_REASON.PROTOCOL_ERROR;
    protocol.disconnect(reason);
    protocol._destruct();
    protocol._onError(err);
    return Infinity;
  },
  readUInt32BE,
  writeUInt32BE,
  writeUInt32LE: (buf, value, offset) => {
    buf[offset++] = value;
    buf[offset++] = value >>> 8;
    buf[offset++] = value >>> 16;
    buf[offset++] = value >>> 24;
    return offset;
  },
  makeBufferParser,
  bufferParser: makeBufferParser(),
  readString: (buffer, start, dest, maxLen) => {
    if (typeof dest === 'number') {
      maxLen = dest;
      dest = undefined;
    }
    if (start === undefined) start = 0;
    const left = buffer.length - start;
    if (start < 0 || start >= buffer.length || left < 4) return;
    const len = readUInt32BE(buffer, start);
    if (left < 4 + len || typeof maxLen === 'number' && len > maxLen) return;
    start += 4;
    const end = start + len;
    buffer._pos = end;
    if (dest) {
      if (Buffer.isBuffer(dest)) return bufferCopy(buffer, dest, start, end);
      return buffer.utf8Slice(start, end);
    }
    return bufferSlice(buffer, start, end);
  },
  sigSSHToASN1: (sig, type) => {
    switch (type) {
      case 'ssh-dss':
        {
          if (sig.length > 40) return sig;
          // Change bare signature r and s values to ASN.1 BER values for OpenSSL
          const asnWriter = new Ber.Writer();
          asnWriter.startSequence();
          let r = sig.slice(0, 20);
          let s = sig.slice(20);
          if (r[0] & 0x80) {
            const rNew = Buffer.allocUnsafe(21);
            rNew[0] = 0x00;
            r.copy(rNew, 1);
            r = rNew;
          } else if (r[0] === 0x00 && !(r[1] & 0x80)) {
            r = r.slice(1);
          }
          if (s[0] & 0x80) {
            const sNew = Buffer.allocUnsafe(21);
            sNew[0] = 0x00;
            s.copy(sNew, 1);
            s = sNew;
          } else if (s[0] === 0x00 && !(s[1] & 0x80)) {
            s = s.slice(1);
          }
          asnWriter.writeBuffer(r, Ber.Integer);
          asnWriter.writeBuffer(s, Ber.Integer);
          asnWriter.endSequence();
          return asnWriter.buffer;
        }
      case 'ecdsa-sha2-nistp256':
      case 'ecdsa-sha2-nistp384':
      case 'ecdsa-sha2-nistp521':
        {
          utilBufferParser.init(sig, 0);
          const r = utilBufferParser.readString();
          const s = utilBufferParser.readString();
          utilBufferParser.clear();
          if (r === undefined || s === undefined) return;
          const asnWriter = new Ber.Writer();
          asnWriter.startSequence();
          asnWriter.writeBuffer(r, Ber.Integer);
          asnWriter.writeBuffer(s, Ber.Integer);
          asnWriter.endSequence();
          return asnWriter.buffer;
        }
      default:
        return sig;
    }
  },
  convertSignature: (signature, keyType) => {
    switch (keyType) {
      case 'ssh-dss':
        {
          if (signature.length <= 40) return signature;
          // This is a quick and dirty way to get from BER encoded r and s that
          // OpenSSL gives us, to just the bare values back to back (40 bytes
          // total) like OpenSSH (and possibly others) are expecting
          const asnReader = new Ber.Reader(signature);
          asnReader.readSequence();
          let r = asnReader.readString(Ber.Integer, true);
          let s = asnReader.readString(Ber.Integer, true);
          let rOffset = 0;
          let sOffset = 0;
          if (r.length < 20) {
            const rNew = Buffer.allocUnsafe(20);
            rNew.set(r, 1);
            r = rNew;
            r[0] = 0;
          }
          if (s.length < 20) {
            const sNew = Buffer.allocUnsafe(20);
            sNew.set(s, 1);
            s = sNew;
            s[0] = 0;
          }
          if (r.length > 20 && r[0] === 0) rOffset = 1;
          if (s.length > 20 && s[0] === 0) sOffset = 1;
          const newSig = Buffer.allocUnsafe(r.length - rOffset + (s.length - sOffset));
          bufferCopy(r, newSig, rOffset, r.length, 0);
          bufferCopy(s, newSig, sOffset, s.length, r.length - rOffset);
          return newSig;
        }
      case 'ecdsa-sha2-nistp256':
      case 'ecdsa-sha2-nistp384':
      case 'ecdsa-sha2-nistp521':
        {
          if (signature[0] === 0) return signature;
          // Convert SSH signature parameters to ASN.1 BER values for OpenSSL
          const asnReader = new Ber.Reader(signature);
          asnReader.readSequence();
          const r = asnReader.readString(Ber.Integer, true);
          const s = asnReader.readString(Ber.Integer, true);
          if (r === null || s === null) return;
          const newSig = Buffer.allocUnsafe(4 + r.length + 4 + s.length);
          writeUInt32BE(newSig, r.length, 0);
          newSig.set(r, 4);
          writeUInt32BE(newSig, s.length, 4 + r.length);
          newSig.set(s, 4 + 4 + r.length);
          return newSig;
        }
    }
    return signature;
  },
  sendPacket: (proto, packet, bypass) => {
    if (!bypass && proto._kexinit !== undefined) {
      // We're currently in the middle of a handshake

      if (proto._queue === undefined) proto._queue = [];
      proto._queue.push(packet);
      proto._debug && proto._debug('Outbound: ... packet queued');
      return false;
    }
    proto._cipher.encrypt(packet);
    return true;
  }
};

/***/ }),

/***/ 6719:
/*!*************************************************!*\
  !*** ../node_modules/ssh2/lib/protocol/zlib.js ***!
  \*************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


const {
  kMaxLength
} = __webpack_require__(/*! buffer */ 4300);
const {
  createInflate,
  constants: {
    DEFLATE,
    INFLATE,
    Z_DEFAULT_CHUNK,
    Z_DEFAULT_COMPRESSION,
    Z_DEFAULT_MEMLEVEL,
    Z_DEFAULT_STRATEGY,
    Z_DEFAULT_WINDOWBITS,
    Z_PARTIAL_FLUSH
  }
} = __webpack_require__(/*! zlib */ 9796);
const ZlibHandle = createInflate()._handle.constructor;
function processCallback() {
  throw new Error('Should not get here');
}
function zlibOnError(message, errno, code) {
  const self = this._owner;
  // There is no way to cleanly recover.
  // Continuing only obscures problems.

  const error = new Error(message);
  error.errno = errno;
  error.code = code;
  self._err = error;
}
function _close(engine) {
  // Caller may invoke .close after a zlib error (which will null _handle).
  if (!engine._handle) return;
  engine._handle.close();
  engine._handle = null;
}
class Zlib {
  constructor(mode) {
    const windowBits = Z_DEFAULT_WINDOWBITS;
    const level = Z_DEFAULT_COMPRESSION;
    const memLevel = Z_DEFAULT_MEMLEVEL;
    const strategy = Z_DEFAULT_STRATEGY;
    const dictionary = undefined;
    this._err = undefined;
    this._writeState = new Uint32Array(2);
    this._chunkSize = Z_DEFAULT_CHUNK;
    this._maxOutputLength = kMaxLength;
    this._outBuffer = Buffer.allocUnsafe(this._chunkSize);
    this._outOffset = 0;
    this._handle = new ZlibHandle(mode);
    this._handle._owner = this;
    this._handle.onerror = zlibOnError;
    this._handle.init(windowBits, level, memLevel, strategy, this._writeState, processCallback, dictionary);
  }
  writeSync(chunk, retChunks) {
    const handle = this._handle;
    if (!handle) throw new Error('Invalid Zlib instance');
    let availInBefore = chunk.length;
    let availOutBefore = this._chunkSize - this._outOffset;
    let inOff = 0;
    let availOutAfter;
    let availInAfter;
    let buffers;
    let nread = 0;
    const state = this._writeState;
    let buffer = this._outBuffer;
    let offset = this._outOffset;
    const chunkSize = this._chunkSize;
    while (true) {
      handle.writeSync(Z_PARTIAL_FLUSH, chunk,
      // in
      inOff,
      // in_off
      availInBefore,
      // in_len
      buffer,
      // out
      offset,
      // out_off
      availOutBefore); // out_len
      if (this._err) throw this._err;
      availOutAfter = state[0];
      availInAfter = state[1];
      const inDelta = availInBefore - availInAfter;
      const have = availOutBefore - availOutAfter;
      if (have > 0) {
        const out = offset === 0 && have === buffer.length ? buffer : buffer.slice(offset, offset + have);
        offset += have;
        if (!buffers) buffers = out;else if (buffers.push === undefined) buffers = [buffers, out];else buffers.push(out);
        nread += out.byteLength;
        if (nread > this._maxOutputLength) {
          _close(this);
          throw new Error(`Output length exceeded maximum of ${this._maxOutputLength}`);
        }
      } else if (have !== 0) {
        throw new Error('have should not go down');
      }

      // Exhausted the output buffer, or used all the input create a new one.
      if (availOutAfter === 0 || offset >= chunkSize) {
        availOutBefore = chunkSize;
        offset = 0;
        buffer = Buffer.allocUnsafe(chunkSize);
      }
      if (availOutAfter === 0) {
        // Not actually done. Need to reprocess.
        // Also, update the availInBefore to the availInAfter value,
        // so that if we have to hit it a third (fourth, etc.) time,
        // it'll have the correct byte counts.
        inOff += inDelta;
        availInBefore = availInAfter;
      } else {
        break;
      }
    }
    this._outBuffer = buffer;
    this._outOffset = offset;
    if (nread === 0) buffers = Buffer.alloc(0);
    if (retChunks) {
      buffers.totalLen = nread;
      return buffers;
    }
    if (buffers.push === undefined) return buffers;
    const output = Buffer.allocUnsafe(nread);
    for (let i = 0, p = 0; i < buffers.length; ++i) {
      const buf = buffers[i];
      output.set(buf, p);
      p += buf.length;
    }
    return output;
  }
}
class ZlibPacketWriter {
  constructor(protocol) {
    this.allocStart = 0;
    this.allocStartKEX = 0;
    this._protocol = protocol;
    this._zlib = new Zlib(DEFLATE);
  }
  cleanup() {
    if (this._zlib) _close(this._zlib);
  }
  alloc(payloadSize, force) {
    return Buffer.allocUnsafe(payloadSize);
  }
  finalize(payload, force) {
    if (this._protocol._kexinit === undefined || force) {
      const output = this._zlib.writeSync(payload, true);
      const packet = this._protocol._cipher.allocPacket(output.totalLen);
      if (output.push === undefined) {
        packet.set(output, 5);
      } else {
        for (let i = 0, p = 5; i < output.length; ++i) {
          const chunk = output[i];
          packet.set(chunk, p);
          p += chunk.length;
        }
      }
      return packet;
    }
    return payload;
  }
}
class PacketWriter {
  constructor(protocol) {
    this.allocStart = 5;
    this.allocStartKEX = 5;
    this._protocol = protocol;
  }
  cleanup() {}
  alloc(payloadSize, force) {
    if (this._protocol._kexinit === undefined || force) return this._protocol._cipher.allocPacket(payloadSize);
    return Buffer.allocUnsafe(payloadSize);
  }
  finalize(packet, force) {
    return packet;
  }
}
class ZlibPacketReader {
  constructor() {
    this._zlib = new Zlib(INFLATE);
  }
  cleanup() {
    if (this._zlib) _close(this._zlib);
  }
  read(data) {
    return this._zlib.writeSync(data, false);
  }
}
class PacketReader {
  cleanup() {}
  read(data) {
    return data;
  }
}
module.exports = {
  PacketReader,
  PacketWriter,
  ZlibPacketReader,
  ZlibPacketWriter
};

/***/ }),

/***/ 6313:
/*!******************************************!*\
  !*** ../node_modules/ssh2/lib/server.js ***!
  \******************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";
// TODO:
//   * convert listenerCount() usage to emit() return value checking?
//   * emit error when connection severed early (e.g. before handshake)
//   * add '.connected' or similar property to connection objects to allow
//     immediate connection status checking


const {
  Server: netServer
} = __webpack_require__(/*! net */ 1548);
const EventEmitter = __webpack_require__(/*! events */ 2361);
const {
  listenerCount
} = EventEmitter;
const {
  CHANNEL_OPEN_FAILURE,
  DEFAULT_CIPHER,
  DEFAULT_COMPRESSION,
  DEFAULT_KEX,
  DEFAULT_MAC,
  DEFAULT_SERVER_HOST_KEY,
  DISCONNECT_REASON,
  DISCONNECT_REASON_BY_VALUE,
  SUPPORTED_CIPHER,
  SUPPORTED_COMPRESSION,
  SUPPORTED_KEX,
  SUPPORTED_MAC,
  SUPPORTED_SERVER_HOST_KEY
} = __webpack_require__(/*! ./protocol/constants.js */ 7816);
const {
  init: cryptoInit
} = __webpack_require__(/*! ./protocol/crypto.js */ 6173);
const {
  KexInit
} = __webpack_require__(/*! ./protocol/kex.js */ 3027);
const {
  parseKey
} = __webpack_require__(/*! ./protocol/keyParser.js */ 9934);
const Protocol = __webpack_require__(/*! ./protocol/Protocol.js */ 1551);
const {
  SFTP
} = __webpack_require__(/*! ./protocol/SFTP.js */ 287);
const {
  writeUInt32BE
} = __webpack_require__(/*! ./protocol/utils.js */ 3549);
const {
  Channel,
  MAX_WINDOW,
  PACKET_SIZE,
  windowAdjust,
  WINDOW_THRESHOLD
} = __webpack_require__(/*! ./Channel.js */ 4165);
const {
  ChannelManager,
  generateAlgorithmList,
  isWritable,
  onChannelOpenFailure,
  onCHANNEL_CLOSE
} = __webpack_require__(/*! ./utils.js */ 7601);
const MAX_PENDING_AUTHS = 10;
class AuthContext extends EventEmitter {
  constructor(protocol, username, service, method, cb) {
    super();
    this.username = this.user = username;
    this.service = service;
    this.method = method;
    this._initialResponse = false;
    this._finalResponse = false;
    this._multistep = false;
    this._cbfinal = (allowed, methodsLeft, isPartial) => {
      if (!this._finalResponse) {
        this._finalResponse = true;
        cb(this, allowed, methodsLeft, isPartial);
      }
    };
    this._protocol = protocol;
  }
  accept() {
    this._cleanup && this._cleanup();
    this._initialResponse = true;
    this._cbfinal(true);
  }
  reject(methodsLeft, isPartial) {
    this._cleanup && this._cleanup();
    this._initialResponse = true;
    this._cbfinal(false, methodsLeft, isPartial);
  }
}
class KeyboardAuthContext extends AuthContext {
  constructor(protocol, username, service, method, submethods, cb) {
    super(protocol, username, service, method, cb);
    this._multistep = true;
    this._cb = undefined;
    this._onInfoResponse = responses => {
      const callback = this._cb;
      if (callback) {
        this._cb = undefined;
        callback(responses);
      }
    };
    this.submethods = submethods;
    this.on('abort', () => {
      this._cb && this._cb(new Error('Authentication request aborted'));
    });
  }
  prompt(prompts, title, instructions, cb) {
    if (!Array.isArray(prompts)) prompts = [prompts];
    if (typeof title === 'function') {
      cb = title;
      title = instructions = undefined;
    } else if (typeof instructions === 'function') {
      cb = instructions;
      instructions = undefined;
    } else if (typeof cb !== 'function') {
      cb = undefined;
    }
    for (let i = 0; i < prompts.length; ++i) {
      if (typeof prompts[i] === 'string') {
        prompts[i] = {
          prompt: prompts[i],
          echo: true
        };
      }
    }
    this._cb = cb;
    this._initialResponse = true;
    this._protocol.authInfoReq(title, instructions, prompts);
  }
}
class PKAuthContext extends AuthContext {
  constructor(protocol, username, service, method, pkInfo, cb) {
    super(protocol, username, service, method, cb);
    this.key = {
      algo: pkInfo.keyAlgo,
      data: pkInfo.key
    };
    this.signature = pkInfo.signature;
    this.blob = pkInfo.blob;
  }
  accept() {
    if (!this.signature) {
      this._initialResponse = true;
      this._protocol.authPKOK(this.key.algo, this.key.data);
    } else {
      AuthContext.prototype.accept.call(this);
    }
  }
}
class HostbasedAuthContext extends AuthContext {
  constructor(protocol, username, service, method, pkInfo, cb) {
    super(protocol, username, service, method, cb);
    this.key = {
      algo: pkInfo.keyAlgo,
      data: pkInfo.key
    };
    this.signature = pkInfo.signature;
    this.blob = pkInfo.blob;
    this.localHostname = pkInfo.localHostname;
    this.localUsername = pkInfo.localUsername;
  }
}
class PwdAuthContext extends AuthContext {
  constructor(protocol, username, service, method, password, cb) {
    super(protocol, username, service, method, cb);
    this.password = password;
    this._changeCb = undefined;
  }
  requestChange(prompt, cb) {
    if (this._changeCb) throw new Error('Change request already in progress');
    if (typeof prompt !== 'string') throw new Error('prompt argument must be a string');
    if (typeof cb !== 'function') throw new Error('Callback argument must be a function');
    this._changeCb = cb;
    this._protocol.authPasswdChg(prompt);
  }
}
class Session extends EventEmitter {
  constructor(client, info, localChan) {
    super();
    this.type = 'session';
    this.subtype = undefined;
    this.server = true;
    this._ending = false;
    this._channel = undefined;
    this._chanInfo = {
      type: 'session',
      incoming: {
        id: localChan,
        window: MAX_WINDOW,
        packetSize: PACKET_SIZE,
        state: 'open'
      },
      outgoing: {
        id: info.sender,
        window: info.window,
        packetSize: info.packetSize,
        state: 'open'
      }
    };
  }
}
class Server extends EventEmitter {
  constructor(cfg, listener) {
    super();
    if (typeof cfg !== 'object' || cfg === null) throw new Error('Missing configuration object');
    const hostKeys = Object.create(null);
    const hostKeyAlgoOrder = [];
    const hostKeys_ = cfg.hostKeys;
    if (!Array.isArray(hostKeys_)) throw new Error('hostKeys must be an array');
    const cfgAlgos = typeof cfg.algorithms === 'object' && cfg.algorithms !== null ? cfg.algorithms : {};
    const hostKeyAlgos = generateAlgorithmList(cfgAlgos.serverHostKey, DEFAULT_SERVER_HOST_KEY, SUPPORTED_SERVER_HOST_KEY);
    for (let i = 0; i < hostKeys_.length; ++i) {
      let privateKey;
      if (Buffer.isBuffer(hostKeys_[i]) || typeof hostKeys_[i] === 'string') privateKey = parseKey(hostKeys_[i]);else privateKey = parseKey(hostKeys_[i].key, hostKeys_[i].passphrase);
      if (privateKey instanceof Error) throw new Error(`Cannot parse privateKey: ${privateKey.message}`);
      if (Array.isArray(privateKey)) {
        // OpenSSH's newer format only stores 1 key for now
        privateKey = privateKey[0];
      }
      if (privateKey.getPrivatePEM() === null) throw new Error('privateKey value contains an invalid private key');

      // Discard key if we already found a key of the same type
      if (hostKeyAlgoOrder.includes(privateKey.type)) continue;
      if (privateKey.type === 'ssh-rsa') {
        // SSH supports multiple signature hashing algorithms for RSA, so we add
        // the algorithms in the desired order
        let sha1Pos = hostKeyAlgos.indexOf('ssh-rsa');
        const sha256Pos = hostKeyAlgos.indexOf('rsa-sha2-256');
        const sha512Pos = hostKeyAlgos.indexOf('rsa-sha2-512');
        if (sha1Pos === -1) {
          // Fall back to giving SHA1 the lowest priority
          sha1Pos = Infinity;
        }
        [sha1Pos, sha256Pos, sha512Pos].sort(compareNumbers).forEach(pos => {
          if (pos === -1) return;
          let type;
          switch (pos) {
            case sha1Pos:
              type = 'ssh-rsa';
              break;
            case sha256Pos:
              type = 'rsa-sha2-256';
              break;
            case sha512Pos:
              type = 'rsa-sha2-512';
              break;
            default:
              return;
          }

          // Store same RSA key under each hash algorithm name for convenience
          hostKeys[type] = privateKey;
          hostKeyAlgoOrder.push(type);
        });
      } else {
        hostKeys[privateKey.type] = privateKey;
        hostKeyAlgoOrder.push(privateKey.type);
      }
    }
    const algorithms = {
      kex: generateAlgorithmList(cfgAlgos.kex, DEFAULT_KEX, SUPPORTED_KEX),
      serverHostKey: hostKeyAlgoOrder,
      cs: {
        cipher: generateAlgorithmList(cfgAlgos.cipher, DEFAULT_CIPHER, SUPPORTED_CIPHER),
        mac: generateAlgorithmList(cfgAlgos.hmac, DEFAULT_MAC, SUPPORTED_MAC),
        compress: generateAlgorithmList(cfgAlgos.compress, DEFAULT_COMPRESSION, SUPPORTED_COMPRESSION),
        lang: []
      },
      sc: undefined
    };
    algorithms.sc = algorithms.cs;
    if (typeof listener === 'function') this.on('connection', listener);
    const origDebug = typeof cfg.debug === 'function' ? cfg.debug : undefined;
    const ident = cfg.ident ? Buffer.from(cfg.ident) : undefined;
    const offer = new KexInit(algorithms);
    this._srv = new netServer(socket => {
      if (this._connections >= this.maxConnections) {
        socket.destroy();
        return;
      }
      ++this._connections;
      socket.once('close', () => {
        --this._connections;
      });
      let debug;
      if (origDebug) {
        // Prepend debug output with a unique identifier in case there are
        // multiple clients connected at the same time
        const debugPrefix = `[${process.hrtime().join('.')}] `;
        debug = msg => {
          origDebug(`${debugPrefix}${msg}`);
        };
      }

      // eslint-disable-next-line no-use-before-define
      new Client(socket, hostKeys, ident, offer, debug, this, cfg);
    }).on('error', err => {
      this.emit('error', err);
    }).on('listening', () => {
      this.emit('listening');
    }).on('close', () => {
      this.emit('close');
    });
    this._connections = 0;
    this.maxConnections = Infinity;
  }
  injectSocket(socket) {
    this._srv.emit('connection', socket);
  }
  listen(...args) {
    this._srv.listen(...args);
    return this;
  }
  address() {
    return this._srv.address();
  }
  getConnections(cb) {
    this._srv.getConnections(cb);
    return this;
  }
  close(cb) {
    this._srv.close(cb);
    return this;
  }
  ref() {
    this._srv.ref();
    return this;
  }
  unref() {
    this._srv.unref();
    return this;
  }
}
Server.KEEPALIVE_CLIENT_INTERVAL = 15000;
Server.KEEPALIVE_CLIENT_COUNT_MAX = 3;
class Client extends EventEmitter {
  constructor(socket, hostKeys, ident, offer, debug, server, srvCfg) {
    super();
    let exchanges = 0;
    let acceptedAuthSvc = false;
    let pendingAuths = [];
    let authCtx;
    let kaTimer;
    let onPacket;
    const unsentGlobalRequestsReplies = [];
    this._sock = socket;
    this._chanMgr = new ChannelManager(this);
    this._debug = debug;
    this.noMoreSessions = false;
    this.authenticated = false;

    // Silence pre-header errors
    function onClientPreHeaderError(err) {}
    this.on('error', onClientPreHeaderError);
    const DEBUG_HANDLER = !debug ? undefined : (p, display, msg) => {
      debug(`Debug output from client: ${JSON.stringify(msg)}`);
    };
    const kaIntvl = typeof srvCfg.keepaliveInterval === 'number' && isFinite(srvCfg.keepaliveInterval) && srvCfg.keepaliveInterval > 0 ? srvCfg.keepaliveInterval : typeof Server.KEEPALIVE_CLIENT_INTERVAL === 'number' && isFinite(Server.KEEPALIVE_CLIENT_INTERVAL) && Server.KEEPALIVE_CLIENT_INTERVAL > 0 ? Server.KEEPALIVE_CLIENT_INTERVAL : -1;
    const kaCountMax = typeof srvCfg.keepaliveCountMax === 'number' && isFinite(srvCfg.keepaliveCountMax) && srvCfg.keepaliveCountMax >= 0 ? srvCfg.keepaliveCountMax : typeof Server.KEEPALIVE_CLIENT_COUNT_MAX === 'number' && isFinite(Server.KEEPALIVE_CLIENT_COUNT_MAX) && Server.KEEPALIVE_CLIENT_COUNT_MAX >= 0 ? Server.KEEPALIVE_CLIENT_COUNT_MAX : -1;
    let kaCurCount = 0;
    if (kaIntvl !== -1 && kaCountMax !== -1) {
      this.once('ready', () => {
        const onClose = () => {
          clearInterval(kaTimer);
        };
        this.on('close', onClose).on('end', onClose);
        kaTimer = setInterval(() => {
          if (++kaCurCount > kaCountMax) {
            clearInterval(kaTimer);
            const err = new Error('Keepalive timeout');
            err.level = 'client-timeout';
            this.emit('error', err);
            this.end();
          } else {
            // XXX: if the server ever starts sending real global requests to
            //      the client, we will need to add a dummy callback here to
            //      keep the correct reply order
            proto.ping();
          }
        }, kaIntvl);
      });
      // TODO: re-verify keepalive behavior with OpenSSH
      onPacket = () => {
        kaTimer && kaTimer.refresh();
        kaCurCount = 0;
      };
    }
    const proto = this._protocol = new Protocol({
      server: true,
      hostKeys,
      ident,
      offer,
      onPacket,
      greeting: srvCfg.greeting,
      banner: srvCfg.banner,
      onWrite: data => {
        if (isWritable(socket)) socket.write(data);
      },
      onError: err => {
        if (!proto._destruct) socket.removeAllListeners('data');
        this.emit('error', err);
        try {
          socket.end();
        } catch {}
      },
      onHeader: header => {
        this.removeListener('error', onClientPreHeaderError);
        const info = {
          ip: socket.remoteAddress,
          family: socket.remoteFamily,
          port: socket.remotePort,
          header
        };
        if (!server.emit('connection', this, info)) {
          // auto reject
          proto.disconnect(DISCONNECT_REASON.BY_APPLICATION);
          socket.end();
          return;
        }
        if (header.greeting) this.emit('greeting', header.greeting);
      },
      onHandshakeComplete: negotiated => {
        if (++exchanges > 1) this.emit('rekey');
        this.emit('handshake', negotiated);
      },
      debug,
      messageHandlers: {
        DEBUG: DEBUG_HANDLER,
        DISCONNECT: (p, reason, desc) => {
          if (reason !== DISCONNECT_REASON.BY_APPLICATION) {
            if (!desc) {
              desc = DISCONNECT_REASON_BY_VALUE[reason];
              if (desc === undefined) desc = `Unexpected disconnection reason: ${reason}`;
            }
            const err = new Error(desc);
            err.code = reason;
            this.emit('error', err);
          }
          socket.end();
        },
        CHANNEL_OPEN: (p, info) => {
          // Handle incoming requests from client

          // Do early reject in some cases to prevent wasteful channel
          // allocation
          if (info.type === 'session' && this.noMoreSessions || !this.authenticated) {
            const reasonCode = CHANNEL_OPEN_FAILURE.ADMINISTRATIVELY_PROHIBITED;
            return proto.channelOpenFail(info.sender, reasonCode);
          }
          let localChan = -1;
          let reason;
          let replied = false;
          let accept;
          const reject = () => {
            if (replied) return;
            replied = true;
            if (reason === undefined) {
              if (localChan === -1) reason = CHANNEL_OPEN_FAILURE.RESOURCE_SHORTAGE;else reason = CHANNEL_OPEN_FAILURE.CONNECT_FAILED;
            }
            if (localChan !== -1) this._chanMgr.remove(localChan);
            proto.channelOpenFail(info.sender, reason, '');
          };
          const reserveChannel = () => {
            localChan = this._chanMgr.add();
            if (localChan === -1) {
              reason = CHANNEL_OPEN_FAILURE.RESOURCE_SHORTAGE;
              if (debug) {
                debug('Automatic rejection of incoming channel open: ' + 'no channels available');
              }
            }
            return localChan !== -1;
          };
          const data = info.data;
          switch (info.type) {
            case 'session':
              if (listenerCount(this, 'session') && reserveChannel()) {
                accept = () => {
                  if (replied) return;
                  replied = true;
                  const instance = new Session(this, info, localChan);
                  this._chanMgr.update(localChan, instance);
                  proto.channelOpenConfirm(info.sender, localChan, MAX_WINDOW, PACKET_SIZE);
                  return instance;
                };
                this.emit('session', accept, reject);
                return;
              }
              break;
            case 'direct-tcpip':
              if (listenerCount(this, 'tcpip') && reserveChannel()) {
                accept = () => {
                  if (replied) return;
                  replied = true;
                  const chanInfo = {
                    type: undefined,
                    incoming: {
                      id: localChan,
                      window: MAX_WINDOW,
                      packetSize: PACKET_SIZE,
                      state: 'open'
                    },
                    outgoing: {
                      id: info.sender,
                      window: info.window,
                      packetSize: info.packetSize,
                      state: 'open'
                    }
                  };
                  const stream = new Channel(this, chanInfo, {
                    server: true
                  });
                  this._chanMgr.update(localChan, stream);
                  proto.channelOpenConfirm(info.sender, localChan, MAX_WINDOW, PACKET_SIZE);
                  return stream;
                };
                this.emit('tcpip', accept, reject, data);
                return;
              }
              break;
            case 'direct-streamlocal@openssh.com':
              if (listenerCount(this, 'openssh.streamlocal') && reserveChannel()) {
                accept = () => {
                  if (replied) return;
                  replied = true;
                  const chanInfo = {
                    type: undefined,
                    incoming: {
                      id: localChan,
                      window: MAX_WINDOW,
                      packetSize: PACKET_SIZE,
                      state: 'open'
                    },
                    outgoing: {
                      id: info.sender,
                      window: info.window,
                      packetSize: info.packetSize,
                      state: 'open'
                    }
                  };
                  const stream = new Channel(this, chanInfo, {
                    server: true
                  });
                  this._chanMgr.update(localChan, stream);
                  proto.channelOpenConfirm(info.sender, localChan, MAX_WINDOW, PACKET_SIZE);
                  return stream;
                };
                this.emit('openssh.streamlocal', accept, reject, data);
                return;
              }
              break;
            default:
              // Automatically reject any unsupported channel open requests
              reason = CHANNEL_OPEN_FAILURE.UNKNOWN_CHANNEL_TYPE;
              if (debug) {
                debug('Automatic rejection of unsupported incoming channel open' + ` type: ${info.type}`);
              }
          }
          if (reason === undefined) {
            reason = CHANNEL_OPEN_FAILURE.ADMINISTRATIVELY_PROHIBITED;
            if (debug) {
              debug('Automatic rejection of unexpected incoming channel open' + ` for: ${info.type}`);
            }
          }
          reject();
        },
        CHANNEL_OPEN_CONFIRMATION: (p, info) => {
          const channel = this._chanMgr.get(info.recipient);
          if (typeof channel !== 'function') return;
          const chanInfo = {
            type: channel.type,
            incoming: {
              id: info.recipient,
              window: MAX_WINDOW,
              packetSize: PACKET_SIZE,
              state: 'open'
            },
            outgoing: {
              id: info.sender,
              window: info.window,
              packetSize: info.packetSize,
              state: 'open'
            }
          };
          const instance = new Channel(this, chanInfo, {
            server: true
          });
          this._chanMgr.update(info.recipient, instance);
          channel(undefined, instance);
        },
        CHANNEL_OPEN_FAILURE: (p, recipient, reason, description) => {
          const channel = this._chanMgr.get(recipient);
          if (typeof channel !== 'function') return;
          const info = {
            reason,
            description
          };
          onChannelOpenFailure(this, recipient, info, channel);
        },
        CHANNEL_DATA: (p, recipient, data) => {
          let channel = this._chanMgr.get(recipient);
          if (typeof channel !== 'object' || channel === null) return;
          if (channel.constructor === Session) {
            channel = channel._channel;
            if (!channel) return;
          }

          // The remote party should not be sending us data if there is no
          // window space available ...
          // TODO: raise error on data with not enough window?
          if (channel.incoming.window === 0) return;
          channel.incoming.window -= data.length;
          if (channel.push(data) === false) {
            channel._waitChanDrain = true;
            return;
          }
          if (channel.incoming.window <= WINDOW_THRESHOLD) windowAdjust(channel);
        },
        CHANNEL_EXTENDED_DATA: (p, recipient, data, type) => {
          // NOOP -- should not be sent by client
        },
        CHANNEL_WINDOW_ADJUST: (p, recipient, amount) => {
          let channel = this._chanMgr.get(recipient);
          if (typeof channel !== 'object' || channel === null) return;
          if (channel.constructor === Session) {
            channel = channel._channel;
            if (!channel) return;
          }

          // The other side is allowing us to send `amount` more bytes of data
          channel.outgoing.window += amount;
          if (channel._waitWindow) {
            channel._waitWindow = false;
            if (channel._chunk) {
              channel._write(channel._chunk, null, channel._chunkcb);
            } else if (channel._chunkcb) {
              channel._chunkcb();
            } else if (channel._chunkErr) {
              channel.stderr._write(channel._chunkErr, null, channel._chunkcbErr);
            } else if (channel._chunkcbErr) {
              channel._chunkcbErr();
            }
          }
        },
        CHANNEL_SUCCESS: (p, recipient) => {
          let channel = this._chanMgr.get(recipient);
          if (typeof channel !== 'object' || channel === null) return;
          if (channel.constructor === Session) {
            channel = channel._channel;
            if (!channel) return;
          }
          if (channel._callbacks.length) channel._callbacks.shift()(false);
        },
        CHANNEL_FAILURE: (p, recipient) => {
          let channel = this._chanMgr.get(recipient);
          if (typeof channel !== 'object' || channel === null) return;
          if (channel.constructor === Session) {
            channel = channel._channel;
            if (!channel) return;
          }
          if (channel._callbacks.length) channel._callbacks.shift()(true);
        },
        CHANNEL_REQUEST: (p, recipient, type, wantReply, data) => {
          const session = this._chanMgr.get(recipient);
          if (typeof session !== 'object' || session === null) return;
          let replied = false;
          let accept;
          let reject;
          if (session.constructor !== Session) {
            // normal Channel instance
            if (wantReply) proto.channelFailure(session.outgoing.id);
            return;
          }
          if (wantReply) {
            // "real session" requests will have custom accept behaviors
            if (type !== 'shell' && type !== 'exec' && type !== 'subsystem') {
              accept = () => {
                if (replied || session._ending || session._channel) return;
                replied = true;
                proto.channelSuccess(session._chanInfo.outgoing.id);
              };
            }
            reject = () => {
              if (replied || session._ending || session._channel) return;
              replied = true;
              proto.channelFailure(session._chanInfo.outgoing.id);
            };
          }
          if (session._ending) {
            reject && reject();
            return;
          }
          switch (type) {
            // "pre-real session start" requests
            case 'env':
              if (listenerCount(session, 'env')) {
                session.emit('env', accept, reject, {
                  key: data.name,
                  val: data.value
                });
                return;
              }
              break;
            case 'pty-req':
              if (listenerCount(session, 'pty')) {
                session.emit('pty', accept, reject, data);
                return;
              }
              break;
            case 'window-change':
              if (listenerCount(session, 'window-change')) session.emit('window-change', accept, reject, data);else reject && reject();
              break;
            case 'x11-req':
              if (listenerCount(session, 'x11')) {
                session.emit('x11', accept, reject, data);
                return;
              }
              break;
            // "post-real session start" requests
            case 'signal':
              if (listenerCount(session, 'signal')) {
                session.emit('signal', accept, reject, {
                  name: data
                });
                return;
              }
              break;
            // XXX: is `auth-agent-req@openssh.com` really "post-real session
            // start"?
            case 'auth-agent-req@openssh.com':
              if (listenerCount(session, 'auth-agent')) {
                session.emit('auth-agent', accept, reject);
                return;
              }
              break;
            // "real session start" requests
            case 'shell':
              if (listenerCount(session, 'shell')) {
                accept = () => {
                  if (replied || session._ending || session._channel) return;
                  replied = true;
                  if (wantReply) proto.channelSuccess(session._chanInfo.outgoing.id);
                  const channel = new Channel(this, session._chanInfo, {
                    server: true
                  });
                  channel.subtype = session.subtype = type;
                  session._channel = channel;
                  return channel;
                };
                session.emit('shell', accept, reject);
                return;
              }
              break;
            case 'exec':
              if (listenerCount(session, 'exec')) {
                accept = () => {
                  if (replied || session._ending || session._channel) return;
                  replied = true;
                  if (wantReply) proto.channelSuccess(session._chanInfo.outgoing.id);
                  const channel = new Channel(this, session._chanInfo, {
                    server: true
                  });
                  channel.subtype = session.subtype = type;
                  session._channel = channel;
                  return channel;
                };
                session.emit('exec', accept, reject, {
                  command: data
                });
                return;
              }
              break;
            case 'subsystem':
              {
                let useSFTP = data === 'sftp';
                accept = () => {
                  if (replied || session._ending || session._channel) return;
                  replied = true;
                  if (wantReply) proto.channelSuccess(session._chanInfo.outgoing.id);
                  let instance;
                  if (useSFTP) {
                    instance = new SFTP(this, session._chanInfo, {
                      server: true,
                      debug
                    });
                  } else {
                    instance = new Channel(this, session._chanInfo, {
                      server: true
                    });
                    instance.subtype = session.subtype = `${type}:${data}`;
                  }
                  session._channel = instance;
                  return instance;
                };
                if (data === 'sftp') {
                  if (listenerCount(session, 'sftp')) {
                    session.emit('sftp', accept, reject);
                    return;
                  }
                  useSFTP = false;
                }
                if (listenerCount(session, 'subsystem')) {
                  session.emit('subsystem', accept, reject, {
                    name: data
                  });
                  return;
                }
                break;
              }
          }
          debug && debug(`Automatic rejection of incoming channel request: ${type}`);
          reject && reject();
        },
        CHANNEL_EOF: (p, recipient) => {
          let channel = this._chanMgr.get(recipient);
          if (typeof channel !== 'object' || channel === null) return;
          if (channel.constructor === Session) {
            if (!channel._ending) {
              channel._ending = true;
              channel.emit('eof');
              channel.emit('end');
            }
            channel = channel._channel;
            if (!channel) return;
          }
          if (channel.incoming.state !== 'open') return;
          channel.incoming.state = 'eof';
          if (channel.readable) channel.push(null);
        },
        CHANNEL_CLOSE: (p, recipient) => {
          let channel = this._chanMgr.get(recipient);
          if (typeof channel !== 'object' || channel === null) return;
          if (channel.constructor === Session) {
            channel._ending = true;
            channel.emit('close');
            channel = channel._channel;
            if (!channel) return;
          }
          onCHANNEL_CLOSE(this, recipient, channel);
        },
        // Begin service/auth-related ==========================================
        SERVICE_REQUEST: (p, service) => {
          if (exchanges === 0 || acceptedAuthSvc || this.authenticated || service !== 'ssh-userauth') {
            proto.disconnect(DISCONNECT_REASON.SERVICE_NOT_AVAILABLE);
            socket.end();
            return;
          }
          acceptedAuthSvc = true;
          proto.serviceAccept(service);
        },
        USERAUTH_REQUEST: (p, username, service, method, methodData) => {
          if (exchanges === 0 || this.authenticated || authCtx && (authCtx.username !== username || authCtx.service !== service)
          // TODO: support hostbased auth
          || method !== 'password' && method !== 'publickey' && method !== 'hostbased' && method !== 'keyboard-interactive' && method !== 'none' || pendingAuths.length === MAX_PENDING_AUTHS) {
            proto.disconnect(DISCONNECT_REASON.PROTOCOL_ERROR);
            socket.end();
            return;
          } else if (service !== 'ssh-connection') {
            proto.disconnect(DISCONNECT_REASON.SERVICE_NOT_AVAILABLE);
            socket.end();
            return;
          }
          let ctx;
          switch (method) {
            case 'keyboard-interactive':
              ctx = new KeyboardAuthContext(proto, username, service, method, methodData, onAuthDecide);
              break;
            case 'publickey':
              ctx = new PKAuthContext(proto, username, service, method, methodData, onAuthDecide);
              break;
            case 'hostbased':
              ctx = new HostbasedAuthContext(proto, username, service, method, methodData, onAuthDecide);
              break;
            case 'password':
              if (authCtx && authCtx instanceof PwdAuthContext && authCtx._changeCb) {
                const cb = authCtx._changeCb;
                authCtx._changeCb = undefined;
                cb(methodData.newPassword);
                return;
              }
              ctx = new PwdAuthContext(proto, username, service, method, methodData, onAuthDecide);
              break;
            case 'none':
              ctx = new AuthContext(proto, username, service, method, onAuthDecide);
              break;
          }
          if (authCtx) {
            if (!authCtx._initialResponse) {
              return pendingAuths.push(ctx);
            } else if (authCtx._multistep && !authCtx._finalResponse) {
              // RFC 4252 says to silently abort the current auth request if a
              // new auth request comes in before the final response from an
              // auth method that requires additional request/response exchanges
              // -- this means keyboard-interactive for now ...
              authCtx._cleanup && authCtx._cleanup();
              authCtx.emit('abort');
            }
          }
          authCtx = ctx;
          if (listenerCount(this, 'authentication')) this.emit('authentication', authCtx);else authCtx.reject();
        },
        USERAUTH_INFO_RESPONSE: (p, responses) => {
          if (authCtx && authCtx instanceof KeyboardAuthContext) authCtx._onInfoResponse(responses);
        },
        // End service/auth-related ============================================
        GLOBAL_REQUEST: (p, name, wantReply, data) => {
          const reply = {
            type: null,
            buf: null
          };
          function setReply(type, buf) {
            reply.type = type;
            reply.buf = buf;
            sendReplies();
          }
          if (wantReply) unsentGlobalRequestsReplies.push(reply);
          if ((name === 'tcpip-forward' || name === 'cancel-tcpip-forward' || name === 'no-more-sessions@openssh.com' || name === 'streamlocal-forward@openssh.com' || name === 'cancel-streamlocal-forward@openssh.com') && listenerCount(this, 'request') && this.authenticated) {
            let accept;
            let reject;
            if (wantReply) {
              let replied = false;
              accept = chosenPort => {
                if (replied) return;
                replied = true;
                let bufPort;
                if (name === 'tcpip-forward' && data.bindPort === 0 && typeof chosenPort === 'number') {
                  bufPort = Buffer.allocUnsafe(4);
                  writeUInt32BE(bufPort, chosenPort, 0);
                }
                setReply('SUCCESS', bufPort);
              };
              reject = () => {
                if (replied) return;
                replied = true;
                setReply('FAILURE');
              };
            }
            if (name === 'no-more-sessions@openssh.com') {
              this.noMoreSessions = true;
              accept && accept();
              return;
            }
            this.emit('request', accept, reject, name, data);
          } else if (wantReply) {
            setReply('FAILURE');
          }
        }
      }
    });
    socket.pause();
    cryptoInit.then(() => {
      proto.start();
      socket.on('data', data => {
        try {
          proto.parse(data, 0, data.length);
        } catch (ex) {
          this.emit('error', ex);
          try {
            if (isWritable(socket)) socket.end();
          } catch {}
        }
      });
      socket.resume();
    }).catch(err => {
      this.emit('error', err);
      try {
        if (isWritable(socket)) socket.end();
      } catch {}
    });
    socket.on('error', err => {
      err.level = 'socket';
      this.emit('error', err);
    }).once('end', () => {
      debug && debug('Socket ended');
      proto.cleanup();
      this.emit('end');
    }).once('close', () => {
      debug && debug('Socket closed');
      proto.cleanup();
      this.emit('close');
      const err = new Error('No response from server');

      // Simulate error for pending channels and close any open channels
      this._chanMgr.cleanup(err);
    });
    const onAuthDecide = (ctx, allowed, methodsLeft, isPartial) => {
      if (authCtx === ctx && !this.authenticated) {
        if (allowed) {
          authCtx = undefined;
          this.authenticated = true;
          proto.authSuccess();
          pendingAuths = [];
          this.emit('ready');
        } else {
          proto.authFailure(methodsLeft, isPartial);
          if (pendingAuths.length) {
            authCtx = pendingAuths.pop();
            if (listenerCount(this, 'authentication')) this.emit('authentication', authCtx);else authCtx.reject();
          }
        }
      }
    };
    function sendReplies() {
      while (unsentGlobalRequestsReplies.length > 0 && unsentGlobalRequestsReplies[0].type) {
        const reply = unsentGlobalRequestsReplies.shift();
        if (reply.type === 'SUCCESS') proto.requestSuccess(reply.buf);
        if (reply.type === 'FAILURE') proto.requestFailure();
      }
    }
  }
  end() {
    if (this._sock && isWritable(this._sock)) {
      this._protocol.disconnect(DISCONNECT_REASON.BY_APPLICATION);
      this._sock.end();
    }
    return this;
  }
  x11(originAddr, originPort, cb) {
    const opts = {
      originAddr,
      originPort
    };
    openChannel(this, 'x11', opts, cb);
    return this;
  }
  forwardOut(boundAddr, boundPort, remoteAddr, remotePort, cb) {
    const opts = {
      boundAddr,
      boundPort,
      remoteAddr,
      remotePort
    };
    openChannel(this, 'forwarded-tcpip', opts, cb);
    return this;
  }
  openssh_forwardOutStreamLocal(socketPath, cb) {
    const opts = {
      socketPath
    };
    openChannel(this, 'forwarded-streamlocal@openssh.com', opts, cb);
    return this;
  }
  rekey(cb) {
    let error;
    try {
      this._protocol.rekey();
    } catch (ex) {
      error = ex;
    }

    // TODO: re-throw error if no callback?

    if (typeof cb === 'function') {
      if (error) process.nextTick(cb, error);else this.once('rekey', cb);
    }
  }
}
function openChannel(self, type, opts, cb) {
  // Ask the client to open a channel for some purpose (e.g. a forwarded TCP
  // connection)
  const initWindow = MAX_WINDOW;
  const maxPacket = PACKET_SIZE;
  if (typeof opts === 'function') {
    cb = opts;
    opts = {};
  }
  const wrapper = (err, stream) => {
    cb(err, stream);
  };
  wrapper.type = type;
  const localChan = self._chanMgr.add(wrapper);
  if (localChan === -1) {
    cb(new Error('No free channels available'));
    return;
  }
  switch (type) {
    case 'forwarded-tcpip':
      self._protocol.forwardedTcpip(localChan, initWindow, maxPacket, opts);
      break;
    case 'x11':
      self._protocol.x11(localChan, initWindow, maxPacket, opts);
      break;
    case 'forwarded-streamlocal@openssh.com':
      self._protocol.openssh_forwardedStreamLocal(localChan, initWindow, maxPacket, opts);
      break;
    default:
      throw new Error(`Unsupported channel type: ${type}`);
  }
}
function compareNumbers(a, b) {
  return a - b;
}
module.exports = Server;
module.exports.IncomingClient = Client;

/***/ }),

/***/ 7601:
/*!*****************************************!*\
  !*** ../node_modules/ssh2/lib/utils.js ***!
  \*****************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


const {
  SFTP
} = __webpack_require__(/*! ./protocol/SFTP.js */ 287);
const MAX_CHANNEL = 2 ** 32 - 1;
function onChannelOpenFailure(self, recipient, info, cb) {
  self._chanMgr.remove(recipient);
  if (typeof cb !== 'function') return;
  let err;
  if (info instanceof Error) {
    err = info;
  } else if (typeof info === 'object' && info !== null) {
    err = new Error(`(SSH) Channel open failure: ${info.description}`);
    err.reason = info.reason;
  } else {
    err = new Error('(SSH) Channel open failure: server closed channel unexpectedly');
    err.reason = '';
  }
  cb(err);
}
function onCHANNEL_CLOSE(self, recipient, channel, err, dead) {
  if (typeof channel === 'function') {
    // We got CHANNEL_CLOSE instead of CHANNEL_OPEN_FAILURE when
    // requesting to open a channel
    onChannelOpenFailure(self, recipient, err, channel);
    return;
  }
  if (typeof channel !== 'object' || channel === null) return;
  if (channel.incoming && channel.incoming.state === 'closed') return;
  self._chanMgr.remove(recipient);
  if (channel.server && channel.constructor.name === 'Session') return;
  channel.incoming.state = 'closed';
  if (channel.readable) channel.push(null);
  if (channel.server) {
    if (channel.stderr.writable) channel.stderr.end();
  } else if (channel.stderr.readable) {
    channel.stderr.push(null);
  }
  if (channel.constructor !== SFTP && (channel.outgoing.state === 'open' || channel.outgoing.state === 'eof') && !dead) {
    channel.close();
  }
  if (channel.outgoing.state === 'closing') channel.outgoing.state = 'closed';
  const readState = channel._readableState;
  const writeState = channel._writableState;
  if (writeState && !writeState.ending && !writeState.finished && !dead) channel.end();

  // Take care of any outstanding channel requests
  const chanCallbacks = channel._callbacks;
  channel._callbacks = [];
  for (let i = 0; i < chanCallbacks.length; ++i) chanCallbacks[i](true);
  if (channel.server) {
    if (!channel.readable || channel.destroyed || readState && readState.endEmitted) {
      channel.emit('close');
    } else {
      channel.once('end', () => channel.emit('close'));
    }
  } else {
    let doClose;
    switch (channel.type) {
      case 'direct-streamlocal@openssh.com':
      case 'direct-tcpip':
        doClose = () => channel.emit('close');
        break;
      default:
        {
          // Align more with node child processes, where the close event gets
          // the same arguments as the exit event
          const exit = channel._exit;
          doClose = () => {
            if (exit.code === null) channel.emit('close', exit.code, exit.signal, exit.dump, exit.desc);else channel.emit('close', exit.code);
          };
        }
    }
    if (!channel.readable || channel.destroyed || readState && readState.endEmitted) {
      doClose();
    } else {
      channel.once('end', doClose);
    }
    const errReadState = channel.stderr._readableState;
    if (!channel.stderr.readable || channel.stderr.destroyed || errReadState && errReadState.endEmitted) {
      channel.stderr.emit('close');
    } else {
      channel.stderr.once('end', () => channel.stderr.emit('close'));
    }
  }
}
class ChannelManager {
  constructor(client) {
    this._client = client;
    this._channels = {};
    this._cur = -1;
    this._count = 0;
  }
  add(val) {
    // Attempt to reserve an id

    let id;
    // Optimized paths
    if (this._cur < MAX_CHANNEL) {
      id = ++this._cur;
    } else if (this._count === 0) {
      // Revert and reset back to fast path once we no longer have any channels
      // open
      this._cur = 0;
      id = 0;
    } else {
      // Slower lookup path

      // This path is triggered we have opened at least MAX_CHANNEL channels
      // while having at least one channel open at any given time, so we have
      // to search for a free id.
      const channels = this._channels;
      for (let i = 0; i < MAX_CHANNEL; ++i) {
        if (channels[i] === undefined) {
          id = i;
          break;
        }
      }
    }
    if (id === undefined) return -1;
    this._channels[id] = val || true;
    ++this._count;
    return id;
  }
  update(id, val) {
    if (typeof id !== 'number' || id < 0 || id >= MAX_CHANNEL || !isFinite(id)) throw new Error(`Invalid channel id: ${id}`);
    if (val && this._channels[id]) this._channels[id] = val;
  }
  get(id) {
    if (typeof id !== 'number' || id < 0 || id >= MAX_CHANNEL || !isFinite(id)) throw new Error(`Invalid channel id: ${id}`);
    return this._channels[id];
  }
  remove(id) {
    if (typeof id !== 'number' || id < 0 || id >= MAX_CHANNEL || !isFinite(id)) throw new Error(`Invalid channel id: ${id}`);
    if (this._channels[id]) {
      delete this._channels[id];
      if (this._count) --this._count;
    }
  }
  cleanup(err) {
    const channels = this._channels;
    this._channels = {};
    this._cur = -1;
    this._count = 0;
    const chanIDs = Object.keys(channels);
    const client = this._client;
    for (let i = 0; i < chanIDs.length; ++i) {
      const id = +chanIDs[i];
      const channel = channels[id];
      onCHANNEL_CLOSE(client, id, channel._channel || channel, err, true);
    }
  }
}
const isRegExp = (() => {
  const toString = Object.prototype.toString;
  return val => toString.call(val) === '[object RegExp]';
})();
function generateAlgorithmList(algoList, defaultList, supportedList) {
  if (Array.isArray(algoList) && algoList.length > 0) {
    // Exact list
    for (let i = 0; i < algoList.length; ++i) {
      if (supportedList.indexOf(algoList[i]) === -1) throw new Error(`Unsupported algorithm: ${algoList[i]}`);
    }
    return algoList;
  }
  if (typeof algoList === 'object' && algoList !== null) {
    // Operations based on the default list
    const keys = Object.keys(algoList);
    let list = defaultList;
    for (let i = 0; i < keys.length; ++i) {
      const key = keys[i];
      let val = algoList[key];
      switch (key) {
        case 'append':
          if (!Array.isArray(val)) val = [val];
          if (Array.isArray(val)) {
            for (let j = 0; j < val.length; ++j) {
              const append = val[j];
              if (typeof append === 'string') {
                if (!append || list.indexOf(append) !== -1) continue;
                if (supportedList.indexOf(append) === -1) throw new Error(`Unsupported algorithm: ${append}`);
                if (list === defaultList) list = list.slice();
                list.push(append);
              } else if (isRegExp(append)) {
                for (let k = 0; k < supportedList.length; ++k) {
                  const algo = supportedList[k];
                  if (append.test(algo)) {
                    if (list.indexOf(algo) !== -1) continue;
                    if (list === defaultList) list = list.slice();
                    list.push(algo);
                  }
                }
              }
            }
          }
          break;
        case 'prepend':
          if (!Array.isArray(val)) val = [val];
          if (Array.isArray(val)) {
            for (let j = val.length; j >= 0; --j) {
              const prepend = val[j];
              if (typeof prepend === 'string') {
                if (!prepend || list.indexOf(prepend) !== -1) continue;
                if (supportedList.indexOf(prepend) === -1) throw new Error(`Unsupported algorithm: ${prepend}`);
                if (list === defaultList) list = list.slice();
                list.unshift(prepend);
              } else if (isRegExp(prepend)) {
                for (let k = supportedList.length; k >= 0; --k) {
                  const algo = supportedList[k];
                  if (prepend.test(algo)) {
                    if (list.indexOf(algo) !== -1) continue;
                    if (list === defaultList) list = list.slice();
                    list.unshift(algo);
                  }
                }
              }
            }
          }
          break;
        case 'remove':
          if (!Array.isArray(val)) val = [val];
          if (Array.isArray(val)) {
            for (let j = 0; j < val.length; ++j) {
              const search = val[j];
              if (typeof search === 'string') {
                if (!search) continue;
                const idx = list.indexOf(search);
                if (idx === -1) continue;
                if (list === defaultList) list = list.slice();
                list.splice(idx, 1);
              } else if (isRegExp(search)) {
                for (let k = 0; k < list.length; ++k) {
                  if (search.test(list[k])) {
                    if (list === defaultList) list = list.slice();
                    list.splice(k, 1);
                    --k;
                  }
                }
              }
            }
          }
          break;
      }
    }
    return list;
  }
  return defaultList;
}
module.exports = {
  ChannelManager,
  generateAlgorithmList,
  onChannelOpenFailure,
  onCHANNEL_CLOSE,
  isWritable: stream => {
    // XXX: hack to workaround regression in node
    // See: https://github.com/nodejs/node/issues/36029
    return stream && stream.writable && stream._readableState && stream._readableState.ended === false;
  }
};

/***/ }),

/***/ 8635:
/*!***********************************************!*\
  !*** ../node_modules/thenby/thenBy.module.js ***!
  \***********************************************/
/***/ ((module) => {

/***
   Copyright 2013 Teun Duynstee

   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.
*/
module.exports = function () {
  function identity(v) {
    return v;
  }
  function ignoreCase(v) {
    return typeof v === "string" ? v.toLowerCase() : v;
  }
  function makeCompareFunction(f, opt) {
    opt = typeof opt === "object" ? opt : {
      direction: opt
    };
    if (typeof f != "function") {
      var prop = f;
      // make unary function
      f = function (v1) {
        return !!v1[prop] ? v1[prop] : "";
      };
    }
    if (f.length === 1) {
      // f is a unary function mapping a single item to its sort score
      var uf = f;
      var preprocess = opt.ignoreCase ? ignoreCase : identity;
      var cmp = opt.cmp || function (v1, v2) {
        return v1 < v2 ? -1 : v1 > v2 ? 1 : 0;
      };
      f = function (v1, v2) {
        return cmp(preprocess(uf(v1)), preprocess(uf(v2)));
      };
    }
    const descTokens = {
      "-1": '',
      desc: ''
    };
    if (opt.direction in descTokens) return function (v1, v2) {
      return -f(v1, v2);
    };
    return f;
  }

  /* adds a secondary compare function to the target function (`this` context)
     which is applied in case the first one returns 0 (equal)
     returns a new compare function, which has a `thenBy` method as well */
  function tb(func, opt) {
    /* should get value false for the first call. This can be done by calling the 
    exported function, or the firstBy property on it (for es6 module compatibility)
    */
    var x = typeof this == "function" && !this.firstBy ? this : false;
    var y = makeCompareFunction(func, opt);
    var f = x ? function (a, b) {
      return x(a, b) || y(a, b);
    } : y;
    f.thenBy = tb;
    return f;
  }
  tb.firstBy = tb;
  return tb;
}();

/***/ }),

/***/ 4596:
/*!*******************************************!*\
  !*** ./node_modules/ansi-colors/index.js ***!
  \*******************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


const isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);

/* eslint-disable no-control-regex */
// this is a modified version of https://github.com/chalk/ansi-regex (MIT License)
const ANSI_REGEX = /[\u001b\u009b][[\]#;?()]*(?:(?:(?:[^\W_]*;?[^\W_]*)\u0007)|(?:(?:[0-9]{1,4}(;[0-9]{0,4})*)?[~0-9=<>cf-nqrtyA-PRZ]))/g;
const hasColor = () => {
  if (typeof process !== 'undefined') {
    return process.env.FORCE_COLOR !== '0';
  }
  return false;
};
const create = () => {
  const colors = {
    enabled: hasColor(),
    visible: true,
    styles: {},
    keys: {}
  };
  const ansi = style => {
    let open = style.open = `\u001b[${style.codes[0]}m`;
    let close = style.close = `\u001b[${style.codes[1]}m`;
    let regex = style.regex = new RegExp(`\\u001b\\[${style.codes[1]}m`, 'g');
    style.wrap = (input, newline) => {
      if (input.includes(close)) input = input.replace(regex, close + open);
      let output = open + input + close;
      // see https://github.com/chalk/chalk/pull/92, thanks to the
      // chalk contributors for this fix. However, we've confirmed that
      // this issue is also present in Windows terminals
      return newline ? output.replace(/\r*\n/g, `${close}$&${open}`) : output;
    };
    return style;
  };
  const wrap = (style, input, newline) => {
    return typeof style === 'function' ? style(input) : style.wrap(input, newline);
  };
  const style = (input, stack) => {
    if (input === '' || input == null) return '';
    if (colors.enabled === false) return input;
    if (colors.visible === false) return '';
    let str = '' + input;
    let nl = str.includes('\n');
    let n = stack.length;
    if (n > 0 && stack.includes('unstyle')) {
      stack = [...new Set(['unstyle', ...stack])].reverse();
    }
    while (n-- > 0) str = wrap(colors.styles[stack[n]], str, nl);
    return str;
  };
  const define = (name, codes, type) => {
    colors.styles[name] = ansi({
      name,
      codes
    });
    let keys = colors.keys[type] || (colors.keys[type] = []);
    keys.push(name);
    Reflect.defineProperty(colors, name, {
      configurable: true,
      enumerable: true,
      set(value) {
        colors.alias(name, value);
      },
      get() {
        let color = input => style(input, color.stack);
        Reflect.setPrototypeOf(color, colors);
        color.stack = this.stack ? this.stack.concat(name) : [name];
        return color;
      }
    });
  };
  define('reset', [0, 0], 'modifier');
  define('bold', [1, 22], 'modifier');
  define('dim', [2, 22], 'modifier');
  define('italic', [3, 23], 'modifier');
  define('underline', [4, 24], 'modifier');
  define('inverse', [7, 27], 'modifier');
  define('hidden', [8, 28], 'modifier');
  define('strikethrough', [9, 29], 'modifier');
  define('black', [30, 39], 'color');
  define('red', [31, 39], 'color');
  define('green', [32, 39], 'color');
  define('yellow', [33, 39], 'color');
  define('blue', [34, 39], 'color');
  define('magenta', [35, 39], 'color');
  define('cyan', [36, 39], 'color');
  define('white', [37, 39], 'color');
  define('gray', [90, 39], 'color');
  define('grey', [90, 39], 'color');
  define('bgBlack', [40, 49], 'bg');
  define('bgRed', [41, 49], 'bg');
  define('bgGreen', [42, 49], 'bg');
  define('bgYellow', [43, 49], 'bg');
  define('bgBlue', [44, 49], 'bg');
  define('bgMagenta', [45, 49], 'bg');
  define('bgCyan', [46, 49], 'bg');
  define('bgWhite', [47, 49], 'bg');
  define('blackBright', [90, 39], 'bright');
  define('redBright', [91, 39], 'bright');
  define('greenBright', [92, 39], 'bright');
  define('yellowBright', [93, 39], 'bright');
  define('blueBright', [94, 39], 'bright');
  define('magentaBright', [95, 39], 'bright');
  define('cyanBright', [96, 39], 'bright');
  define('whiteBright', [97, 39], 'bright');
  define('bgBlackBright', [100, 49], 'bgBright');
  define('bgRedBright', [101, 49], 'bgBright');
  define('bgGreenBright', [102, 49], 'bgBright');
  define('bgYellowBright', [103, 49], 'bgBright');
  define('bgBlueBright', [104, 49], 'bgBright');
  define('bgMagentaBright', [105, 49], 'bgBright');
  define('bgCyanBright', [106, 49], 'bgBright');
  define('bgWhiteBright', [107, 49], 'bgBright');
  colors.ansiRegex = ANSI_REGEX;
  colors.hasColor = colors.hasAnsi = str => {
    colors.ansiRegex.lastIndex = 0;
    return typeof str === 'string' && str !== '' && colors.ansiRegex.test(str);
  };
  colors.alias = (name, color) => {
    let fn = typeof color === 'string' ? colors[color] : color;
    if (typeof fn !== 'function') {
      throw new TypeError('Expected alias to be the name of an existing color (string) or a function');
    }
    if (!fn.stack) {
      Reflect.defineProperty(fn, 'name', {
        value: name
      });
      colors.styles[name] = fn;
      fn.stack = [name];
    }
    Reflect.defineProperty(colors, name, {
      configurable: true,
      enumerable: true,
      set(value) {
        colors.alias(name, value);
      },
      get() {
        let color = input => style(input, color.stack);
        Reflect.setPrototypeOf(color, colors);
        color.stack = this.stack ? this.stack.concat(fn.stack) : fn.stack;
        return color;
      }
    });
  };
  colors.theme = custom => {
    if (!isObject(custom)) throw new TypeError('Expected theme to be an object');
    for (let name of Object.keys(custom)) {
      colors.alias(name, custom[name]);
    }
    return colors;
  };
  colors.alias('unstyle', str => {
    if (typeof str === 'string' && str !== '') {
      colors.ansiRegex.lastIndex = 0;
      return str.replace(colors.ansiRegex, '');
    }
    return '';
  });
  colors.alias('noop', str => str);
  colors.none = colors.clear = colors.noop;
  colors.stripColor = colors.unstyle;
  colors.symbols = __webpack_require__(/*! ./symbols */ 3569);
  colors.define = define;
  return colors;
};
module.exports = create();
module.exports.create = create;

/***/ }),

/***/ 3569:
/*!*********************************************!*\
  !*** ./node_modules/ansi-colors/symbols.js ***!
  \*********************************************/
/***/ ((module) => {

"use strict";


const isHyper = typeof process !== 'undefined' && process.env.TERM_PROGRAM === 'Hyper';
const isWindows = typeof process !== 'undefined' && process.platform === 'win32';
const isLinux = typeof process !== 'undefined' && process.platform === 'linux';
const common = {
  ballotDisabled: '☒',
  ballotOff: '☐',
  ballotOn: '☑',
  bullet: '•',
  bulletWhite: '◦',
  fullBlock: '█',
  heart: '❤',
  identicalTo: '≡',
  line: '─',
  mark: '※',
  middot: '·',
  minus: '－',
  multiplication: '×',
  obelus: '÷',
  pencilDownRight: '✎',
  pencilRight: '✏',
  pencilUpRight: '✐',
  percent: '%',
  pilcrow2: '❡',
  pilcrow: '¶',
  plusMinus: '±',
  question: '?',
  section: '§',
  starsOff: '☆',
  starsOn: '★',
  upDownArrow: '↕'
};
const windows = Object.assign({}, common, {
  check: '√',
  cross: '×',
  ellipsisLarge: '...',
  ellipsis: '...',
  info: 'i',
  questionSmall: '?',
  pointer: '>',
  pointerSmall: '»',
  radioOff: '( )',
  radioOn: '(*)',
  warning: '‼'
});
const other = Object.assign({}, common, {
  ballotCross: '✘',
  check: '✔',
  cross: '✖',
  ellipsisLarge: '⋯',
  ellipsis: '…',
  info: 'ℹ',
  questionFull: '？',
  questionSmall: '﹖',
  pointer: isLinux ? '▸' : '❯',
  pointerSmall: isLinux ? '‣' : '›',
  radioOff: '◯',
  radioOn: '◉',
  warning: '⚠'
});
module.exports = isWindows && !isHyper ? windows : other;
Reflect.defineProperty(module.exports, 'common', {
  enumerable: false,
  value: common
});
Reflect.defineProperty(module.exports, 'windows', {
  enumerable: false,
  value: windows
});
Reflect.defineProperty(module.exports, 'other', {
  enumerable: false,
  value: other
});

/***/ }),

/***/ 4880:
/*!*********************************************!*\
  !*** ./node_modules/asn1/lib/ber/errors.js ***!
  \*********************************************/
/***/ ((module) => {

// Copyright 2011 Mark Cavage <mcavage@gmail.com> All rights reserved.

module.exports = {
  newInvalidAsn1Error: function (msg) {
    var e = new Error();
    e.name = 'InvalidAsn1Error';
    e.message = msg || '';
    return e;
  }
};

/***/ }),

/***/ 7951:
/*!********************************************!*\
  !*** ./node_modules/asn1/lib/ber/index.js ***!
  \********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// Copyright 2011 Mark Cavage <mcavage@gmail.com> All rights reserved.

var errors = __webpack_require__(/*! ./errors */ 4880);
var types = __webpack_require__(/*! ./types */ 5898);
var Reader = __webpack_require__(/*! ./reader */ 7089);
var Writer = __webpack_require__(/*! ./writer */ 1836);

// --- Exports

module.exports = {
  Reader: Reader,
  Writer: Writer
};
for (var t in types) {
  if (types.hasOwnProperty(t)) module.exports[t] = types[t];
}
for (var e in errors) {
  if (errors.hasOwnProperty(e)) module.exports[e] = errors[e];
}

/***/ }),

/***/ 7089:
/*!*********************************************!*\
  !*** ./node_modules/asn1/lib/ber/reader.js ***!
  \*********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// Copyright 2011 Mark Cavage <mcavage@gmail.com> All rights reserved.

var assert = __webpack_require__(/*! assert */ 9491);
var Buffer = (__webpack_require__(/*! safer-buffer */ 3745).Buffer);
var ASN1 = __webpack_require__(/*! ./types */ 5898);
var errors = __webpack_require__(/*! ./errors */ 4880);

// --- Globals

var newInvalidAsn1Error = errors.newInvalidAsn1Error;

// --- API

function Reader(data) {
  if (!data || !Buffer.isBuffer(data)) throw new TypeError('data must be a node Buffer');
  this._buf = data;
  this._size = data.length;

  // These hold the "current" state
  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);
  }
});

/**
 * Reads a single byte and advances offset; you can pass in `true` to make this
 * a "peek" operation (i.e., get the byte, but don't advance the offset).
 *
 * @param {Boolean} peek true means don't move offset.
 * @return {Number} the next byte, null if not enough data.
 */
Reader.prototype.readByte = function (peek) {
  if (this._size - this._offset < 1) return null;
  var b = this._buf[this._offset] & 0xff;
  if (!peek) this._offset += 1;
  return b;
};
Reader.prototype.peek = function () {
  return this.readByte(true);
};

/**
 * Reads a (potentially) variable length off the BER buffer.  This call is
 * not really meant to be called directly, as callers have to manipulate
 * the internal buffer afterwards.
 *
 * As a result of this call, you can call `Reader.length`, until the
 * next thing called that does a readLength.
 *
 * @return {Number} the amount of offset to advance the buffer.
 * @throws {InvalidAsn1Error} on bad ASN.1
 */
Reader.prototype.readLength = function (offset) {
  if (offset === undefined) offset = this._offset;
  if (offset >= this._size) return null;
  var lenB = this._buf[offset++] & 0xff;
  if (lenB === null) return null;
  if ((lenB & 0x80) === 0x80) {
    lenB &= 0x7f;
    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 i = 0; i < lenB; i++) this._len = (this._len << 8) + (this._buf[offset++] & 0xff);
  } else {
    // Wasn't a variable length
    this._len = lenB;
  }
  return offset;
};

/**
 * Parses the next sequence in this BER buffer.
 *
 * To get the length of the sequence, call `Reader.length`.
 *
 * @return {Number} the sequence's tag.
 */
Reader.prototype.readSequence = function (tag) {
  var seq = this.peek();
  if (seq === null) return null;
  if (tag !== undefined && tag !== seq) throw newInvalidAsn1Error('Expected 0x' + tag.toString(16) + ': got 0x' + seq.toString(16));
  var o = this.readLength(this._offset + 1); // stored in `length`
  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 b = this.peek();
  if (b === null) return null;
  if (b !== tag) throw newInvalidAsn1Error('Expected 0x' + tag.toString(16) + ': got 0x' + b.toString(16));
  var o = this.readLength(this._offset + 1); // stored in `length`

  if (o === null) return null;
  if (this.length > this._size - o) return null;
  this._offset = o;
  if (this.length === 0) return retbuf ? Buffer.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 b = this.readString(tag, true);
  if (b === null) return null;
  var values = [];
  var value = 0;
  for (var i = 0; i < b.length; i++) {
    var byte = b[i] & 0xff;
    value <<= 7;
    value += byte & 0x7f;
    if ((byte & 0x80) === 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 !== undefined);
  var b = this.peek();
  if (b === null) return null;
  if (b !== tag) throw newInvalidAsn1Error('Expected 0x' + tag.toString(16) + ': got 0x' + b.toString(16));
  var o = this.readLength(this._offset + 1); // stored in `length`
  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 i = 0; i < this.length; i++) {
    value <<= 8;
    value |= this._buf[this._offset++] & 0xff;
  }
  if ((fb & 0x80) === 0x80 && i !== 4) value -= 1 << i * 8;
  return value >> 0;
};

// --- Exported API

module.exports = Reader;

/***/ }),

/***/ 5898:
/*!********************************************!*\
  !*** ./node_modules/asn1/lib/ber/types.js ***!
  \********************************************/
/***/ ((module) => {

// Copyright 2011 Mark Cavage <mcavage@gmail.com> All rights reserved.

module.exports = {
  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
};

/***/ }),

/***/ 1836:
/*!*********************************************!*\
  !*** ./node_modules/asn1/lib/ber/writer.js ***!
  \*********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// Copyright 2011 Mark Cavage <mcavage@gmail.com> All rights reserved.

var assert = __webpack_require__(/*! assert */ 9491);
var Buffer = (__webpack_require__(/*! safer-buffer */ 3745).Buffer);
var ASN1 = __webpack_require__(/*! ./types */ 5898);
var errors = __webpack_require__(/*! ./errors */ 4880);

// --- Globals

var newInvalidAsn1Error = errors.newInvalidAsn1Error;
var DEFAULT_OPTS = {
  size: 1024,
  growthFactor: 8
};

// --- Helpers

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 (key) {
    if (to[key]) return;
    var value = Object.getOwnPropertyDescriptor(from, key);
    Object.defineProperty(to, key, value);
  });
  return to;
}

// --- API

function Writer(options) {
  options = merge(DEFAULT_OPTS, options || {});
  this._buf = Buffer.alloc(options.size || 1024);
  this._size = this._buf.length;
  this._offset = 0;
  this._options = options;

  // A list of offsets in the buffer where we need to insert
  // sequence tag/len pairs.
  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 (b) {
  if (typeof b !== 'number') throw new TypeError('argument must be a Number');
  this._ensure(1);
  this._buf[this._offset++] = b;
};
Writer.prototype.writeInt = function (i, tag) {
  if (typeof i !== 'number') throw new TypeError('argument must be a Number');
  if (typeof tag !== 'number') tag = ASN1.Integer;
  var sz = 4;
  while (((i & 0xff800000) === 0 || (i & 0xff800000) === 0xff800000 >> 0) && sz > 1) {
    sz--;
    i <<= 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++] = (i & 0xff000000) >>> 24;
    i <<= 8;
  }
};
Writer.prototype.writeNull = function () {
  this.writeByte(ASN1.Null);
  this.writeByte(0x00);
};
Writer.prototype.writeEnumeration = function (i, tag) {
  if (typeof i !== 'number') throw new TypeError('argument must be a Number');
  if (typeof tag !== 'number') tag = ASN1.Enumeration;
  return this.writeInt(i, tag);
};
Writer.prototype.writeBoolean = function (b, tag) {
  if (typeof b !== '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++] = 0x01;
  this._buf[this._offset++] = b ? 0xff : 0x00;
};
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 = Buffer.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 (!Buffer.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 self = this;
  strings.forEach(function (s) {
    self.writeString(s);
  });
};

// This is really to solve DER cases, but whatever for now
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(bytes, octet) {
    if (octet < 128) {
      bytes.push(octet);
    } else if (octet < 16384) {
      bytes.push(octet >>> 7 | 0x80);
      bytes.push(octet & 0x7F);
    } else if (octet < 2097152) {
      bytes.push(octet >>> 14 | 0x80);
      bytes.push((octet >>> 7 | 0x80) & 0xFF);
      bytes.push(octet & 0x7F);
    } else if (octet < 268435456) {
      bytes.push(octet >>> 21 | 0x80);
      bytes.push((octet >>> 14 | 0x80) & 0xFF);
      bytes.push((octet >>> 7 | 0x80) & 0xFF);
      bytes.push(octet & 0x7F);
    } else {
      bytes.push((octet >>> 28 | 0x80) & 0xFF);
      bytes.push((octet >>> 21 | 0x80) & 0xFF);
      bytes.push((octet >>> 14 | 0x80) & 0xFF);
      bytes.push((octet >>> 7 | 0x80) & 0xFF);
      bytes.push(octet & 0x7F);
    }
  }
  var tmp = s.split('.');
  var bytes = [];
  bytes.push(parseInt(tmp[0], 10) * 40 + parseInt(tmp[1], 10));
  tmp.slice(2).forEach(function (b) {
    encodeOctet(bytes, parseInt(b, 10));
  });
  var self = this;
  this._ensure(2 + bytes.length);
  this.writeByte(tag);
  this.writeLength(bytes.length);
  bytes.forEach(function (b) {
    self.writeByte(b);
  });
};
Writer.prototype.writeLength = function (len) {
  if (typeof len !== 'number') throw new TypeError('argument must be a Number');
  this._ensure(4);
  if (len <= 0x7f) {
    this._buf[this._offset++] = len;
  } else if (len <= 0xff) {
    this._buf[this._offset++] = 0x81;
    this._buf[this._offset++] = len;
  } else if (len <= 0xffff) {
    this._buf[this._offset++] = 0x82;
    this._buf[this._offset++] = len >> 8;
    this._buf[this._offset++] = len;
  } else if (len <= 0xffffff) {
    this._buf[this._offset++] = 0x83;
    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 <= 0x7f) {
    this._shift(start, len, -2);
    this._buf[seq] = len;
  } else if (len <= 0xff) {
    this._shift(start, len, -1);
    this._buf[seq] = 0x81;
    this._buf[seq + 1] = len;
  } else if (len <= 0xffff) {
    this._buf[seq] = 0x82;
    this._buf[seq + 1] = len >> 8;
    this._buf[seq + 2] = len;
  } else if (len <= 0xffffff) {
    this._shift(start, len, 1);
    this._buf[seq] = 0x83;
    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 !== undefined);
  assert.ok(len !== undefined);
  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 = Buffer.alloc(sz);
    this._buf.copy(buf, 0, 0, this._offset);
    this._buf = buf;
    this._size = sz;
  }
};

// --- Exported API

module.exports = Writer;

/***/ }),

/***/ 5593:
/*!****************************************!*\
  !*** ./node_modules/asn1/lib/index.js ***!
  \****************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// Copyright 2011 Mark Cavage <mcavage@gmail.com> All rights reserved.

// If you have no idea what ASN.1 or BER is, see this:
// ftp://ftp.rsa.com/pub/pkcs/ascii/layman.asc

var Ber = __webpack_require__(/*! ./ber/index */ 7951);

// --- Exported API

module.exports = {
  Ber: Ber,
  BerReader: Ber.Reader,
  BerWriter: Ber.Writer
};

/***/ }),

/***/ 1095:
/*!********************************************!*\
  !*** ./node_modules/assert-plus/assert.js ***!
  \********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// Copyright (c) 2012, Mark Cavage. All rights reserved.
// Copyright 2015 Joyent, Inc.

var assert = __webpack_require__(/*! assert */ 9491);
var Stream = (__webpack_require__(/*! stream */ 3978).Stream);
var util = __webpack_require__(/*! util */ 3837);

///--- Globals

/* JSSTYLED */
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}$/;

///--- Internal

function _capitalize(str) {
  return str.charAt(0).toUpperCase() + str.slice(1);
}
function _toss(name, expected, oper, arg, actual) {
  throw new assert.AssertionError({
    message: util.format('%s (%s) is required', name, expected),
    actual: actual === undefined ? typeof arg : actual(arg),
    expected: expected,
    operator: oper || '===',
    stackStartFunction: _toss.caller
  });
}
function _getClass(arg) {
  return Object.prototype.toString.call(arg).slice(8, -1);
}
function noop() {
  // Why even bother with asserts?
}

///--- Exports

var types = {
  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(types);
  var out;

  /* re-export standard assert */
  if (process.env.NODE_NDEBUG) {
    out = noop;
  } else {
    out = function (arg, msg) {
      if (!arg) {
        _toss(msg, 'true', arg);
      }
    };
  }

  /* standard checks */
  keys.forEach(function (k) {
    if (ndebug) {
      out[k] = noop;
      return;
    }
    var type = types[k];
    out[k] = function (arg, msg) {
      if (!type.check(arg)) {
        _toss(msg, k, type.operator, arg, type.actual);
      }
    };
  });

  /* optional checks */
  keys.forEach(function (k) {
    var name = 'optional' + _capitalize(k);
    if (ndebug) {
      out[name] = noop;
      return;
    }
    var type = types[k];
    out[name] = function (arg, msg) {
      if (arg === undefined || arg === null) {
        return;
      }
      if (!type.check(arg)) {
        _toss(msg, k, type.operator, arg, type.actual);
      }
    };
  });

  /* arrayOf checks */
  keys.forEach(function (k) {
    var name = 'arrayOf' + _capitalize(k);
    if (ndebug) {
      out[name] = noop;
      return;
    }
    var type = types[k];
    var expected = '[' + k + ']';
    out[name] = function (arg, msg) {
      if (!Array.isArray(arg)) {
        _toss(msg, expected, type.operator, arg, type.actual);
      }
      var i;
      for (i = 0; i < arg.length; i++) {
        if (!type.check(arg[i])) {
          _toss(msg, expected, type.operator, arg, type.actual);
        }
      }
    };
  });

  /* optionalArrayOf checks */
  keys.forEach(function (k) {
    var name = 'optionalArrayOf' + _capitalize(k);
    if (ndebug) {
      out[name] = noop;
      return;
    }
    var type = types[k];
    var expected = '[' + k + ']';
    out[name] = function (arg, msg) {
      if (arg === undefined || arg === null) {
        return;
      }
      if (!Array.isArray(arg)) {
        _toss(msg, expected, type.operator, arg, type.actual);
      }
      var i;
      for (i = 0; i < arg.length; i++) {
        if (!type.check(arg[i])) {
          _toss(msg, expected, type.operator, arg, type.actual);
        }
      }
    };
  });

  /* re-export built-in assertions */
  Object.keys(assert).forEach(function (k) {
    if (k === 'AssertionError') {
      out[k] = assert[k];
      return;
    }
    if (ndebug) {
      out[k] = noop;
      return;
    }
    out[k] = assert[k];
  });

  /* export ourselves (for unit tests _only_) */
  out._setExports = _setExports;
  return out;
}
module.exports = _setExports(process.env.NODE_NDEBUG);

/***/ }),

/***/ 3040:
/*!**********************************************!*\
  !*** ./node_modules/balanced-match/index.js ***!
  \**********************************************/
/***/ ((module) => {

"use strict";


module.exports = balanced;
function balanced(a, b, str) {
  if (a instanceof RegExp) a = maybeMatch(a, str);
  if (b instanceof RegExp) b = maybeMatch(b, str);
  var r = range(a, b, str);
  return r && {
    start: r[0],
    end: r[1],
    pre: str.slice(0, r[0]),
    body: str.slice(r[0] + a.length, r[1]),
    post: str.slice(r[1] + b.length)
  };
}
function maybeMatch(reg, str) {
  var m = str.match(reg);
  return m ? m[0] : null;
}
balanced.range = range;
function range(a, b, str) {
  var begs, beg, left, right, result;
  var ai = str.indexOf(a);
  var bi = str.indexOf(b, ai + 1);
  var i = ai;
  if (ai >= 0 && bi > 0) {
    begs = [];
    left = str.length;
    while (i >= 0 && !result) {
      if (i == ai) {
        begs.push(i);
        ai = str.indexOf(a, i + 1);
      } else if (begs.length == 1) {
        result = [begs.pop(), bi];
      } else {
        beg = begs.pop();
        if (beg < left) {
          left = beg;
          right = bi;
        }
        bi = str.indexOf(b, i + 1);
      }
      i = ai < bi && ai >= 0 ? ai : bi;
    }
    if (begs.length) {
      result = [left, right];
    }
  }
  return result;
}

/***/ }),

/***/ 5116:
/*!********************************************!*\
  !*** ./node_modules/bcrypt-pbkdf/index.js ***!
  \********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


var crypto_hash_sha512 = (__webpack_require__(/*! tweetnacl */ 8227).lowlevel.crypto_hash);

/*
 * This file is a 1:1 port from the OpenBSD blowfish.c and bcrypt_pbkdf.c. As a
 * result, it retains the original copyright and license. The two files are
 * under slightly different (but compatible) licenses, and are here combined in
 * one file.
 *
 * Credit for the actual porting work goes to:
 *  Devi Mandiri <me@devi.web.id>
 */

/*
 * The Blowfish portions are under the following license:
 *
 * Blowfish block cipher for OpenBSD
 * Copyright 1997 Niels Provos <provos@physnet.uni-hamburg.de>
 * All rights reserved.
 *
 * Implementation advice by David Mazieres <dm@lcs.mit.edu>.
 *
 * 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. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
 */

/*
 * The bcrypt_pbkdf portions are under the following license:
 *
 * Copyright (c) 2013 Ted Unangst <tedu@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

/*
 * Performance improvements (Javascript-specific):
 *
 * Copyright 2016, Joyent Inc
 * Author: Alex Wilson <alex.wilson@joyent.com>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

// Ported from OpenBSD bcrypt_pbkdf.c v1.9

var BLF_J = 0;
var Blowfish = function () {
  this.S = [new Uint32Array([0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7, 0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99, 0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16, 0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e, 0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee, 0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013, 0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef, 0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e, 0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60, 0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440, 0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce, 0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a, 0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e, 0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677, 0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193, 0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032, 0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88, 0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239, 0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e, 0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0, 0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3, 0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98, 0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88, 0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe, 0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6, 0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d, 0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b, 0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7, 0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba, 0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463, 0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f, 0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09, 0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3, 0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb, 0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279, 0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8, 0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab, 0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82, 0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db, 0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573, 0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0, 0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b, 0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790, 0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8, 0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4, 0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0, 0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7, 0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c, 0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad, 0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1, 0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299, 0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9, 0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477, 0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf, 0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49, 0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af, 0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa, 0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5, 0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41, 0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915, 0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400, 0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915, 0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664, 0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a]), new Uint32Array([0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623, 0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266, 0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1, 0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e, 0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6, 0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1, 0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e, 0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1, 0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737, 0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8, 0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff, 0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd, 0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701, 0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7, 0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41, 0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331, 0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf, 0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af, 0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e, 0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87, 0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c, 0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2, 0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16, 0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd, 0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b, 0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509, 0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e, 0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3, 0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f, 0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a, 0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4, 0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960, 0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66, 0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28, 0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802, 0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84, 0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510, 0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf, 0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14, 0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e, 0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50, 0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7, 0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8, 0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281, 0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99, 0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696, 0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128, 0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73, 0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0, 0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0, 0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105, 0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250, 0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3, 0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285, 0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00, 0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061, 0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb, 0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e, 0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735, 0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc, 0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9, 0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340, 0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20, 0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7]), new Uint32Array([0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934, 0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068, 0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af, 0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840, 0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45, 0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504, 0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a, 0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb, 0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee, 0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6, 0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42, 0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b, 0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2, 0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb, 0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527, 0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b, 0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33, 0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c, 0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3, 0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc, 0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17, 0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564, 0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b, 0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115, 0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922, 0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728, 0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0, 0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e, 0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37, 0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d, 0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804, 0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b, 0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3, 0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb, 0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d, 0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c, 0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350, 0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9, 0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a, 0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe, 0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d, 0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc, 0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f, 0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61, 0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2, 0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9, 0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2, 0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c, 0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e, 0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633, 0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10, 0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169, 0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52, 0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027, 0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5, 0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62, 0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634, 0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76, 0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24, 0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc, 0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4, 0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c, 0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837, 0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0]), new Uint32Array([0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b, 0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe, 0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b, 0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4, 0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8, 0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6, 0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304, 0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22, 0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4, 0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6, 0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9, 0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59, 0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593, 0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51, 0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28, 0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c, 0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b, 0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28, 0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c, 0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd, 0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a, 0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319, 0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb, 0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f, 0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991, 0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32, 0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680, 0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166, 0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae, 0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb, 0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5, 0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47, 0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370, 0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d, 0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84, 0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048, 0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8, 0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd, 0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9, 0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7, 0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38, 0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f, 0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c, 0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525, 0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1, 0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442, 0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964, 0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e, 0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8, 0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d, 0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f, 0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299, 0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02, 0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc, 0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614, 0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a, 0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6, 0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b, 0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0, 0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060, 0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e, 0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9, 0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f, 0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6])];
  this.P = new Uint32Array([0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344, 0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89, 0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c, 0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917, 0x9216d5d9, 0x8979fb1b]);
};
function F(S, x8, i) {
  return (S[0][x8[i + 3]] + S[1][x8[i + 2]] ^ S[2][x8[i + 1]]) + S[3][x8[i]];
}
;
Blowfish.prototype.encipher = function (x, x8) {
  if (x8 === undefined) {
    x8 = new Uint8Array(x.buffer);
    if (x.byteOffset !== 0) x8 = x8.subarray(x.byteOffset);
  }
  x[0] ^= this.P[0];
  for (var i = 1; i < 16; i += 2) {
    x[1] ^= F(this.S, x8, 0) ^ this.P[i];
    x[0] ^= F(this.S, x8, 4) ^ this.P[i + 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 i = 16; i > 0; i -= 2) {
    x[1] ^= F(this.S, x8, 0) ^ this.P[i];
    x[0] ^= F(this.S, x8, 4) ^ this.P[i - 1];
  }
  var t = x[0];
  x[0] = x[1] ^ this.P[0];
  x[1] = t;
};
function stream2word(data, databytes) {
  var i,
    temp = 0;
  for (i = 0; i < 4; i++, BLF_J++) {
    if (BLF_J >= databytes) BLF_J = 0;
    temp = temp << 8 | data[BLF_J];
  }
  return temp;
}
;
Blowfish.prototype.expand0state = function (key, keybytes) {
  var d = new Uint32Array(2),
    i,
    k;
  var d8 = new Uint8Array(d.buffer);
  for (i = 0, BLF_J = 0; i < 18; i++) {
    this.P[i] ^= stream2word(key, keybytes);
  }
  BLF_J = 0;
  for (i = 0; i < 18; i += 2) {
    this.encipher(d, d8);
    this.P[i] = d[0];
    this.P[i + 1] = d[1];
  }
  for (i = 0; i < 4; i++) {
    for (k = 0; k < 256; k += 2) {
      this.encipher(d, d8);
      this.S[i][k] = d[0];
      this.S[i][k + 1] = d[1];
    }
  }
};
Blowfish.prototype.expandstate = function (data, databytes, key, keybytes) {
  var d = new Uint32Array(2),
    i,
    k;
  for (i = 0, BLF_J = 0; i < 18; i++) {
    this.P[i] ^= stream2word(key, keybytes);
  }
  for (i = 0, BLF_J = 0; i < 18; i += 2) {
    d[0] ^= stream2word(data, databytes);
    d[1] ^= stream2word(data, databytes);
    this.encipher(d);
    this.P[i] = d[0];
    this.P[i + 1] = d[1];
  }
  for (i = 0; i < 4; i++) {
    for (k = 0; k < 256; k += 2) {
      d[0] ^= stream2word(data, databytes);
      d[1] ^= stream2word(data, databytes);
      this.encipher(d);
      this.S[i][k] = d[0];
      this.S[i][k + 1] = d[1];
    }
  }
  BLF_J = 0;
};
Blowfish.prototype.enc = function (data, blocks) {
  for (var i = 0; i < blocks; i++) {
    this.encipher(data.subarray(i * 2));
  }
};
Blowfish.prototype.dec = function (data, blocks) {
  for (var i = 0; i < blocks; i++) {
    this.decipher(data.subarray(i * 2));
  }
};
var BCRYPT_BLOCKS = 8,
  BCRYPT_HASHSIZE = 32;
function bcrypt_hash(sha2pass, sha2salt, out) {
  var state = new Blowfish(),
    cdata = new Uint32Array(BCRYPT_BLOCKS),
    i,
    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]); //"OxychromaticBlowfishSwatDynamite"

  state.expandstate(sha2salt, 64, sha2pass, 64);
  for (i = 0; i < 64; i++) {
    state.expand0state(sha2salt, 64);
    state.expand0state(sha2pass, 64);
  }
  for (i = 0; i < BCRYPT_BLOCKS; i++) cdata[i] = stream2word(ciphertext, ciphertext.byteLength);
  for (i = 0; i < 64; i++) state.enc(cdata, cdata.byteLength / 8);
  for (i = 0; i < BCRYPT_BLOCKS; i++) {
    out[4 * i + 3] = cdata[i] >>> 24;
    out[4 * i + 2] = cdata[i] >>> 16;
    out[4 * i + 1] = cdata[i] >>> 8;
    out[4 * i + 0] = cdata[i];
  }
}
;
function bcrypt_pbkdf(pass, passlen, salt, saltlen, key, 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),
    i,
    j,
    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 (i = 0; i < saltlen; i++) countsalt[i] = salt[i];
  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 (i = out.byteLength; i--;) out[i] = tmpout[i];
    for (i = 1; i < rounds; i++) {
      crypto_hash_sha512(sha2salt, tmpout, tmpout.byteLength);
      bcrypt_hash(sha2pass, sha2salt, tmpout);
      for (j = 0; j < out.byteLength; j++) out[j] ^= tmpout[j];
    }
    amt = Math.min(amt, keylen);
    for (i = 0; i < amt; i++) {
      dest = i * stride + (count - 1);
      if (dest >= origkeylen) break;
      key[dest] = out[i];
    }
    keylen -= i;
  }
  return 0;
}
;
module.exports = {
  BLOCKS: BCRYPT_BLOCKS,
  HASHSIZE: BCRYPT_HASHSIZE,
  hash: bcrypt_hash,
  pbkdf: bcrypt_pbkdf
};

/***/ }),

/***/ 3297:
/*!***********************************************!*\
  !*** ./node_modules/brace-expansion/index.js ***!
  \***********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var concatMap = __webpack_require__(/*! concat-map */ 5877);
var balanced = __webpack_require__(/*! balanced-match */ 3040);
module.exports = expandTop;
var escSlash = '\0SLASH' + Math.random() + '\0';
var escOpen = '\0OPEN' + Math.random() + '\0';
var escClose = '\0CLOSE' + Math.random() + '\0';
var escComma = '\0COMMA' + Math.random() + '\0';
var escPeriod = '\0PERIOD' + Math.random() + '\0';
function numeric(str) {
  return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
}
function escapeBraces(str) {
  return str.split('\\\\').join(escSlash).split('\\{').join(escOpen).split('\\}').join(escClose).split('\\,').join(escComma).split('\\.').join(escPeriod);
}
function unescapeBraces(str) {
  return str.split(escSlash).join('\\').split(escOpen).join('{').split(escClose).join('}').split(escComma).join(',').split(escPeriod).join('.');
}

// Basically just str.split(","), but handling cases
// where we have nested braced sections, which should be
// treated as individual members, like {a,{b,c},d}
function parseCommaParts(str) {
  if (!str) return [''];
  var parts = [];
  var m = balanced('{', '}', str);
  if (!m) return str.split(',');
  var pre = m.pre;
  var body = m.body;
  var post = m.post;
  var p = pre.split(',');
  p[p.length - 1] += '{' + body + '}';
  var postParts = parseCommaParts(post);
  if (post.length) {
    p[p.length - 1] += postParts.shift();
    p.push.apply(p, postParts);
  }
  parts.push.apply(parts, p);
  return parts;
}
function expandTop(str) {
  if (!str) return [];

  // I don't know why Bash 4.3 does this, but it does.
  // Anything starting with {} will have the first two bytes preserved
  // but *only* at the top level, so {},a}b will not expand to anything,
  // but a{},b}c will be expanded to [a}c,abc].
  // One could argue that this is a bug in Bash, but since the goal of
  // this module is to match Bash's rules, we escape a leading {}
  if (str.substr(0, 2) === '{}') {
    str = '\\{\\}' + str.substr(2);
  }
  return expand(escapeBraces(str), true).map(unescapeBraces);
}
function identity(e) {
  return e;
}
function embrace(str) {
  return '{' + str + '}';
}
function isPadded(el) {
  return /^-?0\d/.test(el);
}
function lte(i, y) {
  return i <= y;
}
function gte(i, y) {
  return i >= y;
}
function expand(str, isTop) {
  var expansions = [];
  var m = balanced('{', '}', str);
  if (!m || /\$$/.test(m.pre)) return [str];
  var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
  var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
  var isSequence = isNumericSequence || isAlphaSequence;
  var isOptions = m.body.indexOf(',') >= 0;
  if (!isSequence && !isOptions) {
    // {a},b}
    if (m.post.match(/,.*\}/)) {
      str = m.pre + '{' + m.body + escClose + m.post;
      return expand(str);
    }
    return [str];
  }
  var n;
  if (isSequence) {
    n = m.body.split(/\.\./);
  } else {
    n = parseCommaParts(m.body);
    if (n.length === 1) {
      // x{{a,b}}y ==> x{a}y x{b}y
      n = expand(n[0], false).map(embrace);
      if (n.length === 1) {
        var post = m.post.length ? expand(m.post, false) : [''];
        return post.map(function (p) {
          return m.pre + n[0] + p;
        });
      }
    }
  }

  // at this point, n is the parts, and we know it's not a comma set
  // with a single entry.

  // no need to expand pre, since it is guaranteed to be free of brace-sets
  var pre = m.pre;
  var post = m.post.length ? expand(m.post, false) : [''];
  var N;
  if (isSequence) {
    var x = numeric(n[0]);
    var y = numeric(n[1]);
    var width = Math.max(n[0].length, n[1].length);
    var incr = n.length == 3 ? Math.abs(numeric(n[2])) : 1;
    var test = lte;
    var reverse = y < x;
    if (reverse) {
      incr *= -1;
      test = gte;
    }
    var pad = n.some(isPadded);
    N = [];
    for (var i = x; test(i, y); i += incr) {
      var c;
      if (isAlphaSequence) {
        c = String.fromCharCode(i);
        if (c === '\\') c = '';
      } else {
        c = String(i);
        if (pad) {
          var need = width - c.length;
          if (need > 0) {
            var z = new Array(need + 1).join('0');
            if (i < 0) c = '-' + z + c.slice(1);else c = z + c;
          }
        }
      }
      N.push(c);
    }
  } else {
    N = concatMap(n, function (el) {
      return expand(el, false);
    });
  }
  for (var j = 0; j < N.length; j++) {
    for (var k = 0; k < post.length; k++) {
      var expansion = pre + N[j] + post[k];
      if (!isTop || isSequence || expansion) expansions.push(expansion);
    }
  }
  return expansions;
}

/***/ }),

/***/ 5877:
/*!******************************************!*\
  !*** ./node_modules/concat-map/index.js ***!
  \******************************************/
/***/ ((module) => {

module.exports = function (xs, fn) {
  var res = [];
  for (var i = 0; i < xs.length; i++) {
    var x = fn(xs[i], i);
    if (isArray(x)) res.push.apply(res, x);else res.push(x);
  }
  return res;
};
var isArray = Array.isArray || function (xs) {
  return Object.prototype.toString.call(xs) === '[object Array]';
};

/***/ }),

/***/ 6695:
/*!****************************************!*\
  !*** ./node_modules/ecc-jsbn/index.js ***!
  \****************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

var crypto = __webpack_require__(/*! crypto */ 6113);
var BigInteger = (__webpack_require__(/*! jsbn */ 456).BigInteger);
var ECPointFp = (__webpack_require__(/*! ./lib/ec.js */ 7221).ECPointFp);
var Buffer = (__webpack_require__(/*! safer-buffer */ 3745).Buffer);
exports.ECCurves = __webpack_require__(/*! ./lib/sec.js */ 4620);

// zero prepad
function unstupid(hex, len) {
  return hex.length >= len ? hex : unstupid("0" + hex, len);
}
exports.ECKey = function (curve, key, isPublic) {
  var priv;
  var c = curve();
  var n = c.getN();
  var bytes = Math.floor(n.bitLength() / 8);
  if (key) {
    if (isPublic) {
      var curve = c.getCurve();
      //      var x = key.slice(1,bytes+1); // skip the 04 for uncompressed format
      //      var y = key.slice(bytes+1);
      //      this.P = new ECPointFp(curve,
      //        curve.fromBigInteger(new BigInteger(x.toString("hex"), 16)),
      //        curve.fromBigInteger(new BigInteger(y.toString("hex"), 16)));      
      this.P = curve.decodePointHex(key.toString("hex"));
    } else {
      if (key.length != bytes) return false;
      priv = new BigInteger(key.toString("hex"), 16);
    }
  } else {
    var n1 = n.subtract(BigInteger.ONE);
    var r = new BigInteger(crypto.randomBytes(n.bitLength()));
    priv = r.mod(n1).add(BigInteger.ONE);
    this.P = c.getG().multiply(priv);
  }
  if (this.P) {
    //  var pubhex = unstupid(this.P.getX().toBigInteger().toString(16),bytes*2)+unstupid(this.P.getY().toBigInteger().toString(16),bytes*2);
    //  this.PublicKey = Buffer.from("04"+pubhex,"hex");
    this.PublicKey = Buffer.from(c.getCurve().encodeCompressedPointHex(this.P), "hex");
  }
  if (priv) {
    this.PrivateKey = Buffer.from(unstupid(priv.toString(16), bytes * 2), "hex");
    this.deriveSharedSecret = function (key) {
      if (!key || !key.P) return false;
      var S = key.P.multiply(priv);
      return Buffer.from(unstupid(S.getX().toBigInteger().toString(16), bytes * 2), "hex");
    };
  }
};

/***/ }),

/***/ 7221:
/*!*****************************************!*\
  !*** ./node_modules/ecc-jsbn/lib/ec.js ***!
  \*****************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// Basic Javascript Elliptic Curve implementation
// Ported loosely from BouncyCastle's Java EC code
// Only Fp curves implemented for now

// Requires jsbn.js and jsbn2.js
var BigInteger = (__webpack_require__(/*! jsbn */ 456).BigInteger);
var Barrett = BigInteger.prototype.Barrett;

// ----------------
// ECFieldElementFp

// constructor
function ECFieldElementFp(q, x) {
  this.x = x;
  // TODO if(x.compareTo(q) >= 0) error
  this.q = q;
}
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(b) {
  return new ECFieldElementFp(this.q, this.x.add(b.toBigInteger()).mod(this.q));
}
function feFpSubtract(b) {
  return new ECFieldElementFp(this.q, this.x.subtract(b.toBigInteger()).mod(this.q));
}
function feFpMultiply(b) {
  return new ECFieldElementFp(this.q, this.x.multiply(b.toBigInteger()).mod(this.q));
}
function feFpSquare() {
  return new ECFieldElementFp(this.q, this.x.square().mod(this.q));
}
function feFpDivide(b) {
  return new ECFieldElementFp(this.q, this.x.multiply(b.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;

// ----------------
// ECPointFp

// constructor
function ECPointFp(curve, x, y, z) {
  this.curve = curve;
  this.x = x;
  this.y = y;
  // Projective coordinates: either zinv == null or z * zinv == 1
  // z and zinv are just BigIntegers, not fieldElements
  if (z == null) {
    this.z = BigInteger.ONE;
  } else {
    this.z = z;
  }
  this.zinv = null;
  //TODO: compression flag
}

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 = Y2 * Z1 - Y1 * Z2
  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 = X2 * Z1 - X1 * Z2
  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(b) {
  if (this.isInfinity()) return b;
  if (b.isInfinity()) return this;

  // u = Y2 * Z1 - Y1 * Z2
  var u = b.y.toBigInteger().multiply(this.z).subtract(this.y.toBigInteger().multiply(b.z)).mod(this.curve.q);
  // v = X2 * Z1 - X1 * Z2
  var v = b.x.toBigInteger().multiply(this.z).subtract(this.x.toBigInteger().multiply(b.z)).mod(this.curve.q);
  if (BigInteger.ZERO.equals(v)) {
    if (BigInteger.ZERO.equals(u)) {
      return this.twice(); // this == b, so double
    }

    return this.curve.getInfinity(); // this = -b, so infinity
  }

  var THREE = new BigInteger("3");
  var x1 = this.x.toBigInteger();
  var y1 = this.y.toBigInteger();
  var x2 = b.x.toBigInteger();
  var y2 = b.y.toBigInteger();
  var v2 = v.square();
  var v3 = v2.multiply(v);
  var x1v2 = x1.multiply(v2);
  var zu2 = u.square().multiply(this.z);

  // x3 = v * (z2 * (z1 * u^2 - 2 * x1 * v^2) - v^3)
  var x3 = zu2.subtract(x1v2.shiftLeft(1)).multiply(b.z).subtract(v3).multiply(v).mod(this.curve.q);
  // y3 = z2 * (3 * x1 * u * v^2 - y1 * v^3 - z1 * u^3) + u * v^3
  var y3 = x1v2.multiply(THREE).multiply(u).subtract(y1.multiply(v3)).subtract(zu2.multiply(u)).multiply(b.z).add(u.multiply(v3)).mod(this.curve.q);
  // z3 = v^3 * z1 * z2
  var z3 = v3.multiply(this.z).multiply(b.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();

  // TODO: optimized handling of constants
  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 a = this.curve.a.toBigInteger();

  // w = 3 * x1^2 + a * z1^2
  var w = x1.square().multiply(THREE);
  if (!BigInteger.ZERO.equals(a)) {
    w = w.add(this.z.square().multiply(a));
  }
  w = w.mod(this.curve.q);
  //this.curve.reduce(w);
  // x3 = 2 * y1 * z1 * (w^2 - 8 * x1 * y1^2 * z1)
  var x3 = w.square().subtract(x1.shiftLeft(3).multiply(y1sqz1)).shiftLeft(1).multiply(y1z1).mod(this.curve.q);
  // y3 = 4 * y1^2 * z1 * (3 * w * x1 - 2 * y1^2 * z1) - w^3
  var y3 = w.multiply(THREE).multiply(x1).subtract(y1sqz1.shiftLeft(1)).shiftLeft(2).multiply(y1sqz1).subtract(w.square().multiply(w)).mod(this.curve.q);
  // z3 = 8 * (y1 * z1)^3
  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);
}

// Simple NAF (Non-Adjacent Form) multiplication algorithm
// TODO: modularize the multiplication algorithm
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 i;
  for (i = h.bitLength() - 2; i > 0; --i) {
    R = R.twice();
    var hBit = h.testBit(i);
    var eBit = e.testBit(i);
    if (hBit != eBit) {
      R = R.add(hBit ? this : neg);
    }
  }
  return R;
}

// Compute this*j + x*k (simultaneous multiplication)
function pointFpMultiplyTwo(j, x, k) {
  var i;
  if (j.bitLength() > k.bitLength()) i = j.bitLength() - 1;else i = k.bitLength() - 1;
  var R = this.curve.getInfinity();
  var both = this.add(x);
  while (i >= 0) {
    R = R.twice();
    if (j.testBit(i)) {
      if (k.testBit(i)) {
        R = R.add(both);
      } else {
        R = R.add(this);
      }
    } else {
      if (k.testBit(i)) {
        R = R.add(x);
      }
    }
    --i;
  }
  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;

// ----------------
// ECCurveFp

// constructor
function ECCurveFp(q, a, b) {
  this.q = q;
  this.a = this.fromBigInteger(a);
  this.b = this.fromBigInteger(b);
  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);
}

// for now, work with hex strings because they're easier in JS
function curveFpDecodePointHex(s) {
  switch (parseInt(s.substr(0, 2), 16)) {
    // first byte
    case 0:
      return this.infinity;
    case 2:
    case 3:
      // point compression not supported yet
      return null;
    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:
      // unsupported
      return null;
  }
}
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.decodePointHex = curveFpDecodePointHex;
ECCurveFp.prototype.encodePointHex = curveFpEncodePointHex;

// from: https://github.com/kaielvin/jsbn-ec-point-compression
ECCurveFp.prototype.decodePointHex = function (s) {
  var yIsEven;
  switch (parseInt(s.substr(0, 2), 16)) {
    // first byte
    case 0:
      return this.infinity;
    case 2:
      yIsEven = false;
    case 3:
      if (yIsEven == undefined) 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) {
        // Use the other root
        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:
      // unsupported
      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 != undefined) 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";

  // p mod 4 == 3
  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;
  }

  // p mod 4 == 1
  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 result = this.lucasSequence(P, Q, k);
    U = result[0];
    V = result[1];
    if (this.modMult(V, V).equals(fourQ)) {
      // Integer division by 2, mod q
      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 j = n - 1; j >= s + 1; --j) {
    Ql = this.modMult(Ql, Qh);
    if (k.testBit(j)) {
      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 j = 1; j <= s; ++j) {
    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: ECCurveFp,
  ECPointFp: ECPointFp,
  ECFieldElementFp: ECFieldElementFp
};
module.exports = exports;

/***/ }),

/***/ 4620:
/*!******************************************!*\
  !*** ./node_modules/ecc-jsbn/lib/sec.js ***!
  \******************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// Named EC curves

// Requires ec.js, jsbn.js, and jsbn2.js
var BigInteger = (__webpack_require__(/*! jsbn */ 456).BigInteger);
var ECCurveFp = (__webpack_require__(/*! ./ec.js */ 7221).ECCurveFp);

// ----------------
// X9ECParameters

// constructor
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;

// ----------------
// SECNamedCurves

function fromHex(s) {
  return new BigInteger(s, 16);
}
function secp128r1() {
  // p = 2^128 - 2^97 - 1
  var p = fromHex("FFFFFFFDFFFFFFFFFFFFFFFFFFFFFFFF");
  var a = fromHex("FFFFFFFDFFFFFFFFFFFFFFFFFFFFFFFC");
  var b = fromHex("E87579C11079F43DD824993C2CEE5ED3");
  //byte[] S = Hex.decode("000E0D4D696E6768756151750CC03A4473D03679");
  var n = fromHex("FFFFFFFE0000000075A30D1B9038A115");
  var h = BigInteger.ONE;
  var curve = new ECCurveFp(p, a, b);
  var G = curve.decodePointHex("04" + "161FF7528B899B2D0C28607CA52C5B86" + "CF5AC8395BAFEB13C02DA292DDED7A83");
  return new X9ECParameters(curve, G, n, h);
}
function secp160k1() {
  // p = 2^160 - 2^32 - 2^14 - 2^12 - 2^9 - 2^8 - 2^7 - 2^3 - 2^2 - 1
  var p = fromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFAC73");
  var a = BigInteger.ZERO;
  var b = fromHex("7");
  //byte[] S = null;
  var n = fromHex("0100000000000000000001B8FA16DFAB9ACA16B6B3");
  var h = BigInteger.ONE;
  var curve = new ECCurveFp(p, a, b);
  var G = curve.decodePointHex("04" + "3B4C382CE37AA192A4019E763036F4F5DD4D7EBB" + "938CF935318FDCED6BC28286531733C3F03C4FEE");
  return new X9ECParameters(curve, G, n, h);
}
function secp160r1() {
  // p = 2^160 - 2^31 - 1
  var p = fromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFF");
  var a = fromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFC");
  var b = fromHex("1C97BEFC54BD7A8B65ACF89F81D4D4ADC565FA45");
  //byte[] S = Hex.decode("1053CDE42C14D696E67687561517533BF3F83345");
  var n = fromHex("0100000000000000000001F4C8F927AED3CA752257");
  var h = BigInteger.ONE;
  var curve = new ECCurveFp(p, a, b);
  var G = curve.decodePointHex("04" + "4A96B5688EF573284664698968C38BB913CBFC82" + "23A628553168947D59DCC912042351377AC5FB32");
  return new X9ECParameters(curve, G, n, h);
}
function secp192k1() {
  // p = 2^192 - 2^32 - 2^12 - 2^8 - 2^7 - 2^6 - 2^3 - 1
  var p = fromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFEE37");
  var a = BigInteger.ZERO;
  var b = fromHex("3");
  //byte[] S = null;
  var n = fromHex("FFFFFFFFFFFFFFFFFFFFFFFE26F2FC170F69466A74DEFD8D");
  var h = BigInteger.ONE;
  var curve = new ECCurveFp(p, a, b);
  var G = curve.decodePointHex("04" + "DB4FF10EC057E9AE26B07D0280B7F4341DA5D1B1EAE06C7D" + "9B2F2F6D9C5628A7844163D015BE86344082AA88D95E2F9D");
  return new X9ECParameters(curve, G, n, h);
}
function secp192r1() {
  // p = 2^192 - 2^64 - 1
  var p = fromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFF");
  var a = fromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFC");
  var b = fromHex("64210519E59C80E70FA7E9AB72243049FEB8DEECC146B9B1");
  //byte[] S = Hex.decode("3045AE6FC8422F64ED579528D38120EAE12196D5");
  var n = fromHex("FFFFFFFFFFFFFFFFFFFFFFFF99DEF836146BC9B1B4D22831");
  var h = BigInteger.ONE;
  var curve = new ECCurveFp(p, a, b);
  var G = curve.decodePointHex("04" + "188DA80EB03090F67CBF20EB43A18800F4FF0AFD82FF1012" + "07192B95FFC8DA78631011ED6B24CDD573F977A11E794811");
  return new X9ECParameters(curve, G, n, h);
}
function secp224r1() {
  // p = 2^224 - 2^96 + 1
  var p = fromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000001");
  var a = fromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFE");
  var b = fromHex("B4050A850C04B3ABF54132565044B0B7D7BFD8BA270B39432355FFB4");
  //byte[] S = Hex.decode("BD71344799D5C7FCDC45B59FA3B9AB8F6A948BC5");
  var n = fromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFF16A2E0B8F03E13DD29455C5C2A3D");
  var h = BigInteger.ONE;
  var curve = new ECCurveFp(p, a, b);
  var G = curve.decodePointHex("04" + "B70E0CBD6BB4BF7F321390B94A03C1D356C21122343280D6115C1D21" + "BD376388B5F723FB4C22DFE6CD4375A05A07476444D5819985007E34");
  return new X9ECParameters(curve, G, n, h);
}
function secp256r1() {
  // p = 2^224 (2^32 - 1) + 2^192 + 2^96 - 1
  var p = fromHex("FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF");
  var a = fromHex("FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFC");
  var b = fromHex("5AC635D8AA3A93E7B3EBBD55769886BC651D06B0CC53B0F63BCE3C3E27D2604B");
  //byte[] S = Hex.decode("C49D360886E704936A6678E1139D26B7819F7E90");
  var n = fromHex("FFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551");
  var h = BigInteger.ONE;
  var curve = new ECCurveFp(p, a, b);
  var G = curve.decodePointHex("04" + "6B17D1F2E12C4247F8BCE6E563A440F277037D812DEB33A0F4A13945D898C296" + "4FE342E2FE1A7F9B8EE7EB4A7C0F9E162BCE33576B315ECECBB6406837BF51F5");
  return new X9ECParameters(curve, G, n, h);
}

// TODO: make this into a proper hashtable
function getSECCurveByName(name) {
  if (name == "secp128r1") return secp128r1();
  if (name == "secp160k1") return secp160k1();
  if (name == "secp160r1") return secp160r1();
  if (name == "secp192k1") return secp192k1();
  if (name == "secp192r1") return secp192r1();
  if (name == "secp224r1") return secp224r1();
  if (name == "secp256r1") return secp256r1();
  return null;
}
module.exports = {
  "secp128r1": secp128r1,
  "secp160k1": secp160k1,
  "secp160r1": secp160r1,
  "secp192k1": secp192k1,
  "secp192r1": secp192r1,
  "secp224r1": secp224r1,
  "secp256r1": secp256r1
};

/***/ }),

/***/ 7990:
/*!*******************************************!*\
  !*** ./node_modules/fs.realpath/index.js ***!
  \*******************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

module.exports = realpath;
realpath.realpath = realpath;
realpath.sync = realpathSync;
realpath.realpathSync = realpathSync;
realpath.monkeypatch = monkeypatch;
realpath.unmonkeypatch = unmonkeypatch;
var fs = __webpack_require__(/*! fs */ 2089);
var origRealpath = fs.realpath;
var origRealpathSync = fs.realpathSync;
var version = process.version;
var ok = /^v[0-5]\./.test(version);
var old = __webpack_require__(/*! ./old.js */ 6734);
function newError(er) {
  return er && er.syscall === 'realpath' && (er.code === 'ELOOP' || er.code === 'ENOMEM' || er.code === 'ENAMETOOLONG');
}
function realpath(p, cache, cb) {
  if (ok) {
    return origRealpath(p, cache, cb);
  }
  if (typeof cache === 'function') {
    cb = cache;
    cache = null;
  }
  origRealpath(p, cache, function (er, result) {
    if (newError(er)) {
      old.realpath(p, cache, cb);
    } else {
      cb(er, result);
    }
  });
}
function realpathSync(p, cache) {
  if (ok) {
    return origRealpathSync(p, cache);
  }
  try {
    return origRealpathSync(p, cache);
  } catch (er) {
    if (newError(er)) {
      return old.realpathSync(p, cache);
    } else {
      throw er;
    }
  }
}
function monkeypatch() {
  fs.realpath = realpath;
  fs.realpathSync = realpathSync;
}
function unmonkeypatch() {
  fs.realpath = origRealpath;
  fs.realpathSync = origRealpathSync;
}

/***/ }),

/***/ 6734:
/*!*****************************************!*\
  !*** ./node_modules/fs.realpath/old.js ***!
  \*****************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

var pathModule = __webpack_require__(/*! path */ 3056);
var isWindows = process.platform === 'win32';
var fs = __webpack_require__(/*! fs */ 2089);

// JavaScript implementation of realpath, ported from node pre-v6

var DEBUG = process.env.NODE_DEBUG && /fs/.test(process.env.NODE_DEBUG);
function rethrow() {
  // Only enable in debug mode. A backtrace uses ~1000 bytes of heap space and
  // is fairly slow to generate.
  var callback;
  if (DEBUG) {
    var backtrace = new Error();
    callback = debugCallback;
  } else callback = missingCallback;
  return callback;
  function debugCallback(err) {
    if (err) {
      backtrace.message = err.message;
      err = backtrace;
      missingCallback(err);
    }
  }
  function missingCallback(err) {
    if (err) {
      if (process.throwDeprecation) throw err; // Forgot a callback but don't know where? Use NODE_DEBUG=fs
      else if (!process.noDeprecation) {
        var msg = 'fs: missing callback ' + (err.stack || err.message);
        if (process.traceDeprecation) console.trace(msg);else console.error(msg);
      }
    }
  }
}
function maybeCallback(cb) {
  return typeof cb === 'function' ? cb : rethrow();
}
var normalize = pathModule.normalize;

// Regexp that finds the next partion of a (partial) path
// result is [base_with_slash, base], e.g. ['somedir/', 'somedir']
if (isWindows) {
  var nextPartRe = /(.*?)(?:[\/\\]+|$)/g;
} else {
  var nextPartRe = /(.*?)(?:[\/]+|$)/g;
}

// Regex to find the device root, including trailing slash. E.g. 'c:\\'.
if (isWindows) {
  var splitRootRe = /^(?:[a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/][^\\\/]+)?[\\\/]*/;
} else {
  var splitRootRe = /^[\/]*/;
}
exports.realpathSync = function realpathSync(p, cache) {
  // make p is absolute
  p = pathModule.resolve(p);
  if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
    return cache[p];
  }
  var original = p,
    seenLinks = {},
    knownHard = {};

  // current character position in p
  var pos;
  // the partial path so far, including a trailing slash if any
  var current;
  // the partial path without a trailing slash (except when pointing at a root)
  var base;
  // the partial path scanned in the previous round, with slash
  var previous;
  start();
  function start() {
    // Skip over roots
    var m = splitRootRe.exec(p);
    pos = m[0].length;
    current = m[0];
    base = m[0];
    previous = '';

    // On windows, check that the root exists. On unix there is no need.
    if (isWindows && !knownHard[base]) {
      fs.lstatSync(base);
      knownHard[base] = true;
    }
  }

  // walk down the path, swapping out linked pathparts for their real
  // values
  // NB: p.length changes.
  while (pos < p.length) {
    // find the next part
    nextPartRe.lastIndex = pos;
    var result = nextPartRe.exec(p);
    previous = current;
    current += result[0];
    base = previous + result[1];
    pos = nextPartRe.lastIndex;

    // continue if not a symlink
    if (knownHard[base] || cache && cache[base] === base) {
      continue;
    }
    var resolvedLink;
    if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
      // some known symbolic link.  no need to stat again.
      resolvedLink = cache[base];
    } else {
      var stat = fs.lstatSync(base);
      if (!stat.isSymbolicLink()) {
        knownHard[base] = true;
        if (cache) cache[base] = base;
        continue;
      }

      // read the link if it wasn't read before
      // dev/ino always return 0 on windows, so skip the check.
      var linkTarget = null;
      if (!isWindows) {
        var id = stat.dev.toString(32) + ':' + stat.ino.toString(32);
        if (seenLinks.hasOwnProperty(id)) {
          linkTarget = seenLinks[id];
        }
      }
      if (linkTarget === null) {
        fs.statSync(base);
        linkTarget = fs.readlinkSync(base);
      }
      resolvedLink = pathModule.resolve(previous, linkTarget);
      // track this, if given a cache.
      if (cache) cache[base] = resolvedLink;
      if (!isWindows) seenLinks[id] = linkTarget;
    }

    // resolve the link, then start over
    p = pathModule.resolve(resolvedLink, p.slice(pos));
    start();
  }
  if (cache) cache[original] = p;
  return p;
};
exports.realpath = function realpath(p, cache, cb) {
  if (typeof cb !== 'function') {
    cb = maybeCallback(cache);
    cache = null;
  }

  // make p is absolute
  p = pathModule.resolve(p);
  if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
    return process.nextTick(cb.bind(null, null, cache[p]));
  }
  var original = p,
    seenLinks = {},
    knownHard = {};

  // current character position in p
  var pos;
  // the partial path so far, including a trailing slash if any
  var current;
  // the partial path without a trailing slash (except when pointing at a root)
  var base;
  // the partial path scanned in the previous round, with slash
  var previous;
  start();
  function start() {
    // Skip over roots
    var m = splitRootRe.exec(p);
    pos = m[0].length;
    current = m[0];
    base = m[0];
    previous = '';

    // On windows, check that the root exists. On unix there is no need.
    if (isWindows && !knownHard[base]) {
      fs.lstat(base, function (err) {
        if (err) return cb(err);
        knownHard[base] = true;
        LOOP();
      });
    } else {
      process.nextTick(LOOP);
    }
  }

  // walk down the path, swapping out linked pathparts for their real
  // values
  function LOOP() {
    // stop if scanned past end of path
    if (pos >= p.length) {
      if (cache) cache[original] = p;
      return cb(null, p);
    }

    // find the next part
    nextPartRe.lastIndex = pos;
    var result = nextPartRe.exec(p);
    previous = current;
    current += result[0];
    base = previous + result[1];
    pos = nextPartRe.lastIndex;

    // continue if not a symlink
    if (knownHard[base] || cache && cache[base] === base) {
      return process.nextTick(LOOP);
    }
    if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
      // known symbolic link.  no need to stat again.
      return gotResolvedLink(cache[base]);
    }
    return fs.lstat(base, gotStat);
  }
  function gotStat(err, stat) {
    if (err) return cb(err);

    // if not a symlink, skip to the next path part
    if (!stat.isSymbolicLink()) {
      knownHard[base] = true;
      if (cache) cache[base] = base;
      return process.nextTick(LOOP);
    }

    // stat & read the link if not read before
    // call gotTarget as soon as the link target is known
    // dev/ino always return 0 on windows, so skip the check.
    if (!isWindows) {
      var id = stat.dev.toString(32) + ':' + stat.ino.toString(32);
      if (seenLinks.hasOwnProperty(id)) {
        return gotTarget(null, seenLinks[id], base);
      }
    }
    fs.stat(base, function (err) {
      if (err) return cb(err);
      fs.readlink(base, function (err, target) {
        if (!isWindows) seenLinks[id] = target;
        gotTarget(err, target);
      });
    });
  }
  function gotTarget(err, target, base) {
    if (err) return cb(err);
    var resolvedLink = pathModule.resolve(previous, target);
    if (cache) cache[base] = resolvedLink;
    gotResolvedLink(resolvedLink);
  }
  function gotResolvedLink(resolvedLink) {
    // resolve the link, then start over
    p = pathModule.resolve(resolvedLink, p.slice(pos));
    start();
  }
};

/***/ }),

/***/ 6064:
/*!*************************************!*\
  !*** ./node_modules/glob/common.js ***!
  \*************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

exports.alphasort = alphasort;
exports.alphasorti = alphasorti;
exports.setopts = setopts;
exports.ownProp = ownProp;
exports.makeAbs = makeAbs;
exports.finish = finish;
exports.mark = mark;
exports.isIgnored = isIgnored;
exports.childrenIgnored = childrenIgnored;
function ownProp(obj, field) {
  return Object.prototype.hasOwnProperty.call(obj, field);
}
var path = __webpack_require__(/*! path */ 3056);
var minimatch = __webpack_require__(/*! minimatch */ 6091);
var isAbsolute = __webpack_require__(/*! path-is-absolute */ 5450);
var Minimatch = minimatch.Minimatch;
function alphasorti(a, b) {
  return a.toLowerCase().localeCompare(b.toLowerCase());
}
function alphasort(a, b) {
  return a.localeCompare(b);
}
function setupIgnores(self, options) {
  self.ignore = options.ignore || [];
  if (!Array.isArray(self.ignore)) self.ignore = [self.ignore];
  if (self.ignore.length) {
    self.ignore = self.ignore.map(ignoreMap);
  }
}

// ignore patterns are always in dot:true mode.
function ignoreMap(pattern) {
  var gmatcher = null;
  if (pattern.slice(-3) === '/**') {
    var gpattern = pattern.replace(/(\/\*\*)+$/, '');
    gmatcher = new Minimatch(gpattern, {
      dot: true
    });
  }
  return {
    matcher: new Minimatch(pattern, {
      dot: true
    }),
    gmatcher: gmatcher
  };
}
function setopts(self, pattern, options) {
  if (!options) options = {};

  // base-matching: just use globstar for that.
  if (options.matchBase && -1 === pattern.indexOf("/")) {
    if (options.noglobstar) {
      throw new Error("base matching requires globstar");
    }
    pattern = "**/" + pattern;
  }
  self.silent = !!options.silent;
  self.pattern = pattern;
  self.strict = options.strict !== false;
  self.realpath = !!options.realpath;
  self.realpathCache = options.realpathCache || Object.create(null);
  self.follow = !!options.follow;
  self.dot = !!options.dot;
  self.mark = !!options.mark;
  self.nodir = !!options.nodir;
  if (self.nodir) self.mark = true;
  self.sync = !!options.sync;
  self.nounique = !!options.nounique;
  self.nonull = !!options.nonull;
  self.nosort = !!options.nosort;
  self.nocase = !!options.nocase;
  self.stat = !!options.stat;
  self.noprocess = !!options.noprocess;
  self.absolute = !!options.absolute;
  self.maxLength = options.maxLength || Infinity;
  self.cache = options.cache || Object.create(null);
  self.statCache = options.statCache || Object.create(null);
  self.symlinks = options.symlinks || Object.create(null);
  setupIgnores(self, options);
  self.changedCwd = false;
  var cwd = process.cwd();
  if (!ownProp(options, "cwd")) self.cwd = cwd;else {
    self.cwd = path.resolve(options.cwd);
    self.changedCwd = self.cwd !== cwd;
  }
  self.root = options.root || path.resolve(self.cwd, "/");
  self.root = path.resolve(self.root);
  if (process.platform === "win32") self.root = self.root.replace(/\\/g, "/");

  // TODO: is an absolute `cwd` supposed to be resolved against `root`?
  // e.g. { cwd: '/test', root: __dirname } === path.join(__dirname, '/test')
  self.cwdAbs = isAbsolute(self.cwd) ? self.cwd : makeAbs(self, self.cwd);
  if (process.platform === "win32") self.cwdAbs = self.cwdAbs.replace(/\\/g, "/");
  self.nomount = !!options.nomount;

  // disable comments and negation in Minimatch.
  // Note that they are not supported in Glob itself anyway.
  options.nonegate = true;
  options.nocomment = true;
  self.minimatch = new Minimatch(pattern, options);
  self.options = self.minimatch.options;
}
function finish(self) {
  var nou = self.nounique;
  var all = nou ? [] : Object.create(null);
  for (var i = 0, l = self.matches.length; i < l; i++) {
    var matches = self.matches[i];
    if (!matches || Object.keys(matches).length === 0) {
      if (self.nonull) {
        // do like the shell, and spit out the literal glob
        var literal = self.minimatch.globSet[i];
        if (nou) all.push(literal);else all[literal] = true;
      }
    } else {
      // had matches
      var m = Object.keys(matches);
      if (nou) all.push.apply(all, m);else m.forEach(function (m) {
        all[m] = true;
      });
    }
  }
  if (!nou) all = Object.keys(all);
  if (!self.nosort) all = all.sort(self.nocase ? alphasorti : alphasort);

  // at *some* point we statted all of these
  if (self.mark) {
    for (var i = 0; i < all.length; i++) {
      all[i] = self._mark(all[i]);
    }
    if (self.nodir) {
      all = all.filter(function (e) {
        var notDir = !/\/$/.test(e);
        var c = self.cache[e] || self.cache[makeAbs(self, e)];
        if (notDir && c) notDir = c !== 'DIR' && !Array.isArray(c);
        return notDir;
      });
    }
  }
  if (self.ignore.length) all = all.filter(function (m) {
    return !isIgnored(self, m);
  });
  self.found = all;
}
function mark(self, p) {
  var abs = makeAbs(self, p);
  var c = self.cache[abs];
  var m = p;
  if (c) {
    var isDir = c === 'DIR' || Array.isArray(c);
    var slash = p.slice(-1) === '/';
    if (isDir && !slash) m += '/';else if (!isDir && slash) m = m.slice(0, -1);
    if (m !== p) {
      var mabs = makeAbs(self, m);
      self.statCache[mabs] = self.statCache[abs];
      self.cache[mabs] = self.cache[abs];
    }
  }
  return m;
}

// lotta situps...
function makeAbs(self, f) {
  var abs = f;
  if (f.charAt(0) === '/') {
    abs = path.join(self.root, f);
  } else if (isAbsolute(f) || f === '') {
    abs = f;
  } else if (self.changedCwd) {
    abs = path.resolve(self.cwd, f);
  } else {
    abs = path.resolve(f);
  }
  if (process.platform === 'win32') abs = abs.replace(/\\/g, '/');
  return abs;
}

// Return true, if pattern ends with globstar '**', for the accompanying parent directory.
// Ex:- If node_modules/** is the pattern, add 'node_modules' to ignore list along with it's contents
function isIgnored(self, path) {
  if (!self.ignore.length) return false;
  return self.ignore.some(function (item) {
    return item.matcher.match(path) || !!(item.gmatcher && item.gmatcher.match(path));
  });
}
function childrenIgnored(self, path) {
  if (!self.ignore.length) return false;
  return self.ignore.some(function (item) {
    return !!(item.gmatcher && item.gmatcher.match(path));
  });
}

/***/ }),

/***/ 9953:
/*!***********************************!*\
  !*** ./node_modules/glob/glob.js ***!
  \***********************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// Approach:
//
// 1. Get the minimatch set
// 2. For each pattern in the set, PROCESS(pattern, false)
// 3. Store matches per-set, then uniq them
//
// PROCESS(pattern, inGlobStar)
// Get the first [n] items from pattern that are all strings
// Join these together.  This is PREFIX.
//   If there is no more remaining, then stat(PREFIX) and
//   add to matches if it succeeds.  END.
//
// If inGlobStar and PREFIX is symlink and points to dir
//   set ENTRIES = []
// else readdir(PREFIX) as ENTRIES
//   If fail, END
//
// with ENTRIES
//   If pattern[n] is GLOBSTAR
//     // handle the case where the globstar match is empty
//     // by pruning it out, and testing the resulting pattern
//     PROCESS(pattern[0..n] + pattern[n+1 .. $], false)
//     // handle other cases.
//     for ENTRY in ENTRIES (not dotfiles)
//       // attach globstar + tail onto the entry
//       // Mark that this entry is a globstar match
//       PROCESS(pattern[0..n] + ENTRY + pattern[n .. $], true)
//
//   else // not globstar
//     for ENTRY in ENTRIES (not dotfiles, unless pattern[n] is dot)
//       Test ENTRY against pattern[n]
//       If fails, continue
//       If passes, PROCESS(pattern[0..n] + item + pattern[n+1 .. $])
//
// Caveat:
//   Cache all stats and readdirs results to minimize syscall.  Since all
//   we ever care about is existence and directory-ness, we can just keep
//   `true` for files, and [children,...] for directories, or `false` for
//   things that don't exist.

module.exports = glob;
var fs = __webpack_require__(/*! fs */ 2089);
var rp = __webpack_require__(/*! fs.realpath */ 7990);
var minimatch = __webpack_require__(/*! minimatch */ 6091);
var Minimatch = minimatch.Minimatch;
var inherits = __webpack_require__(/*! inherits */ 7694);
var EE = (__webpack_require__(/*! events */ 2361).EventEmitter);
var path = __webpack_require__(/*! path */ 3056);
var assert = __webpack_require__(/*! assert */ 9491);
var isAbsolute = __webpack_require__(/*! path-is-absolute */ 5450);
var globSync = __webpack_require__(/*! ./sync.js */ 6109);
var common = __webpack_require__(/*! ./common.js */ 6064);
var alphasort = common.alphasort;
var alphasorti = common.alphasorti;
var setopts = common.setopts;
var ownProp = common.ownProp;
var inflight = __webpack_require__(/*! inflight */ 9123);
var util = __webpack_require__(/*! util */ 3837);
var childrenIgnored = common.childrenIgnored;
var isIgnored = common.isIgnored;
var once = __webpack_require__(/*! once */ 5831);
function glob(pattern, options, cb) {
  if (typeof options === 'function') cb = options, options = {};
  if (!options) options = {};
  if (options.sync) {
    if (cb) throw new TypeError('callback provided to sync glob');
    return globSync(pattern, options);
  }
  return new Glob(pattern, options, cb);
}
glob.sync = globSync;
var GlobSync = glob.GlobSync = globSync.GlobSync;

// old api surface
glob.glob = glob;
function extend(origin, add) {
  if (add === null || typeof add !== 'object') {
    return origin;
  }
  var keys = Object.keys(add);
  var i = keys.length;
  while (i--) {
    origin[keys[i]] = add[keys[i]];
  }
  return origin;
}
glob.hasMagic = function (pattern, options_) {
  var options = extend({}, options_);
  options.noprocess = true;
  var g = new Glob(pattern, options);
  var set = g.minimatch.set;
  if (!pattern) return false;
  if (set.length > 1) return true;
  for (var j = 0; j < set[0].length; j++) {
    if (typeof set[0][j] !== 'string') return true;
  }
  return false;
};
glob.Glob = Glob;
inherits(Glob, EE);
function Glob(pattern, options, cb) {
  if (typeof options === 'function') {
    cb = options;
    options = null;
  }
  if (options && options.sync) {
    if (cb) throw new TypeError('callback provided to sync glob');
    return new GlobSync(pattern, options);
  }
  if (!(this instanceof Glob)) return new Glob(pattern, options, cb);
  setopts(this, pattern, options);
  this._didRealPath = false;

  // process each pattern in the minimatch set
  var n = this.minimatch.set.length;

  // The matches are stored as {<filename>: true,...} so that
  // duplicates are automagically pruned.
  // Later, we do an Object.keys() on these.
  // Keep them as a list so we can fill in when nonull is set.
  this.matches = new Array(n);
  if (typeof cb === 'function') {
    cb = once(cb);
    this.on('error', cb);
    this.on('end', function (matches) {
      cb(null, matches);
    });
  }
  var self = this;
  this._processing = 0;
  this._emitQueue = [];
  this._processQueue = [];
  this.paused = false;
  if (this.noprocess) return this;
  if (n === 0) return done();
  var sync = true;
  for (var i = 0; i < n; i++) {
    this._process(this.minimatch.set[i], i, false, done);
  }
  sync = false;
  function done() {
    --self._processing;
    if (self._processing <= 0) {
      if (sync) {
        process.nextTick(function () {
          self._finish();
        });
      } else {
        self._finish();
      }
    }
  }
}
Glob.prototype._finish = function () {
  assert(this instanceof Glob);
  if (this.aborted) return;
  if (this.realpath && !this._didRealpath) return this._realpath();
  common.finish(this);
  this.emit('end', this.found);
};
Glob.prototype._realpath = function () {
  if (this._didRealpath) return;
  this._didRealpath = true;
  var n = this.matches.length;
  if (n === 0) return this._finish();
  var self = this;
  for (var i = 0; i < this.matches.length; i++) this._realpathSet(i, next);
  function next() {
    if (--n === 0) self._finish();
  }
};
Glob.prototype._realpathSet = function (index, cb) {
  var matchset = this.matches[index];
  if (!matchset) return cb();
  var found = Object.keys(matchset);
  var self = this;
  var n = found.length;
  if (n === 0) return cb();
  var set = this.matches[index] = Object.create(null);
  found.forEach(function (p, i) {
    // If there's a problem with the stat, then it means that
    // one or more of the links in the realpath couldn't be
    // resolved.  just return the abs value in that case.
    p = self._makeAbs(p);
    rp.realpath(p, self.realpathCache, function (er, real) {
      if (!er) set[real] = true;else if (er.syscall === 'stat') set[p] = true;else self.emit('error', er); // srsly wtf right here

      if (--n === 0) {
        self.matches[index] = set;
        cb();
      }
    });
  });
};
Glob.prototype._mark = function (p) {
  return common.mark(this, p);
};
Glob.prototype._makeAbs = function (f) {
  return common.makeAbs(this, f);
};
Glob.prototype.abort = function () {
  this.aborted = true;
  this.emit('abort');
};
Glob.prototype.pause = function () {
  if (!this.paused) {
    this.paused = true;
    this.emit('pause');
  }
};
Glob.prototype.resume = function () {
  if (this.paused) {
    this.emit('resume');
    this.paused = false;
    if (this._emitQueue.length) {
      var eq = this._emitQueue.slice(0);
      this._emitQueue.length = 0;
      for (var i = 0; i < eq.length; i++) {
        var e = eq[i];
        this._emitMatch(e[0], e[1]);
      }
    }
    if (this._processQueue.length) {
      var pq = this._processQueue.slice(0);
      this._processQueue.length = 0;
      for (var i = 0; i < pq.length; i++) {
        var p = pq[i];
        this._processing--;
        this._process(p[0], p[1], p[2], p[3]);
      }
    }
  }
};
Glob.prototype._process = function (pattern, index, inGlobStar, cb) {
  assert(this instanceof Glob);
  assert(typeof cb === 'function');
  if (this.aborted) return;
  this._processing++;
  if (this.paused) {
    this._processQueue.push([pattern, index, inGlobStar, cb]);
    return;
  }

  //console.error('PROCESS %d', this._processing, pattern)

  // Get the first [n] parts of pattern that are all strings.
  var n = 0;
  while (typeof pattern[n] === 'string') {
    n++;
  }
  // now n is the index of the first one that is *not* a string.

  // see if there's anything else
  var prefix;
  switch (n) {
    // if not, then this is rather simple
    case pattern.length:
      this._processSimple(pattern.join('/'), index, cb);
      return;
    case 0:
      // pattern *starts* with some non-trivial item.
      // going to readdir(cwd), but not include the prefix in matches.
      prefix = null;
      break;
    default:
      // pattern has some string bits in the front.
      // whatever it starts with, whether that's 'absolute' like /foo/bar,
      // or 'relative' like '../baz'
      prefix = pattern.slice(0, n).join('/');
      break;
  }
  var remain = pattern.slice(n);

  // get the list of entries.
  var read;
  if (prefix === null) read = '.';else if (isAbsolute(prefix) || isAbsolute(pattern.join('/'))) {
    if (!prefix || !isAbsolute(prefix)) prefix = '/' + prefix;
    read = prefix;
  } else read = prefix;
  var abs = this._makeAbs(read);

  //if ignored, skip _processing
  if (childrenIgnored(this, read)) return cb();
  var isGlobStar = remain[0] === minimatch.GLOBSTAR;
  if (isGlobStar) this._processGlobStar(prefix, read, abs, remain, index, inGlobStar, cb);else this._processReaddir(prefix, read, abs, remain, index, inGlobStar, cb);
};
Glob.prototype._processReaddir = function (prefix, read, abs, remain, index, inGlobStar, cb) {
  var self = this;
  this._readdir(abs, inGlobStar, function (er, entries) {
    return self._processReaddir2(prefix, read, abs, remain, index, inGlobStar, entries, cb);
  });
};
Glob.prototype._processReaddir2 = function (prefix, read, abs, remain, index, inGlobStar, entries, cb) {
  // if the abs isn't a dir, then nothing can match!
  if (!entries) return cb();

  // It will only match dot entries if it starts with a dot, or if
  // dot is set.  Stuff like @(.foo|.bar) isn't allowed.
  var pn = remain[0];
  var negate = !!this.minimatch.negate;
  var rawGlob = pn._glob;
  var dotOk = this.dot || rawGlob.charAt(0) === '.';
  var matchedEntries = [];
  for (var i = 0; i < entries.length; i++) {
    var e = entries[i];
    if (e.charAt(0) !== '.' || dotOk) {
      var m;
      if (negate && !prefix) {
        m = !e.match(pn);
      } else {
        m = e.match(pn);
      }
      if (m) matchedEntries.push(e);
    }
  }

  //console.error('prd2', prefix, entries, remain[0]._glob, matchedEntries)

  var len = matchedEntries.length;
  // If there are no matched entries, then nothing matches.
  if (len === 0) return cb();

  // if this is the last remaining pattern bit, then no need for
  // an additional stat *unless* the user has specified mark or
  // stat explicitly.  We know they exist, since readdir returned
  // them.

  if (remain.length === 1 && !this.mark && !this.stat) {
    if (!this.matches[index]) this.matches[index] = Object.create(null);
    for (var i = 0; i < len; i++) {
      var e = matchedEntries[i];
      if (prefix) {
        if (prefix !== '/') e = prefix + '/' + e;else e = prefix + e;
      }
      if (e.charAt(0) === '/' && !this.nomount) {
        e = path.join(this.root, e);
      }
      this._emitMatch(index, e);
    }
    // This was the last one, and no stats were needed
    return cb();
  }

  // now test all matched entries as stand-ins for that part
  // of the pattern.
  remain.shift();
  for (var i = 0; i < len; i++) {
    var e = matchedEntries[i];
    var newPattern;
    if (prefix) {
      if (prefix !== '/') e = prefix + '/' + e;else e = prefix + e;
    }
    this._process([e].concat(remain), index, inGlobStar, cb);
  }
  cb();
};
Glob.prototype._emitMatch = function (index, e) {
  if (this.aborted) return;
  if (isIgnored(this, e)) return;
  if (this.paused) {
    this._emitQueue.push([index, e]);
    return;
  }
  var abs = isAbsolute(e) ? e : this._makeAbs(e);
  if (this.mark) e = this._mark(e);
  if (this.absolute) e = abs;
  if (this.matches[index][e]) return;
  if (this.nodir) {
    var c = this.cache[abs];
    if (c === 'DIR' || Array.isArray(c)) return;
  }
  this.matches[index][e] = true;
  var st = this.statCache[abs];
  if (st) this.emit('stat', e, st);
  this.emit('match', e);
};
Glob.prototype._readdirInGlobStar = function (abs, cb) {
  if (this.aborted) return;

  // follow all symlinked directories forever
  // just proceed as if this is a non-globstar situation
  if (this.follow) return this._readdir(abs, false, cb);
  var lstatkey = 'lstat\0' + abs;
  var self = this;
  var lstatcb = inflight(lstatkey, lstatcb_);
  if (lstatcb) fs.lstat(abs, lstatcb);
  function lstatcb_(er, lstat) {
    if (er && er.code === 'ENOENT') return cb();
    var isSym = lstat && lstat.isSymbolicLink();
    self.symlinks[abs] = isSym;

    // If it's not a symlink or a dir, then it's definitely a regular file.
    // don't bother doing a readdir in that case.
    if (!isSym && lstat && !lstat.isDirectory()) {
      self.cache[abs] = 'FILE';
      cb();
    } else self._readdir(abs, false, cb);
  }
};
Glob.prototype._readdir = function (abs, inGlobStar, cb) {
  if (this.aborted) return;
  cb = inflight('readdir\0' + abs + '\0' + inGlobStar, cb);
  if (!cb) return;

  //console.error('RD %j %j', +inGlobStar, abs)
  if (inGlobStar && !ownProp(this.symlinks, abs)) return this._readdirInGlobStar(abs, cb);
  if (ownProp(this.cache, abs)) {
    var c = this.cache[abs];
    if (!c || c === 'FILE') return cb();
    if (Array.isArray(c)) return cb(null, c);
  }
  var self = this;
  fs.readdir(abs, readdirCb(this, abs, cb));
};
function readdirCb(self, abs, cb) {
  return function (er, entries) {
    if (er) self._readdirError(abs, er, cb);else self._readdirEntries(abs, entries, cb);
  };
}
Glob.prototype._readdirEntries = function (abs, entries, cb) {
  if (this.aborted) return;

  // if we haven't asked to stat everything, then just
  // assume that everything in there exists, so we can avoid
  // having to stat it a second time.
  if (!this.mark && !this.stat) {
    for (var i = 0; i < entries.length; i++) {
      var e = entries[i];
      if (abs === '/') e = abs + e;else e = abs + '/' + e;
      this.cache[e] = true;
    }
  }
  this.cache[abs] = entries;
  return cb(null, entries);
};
Glob.prototype._readdirError = function (f, er, cb) {
  if (this.aborted) return;

  // handle errors, and cache the information
  switch (er.code) {
    case 'ENOTSUP': // https://github.com/isaacs/node-glob/issues/205
    case 'ENOTDIR':
      // totally normal. means it *does* exist.
      var abs = this._makeAbs(f);
      this.cache[abs] = 'FILE';
      if (abs === this.cwdAbs) {
        var error = new Error(er.code + ' invalid cwd ' + this.cwd);
        error.path = this.cwd;
        error.code = er.code;
        this.emit('error', error);
        this.abort();
      }
      break;
    case 'ENOENT': // not terribly unusual
    case 'ELOOP':
    case 'ENAMETOOLONG':
    case 'UNKNOWN':
      this.cache[this._makeAbs(f)] = false;
      break;
    default:
      // some unusual error.  Treat as failure.
      this.cache[this._makeAbs(f)] = false;
      if (this.strict) {
        this.emit('error', er);
        // If the error is handled, then we abort
        // if not, we threw out of here
        this.abort();
      }
      if (!this.silent) console.error('glob error', er);
      break;
  }
  return cb();
};
Glob.prototype._processGlobStar = function (prefix, read, abs, remain, index, inGlobStar, cb) {
  var self = this;
  this._readdir(abs, inGlobStar, function (er, entries) {
    self._processGlobStar2(prefix, read, abs, remain, index, inGlobStar, entries, cb);
  });
};
Glob.prototype._processGlobStar2 = function (prefix, read, abs, remain, index, inGlobStar, entries, cb) {
  //console.error('pgs2', prefix, remain[0], entries)

  // no entries means not a dir, so it can never have matches
  // foo.txt/** doesn't match foo.txt
  if (!entries) return cb();

  // test without the globstar, and with every child both below
  // and replacing the globstar.
  var remainWithoutGlobStar = remain.slice(1);
  var gspref = prefix ? [prefix] : [];
  var noGlobStar = gspref.concat(remainWithoutGlobStar);

  // the noGlobStar pattern exits the inGlobStar state
  this._process(noGlobStar, index, false, cb);
  var isSym = this.symlinks[abs];
  var len = entries.length;

  // If it's a symlink, and we're in a globstar, then stop
  if (isSym && inGlobStar) return cb();
  for (var i = 0; i < len; i++) {
    var e = entries[i];
    if (e.charAt(0) === '.' && !this.dot) continue;

    // these two cases enter the inGlobStar state
    var instead = gspref.concat(entries[i], remainWithoutGlobStar);
    this._process(instead, index, true, cb);
    var below = gspref.concat(entries[i], remain);
    this._process(below, index, true, cb);
  }
  cb();
};
Glob.prototype._processSimple = function (prefix, index, cb) {
  // XXX review this.  Shouldn't it be doing the mounting etc
  // before doing stat?  kinda weird?
  var self = this;
  this._stat(prefix, function (er, exists) {
    self._processSimple2(prefix, index, er, exists, cb);
  });
};
Glob.prototype._processSimple2 = function (prefix, index, er, exists, cb) {
  //console.error('ps2', prefix, exists)

  if (!this.matches[index]) this.matches[index] = Object.create(null);

  // If it doesn't exist, then just mark the lack of results
  if (!exists) return cb();
  if (prefix && isAbsolute(prefix) && !this.nomount) {
    var trail = /[\/\\]$/.test(prefix);
    if (prefix.charAt(0) === '/') {
      prefix = path.join(this.root, prefix);
    } else {
      prefix = path.resolve(this.root, prefix);
      if (trail) prefix += '/';
    }
  }
  if (process.platform === 'win32') prefix = prefix.replace(/\\/g, '/');

  // Mark this as a match
  this._emitMatch(index, prefix);
  cb();
};

// Returns either 'DIR', 'FILE', or false
Glob.prototype._stat = function (f, cb) {
  var abs = this._makeAbs(f);
  var needDir = f.slice(-1) === '/';
  if (f.length > this.maxLength) return cb();
  if (!this.stat && ownProp(this.cache, abs)) {
    var c = this.cache[abs];
    if (Array.isArray(c)) c = 'DIR';

    // It exists, but maybe not how we need it
    if (!needDir || c === 'DIR') return cb(null, c);
    if (needDir && c === 'FILE') return cb();

    // otherwise we have to stat, because maybe c=true
    // if we know it exists, but not what it is.
  }

  var exists;
  var stat = this.statCache[abs];
  if (stat !== undefined) {
    if (stat === false) return cb(null, stat);else {
      var type = stat.isDirectory() ? 'DIR' : 'FILE';
      if (needDir && type === 'FILE') return cb();else return cb(null, type, stat);
    }
  }
  var self = this;
  var statcb = inflight('stat\0' + abs, lstatcb_);
  if (statcb) fs.lstat(abs, statcb);
  function lstatcb_(er, lstat) {
    if (lstat && lstat.isSymbolicLink()) {
      // If it's a symlink, then treat it as the target, unless
      // the target does not exist, then treat it as a file.
      return fs.stat(abs, function (er, stat) {
        if (er) self._stat2(f, abs, null, lstat, cb);else self._stat2(f, abs, er, stat, cb);
      });
    } else {
      self._stat2(f, abs, er, lstat, cb);
    }
  }
};
Glob.prototype._stat2 = function (f, abs, er, stat, cb) {
  if (er && (er.code === 'ENOENT' || er.code === 'ENOTDIR')) {
    this.statCache[abs] = false;
    return cb();
  }
  var needDir = f.slice(-1) === '/';
  this.statCache[abs] = stat;
  if (abs.slice(-1) === '/' && stat && !stat.isDirectory()) return cb(null, false, stat);
  var c = true;
  if (stat) c = stat.isDirectory() ? 'DIR' : 'FILE';
  this.cache[abs] = this.cache[abs] || c;
  if (needDir && c === 'FILE') return cb();
  return cb(null, c, stat);
};

/***/ }),

/***/ 6109:
/*!***********************************!*\
  !*** ./node_modules/glob/sync.js ***!
  \***********************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

module.exports = globSync;
globSync.GlobSync = GlobSync;
var fs = __webpack_require__(/*! fs */ 2089);
var rp = __webpack_require__(/*! fs.realpath */ 7990);
var minimatch = __webpack_require__(/*! minimatch */ 6091);
var Minimatch = minimatch.Minimatch;
var Glob = (__webpack_require__(/*! ./glob.js */ 9953).Glob);
var util = __webpack_require__(/*! util */ 3837);
var path = __webpack_require__(/*! path */ 3056);
var assert = __webpack_require__(/*! assert */ 9491);
var isAbsolute = __webpack_require__(/*! path-is-absolute */ 5450);
var common = __webpack_require__(/*! ./common.js */ 6064);
var alphasort = common.alphasort;
var alphasorti = common.alphasorti;
var setopts = common.setopts;
var ownProp = common.ownProp;
var childrenIgnored = common.childrenIgnored;
var isIgnored = common.isIgnored;
function globSync(pattern, options) {
  if (typeof options === 'function' || arguments.length === 3) throw new TypeError('callback provided to sync glob\n' + 'See: https://github.com/isaacs/node-glob/issues/167');
  return new GlobSync(pattern, options).found;
}
function GlobSync(pattern, options) {
  if (!pattern) throw new Error('must provide pattern');
  if (typeof options === 'function' || arguments.length === 3) throw new TypeError('callback provided to sync glob\n' + 'See: https://github.com/isaacs/node-glob/issues/167');
  if (!(this instanceof GlobSync)) return new GlobSync(pattern, options);
  setopts(this, pattern, options);
  if (this.noprocess) return this;
  var n = this.minimatch.set.length;
  this.matches = new Array(n);
  for (var i = 0; i < n; i++) {
    this._process(this.minimatch.set[i], i, false);
  }
  this._finish();
}
GlobSync.prototype._finish = function () {
  assert(this instanceof GlobSync);
  if (this.realpath) {
    var self = this;
    this.matches.forEach(function (matchset, index) {
      var set = self.matches[index] = Object.create(null);
      for (var p in matchset) {
        try {
          p = self._makeAbs(p);
          var real = rp.realpathSync(p, self.realpathCache);
          set[real] = true;
        } catch (er) {
          if (er.syscall === 'stat') set[self._makeAbs(p)] = true;else throw er;
        }
      }
    });
  }
  common.finish(this);
};
GlobSync.prototype._process = function (pattern, index, inGlobStar) {
  assert(this instanceof GlobSync);

  // Get the first [n] parts of pattern that are all strings.
  var n = 0;
  while (typeof pattern[n] === 'string') {
    n++;
  }
  // now n is the index of the first one that is *not* a string.

  // See if there's anything else
  var prefix;
  switch (n) {
    // if not, then this is rather simple
    case pattern.length:
      this._processSimple(pattern.join('/'), index);
      return;
    case 0:
      // pattern *starts* with some non-trivial item.
      // going to readdir(cwd), but not include the prefix in matches.
      prefix = null;
      break;
    default:
      // pattern has some string bits in the front.
      // whatever it starts with, whether that's 'absolute' like /foo/bar,
      // or 'relative' like '../baz'
      prefix = pattern.slice(0, n).join('/');
      break;
  }
  var remain = pattern.slice(n);

  // get the list of entries.
  var read;
  if (prefix === null) read = '.';else if (isAbsolute(prefix) || isAbsolute(pattern.join('/'))) {
    if (!prefix || !isAbsolute(prefix)) prefix = '/' + prefix;
    read = prefix;
  } else read = prefix;
  var abs = this._makeAbs(read);

  //if ignored, skip processing
  if (childrenIgnored(this, read)) return;
  var isGlobStar = remain[0] === minimatch.GLOBSTAR;
  if (isGlobStar) this._processGlobStar(prefix, read, abs, remain, index, inGlobStar);else this._processReaddir(prefix, read, abs, remain, index, inGlobStar);
};
GlobSync.prototype._processReaddir = function (prefix, read, abs, remain, index, inGlobStar) {
  var entries = this._readdir(abs, inGlobStar);

  // if the abs isn't a dir, then nothing can match!
  if (!entries) return;

  // It will only match dot entries if it starts with a dot, or if
  // dot is set.  Stuff like @(.foo|.bar) isn't allowed.
  var pn = remain[0];
  var negate = !!this.minimatch.negate;
  var rawGlob = pn._glob;
  var dotOk = this.dot || rawGlob.charAt(0) === '.';
  var matchedEntries = [];
  for (var i = 0; i < entries.length; i++) {
    var e = entries[i];
    if (e.charAt(0) !== '.' || dotOk) {
      var m;
      if (negate && !prefix) {
        m = !e.match(pn);
      } else {
        m = e.match(pn);
      }
      if (m) matchedEntries.push(e);
    }
  }
  var len = matchedEntries.length;
  // If there are no matched entries, then nothing matches.
  if (len === 0) return;

  // if this is the last remaining pattern bit, then no need for
  // an additional stat *unless* the user has specified mark or
  // stat explicitly.  We know they exist, since readdir returned
  // them.

  if (remain.length === 1 && !this.mark && !this.stat) {
    if (!this.matches[index]) this.matches[index] = Object.create(null);
    for (var i = 0; i < len; i++) {
      var e = matchedEntries[i];
      if (prefix) {
        if (prefix.slice(-1) !== '/') e = prefix + '/' + e;else e = prefix + e;
      }
      if (e.charAt(0) === '/' && !this.nomount) {
        e = path.join(this.root, e);
      }
      this._emitMatch(index, e);
    }
    // This was the last one, and no stats were needed
    return;
  }

  // now test all matched entries as stand-ins for that part
  // of the pattern.
  remain.shift();
  for (var i = 0; i < len; i++) {
    var e = matchedEntries[i];
    var newPattern;
    if (prefix) newPattern = [prefix, e];else newPattern = [e];
    this._process(newPattern.concat(remain), index, inGlobStar);
  }
};
GlobSync.prototype._emitMatch = function (index, e) {
  if (isIgnored(this, e)) return;
  var abs = this._makeAbs(e);
  if (this.mark) e = this._mark(e);
  if (this.absolute) {
    e = abs;
  }
  if (this.matches[index][e]) return;
  if (this.nodir) {
    var c = this.cache[abs];
    if (c === 'DIR' || Array.isArray(c)) return;
  }
  this.matches[index][e] = true;
  if (this.stat) this._stat(e);
};
GlobSync.prototype._readdirInGlobStar = function (abs) {
  // follow all symlinked directories forever
  // just proceed as if this is a non-globstar situation
  if (this.follow) return this._readdir(abs, false);
  var entries;
  var lstat;
  var stat;
  try {
    lstat = fs.lstatSync(abs);
  } catch (er) {
    if (er.code === 'ENOENT') {
      // lstat failed, doesn't exist
      return null;
    }
  }
  var isSym = lstat && lstat.isSymbolicLink();
  this.symlinks[abs] = isSym;

  // If it's not a symlink or a dir, then it's definitely a regular file.
  // don't bother doing a readdir in that case.
  if (!isSym && lstat && !lstat.isDirectory()) this.cache[abs] = 'FILE';else entries = this._readdir(abs, false);
  return entries;
};
GlobSync.prototype._readdir = function (abs, inGlobStar) {
  var entries;
  if (inGlobStar && !ownProp(this.symlinks, abs)) return this._readdirInGlobStar(abs);
  if (ownProp(this.cache, abs)) {
    var c = this.cache[abs];
    if (!c || c === 'FILE') return null;
    if (Array.isArray(c)) return c;
  }
  try {
    return this._readdirEntries(abs, fs.readdirSync(abs));
  } catch (er) {
    this._readdirError(abs, er);
    return null;
  }
};
GlobSync.prototype._readdirEntries = function (abs, entries) {
  // if we haven't asked to stat everything, then just
  // assume that everything in there exists, so we can avoid
  // having to stat it a second time.
  if (!this.mark && !this.stat) {
    for (var i = 0; i < entries.length; i++) {
      var e = entries[i];
      if (abs === '/') e = abs + e;else e = abs + '/' + e;
      this.cache[e] = true;
    }
  }
  this.cache[abs] = entries;

  // mark and cache dir-ness
  return entries;
};
GlobSync.prototype._readdirError = function (f, er) {
  // handle errors, and cache the information
  switch (er.code) {
    case 'ENOTSUP': // https://github.com/isaacs/node-glob/issues/205
    case 'ENOTDIR':
      // totally normal. means it *does* exist.
      var abs = this._makeAbs(f);
      this.cache[abs] = 'FILE';
      if (abs === this.cwdAbs) {
        var error = new Error(er.code + ' invalid cwd ' + this.cwd);
        error.path = this.cwd;
        error.code = er.code;
        throw error;
      }
      break;
    case 'ENOENT': // not terribly unusual
    case 'ELOOP':
    case 'ENAMETOOLONG':
    case 'UNKNOWN':
      this.cache[this._makeAbs(f)] = false;
      break;
    default:
      // some unusual error.  Treat as failure.
      this.cache[this._makeAbs(f)] = false;
      if (this.strict) throw er;
      if (!this.silent) console.error('glob error', er);
      break;
  }
};
GlobSync.prototype._processGlobStar = function (prefix, read, abs, remain, index, inGlobStar) {
  var entries = this._readdir(abs, inGlobStar);

  // no entries means not a dir, so it can never have matches
  // foo.txt/** doesn't match foo.txt
  if (!entries) return;

  // test without the globstar, and with every child both below
  // and replacing the globstar.
  var remainWithoutGlobStar = remain.slice(1);
  var gspref = prefix ? [prefix] : [];
  var noGlobStar = gspref.concat(remainWithoutGlobStar);

  // the noGlobStar pattern exits the inGlobStar state
  this._process(noGlobStar, index, false);
  var len = entries.length;
  var isSym = this.symlinks[abs];

  // If it's a symlink, and we're in a globstar, then stop
  if (isSym && inGlobStar) return;
  for (var i = 0; i < len; i++) {
    var e = entries[i];
    if (e.charAt(0) === '.' && !this.dot) continue;

    // these two cases enter the inGlobStar state
    var instead = gspref.concat(entries[i], remainWithoutGlobStar);
    this._process(instead, index, true);
    var below = gspref.concat(entries[i], remain);
    this._process(below, index, true);
  }
};
GlobSync.prototype._processSimple = function (prefix, index) {
  // XXX review this.  Shouldn't it be doing the mounting etc
  // before doing stat?  kinda weird?
  var exists = this._stat(prefix);
  if (!this.matches[index]) this.matches[index] = Object.create(null);

  // If it doesn't exist, then just mark the lack of results
  if (!exists) return;
  if (prefix && isAbsolute(prefix) && !this.nomount) {
    var trail = /[\/\\]$/.test(prefix);
    if (prefix.charAt(0) === '/') {
      prefix = path.join(this.root, prefix);
    } else {
      prefix = path.resolve(this.root, prefix);
      if (trail) prefix += '/';
    }
  }
  if (process.platform === 'win32') prefix = prefix.replace(/\\/g, '/');

  // Mark this as a match
  this._emitMatch(index, prefix);
};

// Returns either 'DIR', 'FILE', or false
GlobSync.prototype._stat = function (f) {
  var abs = this._makeAbs(f);
  var needDir = f.slice(-1) === '/';
  if (f.length > this.maxLength) return false;
  if (!this.stat && ownProp(this.cache, abs)) {
    var c = this.cache[abs];
    if (Array.isArray(c)) c = 'DIR';

    // It exists, but maybe not how we need it
    if (!needDir || c === 'DIR') return c;
    if (needDir && c === 'FILE') return false;

    // otherwise we have to stat, because maybe c=true
    // if we know it exists, but not what it is.
  }

  var exists;
  var stat = this.statCache[abs];
  if (!stat) {
    var lstat;
    try {
      lstat = fs.lstatSync(abs);
    } catch (er) {
      if (er && (er.code === 'ENOENT' || er.code === 'ENOTDIR')) {
        this.statCache[abs] = false;
        return false;
      }
    }
    if (lstat && lstat.isSymbolicLink()) {
      try {
        stat = fs.statSync(abs);
      } catch (er) {
        stat = lstat;
      }
    } else {
      stat = lstat;
    }
  }
  this.statCache[abs] = stat;
  var c = true;
  if (stat) c = stat.isDirectory() ? 'DIR' : 'FILE';
  this.cache[abs] = this.cache[abs] || c;
  if (needDir && c === 'FILE') return false;
  return c;
};
GlobSync.prototype._mark = function (p) {
  return common.mark(this, p);
};
GlobSync.prototype._makeAbs = function (f) {
  return common.makeAbs(this, f);
};

/***/ }),

/***/ 9123:
/*!*******************************************!*\
  !*** ./node_modules/inflight/inflight.js ***!
  \*******************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var wrappy = __webpack_require__(/*! wrappy */ 341);
var reqs = Object.create(null);
var once = __webpack_require__(/*! once */ 5831);
module.exports = wrappy(inflight);
function inflight(key, cb) {
  if (reqs[key]) {
    reqs[key].push(cb);
    return null;
  } else {
    reqs[key] = [cb];
    return makeres(key);
  }
}
function makeres(key) {
  return once(function RES() {
    var cbs = reqs[key];
    var len = cbs.length;
    var args = slice(arguments);

    // XXX It's somewhat ambiguous whether a new callback added in this
    // pass should be queued for later execution if something in the
    // list of callbacks throws, or if it should just be discarded.
    // However, it's such an edge case that it hardly matters, and either
    // choice is likely as surprising as the other.
    // As it happens, we do go ahead and schedule it for later execution.
    try {
      for (var i = 0; i < len; i++) {
        cbs[i].apply(null, args);
      }
    } finally {
      if (cbs.length > len) {
        // added more in the interim.
        // de-zalgo, just in case, but don't call again.
        cbs.splice(0, len);
        process.nextTick(function () {
          RES.apply(null, args);
        });
      } else {
        delete reqs[key];
      }
    }
  });
}
function slice(args) {
  var length = args.length;
  var array = [];
  for (var i = 0; i < length; i++) array[i] = args[i];
  return array;
}

/***/ }),

/***/ 7694:
/*!***************************************************!*\
  !*** ./node_modules/inherits/inherits_browser.js ***!
  \***************************************************/
/***/ ((module) => {

if (typeof Object.create === 'function') {
  // implementation from standard node.js 'util' module
  module.exports = function inherits(ctor, superCtor) {
    if (superCtor) {
      ctor.super_ = superCtor;
      ctor.prototype = Object.create(superCtor.prototype, {
        constructor: {
          value: ctor,
          enumerable: false,
          writable: true,
          configurable: true
        }
      });
    }
  };
} else {
  // old school shim for old browsers
  module.exports = function inherits(ctor, superCtor) {
    if (superCtor) {
      ctor.super_ = superCtor;
      var TempCtor = function () {};
      TempCtor.prototype = superCtor.prototype;
      ctor.prototype = new TempCtor();
      ctor.prototype.constructor = ctor;
    }
  };
}

/***/ }),

/***/ 456:
/*!************************************!*\
  !*** ./node_modules/jsbn/index.js ***!
  \************************************/
/***/ (function(module, exports) {

(function () {
  // Copyright (c) 2005  Tom Wu
  // All Rights Reserved.
  // See "LICENSE" for details.

  // Basic JavaScript BN library - subset useful for RSA encryption.

  // Bits per digit
  var dbits;

  // JavaScript engine analysis
  var canary = 0xdeadbeefcafe;
  var j_lm = (canary & 0xffffff) == 0xefcafe;

  // (public) Constructor
  function BigInteger(a, b, c) {
    if (a != null) if ("number" == typeof a) this.fromNumber(a, b, c);else if (b == null && "string" != typeof a) this.fromString(a, 256);else this.fromString(a, b);
  }

  // return new, unset BigInteger
  function nbi() {
    return new BigInteger(null);
  }

  // am: Compute w_j += (x*this_i), propagate carries,
  // c is initial carry, returns final carry.
  // c < 3*dvalue, x < 2*dvalue, this_i < dvalue
  // We need to select the fastest one that works in this environment.

  // am1: use a single mult and divide to get the high bits,
  // max digit bits should be 26 because
  // max internal value = 2*dvalue^2-2*dvalue (< 2^53)
  function am1(i, x, w, j, c, n) {
    while (--n >= 0) {
      var v = x * this[i++] + w[j] + c;
      c = Math.floor(v / 0x4000000);
      w[j++] = v & 0x3ffffff;
    }
    return c;
  }
  // am2 avoids a big mult-and-extract completely.
  // Max digit bits should be <= 30 because we do bitwise ops
  // on values up to 2*hdvalue^2-hdvalue-1 (< 2^31)
  function am2(i, x, w, j, c, n) {
    var xl = x & 0x7fff,
      xh = x >> 15;
    while (--n >= 0) {
      var l = this[i] & 0x7fff;
      var h = this[i++] >> 15;
      var m = xh * l + h * xl;
      l = xl * l + ((m & 0x7fff) << 15) + w[j] + (c & 0x3fffffff);
      c = (l >>> 30) + (m >>> 15) + xh * h + (c >>> 30);
      w[j++] = l & 0x3fffffff;
    }
    return c;
  }
  // Alternately, set max digit bits to 28 since some
  // browsers slow down when dealing with 32-bit numbers.
  function am3(i, x, w, j, c, n) {
    var xl = x & 0x3fff,
      xh = x >> 14;
    while (--n >= 0) {
      var l = this[i] & 0x3fff;
      var h = this[i++] >> 14;
      var m = xh * l + h * xl;
      l = xl * l + ((m & 0x3fff) << 14) + w[j] + c;
      c = (l >> 28) + (m >> 14) + xh * h;
      w[j++] = l & 0xfffffff;
    }
    return c;
  }
  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 {
    // Mozilla/Netscape seems to prefer am3
    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;

  // Digit conversions
  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, i) {
    var c = BI_RC[s.charCodeAt(i)];
    return c == null ? -1 : c;
  }

  // (protected) copy this to r
  function bnpCopyTo(r) {
    for (var i = this.t - 1; i >= 0; --i) r[i] = this[i];
    r.t = this.t;
    r.s = this.s;
  }

  // (protected) set from integer value x, -DV <= x < DV
  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;
  }

  // return bigint initialized to value
  function nbv(i) {
    var r = nbi();
    r.fromInt(i);
    return r;
  }

  // (protected) set from string and radix
  function bnpFromString(s, b) {
    var k;
    if (b == 16) k = 4;else if (b == 8) k = 3;else if (b == 256) k = 8; // byte array
    else if (b == 2) k = 1;else if (b == 32) k = 5;else if (b == 4) k = 2;else {
      this.fromRadix(s, b);
      return;
    }
    this.t = 0;
    this.s = 0;
    var i = s.length,
      mi = false,
      sh = 0;
    while (--i >= 0) {
      var x = k == 8 ? s[i] & 0xff : intAt(s, i);
      if (x < 0) {
        if (s.charAt(i) == "-") 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] & 0x80) != 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);
  }

  // (protected) clamp off excess high words
  function bnpClamp() {
    var c = this.s & this.DM;
    while (this.t > 0 && this[this.t - 1] == c) --this.t;
  }

  // (public) return string representation in given radix
  function bnToString(b) {
    if (this.s < 0) return "-" + this.negate().toString(b);
    var k;
    if (b == 16) k = 4;else if (b == 8) k = 3;else if (b == 2) k = 1;else if (b == 32) k = 5;else if (b == 4) k = 2;else return this.toRadix(b);
    var km = (1 << k) - 1,
      d,
      m = false,
      r = "",
      i = this.t;
    var p = this.DB - i * this.DB % k;
    if (i-- > 0) {
      if (p < this.DB && (d = this[i] >> p) > 0) {
        m = true;
        r = int2char(d);
      }
      while (i >= 0) {
        if (p < k) {
          d = (this[i] & (1 << p) - 1) << k - p;
          d |= this[--i] >> (p += this.DB - k);
        } else {
          d = this[i] >> (p -= k) & km;
          if (p <= 0) {
            p += this.DB;
            --i;
          }
        }
        if (d > 0) m = true;
        if (m) r += int2char(d);
      }
    }
    return m ? r : "0";
  }

  // (public) -this
  function bnNegate() {
    var r = nbi();
    BigInteger.ZERO.subTo(this, r);
    return r;
  }

  // (public) |this|
  function bnAbs() {
    return this.s < 0 ? this.negate() : this;
  }

  // (public) return + if this > a, - if this < a, 0 if equal
  function bnCompareTo(a) {
    var r = this.s - a.s;
    if (r != 0) return r;
    var i = this.t;
    r = i - a.t;
    if (r != 0) return this.s < 0 ? -r : r;
    while (--i >= 0) if ((r = this[i] - a[i]) != 0) return r;
    return 0;
  }

  // returns bit length of the integer x
  function nbits(x) {
    var r = 1,
      t;
    if ((t = x >>> 16) != 0) {
      x = t;
      r += 16;
    }
    if ((t = x >> 8) != 0) {
      x = t;
      r += 8;
    }
    if ((t = x >> 4) != 0) {
      x = t;
      r += 4;
    }
    if ((t = x >> 2) != 0) {
      x = t;
      r += 2;
    }
    if ((t = x >> 1) != 0) {
      x = t;
      r += 1;
    }
    return r;
  }

  // (public) return the number of bits in "this"
  function bnBitLength() {
    if (this.t <= 0) return 0;
    return this.DB * (this.t - 1) + nbits(this[this.t - 1] ^ this.s & this.DM);
  }

  // (protected) r = this << n*DB
  function bnpDLShiftTo(n, r) {
    var i;
    for (i = this.t - 1; i >= 0; --i) r[i + n] = this[i];
    for (i = n - 1; i >= 0; --i) r[i] = 0;
    r.t = this.t + n;
    r.s = this.s;
  }

  // (protected) r = this >> n*DB
  function bnpDRShiftTo(n, r) {
    for (var i = n; i < this.t; ++i) r[i - n] = this[i];
    r.t = Math.max(this.t - n, 0);
    r.s = this.s;
  }

  // (protected) r = this << n
  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),
      c = this.s << bs & this.DM,
      i;
    for (i = this.t - 1; i >= 0; --i) {
      r[i + ds + 1] = this[i] >> cbs | c;
      c = (this[i] & bm) << bs;
    }
    for (i = ds - 1; i >= 0; --i) r[i] = 0;
    r[ds] = c;
    r.t = this.t + ds + 1;
    r.s = this.s;
    r.clamp();
  }

  // (protected) r = this >> n
  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 i = ds + 1; i < this.t; ++i) {
      r[i - ds - 1] |= (this[i] & bm) << cbs;
      r[i - ds] = this[i] >> bs;
    }
    if (bs > 0) r[this.t - ds - 1] |= (this.s & bm) << cbs;
    r.t = this.t - ds;
    r.clamp();
  }

  // (protected) r = this - a
  function bnpSubTo(a, r) {
    var i = 0,
      c = 0,
      m = Math.min(a.t, this.t);
    while (i < m) {
      c += this[i] - a[i];
      r[i++] = c & this.DM;
      c >>= this.DB;
    }
    if (a.t < this.t) {
      c -= a.s;
      while (i < this.t) {
        c += this[i];
        r[i++] = c & this.DM;
        c >>= this.DB;
      }
      c += this.s;
    } else {
      c += this.s;
      while (i < a.t) {
        c -= a[i];
        r[i++] = c & this.DM;
        c >>= this.DB;
      }
      c -= a.s;
    }
    r.s = c < 0 ? -1 : 0;
    if (c < -1) r[i++] = this.DV + c;else if (c > 0) r[i++] = c;
    r.t = i;
    r.clamp();
  }

  // (protected) r = this * a, r != this,a (HAC 14.12)
  // "this" should be the larger one if appropriate.
  function bnpMultiplyTo(a, r) {
    var x = this.abs(),
      y = a.abs();
    var i = x.t;
    r.t = i + y.t;
    while (--i >= 0) r[i] = 0;
    for (i = 0; i < y.t; ++i) r[i + x.t] = x.am(0, y[i], r, i, 0, x.t);
    r.s = 0;
    r.clamp();
    if (this.s != a.s) BigInteger.ZERO.subTo(r, r);
  }

  // (protected) r = this^2, r != this (HAC 14.16)
  function bnpSquareTo(r) {
    var x = this.abs();
    var i = r.t = 2 * x.t;
    while (--i >= 0) r[i] = 0;
    for (i = 0; i < x.t - 1; ++i) {
      var c = x.am(i, x[i], r, 2 * i, 0, 1);
      if ((r[i + x.t] += x.am(i + 1, 2 * x[i], r, 2 * i + 1, c, x.t - i - 1)) >= x.DV) {
        r[i + x.t] -= x.DV;
        r[i + x.t + 1] = 1;
      }
    }
    if (r.t > 0) r[r.t - 1] += x.am(i, x[i], r, 2 * i, 0, 1);
    r.s = 0;
    r.clamp();
  }

  // (protected) divide this by m, quotient and remainder to q, r (HAC 14.20)
  // r != q, this != m.  q or r may be null.
  function bnpDivRemTo(m, q, r) {
    var pm = m.abs();
    if (pm.t <= 0) return;
    var pt = this.abs();
    if (pt.t < pm.t) {
      if (q != null) q.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]); // normalize modulus
    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 i = r.t,
      j = i - ys,
      t = q == null ? nbi() : q;
    y.dlShiftTo(j, t);
    if (r.compareTo(t) >= 0) {
      r[r.t++] = 1;
      r.subTo(t, r);
    }
    BigInteger.ONE.dlShiftTo(ys, t);
    t.subTo(y, y); // "negative" y so we can replace sub with am later
    while (y.t < ys) y[y.t++] = 0;
    while (--j >= 0) {
      // Estimate quotient digit
      var qd = r[--i] == y0 ? this.DM : Math.floor(r[i] * d1 + (r[i - 1] + e) * d2);
      if ((r[i] += y.am(0, qd, r, j, 0, ys)) < qd) {
        // Try it out
        y.dlShiftTo(j, t);
        r.subTo(t, r);
        while (r[i] < --qd) r.subTo(t, r);
      }
    }
    if (q != null) {
      r.drShiftTo(ys, q);
      if (ts != ms) BigInteger.ZERO.subTo(q, q);
    }
    r.t = ys;
    r.clamp();
    if (nsh > 0) r.rShiftTo(nsh, r); // Denormalize remainder
    if (ts < 0) BigInteger.ZERO.subTo(r, r);
  }

  // (public) this mod a
  function bnMod(a) {
    var r = nbi();
    this.abs().divRemTo(a, null, r);
    if (this.s < 0 && r.compareTo(BigInteger.ZERO) > 0) a.subTo(r, r);
    return r;
  }

  // Modular reduction using "classic" algorithm
  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;

  // (protected) return "-1/this % 2^DB"; useful for Mont. reduction
  // justification:
  //         xy == 1 (mod m)
  //         xy =  1+km
  //   xy(2-xy) = (1+km)(1-km)
  // x[y(2-xy)] = 1-k^2m^2
  // x[y(2-xy)] == 1 (mod m^2)
  // if y is 1/x mod m, then y(2-xy) is 1/x mod m^2
  // should reduce x and y(2-xy) by m^2 at each step to keep size bounded.
  // JS multiply "overflows" differently from C/C++, so care is needed here.
  function bnpInvDigit() {
    if (this.t < 1) return 0;
    var x = this[0];
    if ((x & 1) == 0) return 0;
    var y = x & 3; // y == 1/x mod 2^2
    y = y * (2 - (x & 0xf) * y) & 0xf; // y == 1/x mod 2^4
    y = y * (2 - (x & 0xff) * y) & 0xff; // y == 1/x mod 2^8
    y = y * (2 - ((x & 0xffff) * y & 0xffff)) & 0xffff; // y == 1/x mod 2^16
    // last step - calculate inverse mod DV directly;
    // assumes 16 < DB <= 32 and assumes ability to handle 48-bit ints
    y = y * (2 - x * y % this.DV) % this.DV; // y == 1/x mod 2^dbits
    // we really want the negative inverse, and -DV < y < DV
    return y > 0 ? this.DV - y : -y;
  }

  // Montgomery reduction
  function Montgomery(m) {
    this.m = m;
    this.mp = m.invDigit();
    this.mpl = this.mp & 0x7fff;
    this.mph = this.mp >> 15;
    this.um = (1 << m.DB - 15) - 1;
    this.mt2 = 2 * m.t;
  }

  // xR mod m
  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;
  }

  // x/R mod m
  function montRevert(x) {
    var r = nbi();
    x.copyTo(r);
    this.reduce(r);
    return r;
  }

  // x = x/R mod m (HAC 14.32)
  function montReduce(x) {
    while (x.t <= this.mt2)
    // pad x so am has enough room later
    x[x.t++] = 0;
    for (var i = 0; i < this.m.t; ++i) {
      // faster way of calculating u0 = x[i]*mp mod DV
      var j = x[i] & 0x7fff;
      var u0 = j * this.mpl + ((j * this.mph + (x[i] >> 15) * this.mpl & this.um) << 15) & x.DM;
      // use am to combine the multiply-shift-add into one call
      j = i + this.m.t;
      x[j] += this.m.am(0, u0, x, i, 0, this.m.t);
      // propagate carry
      while (x[j] >= x.DV) {
        x[j] -= x.DV;
        x[++j]++;
      }
    }
    x.clamp();
    x.drShiftTo(this.m.t, x);
    if (x.compareTo(this.m) >= 0) x.subTo(this.m, x);
  }

  // r = "x^2/R mod m"; x != r
  function montSqrTo(x, r) {
    x.squareTo(r);
    this.reduce(r);
  }

  // r = "xy/R mod m"; x,y != 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;

  // (protected) true iff this is even
  function bnpIsEven() {
    return (this.t > 0 ? this[0] & 1 : this.s) == 0;
  }

  // (protected) this^e, e < 2^32, doing sqr and mul with "r" (HAC 14.79)
  function bnpExp(e, z) {
    if (e > 0xffffffff || e < 1) return BigInteger.ONE;
    var r = nbi(),
      r2 = nbi(),
      g = z.convert(this),
      i = nbits(e) - 1;
    g.copyTo(r);
    while (--i >= 0) {
      z.sqrTo(r, r2);
      if ((e & 1 << i) > 0) z.mulTo(r2, g, r);else {
        var t = r;
        r = r2;
        r2 = t;
      }
    }
    return z.revert(r);
  }

  // (public) this^e % m, 0 <= e < 2^32
  function bnModPowInt(e, m) {
    var z;
    if (e < 256 || m.isEven()) z = new Classic(m);else z = new Montgomery(m);
    return this.exp(e, z);
  }

  // protected
  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;

  // public
  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;

  // "constants"
  BigInteger.ZERO = nbv(0);
  BigInteger.ONE = nbv(1);

  // Copyright (c) 2005-2009  Tom Wu
  // All Rights Reserved.
  // See "LICENSE" for details.

  // Extended JavaScript BN functions, required for RSA private ops.

  // Version 1.1: new BigInteger("0", 10) returns "proper" zero
  // Version 1.2: square() API, isProbablePrime fix

  // (public)
  function bnClone() {
    var r = nbi();
    this.copyTo(r);
    return r;
  }

  // (public) return value as integer
  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;
    // assumes 16 < DB < 32
    return (this[1] & (1 << 32 - this.DB) - 1) << this.DB | this[0];
  }

  // (public) return value as byte
  function bnByteValue() {
    return this.t == 0 ? this.s : this[0] << 24 >> 24;
  }

  // (public) return value as short (assumes DB>=16)
  function bnShortValue() {
    return this.t == 0 ? this.s : this[0] << 16 >> 16;
  }

  // (protected) return x s.t. r^x < DV
  function bnpChunkSize(r) {
    return Math.floor(Math.LN2 * this.DB / Math.log(r));
  }

  // (public) 0 if this == 0, 1 if this > 0
  function bnSigNum() {
    if (this.s < 0) return -1;else if (this.t <= 0 || this.t == 1 && this[0] <= 0) return 0;else return 1;
  }

  // (protected) convert to radix string
  function bnpToRadix(b) {
    if (b == null) b = 10;
    if (this.signum() == 0 || b < 2 || b > 36) return "0";
    var cs = this.chunkSize(b);
    var a = Math.pow(b, cs);
    var d = nbv(a),
      y = nbi(),
      z = nbi(),
      r = "";
    this.divRemTo(d, y, z);
    while (y.signum() > 0) {
      r = (a + z.intValue()).toString(b).substr(1) + r;
      y.divRemTo(d, y, z);
    }
    return z.intValue().toString(b) + r;
  }

  // (protected) convert from radix string
  function bnpFromRadix(s, b) {
    this.fromInt(0);
    if (b == null) b = 10;
    var cs = this.chunkSize(b);
    var d = Math.pow(b, cs),
      mi = false,
      j = 0,
      w = 0;
    for (var i = 0; i < s.length; ++i) {
      var x = intAt(s, i);
      if (x < 0) {
        if (s.charAt(i) == "-" && this.signum() == 0) mi = true;
        continue;
      }
      w = b * w + x;
      if (++j >= cs) {
        this.dMultiply(d);
        this.dAddOffset(w, 0);
        j = 0;
        w = 0;
      }
    }
    if (j > 0) {
      this.dMultiply(Math.pow(b, j));
      this.dAddOffset(w, 0);
    }
    if (mi) BigInteger.ZERO.subTo(this, this);
  }

  // (protected) alternate constructor
  function bnpFromNumber(a, b, c) {
    if ("number" == typeof b) {
      // new BigInteger(int,int,RNG)
      if (a < 2) this.fromInt(1);else {
        this.fromNumber(a, c);
        if (!this.testBit(a - 1))
          // force MSB set
          this.bitwiseTo(BigInteger.ONE.shiftLeft(a - 1), op_or, this);
        if (this.isEven()) this.dAddOffset(1, 0); // force odd
        while (!this.isProbablePrime(b)) {
          this.dAddOffset(2, 0);
          if (this.bitLength() > a) this.subTo(BigInteger.ONE.shiftLeft(a - 1), this);
        }
      }
    } else {
      // new BigInteger(int,RNG)
      var x = new Array(),
        t = a & 7;
      x.length = (a >> 3) + 1;
      b.nextBytes(x);
      if (t > 0) x[0] &= (1 << t) - 1;else x[0] = 0;
      this.fromString(x, 256);
    }
  }

  // (public) convert to bigendian byte array
  function bnToByteArray() {
    var i = this.t,
      r = new Array();
    r[0] = this.s;
    var p = this.DB - i * this.DB % 8,
      d,
      k = 0;
    if (i-- > 0) {
      if (p < this.DB && (d = this[i] >> p) != (this.s & this.DM) >> p) r[k++] = d | this.s << this.DB - p;
      while (i >= 0) {
        if (p < 8) {
          d = (this[i] & (1 << p) - 1) << 8 - p;
          d |= this[--i] >> (p += this.DB - 8);
        } else {
          d = this[i] >> (p -= 8) & 0xff;
          if (p <= 0) {
            p += this.DB;
            --i;
          }
        }
        if ((d & 0x80) != 0) d |= -256;
        if (k == 0 && (this.s & 0x80) != (d & 0x80)) ++k;
        if (k > 0 || d != this.s) r[k++] = d;
      }
    }
    return r;
  }
  function bnEquals(a) {
    return this.compareTo(a) == 0;
  }
  function bnMin(a) {
    return this.compareTo(a) < 0 ? this : a;
  }
  function bnMax(a) {
    return this.compareTo(a) > 0 ? this : a;
  }

  // (protected) r = this op a (bitwise)
  function bnpBitwiseTo(a, op, r) {
    var i,
      f,
      m = Math.min(a.t, this.t);
    for (i = 0; i < m; ++i) r[i] = op(this[i], a[i]);
    if (a.t < this.t) {
      f = a.s & this.DM;
      for (i = m; i < this.t; ++i) r[i] = op(this[i], f);
      r.t = this.t;
    } else {
      f = this.s & this.DM;
      for (i = m; i < a.t; ++i) r[i] = op(f, a[i]);
      r.t = a.t;
    }
    r.s = op(this.s, a.s);
    r.clamp();
  }

  // (public) this & a
  function op_and(x, y) {
    return x & y;
  }
  function bnAnd(a) {
    var r = nbi();
    this.bitwiseTo(a, op_and, r);
    return r;
  }

  // (public) this | a
  function op_or(x, y) {
    return x | y;
  }
  function bnOr(a) {
    var r = nbi();
    this.bitwiseTo(a, op_or, r);
    return r;
  }

  // (public) this ^ a
  function op_xor(x, y) {
    return x ^ y;
  }
  function bnXor(a) {
    var r = nbi();
    this.bitwiseTo(a, op_xor, r);
    return r;
  }

  // (public) this & ~a
  function op_andnot(x, y) {
    return x & ~y;
  }
  function bnAndNot(a) {
    var r = nbi();
    this.bitwiseTo(a, op_andnot, r);
    return r;
  }

  // (public) ~this
  function bnNot() {
    var r = nbi();
    for (var i = 0; i < this.t; ++i) r[i] = this.DM & ~this[i];
    r.t = this.t;
    r.s = ~this.s;
    return r;
  }

  // (public) this << n
  function bnShiftLeft(n) {
    var r = nbi();
    if (n < 0) this.rShiftTo(-n, r);else this.lShiftTo(n, r);
    return r;
  }

  // (public) this >> n
  function bnShiftRight(n) {
    var r = nbi();
    if (n < 0) this.lShiftTo(-n, r);else this.rShiftTo(n, r);
    return r;
  }

  // return index of lowest 1-bit in x, x < 2^31
  function lbit(x) {
    if (x == 0) return -1;
    var r = 0;
    if ((x & 0xffff) == 0) {
      x >>= 16;
      r += 16;
    }
    if ((x & 0xff) == 0) {
      x >>= 8;
      r += 8;
    }
    if ((x & 0xf) == 0) {
      x >>= 4;
      r += 4;
    }
    if ((x & 3) == 0) {
      x >>= 2;
      r += 2;
    }
    if ((x & 1) == 0) ++r;
    return r;
  }

  // (public) returns index of lowest 1-bit (or -1 if none)
  function bnGetLowestSetBit() {
    for (var i = 0; i < this.t; ++i) if (this[i] != 0) return i * this.DB + lbit(this[i]);
    if (this.s < 0) return this.t * this.DB;
    return -1;
  }

  // return number of 1 bits in x
  function cbit(x) {
    var r = 0;
    while (x != 0) {
      x &= x - 1;
      ++r;
    }
    return r;
  }

  // (public) return number of set bits
  function bnBitCount() {
    var r = 0,
      x = this.s & this.DM;
    for (var i = 0; i < this.t; ++i) r += cbit(this[i] ^ x);
    return r;
  }

  // (public) true iff nth bit is set
  function bnTestBit(n) {
    var j = Math.floor(n / this.DB);
    if (j >= this.t) return this.s != 0;
    return (this[j] & 1 << n % this.DB) != 0;
  }

  // (protected) this op (1<<n)
  function bnpChangeBit(n, op) {
    var r = BigInteger.ONE.shiftLeft(n);
    this.bitwiseTo(r, op, r);
    return r;
  }

  // (public) this | (1<<n)
  function bnSetBit(n) {
    return this.changeBit(n, op_or);
  }

  // (public) this & ~(1<<n)
  function bnClearBit(n) {
    return this.changeBit(n, op_andnot);
  }

  // (public) this ^ (1<<n)
  function bnFlipBit(n) {
    return this.changeBit(n, op_xor);
  }

  // (protected) r = this + a
  function bnpAddTo(a, r) {
    var i = 0,
      c = 0,
      m = Math.min(a.t, this.t);
    while (i < m) {
      c += this[i] + a[i];
      r[i++] = c & this.DM;
      c >>= this.DB;
    }
    if (a.t < this.t) {
      c += a.s;
      while (i < this.t) {
        c += this[i];
        r[i++] = c & this.DM;
        c >>= this.DB;
      }
      c += this.s;
    } else {
      c += this.s;
      while (i < a.t) {
        c += a[i];
        r[i++] = c & this.DM;
        c >>= this.DB;
      }
      c += a.s;
    }
    r.s = c < 0 ? -1 : 0;
    if (c > 0) r[i++] = c;else if (c < -1) r[i++] = this.DV + c;
    r.t = i;
    r.clamp();
  }

  // (public) this + a
  function bnAdd(a) {
    var r = nbi();
    this.addTo(a, r);
    return r;
  }

  // (public) this - a
  function bnSubtract(a) {
    var r = nbi();
    this.subTo(a, r);
    return r;
  }

  // (public) this * a
  function bnMultiply(a) {
    var r = nbi();
    this.multiplyTo(a, r);
    return r;
  }

  // (public) this^2
  function bnSquare() {
    var r = nbi();
    this.squareTo(r);
    return r;
  }

  // (public) this / a
  function bnDivide(a) {
    var r = nbi();
    this.divRemTo(a, r, null);
    return r;
  }

  // (public) this % a
  function bnRemainder(a) {
    var r = nbi();
    this.divRemTo(a, null, r);
    return r;
  }

  // (public) [this/a,this%a]
  function bnDivideAndRemainder(a) {
    var q = nbi(),
      r = nbi();
    this.divRemTo(a, q, r);
    return new Array(q, r);
  }

  // (protected) this *= n, this >= 0, 1 < n < DV
  function bnpDMultiply(n) {
    this[this.t] = this.am(0, n - 1, this, 0, 0, this.t);
    ++this.t;
    this.clamp();
  }

  // (protected) this += n << w words, this >= 0
  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];
    }
  }

  // A "null" reducer
  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;

  // (public) this^e
  function bnPow(e) {
    return this.exp(e, new NullExp());
  }

  // (protected) r = lower n words of "this * a", a.t <= n
  // "this" should be the larger one if appropriate.
  function bnpMultiplyLowerTo(a, n, r) {
    var i = Math.min(this.t + a.t, n);
    r.s = 0; // assumes a,this >= 0
    r.t = i;
    while (i > 0) r[--i] = 0;
    var j;
    for (j = r.t - this.t; i < j; ++i) r[i + this.t] = this.am(0, a[i], r, i, 0, this.t);
    for (j = Math.min(a.t, n); i < j; ++i) this.am(0, a[i], r, i, 0, n - i);
    r.clamp();
  }

  // (protected) r = "this * a" without lower n words, n > 0
  // "this" should be the larger one if appropriate.
  function bnpMultiplyUpperTo(a, n, r) {
    --n;
    var i = r.t = this.t + a.t - n;
    r.s = 0; // assumes a,this >= 0
    while (--i >= 0) r[i] = 0;
    for (i = Math.max(n - this.t, 0); i < a.t; ++i) r[this.t + i - n] = this.am(n - i, a[i], r, 0, 0, this.t + i - n);
    r.clamp();
    r.drShiftTo(1, r);
  }

  // Barrett modular reduction
  function Barrett(m) {
    // setup Barrett
    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;
  }

  // x = x mod m (HAC 14.42)
  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);
  }

  // r = x^2 mod m; x != r
  function barrettSqrTo(x, r) {
    x.squareTo(r);
    this.reduce(r);
  }

  // r = x*y mod m; x,y != 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;

  // (public) this^e % m (HAC 14.85)
  function bnModPow(e, m) {
    var i = e.bitLength(),
      k,
      r = nbv(1),
      z;
    if (i <= 0) return r;else if (i < 18) k = 1;else if (i < 48) k = 3;else if (i < 144) k = 4;else if (i < 768) k = 5;else k = 6;
    if (i < 8) z = new Classic(m);else if (m.isEven()) z = new Barrett(m);else z = new Montgomery(m);

    // precomputation
    var g = new Array(),
      n = 3,
      k1 = k - 1,
      km = (1 << k) - 1;
    g[1] = z.convert(this);
    if (k > 1) {
      var g2 = nbi();
      z.sqrTo(g[1], g2);
      while (n <= km) {
        g[n] = nbi();
        z.mulTo(g2, g[n - 2], g[n]);
        n += 2;
      }
    }
    var j = e.t - 1,
      w,
      is1 = true,
      r2 = nbi(),
      t;
    i = nbits(e[j]) - 1;
    while (j >= 0) {
      if (i >= k1) w = e[j] >> i - k1 & km;else {
        w = (e[j] & (1 << i + 1) - 1) << k1 - i;
        if (j > 0) w |= e[j - 1] >> this.DB + i - k1;
      }
      n = k;
      while ((w & 1) == 0) {
        w >>= 1;
        --n;
      }
      if ((i -= n) < 0) {
        i += this.DB;
        --j;
      }
      if (is1) {
        // ret == 1, don't bother squaring or multiplying it
        g[w].copyTo(r);
        is1 = false;
      } else {
        while (n > 1) {
          z.sqrTo(r, r2);
          z.sqrTo(r2, r);
          n -= 2;
        }
        if (n > 0) z.sqrTo(r, r2);else {
          t = r;
          r = r2;
          r2 = t;
        }
        z.mulTo(r2, g[w], r);
      }
      while (j >= 0 && (e[j] & 1 << i) == 0) {
        z.sqrTo(r, r2);
        t = r;
        r = r2;
        r2 = t;
        if (--i < 0) {
          i = this.DB - 1;
          --j;
        }
      }
    }
    return z.revert(r);
  }

  // (public) gcd(this,a) (HAC 14.54)
  function bnGCD(a) {
    var x = this.s < 0 ? this.negate() : this.clone();
    var y = a.s < 0 ? a.negate() : a.clone();
    if (x.compareTo(y) < 0) {
      var t = x;
      x = y;
      y = t;
    }
    var i = x.getLowestSetBit(),
      g = y.getLowestSetBit();
    if (g < 0) return x;
    if (i < g) g = i;
    if (g > 0) {
      x.rShiftTo(g, x);
      y.rShiftTo(g, y);
    }
    while (x.signum() > 0) {
      if ((i = x.getLowestSetBit()) > 0) x.rShiftTo(i, x);
      if ((i = y.getLowestSetBit()) > 0) y.rShiftTo(i, 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;
  }

  // (protected) this % n, n < 2^26
  function bnpModInt(n) {
    if (n <= 0) return 0;
    var d = this.DV % n,
      r = this.s < 0 ? n - 1 : 0;
    if (this.t > 0) if (d == 0) r = this[0] % n;else for (var i = this.t - 1; i >= 0; --i) r = (d * r + this[i]) % n;
    return r;
  }

  // (public) 1/this % m (HAC 14.61)
  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 a = nbv(1),
      b = nbv(0),
      c = nbv(0),
      d = nbv(1);
    while (u.signum() != 0) {
      while (u.isEven()) {
        u.rShiftTo(1, u);
        if (ac) {
          if (!a.isEven() || !b.isEven()) {
            a.addTo(this, a);
            b.subTo(m, b);
          }
          a.rShiftTo(1, a);
        } else if (!b.isEven()) b.subTo(m, b);
        b.rShiftTo(1, b);
      }
      while (v.isEven()) {
        v.rShiftTo(1, v);
        if (ac) {
          if (!c.isEven() || !d.isEven()) {
            c.addTo(this, c);
            d.subTo(m, d);
          }
          c.rShiftTo(1, c);
        } else if (!d.isEven()) d.subTo(m, d);
        d.rShiftTo(1, d);
      }
      if (u.compareTo(v) >= 0) {
        u.subTo(v, u);
        if (ac) a.subTo(c, a);
        b.subTo(d, b);
      } else {
        v.subTo(u, v);
        if (ac) c.subTo(a, c);
        d.subTo(b, d);
      }
    }
    if (v.compareTo(BigInteger.ONE) != 0) return BigInteger.ZERO;
    if (d.compareTo(m) >= 0) return d.subtract(m);
    if (d.signum() < 0) d.addTo(m, d);else return d;
    if (d.signum() < 0) return d.add(m);else return d;
  }
  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];

  // (public) test primality with certainty >= 1-.5^t
  function bnIsProbablePrime(t) {
    var i,
      x = this.abs();
    if (x.t == 1 && x[0] <= lowprimes[lowprimes.length - 1]) {
      for (i = 0; i < lowprimes.length; ++i) if (x[0] == lowprimes[i]) return true;
      return false;
    }
    if (x.isEven()) return false;
    i = 1;
    while (i < lowprimes.length) {
      var m = lowprimes[i],
        j = i + 1;
      while (j < lowprimes.length && m < lplim) m *= lowprimes[j++];
      m = x.modInt(m);
      while (i < j) if (m % lowprimes[i++] == 0) return false;
    }
    return x.millerRabin(t);
  }

  // (protected) true if probably prime (HAC 4.24, Miller-Rabin)
  function bnpMillerRabin(t) {
    var n1 = this.subtract(BigInteger.ONE);
    var k = n1.getLowestSetBit();
    if (k <= 0) return false;
    var r = n1.shiftRight(k);
    t = t + 1 >> 1;
    if (t > lowprimes.length) t = lowprimes.length;
    var a = nbi();
    for (var i = 0; i < t; ++i) {
      //Pick bases at random, instead of starting at 2
      a.fromInt(lowprimes[Math.floor(Math.random() * lowprimes.length)]);
      var y = a.modPow(r, this);
      if (y.compareTo(BigInteger.ONE) != 0 && y.compareTo(n1) != 0) {
        var j = 1;
        while (j++ < 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;
  }

  // protected
  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;

  // public
  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;

  // JSBN-specific extension
  BigInteger.prototype.square = bnSquare;

  // Expose the Barrett function
  BigInteger.prototype.Barrett = Barrett;

  // BigInteger interfaces not implemented in jsbn:

  // BigInteger(int signum, byte[] magnitude)
  // double doubleValue()
  // float floatValue()
  // int hashCode()
  // long longValue()
  // static BigInteger valueOf(long val)

  // Random number generator - requires a PRNG backend, e.g. prng4.js

  // For best results, put code like
  // <body onClick='rng_seed_time();' onKeyPress='rng_seed_time();'>
  // in your main HTML document.

  var rng_state;
  var rng_pool;
  var rng_pptr;

  // Mix in a 32-bit integer into the pool
  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;
  }

  // Mix in the current time (w/milliseconds) into the pool
  function rng_seed_time() {
    rng_seed_int(new Date().getTime());
  }

  // Initialize the pool with junk if needed.
  if (rng_pool == null) {
    rng_pool = new Array();
    rng_pptr = 0;
    var t;
    if (typeof window !== "undefined" && window.crypto) {
      if (window.crypto.getRandomValues) {
        // Use webcrypto if available
        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") {
        // Extract entropy (256 bits) from NS4 RNG if available
        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) {
      // extract some randomness from Math.random()
      t = Math.floor(65536 * Math.random());
      rng_pool[rng_pptr++] = t >>> 8;
      rng_pool[rng_pptr++] = t & 255;
    }
    rng_pptr = 0;
    rng_seed_time();
    //rng_seed_int(window.screenX);
    //rng_seed_int(window.screenY);
  }

  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;
      //rng_pool = null;
    }
    // TODO: allow reseeding after first request
    return rng_state.next();
  }
  function rng_get_bytes(ba) {
    var i;
    for (i = 0; i < ba.length; ++i) ba[i] = rng_get_byte();
  }
  function SecureRandom() {}
  SecureRandom.prototype.nextBytes = rng_get_bytes;

  // prng4.js - uses Arcfour as a PRNG

  function Arcfour() {
    this.i = 0;
    this.j = 0;
    this.S = new Array();
  }

  // Initialize arcfour context from key, an array of ints, each from [0..255]
  function ARC4init(key) {
    var i, j, t;
    for (i = 0; i < 256; ++i) this.S[i] = i;
    j = 0;
    for (i = 0; i < 256; ++i) {
      j = j + this.S[i] + key[i % key.length] & 255;
      t = this.S[i];
      this.S[i] = this.S[j];
      this.S[j] = t;
    }
    this.i = 0;
    this.j = 0;
  }
  function ARC4next() {
    var t;
    this.i = this.i + 1 & 255;
    this.j = this.j + this.S[this.i] & 255;
    t = this.S[this.i];
    this.S[this.i] = this.S[this.j];
    this.S[this.j] = t;
    return this.S[t + this.S[this.i] & 255];
  }
  Arcfour.prototype.init = ARC4init;
  Arcfour.prototype.next = ARC4next;

  // Plug in your RNG constructor here
  function prng_newstate() {
    return new Arcfour();
  }

  // Pool size must be a multiple of 4 and greater than 32.
  // An array of bytes the size of the pool will be passed to init()
  var rng_psize = 256;
  BigInteger.SecureRandom = SecureRandom;
  BigInteger.BigInteger = BigInteger;
  if (true) {
    exports = module.exports = BigInteger;
  } else {}
}).call(this);

/***/ }),

/***/ 6091:
/*!*********************************************!*\
  !*** ./node_modules/minimatch/minimatch.js ***!
  \*********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

module.exports = minimatch;
minimatch.Minimatch = Minimatch;
var path = {
  sep: '/'
};
try {
  path = __webpack_require__(/*! path */ 3056);
} catch (er) {}
var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {};
var expand = __webpack_require__(/*! brace-expansion */ 3297);
var plTypes = {
  '!': {
    open: '(?:(?!(?:',
    close: '))[^/]*?)'
  },
  '?': {
    open: '(?:',
    close: ')?'
  },
  '+': {
    open: '(?:',
    close: ')+'
  },
  '*': {
    open: '(?:',
    close: ')*'
  },
  '@': {
    open: '(?:',
    close: ')'
  }
};

// any single thing other than /
// don't need to escape / when using new RegExp()
var qmark = '[^/]';

// * => any number of characters
var star = qmark + '*?';

// ** when dots are allowed.  Anything goes, except .. and .
// not (^ or / followed by one or two dots followed by $ or /),
// followed by anything, any number of times.
var twoStarDot = '(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?';

// not a ^ or / followed by a dot,
// followed by anything, any number of times.
var twoStarNoDot = '(?:(?!(?:\\\/|^)\\.).)*?';

// characters that need to be escaped in RegExp.
var reSpecials = charSet('().*{}+?[]^$\\!');

// "abc" -> { a:true, b:true, c:true }
function charSet(s) {
  return s.split('').reduce(function (set, c) {
    set[c] = true;
    return set;
  }, {});
}

// normalizes slashes.
var slashSplit = /\/+/;
minimatch.filter = filter;
function filter(pattern, options) {
  options = options || {};
  return function (p, i, list) {
    return minimatch(p, pattern, options);
  };
}
function ext(a, b) {
  a = a || {};
  b = b || {};
  var t = {};
  Object.keys(b).forEach(function (k) {
    t[k] = b[k];
  });
  Object.keys(a).forEach(function (k) {
    t[k] = a[k];
  });
  return t;
}
minimatch.defaults = function (def) {
  if (!def || !Object.keys(def).length) return minimatch;
  var orig = minimatch;
  var m = function minimatch(p, pattern, options) {
    return orig.minimatch(p, pattern, ext(def, options));
  };
  m.Minimatch = function Minimatch(pattern, options) {
    return new orig.Minimatch(pattern, ext(def, options));
  };
  return m;
};
Minimatch.defaults = function (def) {
  if (!def || !Object.keys(def).length) return Minimatch;
  return minimatch.defaults(def).Minimatch;
};
function minimatch(p, pattern, options) {
  if (typeof pattern !== 'string') {
    throw new TypeError('glob pattern string required');
  }
  if (!options) options = {};

  // shortcut: comments match nothing.
  if (!options.nocomment && pattern.charAt(0) === '#') {
    return false;
  }

  // "" only matches ""
  if (pattern.trim() === '') return p === '';
  return new Minimatch(pattern, options).match(p);
}
function Minimatch(pattern, options) {
  if (!(this instanceof Minimatch)) {
    return new Minimatch(pattern, options);
  }
  if (typeof pattern !== 'string') {
    throw new TypeError('glob pattern string required');
  }
  if (!options) options = {};
  pattern = pattern.trim();

  // windows support: need to use /, not \
  if (path.sep !== '/') {
    pattern = pattern.split(path.sep).join('/');
  }
  this.options = options;
  this.set = [];
  this.pattern = pattern;
  this.regexp = null;
  this.negate = false;
  this.comment = false;
  this.empty = false;

  // make the set of regexps etc.
  this.make();
}
Minimatch.prototype.debug = function () {};
Minimatch.prototype.make = make;
function make() {
  // don't do it more than once.
  if (this._made) return;
  var pattern = this.pattern;
  var options = this.options;

  // empty patterns and comments match nothing.
  if (!options.nocomment && pattern.charAt(0) === '#') {
    this.comment = true;
    return;
  }
  if (!pattern) {
    this.empty = true;
    return;
  }

  // step 1: figure out negation, etc.
  this.parseNegate();

  // step 2: expand braces
  var set = this.globSet = this.braceExpand();
  if (options.debug) this.debug = console.error;
  this.debug(this.pattern, set);

  // step 3: now we have a set, so turn each one into a series of path-portion
  // matching patterns.
  // These will be regexps, except in the case of "**", which is
  // set to the GLOBSTAR object for globstar behavior,
  // and will not contain any / characters
  set = this.globParts = set.map(function (s) {
    return s.split(slashSplit);
  });
  this.debug(this.pattern, set);

  // glob --> regexps
  set = set.map(function (s, si, set) {
    return s.map(this.parse, this);
  }, this);
  this.debug(this.pattern, set);

  // filter out everything that didn't compile properly.
  set = set.filter(function (s) {
    return s.indexOf(false) === -1;
  });
  this.debug(this.pattern, set);
  this.set = set;
}
Minimatch.prototype.parseNegate = parseNegate;
function parseNegate() {
  var pattern = this.pattern;
  var negate = false;
  var options = this.options;
  var negateOffset = 0;
  if (options.nonegate) return;
  for (var i = 0, l = pattern.length; i < l && pattern.charAt(i) === '!'; i++) {
    negate = !negate;
    negateOffset++;
  }
  if (negateOffset) this.pattern = pattern.substr(negateOffset);
  this.negate = negate;
}

// Brace expansion:
// a{b,c}d -> abd acd
// a{b,}c -> abc ac
// a{0..3}d -> a0d a1d a2d a3d
// a{b,c{d,e}f}g -> abg acdfg acefg
// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg
//
// Invalid sets are not expanded.
// a{2..}b -> a{2..}b
// a{b}c -> a{b}c
minimatch.braceExpand = function (pattern, options) {
  return braceExpand(pattern, options);
};
Minimatch.prototype.braceExpand = braceExpand;
function braceExpand(pattern, options) {
  if (!options) {
    if (this instanceof Minimatch) {
      options = this.options;
    } else {
      options = {};
    }
  }
  pattern = typeof pattern === 'undefined' ? this.pattern : pattern;
  if (typeof pattern === 'undefined') {
    throw new TypeError('undefined pattern');
  }
  if (options.nobrace || !pattern.match(/\{.*\}/)) {
    // shortcut. no need to expand.
    return [pattern];
  }
  return expand(pattern);
}

// parse a component of the expanded set.
// At this point, no pattern may contain "/" in it
// so we're going to return a 2d array, where each entry is the full
// pattern, split on '/', and then turned into a regular expression.
// A regexp is made at the end which joins each array with an
// escaped /, and another full one which joins each regexp with |.
//
// Following the lead of Bash 4.1, note that "**" only has special meaning
// when it is the *only* thing in a path portion.  Otherwise, any series
// of * is equivalent to a single *.  Globstar behavior is enabled by
// default, and can be disabled by setting options.noglobstar.
Minimatch.prototype.parse = parse;
var SUBPARSE = {};
function parse(pattern, isSub) {
  if (pattern.length > 1024 * 64) {
    throw new TypeError('pattern is too long');
  }
  var options = this.options;

  // shortcuts
  if (!options.noglobstar && pattern === '**') return GLOBSTAR;
  if (pattern === '') return '';
  var re = '';
  var hasMagic = !!options.nocase;
  var escaping = false;
  // ? => one single character
  var patternListStack = [];
  var negativeLists = [];
  var stateChar;
  var inClass = false;
  var reClassStart = -1;
  var classStart = -1;
  // . and .. never match anything that doesn't start with .,
  // even when options.dot is set.
  var patternStart = pattern.charAt(0) === '.' ? '' // anything
  // not (start or / followed by . or .. followed by / or end)
  : options.dot ? '(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))' : '(?!\\.)';
  var self = this;
  function clearStateChar() {
    if (stateChar) {
      // we had some state-tracking character
      // that wasn't consumed by this pass.
      switch (stateChar) {
        case '*':
          re += star;
          hasMagic = true;
          break;
        case '?':
          re += qmark;
          hasMagic = true;
          break;
        default:
          re += '\\' + stateChar;
          break;
      }
      self.debug('clearStateChar %j %j', stateChar, re);
      stateChar = false;
    }
  }
  for (var i = 0, len = pattern.length, c; i < len && (c = pattern.charAt(i)); i++) {
    this.debug('%s\t%s %s %j', pattern, i, re, c);

    // skip over any that are escaped.
    if (escaping && reSpecials[c]) {
      re += '\\' + c;
      escaping = false;
      continue;
    }
    switch (c) {
      case '/':
        // completely not allowed, even escaped.
        // Should already be path-split by now.
        return false;
      case '\\':
        clearStateChar();
        escaping = true;
        continue;

      // the various stateChar values
      // for the "extglob" stuff.
      case '?':
      case '*':
      case '+':
      case '@':
      case '!':
        this.debug('%s\t%s %s %j <-- stateChar', pattern, i, re, c);

        // all of those are literals inside a class, except that
        // the glob [!a] means [^a] in regexp
        if (inClass) {
          this.debug('  in class');
          if (c === '!' && i === classStart + 1) c = '^';
          re += c;
          continue;
        }

        // if we already have a stateChar, then it means
        // that there was something like ** or +? in there.
        // Handle the stateChar, then proceed with this one.
        self.debug('call clearStateChar %j', stateChar);
        clearStateChar();
        stateChar = c;
        // if extglob is disabled, then +(asdf|foo) isn't a thing.
        // just clear the statechar *now*, rather than even diving into
        // the patternList stuff.
        if (options.noext) clearStateChar();
        continue;
      case '(':
        if (inClass) {
          re += '(';
          continue;
        }
        if (!stateChar) {
          re += '\\(';
          continue;
        }
        patternListStack.push({
          type: stateChar,
          start: i - 1,
          reStart: re.length,
          open: plTypes[stateChar].open,
          close: plTypes[stateChar].close
        });
        // negation is (?:(?!js)[^/]*)
        re += stateChar === '!' ? '(?:(?!(?:' : '(?:';
        this.debug('plType %j %j', stateChar, re);
        stateChar = false;
        continue;
      case ')':
        if (inClass || !patternListStack.length) {
          re += '\\)';
          continue;
        }
        clearStateChar();
        hasMagic = true;
        var pl = patternListStack.pop();
        // negation is (?:(?!js)[^/]*)
        // The others are (?:<pattern>)<type>
        re += pl.close;
        if (pl.type === '!') {
          negativeLists.push(pl);
        }
        pl.reEnd = re.length;
        continue;
      case '|':
        if (inClass || !patternListStack.length || escaping) {
          re += '\\|';
          escaping = false;
          continue;
        }
        clearStateChar();
        re += '|';
        continue;

      // these are mostly the same in regexp and glob
      case '[':
        // swallow any state-tracking char before the [
        clearStateChar();
        if (inClass) {
          re += '\\' + c;
          continue;
        }
        inClass = true;
        classStart = i;
        reClassStart = re.length;
        re += c;
        continue;
      case ']':
        //  a right bracket shall lose its special
        //  meaning and represent itself in
        //  a bracket expression if it occurs
        //  first in the list.  -- POSIX.2 2.8.3.2
        if (i === classStart + 1 || !inClass) {
          re += '\\' + c;
          escaping = false;
          continue;
        }

        // handle the case where we left a class open.
        // "[z-a]" is valid, equivalent to "\[z-a\]"
        if (inClass) {
          // split where the last [ was, make sure we don't have
          // an invalid re. if so, re-walk the contents of the
          // would-be class to re-translate any characters that
          // were passed through as-is
          // TODO: It would probably be faster to determine this
          // without a try/catch and a new RegExp, but it's tricky
          // to do safely.  For now, this is safe and works.
          var cs = pattern.substring(classStart + 1, i);
          try {
            RegExp('[' + cs + ']');
          } catch (er) {
            // not a valid class!
            var sp = this.parse(cs, SUBPARSE);
            re = re.substr(0, reClassStart) + '\\[' + sp[0] + '\\]';
            hasMagic = hasMagic || sp[1];
            inClass = false;
            continue;
          }
        }

        // finish up the class.
        hasMagic = true;
        inClass = false;
        re += c;
        continue;
      default:
        // swallow any state char that wasn't consumed
        clearStateChar();
        if (escaping) {
          // no need
          escaping = false;
        } else if (reSpecials[c] && !(c === '^' && inClass)) {
          re += '\\';
        }
        re += c;
    } // switch
  } // for

  // handle the case where we left a class open.
  // "[abc" is valid, equivalent to "\[abc"
  if (inClass) {
    // split where the last [ was, and escape it
    // this is a huge pita.  We now have to re-walk
    // the contents of the would-be class to re-translate
    // any characters that were passed through as-is
    cs = pattern.substr(classStart + 1);
    sp = this.parse(cs, SUBPARSE);
    re = re.substr(0, reClassStart) + '\\[' + sp[0];
    hasMagic = hasMagic || sp[1];
  }

  // handle the case where we had a +( thing at the *end*
  // of the pattern.
  // each pattern list stack adds 3 chars, and we need to go through
  // and escape any | chars that were passed through as-is for the regexp.
  // Go through and escape them, taking care not to double-escape any
  // | chars that were already escaped.
  for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
    var tail = re.slice(pl.reStart + pl.open.length);
    this.debug('setting tail', re, pl);
    // maybe some even number of \, then maybe 1 \, followed by a |
    tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function (_, $1, $2) {
      if (!$2) {
        // the | isn't already escaped, so escape it.
        $2 = '\\';
      }

      // need to escape all those slashes *again*, without escaping the
      // one that we need for escaping the | character.  As it works out,
      // escaping an even number of slashes can be done by simply repeating
      // it exactly after itself.  That's why this trick works.
      //
      // I am sorry that you have to see this.
      return $1 + $1 + $2 + '|';
    });
    this.debug('tail=%j\n   %s', tail, tail, pl, re);
    var t = pl.type === '*' ? star : pl.type === '?' ? qmark : '\\' + pl.type;
    hasMagic = true;
    re = re.slice(0, pl.reStart) + t + '\\(' + tail;
  }

  // handle trailing things that only matter at the very end.
  clearStateChar();
  if (escaping) {
    // trailing \\
    re += '\\\\';
  }

  // only need to apply the nodot start if the re starts with
  // something that could conceivably capture a dot
  var addPatternStart = false;
  switch (re.charAt(0)) {
    case '.':
    case '[':
    case '(':
      addPatternStart = true;
  }

  // Hack to work around lack of negative lookbehind in JS
  // A pattern like: *.!(x).!(y|z) needs to ensure that a name
  // like 'a.xyz.yz' doesn't match.  So, the first negative
  // lookahead, has to look ALL the way ahead, to the end of
  // the pattern.
  for (var n = negativeLists.length - 1; n > -1; n--) {
    var nl = negativeLists[n];
    var nlBefore = re.slice(0, nl.reStart);
    var nlFirst = re.slice(nl.reStart, nl.reEnd - 8);
    var nlLast = re.slice(nl.reEnd - 8, nl.reEnd);
    var nlAfter = re.slice(nl.reEnd);
    nlLast += nlAfter;

    // Handle nested stuff like *(*.js|!(*.json)), where open parens
    // mean that we should *not* include the ) in the bit that is considered
    // "after" the negated section.
    var openParensBefore = nlBefore.split('(').length - 1;
    var cleanAfter = nlAfter;
    for (i = 0; i < openParensBefore; i++) {
      cleanAfter = cleanAfter.replace(/\)[+*?]?/, '');
    }
    nlAfter = cleanAfter;
    var dollar = '';
    if (nlAfter === '' && isSub !== SUBPARSE) {
      dollar = '$';
    }
    var newRe = nlBefore + nlFirst + nlAfter + dollar + nlLast;
    re = newRe;
  }

  // if the re is not "" at this point, then we need to make sure
  // it doesn't match against an empty path part.
  // Otherwise a/* will match a/, which it should not.
  if (re !== '' && hasMagic) {
    re = '(?=.)' + re;
  }
  if (addPatternStart) {
    re = patternStart + re;
  }

  // parsing just a piece of a larger pattern.
  if (isSub === SUBPARSE) {
    return [re, hasMagic];
  }

  // skip the regexp for non-magical patterns
  // unescape anything in it, though, so that it'll be
  // an exact match against a file etc.
  if (!hasMagic) {
    return globUnescape(pattern);
  }
  var flags = options.nocase ? 'i' : '';
  try {
    var regExp = new RegExp('^' + re + '$', flags);
  } catch (er) {
    // If it was an invalid regular expression, then it can't match
    // anything.  This trick looks for a character after the end of
    // the string, which is of course impossible, except in multi-line
    // mode, but it's not a /m regex.
    return new RegExp('$.');
  }
  regExp._glob = pattern;
  regExp._src = re;
  return regExp;
}
minimatch.makeRe = function (pattern, options) {
  return new Minimatch(pattern, options || {}).makeRe();
};
Minimatch.prototype.makeRe = makeRe;
function makeRe() {
  if (this.regexp || this.regexp === false) return this.regexp;

  // at this point, this.set is a 2d array of partial
  // pattern strings, or "**".
  //
  // It's better to use .match().  This function shouldn't
  // be used, really, but it's pretty convenient sometimes,
  // when you just want to work with a regex.
  var set = this.set;
  if (!set.length) {
    this.regexp = false;
    return this.regexp;
  }
  var options = this.options;
  var twoStar = options.noglobstar ? star : options.dot ? twoStarDot : twoStarNoDot;
  var flags = options.nocase ? 'i' : '';
  var re = set.map(function (pattern) {
    return pattern.map(function (p) {
      return p === GLOBSTAR ? twoStar : typeof p === 'string' ? regExpEscape(p) : p._src;
    }).join('\\\/');
  }).join('|');

  // must match entire pattern
  // ending in a * or ** will make it less strict.
  re = '^(?:' + re + ')$';

  // can match anything, as long as it's not this.
  if (this.negate) re = '^(?!' + re + ').*$';
  try {
    this.regexp = new RegExp(re, flags);
  } catch (ex) {
    this.regexp = false;
  }
  return this.regexp;
}
minimatch.match = function (list, pattern, options) {
  options = options || {};
  var mm = new Minimatch(pattern, options);
  list = list.filter(function (f) {
    return mm.match(f);
  });
  if (mm.options.nonull && !list.length) {
    list.push(pattern);
  }
  return list;
};
Minimatch.prototype.match = match;
function match(f, partial) {
  this.debug('match', f, this.pattern);
  // short-circuit in the case of busted things.
  // comments, etc.
  if (this.comment) return false;
  if (this.empty) return f === '';
  if (f === '/' && partial) return true;
  var options = this.options;

  // windows: need to use /, not \
  if (path.sep !== '/') {
    f = f.split(path.sep).join('/');
  }

  // treat the test path as a set of pathparts.
  f = f.split(slashSplit);
  this.debug(this.pattern, 'split', f);

  // just ONE of the pattern sets in this.set needs to match
  // in order for it to be valid.  If negating, then just one
  // match means that we have failed.
  // Either way, return on the first hit.

  var set = this.set;
  this.debug(this.pattern, 'set', set);

  // Find the basename of the path by looking for the last non-empty segment
  var filename;
  var i;
  for (i = f.length - 1; i >= 0; i--) {
    filename = f[i];
    if (filename) break;
  }
  for (i = 0; i < set.length; i++) {
    var pattern = set[i];
    var file = f;
    if (options.matchBase && pattern.length === 1) {
      file = [filename];
    }
    var hit = this.matchOne(file, pattern, partial);
    if (hit) {
      if (options.flipNegate) return true;
      return !this.negate;
    }
  }

  // didn't get any hits.  this is success if it's a negative
  // pattern, failure otherwise.
  if (options.flipNegate) return false;
  return this.negate;
}

// set partial to true to test if, for example,
// "/a/b" matches the start of "/*/b/*/d"
// Partial means, if you run out of file before you run
// out of pattern, then that's fine, as long as all
// the parts match.
Minimatch.prototype.matchOne = function (file, pattern, partial) {
  var options = this.options;
  this.debug('matchOne', {
    'this': this,
    file: file,
    pattern: pattern
  });
  this.debug('matchOne', file.length, pattern.length);
  for (var fi = 0, pi = 0, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
    this.debug('matchOne loop');
    var p = pattern[pi];
    var f = file[fi];
    this.debug(pattern, p, f);

    // should be impossible.
    // some invalid regexp stuff in the set.
    if (p === false) return false;
    if (p === GLOBSTAR) {
      this.debug('GLOBSTAR', [pattern, p, f]);

      // "**"
      // a/**/b/**/c would match the following:
      // a/b/x/y/z/c
      // a/x/y/z/b/c
      // a/b/x/b/x/c
      // a/b/c
      // To do this, take the rest of the pattern after
      // the **, and see if it would match the file remainder.
      // If so, return success.
      // If not, the ** "swallows" a segment, and try again.
      // This is recursively awful.
      //
      // a/**/b/**/c matching a/b/x/y/z/c
      // - a matches a
      // - doublestar
      //   - matchOne(b/x/y/z/c, b/**/c)
      //     - b matches b
      //     - doublestar
      //       - matchOne(x/y/z/c, c) -> no
      //       - matchOne(y/z/c, c) -> no
      //       - matchOne(z/c, c) -> no
      //       - matchOne(c, c) yes, hit
      var fr = fi;
      var pr = pi + 1;
      if (pr === pl) {
        this.debug('** at the end');
        // a ** at the end will just swallow the rest.
        // We have found a match.
        // however, it will not swallow /.x, unless
        // options.dot is set.
        // . and .. are *never* matched by **, for explosively
        // exponential reasons.
        for (; fi < fl; fi++) {
          if (file[fi] === '.' || file[fi] === '..' || !options.dot && file[fi].charAt(0) === '.') return false;
        }
        return true;
      }

      // ok, let's see if we can swallow whatever we can.
      while (fr < fl) {
        var swallowee = file[fr];
        this.debug('\nglobstar while', file, fr, pattern, pr, swallowee);

        // XXX remove this slice.  Just pass the start index.
        if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
          this.debug('globstar found match!', fr, fl, swallowee);
          // found a match.
          return true;
        } else {
          // can't swallow "." or ".." ever.
          // can only swallow ".foo" when explicitly asked.
          if (swallowee === '.' || swallowee === '..' || !options.dot && swallowee.charAt(0) === '.') {
            this.debug('dot detected!', file, fr, pattern, pr);
            break;
          }

          // ** swallows a segment, and continue.
          this.debug('globstar swallow a segment, and continue');
          fr++;
        }
      }

      // no match was found.
      // However, in partial mode, we can't say this is necessarily over.
      // If there's more *pattern* left, then
      if (partial) {
        // ran out of file
        this.debug('\n>>> no match, partial?', file, fr, pattern, pr);
        if (fr === fl) return true;
      }
      return false;
    }

    // something other than **
    // non-magic patterns just have to match exactly
    // patterns with magic have been turned into regexps.
    var hit;
    if (typeof p === 'string') {
      if (options.nocase) {
        hit = f.toLowerCase() === p.toLowerCase();
      } else {
        hit = f === p;
      }
      this.debug('string match', p, f, hit);
    } else {
      hit = f.match(p);
      this.debug('pattern match', p, f, hit);
    }
    if (!hit) return false;
  }

  // Note: ending in / means that we'll get a final ""
  // at the end of the pattern.  This can only match a
  // corresponding "" at the end of the file.
  // If the file ends in /, then it can only match a
  // a pattern that ends in /, unless the pattern just
  // doesn't have any more for it. But, a/b/ should *not*
  // match "a/b/*", even though "" matches against the
  // [^/]*? pattern, except in partial mode, where it might
  // simply not be reached yet.
  // However, a/b/ should still satisfy a/*

  // now either we fell off the end of the pattern, or we're done.
  if (fi === fl && pi === pl) {
    // ran out of pattern and filename at the same time.
    // an exact hit!
    return true;
  } else if (fi === fl) {
    // ran out of file, but still had pattern left.
    // this is ok if we're doing the match as part of
    // a glob fs traversal.
    return partial;
  } else if (pi === pl) {
    // ran out of pattern, still have file left.
    // this is only acceptable if we're on the very last
    // empty segment of a file with a trailing slash.
    // a/* should match a/b/
    var emptyFileEnd = fi === fl - 1 && file[fi] === '';
    return emptyFileEnd;
  }

  // should be unreachable.
  throw new Error('wtf?');
};

// replace stuff like \* with *
function globUnescape(s) {
  return s.replace(/\\(.)/g, '$1');
}
function regExpEscape(s) {
  return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
}

/***/ }),

/***/ 5831:
/*!***********************************!*\
  !*** ./node_modules/once/once.js ***!
  \***********************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var wrappy = __webpack_require__(/*! wrappy */ 341);
module.exports = wrappy(once);
module.exports.strict = wrappy(onceStrict);
once.proto = once(function () {
  Object.defineProperty(Function.prototype, 'once', {
    value: function () {
      return once(this);
    },
    configurable: true
  });
  Object.defineProperty(Function.prototype, 'onceStrict', {
    value: function () {
      return onceStrict(this);
    },
    configurable: true
  });
});
function once(fn) {
  var f = function () {
    if (f.called) return f.value;
    f.called = true;
    return f.value = fn.apply(this, arguments);
  };
  f.called = false;
  return f;
}
function onceStrict(fn) {
  var f = function () {
    if (f.called) throw new Error(f.onceError);
    f.called = true;
    return f.value = fn.apply(this, arguments);
  };
  var name = fn.name || 'Function wrapped with `once`';
  f.onceError = name + " shouldn't be called more than once";
  f.called = false;
  return f;
}

/***/ }),

/***/ 5450:
/*!************************************************!*\
  !*** ./node_modules/path-is-absolute/index.js ***!
  \************************************************/
/***/ ((module) => {

"use strict";


function posix(path) {
  return path.charAt(0) === '/';
}
function win32(path) {
  // https://github.com/nodejs/node/blob/b3fcc245fb25539909ef1d5eaa01dbf92e168633/lib/path.js#L56
  var splitDeviceRe = /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
  var result = splitDeviceRe.exec(path);
  var device = result[1] || '';
  var isUnc = Boolean(device && device.charAt(1) !== ':');

  // UNC paths are always absolute
  return Boolean(result[2] || isUnc);
}
module.exports = process.platform === 'win32' ? win32 : posix;
module.exports.posix = posix;
module.exports.win32 = win32;

/***/ }),

/***/ 2856:
/*!***************************************!*\
  !*** ./node_modules/rimraf/rimraf.js ***!
  \***************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

const assert = __webpack_require__(/*! assert */ 9491);
const path = __webpack_require__(/*! path */ 3056);
const fs = __webpack_require__(/*! fs */ 2089);
let glob = undefined;
try {
  glob = __webpack_require__(/*! glob */ 9953);
} catch (_err) {
  // treat glob as optional.
}
const defaultGlobOpts = {
  nosort: true,
  silent: true
};

// for EMFILE handling
let timeout = 0;
const isWindows = process.platform === "win32";
const defaults = options => {
  const methods = ['unlink', 'chmod', 'stat', 'lstat', 'rmdir', 'readdir'];
  methods.forEach(m => {
    options[m] = options[m] || fs[m];
    m = m + 'Sync';
    options[m] = options[m] || fs[m];
  });
  options.maxBusyTries = options.maxBusyTries || 3;
  options.emfileWait = options.emfileWait || 1000;
  if (options.glob === false) {
    options.disableGlob = true;
  }
  if (options.disableGlob !== true && glob === undefined) {
    throw Error('glob dependency not found, set `options.disableGlob = true` if intentional');
  }
  options.disableGlob = options.disableGlob || false;
  options.glob = options.glob || defaultGlobOpts;
};
const rimraf = (p, options, cb) => {
  if (typeof options === 'function') {
    cb = options;
    options = {};
  }
  assert(p, 'rimraf: missing path');
  assert.equal(typeof p, 'string', 'rimraf: path should be a string');
  assert.equal(typeof cb, 'function', 'rimraf: callback function required');
  assert(options, 'rimraf: invalid options argument provided');
  assert.equal(typeof options, 'object', 'rimraf: options should be object');
  defaults(options);
  let busyTries = 0;
  let errState = null;
  let n = 0;
  const next = er => {
    errState = errState || er;
    if (--n === 0) cb(errState);
  };
  const afterGlob = (er, results) => {
    if (er) return cb(er);
    n = results.length;
    if (n === 0) return cb();
    results.forEach(p => {
      const CB = er => {
        if (er) {
          if ((er.code === "EBUSY" || er.code === "ENOTEMPTY" || er.code === "EPERM") && busyTries < options.maxBusyTries) {
            busyTries++;
            // try again, with the same exact callback as this one.
            return setTimeout(() => rimraf_(p, options, CB), busyTries * 100);
          }

          // this one won't happen if graceful-fs is used.
          if (er.code === "EMFILE" && timeout < options.emfileWait) {
            return setTimeout(() => rimraf_(p, options, CB), timeout++);
          }

          // already gone
          if (er.code === "ENOENT") er = null;
        }
        timeout = 0;
        next(er);
      };
      rimraf_(p, options, CB);
    });
  };
  if (options.disableGlob || !glob.hasMagic(p)) return afterGlob(null, [p]);
  options.lstat(p, (er, stat) => {
    if (!er) return afterGlob(null, [p]);
    glob(p, options.glob, afterGlob);
  });
};

// Two possible strategies.
// 1. Assume it's a file.  unlink it, then do the dir stuff on EPERM or EISDIR
// 2. Assume it's a directory.  readdir, then do the file stuff on ENOTDIR
//
// Both result in an extra syscall when you guess wrong.  However, there
// are likely far more normal files in the world than directories.  This
// is based on the assumption that a the average number of files per
// directory is >= 1.
//
// If anyone ever complains about this, then I guess the strategy could
// be made configurable somehow.  But until then, YAGNI.
const rimraf_ = (p, options, cb) => {
  assert(p);
  assert(options);
  assert(typeof cb === 'function');

  // sunos lets the root user unlink directories, which is... weird.
  // so we have to lstat here and make sure it's not a dir.
  options.lstat(p, (er, st) => {
    if (er && er.code === "ENOENT") return cb(null);

    // Windows can EPERM on stat.  Life is suffering.
    if (er && er.code === "EPERM" && isWindows) fixWinEPERM(p, options, er, cb);
    if (st && st.isDirectory()) return rmdir(p, options, er, cb);
    options.unlink(p, er => {
      if (er) {
        if (er.code === "ENOENT") return cb(null);
        if (er.code === "EPERM") return isWindows ? fixWinEPERM(p, options, er, cb) : rmdir(p, options, er, cb);
        if (er.code === "EISDIR") return rmdir(p, options, er, cb);
      }
      return cb(er);
    });
  });
};
const fixWinEPERM = (p, options, er, cb) => {
  assert(p);
  assert(options);
  assert(typeof cb === 'function');
  options.chmod(p, 0o666, er2 => {
    if (er2) cb(er2.code === "ENOENT" ? null : er);else options.stat(p, (er3, stats) => {
      if (er3) cb(er3.code === "ENOENT" ? null : er);else if (stats.isDirectory()) rmdir(p, options, er, cb);else options.unlink(p, cb);
    });
  });
};
const fixWinEPERMSync = (p, options, er) => {
  assert(p);
  assert(options);
  try {
    options.chmodSync(p, 0o666);
  } catch (er2) {
    if (er2.code === "ENOENT") return;else throw er;
  }
  let stats;
  try {
    stats = options.statSync(p);
  } catch (er3) {
    if (er3.code === "ENOENT") return;else throw er;
  }
  if (stats.isDirectory()) rmdirSync(p, options, er);else options.unlinkSync(p);
};
const rmdir = (p, options, originalEr, cb) => {
  assert(p);
  assert(options);
  assert(typeof cb === 'function');

  // try to rmdir first, and only readdir on ENOTEMPTY or EEXIST (SunOS)
  // if we guessed wrong, and it's not a directory, then
  // raise the original error.
  options.rmdir(p, er => {
    if (er && (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM")) rmkids(p, options, cb);else if (er && er.code === "ENOTDIR") cb(originalEr);else cb(er);
  });
};
const rmkids = (p, options, cb) => {
  assert(p);
  assert(options);
  assert(typeof cb === 'function');
  options.readdir(p, (er, files) => {
    if (er) return cb(er);
    let n = files.length;
    if (n === 0) return options.rmdir(p, cb);
    let errState;
    files.forEach(f => {
      rimraf(path.join(p, f), options, er => {
        if (errState) return;
        if (er) return cb(errState = er);
        if (--n === 0) options.rmdir(p, cb);
      });
    });
  });
};

// this looks simpler, and is strictly *faster*, but will
// tie up the JavaScript thread and fail on excessively
// deep directory trees.
const rimrafSync = (p, options) => {
  options = options || {};
  defaults(options);
  assert(p, 'rimraf: missing path');
  assert.equal(typeof p, 'string', 'rimraf: path should be a string');
  assert(options, 'rimraf: missing options');
  assert.equal(typeof options, 'object', 'rimraf: options should be object');
  let results;
  if (options.disableGlob || !glob.hasMagic(p)) {
    results = [p];
  } else {
    try {
      options.lstatSync(p);
      results = [p];
    } catch (er) {
      results = glob.sync(p, options.glob);
    }
  }
  if (!results.length) return;
  for (let i = 0; i < results.length; i++) {
    const p = results[i];
    let st;
    try {
      st = options.lstatSync(p);
    } catch (er) {
      if (er.code === "ENOENT") return;

      // Windows can EPERM on stat.  Life is suffering.
      if (er.code === "EPERM" && isWindows) fixWinEPERMSync(p, options, er);
    }
    try {
      // sunos lets the root user unlink directories, which is... weird.
      if (st && st.isDirectory()) rmdirSync(p, options, null);else options.unlinkSync(p);
    } catch (er) {
      if (er.code === "ENOENT") return;
      if (er.code === "EPERM") return isWindows ? fixWinEPERMSync(p, options, er) : rmdirSync(p, options, er);
      if (er.code !== "EISDIR") throw er;
      rmdirSync(p, options, er);
    }
  }
};
const rmdirSync = (p, options, originalEr) => {
  assert(p);
  assert(options);
  try {
    options.rmdirSync(p);
  } catch (er) {
    if (er.code === "ENOENT") return;
    if (er.code === "ENOTDIR") throw originalEr;
    if (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM") rmkidsSync(p, options);
  }
};
const rmkidsSync = (p, options) => {
  assert(p);
  assert(options);
  options.readdirSync(p).forEach(f => rimrafSync(path.join(p, f), options));

  // We only end up here once we got ENOTEMPTY at least once, and
  // at this point, we are guaranteed to have removed all the kids.
  // So, we know that it won't be ENOENT or ENOTDIR or anything else.
  // try really hard to delete stuff on windows, because it has a
  // PROFOUNDLY annoying habit of not closing handles promptly when
  // files are deleted, resulting in spurious ENOTEMPTY errors.
  const retries = isWindows ? 100 : 1;
  let i = 0;
  do {
    let threw = true;
    try {
      const ret = options.rmdirSync(p, options);
      threw = false;
      return ret;
    } finally {
      if (++i < retries && threw) continue;
    }
  } while (true);
};
module.exports = rimraf;
rimraf.sync = rimrafSync;

/***/ }),

/***/ 3745:
/*!********************************************!*\
  !*** ./node_modules/safer-buffer/safer.js ***!
  \********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";
/* eslint-disable node/no-deprecated-api */



var buffer = __webpack_require__(/*! buffer */ 4300);
var Buffer = buffer.Buffer;
var safer = {};
var key;
for (key in buffer) {
  if (!buffer.hasOwnProperty(key)) continue;
  if (key === 'SlowBuffer' || key === 'Buffer') continue;
  safer[key] = buffer[key];
}
var Safer = safer.Buffer = {};
for (key in Buffer) {
  if (!Buffer.hasOwnProperty(key)) continue;
  if (key === 'allocUnsafe' || key === 'allocUnsafeSlow') continue;
  Safer[key] = Buffer[key];
}
safer.Buffer.prototype = Buffer.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 Buffer(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 = Buffer(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) {
    // we can't determine kStringMaxLength in environments where process.binding
    // is unsupported, so let's not set it
  }
}
if (!safer.constants) {
  safer.constants = {
    MAX_LENGTH: safer.kMaxLength
  };
  if (safer.kStringMaxLength) {
    safer.constants.MAX_STRING_LENGTH = safer.kStringMaxLength;
  }
}
module.exports = safer;

/***/ }),

/***/ 1737:
/*!****************************************!*\
  !*** ./node_modules/sshpk/lib/algs.js ***!
  \****************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// Copyright 2015 Joyent, Inc.

var Buffer = (__webpack_require__(/*! safer-buffer */ 3745).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
};

/*
 * Taken from
 * http://csrc.nist.gov/groups/ST/toolkit/documents/dss/NISTReCur.pdf
 */
var curves = {
  'nistp256': {
    size: 256,
    pkcs8oid: '1.2.840.10045.3.1.7',
    p: Buffer.from(('00' + 'ffffffff 00000001 00000000 00000000' + '00000000 ffffffff ffffffff ffffffff').replace(/ /g, ''), 'hex'),
    a: Buffer.from(('00' + 'FFFFFFFF 00000001 00000000 00000000' + '00000000 FFFFFFFF FFFFFFFF FFFFFFFC').replace(/ /g, ''), 'hex'),
    b: Buffer.from(('5ac635d8 aa3a93e7 b3ebbd55 769886bc' + '651d06b0 cc53b0f6 3bce3c3e 27d2604b').replace(/ /g, ''), 'hex'),
    s: Buffer.from(('00' + 'c49d3608 86e70493 6a6678e1 139d26b7' + '819f7e90').replace(/ /g, ''), 'hex'),
    n: Buffer.from(('00' + 'ffffffff 00000000 ffffffff ffffffff' + 'bce6faad a7179e84 f3b9cac2 fc632551').replace(/ /g, ''), 'hex'),
    G: Buffer.from(('04' + '6b17d1f2 e12c4247 f8bce6e5 63a440f2' + '77037d81 2deb33a0 f4a13945 d898c296' + '4fe342e2 fe1a7f9b 8ee7eb4a 7c0f9e16' + '2bce3357 6b315ece cbb64068 37bf51f5').replace(/ /g, ''), 'hex')
  },
  'nistp384': {
    size: 384,
    pkcs8oid: '1.3.132.0.34',
    p: Buffer.from(('00' + 'ffffffff ffffffff ffffffff ffffffff' + 'ffffffff ffffffff ffffffff fffffffe' + 'ffffffff 00000000 00000000 ffffffff').replace(/ /g, ''), 'hex'),
    a: Buffer.from(('00' + 'FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF' + 'FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFE' + 'FFFFFFFF 00000000 00000000 FFFFFFFC').replace(/ /g, ''), 'hex'),
    b: Buffer.from(('b3312fa7 e23ee7e4 988e056b e3f82d19' + '181d9c6e fe814112 0314088f 5013875a' + 'c656398d 8a2ed19d 2a85c8ed d3ec2aef').replace(/ /g, ''), 'hex'),
    s: Buffer.from(('00' + 'a335926a a319a27a 1d00896a 6773a482' + '7acdac73').replace(/ /g, ''), 'hex'),
    n: Buffer.from(('00' + 'ffffffff ffffffff ffffffff ffffffff' + 'ffffffff ffffffff c7634d81 f4372ddf' + '581a0db2 48b0a77a ecec196a ccc52973').replace(/ /g, ''), 'hex'),
    G: Buffer.from(('04' + 'aa87ca22 be8b0537 8eb1c71e f320ad74' + '6e1d3b62 8ba79b98 59f741e0 82542a38' + '5502f25d bf55296c 3a545e38 72760ab7' + '3617de4a 96262c6f 5d9e98bf 9292dc29' + 'f8f41dbd 289a147c e9da3113 b5f0b8c0' + '0a60b1ce 1d7e819d 7a431d7c 90ea0e5f').replace(/ /g, ''), 'hex')
  },
  'nistp521': {
    size: 521,
    pkcs8oid: '1.3.132.0.35',
    p: Buffer.from(('01ffffff ffffffff ffffffff ffffffff' + 'ffffffff ffffffff ffffffff ffffffff' + 'ffffffff ffffffff ffffffff ffffffff' + 'ffffffff ffffffff ffffffff ffffffff' + 'ffff').replace(/ /g, ''), 'hex'),
    a: Buffer.from(('01FF' + 'FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF' + 'FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF' + 'FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF' + 'FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFC').replace(/ /g, ''), 'hex'),
    b: Buffer.from(('51' + '953eb961 8e1c9a1f 929a21a0 b68540ee' + 'a2da725b 99b315f3 b8b48991 8ef109e1' + '56193951 ec7e937b 1652c0bd 3bb1bf07' + '3573df88 3d2c34f1 ef451fd4 6b503f00').replace(/ /g, ''), 'hex'),
    s: Buffer.from(('00' + 'd09e8800 291cb853 96cc6717 393284aa' + 'a0da64ba').replace(/ /g, ''), 'hex'),
    n: Buffer.from(('01ff' + 'ffffffff ffffffff ffffffff ffffffff' + 'ffffffff ffffffff ffffffff fffffffa' + '51868783 bf2f966b 7fcc0148 f709a5d0' + '3bb5c9b8 899c47ae bb6fb71e 91386409').replace(/ /g, ''), 'hex'),
    G: Buffer.from(('04' + '00c6 858e06b7 0404e9cd 9e3ecb66 2395b442' + '9c648139 053fb521 f828af60 6b4d3dba' + 'a14b5e77 efe75928 fe1dc127 a2ffa8de' + '3348b3c1 856a429b f97e7e31 c2e5bd66' + '0118 39296a78 9a3bc004 5c8a5fb4 2c7d1bd9' + '98f54449 579b4468 17afbd17 273e662c' + '97ee7299 5ef42640 c550b901 3fad0761' + '353c7086 a272c240 88be9476 9fd16650').replace(/ /g, ''), 'hex')
  }
};
module.exports = {
  info: algInfo,
  privInfo: algPrivInfo,
  hashAlgs: hashAlgs,
  curves: curves
};

/***/ }),

/***/ 8092:
/*!***********************************************!*\
  !*** ./node_modules/sshpk/lib/certificate.js ***!
  \***********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// Copyright 2016 Joyent, Inc.

module.exports = Certificate;
var assert = __webpack_require__(/*! assert-plus */ 1095);
var Buffer = (__webpack_require__(/*! safer-buffer */ 3745).Buffer);
var algs = __webpack_require__(/*! ./algs */ 1737);
var crypto = __webpack_require__(/*! crypto */ 6113);
var Fingerprint = __webpack_require__(/*! ./fingerprint */ 7339);
var Signature = __webpack_require__(/*! ./signature */ 5206);
var errs = __webpack_require__(/*! ./errors */ 3758);
var util = __webpack_require__(/*! util */ 3837);
var utils = __webpack_require__(/*! ./utils */ 6136);
var Key = __webpack_require__(/*! ./key */ 8996);
var PrivateKey = __webpack_require__(/*! ./private-key */ 8230);
var Identity = __webpack_require__(/*! ./identity */ 7424);
var formats = {};
formats['openssh'] = __webpack_require__(/*! ./formats/openssh-cert */ 4811);
formats['x509'] = __webpack_require__(/*! ./formats/x509 */ 942);
formats['pem'] = __webpack_require__(/*! ./formats/x509-pem */ 401);
var CertificateParseError = errs.CertificateParseError;
var InvalidAlgorithmError = errs.InvalidAlgorithmError;
function Certificate(opts) {
  assert.object(opts, 'options');
  assert.arrayOfObject(opts.subjects, 'options.subjects');
  utils.assertCompatible(opts.subjects[0], Identity, [1, 0], 'options.subjects');
  utils.assertCompatible(opts.subjectKey, Key, [1, 0], 'options.subjectKey');
  utils.assertCompatible(opts.issuer, Identity, [1, 0], 'options.issuer');
  if (opts.issuerKey !== undefined) {
    utils.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 = formats;
Certificate.prototype.toBuffer = function (format, options) {
  if (format === undefined) format = 'x509';
  assert.string(format, 'format');
  assert.object(formats[format], 'formats[format]');
  assert.optionalObject(options, 'options');
  return formats[format].write(this, options);
};
Certificate.prototype.toString = function (format, options) {
  if (format === undefined) format = 'pem';
  return this.toBuffer(format, options).toString();
};
Certificate.prototype.fingerprint = function (algo) {
  if (algo === undefined) 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 (algs.hashAlgs[algo] === undefined) throw new InvalidAlgorithmError(algo);
  if (this._hashCache[algo]) return this._hashCache[algo];
  var hash = crypto.createHash(algo).update(this.toBuffer('x509')).digest();
  this._hashCache[algo] = hash;
  return hash;
};
Certificate.prototype.isExpired = function (when) {
  if (when === undefined) when = new Date();
  return !(when.getTime() >= this.validFrom.getTime() && when.getTime() < this.validUntil.getTime());
};
Certificate.prototype.isSignedBy = function (issuerCert) {
  utils.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 x509 = this.signatures.x509;
  if (x509 && x509.extras && x509.extras.exts) {
    x509.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) {
  utils.assertCompatible(issuerKey, Key, [1, 2], 'issuerKey');
  if (this.issuerKey !== undefined) {
    return this.issuerKey.fingerprint('sha512').matches(issuerKey);
  }
  var fmt = Object.keys(this.signatures)[0];
  var valid = formats[fmt].verify(this, issuerKey);
  if (valid) this.issuerKey = issuerKey;
  return valid;
};
Certificate.prototype.signWith = function (key) {
  utils.assertCompatible(key, PrivateKey, [1, 2], 'key');
  var fmts = Object.keys(formats);
  var didOne = false;
  for (var i = 0; i < fmts.length; ++i) {
    if (fmts[i] !== 'pem') {
      var ret = formats[fmts[i]].sign(this, key);
      if (ret === true) didOne = true;
    }
  }
  if (!didOne) {
    throw new Error('Failed to sign the certificate for any ' + 'available certificate formats');
  }
};
Certificate.createSelfSigned = function (subjectOrSubjects, key, options) {
  var subjects;
  if (Array.isArray(subjectOrSubjects)) subjects = subjectOrSubjects;else subjects = [subjectOrSubjects];
  assert.arrayOfObject(subjects);
  subjects.forEach(function (subject) {
    utils.assertCompatible(subject, Identity, [1, 0], 'subject');
  });
  utils.assertCompatible(key, PrivateKey, [1, 2], 'private key');
  assert.optionalObject(options, 'options');
  if (options === undefined) options = {};
  assert.optionalObject(options.validFrom, 'options.validFrom');
  assert.optionalObject(options.validUntil, 'options.validUntil');
  var validFrom = options.validFrom;
  var validUntil = options.validUntil;
  if (validFrom === undefined) validFrom = new Date();
  if (validUntil === undefined) {
    assert.optionalNumber(options.lifetime, 'options.lifetime');
    var lifetime = options.lifetime;
    if (lifetime === undefined) lifetime = 10 * 365 * 24 * 3600;
    validUntil = new Date();
    validUntil.setTime(validUntil.getTime() + lifetime * 1000);
  }
  assert.optionalBuffer(options.serial, 'options.serial');
  var serial = options.serial;
  if (serial === undefined) serial = Buffer.from('0000000000000001', 'hex');
  var purposes = options.purposes;
  if (purposes === undefined) purposes = [];
  if (purposes.indexOf('signature') === -1) purposes.push('signature');

  /* Self-signed certs are always CAs. */
  if (purposes.indexOf('ca') === -1) purposes.push('ca');
  if (purposes.indexOf('crl') === -1) purposes.push('crl');

  /*
   * If we weren't explicitly given any other purposes, do the sensible
   * thing and add some basic ones depending on the subject type.
   */
  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 (key.type === 'rsa' && purposes.indexOf('encryption') === -1) purposes.push('encryption');
    }
  }
  var cert = new Certificate({
    subjects: subjects,
    issuer: subjects[0],
    subjectKey: key.toPublic(),
    issuerKey: key.toPublic(),
    signatures: {},
    serial: serial,
    validFrom: validFrom,
    validUntil: validUntil,
    purposes: purposes
  });
  cert.signWith(key);
  return cert;
};
Certificate.create = function (subjectOrSubjects, key, issuer, issuerKey, options) {
  var subjects;
  if (Array.isArray(subjectOrSubjects)) subjects = subjectOrSubjects;else subjects = [subjectOrSubjects];
  assert.arrayOfObject(subjects);
  subjects.forEach(function (subject) {
    utils.assertCompatible(subject, Identity, [1, 0], 'subject');
  });
  utils.assertCompatible(key, Key, [1, 0], 'key');
  if (PrivateKey.isPrivateKey(key)) key = key.toPublic();
  utils.assertCompatible(issuer, Identity, [1, 0], 'issuer');
  utils.assertCompatible(issuerKey, PrivateKey, [1, 2], 'issuer key');
  assert.optionalObject(options, 'options');
  if (options === undefined) options = {};
  assert.optionalObject(options.validFrom, 'options.validFrom');
  assert.optionalObject(options.validUntil, 'options.validUntil');
  var validFrom = options.validFrom;
  var validUntil = options.validUntil;
  if (validFrom === undefined) validFrom = new Date();
  if (validUntil === undefined) {
    assert.optionalNumber(options.lifetime, 'options.lifetime');
    var lifetime = options.lifetime;
    if (lifetime === undefined) lifetime = 10 * 365 * 24 * 3600;
    validUntil = new Date();
    validUntil.setTime(validUntil.getTime() + lifetime * 1000);
  }
  assert.optionalBuffer(options.serial, 'options.serial');
  var serial = options.serial;
  if (serial === undefined) serial = Buffer.from('0000000000000001', 'hex');
  var purposes = options.purposes;
  if (purposes === undefined) 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 (key.type === 'rsa' && purposes.indexOf('encryption') === -1) purposes.push('encryption');
  }
  var cert = new Certificate({
    subjects: subjects,
    issuer: issuer,
    subjectKey: key,
    issuerKey: issuerKey.toPublic(),
    signatures: {},
    serial: serial,
    validFrom: validFrom,
    validUntil: validUntil,
    purposes: purposes
  });
  cert.signWith(issuerKey);
  return cert;
};
Certificate.parse = function (data, format, options) {
  if (typeof data !== 'string') assert.buffer(data, 'data');
  if (format === undefined) format = 'auto';
  assert.string(format, 'format');
  if (typeof options === 'string') options = {
    filename: options
  };
  assert.optionalObject(options, 'options');
  if (options === undefined) options = {};
  assert.optionalString(options.filename, 'options.filename');
  if (options.filename === undefined) options.filename = '(unnamed)';
  assert.object(formats[format], 'formats[format]');
  try {
    var k = formats[format].read(data, options);
    return k;
  } catch (e) {
    throw new CertificateParseError(options.filename, format, e);
  }
};
Certificate.isCertificate = function (obj, ver) {
  return utils.isCompatible(obj, Certificate, ver);
};

/*
 * API versions for Certificate:
 * [1,0] -- initial ver
 * [1,1] -- openssh format now unpacks extensions
 */
Certificate.prototype._sshpkApiVersion = [1, 1];
Certificate._oldVersionDetect = function (obj) {
  return [1, 0];
};

/***/ }),

/***/ 3979:
/*!***************************************!*\
  !*** ./node_modules/sshpk/lib/dhe.js ***!
  \***************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// Copyright 2017 Joyent, Inc.

module.exports = {
  DiffieHellman: DiffieHellman,
  generateECDSA: generateECDSA,
  generateED25519: generateED25519
};
var assert = __webpack_require__(/*! assert-plus */ 1095);
var crypto = __webpack_require__(/*! crypto */ 6113);
var Buffer = (__webpack_require__(/*! safer-buffer */ 3745).Buffer);
var algs = __webpack_require__(/*! ./algs */ 1737);
var utils = __webpack_require__(/*! ./utils */ 6136);
var nacl = __webpack_require__(/*! tweetnacl */ 8227);
var Key = __webpack_require__(/*! ./key */ 8996);
var PrivateKey = __webpack_require__(/*! ./private-key */ 8230);
var CRYPTO_HAVE_ECDH = crypto.createECDH !== undefined;
var ecdh = __webpack_require__(/*! ecc-jsbn */ 6695);
var ec = __webpack_require__(/*! ecc-jsbn/lib/ec */ 7221);
var jsbn = (__webpack_require__(/*! jsbn */ 456).BigInteger);
function DiffieHellman(key) {
  utils.assertCompatible(key, Key, [1, 4], 'key');
  this._isPriv = PrivateKey.isPrivateKey(key, [1, 3]);
  this._algo = key.type;
  this._curve = key.curve;
  this._key = key;
  if (key.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 = crypto.createDiffieHellman(key.part.p.data, undefined, key.part.g.data, undefined);
    this._p = key.part.p;
    this._g = key.part.g;
    if (this._isPriv) this._dh.setPrivateKey(key.part.x.data);
    this._dh.setPublicKey(key.part.y.data);
  } else if (key.type === 'ecdsa') {
    if (!CRYPTO_HAVE_ECDH) {
      this._ecParams = new X9ECParameters(this._curve);
      if (this._isPriv) {
        this._priv = new ECPrivate(this._ecParams, key.part.d.data);
      }
      return;
    }
    var curve = {
      'nistp256': 'prime256v1',
      'nistp384': 'secp384r1',
      'nistp521': 'secp521r1'
    }[key.curve];
    this._dh = crypto.createECDH(curve);
    if (typeof this._dh !== 'object' || typeof this._dh.setPrivateKey !== 'function') {
      CRYPTO_HAVE_ECDH = false;
      DiffieHellman.call(this, key);
      return;
    }
    if (this._isPriv) this._dh.setPrivateKey(key.part.d.data);
    this._dh.setPublicKey(key.part.Q.data);
  } else if (key.type === 'curve25519') {
    if (this._isPriv) {
      utils.assertCompatible(key, PrivateKey, [1, 5], 'key');
      this._priv = key.part.k.data;
    }
  } else {
    throw new Error('DH not supported for ' + key.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 undefined;
};
DiffieHellman.prototype.getKey = DiffieHellman.prototype.getPrivateKey;
DiffieHellman.prototype._keyCheck = function (pk, isPub) {
  assert.object(pk, 'key');
  if (!isPub) utils.assertCompatible(pk, PrivateKey, [1, 3], 'key');
  utils.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] === 0x00) 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] === 0x00 && 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 Buffer.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: parts
    });
    this._isPriv = true;
    return this._key;
  } else if (this._algo === 'ecdsa') {
    if (CRYPTO_HAVE_ECDH) {
      this._dh.generateKeys();
      parts.push({
        name: 'curve',
        data: Buffer.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: parts
      });
      this._isPriv = true;
      return this._key;
    } else {
      var n = this._ecParams.getN();
      var r = new jsbn(crypto.randomBytes(n.bitLength()));
      var n1 = n.subtract(jsbn.ONE);
      priv = r.mod(n1).add(jsbn.ONE);
      pub = this._ecParams.getG().multiply(priv);
      priv = Buffer.from(priv.toByteArray());
      pub = Buffer.from(this._ecParams.getCurve().encodePointHex(pub), 'hex');
      this._priv = new ECPrivate(this._ecParams, priv);
      parts.push({
        name: 'curve',
        data: Buffer.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: parts
      });
      this._isPriv = true;
      return this._key;
    }
  } else if (this._algo === 'curve25519') {
    var pair = nacl.box.keyPair();
    priv = Buffer.from(pair.secretKey);
    pub = Buffer.from(pair.publicKey);
    priv = Buffer.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: parts
    });
    this._isPriv = true;
    return this._key;
  }
  throw new Error('Invalid algorithm: ' + this._algo);
};
DiffieHellman.prototype.generateKeys = DiffieHellman.prototype.generateKey;

/* These are helpers for using ecc-jsbn (for node 0.10 compatibility). */

function X9ECParameters(name) {
  var params = algs.curves[name];
  assert.object(params);
  var p = new jsbn(params.p);
  var a = new jsbn(params.a);
  var b = new jsbn(params.b);
  var n = new jsbn(params.n);
  var h = jsbn.ONE;
  var curve = new ec.ECCurveFp(p, a, b);
  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] === 0x00) buffer = buffer.slice(1);
  this._pub = params.getCurve().decodePointHex(buffer.toString('hex'));
}
function ECPrivate(params, buffer) {
  this._params = params;
  this._priv = new jsbn(utils.mpNormalize(buffer));
}
ECPrivate.prototype.deriveSharedSecret = function (pubKey) {
  assert.ok(pubKey instanceof ECPublic);
  var S = pubKey._pub.multiply(this._priv);
  return Buffer.from(S.getX().toBigInteger().toByteArray());
};
function generateED25519() {
  var pair = nacl.sign.keyPair();
  var priv = Buffer.from(pair.secretKey);
  var pub = Buffer.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 key = new PrivateKey({
    type: 'ed25519',
    parts: parts
  });
  return key;
}

/* Generates a new ECDSA private key on a given curve. */
function generateECDSA(curve) {
  var parts = [];
  var key;
  if (CRYPTO_HAVE_ECDH) {
    /*
     * Node crypto doesn't expose key generation directly, but the
     * ECDH instances can generate keys. It turns out this just
     * calls into the OpenSSL generic key generator, and we can
     * read its output happily without doing an actual DH. So we
     * use that here.
     */
    var osCurve = {
      'nistp256': 'prime256v1',
      'nistp384': 'secp384r1',
      'nistp521': 'secp521r1'
    }[curve];
    var dh = crypto.createECDH(osCurve);
    dh.generateKeys();
    parts.push({
      name: 'curve',
      data: Buffer.from(curve)
    });
    parts.push({
      name: 'Q',
      data: dh.getPublicKey()
    });
    parts.push({
      name: 'd',
      data: dh.getPrivateKey()
    });
    key = new PrivateKey({
      type: 'ecdsa',
      curve: curve,
      parts: parts
    });
    return key;
  } else {
    var ecParams = new X9ECParameters(curve);

    /* This algorithm taken from FIPS PUB 186-4 (section B.4.1) */
    var n = ecParams.getN();
    /*
     * The crypto.randomBytes() function can only give us whole
     * bytes, so taking a nod from X9.62, we round up.
     */
    var cByteLen = Math.ceil((n.bitLength() + 64) / 8);
    var c = new jsbn(crypto.randomBytes(cByteLen));
    var n1 = n.subtract(jsbn.ONE);
    var priv = c.mod(n1).add(jsbn.ONE);
    var pub = ecParams.getG().multiply(priv);
    priv = Buffer.from(priv.toByteArray());
    pub = Buffer.from(ecParams.getCurve().encodePointHex(pub), 'hex');
    parts.push({
      name: 'curve',
      data: Buffer.from(curve)
    });
    parts.push({
      name: 'Q',
      data: pub
    });
    parts.push({
      name: 'd',
      data: priv
    });
    key = new PrivateKey({
      type: 'ecdsa',
      curve: curve,
      parts: parts
    });
    return key;
  }
}

/***/ }),

/***/ 1443:
/*!*********************************************!*\
  !*** ./node_modules/sshpk/lib/ed-compat.js ***!
  \*********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// Copyright 2015 Joyent, Inc.

module.exports = {
  Verifier: Verifier,
  Signer: Signer
};
var nacl = __webpack_require__(/*! tweetnacl */ 8227);
var stream = __webpack_require__(/*! stream */ 3978);
var util = __webpack_require__(/*! util */ 3837);
var assert = __webpack_require__(/*! assert-plus */ 1095);
var Buffer = (__webpack_require__(/*! safer-buffer */ 3745).Buffer);
var Signature = __webpack_require__(/*! ./signature */ 5206);
function Verifier(key, hashAlgo) {
  if (hashAlgo.toLowerCase() !== 'sha512') throw new Error('ED25519 only supports the use of ' + 'SHA-512 hashes');
  this.key = key;
  this.chunks = [];
  stream.Writable.call(this, {});
}
util.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 = Buffer.from(chunk, 'binary');
  this.chunks.push(chunk);
};
Verifier.prototype.verify = function (signature, fmt) {
  var sig;
  if (Signature.isSignature(signature, [2, 0])) {
    if (signature.type !== 'ed25519') return false;
    sig = signature.toBuffer('raw');
  } else if (typeof signature === 'string') {
    sig = Buffer.from(signature, 'base64');
  } else if (Signature.isSignature(signature, [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(Buffer.concat(this.chunks)), new Uint8Array(sig), new Uint8Array(this.key.part.A.data));
};
function Signer(key, hashAlgo) {
  if (hashAlgo.toLowerCase() !== 'sha512') throw new Error('ED25519 only supports the use of ' + 'SHA-512 hashes');
  this.key = key;
  this.chunks = [];
  stream.Writable.call(this, {});
}
util.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 = Buffer.from(chunk, 'binary');
  this.chunks.push(chunk);
};
Signer.prototype.sign = function () {
  var sig = nacl.sign.detached(new Uint8Array(Buffer.concat(this.chunks)), new Uint8Array(Buffer.concat([this.key.part.k.data, this.key.part.A.data])));
  var sigBuf = Buffer.from(sig);
  var sigObj = Signature.parse(sigBuf, 'ed25519', 'raw');
  sigObj.hashAlgorithm = 'sha512';
  return sigObj;
};

/***/ }),

/***/ 3758:
/*!******************************************!*\
  !*** ./node_modules/sshpk/lib/errors.js ***!
  \******************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// Copyright 2015 Joyent, Inc.

var assert = __webpack_require__(/*! assert-plus */ 1095);
var util = __webpack_require__(/*! util */ 3837);
function FingerprintFormatError(fp, format) {
  if (Error.captureStackTrace) Error.captureStackTrace(this, FingerprintFormatError);
  this.name = 'FingerprintFormatError';
  this.fingerprint = fp;
  this.format = format;
  this.message = 'Fingerprint format is not supported, or is invalid: ';
  if (fp !== undefined) this.message += ' fingerprint = ' + fp;
  if (format !== undefined) this.message += ' format = ' + format;
}
util.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';
}
util.inherits(InvalidAlgorithmError, Error);
function KeyParseError(name, format, innerErr) {
  if (Error.captureStackTrace) Error.captureStackTrace(this, KeyParseError);
  this.name = 'KeyParseError';
  this.format = format;
  this.keyName = name;
  this.innerErr = innerErr;
  this.message = 'Failed to parse ' + name + ' as a valid ' + format + ' format key: ' + innerErr.message;
}
util.inherits(KeyParseError, Error);
function SignatureParseError(type, format, innerErr) {
  if (Error.captureStackTrace) Error.captureStackTrace(this, SignatureParseError);
  this.name = 'SignatureParseError';
  this.type = type;
  this.format = format;
  this.innerErr = innerErr;
  this.message = 'Failed to parse the given data as a ' + type + ' signature in ' + format + ' format: ' + innerErr.message;
}
util.inherits(SignatureParseError, Error);
function CertificateParseError(name, format, innerErr) {
  if (Error.captureStackTrace) Error.captureStackTrace(this, CertificateParseError);
  this.name = 'CertificateParseError';
  this.format = format;
  this.certName = name;
  this.innerErr = innerErr;
  this.message = 'Failed to parse ' + name + ' as a valid ' + format + ' format certificate: ' + innerErr.message;
}
util.inherits(CertificateParseError, Error);
function KeyEncryptedError(name, format) {
  if (Error.captureStackTrace) Error.captureStackTrace(this, KeyEncryptedError);
  this.name = 'KeyEncryptedError';
  this.format = format;
  this.keyName = name;
  this.message = 'The ' + format + ' format key ' + name + ' is ' + 'encrypted (password-protected), and no passphrase was ' + 'provided in `options`';
}
util.inherits(KeyEncryptedError, Error);
module.exports = {
  FingerprintFormatError: FingerprintFormatError,
  InvalidAlgorithmError: InvalidAlgorithmError,
  KeyParseError: KeyParseError,
  SignatureParseError: SignatureParseError,
  KeyEncryptedError: KeyEncryptedError,
  CertificateParseError: CertificateParseError
};

/***/ }),

/***/ 7339:
/*!***********************************************!*\
  !*** ./node_modules/sshpk/lib/fingerprint.js ***!
  \***********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// Copyright 2018 Joyent, Inc.

module.exports = Fingerprint;
var assert = __webpack_require__(/*! assert-plus */ 1095);
var Buffer = (__webpack_require__(/*! safer-buffer */ 3745).Buffer);
var algs = __webpack_require__(/*! ./algs */ 1737);
var crypto = __webpack_require__(/*! crypto */ 6113);
var errs = __webpack_require__(/*! ./errors */ 3758);
var Key = __webpack_require__(/*! ./key */ 8996);
var PrivateKey = __webpack_require__(/*! ./private-key */ 8230);
var Certificate = __webpack_require__(/*! ./certificate */ 8092);
var utils = __webpack_require__(/*! ./utils */ 6136);
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 (algs.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 (format) {
  if (format === undefined) {
    if (this.algorithm === 'md5' || this.hashType === 'spki') format = 'hex';else format = 'base64';
  }
  assert.string(format);
  switch (format) {
    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(undefined, format);
  }
};
Fingerprint.prototype.matches = function (other) {
  assert.object(other, 'key or certificate');
  if (this.type === 'key' && this.hashType !== 'ssh') {
    utils.assertCompatible(other, Key, [1, 7], 'key with spki');
    if (PrivateKey.isPrivateKey(other)) {
      utils.assertCompatible(other, PrivateKey, [1, 6], 'privatekey with spki support');
    }
  } else if (this.type === 'key') {
    utils.assertCompatible(other, Key, [1, 0], 'key');
  } else {
    utils.assertCompatible(other, Certificate, [1, 0], 'certificate');
  }
  var theirHash = other.hash(this.algorithm, this.hashType);
  var theirHash2 = crypto.createHash(this.algorithm).update(theirHash).digest('base64');
  if (this.hash2 === undefined) this.hash2 = crypto.createHash(this.algorithm).update(this.hash).digest('base64');
  return this.hash2 === theirHash2;
};

/*JSSTYLED*/
var base64RE = /^[A-Za-z0-9+\/=]+$/;
/*JSSTYLED*/
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 === undefined) options = {};
  if (options.enAlgs !== undefined) enAlgs = options.enAlgs;
  if (options.algorithms !== undefined) enAlgs = options.algorithms;
  assert.optionalArrayOfString(enAlgs, 'algorithms');
  var hashType = 'ssh';
  if (options.hashType !== undefined) 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 = Buffer.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 = Buffer.from(parts, 'hex');
    } catch (e) {
      throw new FingerprintFormatError(fp);
    }
  } else {
    if (hexRE.test(fp)) {
      hash = Buffer.from(fp, 'hex');
    } else if (base64RE.test(fp)) {
      hash = Buffer.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);
    }

    /* Plain hex/base64: guess it's probably SPKI unless told. */
    if (options.hashType === undefined) hashType = 'spki';
  }
  if (alg === undefined) throw new FingerprintFormatError(fp);
  if (algs.hashAlgs[alg] === undefined) throw new InvalidAlgorithmError(alg);
  if (enAlgs !== undefined) {
    enAlgs = enAlgs.map(function (a) {
      return a.toLowerCase();
    });
    if (enAlgs.indexOf(alg) === -1) throw new InvalidAlgorithmError(alg);
  }
  return new Fingerprint({
    algorithm: alg,
    hash: hash,
    type: options.type || 'key',
    hashType: hashType
  });
};
function addColons(s) {
  /*JSSTYLED*/
  return s.replace(/(.{2})(?=.)/g, '$1:');
}
function base64Strip(s) {
  /*JSSTYLED*/
  return s.replace(/=*$/, '');
}
function sshBase64Format(alg, h) {
  return alg.toUpperCase() + ':' + base64Strip(h);
}
Fingerprint.isFingerprint = function (obj, ver) {
  return utils.isCompatible(obj, Fingerprint, ver);
};

/*
 * API versions for Fingerprint:
 * [1,0] -- initial ver
 * [1,1] -- first tagged ver
 * [1,2] -- hashType and spki support
 */
Fingerprint.prototype._sshpkApiVersion = [1, 2];
Fingerprint._oldVersionDetect = function (obj) {
  assert.func(obj.toString);
  assert.func(obj.matches);
  return [1, 0];
};

/***/ }),

/***/ 2687:
/*!************************************************!*\
  !*** ./node_modules/sshpk/lib/formats/auto.js ***!
  \************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// Copyright 2018 Joyent, Inc.

module.exports = {
  read: read,
  write: write
};
var assert = __webpack_require__(/*! assert-plus */ 1095);
var Buffer = (__webpack_require__(/*! safer-buffer */ 3745).Buffer);
var utils = __webpack_require__(/*! ../utils */ 6136);
var Key = __webpack_require__(/*! ../key */ 8996);
var PrivateKey = __webpack_require__(/*! ../private-key */ 8230);
var pem = __webpack_require__(/*! ./pem */ 8620);
var ssh = __webpack_require__(/*! ./ssh */ 2300);
var rfc4253 = __webpack_require__(/*! ./rfc4253 */ 4709);
var dnssec = __webpack_require__(/*! ./dnssec */ 160);
var putty = __webpack_require__(/*! ./putty */ 1657);
var DNSSEC_PRIVKEY_HEADER_PREFIX = 'Private-key-format: v1';
function read(buf, options) {
  if (typeof buf === 'string') {
    if (buf.trim().match(/^[-]+[ ]*BEGIN/)) return pem.read(buf, options);
    if (buf.match(/^\s*ssh-[a-z]/)) return ssh.read(buf, options);
    if (buf.match(/^\s*ecdsa-/)) return ssh.read(buf, options);
    if (buf.match(/^putty-user-key-file-2:/i)) return putty.read(buf, options);
    if (findDNSSECHeader(buf)) return dnssec.read(buf, options);
    buf = Buffer.from(buf, 'binary');
  } else {
    assert.buffer(buf);
    if (findPEMHeader(buf)) return pem.read(buf, options);
    if (findSSHHeader(buf)) return ssh.read(buf, options);
    if (findPuTTYHeader(buf)) return putty.read(buf, options);
    if (findDNSSECHeader(buf)) return dnssec.read(buf, options);
  }
  if (buf.readUInt32BE(0) < buf.length) return rfc4253.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) {
  // private case first
  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;

  // public-key RFC3110 ?
  // 'domain.com. IN KEY ...' or 'domain.com. IN DNSKEY ...'
  // skip any comment-lines
  if (typeof buf !== 'string') {
    buf = buf.toString('ascii');
  }
  var lines = buf.split('\n');
  var line = 0;
  /* JSSTYLED */
  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(key, options) {
  throw new Error('"auto" format cannot be used for writing');
}

/***/ }),

/***/ 160:
/*!**************************************************!*\
  !*** ./node_modules/sshpk/lib/formats/dnssec.js ***!
  \**************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// Copyright 2017 Joyent, Inc.

module.exports = {
  read: read,
  write: write
};
var assert = __webpack_require__(/*! assert-plus */ 1095);
var Buffer = (__webpack_require__(/*! safer-buffer */ 3745).Buffer);
var Key = __webpack_require__(/*! ../key */ 8996);
var PrivateKey = __webpack_require__(/*! ../private-key */ 8230);
var utils = __webpack_require__(/*! ../utils */ 6136);
var SSHBuffer = __webpack_require__(/*! ../ssh-buffer */ 6838);
var Dhe = __webpack_require__(/*! ../dhe */ 3979);
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));
  }

  // skip any comment-lines
  var line = 0;
  /* JSSTYLED */
  while (lines[line].match(/^\;/)) line++;
  // we should now have *one single* line left with our KEY on it.
  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(' ');
  //unused var flags = parseInt(elems[3], 10);
  //unused var protocol = parseInt(elems[4], 10);
  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 = Buffer.from(base64key, 'base64');
  if (supportedAlgosById[algorithm].match(/^RSA-/)) {
    // join the rest of the body into a single base64-blob
    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 = utils.mpNormalize(publicExponent);
    var modulus = keyBuffer.slice(1 + publicExponentLen);
    modulus = utils.mpNormalize(modulus);
    // now, make the key
    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: curve,
      size: size,
      parts: [{
        name: 'curve',
        data: Buffer.from(curve)
      }, {
        name: 'Q',
        data: utils.ecNormalize(keyBuffer)
      }]
    };
    return new Key(ecdsaKey);
  }
  throw new Error('Unsupported algorithm: ' + supportedAlgosById[algorithm]);
}
function elementToBuf(e) {
  return Buffer.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);
  });
  // now, make the key
  var key = {
    type: 'rsa',
    parts: [{
      name: 'e',
      data: utils.mpNormalize(rsaParams['e'])
    }, {
      name: 'n',
      data: utils.mpNormalize(rsaParams['n'])
    }, {
      name: 'd',
      data: utils.mpNormalize(rsaParams['d'])
    }, {
      name: 'p',
      data: utils.mpNormalize(rsaParams['p'])
    }, {
      name: 'q',
      data: utils.mpNormalize(rsaParams['q'])
    }, {
      name: 'dmodp',
      data: utils.mpNormalize(rsaParams['dmodp'])
    }, {
      name: 'dmodq',
      data: utils.mpNormalize(rsaParams['dmodq'])
    }, {
      name: 'iqmp',
      data: utils.mpNormalize(rsaParams['iqmp'])
    }]
  };
  return new PrivateKey(key);
}
function readDNSSECPrivateKey(alg, elements) {
  if (supportedAlgosById[alg].match(/^RSA-/)) {
    return readDNSSECRSAPrivateKey(elements);
  }
  if (supportedAlgosById[alg] === 'ECDSA-P384-SHA384' || supportedAlgosById[alg] === 'ECDSA-P256-SHA256') {
    var d = Buffer.from(elements[0].split(' ')[1], 'base64');
    var curve = 'nistp384';
    var size = 384;
    if (supportedAlgosById[alg] === 'ECDSA-P256-SHA256') {
      curve = 'nistp256';
      size = 256;
    }
    // DNSSEC generates the public-key on the fly (go calculate it)
    var publicKey = utils.publicFromPrivateECDSA(curve, d);
    var Q = publicKey.part['Q'].data;
    var ecdsaKey = {
      type: 'ecdsa',
      curve: curve,
      size: size,
      parts: [{
        name: 'curve',
        data: Buffer.from(curve)
      }, {
        name: 'd',
        data: d
      }, {
        name: 'Q',
        data: Q
      }]
    };
    return new PrivateKey(ecdsaKey);
  }
  throw new Error('Unsupported algorithm: ' + supportedAlgosById[alg]);
}
function dnssecTimestamp(date) {
  var year = date.getFullYear() + ''; //stringify
  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(key, options) {
  // if we're missing parts, add them.
  if (!key.part.dmodp || !key.part.dmodq) {
    utils.addRSAMissing(key);
  }
  var out = '';
  out += 'Private-key-format: v1.3\n';
  out += 'Algorithm: ' + rsaAlgFromOptions(options) + '\n';
  var n = utils.mpDenormalize(key.part['n'].data);
  out += 'Modulus: ' + n.toString('base64') + '\n';
  var e = utils.mpDenormalize(key.part['e'].data);
  out += 'PublicExponent: ' + e.toString('base64') + '\n';
  var d = utils.mpDenormalize(key.part['d'].data);
  out += 'PrivateExponent: ' + d.toString('base64') + '\n';
  var p = utils.mpDenormalize(key.part['p'].data);
  out += 'Prime1: ' + p.toString('base64') + '\n';
  var q = utils.mpDenormalize(key.part['q'].data);
  out += 'Prime2: ' + q.toString('base64') + '\n';
  var dmodp = utils.mpDenormalize(key.part['dmodp'].data);
  out += 'Exponent1: ' + dmodp.toString('base64') + '\n';
  var dmodq = utils.mpDenormalize(key.part['dmodq'].data);
  out += 'Exponent2: ' + dmodq.toString('base64') + '\n';
  var iqmp = utils.mpDenormalize(key.part['iqmp'].data);
  out += 'Coefficient: ' + iqmp.toString('base64') + '\n';
  // Assume that we're valid as-of now
  var timestamp = new Date();
  out += 'Created: ' + dnssecTimestamp(timestamp) + '\n';
  out += 'Publish: ' + dnssecTimestamp(timestamp) + '\n';
  out += 'Activate: ' + dnssecTimestamp(timestamp) + '\n';
  return Buffer.from(out, 'ascii');
}
function writeECDSA(key, options) {
  var out = '';
  out += 'Private-key-format: v1.3\n';
  if (key.curve === 'nistp256') {
    out += 'Algorithm: 13 (ECDSAP256SHA256)\n';
  } else if (key.curve === 'nistp384') {
    out += 'Algorithm: 14 (ECDSAP384SHA384)\n';
  } else {
    throw new Error('Unsupported curve');
  }
  var base64Key = key.part['d'].data.toString('base64');
  out += 'PrivateKey: ' + base64Key + '\n';

  // Assume that we're valid as-of now
  var timestamp = new Date();
  out += 'Created: ' + dnssecTimestamp(timestamp) + '\n';
  out += 'Publish: ' + dnssecTimestamp(timestamp) + '\n';
  out += 'Activate: ' + dnssecTimestamp(timestamp) + '\n';
  return Buffer.from(out, 'ascii');
}
function write(key, options) {
  if (PrivateKey.isPrivateKey(key)) {
    if (key.type === 'rsa') {
      return writeRSA(key, options);
    } else if (key.type === 'ecdsa') {
      return writeECDSA(key, options);
    } else {
      throw new Error('Unsupported algorithm: ' + key.type);
    }
  } else if (Key.isKey(key)) {
    /*
     * RFC3110 requires a keyname, and a keytype, which we
     * don't really have a mechanism for specifying such
     * additional metadata.
     */
    throw new Error('Format "dnssec" only supports ' + 'writing private keys');
  } else {
    throw new Error('key is not a Key or PrivateKey');
  }
}

/***/ }),

/***/ 4811:
/*!********************************************************!*\
  !*** ./node_modules/sshpk/lib/formats/openssh-cert.js ***!
  \********************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// Copyright 2017 Joyent, Inc.

module.exports = {
  read: read,
  verify: verify,
  sign: sign,
  signAsync: signAsync,
  write: write,
  /* Internal private API */
  fromBuffer: fromBuffer,
  toBuffer: toBuffer
};
var assert = __webpack_require__(/*! assert-plus */ 1095);
var SSHBuffer = __webpack_require__(/*! ../ssh-buffer */ 6838);
var crypto = __webpack_require__(/*! crypto */ 6113);
var Buffer = (__webpack_require__(/*! safer-buffer */ 3745).Buffer);
var algs = __webpack_require__(/*! ../algs */ 1737);
var Key = __webpack_require__(/*! ../key */ 8996);
var PrivateKey = __webpack_require__(/*! ../private-key */ 8230);
var Identity = __webpack_require__(/*! ../identity */ 7424);
var rfc4253 = __webpack_require__(/*! ./rfc4253 */ 4709);
var Signature = __webpack_require__(/*! ../signature */ 5206);
var utils = __webpack_require__(/*! ../utils */ 6136);
var Certificate = __webpack_require__(/*! ../certificate */ 8092);
function verify(cert, key) {
  /*
   * We always give an issuerKey, so if our verify() is being called then
   * there was no signature. Return false.
   */
  return false;
}
var TYPES = {
  'user': 1,
  'host': 2
};
Object.keys(TYPES).forEach(function (k) {
  TYPES[TYPES[k]] = k;
});
var ECDSA_ALGO = /^ecdsa-sha2-([^@-]+)-cert-v01@openssh.com$/;
function read(buf, options) {
  if (Buffer.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 data = parts[1];
  data = Buffer.from(data, 'base64');
  return fromBuffer(data, algo);
}
function fromBuffer(data, algo, partial) {
  var sshbuf = new SSHBuffer({
    buffer: data
  });
  var innerAlgo = sshbuf.readString();
  if (algo !== undefined && innerAlgo !== algo) throw new Error('SSH certificate algorithm mismatch');
  if (algo === undefined) algo = innerAlgo;
  var cert = {};
  cert.signatures = {};
  cert.signatures.openssh = {};
  cert.signatures.openssh.nonce = sshbuf.readBuffer();
  var key = {};
  var parts = key.parts = [];
  key.type = getAlg(algo);
  var partCount = algs.info[key.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 = algs.info[key.type];
  if (key.type === 'ecdsa') {
    var res = ECDSA_ALGO.exec(algo);
    assert.ok(res !== null);
    assert.strictEqual(res[1], parts[0].data.toString());
  }
  for (var i = 0; i < algInfo.parts.length; ++i) {
    parts[i].name = algInfo.parts[i];
    if (parts[i].name !== 'curve' && algInfo.normalize !== false) {
      var p = parts[i];
      p.data = utils.mpNormalize(p.data);
    }
  }
  cert.subjectKey = new Key(key);
  cert.serial = sshbuf.readInt64();
  var type = TYPES[sshbuf.readInt()];
  assert.string(type, '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 (type === 'user') return Identity.forUser(pr);else if (type === 'host') return Identity.forHost(pr);
    throw new Error('Unknown identity type ' + type);
  });
  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;

  /* reserved */
  sshbuf.readBuffer();
  var signingKeyBuf = sshbuf.readBuffer();
  cert.issuerKey = rfc4253.read(signingKeyBuf);

  /*
   * OpenSSH certs don't give the identity of the issuer, just their
   * public key. So, we use an Identity that matches anything. The
   * isSignedBy() function will later tell you if the key matches.
   */
  cert.issuer = Identity.forHost('**');
  var sigBuf = sshbuf.readBuffer();
  cert.signatures.openssh.signature = Signature.parse(sigBuf, cert.issuerKey.type, 'ssh');
  if (partial !== undefined) {
    partial.remainder = sshbuf.remainder();
    partial.consumed = sshbuf._offset;
  }
  return new Certificate(cert);
}
function int64ToDate(buf) {
  var i = buf.readUInt32BE(0) * 4294967296;
  i += buf.readUInt32BE(4);
  var d = new Date();
  d.setTime(i * 1000);
  d.sourceInt64 = buf;
  return d;
}
function dateToInt64(date) {
  if (date.sourceInt64 !== undefined) return date.sourceInt64;
  var i = Math.round(date.getTime() / 1000);
  var upper = Math.floor(i / 4294967296);
  var lower = Math.floor(i % 4294967296);
  var buf = Buffer.alloc(8);
  buf.writeUInt32BE(upper, 0);
  buf.writeUInt32BE(lower, 4);
  return buf;
}
function sign(cert, key) {
  if (cert.signatures.openssh === undefined) cert.signatures.openssh = {};
  try {
    var blob = toBuffer(cert, true);
  } catch (e) {
    delete cert.signatures.openssh;
    return false;
  }
  var sig = cert.signatures.openssh;
  var hashAlgo = undefined;
  if (key.type === 'rsa' || key.type === 'dsa') hashAlgo = 'sha1';
  var signer = key.createSign(hashAlgo);
  signer.write(blob);
  sig.signature = signer.sign();
  return true;
}
function signAsync(cert, signer, done) {
  if (cert.signatures.openssh === undefined) cert.signatures.openssh = {};
  try {
    var blob = toBuffer(cert, true);
  } catch (e) {
    delete cert.signatures.openssh;
    done(e);
    return;
  }
  var sig = cert.signatures.openssh;
  signer(blob, function (err, signature) {
    if (err) {
      done(err);
      return;
    }
    try {
      /*
       * This will throw if the signature isn't of a
       * type/algo that can be used for SSH.
       */
      signature.toBuffer('ssh');
    } catch (e) {
      done(e);
      return;
    }
    sig.signature = signature;
    done();
  });
}
function write(cert, options) {
  if (options === undefined) 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 === undefined) sig.nonce = crypto.randomBytes(16);
  var buf = new SSHBuffer({});
  buf.writeString(getCertType(cert.subjectKey));
  buf.writeBuffer(sig.nonce);
  var key = cert.subjectKey;
  var algInfo = algs.info[key.type];
  algInfo.parts.forEach(function (part) {
    buf.writePart(key.part[part]);
  });
  buf.writeInt64(cert.serial);
  var type = cert.subjects[0].type;
  assert.notStrictEqual(type, 'unknown');
  cert.subjects.forEach(function (id) {
    assert.strictEqual(id.type, type);
  });
  type = TYPES[type];
  buf.writeInt(type);
  if (sig.keyId === undefined) {
    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 (type === TYPES.host) sub.writeString(id.hostname);else if (type === 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 === undefined) 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());

  /* reserved */
  buf.writeBuffer(Buffer.alloc(0));
  sub = rfc4253.write(cert.issuerKey);
  buf.writeBuffer(sub);
  if (!noSig) buf.writeBuffer(sig.signature.toBuffer('ssh'));
  return buf.toBuffer();
}
function getAlg(certType) {
  if (certType === 'ssh-rsa-cert-v01@openssh.com') return 'rsa';
  if (certType === 'ssh-dss-cert-v01@openssh.com') return 'dsa';
  if (certType.match(ECDSA_ALGO)) return 'ecdsa';
  if (certType === 'ssh-ed25519-cert-v01@openssh.com') return 'ed25519';
  throw new Error('Unsupported cert type ' + certType);
}
function getCertType(key) {
  if (key.type === 'rsa') return 'ssh-rsa-cert-v01@openssh.com';
  if (key.type === 'dsa') return 'ssh-dss-cert-v01@openssh.com';
  if (key.type === 'ecdsa') return 'ecdsa-sha2-' + key.curve + '-cert-v01@openssh.com';
  if (key.type === 'ed25519') return 'ssh-ed25519-cert-v01@openssh.com';
  throw new Error('Unsupported key type ' + key.type);
}

/***/ }),

/***/ 8620:
/*!***********************************************!*\
  !*** ./node_modules/sshpk/lib/formats/pem.js ***!
  \***********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// Copyright 2018 Joyent, Inc.

module.exports = {
  read: read,
  write: write
};
var assert = __webpack_require__(/*! assert-plus */ 1095);
var asn1 = __webpack_require__(/*! asn1 */ 5593);
var crypto = __webpack_require__(/*! crypto */ 6113);
var Buffer = (__webpack_require__(/*! safer-buffer */ 3745).Buffer);
var algs = __webpack_require__(/*! ../algs */ 1737);
var utils = __webpack_require__(/*! ../utils */ 6136);
var Key = __webpack_require__(/*! ../key */ 8996);
var PrivateKey = __webpack_require__(/*! ../private-key */ 8230);
var pkcs1 = __webpack_require__(/*! ./pkcs1 */ 8945);
var pkcs8 = __webpack_require__(/*! ./pkcs8 */ 6137);
var sshpriv = __webpack_require__(/*! ./ssh-private */ 266);
var rfc4253 = __webpack_require__(/*! ./rfc4253 */ 4709);
var errors = __webpack_require__(/*! ../errors */ 3758);
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'
};
var CIPHER_TO_OID = {};
Object.keys(OID_TO_CIPHER).forEach(function (k) {
  CIPHER_TO_OID[OID_TO_CIPHER[k]] = 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'
};
var HASH_TO_OID = {};
Object.keys(OID_TO_HASH).forEach(function (k) {
  HASH_TO_OID[OID_TO_HASH[k]] = k;
});

/*
 * For reading we support both PKCS#1 and PKCS#8. If we find a private key,
 * we just take the public component of it and use that.
 */
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');

  /* Begin and end banners must match key type */
  assert.equal(m[2], m2[2]);
  var type = m[2].toLowerCase();
  var alg;
  if (m[1]) {
    /* They also must match algorithms, if given */
    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];
  }

  /* Chop off the first and last lines */
  lines = lines.slice(0, -1).join('');
  buf = Buffer.from(lines, 'base64');
  var cipher, key, 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 = Buffer.from(options.passphrase, 'utf-8');
      }
      if (!Buffer.isBuffer(options.passphrase)) {
        throw new errors.KeyEncryptedError(options.filename, 'PEM');
      } else {
        parts = headers['dek-info'].split(',');
        assert.ok(parts.length === 2);
        cipher = parts[0].toLowerCase();
        iv = Buffer.from(parts[1], 'hex');
        key = utils.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(); /* PBES2-params */

    eder.readSequence(); /* keyDerivationFunc */
    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 === undefined) {
        throw new Error('Unsupported PBKDF2 hash: ' + hashAlgOid);
      }
    }
    eder._offset = kdfEnd;
    eder.readSequence(); /* encryptionScheme */
    var cipherOid = eder.readOID();
    cipher = OID_TO_CIPHER[cipherOid];
    if (cipher === undefined) {
      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 = Buffer.from(options.passphrase, 'utf-8');
    }
    if (!Buffer.isBuffer(options.passphrase)) {
      throw new errors.KeyEncryptedError(options.filename, 'PEM');
    }
    var cinfo = utils.opensshCipherInfo(cipher);
    cipher = cinfo.opensslName;
    key = utils.pbkdf2(hashAlg, salt, iterations, cinfo.keySize, options.passphrase);
    alg = undefined;
  }
  if (cipher && key && iv) {
    var cipherStream = crypto.createDecipheriv(cipher, key, 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 = Buffer.concat(chunks);
  }

  /* The new OpenSSH internal format abuses PEM headers */
  if (alg && alg.toLowerCase() === 'openssh') return sshpriv.readSSHPrivate(type, buf, options);
  if (alg && alg.toLowerCase() === 'ssh2') return rfc4253.readType(type, buf, options);
  var der = new asn1.BerReader(buf);
  der.originalInput = input;

  /*
   * All of the PEM file types start with a sequence tag, so chop it
   * off here
   */
  der.readSequence();

  /* PKCS#1 type keys name an algorithm in the banner explicitly */
  if (alg) {
    if (forceType) assert.strictEqual(forceType, 'pkcs1');
    return pkcs1.readPkcs1(alg, type, der);
  } else {
    if (forceType) assert.strictEqual(forceType, 'pkcs8');
    return pkcs8.readPkcs8(alg, type, der);
  }
}
function write(key, options, type) {
  assert.object(key);
  var alg = {
    'ecdsa': 'EC',
    'rsa': 'RSA',
    'dsa': 'DSA',
    'ed25519': 'EdDSA'
  }[key.type];
  var header;
  var der = new asn1.BerWriter();
  if (PrivateKey.isPrivateKey(key)) {
    if (type && type === 'pkcs8') {
      header = 'PRIVATE KEY';
      pkcs8.writePkcs8(der, key);
    } else {
      if (type) assert.strictEqual(type, 'pkcs1');
      header = alg + ' PRIVATE KEY';
      pkcs1.writePkcs1(der, key);
    }
  } else if (Key.isKey(key)) {
    if (type && type === 'pkcs1') {
      header = alg + ' PUBLIC KEY';
      pkcs1.writePkcs1(der, key);
    } else {
      if (type) assert.strictEqual(type, 'pkcs8');
      header = 'PUBLIC KEY';
      pkcs8.writePkcs8(der, key);
    }
  } 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 = Buffer.alloc(len);
  var o = 0;
  o += buf.write('-----BEGIN ' + header + '-----\n', o);
  for (var i = 0; i < tmp.length;) {
    var limit = i + 64;
    if (limit > tmp.length) limit = tmp.length;
    o += buf.write(tmp.slice(i, limit), o);
    buf[o++] = 10;
    i = limit;
  }
  o += buf.write('-----END ' + header + '-----\n', o);
  return buf.slice(0, o);
}

/***/ }),

/***/ 8945:
/*!*************************************************!*\
  !*** ./node_modules/sshpk/lib/formats/pkcs1.js ***!
  \*************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// Copyright 2015 Joyent, Inc.

module.exports = {
  read: read,
  readPkcs1: readPkcs1,
  write: write,
  writePkcs1: writePkcs1
};
var assert = __webpack_require__(/*! assert-plus */ 1095);
var asn1 = __webpack_require__(/*! asn1 */ 5593);
var Buffer = (__webpack_require__(/*! safer-buffer */ 3745).Buffer);
var algs = __webpack_require__(/*! ../algs */ 1737);
var utils = __webpack_require__(/*! ../utils */ 6136);
var Key = __webpack_require__(/*! ../key */ 8996);
var PrivateKey = __webpack_require__(/*! ../private-key */ 8230);
var pem = __webpack_require__(/*! ./pem */ 8620);
var pkcs8 = __webpack_require__(/*! ./pkcs8 */ 6137);
var readECDSACurve = pkcs8.readECDSACurve;
function read(buf, options) {
  return pem.read(buf, options, 'pkcs1');
}
function write(key, options) {
  return pem.write(key, options, 'pkcs1');
}

/* Helper to read in a single mpint */
function readMPInt(der, nm) {
  assert.strictEqual(der.peek(), asn1.Ber.Integer, nm + ' is not an Integer');
  return utils.mpNormalize(der.readString(asn1.Ber.Integer, true));
}
function readPkcs1(alg, type, der) {
  switch (alg) {
    case 'RSA':
      if (type === 'public') return readPkcs1RSAPublic(der);else if (type === 'private') return readPkcs1RSAPrivate(der);
      throw new Error('Unknown key type: ' + type);
    case 'DSA':
      if (type === 'public') return readPkcs1DSAPublic(der);else if (type === 'private') return readPkcs1DSAPrivate(der);
      throw new Error('Unknown key type: ' + type);
    case 'EC':
    case 'ECDSA':
      if (type === 'private') return readPkcs1ECDSAPrivate(der);else if (type === 'public') return readPkcs1ECDSAPublic(der);
      throw new Error('Unknown key type: ' + type);
    case 'EDDSA':
    case 'EdDSA':
      if (type === 'private') return readPkcs1EdDSAPrivate(der);
      throw new Error(type + ' keys not supported with EdDSA');
    default:
      throw new Error('Unknown key algo: ' + alg);
  }
}
function readPkcs1RSAPublic(der) {
  // modulus and exponent
  var n = readMPInt(der, 'modulus');
  var e = readMPInt(der, 'exponent');

  // now, make the key
  var key = {
    type: 'rsa',
    parts: [{
      name: 'e',
      data: e
    }, {
      name: 'n',
      data: n
    }]
  };
  return new Key(key);
}
function readPkcs1RSAPrivate(der) {
  var version = readMPInt(der, 'version');
  assert.strictEqual(version[0], 0);

  // modulus then public exponent
  var n = readMPInt(der, 'modulus');
  var e = readMPInt(der, 'public exponent');
  var d = readMPInt(der, 'private exponent');
  var p = readMPInt(der, 'prime1');
  var q = readMPInt(der, 'prime2');
  var dmodp = readMPInt(der, 'exponent1');
  var dmodq = readMPInt(der, 'exponent2');
  var iqmp = readMPInt(der, 'iqmp');

  // now, make the key
  var key = {
    type: 'rsa',
    parts: [{
      name: 'n',
      data: n
    }, {
      name: 'e',
      data: e
    }, {
      name: 'd',
      data: d
    }, {
      name: 'iqmp',
      data: iqmp
    }, {
      name: 'p',
      data: p
    }, {
      name: 'q',
      data: q
    }, {
      name: 'dmodp',
      data: dmodp
    }, {
      name: 'dmodq',
      data: dmodq
    }]
  };
  return new PrivateKey(key);
}
function readPkcs1DSAPrivate(der) {
  var version = readMPInt(der, 'version');
  assert.strictEqual(version.readUInt8(0), 0);
  var p = readMPInt(der, 'p');
  var q = readMPInt(der, 'q');
  var g = readMPInt(der, 'g');
  var y = readMPInt(der, 'y');
  var x = readMPInt(der, 'x');

  // now, make the key
  var key = {
    type: 'dsa',
    parts: [{
      name: 'p',
      data: p
    }, {
      name: 'q',
      data: q
    }, {
      name: 'g',
      data: g
    }, {
      name: 'y',
      data: y
    }, {
      name: 'x',
      data: x
    }]
  };
  return new PrivateKey(key);
}
function readPkcs1EdDSAPrivate(der) {
  var version = readMPInt(der, 'version');
  assert.strictEqual(version.readUInt8(0), 1);

  // private key
  var k = der.readString(asn1.Ber.OctetString, true);
  der.readSequence(0xa0);
  var oid = der.readOID();
  assert.strictEqual(oid, '1.3.101.112', 'the ed25519 curve identifier');
  der.readSequence(0xa1);
  var A = utils.readBitString(der);
  var key = {
    type: 'ed25519',
    parts: [{
      name: 'A',
      data: utils.zeroPadToLength(A, 32)
    }, {
      name: 'k',
      data: k
    }]
  };
  return new PrivateKey(key);
}
function readPkcs1DSAPublic(der) {
  var y = readMPInt(der, 'y');
  var p = readMPInt(der, 'p');
  var q = readMPInt(der, 'q');
  var g = readMPInt(der, 'g');
  var key = {
    type: 'dsa',
    parts: [{
      name: 'y',
      data: y
    }, {
      name: 'p',
      data: p
    }, {
      name: 'q',
      data: q
    }, {
      name: 'g',
      data: g
    }]
  };
  return new Key(key);
}
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(algs.curves);
  for (var j = 0; j < curves.length; ++j) {
    var c = curves[j];
    var cd = algs.curves[c];
    if (cd.pkcs8oid === curveOid) {
      curve = c;
      break;
    }
  }
  assert.string(curve, 'a known ECDSA named curve');
  var Q = der.readString(asn1.Ber.BitString, true);
  Q = utils.ecNormalize(Q);
  var key = {
    type: 'ecdsa',
    parts: [{
      name: 'curve',
      data: Buffer.from(curve)
    }, {
      name: 'Q',
      data: Q
    }]
  };
  return new Key(key);
}
function readPkcs1ECDSAPrivate(der) {
  var version = readMPInt(der, 'version');
  assert.strictEqual(version.readUInt8(0), 1);

  // private key
  var d = der.readString(asn1.Ber.OctetString, true);
  der.readSequence(0xa0);
  var curve = readECDSACurve(der);
  assert.string(curve, 'a known elliptic curve');
  der.readSequence(0xa1);
  var Q = der.readString(asn1.Ber.BitString, true);
  Q = utils.ecNormalize(Q);
  var key = {
    type: 'ecdsa',
    parts: [{
      name: 'curve',
      data: Buffer.from(curve)
    }, {
      name: 'Q',
      data: Q
    }, {
      name: 'd',
      data: d
    }]
  };
  return new PrivateKey(key);
}
function writePkcs1(der, key) {
  der.startSequence();
  switch (key.type) {
    case 'rsa':
      if (PrivateKey.isPrivateKey(key)) writePkcs1RSAPrivate(der, key);else writePkcs1RSAPublic(der, key);
      break;
    case 'dsa':
      if (PrivateKey.isPrivateKey(key)) writePkcs1DSAPrivate(der, key);else writePkcs1DSAPublic(der, key);
      break;
    case 'ecdsa':
      if (PrivateKey.isPrivateKey(key)) writePkcs1ECDSAPrivate(der, key);else writePkcs1ECDSAPublic(der, key);
      break;
    case 'ed25519':
      if (PrivateKey.isPrivateKey(key)) writePkcs1EdDSAPrivate(der, key);else writePkcs1EdDSAPublic(der, key);
      break;
    default:
      throw new Error('Unknown key algo: ' + key.type);
  }
  der.endSequence();
}
function writePkcs1RSAPublic(der, key) {
  der.writeBuffer(key.part.n.data, asn1.Ber.Integer);
  der.writeBuffer(key.part.e.data, asn1.Ber.Integer);
}
function writePkcs1RSAPrivate(der, key) {
  var ver = Buffer.from([0]);
  der.writeBuffer(ver, asn1.Ber.Integer);
  der.writeBuffer(key.part.n.data, asn1.Ber.Integer);
  der.writeBuffer(key.part.e.data, asn1.Ber.Integer);
  der.writeBuffer(key.part.d.data, asn1.Ber.Integer);
  der.writeBuffer(key.part.p.data, asn1.Ber.Integer);
  der.writeBuffer(key.part.q.data, asn1.Ber.Integer);
  if (!key.part.dmodp || !key.part.dmodq) utils.addRSAMissing(key);
  der.writeBuffer(key.part.dmodp.data, asn1.Ber.Integer);
  der.writeBuffer(key.part.dmodq.data, asn1.Ber.Integer);
  der.writeBuffer(key.part.iqmp.data, asn1.Ber.Integer);
}
function writePkcs1DSAPrivate(der, key) {
  var ver = Buffer.from([0]);
  der.writeBuffer(ver, asn1.Ber.Integer);
  der.writeBuffer(key.part.p.data, asn1.Ber.Integer);
  der.writeBuffer(key.part.q.data, asn1.Ber.Integer);
  der.writeBuffer(key.part.g.data, asn1.Ber.Integer);
  der.writeBuffer(key.part.y.data, asn1.Ber.Integer);
  der.writeBuffer(key.part.x.data, asn1.Ber.Integer);
}
function writePkcs1DSAPublic(der, key) {
  der.writeBuffer(key.part.y.data, asn1.Ber.Integer);
  der.writeBuffer(key.part.p.data, asn1.Ber.Integer);
  der.writeBuffer(key.part.q.data, asn1.Ber.Integer);
  der.writeBuffer(key.part.g.data, asn1.Ber.Integer);
}
function writePkcs1ECDSAPublic(der, key) {
  der.startSequence();
  der.writeOID('1.2.840.10045.2.1'); /* ecPublicKey */
  var curve = key.part.curve.data.toString();
  var curveOid = algs.curves[curve].pkcs8oid;
  assert.string(curveOid, 'a known ECDSA named curve');
  der.writeOID(curveOid);
  der.endSequence();
  var Q = utils.ecNormalize(key.part.Q.data, true);
  der.writeBuffer(Q, asn1.Ber.BitString);
}
function writePkcs1ECDSAPrivate(der, key) {
  var ver = Buffer.from([1]);
  der.writeBuffer(ver, asn1.Ber.Integer);
  der.writeBuffer(key.part.d.data, asn1.Ber.OctetString);
  der.startSequence(0xa0);
  var curve = key.part.curve.data.toString();
  var curveOid = algs.curves[curve].pkcs8oid;
  assert.string(curveOid, 'a known ECDSA named curve');
  der.writeOID(curveOid);
  der.endSequence();
  der.startSequence(0xa1);
  var Q = utils.ecNormalize(key.part.Q.data, true);
  der.writeBuffer(Q, asn1.Ber.BitString);
  der.endSequence();
}
function writePkcs1EdDSAPrivate(der, key) {
  var ver = Buffer.from([1]);
  der.writeBuffer(ver, asn1.Ber.Integer);
  der.writeBuffer(key.part.k.data, asn1.Ber.OctetString);
  der.startSequence(0xa0);
  der.writeOID('1.3.101.112');
  der.endSequence();
  der.startSequence(0xa1);
  utils.writeBitString(der, key.part.A.data);
  der.endSequence();
}
function writePkcs1EdDSAPublic(der, key) {
  throw new Error('Public keys are not supported for EdDSA PKCS#1');
}

/***/ }),

/***/ 6137:
/*!*************************************************!*\
  !*** ./node_modules/sshpk/lib/formats/pkcs8.js ***!
  \*************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// Copyright 2018 Joyent, Inc.

module.exports = {
  read: read,
  readPkcs8: readPkcs8,
  write: write,
  writePkcs8: writePkcs8,
  pkcs8ToBuffer: pkcs8ToBuffer,
  readECDSACurve: readECDSACurve,
  writeECDSACurve: writeECDSACurve
};
var assert = __webpack_require__(/*! assert-plus */ 1095);
var asn1 = __webpack_require__(/*! asn1 */ 5593);
var Buffer = (__webpack_require__(/*! safer-buffer */ 3745).Buffer);
var algs = __webpack_require__(/*! ../algs */ 1737);
var utils = __webpack_require__(/*! ../utils */ 6136);
var Key = __webpack_require__(/*! ../key */ 8996);
var PrivateKey = __webpack_require__(/*! ../private-key */ 8230);
var pem = __webpack_require__(/*! ./pem */ 8620);
function read(buf, options) {
  return pem.read(buf, options, 'pkcs8');
}
function write(key, options) {
  return pem.write(key, options, 'pkcs8');
}

/* Helper to read in a single mpint */
function readMPInt(der, nm) {
  assert.strictEqual(der.peek(), asn1.Ber.Integer, nm + ' is not an Integer');
  return utils.mpNormalize(der.readString(asn1.Ber.Integer, true));
}
function readPkcs8(alg, type, der) {
  /* Private keys in pkcs#8 format have a weird extra int */
  if (der.peek() === asn1.Ber.Integer) {
    assert.strictEqual(type, '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 (type === 'public') return readPkcs8RSAPublic(der);else return readPkcs8RSAPrivate(der);
    case '1.2.840.10040.4.1':
      if (type === 'public') return readPkcs8DSAPublic(der);else return readPkcs8DSAPrivate(der);
    case '1.2.840.10045.2.1':
      if (type === 'public') return readPkcs8ECDSAPublic(der);else return readPkcs8ECDSAPrivate(der);
    case '1.3.101.112':
      if (type === 'public') {
        return readPkcs8EdDSAPublic(der);
      } else {
        return readPkcs8EdDSAPrivate(der);
      }
    case '1.3.101.110':
      if (type === 'public') {
        return readPkcs8X25519Public(der);
      } else {
        return readPkcs8X25519Private(der);
      }
    default:
      throw new Error('Unknown key type OID ' + oid);
  }
}
function readPkcs8RSAPublic(der) {
  // bit string sequence
  der.readSequence(asn1.Ber.BitString);
  der.readByte();
  der.readSequence();

  // modulus
  var n = readMPInt(der, 'modulus');
  var e = readMPInt(der, 'exponent');

  // now, make the key
  var key = {
    type: 'rsa',
    source: der.originalInput,
    parts: [{
      name: 'e',
      data: e
    }, {
      name: 'n',
      data: n
    }]
  };
  return new Key(key);
}
function readPkcs8RSAPrivate(der) {
  der.readSequence(asn1.Ber.OctetString);
  der.readSequence();
  var ver = readMPInt(der, 'version');
  assert.equal(ver[0], 0x0, 'unknown RSA private key version');

  // modulus then public exponent
  var n = readMPInt(der, 'modulus');
  var e = readMPInt(der, 'public exponent');
  var d = readMPInt(der, 'private exponent');
  var p = readMPInt(der, 'prime1');
  var q = readMPInt(der, 'prime2');
  var dmodp = readMPInt(der, 'exponent1');
  var dmodq = readMPInt(der, 'exponent2');
  var iqmp = readMPInt(der, 'iqmp');

  // now, make the key
  var key = {
    type: 'rsa',
    parts: [{
      name: 'n',
      data: n
    }, {
      name: 'e',
      data: e
    }, {
      name: 'd',
      data: d
    }, {
      name: 'iqmp',
      data: iqmp
    }, {
      name: 'p',
      data: p
    }, {
      name: 'q',
      data: q
    }, {
      name: 'dmodp',
      data: dmodp
    }, {
      name: 'dmodq',
      data: dmodq
    }]
  };
  return new PrivateKey(key);
}
function readPkcs8DSAPublic(der) {
  der.readSequence();
  var p = readMPInt(der, 'p');
  var q = readMPInt(der, 'q');
  var g = readMPInt(der, 'g');

  // bit string sequence
  der.readSequence(asn1.Ber.BitString);
  der.readByte();
  var y = readMPInt(der, 'y');

  // now, make the key
  var key = {
    type: 'dsa',
    parts: [{
      name: 'p',
      data: p
    }, {
      name: 'q',
      data: q
    }, {
      name: 'g',
      data: g
    }, {
      name: 'y',
      data: y
    }]
  };
  return new Key(key);
}
function readPkcs8DSAPrivate(der) {
  der.readSequence();
  var p = readMPInt(der, 'p');
  var q = readMPInt(der, 'q');
  var g = readMPInt(der, 'g');
  der.readSequence(asn1.Ber.OctetString);
  var x = readMPInt(der, 'x');

  /* The pkcs#8 format does not include the public key */
  var y = utils.calculateDSAPublic(g, p, x);
  var key = {
    type: 'dsa',
    parts: [{
      name: 'p',
      data: p
    }, {
      name: 'q',
      data: q
    }, {
      name: 'g',
      data: g
    }, {
      name: 'y',
      data: y
    }, {
      name: 'x',
      data: x
    }]
  };
  return new PrivateKey(key);
}
function readECDSACurve(der) {
  var curveName, curveNames;
  var j, c, cd;
  if (der.peek() === asn1.Ber.OID) {
    var oid = der.readOID();
    curveNames = Object.keys(algs.curves);
    for (j = 0; j < curveNames.length; ++j) {
      c = curveNames[j];
      cd = algs.curves[c];
      if (cd.pkcs8oid === oid) {
        curveName = c;
        break;
      }
    }
  } else {
    // ECParameters sequence
    der.readSequence();
    var version = der.readString(asn1.Ber.Integer, true);
    assert.strictEqual(version[0], 1, 'ECDSA key not version 1');
    var curve = {};

    // FieldID sequence
    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 = utils.mpNormalize(der.readString(asn1.Ber.Integer, true));
    /*
     * p always starts with a 1 bit, so count the zeros to get its
     * real size.
     */
    curve.size = p.length * 8 - utils.countZeros(p);

    // Curve sequence
    der.readSequence();
    curve.a = utils.mpNormalize(der.readString(asn1.Ber.OctetString, true));
    curve.b = utils.mpNormalize(der.readString(asn1.Ber.OctetString, true));
    if (der.peek() === asn1.Ber.BitString) curve.s = der.readString(asn1.Ber.BitString, true);

    // Combined Gx and Gy
    curve.G = der.readString(asn1.Ber.OctetString, true);
    assert.strictEqual(curve.G[0], 0x4, 'uncompressed G is required');
    curve.n = utils.mpNormalize(der.readString(asn1.Ber.Integer, true));
    curve.h = utils.mpNormalize(der.readString(asn1.Ber.Integer, true));
    assert.strictEqual(curve.h[0], 0x1, 'a cofactor=1 curve is ' + 'required');
    curveNames = Object.keys(algs.curves);
    var ks = Object.keys(curve);
    for (j = 0; j < curveNames.length; ++j) {
      c = curveNames[j];
      cd = algs.curves[c];
      var equal = true;
      for (var i = 0; i < ks.length; ++i) {
        var k = ks[i];
        if (cd[k] === undefined) continue;
        if (typeof cd[k] === 'object' && cd[k].equals !== undefined) {
          if (!cd[k].equals(curve[k])) {
            equal = false;
            break;
          }
        } else if (Buffer.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 = c;
        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 version = readMPInt(der, 'version');
  assert.equal(version[0], 1, 'unknown version of ECDSA key');
  var d = der.readString(asn1.Ber.OctetString, true);
  var Q;
  if (der.peek() == 0xa0) {
    der.readSequence(0xa0);
    der._offset += der.length;
  }
  if (der.peek() == 0xa1) {
    der.readSequence(0xa1);
    Q = der.readString(asn1.Ber.BitString, true);
    Q = utils.ecNormalize(Q);
  }
  if (Q === undefined) {
    var pub = utils.publicFromPrivateECDSA(curveName, d);
    Q = pub.part.Q.data;
  }
  var key = {
    type: 'ecdsa',
    parts: [{
      name: 'curve',
      data: Buffer.from(curveName)
    }, {
      name: 'Q',
      data: Q
    }, {
      name: 'd',
      data: d
    }]
  };
  return new PrivateKey(key);
}
function readPkcs8ECDSAPublic(der) {
  var curveName = readECDSACurve(der);
  assert.string(curveName, 'a known elliptic curve');
  var Q = der.readString(asn1.Ber.BitString, true);
  Q = utils.ecNormalize(Q);
  var key = {
    type: 'ecdsa',
    parts: [{
      name: 'curve',
      data: Buffer.from(curveName)
    }, {
      name: 'Q',
      data: Q
    }]
  };
  return new Key(key);
}
function readPkcs8EdDSAPublic(der) {
  if (der.peek() === 0x00) der.readByte();
  var A = utils.readBitString(der);
  var key = {
    type: 'ed25519',
    parts: [{
      name: 'A',
      data: utils.zeroPadToLength(A, 32)
    }]
  };
  return new Key(key);
}
function readPkcs8X25519Public(der) {
  var A = utils.readBitString(der);
  var key = {
    type: 'curve25519',
    parts: [{
      name: 'A',
      data: utils.zeroPadToLength(A, 32)
    }]
  };
  return new Key(key);
}
function readPkcs8EdDSAPrivate(der) {
  if (der.peek() === 0x00) der.readByte();
  der.readSequence(asn1.Ber.OctetString);
  var k = der.readString(asn1.Ber.OctetString, true);
  k = utils.zeroPadToLength(k, 32);
  var A, tag;
  while ((tag = der.peek()) !== null) {
    if (tag === (asn1.Ber.Context | 1)) {
      A = utils.readBitString(der, tag);
    } else {
      der.readSequence(tag);
      der._offset += der.length;
    }
  }
  if (A === undefined) A = utils.calculateED25519Public(k);
  var key = {
    type: 'ed25519',
    parts: [{
      name: 'A',
      data: utils.zeroPadToLength(A, 32)
    }, {
      name: 'k',
      data: utils.zeroPadToLength(k, 32)
    }]
  };
  return new PrivateKey(key);
}
function readPkcs8X25519Private(der) {
  if (der.peek() === 0x00) der.readByte();
  der.readSequence(asn1.Ber.OctetString);
  var k = der.readString(asn1.Ber.OctetString, true);
  k = utils.zeroPadToLength(k, 32);
  var A = utils.calculateX25519Public(k);
  var key = {
    type: 'curve25519',
    parts: [{
      name: 'A',
      data: utils.zeroPadToLength(A, 32)
    }, {
      name: 'k',
      data: utils.zeroPadToLength(k, 32)
    }]
  };
  return new PrivateKey(key);
}
function pkcs8ToBuffer(key) {
  var der = new asn1.BerWriter();
  writePkcs8(der, key);
  return der.buffer;
}
function writePkcs8(der, key) {
  der.startSequence();
  if (PrivateKey.isPrivateKey(key)) {
    var version = 0;
    if (key.type === 'ed25519') version = 1;
    var vbuf = Buffer.from([version]);
    der.writeBuffer(vbuf, asn1.Ber.Integer);
  }
  der.startSequence();
  switch (key.type) {
    case 'rsa':
      der.writeOID('1.2.840.113549.1.1.1');
      if (PrivateKey.isPrivateKey(key)) writePkcs8RSAPrivate(key, der);else writePkcs8RSAPublic(key, der);
      break;
    case 'dsa':
      der.writeOID('1.2.840.10040.4.1');
      if (PrivateKey.isPrivateKey(key)) writePkcs8DSAPrivate(key, der);else writePkcs8DSAPublic(key, der);
      break;
    case 'ecdsa':
      der.writeOID('1.2.840.10045.2.1');
      if (PrivateKey.isPrivateKey(key)) writePkcs8ECDSAPrivate(key, der);else writePkcs8ECDSAPublic(key, der);
      break;
    case 'ed25519':
      der.writeOID('1.3.101.112');
      if (PrivateKey.isPrivateKey(key)) writePkcs8EdDSAPrivate(key, der);else writePkcs8EdDSAPublic(key, der);
      break;
    default:
      throw new Error('Unsupported key type: ' + key.type);
  }
  der.endSequence();
}
function writePkcs8RSAPrivate(key, der) {
  der.writeNull();
  der.endSequence();
  der.startSequence(asn1.Ber.OctetString);
  der.startSequence();
  var version = Buffer.from([0]);
  der.writeBuffer(version, asn1.Ber.Integer);
  der.writeBuffer(key.part.n.data, asn1.Ber.Integer);
  der.writeBuffer(key.part.e.data, asn1.Ber.Integer);
  der.writeBuffer(key.part.d.data, asn1.Ber.Integer);
  der.writeBuffer(key.part.p.data, asn1.Ber.Integer);
  der.writeBuffer(key.part.q.data, asn1.Ber.Integer);
  if (!key.part.dmodp || !key.part.dmodq) utils.addRSAMissing(key);
  der.writeBuffer(key.part.dmodp.data, asn1.Ber.Integer);
  der.writeBuffer(key.part.dmodq.data, asn1.Ber.Integer);
  der.writeBuffer(key.part.iqmp.data, asn1.Ber.Integer);
  der.endSequence();
  der.endSequence();
}
function writePkcs8RSAPublic(key, der) {
  der.writeNull();
  der.endSequence();
  der.startSequence(asn1.Ber.BitString);
  der.writeByte(0x00);
  der.startSequence();
  der.writeBuffer(key.part.n.data, asn1.Ber.Integer);
  der.writeBuffer(key.part.e.data, asn1.Ber.Integer);
  der.endSequence();
  der.endSequence();
}
function writePkcs8DSAPrivate(key, der) {
  der.startSequence();
  der.writeBuffer(key.part.p.data, asn1.Ber.Integer);
  der.writeBuffer(key.part.q.data, asn1.Ber.Integer);
  der.writeBuffer(key.part.g.data, asn1.Ber.Integer);
  der.endSequence();
  der.endSequence();
  der.startSequence(asn1.Ber.OctetString);
  der.writeBuffer(key.part.x.data, asn1.Ber.Integer);
  der.endSequence();
}
function writePkcs8DSAPublic(key, der) {
  der.startSequence();
  der.writeBuffer(key.part.p.data, asn1.Ber.Integer);
  der.writeBuffer(key.part.q.data, asn1.Ber.Integer);
  der.writeBuffer(key.part.g.data, asn1.Ber.Integer);
  der.endSequence();
  der.endSequence();
  der.startSequence(asn1.Ber.BitString);
  der.writeByte(0x00);
  der.writeBuffer(key.part.y.data, asn1.Ber.Integer);
  der.endSequence();
}
function writeECDSACurve(key, der) {
  var curve = algs.curves[key.curve];
  if (curve.pkcs8oid) {
    /* This one has a name in pkcs#8, so just write the oid */
    der.writeOID(curve.pkcs8oid);
  } else {
    // ECParameters sequence
    der.startSequence();
    var version = Buffer.from([1]);
    der.writeBuffer(version, asn1.Ber.Integer);

    // FieldID sequence
    der.startSequence();
    der.writeOID('1.2.840.10045.1.1'); // prime-field
    der.writeBuffer(curve.p, asn1.Ber.Integer);
    der.endSequence();

    // Curve sequence
    der.startSequence();
    var a = curve.p;
    if (a[0] === 0x0) a = a.slice(1);
    der.writeBuffer(a, 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 = Buffer.from([1]);
    }
    der.writeBuffer(h, asn1.Ber.Integer);

    // ECParameters
    der.endSequence();
  }
}
function writePkcs8ECDSAPublic(key, der) {
  writeECDSACurve(key, der);
  der.endSequence();
  var Q = utils.ecNormalize(key.part.Q.data, true);
  der.writeBuffer(Q, asn1.Ber.BitString);
}
function writePkcs8ECDSAPrivate(key, der) {
  writeECDSACurve(key, der);
  der.endSequence();
  der.startSequence(asn1.Ber.OctetString);
  der.startSequence();
  var version = Buffer.from([1]);
  der.writeBuffer(version, asn1.Ber.Integer);
  der.writeBuffer(key.part.d.data, asn1.Ber.OctetString);
  der.startSequence(0xa1);
  var Q = utils.ecNormalize(key.part.Q.data, true);
  der.writeBuffer(Q, asn1.Ber.BitString);
  der.endSequence();
  der.endSequence();
  der.endSequence();
}
function writePkcs8EdDSAPublic(key, der) {
  der.endSequence();
  utils.writeBitString(der, key.part.A.data);
}
function writePkcs8EdDSAPrivate(key, der) {
  der.endSequence();
  der.startSequence(asn1.Ber.OctetString);
  var k = utils.mpNormalize(key.part.k.data);
  /* RFCs call for storing exactly 32 bytes, so strip any leading zeros */
  while (k.length > 32 && k[0] == 0x00) k = k.slice(1);
  der.writeBuffer(k, asn1.Ber.OctetString);
  der.endSequence();
  utils.writeBitString(der, key.part.A.data, asn1.Ber.Context | 1);
}

/***/ }),

/***/ 1657:
/*!*************************************************!*\
  !*** ./node_modules/sshpk/lib/formats/putty.js ***!
  \*************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// Copyright 2018 Joyent, Inc.

module.exports = {
  read: read,
  write: write
};
var assert = __webpack_require__(/*! assert-plus */ 1095);
var Buffer = (__webpack_require__(/*! safer-buffer */ 3745).Buffer);
var rfc4253 = __webpack_require__(/*! ./rfc4253 */ 4709);
var Key = __webpack_require__(/*! ../key */ 8996);
var SSHBuffer = __webpack_require__(/*! ../ssh-buffer */ 6838);
var crypto = __webpack_require__(/*! crypto */ 6113);
var PrivateKey = __webpack_require__(/*! ../private-key */ 8230);
var errors = __webpack_require__(/*! ../errors */ 3758);

// https://tartarus.org/~simon/putty-prerel-snapshots/htmldoc/AppendixC.html
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 comment = 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 = Buffer.from(lines.slice(si, si + publicLines).join(''), 'base64');
  var keyType = rfc4253.algToKeyType(alg);
  var key = rfc4253.read(publicBuf);
  if (key.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 = Buffer.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 errors.KeyEncryptedError(options.filename, 'PEM');
      }
      var iv = Buffer.alloc(16, 0);
      var decipher = crypto.createDecipheriv('aes-256-cbc', derivePPK2EncryptionKey(options.passphrase), iv);
      decipher.setAutoPadding(false);
      privateBuf = Buffer.concat([decipher.update(privateBuf), decipher.final()]);
    }
    key = new PrivateKey(key);
    if (key.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);
    }
    key = new PrivateKey({
      type: key.type,
      parts: key.parts.concat(privateKeyParts)
    });
  }
  key.comment = comment;
  return key;
}
function derivePPK2EncryptionKey(passphrase) {
  var hash1 = crypto.createHash('sha1').update(Buffer.concat([Buffer.from([0, 0, 0, 0]), Buffer.from(passphrase)])).digest();
  var hash2 = crypto.createHash('sha1').update(Buffer.concat([Buffer.from([0, 0, 0, 1]), Buffer.from(passphrase)])).digest();
  return Buffer.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(key, options) {
  assert.object(key);
  if (!Key.isKey(key)) throw new Error('Must be a public key');
  var alg = rfc4253.keyTypeToAlg(key);
  var buf = rfc4253.write(key);
  var comment = key.comment || '';
  var b64 = buf.toString('base64');
  var lines = wrap(b64, 64);
  lines.unshift('Public-Lines: ' + lines.length);
  lines.unshift('Comment: ' + comment);
  lines.unshift('Encryption: none');
  lines.unshift('PuTTY-User-Key-File-2: ' + alg);
  return Buffer.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;
}

/***/ }),

/***/ 4709:
/*!***************************************************!*\
  !*** ./node_modules/sshpk/lib/formats/rfc4253.js ***!
  \***************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// Copyright 2015 Joyent, Inc.

module.exports = {
  read: read.bind(undefined, false, undefined),
  readType: read.bind(undefined, false),
  write: write,
  /* semi-private api, used by sshpk-agent */
  readPartial: read.bind(undefined, true),
  /* shared with ssh format */
  readInternal: read,
  keyTypeToAlg: keyTypeToAlg,
  algToKeyType: algToKeyType
};
var assert = __webpack_require__(/*! assert-plus */ 1095);
var Buffer = (__webpack_require__(/*! safer-buffer */ 3745).Buffer);
var algs = __webpack_require__(/*! ../algs */ 1737);
var utils = __webpack_require__(/*! ../utils */ 6136);
var Key = __webpack_require__(/*! ../key */ 8996);
var PrivateKey = __webpack_require__(/*! ../private-key */ 8230);
var SSHBuffer = __webpack_require__(/*! ../ssh-buffer */ 6838);
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(key) {
  assert.object(key);
  if (key.type === 'dsa') return 'ssh-dss';else if (key.type === 'rsa') return 'ssh-rsa';else if (key.type === 'ed25519') return 'ssh-ed25519';else if (key.type === 'curve25519') return 'ssh-curve25519';else if (key.type === 'ecdsa') return 'ecdsa-sha2-' + key.part.curve.data.toString();else throw new Error('Unknown key type ' + key.type);
}
function read(partial, type, buf, options) {
  if (typeof buf === 'string') buf = Buffer.from(buf);
  assert.buffer(buf, 'buf');
  var key = {};
  var parts = key.parts = [];
  var sshbuf = new SSHBuffer({
    buffer: buf
  });
  var alg = sshbuf.readString();
  assert.ok(!sshbuf.atEnd(), 'key must have at least one part');
  key.type = algToKeyType(alg);
  var partCount = algs.info[key.type].parts.length;
  if (type && type === 'private') partCount = algs.privInfo[key.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 = algs.info[key.type];
  if (type === 'private' || algInfo.parts.length !== parts.length) {
    algInfo = algs.privInfo[key.type];
    Constructor = PrivateKey;
  }
  assert.strictEqual(algInfo.parts.length, parts.length);
  if (key.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 i = 0; i < algInfo.parts.length; ++i) {
    var p = parts[i];
    p.name = algInfo.parts[i];
    /*
     * OpenSSH stores ed25519 "private" keys as seed + public key
     * concat'd together (k followed by A). We want to keep them
     * separate for other formats that don't do this.
     */
    if (key.type === 'ed25519' && p.name === 'k') p.data = p.data.slice(0, 32);
    if (p.name !== 'curve' && algInfo.normalize !== false) {
      var nd;
      if (key.type === 'ed25519') {
        nd = utils.zeroPadToLength(p.data, 32);
      } else {
        nd = utils.mpNormalize(p.data);
      }
      if (nd.toString('binary') !== p.data.toString('binary')) {
        p.data = nd;
        normalized = false;
      }
    }
  }
  if (normalized) key._rfc4253Cache = sshbuf.toBuffer();
  if (partial && typeof partial === 'object') {
    partial.remainder = sshbuf.remainder();
    partial.consumed = sshbuf._offset;
  }
  return new Constructor(key);
}
function write(key, options) {
  assert.object(key);
  var alg = keyTypeToAlg(key);
  var i;
  var algInfo = algs.info[key.type];
  if (PrivateKey.isPrivateKey(key)) algInfo = algs.privInfo[key.type];
  var parts = algInfo.parts;
  var buf = new SSHBuffer({});
  buf.writeString(alg);
  for (i = 0; i < parts.length; ++i) {
    var data = key.part[parts[i]].data;
    if (algInfo.normalize !== false) {
      if (key.type === 'ed25519') data = utils.zeroPadToLength(data, 32);else data = utils.mpNormalize(data);
    }
    if (key.type === 'ed25519' && parts[i] === 'k') data = Buffer.concat([data, key.part.A.data]);
    buf.writeBuffer(data);
  }
  return buf.toBuffer();
}

/***/ }),

/***/ 266:
/*!*******************************************************!*\
  !*** ./node_modules/sshpk/lib/formats/ssh-private.js ***!
  \*******************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// Copyright 2015 Joyent, Inc.

module.exports = {
  read: read,
  readSSHPrivate: readSSHPrivate,
  write: write
};
var assert = __webpack_require__(/*! assert-plus */ 1095);
var asn1 = __webpack_require__(/*! asn1 */ 5593);
var Buffer = (__webpack_require__(/*! safer-buffer */ 3745).Buffer);
var algs = __webpack_require__(/*! ../algs */ 1737);
var utils = __webpack_require__(/*! ../utils */ 6136);
var crypto = __webpack_require__(/*! crypto */ 6113);
var Key = __webpack_require__(/*! ../key */ 8996);
var PrivateKey = __webpack_require__(/*! ../private-key */ 8230);
var pem = __webpack_require__(/*! ./pem */ 8620);
var rfc4253 = __webpack_require__(/*! ./rfc4253 */ 4709);
var SSHBuffer = __webpack_require__(/*! ../ssh-buffer */ 6838);
var errors = __webpack_require__(/*! ../errors */ 3758);
var bcrypt;
function read(buf, options) {
  return pem.read(buf, options);
}
var MAGIC = 'openssh-key-v1';
function readSSHPrivate(type, 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 (type === 'public') {
    assert.ok(buf.atEnd(), 'excess bytes left after key');
    return rfc4253.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 = utils.opensshCipherInfo(cipher);
      if (bcrypt === undefined) {
        bcrypt = __webpack_require__(/*! bcrypt-pbkdf */ 5116);
      }
      if (typeof options.passphrase === 'string') {
        options.passphrase = Buffer.from(options.passphrase, 'utf-8');
      }
      if (!Buffer.isBuffer(options.passphrase)) {
        throw new errors.KeyEncryptedError(options.filename, 'OpenSSH');
      }
      var pass = new Uint8Array(options.passphrase);
      var salti = new Uint8Array(salt);
      /* Use the pbkdf to derive both the key and the IV. */
      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 = Buffer.from(out);
      var ckey = out.slice(0, cinf.keySize);
      var iv = out.slice(cinf.keySize, cinf.keySize + cinf.blockSize);
      var cipherStream = crypto.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 = Buffer.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 key = rfc4253.readInternal(ret, 'private', buf.remainder());
  buf.skip(ret.consumed);
  var comment = buf.readString();
  key.comment = comment;
  return key;
}
function write(key, options) {
  var pubKey;
  if (PrivateKey.isPrivateKey(key)) pubKey = key.toPublic();else pubKey = key;
  var cipher = 'none';
  var kdf = 'none';
  var kdfopts = Buffer.alloc(0);
  var cinf = {
    blockSize: 8
  };
  var passphrase;
  if (options !== undefined) {
    passphrase = options.passphrase;
    if (typeof passphrase === 'string') passphrase = Buffer.from(passphrase, 'utf-8');
    if (passphrase !== undefined) {
      assert.buffer(passphrase, 'options.passphrase');
      assert.optionalString(options.cipher, 'options.cipher');
      cipher = options.cipher;
      if (cipher === undefined) cipher = 'aes128-ctr';
      cinf = utils.opensshCipherInfo(cipher);
      kdf = 'bcrypt';
    }
  }
  var privBuf;
  if (PrivateKey.isPrivateKey(key)) {
    privBuf = new SSHBuffer({});
    var checkInt = crypto.randomBytes(4).readUInt32BE(0);
    privBuf.writeInt(checkInt);
    privBuf.writeInt(checkInt);
    privBuf.write(key.toBuffer('rfc4253'));
    privBuf.writeString(key.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 = crypto.randomBytes(16);
      var rounds = 16;
      var kdfssh = new SSHBuffer({});
      kdfssh.writeBuffer(salt);
      kdfssh.writeInt(rounds);
      kdfopts = kdfssh.toBuffer();
      if (bcrypt === undefined) {
        bcrypt = __webpack_require__(/*! bcrypt-pbkdf */ 5116);
      }
      var pass = new Uint8Array(passphrase);
      var salti = new Uint8Array(salt);
      /* Use the pbkdf to derive both the key and the IV. */
      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 = Buffer.from(out);
      var ckey = out.slice(0, cinf.keySize);
      var iv = out.slice(cinf.keySize, cinf.keySize + cinf.blockSize);
      var cipherStream = crypto.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 = Buffer.concat(chunks);
      break;
    default:
      throw new Error('Unsupported kdf ' + kdf);
  }
  var buf = new SSHBuffer({});
  buf.writeCString(MAGIC);
  buf.writeString(cipher); /* cipher */
  buf.writeString(kdf); /* kdf */
  buf.writeBuffer(kdfopts); /* kdfoptions */

  buf.writeInt(1); /* nkeys */
  buf.writeBuffer(pubKey.toBuffer('rfc4253'));
  if (privBuf) buf.writeBuffer(privBuf);
  buf = buf.toBuffer();
  var header;
  if (PrivateKey.isPrivateKey(key)) 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 = Buffer.alloc(len);
  var o = 0;
  o += buf.write('-----BEGIN ' + header + '-----\n', o);
  for (var i = 0; i < tmp.length;) {
    var limit = i + 70;
    if (limit > tmp.length) limit = tmp.length;
    o += buf.write(tmp.slice(i, limit), o);
    buf[o++] = 10;
    i = limit;
  }
  o += buf.write('-----END ' + header + '-----\n', o);
  return buf.slice(0, o);
}

/***/ }),

/***/ 2300:
/*!***********************************************!*\
  !*** ./node_modules/sshpk/lib/formats/ssh.js ***!
  \***********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// Copyright 2015 Joyent, Inc.

module.exports = {
  read: read,
  write: write
};
var assert = __webpack_require__(/*! assert-plus */ 1095);
var Buffer = (__webpack_require__(/*! safer-buffer */ 3745).Buffer);
var rfc4253 = __webpack_require__(/*! ./rfc4253 */ 4709);
var utils = __webpack_require__(/*! ../utils */ 6136);
var Key = __webpack_require__(/*! ../key */ 8996);
var PrivateKey = __webpack_require__(/*! ../private-key */ 8230);
var sshpriv = __webpack_require__(/*! ./ssh-private */ 266);

/*JSSTYLED*/
var SSHKEY_RE = /^([a-z0-9-]+)[ \t]+([a-zA-Z0-9+\/]+[=]*)([ \t]+([^ \t][^\n]*[\n]*)?)?$/;
/*JSSTYLED*/
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 type = rfc4253.algToKeyType(m[1]);
  var kbuf = Buffer.from(m[2], 'base64');

  /*
   * This is a bit tricky. If we managed to parse the key and locate the
   * key comment with the regex, then do a non-partial read and assert
   * that we have consumed all bytes. If we couldn't locate the key
   * comment, though, there may be whitespace shenanigans going on that
   * have conjoined the comment to the rest of the key. We do a partial
   * read in this case to try to make the best out of a sorry situation.
   */
  var key;
  var ret = {};
  if (m[4]) {
    try {
      key = rfc4253.read(kbuf);
    } catch (e) {
      m = trimmed.match(SSHKEY_RE2);
      assert.ok(m, 'key must match regex');
      kbuf = Buffer.from(m[2], 'base64');
      key = rfc4253.readInternal(ret, 'public', kbuf);
    }
  } else {
    key = rfc4253.readInternal(ret, 'public', kbuf);
  }
  assert.strictEqual(type, key.type);
  if (m[4] && m[4].length > 0) {
    key.comment = m[4];
  } else if (ret.consumed) {
    /*
     * Now the magic: trying to recover the key comment when it's
     * gotten conjoined to the key or otherwise shenanigan'd.
     *
     * Work out how much base64 we used, then drop all non-base64
     * chars from the beginning up to this point in the the string.
     * Then offset in this and try to make up for missing = chars.
     */
    var data = m[2] + (m[3] ? m[3] : '');
    var realOffset = Math.ceil(ret.consumed / 3) * 4;
    data = data.slice(0, realOffset - 2). /*JSSTYLED*/
    replace(/[^a-zA-Z0-9+\/=]/g, '') + data.slice(realOffset - 2);
    var padding = ret.consumed % 3;
    if (padding > 0 && data.slice(realOffset - 1, realOffset) !== '=') realOffset--;
    while (data.slice(realOffset, realOffset + 1) === '=') realOffset++;

    /* Finally, grab what we think is the comment & clean it up. */
    var trailer = data.slice(realOffset);
    trailer = trailer.replace(/[\r\n]/g, ' ').replace(/^\s+/, '');
    if (trailer.match(/^[a-zA-Z0-9]/)) key.comment = trailer;
  }
  return key;
}
function write(key, options) {
  assert.object(key);
  if (!Key.isKey(key)) throw new Error('Must be a public key');
  var parts = [];
  var alg = rfc4253.keyTypeToAlg(key);
  parts.push(alg);
  var buf = rfc4253.write(key);
  parts.push(buf.toString('base64'));
  if (key.comment) parts.push(key.comment);
  return Buffer.from(parts.join(' '));
}

/***/ }),

/***/ 401:
/*!****************************************************!*\
  !*** ./node_modules/sshpk/lib/formats/x509-pem.js ***!
  \****************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// Copyright 2016 Joyent, Inc.

var x509 = __webpack_require__(/*! ./x509 */ 942);
module.exports = {
  read: read,
  verify: x509.verify,
  sign: x509.sign,
  write: write
};
var assert = __webpack_require__(/*! assert-plus */ 1095);
var asn1 = __webpack_require__(/*! asn1 */ 5593);
var Buffer = (__webpack_require__(/*! safer-buffer */ 3745).Buffer);
var algs = __webpack_require__(/*! ../algs */ 1737);
var utils = __webpack_require__(/*! ../utils */ 6136);
var Key = __webpack_require__(/*! ../key */ 8996);
var PrivateKey = __webpack_require__(/*! ../private-key */ 8230);
var pem = __webpack_require__(/*! ./pem */ 8620);
var Identity = __webpack_require__(/*! ../identity */ 7424);
var Signature = __webpack_require__(/*! ../signature */ 5206);
var Certificate = __webpack_require__(/*! ../certificate */ 8092);
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];
  }

  /* Chop off the first and last lines */
  lines = lines.slice(0, -1).join('');
  buf = Buffer.from(lines, 'base64');
  return x509.read(buf, options);
}
function write(cert, options) {
  var dbuf = x509.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 = Buffer.alloc(len);
  var o = 0;
  o += buf.write('-----BEGIN ' + header + '-----\n', o);
  for (var i = 0; i < tmp.length;) {
    var limit = i + 64;
    if (limit > tmp.length) limit = tmp.length;
    o += buf.write(tmp.slice(i, limit), o);
    buf[o++] = 10;
    i = limit;
  }
  o += buf.write('-----END ' + header + '-----\n', o);
  return buf.slice(0, o);
}

/***/ }),

/***/ 942:
/*!************************************************!*\
  !*** ./node_modules/sshpk/lib/formats/x509.js ***!
  \************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// Copyright 2017 Joyent, Inc.

module.exports = {
  read: read,
  verify: verify,
  sign: sign,
  signAsync: signAsync,
  write: write
};
var assert = __webpack_require__(/*! assert-plus */ 1095);
var asn1 = __webpack_require__(/*! asn1 */ 5593);
var Buffer = (__webpack_require__(/*! safer-buffer */ 3745).Buffer);
var algs = __webpack_require__(/*! ../algs */ 1737);
var utils = __webpack_require__(/*! ../utils */ 6136);
var Key = __webpack_require__(/*! ../key */ 8996);
var PrivateKey = __webpack_require__(/*! ../private-key */ 8230);
var pem = __webpack_require__(/*! ./pem */ 8620);
var Identity = __webpack_require__(/*! ../identity */ 7424);
var Signature = __webpack_require__(/*! ../signature */ 5206);
var Certificate = __webpack_require__(/*! ../certificate */ 8092);
var pkcs8 = __webpack_require__(/*! ./pkcs8 */ 6137);

/*
 * This file is based on RFC5280 (X.509).
 */

/* Helper to read in a single mpint */
function readMPInt(der, nm) {
  assert.strictEqual(der.peek(), asn1.Ber.Integer, nm + ' is not an Integer');
  return utils.mpNormalize(der.readString(asn1.Ber.Integer, true));
}
function verify(cert, key) {
  var sig = cert.signatures.x509;
  assert.object(sig, 'x509 signature');
  var algParts = sig.algo.split('-');
  if (algParts[0] !== key.type) return false;
  var blob = sig.cache;
  if (blob === undefined) {
    var der = new asn1.BerWriter();
    writeTBSCert(cert, der);
    blob = der.buffer;
  }
  var verifier = key.createVerify(algParts[1]);
  verifier.write(blob);
  return verifier.verify(sig.signature);
}
function Local(i) {
  return asn1.Ber.Context | asn1.Ber.Constructor | i;
}
function Context(i) {
  return asn1.Ber.Context | i;
}
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 = Buffer.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 version = der.readInt();
    assert.ok(version <= 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 === undefined) 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 = pkcs8.readPkcs8(undefined, 'public', der);
  der._offset = after;

  /* issuerUniqueID */
  if (der.peek() === Local(1)) {
    der.readSequence(Local(1));
    sig.extras.issuerUniqueID = buf.slice(der.offset, der.offset + der.length);
    der._offset += der.length;
  }

  /* subjectUniqueID */
  if (der.peek() === Local(2)) {
    der.readSequence(Local(2));
    sig.extras.subjectUniqueID = buf.slice(der.offset, der.offset + der.length);
    der._offset += der.length;
  }

  /* extensions */
  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 === undefined) 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);
  }
}

/* RFC5280, section 4.2.1.6 (GeneralName type) */
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)
};

/* RFC5280, section 4.2.1.12 (KeyPurposeId) */
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 === undefined) cert.purposes = [];
      if (ca === true) cert.purposes.push('ca');
      var bc = {
        oid: extId,
        critical: 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 === undefined) cert.purposes = [];
      var ekEnd = der.offset + der.length;
      while (der.offset < ekEnd) {
        var oid = der.readOID();
        cert.purposes.push(EXTPURPOSE_REV[oid] || oid);
      }
      /*
       * This is a bit of a hack: in the case where we have a cert
       * that's only allowed to do serverAuth or clientAuth (and not
       * the other), we want to make sure all our Subjects are of
       * the right type. But we already parsed our Subjects and
       * decided if they were hosts or users earlier (since it appears
       * first in the cert).
       *
       * So we go through and mutate them into the right kind here if
       * it doesn't match. This might not be hugely beneficial, as it
       * seems that single-purpose certs are not often seen in the
       * wild.
       */
      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: 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 === undefined) cert.purposes = [];
        if (cert.purposes.indexOf(bit) === -1) cert.purposes.push(bit);
      });
      sig.extras.exts.push({
        oid: extId,
        critical: critical,
        bits: 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:
            /* RFC822 specifies email addresses */
            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: critical
      });
      break;
    default:
      sig.extras.exts.push({
        oid: extId,
        critical: 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 d = new Date();
  var thisYear = d.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;
  d.setUTCFullYear(year, parseInt(m[2], 10) - 1, parseInt(m[3], 10));
  d.setUTCHours(parseInt(m[4], 10), parseInt(m[5], 10));
  if (m[6] && m[6].length > 0) d.setUTCSeconds(parseInt(m[6], 10));
  return d;
}
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 d = new Date();
  d.setUTCFullYear(parseInt(m[1], 10), parseInt(m[2], 10) - 1, parseInt(m[3], 10));
  d.setUTCHours(parseInt(m[4], 10), parseInt(m[5], 10));
  if (m[6] && m[6].length > 0) d.setUTCSeconds(parseInt(m[6], 10));
  return d;
}
function zeroPad(n, m) {
  if (m === undefined) m = 2;
  var s = '' + n;
  while (s.length < m) s = '0' + s;
  return s;
}
function dateToUTCTime(d) {
  var s = '';
  s += zeroPad(d.getUTCFullYear() % 100);
  s += zeroPad(d.getUTCMonth() + 1);
  s += zeroPad(d.getUTCDate());
  s += zeroPad(d.getUTCHours());
  s += zeroPad(d.getUTCMinutes());
  s += zeroPad(d.getUTCSeconds());
  s += 'Z';
  return s;
}
function dateToGTime(d) {
  var s = '';
  s += zeroPad(d.getUTCFullYear(), 4);
  s += zeroPad(d.getUTCMonth() + 1);
  s += zeroPad(d.getUTCDate());
  s += zeroPad(d.getUTCHours());
  s += zeroPad(d.getUTCMinutes());
  s += zeroPad(d.getUTCSeconds());
  s += 'Z';
  return s;
}
function sign(cert, key) {
  if (cert.signatures.x509 === undefined) cert.signatures.x509 = {};
  var sig = cert.signatures.x509;
  sig.algo = key.type + '-' + key.defaultHashAlgorithm();
  if (SIGN_ALGS[sig.algo] === undefined) return false;
  var der = new asn1.BerWriter();
  writeTBSCert(cert, der);
  var blob = der.buffer;
  sig.cache = blob;
  var signer = key.createSign();
  signer.write(blob);
  cert.signatures.x509.signature = signer.sign();
  return true;
}
function signAsync(cert, signer, done) {
  if (cert.signatures.x509 === undefined) cert.signatures.x509 = {};
  var sig = cert.signatures.x509;
  var der = new asn1.BerWriter();
  writeTBSCert(cert, der);
  var blob = der.buffer;
  sig.cache = blob;
  signer(blob, function (err, signature) {
    if (err) {
      done(err);
      return;
    }
    sig.algo = signature.type + '-' + signature.hashAlgorithm;
    if (SIGN_ALGS[sig.algo] === undefined) {
      done(new Error('Invalid signing algorithm "' + sig.algo + '"'));
      return;
    }
    sig.signature = signature;
    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 data = Buffer.alloc(sigData.length + 1);
  data[0] = 0;
  sigData.copy(data, 1);
  der.writeBuffer(data, 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(utils.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);
  pkcs8.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 !== undefined && cert.purposes.length > 0 || sig.extras && sig.extras.exts) {
    der.startSequence(Local(3));
    der.startSequence();
    var exts = [];
    if (cert.purposes !== undefined && 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 i = 0; i < exts.length; ++i) {
      der.startSequence();
      der.writeOID(exts[i].oid);
      if (exts[i].critical !== undefined) der.writeBoolean(exts[i].critical);
      if (exts[i].oid === EXTS.altName) {
        der.startSequence(asn1.Ber.OctetString);
        der.startSequence();
        if (subject.type === 'host') {
          der.writeString(subject.hostname, Context(2));
        }
        for (var j = 0; j < altNames.length; ++j) {
          if (altNames[j].type === 'host') {
            der.writeString(altNames[j].hostname, ALTNAME.DNSName);
          } else if (altNames[j].type === 'email') {
            der.writeString(altNames[j].email, ALTNAME.RFC822Name);
          } else {
            /*
             * Encode anything else as a
             * DN style name for now.
             */
            der.startSequence(ALTNAME.DirectoryName);
            altNames[j].toAsn1(der);
            der.endSequence();
          }
        }
        der.endSequence();
        der.endSequence();
      } else if (exts[i].oid === EXTS.basicConstraints) {
        der.startSequence(asn1.Ber.OctetString);
        der.startSequence();
        var ca = cert.purposes.indexOf('ca') !== -1;
        var pathLen = exts[i].pathLen;
        der.writeBoolean(ca);
        if (pathLen !== undefined) der.writeInt(pathLen);
        der.endSequence();
        der.endSequence();
      } else if (exts[i].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] !== undefined) oid = EXTPURPOSE[purpose];
          der.writeOID(oid);
        });
        der.endSequence();
        der.endSequence();
      } else if (exts[i].oid === EXTS.keyUsage) {
        der.startSequence(asn1.Ber.OctetString);
        /*
         * If we parsed this certificate from a byte
         * stream (i.e. we didn't generate it in sshpk)
         * then we'll have a ".bits" property on the
         * ext with the original raw byte contents.
         *
         * If we have this, use it here instead of
         * regenerating it. This guarantees we output
         * the same data we parsed, so signatures still
         * validate.
         */
        if (exts[i].bits !== undefined) {
          der.writeBuffer(exts[i].bits, asn1.Ber.BitString);
        } else {
          var bits = writeBitField(cert.purposes, KEYUSEBITS);
          der.writeBuffer(bits, asn1.Ber.BitString);
        }
        der.endSequence();
      } else {
        der.writeBuffer(exts[i].data, asn1.Ber.OctetString);
      }
      der.endSequence();
    }
    der.endSequence();
    der.endSequence();
  }
  der.endSequence();
}

/*
 * Reads an ASN.1 BER bitfield out of the Buffer produced by doing
 * `BerReader#readString(asn1.Ber.BitString)`. That function gives us the raw
 * contents of the BitString tag, which is a count of unused bits followed by
 * the bits as a right-padded byte string.
 *
 * `bits` is the Buffer, `bitIndex` should contain an array of string names
 * for the bits in the string, ordered starting with bit #0 in the ASN.1 spec.
 *
 * Returns an array of Strings, the names of the bits that were set to 1.
 */
function readBitField(bits, bitIndex) {
  var bitLen = 8 * (bits.length - 1) - bits[0];
  var setBits = {};
  for (var i = 0; i < bitLen; ++i) {
    var byteN = 1 + Math.floor(i / 8);
    var bit = 7 - i % 8;
    var mask = 1 << bit;
    var bitVal = (bits[byteN] & mask) !== 0;
    var name = bitIndex[i];
    if (bitVal && typeof name === 'string') {
      setBits[name] = true;
    }
  }
  return Object.keys(setBits);
}

/*
 * `setBits` is an array of strings, containing the names for each bit that
 * sould be set to 1. `bitIndex` is same as in `readBitField()`.
 *
 * Returns a Buffer, ready to be written out with `BerWriter#writeString()`.
 */
function writeBitField(setBits, bitIndex) {
  var bitLen = bitIndex.length;
  var blen = Math.ceil(bitLen / 8);
  var unused = blen * 8 - bitLen;
  var bits = Buffer.alloc(1 + blen); // zero-filled
  bits[0] = unused;
  for (var i = 0; i < bitLen; ++i) {
    var byteN = 1 + Math.floor(i / 8);
    var bit = 7 - i % 8;
    var mask = 1 << bit;
    var name = bitIndex[i];
    if (name === undefined) continue;
    var bitVal = setBits.indexOf(name) !== -1;
    if (bitVal) {
      bits[byteN] |= mask;
    }
  }
  return bits;
}

/***/ }),

/***/ 7424:
/*!********************************************!*\
  !*** ./node_modules/sshpk/lib/identity.js ***!
  \********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// Copyright 2017 Joyent, Inc.

module.exports = Identity;
var assert = __webpack_require__(/*! assert-plus */ 1095);
var algs = __webpack_require__(/*! ./algs */ 1737);
var crypto = __webpack_require__(/*! crypto */ 6113);
var Fingerprint = __webpack_require__(/*! ./fingerprint */ 7339);
var Signature = __webpack_require__(/*! ./signature */ 5206);
var errs = __webpack_require__(/*! ./errors */ 3758);
var util = __webpack_require__(/*! util */ 3837);
var utils = __webpack_require__(/*! ./utils */ 6136);
var asn1 = __webpack_require__(/*! asn1 */ 5593);
var Buffer = (__webpack_require__(/*! safer-buffer */ 3745).Buffer);

/*JSSTYLED*/
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 self = this;
  assert.object(opts, 'options');
  assert.arrayOfObject(opts.components, 'options.components');
  this.components = opts.components;
  this.componentLookup = {};
  this.components.forEach(function (c) {
    if (c.name && !c.oid) c.oid = oids[c.name];
    if (c.oid && !c.name) c.name = unoids[c.oid];
    if (self.componentLookup[c.name] === undefined) self.componentLookup[c.name] = [];
    self.componentLookup[c.name].push(c);
  });
  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 === undefined) {
    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 (c) {
        return c.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 (c) {
    var n = c.name.toUpperCase();
    /*JSSTYLED*/
    n = n.replace(/=/g, '\\=');
    var v = c.value;
    /*JSSTYLED*/
    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 === undefined || arr.length === 0) return undefined;
  if (!asArray && arr.length > 1) throw new Error('Multiple values for attribute ' + name);
  if (!asArray) return arr[0].value;
  return arr.map(function (c) {
    return c.value;
  });
};
Identity.prototype.toArray = function (idx) {
  return this.components.map(function (c) {
    return {
      name: c.name,
      value: c.value
    };
  });
};

/*
 * These are from X.680 -- PrintableString allowed chars are in section 37.4
 * table 8. Spec for IA5Strings is "1,6 + SPACE + DEL" where 1 refers to
 * ISO IR #001 (standard ASCII control characters) and 6 refers to ISO IR #006
 * (the basic ASCII character set).
 */
/* JSSTYLED */
var NOT_PRINTABLE = /[^a-zA-Z0-9 '(),+.\/:=?-]/;
/* JSSTYLED */
var NOT_IA5 = /[^\x00-\x7f]/;
Identity.prototype.toAsn1 = function (der, tag) {
  der.startSequence(tag);
  this.components.forEach(function (c) {
    der.startSequence(asn1.Ber.Constructor | asn1.Ber.Set);
    der.startSequence();
    der.writeOID(c.oid);
    /*
     * If we fit in a PrintableString, use that. Otherwise use an
     * IA5String or UTF8String.
     *
     * If this identity was parsed from a DN, use the ASN.1 types
     * from the original representation (otherwise this might not
     * be a full match for the original in some validators).
     */
    if (c.asn1type === asn1.Ber.Utf8String || c.value.match(NOT_IA5)) {
      var v = Buffer.from(c.value, 'utf8');
      der.writeBuffer(v, asn1.Ber.Utf8String);
    } else if (c.asn1type === asn1.Ber.IA5String || c.value.match(NOT_PRINTABLE)) {
      der.writeString(c.value, asn1.Ber.IA5String);
    } else {
      var type = asn1.Ber.PrintableString;
      if (c.asn1type !== undefined) type = c.asn1type;
      der.writeString(c.value, type);
    }
    der.endSequence();
    der.endSequence();
  });
  der.endSequence();
};
function globMatch(a, b) {
  if (a === '**' || b === '**') return true;
  var aParts = a.split('.');
  var bParts = b.split('.');
  if (aParts.length !== bParts.length) return false;
  for (var i = 0; i < aParts.length; ++i) {
    if (aParts[i] === '*' || bParts[i] === '*') continue;
    if (aParts[i] !== bParts[i]) 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 i = 0; i < this.components.length; ++i) {
    if (this.components[i].oid !== other.components[i].oid) return false;
    if (!globMatch(this.components[i].value, other.components[i].value)) {
      return false;
    }
  }
  return true;
};
Identity.forHost = function (hostname) {
  assert.string(hostname, 'hostname');
  return new Identity({
    type: 'host',
    hostname: hostname,
    components: [{
      name: 'cn',
      value: hostname
    }]
  });
};
Identity.forUser = function (uid) {
  assert.string(uid, 'uid');
  return new Identity({
    type: 'user',
    uid: uid,
    components: [{
      name: 'uid',
      value: uid
    }]
  });
};
Identity.forEmail = function (email) {
  assert.string(email, 'email');
  return new Identity({
    type: 'email',
    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;
    /*JSSTYLED*/
    if ((m = /^,/.exec(rem)) !== null) {
      parts[++idx] = '';
      rem = rem.slice(m[0].length);
      /*JSSTYLED*/
    } else if ((m = /^\\,/.exec(rem)) !== null) {
      parts[idx] += ',';
      rem = rem.slice(m[0].length);
      /*JSSTYLED*/
    } else if ((m = /^\\./.exec(rem)) !== null) {
      parts[idx] += m[0];
      rem = rem.slice(m[0].length);
      /*JSSTYLED*/
    } 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 (c) {
    c = c.trim();
    var eqPos = c.indexOf('=');
    while (eqPos > 0 && c.charAt(eqPos - 1) === '\\') eqPos = c.indexOf('=', eqPos + 1);
    if (eqPos === -1) {
      throw new Error('Failed to parse DN');
    }
    /*JSSTYLED*/
    var name = c.slice(0, eqPos).toLowerCase().replace(/\\=/g, '=');
    var value = c.slice(eqPos + 1);
    return {
      name: name,
      value: 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 (!Buffer.isBuffer(cmp.value) && !(typeof cmp.value === 'string')) {
      throw new Error('Invalid component value');
    }
  });
  return new Identity({
    components: 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 type = der.peek();
    var value;
    switch (type) {
      case asn1.Ber.PrintableString:
      case asn1.Ber.IA5String:
      case asn1.Ber.OctetString:
      case asn1.Ber.T61String:
        value = der.readString(type);
        break;
      case asn1.Ber.Utf8String:
        value = der.readString(type, true);
        value = value.toString('utf8');
        break;
      case asn1.Ber.CharacterString:
      case asn1.Ber.BMPString:
        value = der.readString(type, true);
        value = value.toString('utf16le');
        break;
      default:
        throw new Error('Unknown asn1 type ' + type);
    }
    components.push({
      oid: oid,
      asn1type: type,
      value: value
    });
    der._offset = after;
  }
  der._offset = end;
  return new Identity({
    components: components
  });
};
Identity.isIdentity = function (obj, ver) {
  return utils.isCompatible(obj, Identity, ver);
};

/*
 * API versions for Identity:
 * [1,0] -- initial ver
 */
Identity.prototype._sshpkApiVersion = [1, 0];
Identity._oldVersionDetect = function (obj) {
  return [1, 0];
};

/***/ }),

/***/ 4513:
/*!*****************************************!*\
  !*** ./node_modules/sshpk/lib/index.js ***!
  \*****************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// Copyright 2015 Joyent, Inc.

var Key = __webpack_require__(/*! ./key */ 8996);
var Fingerprint = __webpack_require__(/*! ./fingerprint */ 7339);
var Signature = __webpack_require__(/*! ./signature */ 5206);
var PrivateKey = __webpack_require__(/*! ./private-key */ 8230);
var Certificate = __webpack_require__(/*! ./certificate */ 8092);
var Identity = __webpack_require__(/*! ./identity */ 7424);
var errs = __webpack_require__(/*! ./errors */ 3758);
module.exports = {
  /* top-level classes */
  Key: Key,
  parseKey: Key.parse,
  Fingerprint: Fingerprint,
  parseFingerprint: Fingerprint.parse,
  Signature: Signature,
  parseSignature: Signature.parse,
  PrivateKey: PrivateKey,
  parsePrivateKey: PrivateKey.parse,
  generatePrivateKey: PrivateKey.generate,
  Certificate: Certificate,
  parseCertificate: Certificate.parse,
  createSelfSignedCertificate: Certificate.createSelfSigned,
  createCertificate: Certificate.create,
  Identity: 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
};

/***/ }),

/***/ 8996:
/*!***************************************!*\
  !*** ./node_modules/sshpk/lib/key.js ***!
  \***************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// Copyright 2018 Joyent, Inc.

module.exports = Key;
var assert = __webpack_require__(/*! assert-plus */ 1095);
var algs = __webpack_require__(/*! ./algs */ 1737);
var crypto = __webpack_require__(/*! crypto */ 6113);
var Fingerprint = __webpack_require__(/*! ./fingerprint */ 7339);
var Signature = __webpack_require__(/*! ./signature */ 5206);
var DiffieHellman = (__webpack_require__(/*! ./dhe */ 3979).DiffieHellman);
var errs = __webpack_require__(/*! ./errors */ 3758);
var utils = __webpack_require__(/*! ./utils */ 6136);
var PrivateKey = __webpack_require__(/*! ./private-key */ 8230);
var edCompat;
try {
  edCompat = __webpack_require__(/*! ./ed-compat */ 1443);
} catch (e) {
  /* Just continue through, and bail out if we try to use it. */
}
var InvalidAlgorithmError = errs.InvalidAlgorithmError;
var KeyParseError = errs.KeyParseError;
var formats = {};
formats['auto'] = __webpack_require__(/*! ./formats/auto */ 2687);
formats['pem'] = __webpack_require__(/*! ./formats/pem */ 8620);
formats['pkcs1'] = __webpack_require__(/*! ./formats/pkcs1 */ 8945);
formats['pkcs8'] = __webpack_require__(/*! ./formats/pkcs8 */ 6137);
formats['rfc4253'] = __webpack_require__(/*! ./formats/rfc4253 */ 4709);
formats['ssh'] = __webpack_require__(/*! ./formats/ssh */ 2300);
formats['ssh-private'] = __webpack_require__(/*! ./formats/ssh-private */ 266);
formats['openssh'] = formats['ssh-private'];
formats['dnssec'] = __webpack_require__(/*! ./formats/dnssec */ 160);
formats['putty'] = __webpack_require__(/*! ./formats/putty */ 1657);
formats['ppk'] = formats['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 = algs.info[opts.type];
  if (typeof algInfo !== 'object') throw new InvalidAlgorithmError(opts.type);
  var partLookup = {};
  for (var i = 0; i < opts.parts.length; ++i) {
    var part = opts.parts[i];
    partLookup[part.name] = part;
  }
  this.type = opts.type;
  this.parts = opts.parts;
  this.part = partLookup;
  this.comment = undefined;
  this.source = opts.source;

  /* for speeding up hashing/fingerprint operations */
  this._rfc4253Cache = opts._rfc4253Cache;
  this._hashCache = {};
  var sz;
  this.curve = undefined;
  if (this.type === 'ecdsa') {
    var curve = this.part.curve.data.toString();
    this.curve = curve;
    sz = algs.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 - utils.countZeros(szPart.data);
  }
  this.size = sz;
}
Key.formats = formats;
Key.prototype.toBuffer = function (format, options) {
  if (format === undefined) format = 'ssh';
  assert.string(format, 'format');
  assert.object(formats[format], 'formats[format]');
  assert.optionalObject(options, 'options');
  if (format === 'rfc4253') {
    if (this._rfc4253Cache === undefined) this._rfc4253Cache = formats['rfc4253'].write(this);
    return this._rfc4253Cache;
  }
  return formats[format].write(this, options);
};
Key.prototype.toString = function (format, options) {
  return this.toBuffer(format, options).toString();
};
Key.prototype.hash = function (algo, type) {
  assert.string(algo, 'algorithm');
  assert.optionalString(type, 'type');
  if (type === undefined) type = 'ssh';
  algo = algo.toLowerCase();
  if (algs.hashAlgs[algo] === undefined) throw new InvalidAlgorithmError(algo);
  var cacheKey = algo + '||' + type;
  if (this._hashCache[cacheKey]) return this._hashCache[cacheKey];
  var buf;
  if (type === 'ssh') {
    buf = this.toBuffer('rfc4253');
  } else if (type === 'spki') {
    buf = formats.pkcs8.pkcs8ToBuffer(this);
  } else {
    throw new Error('Hash type ' + type + ' not supported');
  }
  var hash = crypto.createHash(algo).update(buf).digest();
  this._hashCache[cacheKey] = hash;
  return hash;
};
Key.prototype.fingerprint = function (algo, type) {
  if (algo === undefined) algo = 'sha256';
  if (type === undefined) type = 'ssh';
  assert.string(algo, 'algorithm');
  assert.string(type, 'type');
  var opts = {
    type: 'key',
    hash: this.hash(algo, type),
    algorithm: algo,
    hashType: type
  };
  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 === undefined) hashAlgo = this.defaultHashAlgorithm();
  assert.string(hashAlgo, 'hash algorithm');

  /* ED25519 is not supported by OpenSSL, use a javascript impl. */
  if (this.type === 'ed25519' && edCompat !== undefined) return new edCompat.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 = crypto.createVerify(nm);
  } catch (e) {
    err = e;
  }
  if (v === undefined || err instanceof Error && err.message.match(/Unknown message digest/)) {
    nm = 'RSA-';
    nm += hashAlgo.toUpperCase();
    v = crypto.createVerify(nm);
  }
  assert.ok(v, 'failed to create verifier');
  var oldVerify = v.verify.bind(v);
  var key = this.toBuffer('pkcs8');
  var curve = this.curve;
  var self = this;
  v.verify = function (signature, fmt) {
    if (Signature.isSignature(signature, [2, 0])) {
      if (signature.type !== self.type) return false;
      if (signature.hashAlgorithm && signature.hashAlgorithm !== hashAlgo) return false;
      if (signature.curve && self.type === 'ecdsa' && signature.curve !== curve) return false;
      return oldVerify(key, signature.toBuffer('asn1'));
    } else if (typeof signature === 'string' || Buffer.isBuffer(signature)) {
      return oldVerify(key, signature, fmt);

      /*
       * Avoid doing this on valid arguments, walking the prototype
       * chain can be quite slow.
       */
    } else if (Signature.isSignature(signature, [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 (data, format, options) {
  if (typeof data !== 'string') assert.buffer(data, 'data');
  if (format === undefined) format = 'auto';
  assert.string(format, 'format');
  if (typeof options === 'string') options = {
    filename: options
  };
  assert.optionalObject(options, 'options');
  if (options === undefined) options = {};
  assert.optionalString(options.filename, 'options.filename');
  if (options.filename === undefined) options.filename = '(unnamed)';
  assert.object(formats[format], 'formats[format]');
  try {
    var k = formats[format].read(data, 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, format, e);
  }
};
Key.isKey = function (obj, ver) {
  return utils.isCompatible(obj, Key, ver);
};

/*
 * API versions for Key:
 * [1,0] -- initial ver, may take Signature for createVerify or may not
 * [1,1] -- added pkcs1, pkcs8 formats
 * [1,2] -- added auto, ssh-private, openssh formats
 * [1,3] -- added defaultHashAlgorithm
 * [1,4] -- added ed support, createDH
 * [1,5] -- first explicitly tagged version
 * [1,6] -- changed ed25519 part names
 * [1,7] -- spki hash types
 */
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];
};

/***/ }),

/***/ 8230:
/*!***********************************************!*\
  !*** ./node_modules/sshpk/lib/private-key.js ***!
  \***********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// Copyright 2017 Joyent, Inc.

module.exports = PrivateKey;
var assert = __webpack_require__(/*! assert-plus */ 1095);
var Buffer = (__webpack_require__(/*! safer-buffer */ 3745).Buffer);
var algs = __webpack_require__(/*! ./algs */ 1737);
var crypto = __webpack_require__(/*! crypto */ 6113);
var Fingerprint = __webpack_require__(/*! ./fingerprint */ 7339);
var Signature = __webpack_require__(/*! ./signature */ 5206);
var errs = __webpack_require__(/*! ./errors */ 3758);
var util = __webpack_require__(/*! util */ 3837);
var utils = __webpack_require__(/*! ./utils */ 6136);
var dhe = __webpack_require__(/*! ./dhe */ 3979);
var generateECDSA = dhe.generateECDSA;
var generateED25519 = dhe.generateED25519;
var edCompat = __webpack_require__(/*! ./ed-compat */ 1443);
var nacl = __webpack_require__(/*! tweetnacl */ 8227);
var Key = __webpack_require__(/*! ./key */ 8996);
var InvalidAlgorithmError = errs.InvalidAlgorithmError;
var KeyParseError = errs.KeyParseError;
var KeyEncryptedError = errs.KeyEncryptedError;
var formats = {};
formats['auto'] = __webpack_require__(/*! ./formats/auto */ 2687);
formats['pem'] = __webpack_require__(/*! ./formats/pem */ 8620);
formats['pkcs1'] = __webpack_require__(/*! ./formats/pkcs1 */ 8945);
formats['pkcs8'] = __webpack_require__(/*! ./formats/pkcs8 */ 6137);
formats['rfc4253'] = __webpack_require__(/*! ./formats/rfc4253 */ 4709);
formats['ssh-private'] = __webpack_require__(/*! ./formats/ssh-private */ 266);
formats['openssh'] = formats['ssh-private'];
formats['ssh'] = formats['ssh-private'];
formats['dnssec'] = __webpack_require__(/*! ./formats/dnssec */ 160);
formats['putty'] = __webpack_require__(/*! ./formats/putty */ 1657);
function PrivateKey(opts) {
  assert.object(opts, 'options');
  Key.call(this, opts);
  this._pubCache = undefined;
}
util.inherits(PrivateKey, Key);
PrivateKey.formats = formats;
PrivateKey.prototype.toBuffer = function (format, options) {
  if (format === undefined) format = 'pkcs1';
  assert.string(format, 'format');
  assert.object(formats[format], 'formats[format]');
  assert.optionalObject(options, 'options');
  return formats[format].write(this, options);
};
PrivateKey.prototype.hash = function (algo, type) {
  return this.toPublic().hash(algo, type);
};
PrivateKey.prototype.fingerprint = function (algo, type) {
  return this.toPublic().fingerprint(algo, type);
};
PrivateKey.prototype.toPublic = function () {
  if (this._pubCache) return this._pubCache;
  var algInfo = algs.info[this.type];
  var pubParts = [];
  for (var i = 0; i < algInfo.parts.length; ++i) {
    var p = algInfo.parts[i];
    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] === 0x00) priv = priv.slice(1);
    pair = nacl.box.keyPair.fromSecretKey(new Uint8Array(priv));
    pub = Buffer.from(pair.publicKey);
    return new PrivateKey({
      type: 'curve25519',
      parts: [{
        name: 'A',
        data: utils.mpNormalize(pub)
      }, {
        name: 'k',
        data: utils.mpNormalize(priv)
      }]
    });
  } else if (this.type === 'curve25519' && newType === 'ed25519') {
    priv = this.part.k.data;
    if (priv[0] === 0x00) priv = priv.slice(1);
    pair = nacl.sign.keyPair.fromSeed(new Uint8Array(priv));
    pub = Buffer.from(pair.publicKey);
    return new PrivateKey({
      type: 'ed25519',
      parts: [{
        name: 'A',
        data: utils.mpNormalize(pub)
      }, {
        name: 'k',
        data: utils.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 === undefined) hashAlgo = this.defaultHashAlgorithm();
  assert.string(hashAlgo, 'hash algorithm');

  /* ED25519 is not supported by OpenSSL, use a javascript impl. */
  if (this.type === 'ed25519' && edCompat !== undefined) return new edCompat.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 = crypto.createSign(nm);
  } catch (e) {
    err = e;
  }
  if (v === undefined || err instanceof Error && err.message.match(/Unknown message digest/)) {
    nm = 'RSA-';
    nm += hashAlgo.toUpperCase();
    v = crypto.createSign(nm);
  }
  assert.ok(v, 'failed to create verifier');
  var oldSign = v.sign.bind(v);
  var key = this.toBuffer('pkcs1');
  var type = this.type;
  var curve = this.curve;
  v.sign = function () {
    var sig = oldSign(key);
    if (typeof sig === 'string') sig = Buffer.from(sig, 'binary');
    sig = Signature.parse(sig, type, 'asn1');
    sig.hashAlgorithm = hashAlgo;
    sig.curve = curve;
    return sig;
  };
  return v;
};
PrivateKey.parse = function (data, format, options) {
  if (typeof data !== 'string') assert.buffer(data, 'data');
  if (format === undefined) format = 'auto';
  assert.string(format, 'format');
  if (typeof options === 'string') options = {
    filename: options
  };
  assert.optionalObject(options, 'options');
  if (options === undefined) options = {};
  assert.optionalString(options.filename, 'options.filename');
  if (options.filename === undefined) options.filename = '(unnamed)';
  assert.object(formats[format], 'formats[format]');
  try {
    var k = formats[format].read(data, 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, format, e);
  }
};
PrivateKey.isPrivateKey = function (obj, ver) {
  return utils.isCompatible(obj, PrivateKey, ver);
};
PrivateKey.generate = function (type, options) {
  if (options === undefined) options = {};
  assert.object(options, 'options');
  switch (type) {
    case 'ecdsa':
      if (options.curve === undefined) 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 "' + type + '"');
  }
};

/*
 * API versions for PrivateKey:
 * [1,0] -- initial ver
 * [1,1] -- added auto, pkcs[18], openssh/ssh-private formats
 * [1,2] -- added defaultHashAlgorithm
 * [1,3] -- added derive, ed, createDH
 * [1,4] -- first tagged version
 * [1,5] -- changed ed25519 part names and format
 * [1,6] -- type arguments for hash() and fingerprint()
 */
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];
};

/***/ }),

/***/ 5206:
/*!*********************************************!*\
  !*** ./node_modules/sshpk/lib/signature.js ***!
  \*********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// Copyright 2015 Joyent, Inc.

module.exports = Signature;
var assert = __webpack_require__(/*! assert-plus */ 1095);
var Buffer = (__webpack_require__(/*! safer-buffer */ 3745).Buffer);
var algs = __webpack_require__(/*! ./algs */ 1737);
var crypto = __webpack_require__(/*! crypto */ 6113);
var errs = __webpack_require__(/*! ./errors */ 3758);
var utils = __webpack_require__(/*! ./utils */ 6136);
var asn1 = __webpack_require__(/*! asn1 */ 5593);
var SSHBuffer = __webpack_require__(/*! ./ssh-buffer */ 6838);
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 i = 0; i < opts.parts.length; ++i) {
    var part = opts.parts[i];
    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 (format) {
  if (format === undefined) format = 'asn1';
  assert.string(format, '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 undefined:
          break;
        default:
          throw new Error('SSH signature ' + 'format does not support hash ' + 'algorithm ' + this.hashAlgorithm);
      }
      if (format === 'ssh') {
        buf = new SSHBuffer({});
        buf.writeString(stype);
        buf.writePart(this.part.sig);
        return buf.toBuffer();
      } else {
        return this.part.sig.data;
      }
      break;
    case 'ed25519':
      if (format === 'ssh') {
        buf = new SSHBuffer({});
        buf.writeString(stype);
        buf.writePart(this.part.sig);
        return buf.toBuffer();
      } else {
        return this.part.sig.data;
      }
      break;
    case 'dsa':
    case 'ecdsa':
      var r, s;
      if (format === 'asn1') {
        var der = new asn1.BerWriter();
        der.startSequence();
        r = utils.mpNormalize(this.part.r.data);
        s = utils.mpNormalize(this.part.s.data);
        der.writeBuffer(r, asn1.Ber.Integer);
        der.writeBuffer(s, asn1.Ber.Integer);
        der.endSequence();
        return der.buffer;
      } else if (format === 'ssh' && this.type === 'dsa') {
        buf = new SSHBuffer({});
        buf.writeString('ssh-dss');
        r = this.part.r.data;
        if (r.length > 20 && r[0] === 0x00) r = r.slice(1);
        s = this.part.s.data;
        if (s.length > 20 && s[0] === 0x00) 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(Buffer.concat([r, s]));
        return buf.toBuffer();
      } else if (format === 'ssh' && this.type === 'ecdsa') {
        var inner = new SSHBuffer({});
        r = this.part.r.data;
        inner.writeBuffer(r);
        inner.writePart(this.part.s);
        buf = new SSHBuffer({});
        /* XXX: find a more proper way to do this? */
        var curve;
        if (r[0] === 0x00) 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 (format) {
  assert.optionalString(format, 'format');
  return this.toBuffer(format).toString('base64');
};
Signature.parse = function (data, type, format) {
  if (typeof data === 'string') data = Buffer.from(data, 'base64');
  assert.buffer(data, 'data');
  assert.string(format, 'format');
  assert.string(type, 'type');
  var opts = {};
  opts.type = type.toLowerCase();
  opts.parts = [];
  try {
    assert.ok(data.length > 0, 'signature must not be empty');
    switch (opts.type) {
      case 'rsa':
        return parseOneNum(data, type, format, opts);
      case 'ed25519':
        return parseOneNum(data, type, format, opts);
      case 'dsa':
      case 'ecdsa':
        if (format === 'asn1') return parseDSAasn1(data, type, format, opts);else if (opts.type === 'dsa') return parseDSA(data, type, format, opts);else return parseECDSA(data, type, format, opts);
      default:
        throw new InvalidAlgorithmError(type);
    }
  } catch (e) {
    if (e instanceof InvalidAlgorithmError) throw e;
    throw new SignatureParseError(type, format, e);
  }
};
function parseOneNum(data, type, format, opts) {
  if (format === 'ssh') {
    try {
      var buf = new SSHBuffer({
        buffer: data
      });
      var head = buf.readString();
    } catch (e) {
      /* fall through */
    }
    if (buf !== undefined) {
      var msg = 'SSH signature does not match expected ' + 'type (expected ' + type + ', got ' + head + ')';
      switch (head) {
        case 'ssh-rsa':
          assert.strictEqual(type, 'rsa', msg);
          opts.hashAlgo = 'sha1';
          break;
        case 'rsa-sha2-256':
          assert.strictEqual(type, 'rsa', msg);
          opts.hashAlgo = 'sha256';
          break;
        case 'rsa-sha2-512':
          assert.strictEqual(type, 'rsa', msg);
          opts.hashAlgo = 'sha512';
          break;
        case 'ssh-ed25519':
          assert.strictEqual(type, '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: data
  });
  return new Signature(opts);
}
function parseDSAasn1(data, type, format, opts) {
  var der = new asn1.BerReader(data);
  der.readSequence();
  var r = der.readString(asn1.Ber.Integer, true);
  var s = der.readString(asn1.Ber.Integer, true);
  opts.parts.push({
    name: 'r',
    data: utils.mpNormalize(r)
  });
  opts.parts.push({
    name: 's',
    data: utils.mpNormalize(s)
  });
  return new Signature(opts);
}
function parseDSA(data, type, format, opts) {
  if (data.length != 40) {
    var buf = new SSHBuffer({
      buffer: data
    });
    var d = buf.readBuffer();
    if (d.toString('ascii') === 'ssh-dss') d = buf.readBuffer();
    assert.ok(buf.atEnd(), 'extra trailing bytes');
    assert.strictEqual(d.length, 40, 'invalid inner length');
    data = d;
  }
  opts.parts.push({
    name: 'r',
    data: data.slice(0, 20)
  });
  opts.parts.push({
    name: 's',
    data: data.slice(20, 40)
  });
  return new Signature(opts);
}
function parseECDSA(data, type, format, opts) {
  var buf = new SSHBuffer({
    buffer: data
  });
  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 utils.isCompatible(obj, Signature, ver);
};

/*
 * API versions for Signature:
 * [1,0] -- initial ver
 * [2,0] -- support for rsa in full ssh format, compat with sshpk-agent
 *          hashAlgorithm property
 * [2,1] -- first tagged version
 */
Signature.prototype._sshpkApiVersion = [2, 1];
Signature._oldVersionDetect = function (obj) {
  assert.func(obj.toBuffer);
  if (obj.hasOwnProperty('hashAlgorithm')) return [2, 0];
  return [1, 0];
};

/***/ }),

/***/ 6838:
/*!**********************************************!*\
  !*** ./node_modules/sshpk/lib/ssh-buffer.js ***!
  \**********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// Copyright 2015 Joyent, Inc.

module.exports = SSHBuffer;
var assert = __webpack_require__(/*! assert-plus */ 1095);
var Buffer = (__webpack_require__(/*! safer-buffer */ 3745).Buffer);
function SSHBuffer(opts) {
  assert.object(opts, 'options');
  if (opts.buffer !== undefined) assert.buffer(opts.buffer, 'options.buffer');
  this._size = opts.buffer ? opts.buffer.length : 1024;
  this._buffer = opts.buffer || Buffer.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 = Buffer.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] !== 0x00) 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(Buffer.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 i = 0; i < lead.length; ++i) {
      assert.strictEqual(lead[i], 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;
};

/***/ }),

/***/ 6136:
/*!*****************************************!*\
  !*** ./node_modules/sshpk/lib/utils.js ***!
  \*****************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// Copyright 2015 Joyent, Inc.

module.exports = {
  bufferSplit: bufferSplit,
  addRSAMissing: addRSAMissing,
  calculateDSAPublic: calculateDSAPublic,
  calculateED25519Public: calculateED25519Public,
  calculateX25519Public: calculateX25519Public,
  mpNormalize: mpNormalize,
  mpDenormalize: mpDenormalize,
  ecNormalize: ecNormalize,
  countZeros: countZeros,
  assertCompatible: assertCompatible,
  isCompatible: isCompatible,
  opensslKeyDeriv: opensslKeyDeriv,
  opensshCipherInfo: opensshCipherInfo,
  publicFromPrivateECDSA: publicFromPrivateECDSA,
  zeroPadToLength: zeroPadToLength,
  writeBitString: writeBitString,
  readBitString: readBitString,
  pbkdf2: pbkdf2
};
var assert = __webpack_require__(/*! assert-plus */ 1095);
var Buffer = (__webpack_require__(/*! safer-buffer */ 3745).Buffer);
var PrivateKey = __webpack_require__(/*! ./private-key */ 8230);
var Key = __webpack_require__(/*! ./key */ 8996);
var crypto = __webpack_require__(/*! crypto */ 6113);
var algs = __webpack_require__(/*! ./algs */ 1737);
var asn1 = __webpack_require__(/*! asn1 */ 5593);
var ec = __webpack_require__(/*! ecc-jsbn/lib/ec */ 7221);
var jsbn = (__webpack_require__(/*! jsbn */ 456).BigInteger);
var nacl = __webpack_require__(/*! tweetnacl */ 8227);
var MAX_CLASS_DEPTH = 3;
function isCompatible(obj, klass, needVer) {
  if (obj === null || typeof obj !== 'object') return false;
  if (needVer === undefined) 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 === undefined) 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 === undefined) name = 'object';
  assert.ok(obj, name + ' must not be null');
  assert.object(obj, name + ' must be an object');
  if (needVer === undefined) 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 === undefined) 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 = Buffer.alloc(0);
  while (material.length < clen.key + clen.iv) {
    bufs = [];
    if (D_prev) bufs.push(D_prev);
    bufs.push(passphrase);
    bufs.push(salt);
    D = Buffer.concat(bufs);
    for (var j = 0; j < count; ++j) D = crypto.createHash('md5').update(D).digest();
    material = Buffer.concat([material, D]);
    D_prev = D;
  }
  return {
    key: material.slice(0, clen.key),
    iv: material.slice(clen.key, clen.key + clen.iv)
  };
}

/* See: RFC2898 */
function pbkdf2(hashAlg, salt, iterations, size, passphrase) {
  var hkey = Buffer.alloc(salt.length + 4);
  salt.copy(hkey);
  var gen = 0,
    ts = [];
  var i = 1;
  while (gen < size) {
    var t = T(i++);
    gen += t.length;
    ts.push(t);
  }
  return Buffer.concat(ts).slice(0, size);
  function T(I) {
    hkey.writeUInt32BE(I, hkey.length - 4);
    var hmac = crypto.createHmac(hashAlg, passphrase);
    hmac.update(hkey);
    var Ti = hmac.digest();
    var Uc = Ti;
    var c = 1;
    while (c++ < iterations) {
      hmac = crypto.createHmac(hashAlg, passphrase);
      hmac.update(Uc);
      Uc = hmac.digest();
      for (var x = 0; x < Ti.length; ++x) Ti[x] ^= Uc[x];
    }
    return Ti;
  }
}

/* Count leading zero bits on a buffer */
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 i = 0; i < buf.length; ++i) {
    if (buf[i] === chr.charCodeAt(matches)) ++matches;else if (buf[i] === chr.charCodeAt(0)) matches = 1;else matches = 0;
    if (matches >= chr.length) {
      var newPart = i + 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] === 0x00 && buf[1] === 0x04) {
    if (addZero) return buf;
    return buf.slice(1);
  } else if (buf[0] === 0x04) {
    if (!addZero) return buf;
  } else {
    while (buf[0] === 0x00) buf = buf.slice(1);
    if (buf[0] === 0x02 || buf[0] === 0x03) throw new Error('Compressed elliptic curve points ' + 'are not supported');
    if (buf[0] !== 0x04) throw new Error('Not a valid elliptic curve point');
    if (!addZero) return buf;
  }
  var b = Buffer.alloc(buf.length + 1);
  b[0] = 0x0;
  buf.copy(b, 1);
  return b;
}
function readBitString(der, tag) {
  if (tag === undefined) tag = asn1.Ber.BitString;
  var buf = der.readString(tag, true);
  assert.strictEqual(buf[0], 0x00, 'bit strings with unused bits are ' + 'not supported (0x' + buf[0].toString(16) + ')');
  return buf.slice(1);
}
function writeBitString(der, buf, tag) {
  if (tag === undefined) tag = asn1.Ber.BitString;
  var b = Buffer.alloc(buf.length + 1);
  b[0] = 0x00;
  buf.copy(b, 1);
  der.writeBuffer(b, tag);
}
function mpNormalize(buf) {
  assert.buffer(buf);
  while (buf.length > 1 && buf[0] === 0x00 && (buf[1] & 0x80) === 0x00) buf = buf.slice(1);
  if ((buf[0] & 0x80) === 0x80) {
    var b = Buffer.alloc(buf.length + 1);
    b[0] = 0x00;
    buf.copy(b, 1);
    buf = b;
  }
  return buf;
}
function mpDenormalize(buf) {
  assert.buffer(buf);
  while (buf.length > 1 && buf[0] === 0x00) buf = buf.slice(1);
  return buf;
}
function zeroPadToLength(buf, len) {
  assert.buffer(buf);
  assert.number(len);
  while (buf.length > len) {
    assert.equal(buf[0], 0x00);
    buf = buf.slice(1);
  }
  while (buf.length < len) {
    var b = Buffer.alloc(buf.length + 1);
    b[0] = 0x00;
    buf.copy(b, 1);
    buf = b;
  }
  return buf;
}
function bigintToMpBuf(bigint) {
  var buf = Buffer.from(bigint.toByteArray());
  buf = mpNormalize(buf);
  return buf;
}
function calculateDSAPublic(g, p, x) {
  assert.buffer(g);
  assert.buffer(p);
  assert.buffer(x);
  g = new jsbn(g);
  p = new jsbn(p);
  x = new jsbn(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 Buffer.from(kp.publicKey);
}
function calculateX25519Public(k) {
  assert.buffer(k);
  var kp = nacl.box.keyPair.fromSeed(new Uint8Array(k));
  return Buffer.from(kp.publicKey);
}
function addRSAMissing(key) {
  assert.object(key);
  assertCompatible(key, PrivateKey, [1, 1]);
  var d = new jsbn(key.part.d.data);
  var buf;
  if (!key.part.dmodp) {
    var p = new jsbn(key.part.p.data);
    var dmodp = d.mod(p.subtract(1));
    buf = bigintToMpBuf(dmodp);
    key.part.dmodp = {
      name: 'dmodp',
      data: buf
    };
    key.parts.push(key.part.dmodp);
  }
  if (!key.part.dmodq) {
    var q = new jsbn(key.part.q.data);
    var dmodq = d.mod(q.subtract(1));
    buf = bigintToMpBuf(dmodq);
    key.part.dmodq = {
      name: 'dmodq',
      data: buf
    };
    key.parts.push(key.part.dmodq);
  }
}
function publicFromPrivateECDSA(curveName, priv) {
  assert.string(curveName, 'curveName');
  assert.buffer(priv);
  var params = algs.curves[curveName];
  var p = new jsbn(params.p);
  var a = new jsbn(params.a);
  var b = new jsbn(params.b);
  var curve = new ec.ECCurveFp(p, a, b);
  var G = curve.decodePointHex(params.G.toString('hex'));
  var d = new jsbn(mpNormalize(priv));
  var pub = G.multiply(d);
  pub = Buffer.from(curve.encodePointHex(pub), 'hex');
  var parts = [];
  parts.push({
    name: 'curve',
    data: Buffer.from(curveName)
  });
  parts.push({
    name: 'Q',
    data: pub
  });
  var key = new Key({
    type: 'ecdsa',
    curve: curve,
    parts: parts
  });
  return key;
}
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 'aes128-gcm@openssh.com':
      inf.keySize = 16;
      inf.blockSize = 16;
      inf.opensslName = 'aes-128-' + cipher.slice(7, 10);
      break;
    case 'aes192-cbc':
    case 'aes192-ctr':
    case 'aes192-gcm@openssh.com':
      inf.keySize = 24;
      inf.blockSize = 16;
      inf.opensslName = 'aes-192-' + cipher.slice(7, 10);
      break;
    case 'aes256-cbc':
    case 'aes256-ctr':
    case 'aes256-gcm@openssh.com':
      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;
}

/***/ }),

/***/ 8995:
/*!*******************************************!*\
  !*** ./node_modules/tmp-promise/index.js ***!
  \*******************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


const {
  promisify
} = __webpack_require__(/*! util */ 3837);
const tmp = __webpack_require__(/*! tmp */ 2662);

// file
module.exports.fileSync = tmp.fileSync;
const fileWithOptions = promisify((options, cb) => tmp.file(options, (err, path, fd, cleanup) => err ? cb(err) : cb(undefined, {
  path,
  fd,
  cleanup: promisify(cleanup)
})));
module.exports.file = async options => fileWithOptions(options);
module.exports.withFile = async function withFile(fn, options) {
  const {
    path,
    fd,
    cleanup
  } = await module.exports.file(options);
  try {
    return await fn({
      path,
      fd
    });
  } finally {
    await cleanup();
  }
};

// directory
module.exports.dirSync = tmp.dirSync;
const dirWithOptions = promisify((options, cb) => tmp.dir(options, (err, path, cleanup) => err ? cb(err) : cb(undefined, {
  path,
  cleanup: promisify(cleanup)
})));
module.exports.dir = async options => dirWithOptions(options);
module.exports.withDir = async function withDir(fn, options) {
  const {
    path,
    cleanup
  } = await module.exports.dir(options);
  try {
    return await fn({
      path
    });
  } finally {
    await cleanup();
  }
};

// name generation
module.exports.tmpNameSync = tmp.tmpNameSync;
module.exports.tmpName = promisify(tmp.tmpName);
module.exports.tmpdir = tmp.tmpdir;
module.exports.setGracefulCleanup = tmp.setGracefulCleanup;

/***/ }),

/***/ 2662:
/*!*************************************!*\
  !*** ./node_modules/tmp/lib/tmp.js ***!
  \*************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

/*!
 * Tmp
 *
 * Copyright (c) 2011-2017 KARASZI Istvan <github@spam.raszi.hu>
 *
 * MIT Licensed
 */

/*
 * Module dependencies.
 */
const fs = __webpack_require__(/*! fs */ 2089);
const os = __webpack_require__(/*! os */ 9044);
const path = __webpack_require__(/*! path */ 3056);
const crypto = __webpack_require__(/*! crypto */ 6113);
const _c = {
  fs: fs.constants,
  os: os.constants
};
const rimraf = __webpack_require__(/*! rimraf */ 2856);

/*
 * The working inner variables.
 */
const
  // the random characters to choose from
  RANDOM_CHARS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz',
  TEMPLATE_PATTERN = /XXXXXX/,
  DEFAULT_TRIES = 3,
  CREATE_FLAGS = (_c.O_CREAT || _c.fs.O_CREAT) | (_c.O_EXCL || _c.fs.O_EXCL) | (_c.O_RDWR || _c.fs.O_RDWR),
  // constants are off on the windows platform and will not match the actual errno codes
  IS_WIN32 = os.platform() === 'win32',
  EBADF = _c.EBADF || _c.os.errno.EBADF,
  ENOENT = _c.ENOENT || _c.os.errno.ENOENT,
  DIR_MODE = 0o700 /* 448 */,
  FILE_MODE = 0o600 /* 384 */,
  EXIT = 'exit',
  // this will hold the objects need to be removed on exit
  _removeObjects = [],
  // API change in fs.rmdirSync leads to error when passing in a second parameter, e.g. the callback
  FN_RMDIR_SYNC = fs.rmdirSync.bind(fs),
  FN_RIMRAF_SYNC = rimraf.sync;
let _gracefulCleanup = false;

/**
 * Gets a temporary file name.
 *
 * @param {(Options|tmpNameCallback)} options options or callback
 * @param {?tmpNameCallback} callback the callback function
 */
function tmpName(options, callback) {
  const args = _parseArguments(options, callback),
    opts = args[0],
    cb = args[1];
  try {
    _assertAndSanitizeOptions(opts);
  } catch (err) {
    return cb(err);
  }
  let tries = opts.tries;
  (function _getUniqueName() {
    try {
      const name = _generateTmpName(opts);

      // check whether the path exists then retry if needed
      fs.stat(name, function (err) {
        /* istanbul ignore else */
        if (!err) {
          /* istanbul ignore else */
          if (tries-- > 0) return _getUniqueName();
          return cb(new Error('Could not get a unique tmp filename, max tries reached ' + name));
        }
        cb(null, name);
      });
    } catch (err) {
      cb(err);
    }
  })();
}

/**
 * Synchronous version of tmpName.
 *
 * @param {Object} options
 * @returns {string} the generated random name
 * @throws {Error} if the options are invalid or could not generate a filename
 */
function tmpNameSync(options) {
  const args = _parseArguments(options),
    opts = args[0];
  _assertAndSanitizeOptions(opts);
  let tries = opts.tries;
  do {
    const name = _generateTmpName(opts);
    try {
      fs.statSync(name);
    } catch (e) {
      return name;
    }
  } while (tries-- > 0);
  throw new Error('Could not get a unique tmp filename, max tries reached');
}

/**
 * Creates and opens a temporary file.
 *
 * @param {(Options|null|undefined|fileCallback)} options the config options or the callback function or null or undefined
 * @param {?fileCallback} callback
 */
function file(options, callback) {
  const args = _parseArguments(options, callback),
    opts = args[0],
    cb = args[1];

  // gets a temporary filename
  tmpName(opts, function _tmpNameCreated(err, name) {
    /* istanbul ignore else */
    if (err) return cb(err);

    // create and open the file
    fs.open(name, CREATE_FLAGS, opts.mode || FILE_MODE, function _fileCreated(err, fd) {
      /* istanbu ignore else */
      if (err) return cb(err);
      if (opts.discardDescriptor) {
        return fs.close(fd, function _discardCallback(possibleErr) {
          // the chance of getting an error on close here is rather low and might occur in the most edgiest cases only
          return cb(possibleErr, name, undefined, _prepareTmpFileRemoveCallback(name, -1, opts, false));
        });
      } else {
        // detachDescriptor passes the descriptor whereas discardDescriptor closes it, either way, we no longer care
        // about the descriptor
        const discardOrDetachDescriptor = opts.discardDescriptor || opts.detachDescriptor;
        cb(null, name, fd, _prepareTmpFileRemoveCallback(name, discardOrDetachDescriptor ? -1 : fd, opts, false));
      }
    });
  });
}

/**
 * Synchronous version of file.
 *
 * @param {Options} options
 * @returns {FileSyncObject} object consists of name, fd and removeCallback
 * @throws {Error} if cannot create a file
 */
function fileSync(options) {
  const args = _parseArguments(options),
    opts = args[0];
  const discardOrDetachDescriptor = opts.discardDescriptor || opts.detachDescriptor;
  const name = tmpNameSync(opts);
  var fd = fs.openSync(name, CREATE_FLAGS, opts.mode || FILE_MODE);
  /* istanbul ignore else */
  if (opts.discardDescriptor) {
    fs.closeSync(fd);
    fd = undefined;
  }
  return {
    name: name,
    fd: fd,
    removeCallback: _prepareTmpFileRemoveCallback(name, discardOrDetachDescriptor ? -1 : fd, opts, true)
  };
}

/**
 * Creates a temporary directory.
 *
 * @param {(Options|dirCallback)} options the options or the callback function
 * @param {?dirCallback} callback
 */
function dir(options, callback) {
  const args = _parseArguments(options, callback),
    opts = args[0],
    cb = args[1];

  // gets a temporary filename
  tmpName(opts, function _tmpNameCreated(err, name) {
    /* istanbul ignore else */
    if (err) return cb(err);

    // create the directory
    fs.mkdir(name, opts.mode || DIR_MODE, function _dirCreated(err) {
      /* istanbul ignore else */
      if (err) return cb(err);
      cb(null, name, _prepareTmpDirRemoveCallback(name, opts, false));
    });
  });
}

/**
 * Synchronous version of dir.
 *
 * @param {Options} options
 * @returns {DirSyncObject} object consists of name and removeCallback
 * @throws {Error} if it cannot create a directory
 */
function dirSync(options) {
  const args = _parseArguments(options),
    opts = args[0];
  const name = tmpNameSync(opts);
  fs.mkdirSync(name, opts.mode || DIR_MODE);
  return {
    name: name,
    removeCallback: _prepareTmpDirRemoveCallback(name, opts, true)
  };
}

/**
 * Removes files asynchronously.
 *
 * @param {Object} fdPath
 * @param {Function} next
 * @private
 */
function _removeFileAsync(fdPath, next) {
  const _handler = function (err) {
    if (err && !_isENOENT(err)) {
      // reraise any unanticipated error
      return next(err);
    }
    next();
  };
  if (0 <= fdPath[0]) fs.close(fdPath[0], function () {
    fs.unlink(fdPath[1], _handler);
  });else fs.unlink(fdPath[1], _handler);
}

/**
 * Removes files synchronously.
 *
 * @param {Object} fdPath
 * @private
 */
function _removeFileSync(fdPath) {
  let rethrownException = null;
  try {
    if (0 <= fdPath[0]) fs.closeSync(fdPath[0]);
  } catch (e) {
    // reraise any unanticipated error
    if (!_isEBADF(e) && !_isENOENT(e)) throw e;
  } finally {
    try {
      fs.unlinkSync(fdPath[1]);
    } catch (e) {
      // reraise any unanticipated error
      if (!_isENOENT(e)) rethrownException = e;
    }
  }
  if (rethrownException !== null) {
    throw rethrownException;
  }
}

/**
 * Prepares the callback for removal of the temporary file.
 *
 * Returns either a sync callback or a async callback depending on whether
 * fileSync or file was called, which is expressed by the sync parameter.
 *
 * @param {string} name the path of the file
 * @param {number} fd file descriptor
 * @param {Object} opts
 * @param {boolean} sync
 * @returns {fileCallback | fileCallbackSync}
 * @private
 */
function _prepareTmpFileRemoveCallback(name, fd, opts, sync) {
  const removeCallbackSync = _prepareRemoveCallback(_removeFileSync, [fd, name], sync);
  const removeCallback = _prepareRemoveCallback(_removeFileAsync, [fd, name], sync, removeCallbackSync);
  if (!opts.keep) _removeObjects.unshift(removeCallbackSync);
  return sync ? removeCallbackSync : removeCallback;
}

/**
 * Prepares the callback for removal of the temporary directory.
 *
 * Returns either a sync callback or a async callback depending on whether
 * tmpFileSync or tmpFile was called, which is expressed by the sync parameter.
 *
 * @param {string} name
 * @param {Object} opts
 * @param {boolean} sync
 * @returns {Function} the callback
 * @private
 */
function _prepareTmpDirRemoveCallback(name, opts, sync) {
  const removeFunction = opts.unsafeCleanup ? rimraf : fs.rmdir.bind(fs);
  const removeFunctionSync = opts.unsafeCleanup ? FN_RIMRAF_SYNC : FN_RMDIR_SYNC;
  const removeCallbackSync = _prepareRemoveCallback(removeFunctionSync, name, sync);
  const removeCallback = _prepareRemoveCallback(removeFunction, name, sync, removeCallbackSync);
  if (!opts.keep) _removeObjects.unshift(removeCallbackSync);
  return sync ? removeCallbackSync : removeCallback;
}

/**
 * Creates a guarded function wrapping the removeFunction call.
 *
 * The cleanup callback is save to be called multiple times.
 * Subsequent invocations will be ignored.
 *
 * @param {Function} removeFunction
 * @param {string} fileOrDirName
 * @param {boolean} sync
 * @param {cleanupCallbackSync?} cleanupCallbackSync
 * @returns {cleanupCallback | cleanupCallbackSync}
 * @private
 */
function _prepareRemoveCallback(removeFunction, fileOrDirName, sync, cleanupCallbackSync) {
  let called = false;

  // if sync is true, the next parameter will be ignored
  return function _cleanupCallback(next) {
    /* istanbul ignore else */
    if (!called) {
      // remove cleanupCallback from cache
      const toRemove = cleanupCallbackSync || _cleanupCallback;
      const index = _removeObjects.indexOf(toRemove);
      /* istanbul ignore else */
      if (index >= 0) _removeObjects.splice(index, 1);
      called = true;
      if (sync || removeFunction === FN_RMDIR_SYNC || removeFunction === FN_RIMRAF_SYNC) {
        return removeFunction(fileOrDirName);
      } else {
        return removeFunction(fileOrDirName, next || function () {});
      }
    }
  };
}

/**
 * The garbage collector.
 *
 * @private
 */
function _garbageCollector() {
  /* istanbul ignore else */
  if (!_gracefulCleanup) return;

  // the function being called removes itself from _removeObjects,
  // loop until _removeObjects is empty
  while (_removeObjects.length) {
    try {
      _removeObjects[0]();
    } catch (e) {
      // already removed?
    }
  }
}

/**
 * Random name generator based on crypto.
 * Adapted from http://blog.tompawlak.org/how-to-generate-random-values-nodejs-javascript
 *
 * @param {number} howMany
 * @returns {string} the generated random name
 * @private
 */
function _randomChars(howMany) {
  let value = [],
    rnd = null;

  // make sure that we do not fail because we ran out of entropy
  try {
    rnd = crypto.randomBytes(howMany);
  } catch (e) {
    rnd = crypto.pseudoRandomBytes(howMany);
  }
  for (var i = 0; i < howMany; i++) {
    value.push(RANDOM_CHARS[rnd[i] % RANDOM_CHARS.length]);
  }
  return value.join('');
}

/**
 * Helper which determines whether a string s is blank, that is undefined, or empty or null.
 *
 * @private
 * @param {string} s
 * @returns {Boolean} true whether the string s is blank, false otherwise
 */
function _isBlank(s) {
  return s === null || _isUndefined(s) || !s.trim();
}

/**
 * Checks whether the `obj` parameter is defined or not.
 *
 * @param {Object} obj
 * @returns {boolean} true if the object is undefined
 * @private
 */
function _isUndefined(obj) {
  return typeof obj === 'undefined';
}

/**
 * Parses the function arguments.
 *
 * This function helps to have optional arguments.
 *
 * @param {(Options|null|undefined|Function)} options
 * @param {?Function} callback
 * @returns {Array} parsed arguments
 * @private
 */
function _parseArguments(options, callback) {
  /* istanbul ignore else */
  if (typeof options === 'function') {
    return [{}, options];
  }

  /* istanbul ignore else */
  if (_isUndefined(options)) {
    return [{}, callback];
  }

  // copy options so we do not leak the changes we make internally
  const actualOptions = {};
  for (const key of Object.getOwnPropertyNames(options)) {
    actualOptions[key] = options[key];
  }
  return [actualOptions, callback];
}

/**
 * Generates a new temporary name.
 *
 * @param {Object} opts
 * @returns {string} the new random name according to opts
 * @private
 */
function _generateTmpName(opts) {
  const tmpDir = opts.tmpdir;

  /* istanbul ignore else */
  if (!_isUndefined(opts.name)) return path.join(tmpDir, opts.dir, opts.name);

  /* istanbul ignore else */
  if (!_isUndefined(opts.template)) return path.join(tmpDir, opts.dir, opts.template).replace(TEMPLATE_PATTERN, _randomChars(6));

  // prefix and postfix
  const name = [opts.prefix ? opts.prefix : 'tmp', '-', process.pid, '-', _randomChars(12), opts.postfix ? '-' + opts.postfix : ''].join('');
  return path.join(tmpDir, opts.dir, name);
}

/**
 * Asserts whether the specified options are valid, also sanitizes options and provides sane defaults for missing
 * options.
 *
 * @param {Options} options
 * @private
 */
function _assertAndSanitizeOptions(options) {
  options.tmpdir = _getTmpDir(options);
  const tmpDir = options.tmpdir;

  /* istanbul ignore else */
  if (!_isUndefined(options.name)) _assertIsRelative(options.name, 'name', tmpDir);
  /* istanbul ignore else */
  if (!_isUndefined(options.dir)) _assertIsRelative(options.dir, 'dir', tmpDir);
  /* istanbul ignore else */
  if (!_isUndefined(options.template)) {
    _assertIsRelative(options.template, 'template', tmpDir);
    if (!options.template.match(TEMPLATE_PATTERN)) throw new Error(`Invalid template, found "${options.template}".`);
  }
  /* istanbul ignore else */
  if (!_isUndefined(options.tries) && isNaN(options.tries) || options.tries < 0) throw new Error(`Invalid tries, found "${options.tries}".`);

  // if a name was specified we will try once
  options.tries = _isUndefined(options.name) ? options.tries || DEFAULT_TRIES : 1;
  options.keep = !!options.keep;
  options.detachDescriptor = !!options.detachDescriptor;
  options.discardDescriptor = !!options.discardDescriptor;
  options.unsafeCleanup = !!options.unsafeCleanup;

  // sanitize dir, also keep (multiple) blanks if the user, purportedly sane, requests us to
  options.dir = _isUndefined(options.dir) ? '' : path.relative(tmpDir, _resolvePath(options.dir, tmpDir));
  options.template = _isUndefined(options.template) ? undefined : path.relative(tmpDir, _resolvePath(options.template, tmpDir));
  // sanitize further if template is relative to options.dir
  options.template = _isBlank(options.template) ? undefined : path.relative(options.dir, options.template);

  // for completeness' sake only, also keep (multiple) blanks if the user, purportedly sane, requests us to
  options.name = _isUndefined(options.name) ? undefined : _sanitizeName(options.name);
  options.prefix = _isUndefined(options.prefix) ? '' : options.prefix;
  options.postfix = _isUndefined(options.postfix) ? '' : options.postfix;
}

/**
 * Resolve the specified path name in respect to tmpDir.
 *
 * The specified name might include relative path components, e.g. ../
 * so we need to resolve in order to be sure that is is located inside tmpDir
 *
 * @param name
 * @param tmpDir
 * @returns {string}
 * @private
 */
function _resolvePath(name, tmpDir) {
  const sanitizedName = _sanitizeName(name);
  if (sanitizedName.startsWith(tmpDir)) {
    return path.resolve(sanitizedName);
  } else {
    return path.resolve(path.join(tmpDir, sanitizedName));
  }
}

/**
 * Sanitize the specified path name by removing all quote characters.
 *
 * @param name
 * @returns {string}
 * @private
 */
function _sanitizeName(name) {
  if (_isBlank(name)) {
    return name;
  }
  return name.replace(/["']/g, '');
}

/**
 * Asserts whether specified name is relative to the specified tmpDir.
 *
 * @param {string} name
 * @param {string} option
 * @param {string} tmpDir
 * @throws {Error}
 * @private
 */
function _assertIsRelative(name, option, tmpDir) {
  if (option === 'name') {
    // assert that name is not absolute and does not contain a path
    if (path.isAbsolute(name)) throw new Error(`${option} option must not contain an absolute path, found "${name}".`);
    // must not fail on valid .<name> or ..<name> or similar such constructs
    let basename = path.basename(name);
    if (basename === '..' || basename === '.' || basename !== name) throw new Error(`${option} option must not contain a path, found "${name}".`);
  } else {
    // if (option === 'dir' || option === 'template') {
    // assert that dir or template are relative to tmpDir
    if (path.isAbsolute(name) && !name.startsWith(tmpDir)) {
      throw new Error(`${option} option must be relative to "${tmpDir}", found "${name}".`);
    }
    let resolvedPath = _resolvePath(name, tmpDir);
    if (!resolvedPath.startsWith(tmpDir)) throw new Error(`${option} option must be relative to "${tmpDir}", found "${resolvedPath}".`);
  }
}

/**
 * Helper for testing against EBADF to compensate changes made to Node 7.x under Windows.
 *
 * @private
 */
function _isEBADF(error) {
  return _isExpectedError(error, -EBADF, 'EBADF');
}

/**
 * Helper for testing against ENOENT to compensate changes made to Node 7.x under Windows.
 *
 * @private
 */
function _isENOENT(error) {
  return _isExpectedError(error, -ENOENT, 'ENOENT');
}

/**
 * Helper to determine whether the expected error code matches the actual code and errno,
 * which will differ between the supported node versions.
 *
 * - Node >= 7.0:
 *   error.code {string}
 *   error.errno {number} any numerical value will be negated
 *
 * CAVEAT
 *
 * On windows, the errno for EBADF is -4083 but os.constants.errno.EBADF is different and we must assume that ENOENT
 * is no different here.
 *
 * @param {SystemError} error
 * @param {number} errno
 * @param {string} code
 * @private
 */
function _isExpectedError(error, errno, code) {
  return IS_WIN32 ? error.code === code : error.code === code && error.errno === errno;
}

/**
 * Sets the graceful cleanup.
 *
 * If graceful cleanup is set, tmp will remove all controlled temporary objects on process exit, otherwise the
 * temporary objects will remain in place, waiting to be cleaned up on system restart or otherwise scheduled temporary
 * object removals.
 */
function setGracefulCleanup() {
  _gracefulCleanup = true;
}

/**
 * Returns the currently configured tmp dir from os.tmpdir().
 *
 * @private
 * @param {?Options} options
 * @returns {string} the currently configured tmp dir
 */
function _getTmpDir(options) {
  return path.resolve(_sanitizeName(options && options.tmpdir || os.tmpdir()));
}

// Install process exit listener
process.addListener(EXIT, _garbageCollector);

/**
 * Configuration options.
 *
 * @typedef {Object} Options
 * @property {?boolean} keep the temporary object (file or dir) will not be garbage collected
 * @property {?number} tries the number of tries before give up the name generation
 * @property (?int) mode the access mode, defaults are 0o700 for directories and 0o600 for files
 * @property {?string} template the "mkstemp" like filename template
 * @property {?string} name fixed name relative to tmpdir or the specified dir option
 * @property {?string} dir tmp directory relative to the root tmp directory in use
 * @property {?string} prefix prefix for the generated name
 * @property {?string} postfix postfix for the generated name
 * @property {?string} tmpdir the root tmp directory which overrides the os tmpdir
 * @property {?boolean} unsafeCleanup recursively removes the created temporary directory, even when it's not empty
 * @property {?boolean} detachDescriptor detaches the file descriptor, caller is responsible for closing the file, tmp will no longer try closing the file during garbage collection
 * @property {?boolean} discardDescriptor discards the file descriptor (closes file, fd is -1), tmp will no longer try closing the file during garbage collection
 */

/**
 * @typedef {Object} FileSyncObject
 * @property {string} name the name of the file
 * @property {string} fd the file descriptor or -1 if the fd has been discarded
 * @property {fileCallback} removeCallback the callback function to remove the file
 */

/**
 * @typedef {Object} DirSyncObject
 * @property {string} name the name of the directory
 * @property {fileCallback} removeCallback the callback function to remove the directory
 */

/**
 * @callback tmpNameCallback
 * @param {?Error} err the error object if anything goes wrong
 * @param {string} name the temporary file name
 */

/**
 * @callback fileCallback
 * @param {?Error} err the error object if anything goes wrong
 * @param {string} name the temporary file name
 * @param {number} fd the file descriptor or -1 if the fd had been discarded
 * @param {cleanupCallback} fn the cleanup callback function
 */

/**
 * @callback fileCallbackSync
 * @param {?Error} err the error object if anything goes wrong
 * @param {string} name the temporary file name
 * @param {number} fd the file descriptor or -1 if the fd had been discarded
 * @param {cleanupCallbackSync} fn the cleanup callback function
 */

/**
 * @callback dirCallback
 * @param {?Error} err the error object if anything goes wrong
 * @param {string} name the temporary file name
 * @param {cleanupCallback} fn the cleanup callback function
 */

/**
 * @callback dirCallbackSync
 * @param {?Error} err the error object if anything goes wrong
 * @param {string} name the temporary file name
 * @param {cleanupCallbackSync} fn the cleanup callback function
 */

/**
 * Removes the temporary created file or directory.
 *
 * @callback cleanupCallback
 * @param {simpleCallback} [next] function to call whenever the tmp object needs to be removed
 */

/**
 * Removes the temporary created file or directory.
 *
 * @callback cleanupCallbackSync
 */

/**
 * Callback function for function composition.
 * @see {@link https://github.com/raszi/node-tmp/issues/57|raszi/node-tmp#57}
 *
 * @callback simpleCallback
 */

// exporting all the needed methods

// evaluate _getTmpDir() lazily, mainly for simplifying testing but it also will
// allow users to reconfigure the temporary directory
Object.defineProperty(module.exports, "tmpdir", ({
  enumerable: true,
  configurable: false,
  get: function () {
    return _getTmpDir();
  }
}));
module.exports.dir = dir;
module.exports.dirSync = dirSync;
module.exports.file = file;
module.exports.fileSync = fileSync;
module.exports.tmpName = tmpName;
module.exports.tmpNameSync = tmpNameSync;
module.exports.setGracefulCleanup = setGracefulCleanup;

/***/ }),

/***/ 8227:
/*!*********************************************!*\
  !*** ./node_modules/tweetnacl/nacl-fast.js ***!
  \*********************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

(function (nacl) {
  'use strict';

  // Ported in 2014 by Dmitry Chestnykh and Devi Mandiri.
  // Public domain.
  //
  // Implementation derived from TweetNaCl version 20140427.
  // See for details: http://tweetnacl.cr.yp.to/
  var gf = function (init) {
    var i,
      r = new Float64Array(16);
    if (init) for (i = 0; i < init.length; i++) r[i] = init[i];
    return r;
  };

  //  Pluggable, initialized in high-level API below.
  var randombytes = function /* x, n */ () {
    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([0xdb41, 1]),
    D = gf([0x78a3, 0x1359, 0x4dca, 0x75eb, 0xd8ab, 0x4141, 0x0a4d, 0x0070, 0xe898, 0x7779, 0x4079, 0x8cc7, 0xfe73, 0x2b6f, 0x6cee, 0x5203]),
    D2 = gf([0xf159, 0x26b2, 0x9b94, 0xebd6, 0xb156, 0x8283, 0x149a, 0x00e0, 0xd130, 0xeef3, 0x80f2, 0x198e, 0xfce7, 0x56df, 0xd9dc, 0x2406]),
    X = gf([0xd51a, 0x8f25, 0x2d60, 0xc956, 0xa7b2, 0x9525, 0xc760, 0x692c, 0xdc5c, 0xfdd6, 0xe231, 0xc0a4, 0x53fe, 0xcd6e, 0x36d3, 0x2169]),
    Y = gf([0x6658, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666]),
    I = gf([0xa0b0, 0x4a0e, 0x1b27, 0xc4ee, 0xe478, 0xad2f, 0x1806, 0x2f43, 0xd7a7, 0x3dfb, 0x0099, 0x2b4d, 0xdf0b, 0x4fc1, 0x2480, 0x2b83]);
  function ts64(x, i, h, l) {
    x[i] = h >> 24 & 0xff;
    x[i + 1] = h >> 16 & 0xff;
    x[i + 2] = h >> 8 & 0xff;
    x[i + 3] = h & 0xff;
    x[i + 4] = l >> 24 & 0xff;
    x[i + 5] = l >> 16 & 0xff;
    x[i + 6] = l >> 8 & 0xff;
    x[i + 7] = l & 0xff;
  }
  function vn(x, xi, y, yi, n) {
    var i,
      d = 0;
    for (i = 0; i < n; i++) d |= x[xi + i] ^ y[yi + i];
    return (1 & d - 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, c) {
    var j0 = c[0] & 0xff | (c[1] & 0xff) << 8 | (c[2] & 0xff) << 16 | (c[3] & 0xff) << 24,
      j1 = k[0] & 0xff | (k[1] & 0xff) << 8 | (k[2] & 0xff) << 16 | (k[3] & 0xff) << 24,
      j2 = k[4] & 0xff | (k[5] & 0xff) << 8 | (k[6] & 0xff) << 16 | (k[7] & 0xff) << 24,
      j3 = k[8] & 0xff | (k[9] & 0xff) << 8 | (k[10] & 0xff) << 16 | (k[11] & 0xff) << 24,
      j4 = k[12] & 0xff | (k[13] & 0xff) << 8 | (k[14] & 0xff) << 16 | (k[15] & 0xff) << 24,
      j5 = c[4] & 0xff | (c[5] & 0xff) << 8 | (c[6] & 0xff) << 16 | (c[7] & 0xff) << 24,
      j6 = p[0] & 0xff | (p[1] & 0xff) << 8 | (p[2] & 0xff) << 16 | (p[3] & 0xff) << 24,
      j7 = p[4] & 0xff | (p[5] & 0xff) << 8 | (p[6] & 0xff) << 16 | (p[7] & 0xff) << 24,
      j8 = p[8] & 0xff | (p[9] & 0xff) << 8 | (p[10] & 0xff) << 16 | (p[11] & 0xff) << 24,
      j9 = p[12] & 0xff | (p[13] & 0xff) << 8 | (p[14] & 0xff) << 16 | (p[15] & 0xff) << 24,
      j10 = c[8] & 0xff | (c[9] & 0xff) << 8 | (c[10] & 0xff) << 16 | (c[11] & 0xff) << 24,
      j11 = k[16] & 0xff | (k[17] & 0xff) << 8 | (k[18] & 0xff) << 16 | (k[19] & 0xff) << 24,
      j12 = k[20] & 0xff | (k[21] & 0xff) << 8 | (k[22] & 0xff) << 16 | (k[23] & 0xff) << 24,
      j13 = k[24] & 0xff | (k[25] & 0xff) << 8 | (k[26] & 0xff) << 16 | (k[27] & 0xff) << 24,
      j14 = k[28] & 0xff | (k[29] & 0xff) << 8 | (k[30] & 0xff) << 16 | (k[31] & 0xff) << 24,
      j15 = c[12] & 0xff | (c[13] & 0xff) << 8 | (c[14] & 0xff) << 16 | (c[15] & 0xff) << 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 i = 0; i < 20; i += 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 & 0xff;
    o[1] = x0 >>> 8 & 0xff;
    o[2] = x0 >>> 16 & 0xff;
    o[3] = x0 >>> 24 & 0xff;
    o[4] = x1 >>> 0 & 0xff;
    o[5] = x1 >>> 8 & 0xff;
    o[6] = x1 >>> 16 & 0xff;
    o[7] = x1 >>> 24 & 0xff;
    o[8] = x2 >>> 0 & 0xff;
    o[9] = x2 >>> 8 & 0xff;
    o[10] = x2 >>> 16 & 0xff;
    o[11] = x2 >>> 24 & 0xff;
    o[12] = x3 >>> 0 & 0xff;
    o[13] = x3 >>> 8 & 0xff;
    o[14] = x3 >>> 16 & 0xff;
    o[15] = x3 >>> 24 & 0xff;
    o[16] = x4 >>> 0 & 0xff;
    o[17] = x4 >>> 8 & 0xff;
    o[18] = x4 >>> 16 & 0xff;
    o[19] = x4 >>> 24 & 0xff;
    o[20] = x5 >>> 0 & 0xff;
    o[21] = x5 >>> 8 & 0xff;
    o[22] = x5 >>> 16 & 0xff;
    o[23] = x5 >>> 24 & 0xff;
    o[24] = x6 >>> 0 & 0xff;
    o[25] = x6 >>> 8 & 0xff;
    o[26] = x6 >>> 16 & 0xff;
    o[27] = x6 >>> 24 & 0xff;
    o[28] = x7 >>> 0 & 0xff;
    o[29] = x7 >>> 8 & 0xff;
    o[30] = x7 >>> 16 & 0xff;
    o[31] = x7 >>> 24 & 0xff;
    o[32] = x8 >>> 0 & 0xff;
    o[33] = x8 >>> 8 & 0xff;
    o[34] = x8 >>> 16 & 0xff;
    o[35] = x8 >>> 24 & 0xff;
    o[36] = x9 >>> 0 & 0xff;
    o[37] = x9 >>> 8 & 0xff;
    o[38] = x9 >>> 16 & 0xff;
    o[39] = x9 >>> 24 & 0xff;
    o[40] = x10 >>> 0 & 0xff;
    o[41] = x10 >>> 8 & 0xff;
    o[42] = x10 >>> 16 & 0xff;
    o[43] = x10 >>> 24 & 0xff;
    o[44] = x11 >>> 0 & 0xff;
    o[45] = x11 >>> 8 & 0xff;
    o[46] = x11 >>> 16 & 0xff;
    o[47] = x11 >>> 24 & 0xff;
    o[48] = x12 >>> 0 & 0xff;
    o[49] = x12 >>> 8 & 0xff;
    o[50] = x12 >>> 16 & 0xff;
    o[51] = x12 >>> 24 & 0xff;
    o[52] = x13 >>> 0 & 0xff;
    o[53] = x13 >>> 8 & 0xff;
    o[54] = x13 >>> 16 & 0xff;
    o[55] = x13 >>> 24 & 0xff;
    o[56] = x14 >>> 0 & 0xff;
    o[57] = x14 >>> 8 & 0xff;
    o[58] = x14 >>> 16 & 0xff;
    o[59] = x14 >>> 24 & 0xff;
    o[60] = x15 >>> 0 & 0xff;
    o[61] = x15 >>> 8 & 0xff;
    o[62] = x15 >>> 16 & 0xff;
    o[63] = x15 >>> 24 & 0xff;
  }
  function core_hsalsa20(o, p, k, c) {
    var j0 = c[0] & 0xff | (c[1] & 0xff) << 8 | (c[2] & 0xff) << 16 | (c[3] & 0xff) << 24,
      j1 = k[0] & 0xff | (k[1] & 0xff) << 8 | (k[2] & 0xff) << 16 | (k[3] & 0xff) << 24,
      j2 = k[4] & 0xff | (k[5] & 0xff) << 8 | (k[6] & 0xff) << 16 | (k[7] & 0xff) << 24,
      j3 = k[8] & 0xff | (k[9] & 0xff) << 8 | (k[10] & 0xff) << 16 | (k[11] & 0xff) << 24,
      j4 = k[12] & 0xff | (k[13] & 0xff) << 8 | (k[14] & 0xff) << 16 | (k[15] & 0xff) << 24,
      j5 = c[4] & 0xff | (c[5] & 0xff) << 8 | (c[6] & 0xff) << 16 | (c[7] & 0xff) << 24,
      j6 = p[0] & 0xff | (p[1] & 0xff) << 8 | (p[2] & 0xff) << 16 | (p[3] & 0xff) << 24,
      j7 = p[4] & 0xff | (p[5] & 0xff) << 8 | (p[6] & 0xff) << 16 | (p[7] & 0xff) << 24,
      j8 = p[8] & 0xff | (p[9] & 0xff) << 8 | (p[10] & 0xff) << 16 | (p[11] & 0xff) << 24,
      j9 = p[12] & 0xff | (p[13] & 0xff) << 8 | (p[14] & 0xff) << 16 | (p[15] & 0xff) << 24,
      j10 = c[8] & 0xff | (c[9] & 0xff) << 8 | (c[10] & 0xff) << 16 | (c[11] & 0xff) << 24,
      j11 = k[16] & 0xff | (k[17] & 0xff) << 8 | (k[18] & 0xff) << 16 | (k[19] & 0xff) << 24,
      j12 = k[20] & 0xff | (k[21] & 0xff) << 8 | (k[22] & 0xff) << 16 | (k[23] & 0xff) << 24,
      j13 = k[24] & 0xff | (k[25] & 0xff) << 8 | (k[26] & 0xff) << 16 | (k[27] & 0xff) << 24,
      j14 = k[28] & 0xff | (k[29] & 0xff) << 8 | (k[30] & 0xff) << 16 | (k[31] & 0xff) << 24,
      j15 = c[12] & 0xff | (c[13] & 0xff) << 8 | (c[14] & 0xff) << 16 | (c[15] & 0xff) << 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 i = 0; i < 20; i += 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 & 0xff;
    o[1] = x0 >>> 8 & 0xff;
    o[2] = x0 >>> 16 & 0xff;
    o[3] = x0 >>> 24 & 0xff;
    o[4] = x5 >>> 0 & 0xff;
    o[5] = x5 >>> 8 & 0xff;
    o[6] = x5 >>> 16 & 0xff;
    o[7] = x5 >>> 24 & 0xff;
    o[8] = x10 >>> 0 & 0xff;
    o[9] = x10 >>> 8 & 0xff;
    o[10] = x10 >>> 16 & 0xff;
    o[11] = x10 >>> 24 & 0xff;
    o[12] = x15 >>> 0 & 0xff;
    o[13] = x15 >>> 8 & 0xff;
    o[14] = x15 >>> 16 & 0xff;
    o[15] = x15 >>> 24 & 0xff;
    o[16] = x6 >>> 0 & 0xff;
    o[17] = x6 >>> 8 & 0xff;
    o[18] = x6 >>> 16 & 0xff;
    o[19] = x6 >>> 24 & 0xff;
    o[20] = x7 >>> 0 & 0xff;
    o[21] = x7 >>> 8 & 0xff;
    o[22] = x7 >>> 16 & 0xff;
    o[23] = x7 >>> 24 & 0xff;
    o[24] = x8 >>> 0 & 0xff;
    o[25] = x8 >>> 8 & 0xff;
    o[26] = x8 >>> 16 & 0xff;
    o[27] = x8 >>> 24 & 0xff;
    o[28] = x9 >>> 0 & 0xff;
    o[29] = x9 >>> 8 & 0xff;
    o[30] = x9 >>> 16 & 0xff;
    o[31] = x9 >>> 24 & 0xff;
  }
  function crypto_core_salsa20(out, inp, k, c) {
    core_salsa20(out, inp, k, c);
  }
  function crypto_core_hsalsa20(out, inp, k, c) {
    core_hsalsa20(out, inp, k, c);
  }
  var sigma = new Uint8Array([101, 120, 112, 97, 110, 100, 32, 51, 50, 45, 98, 121, 116, 101, 32, 107]);
  // "expand 32-byte k"

  function crypto_stream_salsa20_xor(c, cpos, m, mpos, b, n, k) {
    var z = new Uint8Array(16),
      x = new Uint8Array(64);
    var u, i;
    for (i = 0; i < 16; i++) z[i] = 0;
    for (i = 0; i < 8; i++) z[i] = n[i];
    while (b >= 64) {
      crypto_core_salsa20(x, z, k, sigma);
      for (i = 0; i < 64; i++) c[cpos + i] = m[mpos + i] ^ x[i];
      u = 1;
      for (i = 8; i < 16; i++) {
        u = u + (z[i] & 0xff) | 0;
        z[i] = u & 0xff;
        u >>>= 8;
      }
      b -= 64;
      cpos += 64;
      mpos += 64;
    }
    if (b > 0) {
      crypto_core_salsa20(x, z, k, sigma);
      for (i = 0; i < b; i++) c[cpos + i] = m[mpos + i] ^ x[i];
    }
    return 0;
  }
  function crypto_stream_salsa20(c, cpos, b, n, k) {
    var z = new Uint8Array(16),
      x = new Uint8Array(64);
    var u, i;
    for (i = 0; i < 16; i++) z[i] = 0;
    for (i = 0; i < 8; i++) z[i] = n[i];
    while (b >= 64) {
      crypto_core_salsa20(x, z, k, sigma);
      for (i = 0; i < 64; i++) c[cpos + i] = x[i];
      u = 1;
      for (i = 8; i < 16; i++) {
        u = u + (z[i] & 0xff) | 0;
        z[i] = u & 0xff;
        u >>>= 8;
      }
      b -= 64;
      cpos += 64;
    }
    if (b > 0) {
      crypto_core_salsa20(x, z, k, sigma);
      for (i = 0; i < b; i++) c[cpos + i] = x[i];
    }
    return 0;
  }
  function crypto_stream(c, cpos, d, n, k) {
    var s = new Uint8Array(32);
    crypto_core_hsalsa20(s, n, k, sigma);
    var sn = new Uint8Array(8);
    for (var i = 0; i < 8; i++) sn[i] = n[i + 16];
    return crypto_stream_salsa20(c, cpos, d, sn, s);
  }
  function crypto_stream_xor(c, cpos, m, mpos, d, n, k) {
    var s = new Uint8Array(32);
    crypto_core_hsalsa20(s, n, k, sigma);
    var sn = new Uint8Array(8);
    for (var i = 0; i < 8; i++) sn[i] = n[i + 16];
    return crypto_stream_salsa20_xor(c, cpos, m, mpos, d, sn, s);
  }

  /*
  * Port of Andrew Moon's Poly1305-donna-16. Public domain.
  * https://github.com/floodyberry/poly1305-donna
  */

  var poly1305 = function (key) {
    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 = key[0] & 0xff | (key[1] & 0xff) << 8;
    this.r[0] = t0 & 0x1fff;
    t1 = key[2] & 0xff | (key[3] & 0xff) << 8;
    this.r[1] = (t0 >>> 13 | t1 << 3) & 0x1fff;
    t2 = key[4] & 0xff | (key[5] & 0xff) << 8;
    this.r[2] = (t1 >>> 10 | t2 << 6) & 0x1f03;
    t3 = key[6] & 0xff | (key[7] & 0xff) << 8;
    this.r[3] = (t2 >>> 7 | t3 << 9) & 0x1fff;
    t4 = key[8] & 0xff | (key[9] & 0xff) << 8;
    this.r[4] = (t3 >>> 4 | t4 << 12) & 0x00ff;
    this.r[5] = t4 >>> 1 & 0x1ffe;
    t5 = key[10] & 0xff | (key[11] & 0xff) << 8;
    this.r[6] = (t4 >>> 14 | t5 << 2) & 0x1fff;
    t6 = key[12] & 0xff | (key[13] & 0xff) << 8;
    this.r[7] = (t5 >>> 11 | t6 << 5) & 0x1f81;
    t7 = key[14] & 0xff | (key[15] & 0xff) << 8;
    this.r[8] = (t6 >>> 8 | t7 << 8) & 0x1fff;
    this.r[9] = t7 >>> 5 & 0x007f;
    this.pad[0] = key[16] & 0xff | (key[17] & 0xff) << 8;
    this.pad[1] = key[18] & 0xff | (key[19] & 0xff) << 8;
    this.pad[2] = key[20] & 0xff | (key[21] & 0xff) << 8;
    this.pad[3] = key[22] & 0xff | (key[23] & 0xff) << 8;
    this.pad[4] = key[24] & 0xff | (key[25] & 0xff) << 8;
    this.pad[5] = key[26] & 0xff | (key[27] & 0xff) << 8;
    this.pad[6] = key[28] & 0xff | (key[29] & 0xff) << 8;
    this.pad[7] = key[30] & 0xff | (key[31] & 0xff) << 8;
  };
  poly1305.prototype.blocks = function (m, mpos, bytes) {
    var hibit = this.fin ? 0 : 1 << 11;
    var t0, t1, t2, t3, t4, t5, t6, t7, c;
    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] & 0xff | (m[mpos + 1] & 0xff) << 8;
      h0 += t0 & 0x1fff;
      t1 = m[mpos + 2] & 0xff | (m[mpos + 3] & 0xff) << 8;
      h1 += (t0 >>> 13 | t1 << 3) & 0x1fff;
      t2 = m[mpos + 4] & 0xff | (m[mpos + 5] & 0xff) << 8;
      h2 += (t1 >>> 10 | t2 << 6) & 0x1fff;
      t3 = m[mpos + 6] & 0xff | (m[mpos + 7] & 0xff) << 8;
      h3 += (t2 >>> 7 | t3 << 9) & 0x1fff;
      t4 = m[mpos + 8] & 0xff | (m[mpos + 9] & 0xff) << 8;
      h4 += (t3 >>> 4 | t4 << 12) & 0x1fff;
      h5 += t4 >>> 1 & 0x1fff;
      t5 = m[mpos + 10] & 0xff | (m[mpos + 11] & 0xff) << 8;
      h6 += (t4 >>> 14 | t5 << 2) & 0x1fff;
      t6 = m[mpos + 12] & 0xff | (m[mpos + 13] & 0xff) << 8;
      h7 += (t5 >>> 11 | t6 << 5) & 0x1fff;
      t7 = m[mpos + 14] & 0xff | (m[mpos + 15] & 0xff) << 8;
      h8 += (t6 >>> 8 | t7 << 8) & 0x1fff;
      h9 += t7 >>> 5 | hibit;
      c = 0;
      d0 = c;
      d0 += h0 * r0;
      d0 += h1 * (5 * r9);
      d0 += h2 * (5 * r8);
      d0 += h3 * (5 * r7);
      d0 += h4 * (5 * r6);
      c = d0 >>> 13;
      d0 &= 0x1fff;
      d0 += h5 * (5 * r5);
      d0 += h6 * (5 * r4);
      d0 += h7 * (5 * r3);
      d0 += h8 * (5 * r2);
      d0 += h9 * (5 * r1);
      c += d0 >>> 13;
      d0 &= 0x1fff;
      d1 = c;
      d1 += h0 * r1;
      d1 += h1 * r0;
      d1 += h2 * (5 * r9);
      d1 += h3 * (5 * r8);
      d1 += h4 * (5 * r7);
      c = d1 >>> 13;
      d1 &= 0x1fff;
      d1 += h5 * (5 * r6);
      d1 += h6 * (5 * r5);
      d1 += h7 * (5 * r4);
      d1 += h8 * (5 * r3);
      d1 += h9 * (5 * r2);
      c += d1 >>> 13;
      d1 &= 0x1fff;
      d2 = c;
      d2 += h0 * r2;
      d2 += h1 * r1;
      d2 += h2 * r0;
      d2 += h3 * (5 * r9);
      d2 += h4 * (5 * r8);
      c = d2 >>> 13;
      d2 &= 0x1fff;
      d2 += h5 * (5 * r7);
      d2 += h6 * (5 * r6);
      d2 += h7 * (5 * r5);
      d2 += h8 * (5 * r4);
      d2 += h9 * (5 * r3);
      c += d2 >>> 13;
      d2 &= 0x1fff;
      d3 = c;
      d3 += h0 * r3;
      d3 += h1 * r2;
      d3 += h2 * r1;
      d3 += h3 * r0;
      d3 += h4 * (5 * r9);
      c = d3 >>> 13;
      d3 &= 0x1fff;
      d3 += h5 * (5 * r8);
      d3 += h6 * (5 * r7);
      d3 += h7 * (5 * r6);
      d3 += h8 * (5 * r5);
      d3 += h9 * (5 * r4);
      c += d3 >>> 13;
      d3 &= 0x1fff;
      d4 = c;
      d4 += h0 * r4;
      d4 += h1 * r3;
      d4 += h2 * r2;
      d4 += h3 * r1;
      d4 += h4 * r0;
      c = d4 >>> 13;
      d4 &= 0x1fff;
      d4 += h5 * (5 * r9);
      d4 += h6 * (5 * r8);
      d4 += h7 * (5 * r7);
      d4 += h8 * (5 * r6);
      d4 += h9 * (5 * r5);
      c += d4 >>> 13;
      d4 &= 0x1fff;
      d5 = c;
      d5 += h0 * r5;
      d5 += h1 * r4;
      d5 += h2 * r3;
      d5 += h3 * r2;
      d5 += h4 * r1;
      c = d5 >>> 13;
      d5 &= 0x1fff;
      d5 += h5 * r0;
      d5 += h6 * (5 * r9);
      d5 += h7 * (5 * r8);
      d5 += h8 * (5 * r7);
      d5 += h9 * (5 * r6);
      c += d5 >>> 13;
      d5 &= 0x1fff;
      d6 = c;
      d6 += h0 * r6;
      d6 += h1 * r5;
      d6 += h2 * r4;
      d6 += h3 * r3;
      d6 += h4 * r2;
      c = d6 >>> 13;
      d6 &= 0x1fff;
      d6 += h5 * r1;
      d6 += h6 * r0;
      d6 += h7 * (5 * r9);
      d6 += h8 * (5 * r8);
      d6 += h9 * (5 * r7);
      c += d6 >>> 13;
      d6 &= 0x1fff;
      d7 = c;
      d7 += h0 * r7;
      d7 += h1 * r6;
      d7 += h2 * r5;
      d7 += h3 * r4;
      d7 += h4 * r3;
      c = d7 >>> 13;
      d7 &= 0x1fff;
      d7 += h5 * r2;
      d7 += h6 * r1;
      d7 += h7 * r0;
      d7 += h8 * (5 * r9);
      d7 += h9 * (5 * r8);
      c += d7 >>> 13;
      d7 &= 0x1fff;
      d8 = c;
      d8 += h0 * r8;
      d8 += h1 * r7;
      d8 += h2 * r6;
      d8 += h3 * r5;
      d8 += h4 * r4;
      c = d8 >>> 13;
      d8 &= 0x1fff;
      d8 += h5 * r3;
      d8 += h6 * r2;
      d8 += h7 * r1;
      d8 += h8 * r0;
      d8 += h9 * (5 * r9);
      c += d8 >>> 13;
      d8 &= 0x1fff;
      d9 = c;
      d9 += h0 * r9;
      d9 += h1 * r8;
      d9 += h2 * r7;
      d9 += h3 * r6;
      d9 += h4 * r5;
      c = d9 >>> 13;
      d9 &= 0x1fff;
      d9 += h5 * r4;
      d9 += h6 * r3;
      d9 += h7 * r2;
      d9 += h8 * r1;
      d9 += h9 * r0;
      c += d9 >>> 13;
      d9 &= 0x1fff;
      c = (c << 2) + c | 0;
      c = c + d0 | 0;
      d0 = c & 0x1fff;
      c = c >>> 13;
      d1 += c;
      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 c, mask, f, i;
    if (this.leftover) {
      i = this.leftover;
      this.buffer[i++] = 1;
      for (; i < 16; i++) this.buffer[i] = 0;
      this.fin = 1;
      this.blocks(this.buffer, 0, 16);
    }
    c = this.h[1] >>> 13;
    this.h[1] &= 0x1fff;
    for (i = 2; i < 10; i++) {
      this.h[i] += c;
      c = this.h[i] >>> 13;
      this.h[i] &= 0x1fff;
    }
    this.h[0] += c * 5;
    c = this.h[0] >>> 13;
    this.h[0] &= 0x1fff;
    this.h[1] += c;
    c = this.h[1] >>> 13;
    this.h[1] &= 0x1fff;
    this.h[2] += c;
    g[0] = this.h[0] + 5;
    c = g[0] >>> 13;
    g[0] &= 0x1fff;
    for (i = 1; i < 10; i++) {
      g[i] = this.h[i] + c;
      c = g[i] >>> 13;
      g[i] &= 0x1fff;
    }
    g[9] -= 1 << 13;
    mask = (c ^ 1) - 1;
    for (i = 0; i < 10; i++) g[i] &= mask;
    mask = ~mask;
    for (i = 0; i < 10; i++) this.h[i] = this.h[i] & mask | g[i];
    this.h[0] = (this.h[0] | this.h[1] << 13) & 0xffff;
    this.h[1] = (this.h[1] >>> 3 | this.h[2] << 10) & 0xffff;
    this.h[2] = (this.h[2] >>> 6 | this.h[3] << 7) & 0xffff;
    this.h[3] = (this.h[3] >>> 9 | this.h[4] << 4) & 0xffff;
    this.h[4] = (this.h[4] >>> 12 | this.h[5] << 1 | this.h[6] << 14) & 0xffff;
    this.h[5] = (this.h[6] >>> 2 | this.h[7] << 11) & 0xffff;
    this.h[6] = (this.h[7] >>> 5 | this.h[8] << 8) & 0xffff;
    this.h[7] = (this.h[8] >>> 8 | this.h[9] << 5) & 0xffff;
    f = this.h[0] + this.pad[0];
    this.h[0] = f & 0xffff;
    for (i = 1; i < 8; i++) {
      f = (this.h[i] + this.pad[i] | 0) + (f >>> 16) | 0;
      this.h[i] = f & 0xffff;
    }
    mac[macpos + 0] = this.h[0] >>> 0 & 0xff;
    mac[macpos + 1] = this.h[0] >>> 8 & 0xff;
    mac[macpos + 2] = this.h[1] >>> 0 & 0xff;
    mac[macpos + 3] = this.h[1] >>> 8 & 0xff;
    mac[macpos + 4] = this.h[2] >>> 0 & 0xff;
    mac[macpos + 5] = this.h[2] >>> 8 & 0xff;
    mac[macpos + 6] = this.h[3] >>> 0 & 0xff;
    mac[macpos + 7] = this.h[3] >>> 8 & 0xff;
    mac[macpos + 8] = this.h[4] >>> 0 & 0xff;
    mac[macpos + 9] = this.h[4] >>> 8 & 0xff;
    mac[macpos + 10] = this.h[5] >>> 0 & 0xff;
    mac[macpos + 11] = this.h[5] >>> 8 & 0xff;
    mac[macpos + 12] = this.h[6] >>> 0 & 0xff;
    mac[macpos + 13] = this.h[6] >>> 8 & 0xff;
    mac[macpos + 14] = this.h[7] >>> 0 & 0xff;
    mac[macpos + 15] = this.h[7] >>> 8 & 0xff;
  };
  poly1305.prototype.update = function (m, mpos, bytes) {
    var i, want;
    if (this.leftover) {
      want = 16 - this.leftover;
      if (want > bytes) want = bytes;
      for (i = 0; i < want; i++) this.buffer[this.leftover + i] = m[mpos + i];
      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 (i = 0; i < bytes; i++) this.buffer[this.leftover + i] = m[mpos + i];
      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(c, m, d, n, k) {
    var i;
    if (d < 32) return -1;
    crypto_stream_xor(c, 0, m, 0, d, n, k);
    crypto_onetimeauth(c, 16, c, 32, d - 32, c);
    for (i = 0; i < 16; i++) c[i] = 0;
    return 0;
  }
  function crypto_secretbox_open(m, c, d, n, k) {
    var i;
    var x = new Uint8Array(32);
    if (d < 32) return -1;
    crypto_stream(x, 0, 32, n, k);
    if (crypto_onetimeauth_verify(c, 16, c, 32, d - 32, x) !== 0) return -1;
    crypto_stream_xor(m, 0, c, 0, d, n, k);
    for (i = 0; i < 32; i++) m[i] = 0;
    return 0;
  }
  function set25519(r, a) {
    var i;
    for (i = 0; i < 16; i++) r[i] = a[i] | 0;
  }
  function car25519(o) {
    var i,
      v,
      c = 1;
    for (i = 0; i < 16; i++) {
      v = o[i] + c + 65535;
      c = Math.floor(v / 65536);
      o[i] = v - c * 65536;
    }
    o[0] += c - 1 + 37 * (c - 1);
  }
  function sel25519(p, q, b) {
    var t,
      c = ~(b - 1);
    for (var i = 0; i < 16; i++) {
      t = c & (p[i] ^ q[i]);
      p[i] ^= t;
      q[i] ^= t;
    }
  }
  function pack25519(o, n) {
    var i, j, b;
    var m = gf(),
      t = gf();
    for (i = 0; i < 16; i++) t[i] = n[i];
    car25519(t);
    car25519(t);
    car25519(t);
    for (j = 0; j < 2; j++) {
      m[0] = t[0] - 0xffed;
      for (i = 1; i < 15; i++) {
        m[i] = t[i] - 0xffff - (m[i - 1] >> 16 & 1);
        m[i - 1] &= 0xffff;
      }
      m[15] = t[15] - 0x7fff - (m[14] >> 16 & 1);
      b = m[15] >> 16 & 1;
      m[14] &= 0xffff;
      sel25519(t, m, 1 - b);
    }
    for (i = 0; i < 16; i++) {
      o[2 * i] = t[i] & 0xff;
      o[2 * i + 1] = t[i] >> 8;
    }
  }
  function neq25519(a, b) {
    var c = new Uint8Array(32),
      d = new Uint8Array(32);
    pack25519(c, a);
    pack25519(d, b);
    return crypto_verify_32(c, 0, d, 0);
  }
  function par25519(a) {
    var d = new Uint8Array(32);
    pack25519(d, a);
    return d[0] & 1;
  }
  function unpack25519(o, n) {
    var i;
    for (i = 0; i < 16; i++) o[i] = n[2 * i] + (n[2 * i + 1] << 8);
    o[15] &= 0x7fff;
  }
  function A(o, a, b) {
    for (var i = 0; i < 16; i++) o[i] = a[i] + b[i];
  }
  function Z(o, a, b) {
    for (var i = 0; i < 16; i++) o[i] = a[i] - b[i];
  }
  function M(o, a, b) {
    var v,
      c,
      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 = b[0],
      b1 = b[1],
      b2 = b[2],
      b3 = b[3],
      b4 = b[4],
      b5 = b[5],
      b6 = b[6],
      b7 = b[7],
      b8 = b[8],
      b9 = b[9],
      b10 = b[10],
      b11 = b[11],
      b12 = b[12],
      b13 = b[13],
      b14 = b[14],
      b15 = b[15];
    v = a[0];
    t0 += v * b0;
    t1 += v * b1;
    t2 += v * b2;
    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 = a[1];
    t1 += v * b0;
    t2 += v * b1;
    t3 += v * b2;
    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 = a[2];
    t2 += v * b0;
    t3 += v * b1;
    t4 += v * b2;
    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 = a[3];
    t3 += v * b0;
    t4 += v * b1;
    t5 += v * b2;
    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 = a[4];
    t4 += v * b0;
    t5 += v * b1;
    t6 += v * b2;
    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 = a[5];
    t5 += v * b0;
    t6 += v * b1;
    t7 += v * b2;
    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 = a[6];
    t6 += v * b0;
    t7 += v * b1;
    t8 += v * b2;
    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 = a[7];
    t7 += v * b0;
    t8 += v * b1;
    t9 += v * b2;
    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 = a[8];
    t8 += v * b0;
    t9 += v * b1;
    t10 += v * b2;
    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 = a[9];
    t9 += v * b0;
    t10 += v * b1;
    t11 += v * b2;
    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 = a[10];
    t10 += v * b0;
    t11 += v * b1;
    t12 += v * b2;
    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 = a[11];
    t11 += v * b0;
    t12 += v * b1;
    t13 += v * b2;
    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 = a[12];
    t12 += v * b0;
    t13 += v * b1;
    t14 += v * b2;
    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 = a[13];
    t13 += v * b0;
    t14 += v * b1;
    t15 += v * b2;
    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 = a[14];
    t14 += v * b0;
    t15 += v * b1;
    t16 += v * b2;
    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 = a[15];
    t15 += v * b0;
    t16 += v * b1;
    t17 += v * b2;
    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;
    // t15 left as is

    // first car
    c = 1;
    v = t0 + c + 65535;
    c = Math.floor(v / 65536);
    t0 = v - c * 65536;
    v = t1 + c + 65535;
    c = Math.floor(v / 65536);
    t1 = v - c * 65536;
    v = t2 + c + 65535;
    c = Math.floor(v / 65536);
    t2 = v - c * 65536;
    v = t3 + c + 65535;
    c = Math.floor(v / 65536);
    t3 = v - c * 65536;
    v = t4 + c + 65535;
    c = Math.floor(v / 65536);
    t4 = v - c * 65536;
    v = t5 + c + 65535;
    c = Math.floor(v / 65536);
    t5 = v - c * 65536;
    v = t6 + c + 65535;
    c = Math.floor(v / 65536);
    t6 = v - c * 65536;
    v = t7 + c + 65535;
    c = Math.floor(v / 65536);
    t7 = v - c * 65536;
    v = t8 + c + 65535;
    c = Math.floor(v / 65536);
    t8 = v - c * 65536;
    v = t9 + c + 65535;
    c = Math.floor(v / 65536);
    t9 = v - c * 65536;
    v = t10 + c + 65535;
    c = Math.floor(v / 65536);
    t10 = v - c * 65536;
    v = t11 + c + 65535;
    c = Math.floor(v / 65536);
    t11 = v - c * 65536;
    v = t12 + c + 65535;
    c = Math.floor(v / 65536);
    t12 = v - c * 65536;
    v = t13 + c + 65535;
    c = Math.floor(v / 65536);
    t13 = v - c * 65536;
    v = t14 + c + 65535;
    c = Math.floor(v / 65536);
    t14 = v - c * 65536;
    v = t15 + c + 65535;
    c = Math.floor(v / 65536);
    t15 = v - c * 65536;
    t0 += c - 1 + 37 * (c - 1);

    // second car
    c = 1;
    v = t0 + c + 65535;
    c = Math.floor(v / 65536);
    t0 = v - c * 65536;
    v = t1 + c + 65535;
    c = Math.floor(v / 65536);
    t1 = v - c * 65536;
    v = t2 + c + 65535;
    c = Math.floor(v / 65536);
    t2 = v - c * 65536;
    v = t3 + c + 65535;
    c = Math.floor(v / 65536);
    t3 = v - c * 65536;
    v = t4 + c + 65535;
    c = Math.floor(v / 65536);
    t4 = v - c * 65536;
    v = t5 + c + 65535;
    c = Math.floor(v / 65536);
    t5 = v - c * 65536;
    v = t6 + c + 65535;
    c = Math.floor(v / 65536);
    t6 = v - c * 65536;
    v = t7 + c + 65535;
    c = Math.floor(v / 65536);
    t7 = v - c * 65536;
    v = t8 + c + 65535;
    c = Math.floor(v / 65536);
    t8 = v - c * 65536;
    v = t9 + c + 65535;
    c = Math.floor(v / 65536);
    t9 = v - c * 65536;
    v = t10 + c + 65535;
    c = Math.floor(v / 65536);
    t10 = v - c * 65536;
    v = t11 + c + 65535;
    c = Math.floor(v / 65536);
    t11 = v - c * 65536;
    v = t12 + c + 65535;
    c = Math.floor(v / 65536);
    t12 = v - c * 65536;
    v = t13 + c + 65535;
    c = Math.floor(v / 65536);
    t13 = v - c * 65536;
    v = t14 + c + 65535;
    c = Math.floor(v / 65536);
    t14 = v - c * 65536;
    v = t15 + c + 65535;
    c = Math.floor(v / 65536);
    t15 = v - c * 65536;
    t0 += c - 1 + 37 * (c - 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, a) {
    M(o, a, a);
  }
  function inv25519(o, i) {
    var c = gf();
    var a;
    for (a = 0; a < 16; a++) c[a] = i[a];
    for (a = 253; a >= 0; a--) {
      S(c, c);
      if (a !== 2 && a !== 4) M(c, c, i);
    }
    for (a = 0; a < 16; a++) o[a] = c[a];
  }
  function pow2523(o, i) {
    var c = gf();
    var a;
    for (a = 0; a < 16; a++) c[a] = i[a];
    for (a = 250; a >= 0; a--) {
      S(c, c);
      if (a !== 1) M(c, c, i);
    }
    for (a = 0; a < 16; a++) o[a] = c[a];
  }
  function crypto_scalarmult(q, n, p) {
    var z = new Uint8Array(32);
    var x = new Float64Array(80),
      r,
      i;
    var a = gf(),
      b = gf(),
      c = gf(),
      d = gf(),
      e = gf(),
      f = gf();
    for (i = 0; i < 31; i++) z[i] = n[i];
    z[31] = n[31] & 127 | 64;
    z[0] &= 248;
    unpack25519(x, p);
    for (i = 0; i < 16; i++) {
      b[i] = x[i];
      d[i] = a[i] = c[i] = 0;
    }
    a[0] = d[0] = 1;
    for (i = 254; i >= 0; --i) {
      r = z[i >>> 3] >>> (i & 7) & 1;
      sel25519(a, b, r);
      sel25519(c, d, r);
      A(e, a, c);
      Z(a, a, c);
      A(c, b, d);
      Z(b, b, d);
      S(d, e);
      S(f, a);
      M(a, c, a);
      M(c, b, e);
      A(e, a, c);
      Z(a, a, c);
      S(b, a);
      Z(c, d, f);
      M(a, c, _121665);
      A(a, a, d);
      M(c, c, a);
      M(a, d, f);
      M(d, b, x);
      S(b, e);
      sel25519(a, b, r);
      sel25519(c, d, r);
    }
    for (i = 0; i < 16; i++) {
      x[i + 16] = a[i];
      x[i + 32] = c[i];
      x[i + 48] = b[i];
      x[i + 64] = d[i];
    }
    var x32 = x.subarray(32);
    var x16 = x.subarray(16);
    inv25519(x32, x32);
    M(x16, x16, x32);
    pack25519(q, x16);
    return 0;
  }
  function crypto_scalarmult_base(q, n) {
    return crypto_scalarmult(q, 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(c, m, d, n, y, x) {
    var k = new Uint8Array(32);
    crypto_box_beforenm(k, y, x);
    return crypto_box_afternm(c, m, d, n, k);
  }
  function crypto_box_open(m, c, d, n, y, x) {
    var k = new Uint8Array(32);
    crypto_box_beforenm(k, y, x);
    return crypto_box_open_afternm(m, c, d, n, k);
  }
  var K = [0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd, 0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc, 0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019, 0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118, 0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe, 0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2, 0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1, 0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694, 0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3, 0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65, 0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483, 0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5, 0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210, 0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4, 0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725, 0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70, 0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926, 0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df, 0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8, 0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b, 0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001, 0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30, 0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910, 0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8, 0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53, 0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8, 0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb, 0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3, 0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60, 0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec, 0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9, 0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b, 0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207, 0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178, 0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6, 0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b, 0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493, 0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c, 0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a, 0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817];
  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,
      i,
      j,
      h,
      l,
      a,
      b,
      c,
      d;
    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 (i = 0; i < 16; i++) {
        j = 8 * i + pos;
        wh[i] = m[j + 0] << 24 | m[j + 1] << 16 | m[j + 2] << 8 | m[j + 3];
        wl[i] = m[j + 4] << 24 | m[j + 5] << 16 | m[j + 6] << 8 | m[j + 7];
      }
      for (i = 0; i < 80; i++) {
        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;

        // add
        h = ah7;
        l = al7;
        a = l & 0xffff;
        b = l >>> 16;
        c = h & 0xffff;
        d = h >>> 16;

        // Sigma1
        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));
        a += l & 0xffff;
        b += l >>> 16;
        c += h & 0xffff;
        d += h >>> 16;

        // Ch
        h = ah4 & ah5 ^ ~ah4 & ah6;
        l = al4 & al5 ^ ~al4 & al6;
        a += l & 0xffff;
        b += l >>> 16;
        c += h & 0xffff;
        d += h >>> 16;

        // K
        h = K[i * 2];
        l = K[i * 2 + 1];
        a += l & 0xffff;
        b += l >>> 16;
        c += h & 0xffff;
        d += h >>> 16;

        // w
        h = wh[i % 16];
        l = wl[i % 16];
        a += l & 0xffff;
        b += l >>> 16;
        c += h & 0xffff;
        d += h >>> 16;
        b += a >>> 16;
        c += b >>> 16;
        d += c >>> 16;
        th = c & 0xffff | d << 16;
        tl = a & 0xffff | b << 16;

        // add
        h = th;
        l = tl;
        a = l & 0xffff;
        b = l >>> 16;
        c = h & 0xffff;
        d = h >>> 16;

        // Sigma0
        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));
        a += l & 0xffff;
        b += l >>> 16;
        c += h & 0xffff;
        d += h >>> 16;

        // Maj
        h = ah0 & ah1 ^ ah0 & ah2 ^ ah1 & ah2;
        l = al0 & al1 ^ al0 & al2 ^ al1 & al2;
        a += l & 0xffff;
        b += l >>> 16;
        c += h & 0xffff;
        d += h >>> 16;
        b += a >>> 16;
        c += b >>> 16;
        d += c >>> 16;
        bh7 = c & 0xffff | d << 16;
        bl7 = a & 0xffff | b << 16;

        // add
        h = bh3;
        l = bl3;
        a = l & 0xffff;
        b = l >>> 16;
        c = h & 0xffff;
        d = h >>> 16;
        h = th;
        l = tl;
        a += l & 0xffff;
        b += l >>> 16;
        c += h & 0xffff;
        d += h >>> 16;
        b += a >>> 16;
        c += b >>> 16;
        d += c >>> 16;
        bh3 = c & 0xffff | d << 16;
        bl3 = a & 0xffff | b << 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 (i % 16 === 15) {
          for (j = 0; j < 16; j++) {
            // add
            h = wh[j];
            l = wl[j];
            a = l & 0xffff;
            b = l >>> 16;
            c = h & 0xffff;
            d = h >>> 16;
            h = wh[(j + 9) % 16];
            l = wl[(j + 9) % 16];
            a += l & 0xffff;
            b += l >>> 16;
            c += h & 0xffff;
            d += h >>> 16;

            // sigma0
            th = wh[(j + 1) % 16];
            tl = wl[(j + 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);
            a += l & 0xffff;
            b += l >>> 16;
            c += h & 0xffff;
            d += h >>> 16;

            // sigma1
            th = wh[(j + 14) % 16];
            tl = wl[(j + 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);
            a += l & 0xffff;
            b += l >>> 16;
            c += h & 0xffff;
            d += h >>> 16;
            b += a >>> 16;
            c += b >>> 16;
            d += c >>> 16;
            wh[j] = c & 0xffff | d << 16;
            wl[j] = a & 0xffff | b << 16;
          }
        }
      }

      // add
      h = ah0;
      l = al0;
      a = l & 0xffff;
      b = l >>> 16;
      c = h & 0xffff;
      d = h >>> 16;
      h = hh[0];
      l = hl[0];
      a += l & 0xffff;
      b += l >>> 16;
      c += h & 0xffff;
      d += h >>> 16;
      b += a >>> 16;
      c += b >>> 16;
      d += c >>> 16;
      hh[0] = ah0 = c & 0xffff | d << 16;
      hl[0] = al0 = a & 0xffff | b << 16;
      h = ah1;
      l = al1;
      a = l & 0xffff;
      b = l >>> 16;
      c = h & 0xffff;
      d = h >>> 16;
      h = hh[1];
      l = hl[1];
      a += l & 0xffff;
      b += l >>> 16;
      c += h & 0xffff;
      d += h >>> 16;
      b += a >>> 16;
      c += b >>> 16;
      d += c >>> 16;
      hh[1] = ah1 = c & 0xffff | d << 16;
      hl[1] = al1 = a & 0xffff | b << 16;
      h = ah2;
      l = al2;
      a = l & 0xffff;
      b = l >>> 16;
      c = h & 0xffff;
      d = h >>> 16;
      h = hh[2];
      l = hl[2];
      a += l & 0xffff;
      b += l >>> 16;
      c += h & 0xffff;
      d += h >>> 16;
      b += a >>> 16;
      c += b >>> 16;
      d += c >>> 16;
      hh[2] = ah2 = c & 0xffff | d << 16;
      hl[2] = al2 = a & 0xffff | b << 16;
      h = ah3;
      l = al3;
      a = l & 0xffff;
      b = l >>> 16;
      c = h & 0xffff;
      d = h >>> 16;
      h = hh[3];
      l = hl[3];
      a += l & 0xffff;
      b += l >>> 16;
      c += h & 0xffff;
      d += h >>> 16;
      b += a >>> 16;
      c += b >>> 16;
      d += c >>> 16;
      hh[3] = ah3 = c & 0xffff | d << 16;
      hl[3] = al3 = a & 0xffff | b << 16;
      h = ah4;
      l = al4;
      a = l & 0xffff;
      b = l >>> 16;
      c = h & 0xffff;
      d = h >>> 16;
      h = hh[4];
      l = hl[4];
      a += l & 0xffff;
      b += l >>> 16;
      c += h & 0xffff;
      d += h >>> 16;
      b += a >>> 16;
      c += b >>> 16;
      d += c >>> 16;
      hh[4] = ah4 = c & 0xffff | d << 16;
      hl[4] = al4 = a & 0xffff | b << 16;
      h = ah5;
      l = al5;
      a = l & 0xffff;
      b = l >>> 16;
      c = h & 0xffff;
      d = h >>> 16;
      h = hh[5];
      l = hl[5];
      a += l & 0xffff;
      b += l >>> 16;
      c += h & 0xffff;
      d += h >>> 16;
      b += a >>> 16;
      c += b >>> 16;
      d += c >>> 16;
      hh[5] = ah5 = c & 0xffff | d << 16;
      hl[5] = al5 = a & 0xffff | b << 16;
      h = ah6;
      l = al6;
      a = l & 0xffff;
      b = l >>> 16;
      c = h & 0xffff;
      d = h >>> 16;
      h = hh[6];
      l = hl[6];
      a += l & 0xffff;
      b += l >>> 16;
      c += h & 0xffff;
      d += h >>> 16;
      b += a >>> 16;
      c += b >>> 16;
      d += c >>> 16;
      hh[6] = ah6 = c & 0xffff | d << 16;
      hl[6] = al6 = a & 0xffff | b << 16;
      h = ah7;
      l = al7;
      a = l & 0xffff;
      b = l >>> 16;
      c = h & 0xffff;
      d = h >>> 16;
      h = hh[7];
      l = hl[7];
      a += l & 0xffff;
      b += l >>> 16;
      c += h & 0xffff;
      d += h >>> 16;
      b += a >>> 16;
      c += b >>> 16;
      d += c >>> 16;
      hh[7] = ah7 = c & 0xffff | d << 16;
      hl[7] = al7 = a & 0xffff | b << 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),
      i,
      b = n;
    hh[0] = 0x6a09e667;
    hh[1] = 0xbb67ae85;
    hh[2] = 0x3c6ef372;
    hh[3] = 0xa54ff53a;
    hh[4] = 0x510e527f;
    hh[5] = 0x9b05688c;
    hh[6] = 0x1f83d9ab;
    hh[7] = 0x5be0cd19;
    hl[0] = 0xf3bcc908;
    hl[1] = 0x84caa73b;
    hl[2] = 0xfe94f82b;
    hl[3] = 0x5f1d36f1;
    hl[4] = 0xade682d1;
    hl[5] = 0x2b3e6c1f;
    hl[6] = 0xfb41bd6b;
    hl[7] = 0x137e2179;
    crypto_hashblocks_hl(hh, hl, m, n);
    n %= 128;
    for (i = 0; i < n; i++) x[i] = m[b - n + i];
    x[n] = 128;
    n = 256 - 128 * (n < 112 ? 1 : 0);
    x[n - 9] = 0;
    ts64(x, n - 8, b / 0x20000000 | 0, b << 3);
    crypto_hashblocks_hl(hh, hl, x, n);
    for (i = 0; i < 8; i++) ts64(out, 8 * i, hh[i], hl[i]);
    return 0;
  }
  function add(p, q) {
    var a = gf(),
      b = gf(),
      c = gf(),
      d = gf(),
      e = gf(),
      f = gf(),
      g = gf(),
      h = gf(),
      t = gf();
    Z(a, p[1], p[0]);
    Z(t, q[1], q[0]);
    M(a, a, t);
    A(b, p[0], p[1]);
    A(t, q[0], q[1]);
    M(b, b, t);
    M(c, p[3], q[3]);
    M(c, c, D2);
    M(d, p[2], q[2]);
    A(d, d, d);
    Z(e, b, a);
    Z(f, d, c);
    A(g, d, c);
    A(h, b, a);
    M(p[0], e, f);
    M(p[1], h, g);
    M(p[2], g, f);
    M(p[3], e, h);
  }
  function cswap(p, q, b) {
    var i;
    for (i = 0; i < 4; i++) {
      sel25519(p[i], q[i], b);
    }
  }
  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, q, s) {
    var b, i;
    set25519(p[0], gf0);
    set25519(p[1], gf1);
    set25519(p[2], gf1);
    set25519(p[3], gf0);
    for (i = 255; i >= 0; --i) {
      b = s[i / 8 | 0] >> (i & 7) & 1;
      cswap(p, q, b);
      add(q, p);
      add(p, p);
      cswap(p, q, b);
    }
  }
  function scalarbase(p, s) {
    var q = [gf(), gf(), gf(), gf()];
    set25519(q[0], X);
    set25519(q[1], Y);
    set25519(q[2], gf1);
    M(q[3], X, Y);
    scalarmult(p, q, s);
  }
  function crypto_sign_keypair(pk, sk, seeded) {
    var d = new Uint8Array(64);
    var p = [gf(), gf(), gf(), gf()];
    var i;
    if (!seeded) randombytes(sk, 32);
    crypto_hash(d, sk, 32);
    d[0] &= 248;
    d[31] &= 127;
    d[31] |= 64;
    scalarbase(p, d);
    pack(pk, p);
    for (i = 0; i < 32; i++) sk[i + 32] = pk[i];
    return 0;
  }
  var L = new Float64Array([0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x10]);
  function modL(r, x) {
    var carry, i, j, k;
    for (i = 63; i >= 32; --i) {
      carry = 0;
      for (j = i - 32, k = i - 12; j < k; ++j) {
        x[j] += carry - 16 * x[i] * L[j - (i - 32)];
        carry = x[j] + 128 >> 8;
        x[j] -= carry * 256;
      }
      x[j] += carry;
      x[i] = 0;
    }
    carry = 0;
    for (j = 0; j < 32; j++) {
      x[j] += carry - (x[31] >> 4) * L[j];
      carry = x[j] >> 8;
      x[j] &= 255;
    }
    for (j = 0; j < 32; j++) x[j] -= carry * L[j];
    for (i = 0; i < 32; i++) {
      x[i + 1] += x[i] >> 8;
      r[i] = x[i] & 255;
    }
  }
  function reduce(r) {
    var x = new Float64Array(64),
      i;
    for (i = 0; i < 64; i++) x[i] = r[i];
    for (i = 0; i < 64; i++) r[i] = 0;
    modL(r, x);
  }

  // Note: difference from C - smlen returned, not passed as argument.
  function crypto_sign(sm, m, n, sk) {
    var d = new Uint8Array(64),
      h = new Uint8Array(64),
      r = new Uint8Array(64);
    var i,
      j,
      x = new Float64Array(64);
    var p = [gf(), gf(), gf(), gf()];
    crypto_hash(d, sk, 32);
    d[0] &= 248;
    d[31] &= 127;
    d[31] |= 64;
    var smlen = n + 64;
    for (i = 0; i < n; i++) sm[64 + i] = m[i];
    for (i = 0; i < 32; i++) sm[32 + i] = d[32 + i];
    crypto_hash(r, sm.subarray(32), n + 32);
    reduce(r);
    scalarbase(p, r);
    pack(sm, p);
    for (i = 32; i < 64; i++) sm[i] = sk[i];
    crypto_hash(h, sm, n + 64);
    reduce(h);
    for (i = 0; i < 64; i++) x[i] = 0;
    for (i = 0; i < 32; i++) x[i] = r[i];
    for (i = 0; i < 32; i++) {
      for (j = 0; j < 32; j++) {
        x[i + j] += h[i] * d[j];
      }
    }
    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 i, mlen;
    var t = new Uint8Array(32),
      h = new Uint8Array(64);
    var p = [gf(), gf(), gf(), gf()],
      q = [gf(), gf(), gf(), gf()];
    mlen = -1;
    if (n < 64) return -1;
    if (unpackneg(q, pk)) return -1;
    for (i = 0; i < n; i++) m[i] = sm[i];
    for (i = 0; i < 32; i++) m[i + 32] = pk[i];
    crypto_hash(h, m, n);
    reduce(h);
    scalarmult(p, q, h);
    scalarbase(q, sm.subarray(32));
    add(p, q);
    pack(t, p);
    n -= 64;
    if (crypto_verify_32(sm, 0, t, 0)) {
      for (i = 0; i < n; i++) m[i] = 0;
      return -1;
    }
    for (i = 0; i < n; i++) m[i] = sm[i + 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_core_hsalsa20,
    crypto_stream_xor: crypto_stream_xor,
    crypto_stream: crypto_stream,
    crypto_stream_salsa20_xor: crypto_stream_salsa20_xor,
    crypto_stream_salsa20: crypto_stream_salsa20,
    crypto_onetimeauth: crypto_onetimeauth,
    crypto_onetimeauth_verify: crypto_onetimeauth_verify,
    crypto_verify_16: crypto_verify_16,
    crypto_verify_32: crypto_verify_32,
    crypto_secretbox: crypto_secretbox,
    crypto_secretbox_open: crypto_secretbox_open,
    crypto_scalarmult: crypto_scalarmult,
    crypto_scalarmult_base: crypto_scalarmult_base,
    crypto_box_beforenm: crypto_box_beforenm,
    crypto_box_afternm: crypto_box_afternm,
    crypto_box: crypto_box,
    crypto_box_open: crypto_box_open,
    crypto_box_keypair: crypto_box_keypair,
    crypto_hash: crypto_hash,
    crypto_sign: crypto_sign,
    crypto_sign_keypair: crypto_sign_keypair,
    crypto_sign_open: crypto_sign_open,
    crypto_secretbox_KEYBYTES: crypto_secretbox_KEYBYTES,
    crypto_secretbox_NONCEBYTES: crypto_secretbox_NONCEBYTES,
    crypto_secretbox_ZEROBYTES: crypto_secretbox_ZEROBYTES,
    crypto_secretbox_BOXZEROBYTES: crypto_secretbox_BOXZEROBYTES,
    crypto_scalarmult_BYTES: crypto_scalarmult_BYTES,
    crypto_scalarmult_SCALARBYTES: crypto_scalarmult_SCALARBYTES,
    crypto_box_PUBLICKEYBYTES: crypto_box_PUBLICKEYBYTES,
    crypto_box_SECRETKEYBYTES: crypto_box_SECRETKEYBYTES,
    crypto_box_BEFORENMBYTES: crypto_box_BEFORENMBYTES,
    crypto_box_NONCEBYTES: crypto_box_NONCEBYTES,
    crypto_box_ZEROBYTES: crypto_box_ZEROBYTES,
    crypto_box_BOXZEROBYTES: crypto_box_BOXZEROBYTES,
    crypto_sign_BYTES: crypto_sign_BYTES,
    crypto_sign_PUBLICKEYBYTES: crypto_sign_PUBLICKEYBYTES,
    crypto_sign_SECRETKEYBYTES: crypto_sign_SECRETKEYBYTES,
    crypto_sign_SEEDBYTES: crypto_sign_SEEDBYTES,
    crypto_hash_BYTES: crypto_hash_BYTES
  };

  /* High-level API */

  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, i;
    for (i = 0; i < arguments.length; i++) {
      if ((t = Object.prototype.toString.call(arguments[i])) !== '[object Uint8Array]') throw new TypeError('unexpected type ' + t + ', use Uint8Array');
    }
  }
  function cleanup(arr) {
    for (var i = 0; i < arr.length; i++) arr[i] = 0;
  }

  // TODO: Completely remove this in v0.15.
  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 b = new Uint8Array(n);
    randombytes(b, n);
    return b;
  };
  nacl.secretbox = function (msg, nonce, key) {
    checkArrayTypes(msg, nonce, key);
    checkLengths(key, nonce);
    var m = new Uint8Array(crypto_secretbox_ZEROBYTES + msg.length);
    var c = new Uint8Array(m.length);
    for (var i = 0; i < msg.length; i++) m[i + crypto_secretbox_ZEROBYTES] = msg[i];
    crypto_secretbox(c, m, m.length, nonce, key);
    return c.subarray(crypto_secretbox_BOXZEROBYTES);
  };
  nacl.secretbox.open = function (box, nonce, key) {
    checkArrayTypes(box, nonce, key);
    checkLengths(key, nonce);
    var c = new Uint8Array(crypto_secretbox_BOXZEROBYTES + box.length);
    var m = new Uint8Array(c.length);
    for (var i = 0; i < box.length; i++) c[i + crypto_secretbox_BOXZEROBYTES] = box[i];
    if (c.length < 32) return false;
    if (crypto_secretbox_open(m, c, c.length, nonce, key) !== 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 q = new Uint8Array(crypto_scalarmult_BYTES);
    crypto_scalarmult(q, n, p);
    return q;
  };
  nacl.scalarMult.base = function (n) {
    checkArrayTypes(n);
    if (n.length !== crypto_scalarmult_SCALARBYTES) throw new Error('bad n size');
    var q = new Uint8Array(crypto_scalarmult_BYTES);
    crypto_scalarmult_base(q, n);
    return q;
  };
  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 i = 0; i < m.length; i++) m[i] = tmp[i];
    return m;
  };
  nacl.sign.detached = function (msg, secretKey) {
    var signedMsg = nacl.sign(msg, secretKey);
    var sig = new Uint8Array(crypto_sign_BYTES);
    for (var i = 0; i < sig.length; i++) sig[i] = signedMsg[i];
    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 i;
    for (i = 0; i < crypto_sign_BYTES; i++) sm[i] = sig[i];
    for (i = 0; i < msg.length; i++) sm[i + crypto_sign_BYTES] = msg[i];
    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 i = 0; i < pk.length; i++) pk[i] = secretKey[32 + i];
    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 i = 0; i < 32; i++) sk[i] = seed[i];
    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);
    // Zero length arguments are considered not equal.
    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 () {
    // Initialize PRNG if environment provides CSPRNG.
    // If not, methods calling randombytes will throw.
    var crypto = typeof self !== 'undefined' ? self.crypto || self.msCrypto : null;
    if (crypto && crypto.getRandomValues) {
      // Browsers.
      var QUOTA = 65536;
      nacl.setPRNG(function (x, n) {
        var i,
          v = new Uint8Array(n);
        for (i = 0; i < n; i += QUOTA) {
          crypto.getRandomValues(v.subarray(i, i + Math.min(n - i, QUOTA)));
        }
        for (i = 0; i < n; i++) x[i] = v[i];
        cleanup(v);
      });
    } else if (true) {
      // Node.js.
      crypto = __webpack_require__(/*! crypto */ 6113);
      if (crypto && crypto.randomBytes) {
        nacl.setPRNG(function (x, n) {
          var i,
            v = crypto.randomBytes(n);
          for (i = 0; i < n; i++) x[i] = v[i];
          cleanup(v);
        });
      }
    }
  })();
})( true && module.exports ? module.exports : self.nacl = self.nacl || {});

/***/ }),

/***/ 341:
/*!***************************************!*\
  !*** ./node_modules/wrappy/wrappy.js ***!
  \***************************************/
/***/ ((module) => {

// Returns a wrapper function that returns a wrapped callback
// The wrapper function should do some stuff, and return a
// presumably different callback function.
// This makes sure that own properties are retained, so that
// decorations and such are not lost along the way.
module.exports = wrappy;
function wrappy(fn, cb) {
  if (fn && cb) return wrappy(fn)(cb);
  if (typeof fn !== 'function') throw new TypeError('need wrapper function');
  Object.keys(fn).forEach(function (k) {
    wrapper[k] = fn[k];
  });
  return wrapper;
  function wrapper() {
    var args = new Array(arguments.length);
    for (var i = 0; i < args.length; i++) {
      args[i] = arguments[i];
    }
    var ret = fn.apply(this, args);
    var cb = args[args.length - 1];
    if (typeof ret === 'function' && ret !== cb) {
      Object.keys(cb).forEach(function (k) {
        ret[k] = cb[k];
      });
    }
    return ret;
  }
}

/***/ }),

/***/ 9576:
/*!**************************************************************************************************************************************************************!*\
  !*** ../node_modules/css-loader/dist/cjs.js!../node_modules/sass-loader/dist/cjs.js!./src/components/keyboardInteractiveAuthPanel.component.scss?ngResource ***!
  \**************************************************************************************************************************************************************/
/***/ ((module, __webpack_exports__, __webpack_require__) => {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../node_modules/css-loader/dist/runtime/sourceMaps.js */ 230);
/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../node_modules/css-loader/dist/runtime/api.js */ 7529);
/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__);
// Imports


var ___CSS_LOADER_EXPORT___ = _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default()));
// Module
___CSS_LOADER_EXPORT___.push([module.id, ":host{display:flex;flex-direction:column;padding:15px 20px}.prompt-text{white-space:pre-wrap}", "",{"version":3,"sources":["webpack://./src/components/keyboardInteractiveAuthPanel.component.scss"],"names":[],"mappings":"AAAA,MACI,YAAA,CACA,qBAAA,CACA,iBAAA,CAGJ,aACI,oBAAA","sourcesContent":[":host {\r\n    display: flex;\r\n    flex-direction: column;\r\n    padding: 15px 20px;\r\n}\r\n\r\n.prompt-text {\r\n    white-space: pre-wrap;\r\n}\r\n"],"sourceRoot":""}]);
// Exports
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___);


/***/ }),

/***/ 7543:
/*!*******************************************************************************************************************************************!*\
  !*** ../node_modules/css-loader/dist/cjs.js!../node_modules/sass-loader/dist/cjs.js!./src/components/sftpPanel.component.scss?ngResource ***!
  \*******************************************************************************************************************************************/
/***/ ((module, __webpack_exports__, __webpack_require__) => {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../node_modules/css-loader/dist/runtime/sourceMaps.js */ 230);
/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../node_modules/css-loader/dist/runtime/api.js */ 7529);
/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__);
// Imports


var ___CSS_LOADER_EXPORT___ = _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default()));
// Module
___CSS_LOADER_EXPORT___.push([module.id, ":host{display:flex;flex-direction:column}:host>.header{padding:5px 15px 0 20px;display:flex;align-items:center;flex:none}:host>.body{padding:10px 20px;flex:1 1 0;overflow-y:auto}:host .breadcrumb{background:none;padding:0;margin:0}:host .breadcrumb-item{cursor:pointer}:host .breadcrumb-item:first-child{font-weight:bold}:host .mode,:host .size,:host .date{font-family:monospace;opacity:.5;font-size:12px;text-align:right;margin-left:20px}:host .size{width:100px}:host .date{width:200px}.btn-link svg{width:12px}", "",{"version":3,"sources":["webpack://./src/components/sftpPanel.component.scss"],"names":[],"mappings":"AAAA,MACI,YAAA,CACA,qBAAA,CAEA,cACI,uBAAA,CACA,YAAA,CACA,kBAAA,CACA,SAAA,CAGJ,YACI,iBAAA,CACA,UAAA,CACA,eAAA,CAGJ,kBACI,eAAA,CACA,SAAA,CACA,QAAA,CAGJ,uBACI,cAAA,CAGJ,mCACI,gBAAA,CAGJ,oCACI,qBAAA,CACA,UAAA,CACA,cAAA,CACA,gBAAA,CACA,gBAAA,CAGJ,YACI,WAAA,CAGJ,YACI,WAAA,CAIR,cACI,UAAA","sourcesContent":[":host {\r\n    display: flex;\r\n    flex-direction: column;\r\n\r\n    > .header {\r\n        padding: 5px 15px 0 20px;\r\n        display: flex;\r\n        align-items: center;\r\n        flex: none;\r\n    }\r\n\r\n    > .body {\r\n        padding: 10px 20px;\r\n        flex: 1 1 0;\r\n        overflow-y: auto;\r\n    }\r\n\r\n    .breadcrumb {\r\n        background: none;\r\n        padding: 0;\r\n        margin: 0;\r\n    }\r\n\r\n    .breadcrumb-item {\r\n        cursor: pointer;\r\n    }\r\n\r\n    .breadcrumb-item:first-child {\r\n        font-weight: bold;\r\n    }\r\n\r\n    .mode, .size, .date {\r\n        font-family: monospace;\r\n        opacity: .5;\r\n        font-size: 12px;\r\n        text-align: right;\r\n        margin-left: 20px;\r\n    }\r\n\r\n    .size {\r\n        width: 100px;\r\n    }\r\n\r\n    .date {\r\n        width: 200px;\r\n    }\r\n}\r\n\r\n.btn-link svg {\r\n    width: 12px;\r\n}\r\n"],"sourceRoot":""}]);
// Exports
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___);


/***/ }),

/***/ 9886:
/*!*****************************************************************************************************************************!*\
  !*** ../node_modules/css-loader/dist/cjs.js!../node_modules/sass-loader/dist/cjs.js!./src/components/sshTab.component.scss ***!
  \*****************************************************************************************************************************/
/***/ ((module, __webpack_exports__, __webpack_require__) => {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../node_modules/css-loader/dist/runtime/sourceMaps.js */ 230);
/* harmony import */ var _node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../../node_modules/css-loader/dist/runtime/api.js */ 7529);
/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__);
// Imports


var ___CSS_LOADER_EXPORT___ = _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default()));
// Module
___CSS_LOADER_EXPORT___.push([module.id, "sftp-panel{position:absolute;height:80%;width:100%;bottom:0;z-index:5}", "",{"version":3,"sources":["webpack://./src/components/sshTab.component.scss"],"names":[],"mappings":"AAAA,WACI,iBAAA,CACA,UAAA,CACA,UAAA,CACA,QAAA,CACA,SAAA","sourcesContent":["sftp-panel {\r\n    position: absolute;\r\n    height: 80%;\r\n    width: 100%;\r\n    bottom: 0;\r\n    z-index: 5;\r\n}\r\n"],"sourceRoot":""}]);
// Exports
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___);


/***/ }),

/***/ 7852:
/*!************************************************************************************************************************************!*\
  !*** ../node_modules/pug-loader/index.js??ruleSet[1].rules[3].use[1]!./src/components/hostKeyPromptModal.component.pug?ngResource ***!
  \************************************************************************************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var pug = __webpack_require__(/*! !../../../node_modules/pug-runtime/index.js */ 9757);

function template(locals) {var pug_html = "", pug_mixins = {}, pug_interp;var pug_indent = [];
pug_html = pug_html + "\n\u003Cdiv class=\"modal-header\"\u003E\n  \u003Ch3 class=\"m-0\" translate\u003EHost key verification\u003C\u002Fh3\u003E\n\u003C\u002Fdiv\u003E\n\u003Cdiv class=\"modal-body pt-0\"\u003E\n  \u003Cdiv class=\"alert alert-danger\" *ngIf=\"isMismatched\"\u003E\u003Cstrong translate\u003EWarning: remote host's key has suddenly changed!\u003C\u002Fstrong\u003E\n    \u003Cdiv translate\u003EYou could be under a man-in-the-middle attack right now, or the host key could have just been changed.\u003C\u002Fdiv\u003E\n  \u003C\u002Fdiv\u003E\n  \u003Cdiv class=\"mb-3\" *ngIf=\"isMismatched\"\u003E\n    \u003Cdiv class=\"d-flex align-items-center\"\u003E\n      \u003Clabel translate\u003ELast known host key fingerprint\u003C\u002Flabel\u003E\n      \u003Cdiv class=\"badge text-bg-danger ms-auto\"\u003E{{ selector.type }}\u003C\u002Fdiv\u003E\n    \u003C\u002Fdiv\u003E\u003Ccode\u003E{{knownHost?.digest}}\u003C\u002Fcode\u003E\n  \u003C\u002Fdiv\u003E\n  \u003Cdiv class=\"mb-3\"\u003E\n    \u003Cdiv class=\"d-flex align-items-center\"\u003E\n      \u003Clabel translate\u003ECurrent host key fingerprint\u003C\u002Flabel\u003E\n      \u003Cdiv class=\"badge text-bg-success ms-auto\"\u003E{{ selector.type }}\u003C\u002Fdiv\u003E\n    \u003C\u002Fdiv\u003E\u003Ccode\u003E{{digest}}\u003C\u002Fcode\u003E\n  \u003C\u002Fdiv\u003E\n\u003C\u002Fdiv\u003E\n\u003Cdiv class=\"modal-footer\"\u003E\n  \u003Cdiv class=\"w-100\"\u003E\n    \u003Cbutton class=\"d-block w-100 mb-3 btn btn-primary\" (click)=\"acceptAndSave()\" [class.btn-danger]=\"isMismatched\" translate\u003EAccept and remember key\u003C\u002Fbutton\u003E\n    \u003Cbutton class=\"d-block w-100 mb-3 btn btn-secondary\" (click)=\"accept()\" [class.btn-warning]=\"isMismatched\" translate\u003EAccept just this once\u003C\u002Fbutton\u003E\n    \u003Cbutton class=\"d-block w-100 btn btn-secondary\" [class.btn-danger]=\"!isMismatched\" (click)=\"cancel()\" translate\u003EDisconnect\u003C\u002Fbutton\u003E\n  \u003C\u002Fdiv\u003E\n\u003C\u002Fdiv\u003E";;return pug_html;};
module.exports = template;

/***/ }),

/***/ 1003:
/*!**********************************************************************************************************************************************!*\
  !*** ../node_modules/pug-loader/index.js??ruleSet[1].rules[3].use[1]!./src/components/keyboardInteractiveAuthPanel.component.pug?ngResource ***!
  \**********************************************************************************************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var pug = __webpack_require__(/*! !../../../node_modules/pug-runtime/index.js */ 9757);

function template(locals) {var pug_html = "", pug_mixins = {}, pug_interp;var pug_indent = [];
pug_html = pug_html + "\n\u003Cdiv class=\"d-flex\"\u003E\u003Cstrong translate\u003EKeyboard-interactive auth\u003C\u002Fstrong\u003E\n  \u003Cdiv class=\"ms-2\"\u003E{{prompt.name}}\u003C\u002Fdiv\u003E\n\u003C\u002Fdiv\u003E\n\u003Cdiv class=\"prompt-text\"\u003E{{prompt.prompts[step].prompt}}\u003C\u002Fdiv\u003E\n\u003Cinput class=\"form-control mt-2\" #input autofocus [type]=\"isPassword() ? &quot;password&quot;: &quot;text&quot;\" placeholder=\"Response\" (keyup.enter)=\"next()\" [(ngModel)]=\"prompt.responses[step]\"\u003E\n\u003Cdiv class=\"d-flex mt-3\"\u003E\n  \u003Cbutton class=\"btn btn-secondary\" *ngIf=\"step &gt; 0\" (click)=\"previous()\"\u003E\u003C\u002Fbutton\u003E\n  \u003Cdiv class=\"ms-auto\"\u003E\u003C\u002Fdiv\u003E\n  \u003Cbutton class=\"btn btn-primary\" (click)=\"next()\"\u003E\u003Cspan *ngIf=\"step &lt; prompt.prompts.length - 1\"\u003ENext\u003C\u002Fspan\u003E\u003Cspan *ngIf=\"step == prompt.prompts.length - 1\"\u003EFinish\u003C\u002Fspan\u003E\u003C\u002Fbutton\u003E\n\u003C\u002Fdiv\u003E";;return pug_html;};
module.exports = template;

/***/ }),

/***/ 3516:
/*!******************************************************************************************************************************************!*\
  !*** ../node_modules/pug-loader/index.js??ruleSet[1].rules[3].use[1]!./src/components/sftpCreateDirectoryModal.component.pug?ngResource ***!
  \******************************************************************************************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var pug = __webpack_require__(/*! !../../../node_modules/pug-runtime/index.js */ 9757);

function template(locals) {var pug_html = "", pug_mixins = {}, pug_interp;var pug_indent = [];
pug_html = pug_html + "\n\u003Cdiv class=\"modal-body\"\u003E\n  \u003Clabel translate\u003EName for the new directory\u003C\u002Flabel\u003E\n  \u003Cdiv class=\"mb-3 w-100 me-2\"\u003E\n    \u003Cinput class=\"form-control\" type=\"text\" [(ngModel)]=\"directoryName\"\u003E\n  \u003C\u002Fdiv\u003E\n\u003C\u002Fdiv\u003E\n\u003Cdiv class=\"modal-footer\"\u003E\n  \u003Cbutton class=\"btn btn-success\" (click)=\"create()\" translate\u003ECreate\u003C\u002Fbutton\u003E\n  \u003Cbutton class=\"btn btn-danger\" (click)=\"cancel()\" translate\u003ECancel\u003C\u002Fbutton\u003E\n\u003C\u002Fdiv\u003E";;return pug_html;};
module.exports = template;

/***/ }),

/***/ 883:
/*!*********************************************************************************************************************************!*\
  !*** ../node_modules/pug-loader/index.js??ruleSet[1].rules[3].use[1]!./src/components/sftpDeleteModal.component.pug?ngResource ***!
  \*********************************************************************************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var pug = __webpack_require__(/*! !../../../node_modules/pug-runtime/index.js */ 9757);

function template(locals) {var pug_html = "", pug_mixins = {}, pug_interp;var pug_indent = [];
pug_html = pug_html + "\n\u003Cdiv class=\"modal-body\"\u003E\n  \u003Clabel translate\u003EDeleting\u003C\u002Flabel\u003E\n  \u003Cdiv class=\"no-wrap\"\u003E{{progressMessage}}\u003C\u002Fdiv\u003E\n\u003C\u002Fdiv\u003E\n\u003Cdiv class=\"modal-footer\"\u003E\n  \u003Cbutton class=\"btn btn-danger\" (click)=\"cancel()\" translate\u003ECancel\u003C\u002Fbutton\u003E\n\u003C\u002Fdiv\u003E";;return pug_html;};
module.exports = template;

/***/ }),

/***/ 3576:
/*!***************************************************************************************************************************!*\
  !*** ../node_modules/pug-loader/index.js??ruleSet[1].rules[3].use[1]!./src/components/sftpPanel.component.pug?ngResource ***!
  \***************************************************************************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var pug = __webpack_require__(/*! !../../../node_modules/pug-runtime/index.js */ 9757);

function template(locals) {var pug_html = "", pug_mixins = {}, pug_interp;var pug_indent = [];
pug_html = pug_html + "\n\u003Cdiv class=\"header\"\u003E\n  \u003Cinput class=\"form-control flex-grow-1 w-0\" *ngIf=\"editingPath !== null\" type=\"text\" autofocus (keydown.enter)=\"confirmPath()\" (keydown.esc)=\"editingPath = null\" (blur)=\"editingPath = null\" [(ngModel)]=\"editingPath\"\u003E\n  \u003Cdiv class=\"breadcrumb\" *ngIf=\"editingPath === null\" (dblclick)=\"editPath()\"\u003E\u003Ca class=\"breadcrumb-item text-decoration-none\" (click)=\"navigate(&quot;\u002F&quot;)\"\u003ESFTP\u003C\u002Fa\u003E\u003Ca class=\"breadcrumb-item text-decoration-none\" *ngFor=\"let segment of pathSegments\" (click)=\"navigate(segment.path)\"\u003E{{segment.name}}\u003C\u002Fa\u003E\u003C\u002Fdiv\u003E\n  \u003Cdiv class=\"breadcrumb-spacer flex-grow-1 h-100\" (dblclick)=\"editPath()\"\u003E\u003C\u002Fdiv\u003E\n  \u003Cbutton class=\"btn btn-link btn-sm flex-shrink-0 d-flex\" (click)=\"openCreateDirectoryModal()\"\u003E\u003Ci class=\"fas fa-plus me-1\"\u003E\u003C\u002Fi\u003E\n    \u003Cdiv translate\u003ECreate directory\u003C\u002Fdiv\u003E\n  \u003C\u002Fbutton\u003E\n  \u003Cbutton class=\"btn btn-link btn-sm flex-shrink-0 d-flex\" (click)=\"upload()\"\u003E\u003Ci class=\"fas fa-upload me-1\"\u003E\u003C\u002Fi\u003E\n    \u003Cdiv translate\u003EUpload\u003C\u002Fdiv\u003E\n  \u003C\u002Fbutton\u003E\n  \u003Cbutton class=\"btn btn-link text-decoration-none\" (click)=\"close()\"\u003E" + (null == (pug_interp = __webpack_require__(/*! ../../../tabby-core/src/icons/times.svg */ 2024)) ? "" : pug_interp) + "\u003C\u002Fbutton\u003E\n\u003C\u002Fdiv\u003E\n\u003Cdiv class=\"body\" dropZone (transfer)=\"uploadOne($event)\"\u003E\u003Ca class=\"alert alert-info d-flex align-items-center\" *ngIf=\"shouldShowCWDTip &amp;&amp; !cwdDetectionAvailable\" (click)=\"platform.openExternal(&quot;https:\u002F\u002Ftabby.sh\u002Fgo\u002Fcwd-detection&quot;)\"\u003E\n    \u003Cdiv class=\"me-auto\"\u003E\u003Cstrong translate\u003EWorking directory detection\u003C\u002Fstrong\u003E\n      \u003Cdiv translate\u003ELearn how to allow Tabby to detect remote shell's working directory.\u003C\u002Fdiv\u003E\n    \u003C\u002Fdiv\u003E\n    \u003Cbutton class=\"close\" (click)=\"dismissCWDTip()\"\u003E\u003Ci class=\"fas fa-close\"\u003E\u003C\u002Fi\u003E\u003C\u002Fbutton\u003E\u003C\u002Fa\u003E\n  \u003Cdiv *ngIf=\"!sftp\" translate\u003EConnecting\u003C\u002Fdiv\u003E\n  \u003Cdiv *ngIf=\"sftp\"\u003E\n    \u003Cdiv *ngIf=\"fileList === null\" translate\u003ELoading\u003C\u002Fdiv\u003E\n    \u003Cdiv class=\"list-group list-group-light\" *ngIf=\"fileList !== null\"\u003E\n      \u003Cdiv class=\"list-group-item list-group-item-action d-flex align-items-center\" *ngIf=\"path !== &quot;\u002F&quot;\" (click)=\"goUp()\"\u003E\u003Ci class=\"fas fa-fw fa-level-up-alt\"\u003E\u003C\u002Fi\u003E\n        \u003Cdiv translate\u003EGo up\u003C\u002Fdiv\u003E\n      \u003C\u002Fdiv\u003E\n      \u003Cdiv class=\"list-group-item list-group-item-action d-flex align-items-center\" *ngFor=\"let item of fileList\" (contextmenu)=\"showContextMenu(item, $event)\" (click)=\"open(item)\"\u003E\u003Ci class=\"fa-fw\" [class]=\"getIcon(item)\"\u003E\u003C\u002Fi\u003E\n        \u003Cdiv\u003E{{item.name}}\u003C\u002Fdiv\u003E\n        \u003Cdiv class=\"me-auto\"\u003E\u003C\u002Fdiv\u003E\n        \u003Cdiv class=\"size\" *ngIf=\"!item.isDirectory\"\u003E{{item.size|filesize}}\u003C\u002Fdiv\u003E\n        \u003Cdiv class=\"date\"\u003E{{item.modified|date:'medium'}}\u003C\u002Fdiv\u003E\n        \u003Cdiv class=\"mode\"\u003E{{getModeString(item)}}\u003C\u002Fdiv\u003E\n      \u003C\u002Fdiv\u003E\n    \u003C\u002Fdiv\u003E\n  \u003C\u002Fdiv\u003E\n\u003C\u002Fdiv\u003E";;return pug_html;};
module.exports = template;

/***/ }),

/***/ 7083:
/*!*****************************************************************************************************************************************!*\
  !*** ../node_modules/pug-loader/index.js??ruleSet[1].rules[3].use[1]!./src/components/sshPortForwardingConfig.component.pug?ngResource ***!
  \*****************************************************************************************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var pug = __webpack_require__(/*! !../../../node_modules/pug-runtime/index.js */ 9757);

function template(locals) {var pug_html = "", pug_mixins = {}, pug_interp;var pug_indent = [];
pug_html = pug_html + "\n\u003Cdiv class=\"list-group mb-3\"\u003E\n  \u003Cdiv class=\"list-group-item d-flex align-items-center\" *ngFor=\"let fw of model\"\u003E\n    \u003Cdiv\u003E\n      \u003Cdiv class=\"d-flex align-items-center\"\u003E\u003Cstrong *ngIf=\"fw.type === PortForwardType.Local\" translate\u003ELocal\u003C\u002Fstrong\u003E\u003Cstrong *ngIf=\"fw.type === PortForwardType.Remote\" translate\u003ERemote\u003C\u002Fstrong\u003E\u003Cstrong *ngIf=\"fw.type === PortForwardType.Dynamic\" translate translateContext=\"[Dynamic] port forwarding\"\u003Eid.port-forwarding.dynamic\u003C\u002Fstrong\u003E\n        \u003Cdiv class=\"ms-3\"\u003E{{fw.host}}:{{fw.port}}\u003C\u002Fdiv\u003E\n        \u003Cdiv class=\"ms-2\"\u003E&rarr;\u003C\u002Fdiv\u003E\n        \u003Cdiv class=\"ms-2\" *ngIf=\"fw.type !== PortForwardType.Dynamic\"\u003E{{fw.targetAddress}}:{{fw.targetPort}}\u003C\u002Fdiv\u003E\n        \u003Cdiv class=\"ms-2\" *ngIf=\"fw.type === PortForwardType.Dynamic\" translate\u003ESOCKS proxy\u003C\u002Fdiv\u003E\n      \u003C\u002Fdiv\u003E\n      \u003Cdiv\u003E{{fw.description}}\u003C\u002Fdiv\u003E\n    \u003C\u002Fdiv\u003E\n    \u003Cbutton class=\"btn btn-link hover-reveal ms-auto\" (click)=\"remove(fw)\"\u003E\u003Ci class=\"fas fa-trash-alt\"\u003E\u003C\u002Fi\u003E\u003C\u002Fbutton\u003E\n  \u003C\u002Fdiv\u003E\n\u003C\u002Fdiv\u003E\n\u003Ch5 translate\u003EAdd a port forward\u003C\u002Fh5\u003E\n\u003Cdiv class=\"input-group mb-2\" *ngIf=\"newForward.type === PortForwardType.Dynamic\"\u003E\n  \u003Cinput class=\"form-control\" type=\"text\" [(ngModel)]=\"newForward.host\"\u003E\n  \u003Cdiv class=\"input-group-text\"\u003E:\u003C\u002Fdiv\u003E\n  \u003Cinput class=\"form-control\" type=\"number\" [(ngModel)]=\"newForward.port\"\u003E\n  \u003Cdiv class=\"input-group-text\"\u003E&rarr;\u003C\u002Fdiv\u003E\n  \u003Cdiv class=\"input-group-text\" style=\"flex: 3 1 0\" translate\u003ESOCKS proxy\u003C\u002Fdiv\u003E\n\u003C\u002Fdiv\u003E\n\u003Cdiv class=\"input-group mb-2\" *ngIf=\"newForward.type !== PortForwardType.Dynamic\"\u003E\n  \u003Cinput class=\"form-control\" type=\"text\" [(ngModel)]=\"newForward.host\"\u003E\n  \u003Cdiv class=\"input-group-text\"\u003E:\u003C\u002Fdiv\u003E\n  \u003Cinput class=\"form-control\" type=\"number\" [(ngModel)]=\"newForward.port\"\u003E\n  \u003Cdiv class=\"input-group-text\"\u003E&rarr;\u003C\u002Fdiv\u003E\n  \u003Cinput class=\"form-control\" type=\"text\" [(ngModel)]=\"newForward.targetAddress\"\u003E\n  \u003Cdiv class=\"input-group-text\"\u003E:\u003C\u002Fdiv\u003E\n  \u003Cinput class=\"form-control\" type=\"number\" [(ngModel)]=\"newForward.targetPort\"\u003E\n\u003C\u002Fdiv\u003E\n\u003Cdiv class=\"input-group mb-2\"\u003E\n  \u003Cinput class=\"form-control\" type=\"text\" [placeholder]=\"&quot;Description&quot;|translate\" [(ngModel)]=\"newForward.description\"\u003E\n\u003C\u002Fdiv\u003E\n\u003Cdiv class=\"d-flex\"\u003E\n  \u003Cdiv class=\"btn-group me-auto\"\u003E\n    \u003Cinput class=\"btn-check\" type=\"radio\" [(ngModel)]=\"newForward.type\" id=\"newForwardTypeLocal\" name=\"newForwardType\" [value]=\"PortForwardType.Local\"\u003E\n    \u003Clabel class=\"btn btn-secondary m-0\" for=\"newForwardTypeLocal\" translate\u003ELocal\u003C\u002Flabel\u003E\n    \u003Cinput class=\"btn-check\" type=\"radio\" [(ngModel)]=\"newForward.type\" id=\"newForwardTypeRemote\" name=\"newForwardType\" [value]=\"PortForwardType.Remote\"\u003E\n    \u003Clabel class=\"btn btn-secondary m-0\" for=\"newForwardTypeRemote\" translate\u003ERemote\u003C\u002Flabel\u003E\n    \u003Cinput class=\"btn-check\" type=\"radio\" [(ngModel)]=\"newForward.type\" id=\"newForwardTypeDynamic\" name=\"newForwardType\" [value]=\"PortForwardType.Dynamic\"\u003E\n    \u003Clabel class=\"btn btn-secondary m-0\" for=\"newForwardTypeDynamic\" translate translateContext=\"[Dynamic] port forwarding\"\u003Eid.port-forwarding.dynamic\u003C\u002Flabel\u003E\n  \u003C\u002Fdiv\u003E\n  \u003Cbutton class=\"btn btn-primary\" (click)=\"addForward()\"\u003E\u003Ci class=\"fas fa-check me-2\"\u003E\u003C\u002Fi\u003E\u003Cspan translate\u003EForward port\u003C\u002Fspan\u003E\u003C\u002Fbutton\u003E\n\u003C\u002Fdiv\u003E";;return pug_html;};
module.exports = template;

/***/ }),

/***/ 9040:
/*!****************************************************************************************************************************************!*\
  !*** ../node_modules/pug-loader/index.js??ruleSet[1].rules[3].use[1]!./src/components/sshPortForwardingModal.component.pug?ngResource ***!
  \****************************************************************************************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var pug = __webpack_require__(/*! !../../../node_modules/pug-runtime/index.js */ 9757);

function template(locals) {var pug_html = "", pug_mixins = {}, pug_interp;var pug_indent = [];
pug_html = pug_html + "\n\u003Cdiv class=\"modal-header\" *ngIf=\"session.forwardedPorts.length\"\u003E\n  \u003Ch5 class=\"m-0\" translate\u003EForwarded ports\u003C\u002Fh5\u003E\n\u003C\u002Fdiv\u003E\n\u003Cdiv class=\"modal-body pt-0\"\u003E\n  \u003Cssh-port-forwarding-config [model]=\"session.forwardedPorts\" (forwardAdded)=\"onForwardAdded($event)\" (forwardRemoved)=\"onForwardRemoved($event)\"\u003E\u003C\u002Fssh-port-forwarding-config\u003E\n\u003C\u002Fdiv\u003E";;return pug_html;};
module.exports = template;

/***/ }),

/***/ 3660:
/*!************************************************************************************************************************************!*\
  !*** ../node_modules/pug-loader/index.js??ruleSet[1].rules[3].use[1]!./src/components/sshProfileSettings.component.pug?ngResource ***!
  \************************************************************************************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var pug = __webpack_require__(/*! !../../../node_modules/pug-runtime/index.js */ 9757);

function template(locals) {var pug_html = "", pug_mixins = {}, pug_interp;;
    var locals_for_with = (locals || {});
    
    (function (value) {
      var pug_indent = [];
pug_html = pug_html + "\n\u003Cul class=\"nav-tabs\" ngbNav #nav=\"ngbNav\"\u003E\n  \u003Cli ngbNavItem\u003E\u003Ca ngbNavLink translate\u003EGeneral\u003C\u002Fa\u003E\n    \u003Cng-template ngbNavContent\u003E\n      \u003Cdiv class=\"d-flex w-100 mt-3\"\u003E\n        \u003Cdiv class=\"mb-3 me-2\" ngbDropdown\u003E\n          \u003Clabel translate\u003EConnection\u003C\u002Flabel\u003E\n          \u003Cbutton class=\"btn btn-secondary d-block\" ngbDropdownToggle\u003E{{getConnectionDropdownTitle()}}\u003C\u002Fbutton\u003E\n          \u003Cdiv ngbDropdownMenu\u003E\n            \u003Cbutton class=\"dropdown-item\" (click)=\"connectionMode = &quot;direct&quot;\" translate\u003EDirect\u003C\u002Fbutton\u003E\n            \u003Cbutton class=\"dropdown-item\" *ngIf=\"hostApp.platform !== Platform.Web\" (click)=\"connectionMode = &quot;proxyCommand&quot;\"\u003E\n              \u003Cdiv\u003EProxy command\u003C\u002Fdiv\u003E\n              \u003Cdiv class=\"text-muted\" translate\u003ECommand's stdin\u002Fstdout is used instead of a network connection\u003C\u002Fdiv\u003E\n            \u003C\u002Fbutton\u003E\n            \u003Cbutton class=\"dropdown-item\" (click)=\"connectionMode = &quot;jumpHost&quot;\"\u003E\n              \u003Cdiv translate\u003EJump host\u003C\u002Fdiv\u003E\n              \u003Cdiv class=\"text-muted\" translate\u003EConnect to a different host first and use it as a proxy\u003C\u002Fdiv\u003E\n            \u003C\u002Fbutton\u003E\n            \u003Cbutton class=\"dropdown-item\" (click)=\"connectionMode = &quot;socksProxy&quot;\"\u003E\n              \u003Cdiv translate\u003ESOCKS proxy\u003C\u002Fdiv\u003E\n              \u003Cdiv class=\"text-muted\" translate\u003EConnect through a proxy server\u003C\u002Fdiv\u003E\n            \u003C\u002Fbutton\u003E\n            \u003Cbutton class=\"dropdown-item\" (click)=\"connectionMode = &quot;httpProxy&quot;\"\u003E\n              \u003Cdiv translate\u003EHTTP proxy\u003C\u002Fdiv\u003E\n              \u003Cdiv class=\"text-muted\" translate\u003EUsing CONNECT method\u003C\u002Fdiv\u003E\n            \u003C\u002Fbutton\u003E\n          \u003C\u002Fdiv\u003E\n        \u003C\u002Fdiv\u003E\n        \u003Cdiv class=\"mb-3 w-100\" *ngIf=\"connectionMode === &quot;proxyCommand&quot;\"\u003E\n          \u003Clabel translate\u003EProxy command\u003C\u002Flabel\u003E\n          \u003Cinput class=\"form-control\" type=\"text\" [(ngModel)]=\"profile.options.proxyCommand\"\u003E\n        \u003C\u002Fdiv\u003E\n        \u003Cdiv class=\"mb-3 w-100 me-2\" *ngIf=\"connectionMode !== &quot;proxyCommand&quot;\"\u003E\n          \u003Clabel translate\u003EHost\u003C\u002Flabel\u003E\n          \u003Cinput class=\"form-control\" type=\"text\" [(ngModel)]=\"profile.options.host\"\u003E\n        \u003C\u002Fdiv\u003E\n        \u003Cdiv class=\"mb-3\" *ngIf=\"connectionMode !== &quot;proxyCommand&quot;\"\u003E\n          \u003Clabel translate\u003EPort\u003C\u002Flabel\u003E\n          \u003Cinput class=\"form-control\" type=\"number\" placeholder=\"22\" [(ngModel)]=\"profile.options.port\"\u003E\n        \u003C\u002Fdiv\u003E\n      \u003C\u002Fdiv\u003E\n      \u003Cdiv class=\"mb-3\" *ngIf=\"connectionMode === &quot;jumpHost&quot;\"\u003E\n        \u003Clabel translate\u003EJump host\u003C\u002Flabel\u003E\n        \u003Cselect class=\"form-control\" [(ngModel)]=\"profile.options.jumpHost\"\u003E\n          \u003Coption [ngValue]=\"null\" translate\u003ESelect\u003C\u002Foption\u003E\n          \u003Coption [ngValue]=\"x.id\" *ngFor=\"let x of jumpHosts\"\u003E{{getJumpHostLabel(x)}}\u003C\u002Foption\u003E\n        \u003C\u002Fselect\u003E\n      \u003C\u002Fdiv\u003E\n      \u003Cdiv class=\"d-flex w-100\" *ngIf=\"connectionMode === &quot;socksProxy&quot;\"\u003E\n        \u003Cdiv class=\"mb-3 w-100 me-2\"\u003E\n          \u003Clabel translate\u003ESOCKS proxy host\u003C\u002Flabel\u003E\n          \u003Cinput class=\"form-control\" type=\"text\" [(ngModel)]=\"profile.options.socksProxyHost\"\u003E\n        \u003C\u002Fdiv\u003E\n        \u003Cdiv class=\"mb-3\"\u003E\n          \u003Clabel translate\u003ESOCKS proxy port\u003C\u002Flabel\u003E\n          \u003Cinput class=\"form-control\" type=\"number\" placeholder=\"5000\" [(ngModel)]=\"profile.options.socksProxyPort\"\u003E\n        \u003C\u002Fdiv\u003E\n      \u003C\u002Fdiv\u003E\n      \u003Cdiv class=\"d-flex w-100\" *ngIf=\"connectionMode === &quot;httpProxy&quot;\"\u003E\n        \u003Cdiv class=\"mb-3 w-100 me-2\"\u003E\n          \u003Clabel translate\u003EHTTP proxy host\u003C\u002Flabel\u003E\n          \u003Cinput class=\"form-control\" type=\"text\" [(ngModel)]=\"profile.options.httpProxyHost\"\u003E\n        \u003C\u002Fdiv\u003E\n        \u003Cdiv class=\"mb-3\"\u003E\n          \u003Clabel translate\u003EHTTP proxy port\u003C\u002Flabel\u003E\n          \u003Cinput class=\"form-control\" type=\"number\" placeholder=\"5000\" [(ngModel)]=\"profile.options.httpProxyPort\"\u003E\n        \u003C\u002Fdiv\u003E\n      \u003C\u002Fdiv\u003E\n      \u003Cdiv class=\"mb-3\"\u003E\n        \u003Clabel translate\u003EUsername\u003C\u002Flabel\u003E\n        \u003Cinput class=\"form-control\" type=\"text\" placeholder=\"Ask every time\" [(ngModel)]=\"profile.options.user\"\u003E\n      \u003C\u002Fdiv\u003E\n      \u003Cdiv class=\"mb-3\"\u003E\n        \u003Clabel translate\u003EAuthentication method\u003C\u002Flabel\u003E\n        \u003Cdiv class=\"btn-group mt-1 w-100\"\u003E\n          \u003Cinput class=\"btn-check\" type=\"radio\" name=\"auth\" [(ngModel)]=\"profile.options.auth\" id=\"authAuto\" [value]=\"null\"\u003E\n          \u003Clabel class=\"btn btn-secondary\" for=\"authAuto\"\u003E\u003Ci class=\"far fa-lightbulb\"\u003E\u003C\u002Fi\u003E\n            \u003Cdiv class=\"m-0\" translate\u003EAuto\u003C\u002Fdiv\u003E\n          \u003C\u002Flabel\u003E\n          \u003Cinput class=\"btn-check\" type=\"radio\" name=\"auth\" [(ngModel)]=\"profile.options.auth\" id=\"authPassword\" [value]=\"&quot;password&quot;\"\u003E\n          \u003Clabel class=\"btn btn-secondary\" for=\"authPassword\"\u003E\u003Ci class=\"fas fa-font\"\u003E\u003C\u002Fi\u003E\n            \u003Cdiv class=\"m-0\" translate\u003EPassword\u003C\u002Fdiv\u003E\n          \u003C\u002Flabel\u003E\n          \u003Cinput class=\"btn-check\" type=\"radio\" name=\"auth\" [(ngModel)]=\"profile.options.auth\" id=\"authPublicKey\" [value]=\"&quot;publicKey&quot;\"\u003E\n          \u003Clabel class=\"btn btn-secondary\" for=\"authPublicKey\"\u003E\u003Ci class=\"fas fa-key\"\u003E\u003C\u002Fi\u003E\n            \u003Cdiv class=\"m-0\" translate\u003EKey\u003C\u002Fdiv\u003E\n          \u003C\u002Flabel\u003E\n          \u003Cinput class=\"btn-check\" type=\"radio\" name=\"auth\" [(ngModel)]=\"profile.options.auth\" id=\"authAgent\" [value]=\"&quot;agent&quot;\"\u003E\n          \u003Clabel class=\"btn btn-secondary\" for=\"authAgent\" ng:if=\"hostApp.platform !== Platform.Web\"\u003E\u003Ci class=\"fas fa-user-secret\"\u003E\u003C\u002Fi\u003E\n            \u003Cdiv class=\"m-0\" translate\u003EAgent\u003C\u002Fdiv\u003E\n          \u003C\u002Flabel\u003E\n          \u003Cinput" + (" class=\"btn-check\""+" type=\"radio\" name=\"auth\" [(ngModel)]=\"profile.options.auth\""+pug.attr("id", 'auth"keyboardInteractive"'
                        [value]='"keyboardInteractive"', true, true)) + "\u003E\n          \u003Clabel class=\"btn btn-secondary\" ngbButtonLabel\u003E\u003Ci class=\"far fa-keyboard\"\u003E\u003C\u002Fi\u003E\n            \u003Cdiv class=\"m-0\" translate\u003EInteractive\u003C\u002Fdiv\u003E\n          \u003C\u002Flabel\u003E\n        \u003C\u002Fdiv\u003E\n      \u003C\u002Fdiv\u003E\n      \u003Cdiv class=\"form-line\" *ngIf=\"profile.options.user &amp;&amp; (!profile.options.auth || profile.options.auth === &quot;password&quot;)\"\u003E\n        \u003Cdiv class=\"header\"\u003E\n          \u003Cdiv class=\"title\" translate\u003EPassword\u003C\u002Fdiv\u003E\n          \u003Cdiv class=\"description\" *ngIf=\"!hasSavedPassword\" translate\u003ESave a password in the keychain\u003C\u002Fdiv\u003E\n          \u003Cdiv class=\"description\" *ngIf=\"hasSavedPassword\" translate\u003EThere is a saved password for this connection\u003C\u002Fdiv\u003E\n        \u003C\u002Fdiv\u003E\n        \u003Cbutton class=\"btn btn-success ms-4\" *ngIf=\"!hasSavedPassword\" (click)=\"setPassword()\"\u003E\u003Ci class=\"fas fa-key\"\u003E\u003C\u002Fi\u003E\u003Cspan translate\u003ESet password\u003C\u002Fspan\u003E\u003C\u002Fbutton\u003E\n        \u003Cbutton class=\"btn btn-danger ms-4\" *ngIf=\"hasSavedPassword\" (click)=\"clearSavedPassword()\"\u003E\u003Ci class=\"fas fa-trash-alt\"\u003E\u003C\u002Fi\u003E\u003Cspan translate\u003EForget\u003C\u002Fspan\u003E\u003C\u002Fbutton\u003E\n      \u003C\u002Fdiv\u003E\n      \u003Cdiv class=\"mb-3\" *ngIf=\"!profile.options.auth || profile.options.auth === &quot;publicKey&quot;\"\u003E\n        \u003Clabel translate\u003EPrivate keys\u003C\u002Flabel\u003E\n        \u003Cdiv class=\"list-group mb-2\"\u003E\n          \u003Cdiv class=\"list-group-item d-flex align-items-center p-1 ps-3\" *ngFor=\"let path of profile.options.privateKeys\"\u003E\u003Ci class=\"fas fa-key\"\u003E\u003C\u002Fi\u003E\n            \u003Cdiv class=\"no-wrap me-auto\"\u003E{{path}}\u003C\u002Fdiv\u003E\n            \u003Cbutton class=\"btn btn-link\" (click)=\"removePrivateKey(path)\"\u003E\u003Ci class=\"fas fa-trash\"\u003E\u003C\u002Fi\u003E\u003C\u002Fbutton\u003E\n          \u003C\u002Fdiv\u003E\n        \u003C\u002Fdiv\u003E\n        \u003Cbutton class=\"btn btn-secondary\" (click)=\"addPrivateKey()\"\u003E\u003Ci class=\"fas fa-folder-open\"\u003E\u003C\u002Fi\u003E\u003Cspan translate\u003EAdd a private key\u003C\u002Fspan\u003E\u003C\u002Fbutton\u003E\n      \u003C\u002Fdiv\u003E\n    \u003C\u002Fng-template\u003E\n  \u003C\u002Fli\u003E\n  \u003Cli ngbNavItem\u003E\u003Ca ngbNavLink translate\u003EPorts\u003C\u002Fa\u003E\n    \u003Cng-template ngbNavContent\u003E\n      \u003Cssh-port-forwarding-config *ngIf=\"profile.options.forwardedPorts\" [model]=\"profile.options.forwardedPorts\" (forwardAdded)=\"onForwardAdded($event)\" (forwardRemoved)=\"onForwardRemoved($event)\"\u003E\u003C\u002Fssh-port-forwarding-config\u003E\n    \u003C\u002Fng-template\u003E\n  \u003C\u002Fli\u003E\n  \u003Cli ngbNavItem\u003E\u003Ca ngbNavLink translate\u003EAdvanced\u003C\u002Fa\u003E\n    \u003Cng-template ngbNavContent\u003E\n      \u003Cdiv class=\"form-line\" ng:if=\"hostApp.platform !== Platform.Web\"\u003E\n        \u003Cdiv class=\"header\"\u003E\n          \u003Cdiv class=\"title\" translate\u003EX11 forwarding\u003C\u002Fdiv\u003E\n        \u003C\u002Fdiv\u003E\n        \u003Ctoggle [(ngModel)]=\"profile.options.x11\"\u003E\u003C\u002Ftoggle\u003E\n      \u003C\u002Fdiv\u003E\n      \u003Cdiv class=\"form-line\" ng:if=\"hostApp.platform !== Platform.Web\"\u003E\n        \u003Cdiv class=\"header\"\u003E\n          \u003Cdiv class=\"title\" translate\u003EAgent forwarding\u003C\u002Fdiv\u003E\n        \u003C\u002Fdiv\u003E\n        \u003Ctoggle [(ngModel)]=\"profile.options.agentForward\"\u003E\u003C\u002Ftoggle\u003E\n      \u003C\u002Fdiv\u003E\n      \u003Cdiv class=\"form-line\"\u003E\n        \u003Cdiv class=\"header\"\u003E\n          \u003Cdiv class=\"title\" translate\u003ESkip MoTD\u002Fbanner\u003C\u002Fdiv\u003E\n          \u003Cdiv class=\"description\" translate\u003EWill prevent the SSH greeting from showing up\u003C\u002Fdiv\u003E\n        \u003C\u002Fdiv\u003E\n        \u003Ctoggle [(ngModel)]=\"profile.options.skipBanner\"\u003E\u003C\u002Ftoggle\u003E\n      \u003C\u002Fdiv\u003E\n      \u003Cdiv class=\"form-line\"\u003E\n        \u003Cdiv class=\"header\"\u003E\n          \u003Cdiv class=\"title\" translate\u003EReuse session for multiple tabs\u003C\u002Fdiv\u003E\n          \u003Cdiv class=\"description\"\u003EMultiplex multiple shells through the same connection\u003C\u002Fdiv\u003E\n        \u003C\u002Fdiv\u003E\n        \u003Ctoggle [(ngModel)]=\"profile.options.reuseSession\"\u003E\u003C\u002Ftoggle\u003E\n      \u003C\u002Fdiv\u003E\n      \u003Cdiv class=\"form-line\"\u003E\n        \u003Cdiv class=\"header\"\u003E\n          \u003Cdiv class=\"title\" translate\u003EKeep Alive Interval (Milliseconds)\u003C\u002Fdiv\u003E\n        \u003C\u002Fdiv\u003E\n        \u003Cinput class=\"form-control\" type=\"number\" placeholder=\"0\" [(ngModel)]=\"profile.options.keepaliveInterval\"\u003E\n      \u003C\u002Fdiv\u003E\n      \u003Cdiv class=\"form-line\"\u003E\n        \u003Cdiv class=\"header\"\u003E\n          \u003Cdiv class=\"title\" translate\u003EMax Keep Alive Count\u003C\u002Fdiv\u003E\n        \u003C\u002Fdiv\u003E\n        \u003Cinput class=\"form-control\" type=\"number\" placeholder=\"3\" [(ngModel)]=\"profile.options.keepaliveCountMax\"\u003E\n      \u003C\u002Fdiv\u003E\n      \u003Cdiv class=\"form-line\"\u003E\n        \u003Cdiv class=\"header\"\u003E\n          \u003Cdiv class=\"title\" translate\u003EReady Timeout (Milliseconds)\u003C\u002Fdiv\u003E\n        \u003C\u002Fdiv\u003E\n        \u003Cinput class=\"form-control\" type=\"number\" placeholder=\"20000\" [(ngModel)]=\"profile.options.readyTimeout\"\u003E\n      \u003C\u002Fdiv\u003E\n    \u003C\u002Fng-template\u003E\n  \u003C\u002Fli\u003E\n  \u003Cli ngbNavItem\u003E\u003Ca ngbNavLink translate\u003ECiphers\u003C\u002Fa\u003E\n    \u003Cng-template ngbNavContent\u003E\n      \u003Cdiv class=\"form-line align-items-start\"\u003E\n        \u003Cdiv class=\"header\"\u003E\n          \u003Cdiv class=\"title\" translate\u003ECiphers\u003C\u002Fdiv\u003E\n        \u003C\u002Fdiv\u003E\n        \u003Cdiv class=\"w-75\"\u003E\n          \u003Cdiv *ngFor=\"let alg of supportedAlgorithms.cipher\"\u003E\n            \u003Ccheckbox [text]=\"alg\" [(ngModel)]=\"algorithms.cipher[alg]\"\u003E\u003C\u002Fcheckbox\u003E\n          \u003C\u002Fdiv\u003E\n        \u003C\u002Fdiv\u003E\n      \u003C\u002Fdiv\u003E\n      \u003Cdiv class=\"form-line align-items-start\"\u003E\n        \u003Cdiv class=\"header\"\u003E\n          \u003Cdiv class=\"title\" translate\u003EKey exchange\u003C\u002Fdiv\u003E\n        \u003C\u002Fdiv\u003E\n        \u003Cdiv class=\"w-75\"\u003E\n          \u003Cdiv *ngFor=\"let alg of supportedAlgorithms.kex\"\u003E\n            \u003Ccheckbox [text]=\"alg\" [(ngModel)]=\"algorithms.kex[alg]\"\u003E\u003C\u002Fcheckbox\u003E\n          \u003C\u002Fdiv\u003E\n        \u003C\u002Fdiv\u003E\n      \u003C\u002Fdiv\u003E\n      \u003Cdiv class=\"form-line align-items-start\"\u003E\n        \u003Cdiv class=\"header\"\u003E\n          \u003Cdiv class=\"title\"\u003EHMAC\u003C\u002Fdiv\u003E\n        \u003C\u002Fdiv\u003E\n        \u003Cdiv class=\"w-75\"\u003E\n          \u003Cdiv *ngFor=\"let alg of supportedAlgorithms.hmac\"\u003E\n            \u003Ccheckbox [text]=\"alg\" [(ngModel)]=\"algorithms.hmac[alg]\"\u003E\u003C\u002Fcheckbox\u003E\n          \u003C\u002Fdiv\u003E\n        \u003C\u002Fdiv\u003E\n      \u003C\u002Fdiv\u003E\n      \u003Cdiv class=\"form-line align-items-start\"\u003E\n        \u003Cdiv class=\"header\"\u003E\n          \u003Cdiv class=\"title\" translate\u003EHost key\u003C\u002Fdiv\u003E\n        \u003C\u002Fdiv\u003E\n        \u003Cdiv class=\"w-75\"\u003E\n          \u003Cdiv *ngFor=\"let alg of supportedAlgorithms.serverHostKey\"\u003E\n            \u003Ccheckbox [text]=\"alg\" [(ngModel)]=\"algorithms.serverHostKey[alg]\"\u003E\u003C\u002Fcheckbox\u003E\n          \u003C\u002Fdiv\u003E\n        \u003C\u002Fdiv\u003E\n      \u003C\u002Fdiv\u003E\n    \u003C\u002Fng-template\u003E\n  \u003C\u002Fli\u003E\n  \u003Cli ngbNavItem\u003E\u003Ca ngbNavLink translate\u003EColors\u003C\u002Fa\u003E\n    \u003Cng-template ngbNavContent\u003E\n      \u003Ccolor-scheme-selector [(model)]=\"profile.terminalColorScheme\"\u003E\u003C\u002Fcolor-scheme-selector\u003E\n    \u003C\u002Fng-template\u003E\n  \u003C\u002Fli\u003E\n  \u003Cli ngbNavItem\u003E\u003Ca ngbNavLink translate\u003ELogin scripts\u003C\u002Fa\u003E\n    \u003Cng-template ngbNavContent\u003E\n      \u003Clogin-scripts-settings [options]=\"profile.options\" #loginScriptsSettings\u003E\u003C\u002Flogin-scripts-settings\u003E\n    \u003C\u002Fng-template\u003E\n  \u003C\u002Fli\u003E\n\u003C\u002Ful\u003E\n\u003Cdiv [ngbNavOutlet]=\"nav\"\u003E\u003C\u002Fdiv\u003E";
    }.call(this, "value" in locals_for_with ?
        locals_for_with.value :
        typeof value !== 'undefined' ? value : undefined));
    ;;return pug_html;};
module.exports = template;

/***/ }),

/***/ 5859:
/*!********************************************************************************************************************************!*\
  !*** ../node_modules/pug-loader/index.js??ruleSet[1].rules[3].use[1]!./src/components/sshSettingsTab.component.pug?ngResource ***!
  \********************************************************************************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var pug = __webpack_require__(/*! !../../../node_modules/pug-runtime/index.js */ 9757);

function template(locals) {var pug_html = "", pug_mixins = {}, pug_interp;var pug_indent = [];
pug_html = pug_html + "\n\u003Ch3\u003ESSH\u003C\u002Fh3\u003E\n\u003Cdiv class=\"form-line\"\u003E\n  \u003Cdiv class=\"header\"\u003E\n    \u003Cdiv class=\"title\" translate\u003EWarn when closing active connections\u003C\u002Fdiv\u003E\n  \u003C\u002Fdiv\u003E\n  \u003Ctoggle [(ngModel)]=\"config.store.ssh.warnOnClose\" (ngModelChange)=\"config.save()\"\u003E\u003C\u002Ftoggle\u003E\n\u003C\u002Fdiv\u003E\n\u003Cdiv class=\"form-line\"\u003E\n  \u003Cdiv class=\"header\"\u003E\n    \u003Cdiv class=\"title\" translate\u003EVerify host keys when connecting\u003C\u002Fdiv\u003E\n  \u003C\u002Fdiv\u003E\n  \u003Ctoggle [(ngModel)]=\"config.store.ssh.verifyHostKeys\" (ngModelChange)=\"config.save()\"\u003E\u003C\u002Ftoggle\u003E\n\u003C\u002Fdiv\u003E\n\u003Cdiv class=\"form-line\" *ngIf=\"hostApp.platform === Platform.Windows\"\u003E\n  \u003Cdiv class=\"header\"\u003E\n    \u003Cdiv class=\"title\" translate\u003EWinSCP path\u003C\u002Fdiv\u003E\n    \u003Cdiv class=\"description\" translate\u003EWhen WinSCP is detected, you can launch an SCP session from the context menu.\u003C\u002Fdiv\u003E\n  \u003C\u002Fdiv\u003E\n  \u003Cinput class=\"form-control\" type=\"text\" placeholder=\"Auto-detect\" [(ngModel)]=\"config.store.ssh.winSCPPath\" (ngModelChange)=\"config.save()\"\u003E\n\u003C\u002Fdiv\u003E\n\u003Cdiv class=\"form-line\" *ngIf=\"hostApp.platform === Platform.Windows\"\u003E\n  \u003Cdiv class=\"header\"\u003E\n    \u003Cdiv class=\"title\" translate\u003EAgent type\u003C\u002Fdiv\u003E\n    \u003Cdiv class=\"description\" translate\u003EForces a specific SSH agent connection type.\u003C\u002Fdiv\u003E\n  \u003C\u002Fdiv\u003E\n  \u003Cselect class=\"form-control\" [(ngModel)]=\"config.store.ssh.agentType\" (ngModelChange)=\"config.save()\"\u003E\n    \u003Coption value=\"auto\" translate\u003EAutomatic\u003C\u002Foption\u003E\n    \u003Coption value=\"pageant\"\u003EPageant\u003C\u002Foption\u003E\n    \u003Coption value=\"pipe\"\u003ENamed pipe\u003C\u002Foption\u003E\n  \u003C\u002Fselect\u003E\n\u003C\u002Fdiv\u003E\n\u003Cdiv class=\"form-line\" *ngIf=\"config.store.ssh.agentType === &quot;pipe&quot;\"\u003E\n  \u003Cdiv class=\"header\"\u003E\n    \u003Cdiv class=\"title\" translate\u003EAgent pipe path\u003C\u002Fdiv\u003E\n    \u003Cdiv class=\"description\" translate\u003ESets the SSH agent's named pipe path.\u003C\u002Fdiv\u003E\n  \u003C\u002Fdiv\u003E\n  \u003Cinput class=\"form-control\" type=\"text\" placeholder=\"Default: \\\\.\\pipe\\openssh-ssh-agent\" [(ngModel)]=\"config.store.ssh.agentPath\" (ngModelChange)=\"config.save()\"\u003E\n\u003C\u002Fdiv\u003E\n\u003Cdiv class=\"form-line\"\u003E\n  \u003Cdiv class=\"header\"\u003E\n    \u003Cdiv class=\"title\" translate\u003EOverride X11 display\u003C\u002Fdiv\u003E\n    \u003Cdiv class=\"description\" translate\u003EPath or address of the local X11 socket\u003C\u002Fdiv\u003E\n  \u003C\u002Fdiv\u003E\n  \u003Cinput class=\"form-control\" type=\"text\" [placeholder]=\"defaultX11Display\" [(ngModel)]=\"config.store.ssh.x11Display\" (ngModelChange)=\"config.save()\"\u003E\n\u003C\u002Fdiv\u003E\n\u003Cdiv class=\"form-line\"\u003E\n  \u003Cdiv class=\"header\"\u003E\n    \u003Cdiv class=\"title\" translate\u003EClear terminal after connection\u003C\u002Fdiv\u003E\n  \u003C\u002Fdiv\u003E\n  \u003Ctoggle [(ngModel)]=\"config.store.ssh.clearServiceMessagesOnConnect\" (ngModelChange)=\"config.save()\"\u003E\u003C\u002Ftoggle\u003E\n\u003C\u002Fdiv\u003E\n\u003Cdiv class=\"alert alert-info\" translate\u003ESSH connection management is now done through the \"Profiles & connections\" tab\u003C\u002Fdiv\u003E";;return pug_html;};
module.exports = template;

/***/ }),

/***/ 2517:
/*!*************************************************************************************************************!*\
  !*** ../node_modules/pug-loader/index.js??ruleSet[1].rules[3].use[1]!./src/components/sshTab.component.pug ***!
  \*************************************************************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var pug = __webpack_require__(/*! !../../../node_modules/pug-runtime/index.js */ 9757);

function template(locals) {var pug_html = "", pug_mixins = {}, pug_interp;var pug_indent = [];
pug_html = pug_html + "\n\u003Cterminal-toolbar [tab]=\"this\"\u003E\u003Ci class=\"fas fa-xs fa-circle text-success me-2\" *ngIf=\"session &amp;&amp; session.open\"\u003E\u003C\u002Fi\u003E\u003Ci class=\"fas fa-xs fa-circle text-danger me-2\" *ngIf=\"!session || !session.open\"\u003E\u003C\u002Fi\u003E\u003Cstrong class=\"me-auto\"\u003E{{profile.options.user}}@{{profile.options.host}}:{{profile.options.port}}\u003C\u002Fstrong\u003E\n  \u003Cdiv class=\"me-2\" ngbDropdown container=\"body\" *ngIf=\"session &amp;&amp; !session.supportsWorkingDirectory()\" placement=\"bottom-right bottom-left bottom\"\u003E\n    \u003Cbutton class=\"btn btn-sm btn-link\" ngbDropdownToggle\u003E\u003Ci class=\"far fa-lightbulb text-primary\"\u003E\u003C\u002Fi\u003E\u003C\u002Fbutton\u003E\n    \u003Cdiv class=\"bg-dark\" ngbDropdownMenu\u003E\u003Ca class=\"d-flex align-items-center\" ngbDropdownItem (click)=\"platform.openExternal(&quot;https:\u002F\u002Ftabby.sh\u002Fgo\u002Fcwd-detection&quot;)\"\u003E\n        \u003Cdiv class=\"me-auto\"\u003E\u003Cstrong translate\u003EWorking directory detection\u003C\u002Fstrong\u003E\n          \u003Cdiv translate\u003ELearn how to allow Tabby to detect remote shell's working directory.\u003C\u002Fdiv\u003E\n        \u003C\u002Fdiv\u003E\u003Ci class=\"fas fa-arrow-right ms-4\"\u003E\u003C\u002Fi\u003E\u003C\u002Fa\u003E\u003C\u002Fdiv\u003E\n  \u003C\u002Fdiv\u003E\n  \u003Cbutton class=\"btn btn-sm btn-link me-2\" (click)=\"reconnect()\"\u003E\u003Ci class=\"fas fa-redo\"\u003E\u003C\u002Fi\u003E\u003Cspan translate\u003EReconnect\u003C\u002Fspan\u003E\u003C\u002Fbutton\u003E\n  \u003Cbutton class=\"btn btn-sm btn-link me-2\" (click)=\"openSFTP()\" *ngIf=\"session &amp;&amp; session.open\"\u003E\u003Ci class=\"far fa-folder-open\"\u003E\u003C\u002Fi\u003E\u003Cspan\u003ESFTP\u003C\u002Fspan\u003E\u003C\u002Fbutton\u003E\n  \u003Cbutton class=\"btn btn-sm btn-link\" *ngIf=\"session &amp;&amp; session.open &amp;&amp; hostApp.platform !== Platform.Web\" (click)=\"showPortForwarding()\"\u003E\u003Ci class=\"fas fa-plug\"\u003E\u003C\u002Fi\u003E\u003Cspan translate\u003EPorts\u003C\u002Fspan\u003E\u003C\u002Fbutton\u003E\n\u003C\u002Fterminal-toolbar\u003E\n\u003Csftp-panel class=\"bg-dark\" @panelSlide [@.disabled]=\"!config.store.accessibility.animations\" [(path)]=\"sftpPath\" *ngIf=\"sftpPanelVisible &amp;&amp; sshSession\" (click)=\"$event.stopPropagation()\" [session]=\"sshSession!\" [cwdDetectionAvailable]=\"session?.supportsWorkingDirectory() ?? false\" (closed)=\"sftpPanelVisible = false\"\u003E\u003C\u002Fsftp-panel\u003E\n\u003Ckeyboard-interactive-auth-panel class=\"bg-dark\" *ngIf=\"activeKIPrompt\" [prompt]=\"activeKIPrompt\" (click)=\"$event.stopPropagation()\" (done)=\"activeKIPrompt = null; frontend?.focus()\"\u003E\u003C\u002Fkeyboard-interactive-auth-panel\u003E";;return pug_html;};
module.exports = template;

/***/ }),

/***/ 9757:
/*!********************************************!*\
  !*** ../node_modules/pug-runtime/index.js ***!
  \********************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


var pug_has_own_property = Object.prototype.hasOwnProperty;

/**
 * Merge two attribute objects giving precedence
 * to values in object `b`. Classes are special-cased
 * allowing for arrays and merging/joining appropriately
 * resulting in a string.
 *
 * @param {Object} a
 * @param {Object} b
 * @return {Object} a
 * @api private
 */

exports.merge = pug_merge;
function pug_merge(a, b) {
  if (arguments.length === 1) {
    var attrs = a[0];
    for (var i = 1; i < a.length; i++) {
      attrs = pug_merge(attrs, a[i]);
    }
    return attrs;
  }

  for (var key in b) {
    if (key === 'class') {
      var valA = a[key] || [];
      a[key] = (Array.isArray(valA) ? valA : [valA]).concat(b[key] || []);
    } else if (key === 'style') {
      var valA = pug_style(a[key]);
      valA = valA && valA[valA.length - 1] !== ';' ? valA + ';' : valA;
      var valB = pug_style(b[key]);
      valB = valB && valB[valB.length - 1] !== ';' ? valB + ';' : valB;
      a[key] = valA + valB;
    } else {
      a[key] = b[key];
    }
  }

  return a;
}

/**
 * Process array, object, or string as a string of classes delimited by a space.
 *
 * If `val` is an array, all members of it and its subarrays are counted as
 * classes. If `escaping` is an array, then whether or not the item in `val` is
 * escaped depends on the corresponding item in `escaping`. If `escaping` is
 * not an array, no escaping is done.
 *
 * If `val` is an object, all the keys whose value is truthy are counted as
 * classes. No escaping is done.
 *
 * If `val` is a string, it is counted as a class. No escaping is done.
 *
 * @param {(Array.<string>|Object.<string, boolean>|string)} val
 * @param {?Array.<string>} escaping
 * @return {String}
 */
exports.classes = pug_classes;
function pug_classes_array(val, escaping) {
  var classString = '',
    className,
    padding = '',
    escapeEnabled = Array.isArray(escaping);
  for (var i = 0; i < val.length; i++) {
    className = pug_classes(val[i]);
    if (!className) continue;
    escapeEnabled && escaping[i] && (className = pug_escape(className));
    classString = classString + padding + className;
    padding = ' ';
  }
  return classString;
}
function pug_classes_object(val) {
  var classString = '',
    padding = '';
  for (var key in val) {
    if (key && val[key] && pug_has_own_property.call(val, key)) {
      classString = classString + padding + key;
      padding = ' ';
    }
  }
  return classString;
}
function pug_classes(val, escaping) {
  if (Array.isArray(val)) {
    return pug_classes_array(val, escaping);
  } else if (val && typeof val === 'object') {
    return pug_classes_object(val);
  } else {
    return val || '';
  }
}

/**
 * Convert object or string to a string of CSS styles delimited by a semicolon.
 *
 * @param {(Object.<string, string>|string)} val
 * @return {String}
 */

exports.style = pug_style;
function pug_style(val) {
  if (!val) return '';
  if (typeof val === 'object') {
    var out = '';
    for (var style in val) {
      /* istanbul ignore else */
      if (pug_has_own_property.call(val, style)) {
        out = out + style + ':' + val[style] + ';';
      }
    }
    return out;
  } else {
    return val + '';
  }
}

/**
 * Render the given attribute.
 *
 * @param {String} key
 * @param {String} val
 * @param {Boolean} escaped
 * @param {Boolean} terse
 * @return {String}
 */
exports.attr = pug_attr;
function pug_attr(key, val, escaped, terse) {
  if (
    val === false ||
    val == null ||
    (!val && (key === 'class' || key === 'style'))
  ) {
    return '';
  }
  if (val === true) {
    return ' ' + (terse ? key : key + '="' + key + '"');
  }
  var type = typeof val;
  if (
    (type === 'object' || type === 'function') &&
    typeof val.toJSON === 'function'
  ) {
    val = val.toJSON();
  }
  if (typeof val !== 'string') {
    val = JSON.stringify(val);
    if (!escaped && val.indexOf('"') !== -1) {
      return ' ' + key + "='" + val.replace(/'/g, '&#39;') + "'";
    }
  }
  if (escaped) val = pug_escape(val);
  return ' ' + key + '="' + val + '"';
}

/**
 * Render the given attributes object.
 *
 * @param {Object} obj
 * @param {Object} terse whether to use HTML5 terse boolean attributes
 * @return {String}
 */
exports.attrs = pug_attrs;
function pug_attrs(obj, terse) {
  var attrs = '';

  for (var key in obj) {
    if (pug_has_own_property.call(obj, key)) {
      var val = obj[key];

      if ('class' === key) {
        val = pug_classes(val);
        attrs = pug_attr(key, val, false, terse) + attrs;
        continue;
      }
      if ('style' === key) {
        val = pug_style(val);
      }
      attrs += pug_attr(key, val, false, terse);
    }
  }

  return attrs;
}

/**
 * Escape the given string of `html`.
 *
 * @param {String} html
 * @return {String}
 * @api private
 */

var pug_match_html = /["&<>]/;
exports.escape = pug_escape;
function pug_escape(_html) {
  var html = '' + _html;
  var regexResult = pug_match_html.exec(html);
  if (!regexResult) return _html;

  var result = '';
  var i, lastIndex, escape;
  for (i = regexResult.index, lastIndex = 0; i < html.length; i++) {
    switch (html.charCodeAt(i)) {
      case 34:
        escape = '&quot;';
        break;
      case 38:
        escape = '&amp;';
        break;
      case 60:
        escape = '&lt;';
        break;
      case 62:
        escape = '&gt;';
        break;
      default:
        continue;
    }
    if (lastIndex !== i) result += html.substring(lastIndex, i);
    lastIndex = i + 1;
    result += escape;
  }
  if (lastIndex !== i) return result + html.substring(lastIndex, i);
  else return result;
}

/**
 * Re-throw the given `err` in context to the
 * the pug in `filename` at the given `lineno`.
 *
 * @param {Error} err
 * @param {String} filename
 * @param {String} lineno
 * @param {String} str original source
 * @api private
 */

exports.rethrow = pug_rethrow;
function pug_rethrow(err, filename, lineno, str) {
  if (!(err instanceof Error)) throw err;
  if ((typeof window != 'undefined' || !filename) && !str) {
    err.message += ' on line ' + lineno;
    throw err;
  }
  var context, lines, start, end;
  try {
    str = str || (__webpack_require__(/*! fs */ 2089).readFileSync)(filename, {encoding: 'utf8'});
    context = 3;
    lines = str.split('\n');
    start = Math.max(lineno - context, 0);
    end = Math.min(lines.length, lineno + context);
  } catch (ex) {
    err.message +=
      ' - could not read from ' + filename + ' (' + ex.message + ')';
    pug_rethrow(err, null, lineno);
    return;
  }

  // Error context
  context = lines
    .slice(start, end)
    .map(function(line, i) {
      var curr = i + start + 1;
      return (curr == lineno ? '  > ' : '    ') + curr + '| ' + line;
    })
    .join('\n');

  // Alter exception message
  err.path = filename;
  try {
    err.message =
      (filename || 'Pug') +
      ':' +
      lineno +
      '\n' +
      context +
      '\n\n' +
      err.message;
  } catch (e) {}
  throw err;
}


/***/ }),

/***/ 2024:
/*!*****************************************!*\
  !*** ../tabby-core/src/icons/times.svg ***!
  \*****************************************/
/***/ ((module) => {

module.exports = "<svg aria-hidden=\"true\" focusable=\"false\" data-prefix=\"fal\" data-icon=\"times\" class=\"svg-inline--fa fa-times fa-w-10\" role=\"img\" xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 320 512\"><path fill=\"currentColor\" d=\"M193.94 256L296.5 153.44l21.15-21.15c3.12-3.12 3.12-8.19 0-11.31l-22.63-22.63c-3.12-3.12-8.19-3.12-11.31 0L160 222.06 36.29 98.34c-3.12-3.12-8.19-3.12-11.31 0L2.34 120.97c-3.12 3.12-3.12 8.19 0 11.31L126.06 256 2.34 379.71c-3.12 3.12-3.12 8.19 0 11.31l22.63 22.63c3.12 3.12 8.19 3.12 11.31 0L160 289.94 262.56 392.5l21.15 21.15c3.12 3.12 8.19 3.12 11.31 0l22.63-22.63c3.12-3.12 3.12-8.19 0-11.31L193.94 256z\"></path></svg>"

/***/ }),

/***/ 9491:
/*!*************************!*\
  !*** external "assert" ***!
  \*************************/
/***/ ((module) => {

"use strict";
module.exports = require("assert");

/***/ }),

/***/ 4300:
/*!*************************!*\
  !*** external "buffer" ***!
  \*************************/
/***/ ((module) => {

"use strict";
module.exports = require("buffer");

/***/ }),

/***/ 2057:
/*!****************************!*\
  !*** external "constants" ***!
  \****************************/
/***/ ((module) => {

"use strict";
module.exports = require("constants");

/***/ }),

/***/ 6113:
/*!*************************!*\
  !*** external "crypto" ***!
  \*************************/
/***/ ((module) => {

"use strict";
module.exports = require("crypto");

/***/ }),

/***/ 9523:
/*!**********************!*\
  !*** external "dns" ***!
  \**********************/
/***/ ((module) => {

"use strict";
module.exports = require("dns");

/***/ }),

/***/ 2361:
/*!*************************!*\
  !*** external "events" ***!
  \*************************/
/***/ ((module) => {

"use strict";
module.exports = require("events");

/***/ }),

/***/ 3685:
/*!***********************!*\
  !*** external "http" ***!
  \***********************/
/***/ ((module) => {

"use strict";
module.exports = require("http");

/***/ }),

/***/ 5687:
/*!************************!*\
  !*** external "https" ***!
  \************************/
/***/ ((module) => {

"use strict";
module.exports = require("https");

/***/ }),

/***/ 1576:
/*!*********************************!*\
  !*** external "string_decoder" ***!
  \*********************************/
/***/ ((module) => {

"use strict";
module.exports = require("string_decoder");

/***/ }),

/***/ 4404:
/*!**********************!*\
  !*** external "tls" ***!
  \**********************/
/***/ ((module) => {

"use strict";
module.exports = require("tls");

/***/ }),

/***/ 3837:
/*!***********************!*\
  !*** external "util" ***!
  \***********************/
/***/ ((module) => {

"use strict";
module.exports = require("util");

/***/ }),

/***/ 9796:
/*!***********************!*\
  !*** external "zlib" ***!
  \***********************/
/***/ ((module) => {

"use strict";
module.exports = require("zlib");

/***/ }),

/***/ 5848:
/*!**********************************!*\
  !*** external "@angular/common" ***!
  \**********************************/
/***/ ((module) => {

"use strict";
module.exports = __WEBPACK_EXTERNAL_MODULE__5848__;

/***/ }),

/***/ 8900:
/*!********************************!*\
  !*** external "@angular/core" ***!
  \********************************/
/***/ ((module) => {

"use strict";
module.exports = __WEBPACK_EXTERNAL_MODULE__8900__;

/***/ }),

/***/ 7161:
/*!*********************************!*\
  !*** external "@angular/forms" ***!
  \*********************************/
/***/ ((module) => {

"use strict";
module.exports = __WEBPACK_EXTERNAL_MODULE__7161__;

/***/ }),

/***/ 6608:
/*!***************************************!*\
  !*** external "@luminati-io/socksv5" ***!
  \***************************************/
/***/ ((module) => {

"use strict";
module.exports = __WEBPACK_EXTERNAL_MODULE__6608__;

/***/ }),

/***/ 7571:
/*!*********************************************!*\
  !*** external "@ng-bootstrap/ng-bootstrap" ***!
  \*********************************************/
/***/ ((module) => {

"use strict";
module.exports = __WEBPACK_EXTERNAL_MODULE__7571__;

/***/ }),

/***/ 7154:
/*!******************************!*\
  !*** external "any-promise" ***!
  \******************************/
/***/ ((module) => {

"use strict";
module.exports = __WEBPACK_EXTERNAL_MODULE__7154__;

/***/ }),

/***/ 7198:
/*!********************************!*\
  !*** external "child_process" ***!
  \********************************/
/***/ ((module) => {

"use strict";
module.exports = __WEBPACK_EXTERNAL_MODULE__7198__;

/***/ }),

/***/ 2089:
/*!*********************!*\
  !*** external "fs" ***!
  \*********************/
/***/ ((module) => {

"use strict";
module.exports = __WEBPACK_EXTERNAL_MODULE__2089__;

/***/ }),

/***/ 5860:
/*!*************************!*\
  !*** external "keytar" ***!
  \*************************/
/***/ ((module) => {

"use strict";
module.exports = __WEBPACK_EXTERNAL_MODULE__5860__;

/***/ }),

/***/ 1548:
/*!**********************!*\
  !*** external "net" ***!
  \**********************/
/***/ ((module) => {

"use strict";
module.exports = __WEBPACK_EXTERNAL_MODULE__1548__;

/***/ }),

/***/ 7170:
/*!*****************************!*\
  !*** external "ngx-toastr" ***!
  \*****************************/
/***/ ((module) => {

"use strict";
module.exports = __WEBPACK_EXTERNAL_MODULE__7170__;

/***/ }),

/***/ 9044:
/*!*********************!*\
  !*** external "os" ***!
  \*********************/
/***/ ((module) => {

"use strict";
module.exports = __WEBPACK_EXTERNAL_MODULE__9044__;

/***/ }),

/***/ 3056:
/*!***********************!*\
  !*** external "path" ***!
  \***********************/
/***/ ((module) => {

"use strict";
module.exports = __WEBPACK_EXTERNAL_MODULE__3056__;

/***/ }),

/***/ 3832:
/*!***********************!*\
  !*** external "rxjs" ***!
  \***********************/
/***/ ((module) => {

"use strict";
module.exports = __WEBPACK_EXTERNAL_MODULE__3832__;

/***/ }),

/***/ 3978:
/*!*************************!*\
  !*** external "stream" ***!
  \*************************/
/***/ ((module) => {

"use strict";
module.exports = __WEBPACK_EXTERNAL_MODULE__3978__;

/***/ }),

/***/ 315:
/*!*****************************!*\
  !*** external "tabby-core" ***!
  \*****************************/
/***/ ((module) => {

"use strict";
module.exports = __WEBPACK_EXTERNAL_MODULE__315__;

/***/ }),

/***/ 6663:
/*!*********************************!*\
  !*** external "tabby-settings" ***!
  \*********************************/
/***/ ((module) => {

"use strict";
module.exports = __WEBPACK_EXTERNAL_MODULE__6663__;

/***/ }),

/***/ 8316:
/*!*********************************!*\
  !*** external "tabby-terminal" ***!
  \*********************************/
/***/ ((module) => {

"use strict";
module.exports = __WEBPACK_EXTERNAL_MODULE__8316__;

/***/ }),

/***/ 1497:
/*!*******************************************************!*\
  !*** ./crypto/build/Release/sshcrypto.node (ignored) ***!
  \*******************************************************/
/***/ (() => {

/* (ignored) */

/***/ }),

/***/ 7493:
/*!******************************!*\
  !*** cpu-features (ignored) ***!
  \******************************/
/***/ (() => {

/* (ignored) */

/***/ }),

/***/ 4923:
/*!******************************************************!*\
  !*** ../node_modules/browserify-aes/modes/list.json ***!
  \******************************************************/
/***/ ((module) => {

"use strict";
module.exports = JSON.parse('{"aes-128-ecb":{"cipher":"AES","key":128,"iv":0,"mode":"ECB","type":"block"},"aes-192-ecb":{"cipher":"AES","key":192,"iv":0,"mode":"ECB","type":"block"},"aes-256-ecb":{"cipher":"AES","key":256,"iv":0,"mode":"ECB","type":"block"},"aes-128-cbc":{"cipher":"AES","key":128,"iv":16,"mode":"CBC","type":"block"},"aes-192-cbc":{"cipher":"AES","key":192,"iv":16,"mode":"CBC","type":"block"},"aes-256-cbc":{"cipher":"AES","key":256,"iv":16,"mode":"CBC","type":"block"},"aes128":{"cipher":"AES","key":128,"iv":16,"mode":"CBC","type":"block"},"aes192":{"cipher":"AES","key":192,"iv":16,"mode":"CBC","type":"block"},"aes256":{"cipher":"AES","key":256,"iv":16,"mode":"CBC","type":"block"},"aes-128-cfb":{"cipher":"AES","key":128,"iv":16,"mode":"CFB","type":"stream"},"aes-192-cfb":{"cipher":"AES","key":192,"iv":16,"mode":"CFB","type":"stream"},"aes-256-cfb":{"cipher":"AES","key":256,"iv":16,"mode":"CFB","type":"stream"},"aes-128-cfb8":{"cipher":"AES","key":128,"iv":16,"mode":"CFB8","type":"stream"},"aes-192-cfb8":{"cipher":"AES","key":192,"iv":16,"mode":"CFB8","type":"stream"},"aes-256-cfb8":{"cipher":"AES","key":256,"iv":16,"mode":"CFB8","type":"stream"},"aes-128-cfb1":{"cipher":"AES","key":128,"iv":16,"mode":"CFB1","type":"stream"},"aes-192-cfb1":{"cipher":"AES","key":192,"iv":16,"mode":"CFB1","type":"stream"},"aes-256-cfb1":{"cipher":"AES","key":256,"iv":16,"mode":"CFB1","type":"stream"},"aes-128-ofb":{"cipher":"AES","key":128,"iv":16,"mode":"OFB","type":"stream"},"aes-192-ofb":{"cipher":"AES","key":192,"iv":16,"mode":"OFB","type":"stream"},"aes-256-ofb":{"cipher":"AES","key":256,"iv":16,"mode":"OFB","type":"stream"},"aes-128-ctr":{"cipher":"AES","key":128,"iv":16,"mode":"CTR","type":"stream"},"aes-192-ctr":{"cipher":"AES","key":192,"iv":16,"mode":"CTR","type":"stream"},"aes-256-ctr":{"cipher":"AES","key":256,"iv":16,"mode":"CTR","type":"stream"},"aes-128-gcm":{"cipher":"AES","key":128,"iv":12,"mode":"GCM","type":"auth"},"aes-192-gcm":{"cipher":"AES","key":192,"iv":12,"mode":"GCM","type":"auth"},"aes-256-gcm":{"cipher":"AES","key":256,"iv":12,"mode":"GCM","type":"auth"}}');

/***/ }),

/***/ 7536:
/*!***************************************************************!*\
  !*** ../node_modules/browserify-sign/browser/algorithms.json ***!
  \***************************************************************/
/***/ ((module) => {

"use strict";
module.exports = JSON.parse('{"sha224WithRSAEncryption":{"sign":"rsa","hash":"sha224","id":"302d300d06096086480165030402040500041c"},"RSA-SHA224":{"sign":"ecdsa/rsa","hash":"sha224","id":"302d300d06096086480165030402040500041c"},"sha256WithRSAEncryption":{"sign":"rsa","hash":"sha256","id":"3031300d060960864801650304020105000420"},"RSA-SHA256":{"sign":"ecdsa/rsa","hash":"sha256","id":"3031300d060960864801650304020105000420"},"sha384WithRSAEncryption":{"sign":"rsa","hash":"sha384","id":"3041300d060960864801650304020205000430"},"RSA-SHA384":{"sign":"ecdsa/rsa","hash":"sha384","id":"3041300d060960864801650304020205000430"},"sha512WithRSAEncryption":{"sign":"rsa","hash":"sha512","id":"3051300d060960864801650304020305000440"},"RSA-SHA512":{"sign":"ecdsa/rsa","hash":"sha512","id":"3051300d060960864801650304020305000440"},"RSA-SHA1":{"sign":"rsa","hash":"sha1","id":"3021300906052b0e03021a05000414"},"ecdsa-with-SHA1":{"sign":"ecdsa","hash":"sha1","id":""},"sha256":{"sign":"ecdsa","hash":"sha256","id":""},"sha224":{"sign":"ecdsa","hash":"sha224","id":""},"sha384":{"sign":"ecdsa","hash":"sha384","id":""},"sha512":{"sign":"ecdsa","hash":"sha512","id":""},"DSA-SHA":{"sign":"dsa","hash":"sha1","id":""},"DSA-SHA1":{"sign":"dsa","hash":"sha1","id":""},"DSA":{"sign":"dsa","hash":"sha1","id":""},"DSA-WITH-SHA224":{"sign":"dsa","hash":"sha224","id":""},"DSA-SHA224":{"sign":"dsa","hash":"sha224","id":""},"DSA-WITH-SHA256":{"sign":"dsa","hash":"sha256","id":""},"DSA-SHA256":{"sign":"dsa","hash":"sha256","id":""},"DSA-WITH-SHA384":{"sign":"dsa","hash":"sha384","id":""},"DSA-SHA384":{"sign":"dsa","hash":"sha384","id":""},"DSA-WITH-SHA512":{"sign":"dsa","hash":"sha512","id":""},"DSA-SHA512":{"sign":"dsa","hash":"sha512","id":""},"DSA-RIPEMD160":{"sign":"dsa","hash":"rmd160","id":""},"ripemd160WithRSA":{"sign":"rsa","hash":"rmd160","id":"3021300906052b2403020105000414"},"RSA-RIPEMD160":{"sign":"rsa","hash":"rmd160","id":"3021300906052b2403020105000414"},"md5WithRSAEncryption":{"sign":"rsa","hash":"md5","id":"3020300c06082a864886f70d020505000410"},"RSA-MD5":{"sign":"rsa","hash":"md5","id":"3020300c06082a864886f70d020505000410"}}');

/***/ }),

/***/ 7330:
/*!***********************************************************!*\
  !*** ../node_modules/browserify-sign/browser/curves.json ***!
  \***********************************************************/
/***/ ((module) => {

"use strict";
module.exports = JSON.parse('{"1.3.132.0.10":"secp256k1","1.3.132.0.33":"p224","1.2.840.10045.3.1.1":"p192","1.2.840.10045.3.1.7":"p256","1.3.132.0.34":"p384","1.3.132.0.35":"p521"}');

/***/ }),

/***/ 312:
/*!*********************************************!*\
  !*** ../node_modules/elliptic/package.json ***!
  \*********************************************/
/***/ ((module) => {

"use strict";
module.exports = {"i8":"6.5.4"};

/***/ }),

/***/ 8850:
/*!*********************************************!*\
  !*** ../node_modules/parse-asn1/aesid.json ***!
  \*********************************************/
/***/ ((module) => {

"use strict";
module.exports = JSON.parse('{"2.16.840.1.101.3.4.1.1":"aes-128-ecb","2.16.840.1.101.3.4.1.2":"aes-128-cbc","2.16.840.1.101.3.4.1.3":"aes-128-ofb","2.16.840.1.101.3.4.1.4":"aes-128-cfb","2.16.840.1.101.3.4.1.21":"aes-192-ecb","2.16.840.1.101.3.4.1.22":"aes-192-cbc","2.16.840.1.101.3.4.1.23":"aes-192-ofb","2.16.840.1.101.3.4.1.24":"aes-192-cfb","2.16.840.1.101.3.4.1.41":"aes-256-ecb","2.16.840.1.101.3.4.1.42":"aes-256-cbc","2.16.840.1.101.3.4.1.43":"aes-256-ofb","2.16.840.1.101.3.4.1.44":"aes-256-cfb"}');

/***/ }),

/***/ 2291:
/*!*****************************************!*\
  !*** ../node_modules/ssh2/package.json ***!
  \*****************************************/
/***/ ((module) => {

"use strict";
module.exports = {"i8":"1.11.0"};

/***/ })

/******/ 	});
/************************************************************************/
/******/ 	// The module cache
/******/ 	var __webpack_module_cache__ = {};
/******/ 	
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/ 		// Check if module is in cache
/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
/******/ 		if (cachedModule !== undefined) {
/******/ 			return cachedModule.exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = __webpack_module_cache__[moduleId] = {
/******/ 			id: moduleId,
/******/ 			loaded: false,
/******/ 			exports: {}
/******/ 		};
/******/ 	
/******/ 		// Execute the module function
/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/ 	
/******/ 		// Flag the module as loaded
/******/ 		module.loaded = true;
/******/ 	
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/ 	
/************************************************************************/
/******/ 	/* webpack/runtime/compat get default export */
/******/ 	(() => {
/******/ 		// getDefaultExport function for compatibility with non-harmony modules
/******/ 		__webpack_require__.n = (module) => {
/******/ 			var getter = module && module.__esModule ?
/******/ 				() => (module['default']) :
/******/ 				() => (module);
/******/ 			__webpack_require__.d(getter, { a: getter });
/******/ 			return getter;
/******/ 		};
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/define property getters */
/******/ 	(() => {
/******/ 		// define getter functions for harmony exports
/******/ 		__webpack_require__.d = (exports, definition) => {
/******/ 			for(var key in definition) {
/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
/******/ 				}
/******/ 			}
/******/ 		};
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
/******/ 	(() => {
/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/make namespace object */
/******/ 	(() => {
/******/ 		// define __esModule on exports
/******/ 		__webpack_require__.r = (exports) => {
/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ 			}
/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
/******/ 		};
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/node module decorator */
/******/ 	(() => {
/******/ 		__webpack_require__.nmd = (module) => {
/******/ 			module.paths = [];
/******/ 			if (!module.children) module.children = [];
/******/ 			return module;
/******/ 		};
/******/ 	})();
/******/ 	
/************************************************************************/
var __webpack_exports__ = {};
// This entry need to be wrapped in an IIFE because it need to be in strict mode.
(() => {
"use strict";
/*!***********************************!*\
  !*** ./src/index.ts + 38 modules ***!
  \***********************************/
// ESM COMPAT FLAG
__webpack_require__.r(__webpack_exports__);

// EXPORTS
__webpack_require__.d(__webpack_exports__, {
  "ALGORITHM_BLACKLIST": () => (/* reexport */ ALGORITHM_BLACKLIST),
  "AutoPrivateKeyLocator": () => (/* reexport */ AutoPrivateKeyLocator),
  "PortForwardType": () => (/* reexport */ PortForwardType),
  "SFTPContextMenuItemProvider": () => (/* reexport */ SFTPContextMenuItemProvider),
  "SFTPPanelComponent": () => (/* reexport */ SFTPPanelComponent),
  "SFTPSession": () => (/* reexport */ SFTPSession),
  "SSHAlgorithmType": () => (/* reexport */ SSHAlgorithmType),
  "SSHProfileImporter": () => (/* reexport */ SSHProfileImporter),
  "SSHProxyStream": () => (/* reexport */ SSHProxyStream),
  "SSHProxyStreamSocket": () => (/* reexport */ SSHProxyStreamSocket),
  "default": () => (/* binding */ src)
});

;// CONCATENATED MODULE: ../app/node_modules/tslib/tslib.es6.js
/******************************************************************************
Copyright (c) Microsoft Corporation.

Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
/* global Reflect, Promise */

var extendStatics = function (d, b) {
  extendStatics = Object.setPrototypeOf || {
    __proto__: []
  } instanceof Array && function (d, b) {
    d.__proto__ = b;
  } || function (d, b) {
    for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
  };
  return extendStatics(d, b);
};
function __extends(d, b) {
  if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
  extendStatics(d, b);
  function __() {
    this.constructor = d;
  }
  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
var __assign = function () {
  __assign = Object.assign || function __assign(t) {
    for (var s, i = 1, n = arguments.length; i < n; i++) {
      s = arguments[i];
      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
    }
    return t;
  };
  return __assign.apply(this, arguments);
};
function __rest(s, e) {
  var t = {};
  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
  }
  return t;
}
function __decorate(decorators, target, key, desc) {
  var c = arguments.length,
    r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc,
    d;
  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
  return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function __param(paramIndex, decorator) {
  return function (target, key) {
    decorator(target, key, paramIndex);
  };
}
function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
  function accept(f) {
    if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
    return f;
  }
  var kind = contextIn.kind,
    key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
  var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
  var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
  var _,
    done = false;
  for (var i = decorators.length - 1; i >= 0; i--) {
    var context = {};
    for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
    for (var p in contextIn.access) context.access[p] = contextIn.access[p];
    context.addInitializer = function (f) {
      if (done) throw new TypeError("Cannot add initializers after decoration has completed");
      extraInitializers.push(accept(f || null));
    };
    var result = (0, decorators[i])(kind === "accessor" ? {
      get: descriptor.get,
      set: descriptor.set
    } : descriptor[key], context);
    if (kind === "accessor") {
      if (result === void 0) continue;
      if (result === null || typeof result !== "object") throw new TypeError("Object expected");
      if (_ = accept(result.get)) descriptor.get = _;
      if (_ = accept(result.set)) descriptor.set = _;
      if (_ = accept(result.init)) initializers.push(_);
    } else if (_ = accept(result)) {
      if (kind === "field") initializers.push(_);else descriptor[key] = _;
    }
  }
  if (target) Object.defineProperty(target, contextIn.name, descriptor);
  done = true;
}
;
function __runInitializers(thisArg, initializers, value) {
  var useValue = arguments.length > 2;
  for (var i = 0; i < initializers.length; i++) {
    value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
  }
  return useValue ? value : void 0;
}
;
function __propKey(x) {
  return typeof x === "symbol" ? x : "".concat(x);
}
;
function __setFunctionName(f, name, prefix) {
  if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
  return Object.defineProperty(f, "name", {
    configurable: true,
    value: prefix ? "".concat(prefix, " ", name) : name
  });
}
;
function __metadata(metadataKey, metadataValue) {
  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
}
function __awaiter(thisArg, _arguments, P, generator) {
  function adopt(value) {
    return value instanceof P ? value : new P(function (resolve) {
      resolve(value);
    });
  }
  return new (P || (P = Promise))(function (resolve, reject) {
    function fulfilled(value) {
      try {
        step(generator.next(value));
      } catch (e) {
        reject(e);
      }
    }
    function rejected(value) {
      try {
        step(generator["throw"](value));
      } catch (e) {
        reject(e);
      }
    }
    function step(result) {
      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
    }
    step((generator = generator.apply(thisArg, _arguments || [])).next());
  });
}
function __generator(thisArg, body) {
  var _ = {
      label: 0,
      sent: function () {
        if (t[0] & 1) throw t[1];
        return t[1];
      },
      trys: [],
      ops: []
    },
    f,
    y,
    t,
    g;
  return g = {
    next: verb(0),
    "throw": verb(1),
    "return": verb(2)
  }, typeof Symbol === "function" && (g[Symbol.iterator] = function () {
    return this;
  }), g;
  function verb(n) {
    return function (v) {
      return step([n, v]);
    };
  }
  function step(op) {
    if (f) throw new TypeError("Generator is already executing.");
    while (g && (g = 0, op[0] && (_ = 0)), _) try {
      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
      if (y = 0, t) op = [op[0] & 2, t.value];
      switch (op[0]) {
        case 0:
        case 1:
          t = op;
          break;
        case 4:
          _.label++;
          return {
            value: op[1],
            done: false
          };
        case 5:
          _.label++;
          y = op[1];
          op = [0];
          continue;
        case 7:
          op = _.ops.pop();
          _.trys.pop();
          continue;
        default:
          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
            _ = 0;
            continue;
          }
          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
            _.label = op[1];
            break;
          }
          if (op[0] === 6 && _.label < t[1]) {
            _.label = t[1];
            t = op;
            break;
          }
          if (t && _.label < t[2]) {
            _.label = t[2];
            _.ops.push(op);
            break;
          }
          if (t[2]) _.ops.pop();
          _.trys.pop();
          continue;
      }
      op = body.call(thisArg, _);
    } catch (e) {
      op = [6, e];
      y = 0;
    } finally {
      f = t = 0;
    }
    if (op[0] & 5) throw op[1];
    return {
      value: op[0] ? op[1] : void 0,
      done: true
    };
  }
}
var __createBinding = Object.create ? function (o, m, k, k2) {
  if (k2 === undefined) k2 = k;
  var desc = Object.getOwnPropertyDescriptor(m, k);
  if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
    desc = {
      enumerable: true,
      get: function () {
        return m[k];
      }
    };
  }
  Object.defineProperty(o, k2, desc);
} : function (o, m, k, k2) {
  if (k2 === undefined) k2 = k;
  o[k2] = m[k];
};
function __exportStar(m, o) {
  for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);
}
function __values(o) {
  var s = typeof Symbol === "function" && Symbol.iterator,
    m = s && o[s],
    i = 0;
  if (m) return m.call(o);
  if (o && typeof o.length === "number") return {
    next: function () {
      if (o && i >= o.length) o = void 0;
      return {
        value: o && o[i++],
        done: !o
      };
    }
  };
  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
}
function __read(o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
    r,
    ar = [],
    e;
  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }
  return ar;
}

/** @deprecated */
function __spread() {
  for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
  return ar;
}

/** @deprecated */
function __spreadArrays() {
  for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
  for (var r = Array(s), k = 0, i = 0; i < il; i++) for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) r[k] = a[j];
  return r;
}
function __spreadArray(to, from, pack) {
  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
    if (ar || !(i in from)) {
      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
      ar[i] = from[i];
    }
  }
  return to.concat(ar || Array.prototype.slice.call(from));
}
function __await(v) {
  return this instanceof __await ? (this.v = v, this) : new __await(v);
}
function __asyncGenerator(thisArg, _arguments, generator) {
  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
  var g = generator.apply(thisArg, _arguments || []),
    i,
    q = [];
  return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () {
    return this;
  }, i;
  function verb(n) {
    if (g[n]) i[n] = function (v) {
      return new Promise(function (a, b) {
        q.push([n, v, a, b]) > 1 || resume(n, v);
      });
    };
  }
  function resume(n, v) {
    try {
      step(g[n](v));
    } catch (e) {
      settle(q[0][3], e);
    }
  }
  function step(r) {
    r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
  }
  function fulfill(value) {
    resume("next", value);
  }
  function reject(value) {
    resume("throw", value);
  }
  function settle(f, v) {
    if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
  }
}
function __asyncDelegator(o) {
  var i, p;
  return i = {}, verb("next"), verb("throw", function (e) {
    throw e;
  }), verb("return"), i[Symbol.iterator] = function () {
    return this;
  }, i;
  function verb(n, f) {
    i[n] = o[n] ? function (v) {
      return (p = !p) ? {
        value: __await(o[n](v)),
        done: false
      } : f ? f(v) : v;
    } : f;
  }
}
function __asyncValues(o) {
  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
  var m = o[Symbol.asyncIterator],
    i;
  return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () {
    return this;
  }, i);
  function verb(n) {
    i[n] = o[n] && function (v) {
      return new Promise(function (resolve, reject) {
        v = o[n](v), settle(resolve, reject, v.done, v.value);
      });
    };
  }
  function settle(resolve, reject, d, v) {
    Promise.resolve(v).then(function (v) {
      resolve({
        value: v,
        done: d
      });
    }, reject);
  }
}
function __makeTemplateObject(cooked, raw) {
  if (Object.defineProperty) {
    Object.defineProperty(cooked, "raw", {
      value: raw
    });
  } else {
    cooked.raw = raw;
  }
  return cooked;
}
;
var __setModuleDefault = Object.create ? function (o, v) {
  Object.defineProperty(o, "default", {
    enumerable: true,
    value: v
  });
} : function (o, v) {
  o["default"] = v;
};
function __importStar(mod) {
  if (mod && mod.__esModule) return mod;
  var result = {};
  if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
  __setModuleDefault(result, mod);
  return result;
}
function __importDefault(mod) {
  return mod && mod.__esModule ? mod : {
    default: mod
  };
}
function __classPrivateFieldGet(receiver, state, kind, f) {
  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
}
function __classPrivateFieldSet(receiver, state, value, kind, f) {
  if (kind === "m") throw new TypeError("Private method is not writable");
  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
  return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
}
function __classPrivateFieldIn(state, receiver) {
  if (receiver === null || typeof receiver !== "object" && typeof receiver !== "function") throw new TypeError("Cannot use 'in' operator on non-object");
  return typeof state === "function" ? receiver === state : state.has(receiver);
}
// EXTERNAL MODULE: external "@angular/core"
var core_ = __webpack_require__(8900);
// EXTERNAL MODULE: external "@angular/common"
var common_ = __webpack_require__(5848);
// EXTERNAL MODULE: external "@angular/forms"
var forms_ = __webpack_require__(7161);
// EXTERNAL MODULE: external "@ng-bootstrap/ng-bootstrap"
var ng_bootstrap_ = __webpack_require__(7571);
// EXTERNAL MODULE: external "ngx-toastr"
var external_ngx_toastr_ = __webpack_require__(7170);
// EXTERNAL MODULE: ../app/node_modules/filesize/lib/filesize.min.js
var filesize_min = __webpack_require__(1752);
;// CONCATENATED MODULE: ../app/node_modules/ngx-filesize/fesm2015/ngx-filesize.mjs



class FileSizePipe {
  static transformOne(value, options) {
    return filesize_min(value, options);
  }
  transform(value, options) {
    if (Array.isArray(value)) {
      return value.map(val => FileSizePipe.transformOne(val, options));
    }
    return FileSizePipe.transformOne(value, options);
  }
}
FileSizePipe.ɵfac = function FileSizePipe_Factory(t) {
  return new (t || FileSizePipe)();
};
FileSizePipe.ɵpipe = /* @__PURE__ */core_["ɵɵdefinePipe"]({
  name: "filesize",
  type: FileSizePipe,
  pure: true
});
(function () {
  (typeof ngDevMode === "undefined" || ngDevMode) && core_["ɵsetClassMetadata"](FileSizePipe, [{
    type: core_.Pipe,
    args: [{
      name: 'filesize'
    }]
  }], null, null);
})();
class NgxFilesizeModule {}
NgxFilesizeModule.ɵfac = function NgxFilesizeModule_Factory(t) {
  return new (t || NgxFilesizeModule)();
};
NgxFilesizeModule.ɵmod = /* @__PURE__ */core_["ɵɵdefineNgModule"]({
  type: NgxFilesizeModule,
  declarations: [FileSizePipe],
  exports: [FileSizePipe]
});
NgxFilesizeModule.ɵinj = /* @__PURE__ */core_["ɵɵdefineInjector"]({});
(function () {
  (typeof ngDevMode === "undefined" || ngDevMode) && core_["ɵsetClassMetadata"](NgxFilesizeModule, [{
    type: core_.NgModule,
    args: [{
      declarations: [FileSizePipe],
      exports: [FileSizePipe]
    }]
  }], null, null);
})();

/*
 * Public API Surface of ngx-filesize
 */

/**
 * Generated bundle index. Do not edit.
 */


// EXTERNAL MODULE: external "tabby-core"
var external_tabby_core_ = __webpack_require__(315);
var external_tabby_core_default = /*#__PURE__*/__webpack_require__.n(external_tabby_core_);
// EXTERNAL MODULE: external "tabby-settings"
var external_tabby_settings_ = __webpack_require__(6663);
// EXTERNAL MODULE: external "tabby-terminal"
var external_tabby_terminal_ = __webpack_require__(8316);
var external_tabby_terminal_default = /*#__PURE__*/__webpack_require__.n(external_tabby_terminal_);
// EXTERNAL MODULE: ./src/components/sshProfileSettings.component.pug?ngResource
var sshProfileSettings_componentngResource = __webpack_require__(1295);
var sshProfileSettings_componentngResource_default = /*#__PURE__*/__webpack_require__.n(sshProfileSettings_componentngResource);
// EXTERNAL MODULE: ../node_modules/thenby/thenBy.module.js
var thenBy_module = __webpack_require__(8635);
// EXTERNAL MODULE: external "keytar"
var external_keytar_ = __webpack_require__(5860);
;// CONCATENATED MODULE: ./src/services/passwordStorage.service.ts




const VAULT_SECRET_TYPE_PASSWORD = 'ssh:password';
const VAULT_SECRET_TYPE_PASSPHRASE = 'ssh:key-passphrase';
let PasswordStorageService = class PasswordStorageService {
    constructor(vault) {
        this.vault = vault;
    }
    savePassword(profile, password) {
        return __awaiter(this, void 0, void 0, function* () {
            if (this.vault.isEnabled()) {
                const key = this.getVaultKeyForConnection(profile);
                this.vault.addSecret({ type: VAULT_SECRET_TYPE_PASSWORD, key, value: password });
            }
            else {
                const key = this.getKeytarKeyForConnection(profile);
                return external_keytar_.setPassword(key, profile.options.user, password);
            }
        });
    }
    deletePassword(profile) {
        return __awaiter(this, void 0, void 0, function* () {
            if (this.vault.isEnabled()) {
                const key = this.getVaultKeyForConnection(profile);
                this.vault.removeSecret(VAULT_SECRET_TYPE_PASSWORD, key);
            }
            else {
                const key = this.getKeytarKeyForConnection(profile);
                yield external_keytar_.deletePassword(key, profile.options.user);
            }
        });
    }
    loadPassword(profile) {
        var _a, _b;
        return __awaiter(this, void 0, void 0, function* () {
            if (this.vault.isEnabled()) {
                const key = this.getVaultKeyForConnection(profile);
                return (_b = (_a = (yield this.vault.getSecret(VAULT_SECRET_TYPE_PASSWORD, key))) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : null;
            }
            else {
                const key = this.getKeytarKeyForConnection(profile);
                return external_keytar_.getPassword(key, profile.options.user);
            }
        });
    }
    savePrivateKeyPassword(id, password) {
        return __awaiter(this, void 0, void 0, function* () {
            if (this.vault.isEnabled()) {
                const key = this.getVaultKeyForPrivateKey(id);
                this.vault.addSecret({ type: VAULT_SECRET_TYPE_PASSPHRASE, key, value: password });
            }
            else {
                const key = this.getKeytarKeyForPrivateKey(id);
                return external_keytar_.setPassword(key, 'user', password);
            }
        });
    }
    deletePrivateKeyPassword(id) {
        return __awaiter(this, void 0, void 0, function* () {
            if (this.vault.isEnabled()) {
                const key = this.getVaultKeyForPrivateKey(id);
                this.vault.removeSecret(VAULT_SECRET_TYPE_PASSPHRASE, key);
            }
            else {
                const key = this.getKeytarKeyForPrivateKey(id);
                yield external_keytar_.deletePassword(key, 'user');
            }
        });
    }
    loadPrivateKeyPassword(id) {
        var _a, _b;
        return __awaiter(this, void 0, void 0, function* () {
            if (this.vault.isEnabled()) {
                const key = this.getVaultKeyForPrivateKey(id);
                return (_b = (_a = (yield this.vault.getSecret(VAULT_SECRET_TYPE_PASSPHRASE, key))) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : null;
            }
            else {
                const key = this.getKeytarKeyForPrivateKey(id);
                return external_keytar_.getPassword(key, 'user');
            }
        });
    }
    getKeytarKeyForConnection(profile) {
        let key = `ssh@${profile.options.host}`;
        if (profile.options.port) {
            key = `ssh@${profile.options.host}:${profile.options.port}`;
        }
        return key;
    }
    getKeytarKeyForPrivateKey(id) {
        return `ssh-private-key:${id}`;
    }
    getVaultKeyForConnection(profile) {
        return {
            user: profile.options.user,
            host: profile.options.host,
            port: profile.options.port,
        };
    }
    getVaultKeyForPrivateKey(id) {
        return { hash: id };
    }
};
PasswordStorageService.ctorParameters = () => [
    { type: external_tabby_core_.VaultService }
];
PasswordStorageService = __decorate([
    (0,core_.Injectable)({ providedIn: 'root' }),
    __metadata("design:paramtypes", [external_tabby_core_.VaultService])
], PasswordStorageService);


;// CONCATENATED MODULE: ./src/api/contextMenu.ts
/**
 * Extend to add items to the SFTPPanel context menu
 */
class SFTPContextMenuItemProvider {
    constructor() {
        this.weight = 0;
    }
}

;// CONCATENATED MODULE: ./src/api/interfaces.ts
var SSHAlgorithmType;
(function (SSHAlgorithmType) {
    SSHAlgorithmType["HMAC"] = "hmac";
    SSHAlgorithmType["KEX"] = "kex";
    SSHAlgorithmType["CIPHER"] = "cipher";
    SSHAlgorithmType["HOSTKEY"] = "serverHostKey";
})(SSHAlgorithmType || (SSHAlgorithmType = {}));
var PortForwardType;
(function (PortForwardType) {
    PortForwardType["Local"] = "Local";
    PortForwardType["Remote"] = "Remote";
    PortForwardType["Dynamic"] = "Dynamic";
})(PortForwardType || (PortForwardType = {}));
let ALGORITHM_BLACKLIST = [
    // cause native crashes in node crypto, use EC instead
    'diffie-hellman-group-exchange-sha256',
    'diffie-hellman-group-exchange-sha1',
];
if (!process.env.TABBY_ENABLE_SSH_ALG_BLACKLIST) {
    ALGORITHM_BLACKLIST = [];
}

;// CONCATENATED MODULE: ./src/api/importer.ts
class SSHProfileImporter {
}
class AutoPrivateKeyLocator {
}

// EXTERNAL MODULE: external "rxjs"
var external_rxjs_ = __webpack_require__(3832);
// EXTERNAL MODULE: external "stream"
var external_stream_ = __webpack_require__(3978);
;// CONCATENATED MODULE: ./src/api/proxyStream.ts



class SSHProxyStreamSocket extends external_stream_.Duplex {
    constructor(parent) {
        super({
            allowHalfOpen: false,
        });
        this.parent = parent;
    }
    _read(size) {
        this.parent.requestData(size);
    }
    _write(chunk, _encoding, callback) {
        this.parent.consumeInput(chunk).then(() => callback(null), e => callback(e));
    }
    _destroy(error, callback) {
        this.parent.handleStopRequest(error).then(() => callback(null), e => callback(e));
    }
}
class SSHProxyStream {
    constructor() {
        this.message = new external_rxjs_.Subject();
        this.destroyed = new external_rxjs_.Subject();
        this._socket = null;
    }
    get message$() { return this.message; }
    get destroyed$() { return this.destroyed; }
    get socket() { return this._socket; }
    start() {
        return __awaiter(this, void 0, void 0, function* () {
            if (!this._socket) {
                this._socket = new SSHProxyStreamSocket(this);
            }
            return this._socket;
        });
    }
    emitMessage(message) {
        this.message.next(message);
    }
    emitOutput(data) {
        var _a;
        (_a = this._socket) === null || _a === void 0 ? void 0 : _a.push(data);
    }
    handleStopRequest(error) {
        return __awaiter(this, void 0, void 0, function* () {
            this.destroyed.next(error);
            this.destroyed.complete();
            this.message.complete();
        });
    }
    stop(error) {
        var _a;
        (_a = this._socket) === null || _a === void 0 ? void 0 : _a.destroy(error);
    }
}

;// CONCATENATED MODULE: ./src/api/index.ts





// EXTERNAL MODULE: ../node_modules/ssh2/lib/protocol/constants.js
var constants = __webpack_require__(7816);
;// CONCATENATED MODULE: ./src/algorithms.ts


// Counteracts https://github.com/mscdex/ssh2/commit/f1b5ac3c81734c194740016eab79a699efae83d8
constants.DEFAULT_CIPHER.push('aes128-gcm');
constants.DEFAULT_CIPHER.push('aes256-gcm');
constants.SUPPORTED_CIPHER.push('aes128-gcm');
constants.SUPPORTED_CIPHER.push('aes256-gcm');
const supportedAlgorithms = {};
for (const k of Object.values(SSHAlgorithmType)) {
    const supportedAlg = {
        [SSHAlgorithmType.KEX]: 'SUPPORTED_KEX',
        [SSHAlgorithmType.HOSTKEY]: 'SUPPORTED_SERVER_HOST_KEY',
        [SSHAlgorithmType.CIPHER]: 'SUPPORTED_CIPHER',
        [SSHAlgorithmType.HMAC]: 'SUPPORTED_MAC',
    }[k];
    supportedAlgorithms[k] = constants[supportedAlg].filter(x => !ALGORITHM_BLACKLIST.includes(x)).sort();
}

;// CONCATENATED MODULE: ./src/components/sshProfileSettings.component.ts


/* eslint-disable @typescript-eslint/explicit-module-boundary-types */







/** @hidden */
let SSHProfileSettingsComponent = class SSHProfileSettingsComponent {
    constructor(hostApp, config, passwordStorage, ngbModal, fileProviders) {
        this.hostApp = hostApp;
        this.config = config;
        this.passwordStorage = passwordStorage;
        this.ngbModal = ngbModal;
        this.fileProviders = fileProviders;
        this.Platform = external_tabby_core_.Platform;
        this.connectionMode = 'direct';
        this.supportedAlgorithms = supportedAlgorithms;
        this.algorithms = {};
    }
    ngOnInit() {
        var _a, _b, _c, _d;
        var _e;
        return __awaiter(this, void 0, void 0, function* () {
            this.jumpHosts = this.config.store.profiles.filter(x => x.type === 'ssh' && x !== this.profile);
            this.jumpHosts.sort((0,thenBy_module.firstBy)(x => this.getJumpHostLabel(x)));
            for (const k of Object.values(SSHAlgorithmType)) {
                this.algorithms[k] = {};
                for (const alg of (_b = (_a = this.profile.options.algorithms) === null || _a === void 0 ? void 0 : _a[k]) !== null && _b !== void 0 ? _b : []) {
                    this.algorithms[k][alg] = true;
                }
            }
            this.profile.options.auth = (_c = this.profile.options.auth) !== null && _c !== void 0 ? _c : null;
            (_d = (_e = this.profile.options).privateKeys) !== null && _d !== void 0 ? _d : (_e.privateKeys = []);
            if (this.profile.options.proxyCommand) {
                this.connectionMode = 'proxyCommand';
            }
            else if (this.profile.options.jumpHost) {
                this.connectionMode = 'jumpHost';
            }
            else if (this.profile.options.socksProxyHost) {
                this.connectionMode = 'socksProxy';
            }
            else if (this.profile.options.httpProxyHost) {
                this.connectionMode = 'httpProxy';
            }
            if (this.profile.options.user) {
                try {
                    this.hasSavedPassword = !!(yield this.passwordStorage.loadPassword(this.profile));
                }
                catch (e) {
                    console.error('Could not check for saved password', e);
                }
            }
        });
    }
    getJumpHostLabel(p) {
        return p.group ? `${p.group} / ${p.name}` : p.name;
    }
    setPassword() {
        return __awaiter(this, void 0, void 0, function* () {
            const modal = this.ngbModal.open(external_tabby_core_.PromptModalComponent);
            modal.componentInstance.prompt = `Password for ${this.profile.options.user}@${this.profile.options.host}`;
            modal.componentInstance.password = true;
            try {
                const result = yield modal.result;
                if (result === null || result === void 0 ? void 0 : result.value) {
                    this.passwordStorage.savePassword(this.profile, result.value);
                    this.hasSavedPassword = true;
                }
            }
            catch (_a) { }
        });
    }
    clearSavedPassword() {
        this.hasSavedPassword = false;
        this.passwordStorage.deletePassword(this.profile);
    }
    addPrivateKey() {
        return __awaiter(this, void 0, void 0, function* () {
            const ref = yield this.fileProviders.selectAndStoreFile(`private key for ${this.profile.name}`);
            this.profile.options.privateKeys = [
                ...this.profile.options.privateKeys,
                ref,
            ];
        });
    }
    removePrivateKey(path) {
        var _a;
        this.profile.options.privateKeys = (_a = this.profile.options.privateKeys) === null || _a === void 0 ? void 0 : _a.filter(x => x !== path);
    }
    save() {
        var _a;
        for (const k of Object.values(SSHAlgorithmType)) {
            this.profile.options.algorithms[k] = Object.entries(this.algorithms[k])
                .filter(([_, v]) => !!v)
                .map(([key, _]) => key);
            this.profile.options.algorithms[k].sort();
        }
        if (this.connectionMode !== 'jumpHost') {
            this.profile.options.jumpHost = undefined;
        }
        if (this.connectionMode !== 'proxyCommand') {
            this.profile.options.proxyCommand = undefined;
        }
        if (this.connectionMode !== 'socksProxy') {
            this.profile.options.socksProxyHost = undefined;
            this.profile.options.socksProxyPort = undefined;
        }
        if (this.connectionMode !== 'httpProxy') {
            this.profile.options.httpProxyHost = undefined;
            this.profile.options.httpProxyPort = undefined;
        }
        (_a = this.loginScriptsSettings) === null || _a === void 0 ? void 0 : _a.save();
    }
    onForwardAdded(fw) {
        var _a;
        this.profile.options.forwardedPorts = (_a = this.profile.options.forwardedPorts) !== null && _a !== void 0 ? _a : [];
        this.profile.options.forwardedPorts.push(fw);
    }
    onForwardRemoved(fw) {
        var _a;
        this.profile.options.forwardedPorts = (_a = this.profile.options.forwardedPorts) === null || _a === void 0 ? void 0 : _a.filter(x => x !== fw);
    }
    getConnectionDropdownTitle() {
        return {
            direct: 'Direct',
            proxyCommand: 'Proxy command',
            jumpHost: 'Jump host',
            socksProxy: 'SOCKS proxy',
            httpProxy: 'HTTP proxy',
        }[this.connectionMode];
    }
};
SSHProfileSettingsComponent.ctorParameters = () => [
    { type: external_tabby_core_.HostAppService },
    { type: external_tabby_core_.ConfigService },
    { type: PasswordStorageService },
    { type: ng_bootstrap_.NgbModal },
    { type: external_tabby_core_.FileProvidersService }
];
SSHProfileSettingsComponent.propDecorators = {
    loginScriptsSettings: [{ type: core_.ViewChild, args: ['loginScriptsSettings',] }]
};
SSHProfileSettingsComponent = __decorate([
    (0,core_.Component)({
        template: (sshProfileSettings_componentngResource_default()),
    }),
    __metadata("design:paramtypes", [external_tabby_core_.HostAppService,
        external_tabby_core_.ConfigService,
        PasswordStorageService,
        ng_bootstrap_.NgbModal,
        external_tabby_core_.FileProvidersService])
], SSHProfileSettingsComponent);


// EXTERNAL MODULE: ./src/components/sshPortForwardingModal.component.pug?ngResource
var sshPortForwardingModal_componentngResource = __webpack_require__(1355);
var sshPortForwardingModal_componentngResource_default = /*#__PURE__*/__webpack_require__.n(sshPortForwardingModal_componentngResource);
// EXTERNAL MODULE: external "@luminati-io/socksv5"
var socksv5_ = __webpack_require__(6608);
var socksv5_default = /*#__PURE__*/__webpack_require__.n(socksv5_);
// EXTERNAL MODULE: external "net"
var external_net_ = __webpack_require__(1548);
;// CONCATENATED MODULE: ./src/session/forwards.ts




class ForwardedPort {
    constructor() {
        this.host = '127.0.0.1';
        this.listener = null;
    }
    startLocalListener(callback) {
        return __awaiter(this, void 0, void 0, function* () {
            if (this.type === PortForwardType.Local) {
                const listener = this.listener = (0,external_net_.createServer)(s => {
                    var _a, _b;
                    return callback(() => s, () => s.destroy(), (_a = s.remoteAddress) !== null && _a !== void 0 ? _a : null, (_b = s.remotePort) !== null && _b !== void 0 ? _b : null, this.targetAddress, this.targetPort);
                });
                return new Promise((resolve, reject) => {
                    listener.listen(this.port, this.host);
                    listener.on('error', reject);
                    listener.on('listening', resolve);
                });
            }
            else if (this.type === PortForwardType.Dynamic) {
                return new Promise((resolve, reject) => {
                    this.listener = socksv5_default().createServer((info, acceptConnection, rejectConnection) => {
                        callback(() => acceptConnection(true), () => rejectConnection(), null, null, info.dstAddr, info.dstPort);
                    });
                    this.listener.on('error', reject);
                    this.listener.listen(this.port, this.host, resolve);
                    this.listener['useAuth'](socksv5_default().auth.None());
                });
            }
            else {
                throw new Error('Invalid forward type for a local listener');
            }
        });
    }
    stopLocalListener() {
        var _a;
        (_a = this.listener) === null || _a === void 0 ? void 0 : _a.close();
    }
    toString() {
        if (this.type === PortForwardType.Local) {
            return `(local) ${this.host}:${this.port} → (remote) ${this.targetAddress}:${this.targetPort}`;
        }
        if (this.type === PortForwardType.Remote) {
            return `(remote) ${this.host}:${this.port} → (local) ${this.targetAddress}:${this.targetPort}`;
        }
        else {
            return `(dynamic) ${this.host}:${this.port}`;
        }
    }
}

// EXTERNAL MODULE: ../app/node_modules/mz/fs.js
var fs = __webpack_require__(7461);
// EXTERNAL MODULE: external "crypto"
var external_crypto_ = __webpack_require__(6113);
// EXTERNAL MODULE: ./node_modules/sshpk/lib/index.js
var lib = __webpack_require__(4513);
// EXTERNAL MODULE: ./node_modules/ansi-colors/index.js
var ansi_colors = __webpack_require__(4596);
var ansi_colors_default = /*#__PURE__*/__webpack_require__.n(ansi_colors);
;// CONCATENATED MODULE: ./node_modules/ansi-regex/index.js
function ansiRegex({
  onlyFirst = false
} = {}) {
  const pattern = ['[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)', '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))'].join('|');
  return new RegExp(pattern, onlyFirst ? undefined : 'g');
}
;// CONCATENATED MODULE: ./node_modules/strip-ansi/index.js

function stripAnsi(string) {
  if (typeof string !== 'string') {
    throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
  }
  return string.replace(ansiRegex(), '');
}
// EXTERNAL MODULE: ../node_modules/ssh2/lib/index.js
var ssh2_lib = __webpack_require__(9647);
// EXTERNAL MODULE: ./src/components/hostKeyPromptModal.component.pug?ngResource
var hostKeyPromptModal_componentngResource = __webpack_require__(5098);
var hostKeyPromptModal_componentngResource_default = /*#__PURE__*/__webpack_require__.n(hostKeyPromptModal_componentngResource);
;// CONCATENATED MODULE: ./src/services/sshKnownHosts.service.ts



let SSHKnownHostsService = class SSHKnownHostsService {
    constructor(config) {
        this.config = config;
    }
    getFor(selector) {
        var _a;
        return (_a = this.config.store.ssh.knownHosts.find(x => x.host === selector.host && x.port === selector.port && x.type === selector.type)) !== null && _a !== void 0 ? _a : null;
    }
    store(selector, digest) {
        return __awaiter(this, void 0, void 0, function* () {
            const existing = this.getFor(selector);
            if (existing) {
                existing.digest = digest;
            }
            else {
                this.config.store.ssh.knownHosts.push(Object.assign(Object.assign({}, selector), { digest }));
            }
            this.config.save();
        });
    }
};
SSHKnownHostsService.ctorParameters = () => [
    { type: external_tabby_core_.ConfigService }
];
SSHKnownHostsService = __decorate([
    (0,core_.Injectable)({ providedIn: 'root' }),
    __metadata("design:paramtypes", [external_tabby_core_.ConfigService])
], SSHKnownHostsService);


;// CONCATENATED MODULE: ./src/components/hostKeyPromptModal.component.ts


/* eslint-disable @typescript-eslint/explicit-module-boundary-types */



/** @hidden */
let HostKeyPromptModalComponent = class HostKeyPromptModalComponent {
    constructor(knownHosts, modalInstance) {
        this.knownHosts = knownHosts;
        this.modalInstance = modalInstance;
        this.isMismatched = false;
        this.isUnknown = false;
    }
    ngOnInit() {
        this.knownHost = this.knownHosts.getFor(this.selector);
        if (!this.knownHost) {
            this.isUnknown = true;
        }
        else if (this.knownHost.digest !== this.digest) {
            this.isMismatched = true;
        }
    }
    accept() {
        this.modalInstance.close(true);
    }
    acceptAndSave() {
        return __awaiter(this, void 0, void 0, function* () {
            yield this.knownHosts.store(this.selector, this.digest);
            this.accept();
        });
    }
    cancel() {
        this.modalInstance.close(false);
    }
};
HostKeyPromptModalComponent.ctorParameters = () => [
    { type: SSHKnownHostsService },
    { type: ng_bootstrap_.NgbActiveModal }
];
HostKeyPromptModalComponent.propDecorators = {
    selector: [{ type: core_.Input }],
    digest: [{ type: core_.Input }]
};
HostKeyPromptModalComponent = __decorate([
    (0,core_.Component)({
        template: (hostKeyPromptModal_componentngResource_default()),
    }),
    __metadata("design:paramtypes", [SSHKnownHostsService,
        ng_bootstrap_.NgbActiveModal])
], HostKeyPromptModalComponent);


// EXTERNAL MODULE: ../node_modules/shell-quote/index.js
var shell_quote = __webpack_require__(6830);
;// CONCATENATED MODULE: external "fs/promises"
const promises_namespaceObject = require("fs/promises");
// EXTERNAL MODULE: ./node_modules/tmp-promise/index.js
var tmp_promise = __webpack_require__(8995);
// EXTERNAL MODULE: external "child_process"
var external_child_process_ = __webpack_require__(7198);
;// CONCATENATED MODULE: ./src/services/ssh.service.ts











let SSHService = class SSHService {
    constructor(passwordStorage, config, hostApp, platform) {
        this.passwordStorage = passwordStorage;
        this.config = config;
        this.platform = platform;
        if (hostApp.platform === external_tabby_core_.Platform.Windows) {
            this.detectedWinSCPPath = platform.getWinSCPPath();
        }
    }
    getWinSCPPath() {
        var _a;
        return (_a = this.detectedWinSCPPath) !== null && _a !== void 0 ? _a : this.config.store.ssh.winSCPPath;
    }
    getWinSCPURI(profile, cwd, username) {
        return __awaiter(this, void 0, void 0, function* () {
            let uri = `scp://${username !== null && username !== void 0 ? username : profile.options.user}`;
            const password = yield this.passwordStorage.loadPassword(profile);
            if (password) {
                uri += ':' + encodeURIComponent(password);
            }
            uri += `@${profile.options.host}:${profile.options.port}${cwd !== null && cwd !== void 0 ? cwd : '/'}`;
            return uri;
        });
    }
    launchWinSCP(session) {
        var _a;
        return __awaiter(this, void 0, void 0, function* () {
            const path = this.getWinSCPPath();
            if (!path) {
                return;
            }
            const args = [yield this.getWinSCPURI(session.profile, undefined, (_a = session.authUsername) !== null && _a !== void 0 ? _a : undefined)];
            let tmpFile = null;
            if (session.activePrivateKey) {
                tmpFile = yield tmp_promise.file();
                yield promises_namespaceObject.writeFile(tmpFile.path, session.activePrivateKey);
                const winSCPcom = path.slice(0, -3) + 'com';
                yield this.platform.exec(winSCPcom, ['/keygen', tmpFile.path, `/output=${tmpFile.path}`]);
                args.push(`/privatekey=${tmpFile.path}`);
            }
            yield this.platform.exec(path, args);
            tmpFile === null || tmpFile === void 0 ? void 0 : tmpFile.cleanup();
        });
    }
};
SSHService.ctorParameters = () => [
    { type: PasswordStorageService },
    { type: external_tabby_core_.ConfigService },
    { type: external_tabby_core_.HostAppService },
    { type: external_tabby_core_.PlatformService }
];
SSHService = __decorate([
    (0,core_.Injectable)({ providedIn: 'root' }),
    __metadata("design:paramtypes", [PasswordStorageService,
        external_tabby_core_.ConfigService,
        external_tabby_core_.HostAppService,
        external_tabby_core_.PlatformService])
], SSHService);

class ProxyCommandStream extends SSHProxyStream {
    constructor(command) {
        super();
        this.command = command;
    }
    start() {
        const _super = Object.create(null, {
            start: { get: () => super.start }
        });
        var _a, _b, _c;
        return __awaiter(this, void 0, void 0, function* () {
            const argv = shell_quote/* parse */.Q(this.command);
            this.process = (0,external_child_process_.spawn)(argv[0], argv.slice(1), {
                windowsHide: true,
                stdio: ['pipe', 'pipe', 'pipe'],
            });
            this.process.on('error', error => {
                this.stop(new Error(`Proxy command has failed to start: ${error.message}`));
            });
            this.process.on('exit', code => {
                this.stop(new Error(`Proxy command has exited with code ${code}`));
            });
            (_a = this.process.stdout) === null || _a === void 0 ? void 0 : _a.on('data', data => {
                this.emitOutput(data);
            });
            (_b = this.process.stdout) === null || _b === void 0 ? void 0 : _b.on('error', (err) => {
                this.stop(err);
            });
            (_c = this.process.stderr) === null || _c === void 0 ? void 0 : _c.on('data', data => {
                this.emitMessage(data.toString());
            });
            return _super.start.call(this);
        });
    }
    requestData(size) {
        var _a, _b;
        (_b = (_a = this.process) === null || _a === void 0 ? void 0 : _a.stdout) === null || _b === void 0 ? void 0 : _b.read(size);
    }
    consumeInput(data) {
        return __awaiter(this, void 0, void 0, function* () {
            const process = this.process;
            if (process) {
                yield new Promise(resolve => { var _a; return (_a = process.stdin) === null || _a === void 0 ? void 0 : _a.write(data, resolve); });
            }
        });
    }
    stop(error) {
        const _super = Object.create(null, {
            stop: { get: () => super.stop }
        });
        var _a;
        return __awaiter(this, void 0, void 0, function* () {
            (_a = this.process) === null || _a === void 0 ? void 0 : _a.kill();
            _super.stop.call(this, error);
        });
    }
}
class SocksProxyStream extends SSHProxyStream {
    constructor(profile) {
        super();
        this.profile = profile;
    }
    start() {
        const _super = Object.create(null, {
            start: { get: () => super.start }
        });
        var _a, _b;
        return __awaiter(this, void 0, void 0, function* () {
            this.client = yield new Promise((resolve, reject) => {
                var _a, _b;
                const connector = socksv5_default().connect({
                    host: this.profile.options.host,
                    port: this.profile.options.port,
                    proxyHost: (_a = this.profile.options.socksProxyHost) !== null && _a !== void 0 ? _a : '127.0.0.1',
                    proxyPort: (_b = this.profile.options.socksProxyPort) !== null && _b !== void 0 ? _b : 5000,
                    auths: [socksv5_default().auth.None()],
                    strictLocalDNS: false,
                }, s => {
                    resolve(s);
                    this.header = s.read();
                    if (this.header) {
                        this.emitOutput(this.header);
                    }
                });
                connector.on('error', (err) => {
                    reject(err);
                    this.stop(new Error(`SOCKS connection failed: ${err.message}`));
                });
            });
            (_a = this.client) === null || _a === void 0 ? void 0 : _a.on('data', data => {
                if (!this.header || data !== this.header) {
                    // socksv5 doesn't reliably emit the first data event
                    this.emitOutput(data);
                    this.header = null;
                }
            });
            (_b = this.client) === null || _b === void 0 ? void 0 : _b.on('close', error => {
                this.stop(error);
            });
            return _super.start.call(this);
        });
    }
    requestData(size) {
        var _a;
        (_a = this.client) === null || _a === void 0 ? void 0 : _a.read(size);
    }
    consumeInput(data) {
        return __awaiter(this, void 0, void 0, function* () {
            return new Promise((resolve, reject) => {
                var _a;
                (_a = this.client) === null || _a === void 0 ? void 0 : _a.write(data, undefined, err => err ? reject(err) : resolve());
            });
        });
    }
    stop(error) {
        const _super = Object.create(null, {
            stop: { get: () => super.stop }
        });
        var _a;
        return __awaiter(this, void 0, void 0, function* () {
            (_a = this.client) === null || _a === void 0 ? void 0 : _a.destroy();
            _super.stop.call(this, error);
        });
    }
}
class HTTPProxyStream extends SSHProxyStream {
    constructor(profile) {
        super();
        this.profile = profile;
        this.connected = false;
    }
    start() {
        const _super = Object.create(null, {
            start: { get: () => super.start }
        });
        var _a, _b, _c;
        return __awaiter(this, void 0, void 0, function* () {
            this.client = yield new Promise((resolve, reject) => {
                const connector = external_net_.createConnection({
                    host: this.profile.options.httpProxyHost,
                    port: this.profile.options.httpProxyPort,
                }, () => resolve(connector));
                connector.on('error', error => {
                    reject(error);
                    this.stop(new Error(`Proxy connection failed: ${error.message}`));
                });
            });
            (_a = this.client) === null || _a === void 0 ? void 0 : _a.write(Buffer.from(`CONNECT ${this.profile.options.host}:${this.profile.options.port} HTTP/1.1\r\n\r\n`));
            (_b = this.client) === null || _b === void 0 ? void 0 : _b.on('data', (data) => {
                if (this.connected) {
                    this.emitOutput(data);
                }
                else {
                    if (data.slice(0, 5).equals(Buffer.from('HTTP/'))) {
                        const idx = data.indexOf('\n\n');
                        const headers = data.slice(0, idx).toString();
                        const code = parseInt(headers.split(' ')[1]);
                        if (code >= 200 && code < 300) {
                            this.emitMessage('Connected');
                            this.emitOutput(data.slice(idx + 2));
                            this.connected = true;
                        }
                        else {
                            this.stop(new Error(`Connection failed, code ${code}`));
                        }
                    }
                }
            });
            (_c = this.client) === null || _c === void 0 ? void 0 : _c.on('close', error => {
                this.stop(error);
            });
            return _super.start.call(this);
        });
    }
    requestData(size) {
        var _a;
        (_a = this.client) === null || _a === void 0 ? void 0 : _a.read(size);
    }
    consumeInput(data) {
        return __awaiter(this, void 0, void 0, function* () {
            return new Promise((resolve, reject) => {
                var _a;
                (_a = this.client) === null || _a === void 0 ? void 0 : _a.write(data, undefined, err => err ? reject(err) : resolve());
            });
        });
    }
    stop(error) {
        const _super = Object.create(null, {
            stop: { get: () => super.stop }
        });
        var _a;
        return __awaiter(this, void 0, void 0, function* () {
            (_a = this.client) === null || _a === void 0 ? void 0 : _a.destroy();
            _super.stop.call(this, error);
        });
    }
}

// EXTERNAL MODULE: external "util"
var external_util_ = __webpack_require__(3837);
// EXTERNAL MODULE: external "constants"
var external_constants_ = __webpack_require__(2057);
// EXTERNAL MODULE: external "path"
var external_path_ = __webpack_require__(3056);
;// CONCATENATED MODULE: ./src/session/sftp.ts


// eslint-disable-next-line @typescript-eslint/no-duplicate-imports, no-duplicate-imports





class SFTPFileHandle {
    constructor(sftp, handle, zone) {
        this.sftp = sftp;
        this.handle = handle;
        this.zone = zone;
        this.position = 0;
    }
    read() {
        const buffer = Buffer.alloc(256 * 1024);
        return (0,external_tabby_core_.wrapPromise)(this.zone, new Promise((resolve, reject) => {
            while (true) {
                const wait = this.sftp.read(this.handle, buffer, 0, buffer.length, this.position, (err, read) => {
                    if (err) {
                        reject(err);
                        return;
                    }
                    this.position += read;
                    resolve(buffer.slice(0, read));
                });
                if (!wait) {
                    break;
                }
            }
        }));
    }
    write(chunk) {
        return (0,external_tabby_core_.wrapPromise)(this.zone, new Promise((resolve, reject) => {
            while (true) {
                const wait = this.sftp.write(this.handle, chunk, 0, chunk.length, this.position, err => {
                    if (err) {
                        reject(err);
                        return;
                    }
                    this.position += chunk.length;
                    resolve();
                });
                if (!wait) {
                    break;
                }
            }
        }));
    }
    close() {
        return (0,external_tabby_core_.wrapPromise)(this.zone, (0,external_util_.promisify)(this.sftp.close.bind(this.sftp))(this.handle));
    }
}
class SFTPSession {
    get closed$() { return this.closed; }
    constructor(sftp, injector) {
        this.sftp = sftp;
        this.closed = new external_rxjs_.Subject();
        this.zone = injector.get(core_.NgZone);
        this.logger = injector.get(external_tabby_core_.LogService).create('sftp');
        sftp.on('close', () => {
            this.closed.next();
            this.closed.complete();
        });
    }
    readdir(p) {
        return __awaiter(this, void 0, void 0, function* () {
            this.logger.debug('readdir', p);
            const entries = yield (0,external_tabby_core_.wrapPromise)(this.zone, (0,external_util_.promisify)(f => this.sftp.readdir(p, f))());
            return entries.map(entry => this._makeFile(external_path_.posix.join(p, entry.filename), entry));
        });
    }
    readlink(p) {
        this.logger.debug('readlink', p);
        return (0,external_tabby_core_.wrapPromise)(this.zone, (0,external_util_.promisify)(f => this.sftp.readlink(p, f))());
    }
    stat(p) {
        return __awaiter(this, void 0, void 0, function* () {
            this.logger.debug('stat', p);
            const stats = yield (0,external_tabby_core_.wrapPromise)(this.zone, (0,external_util_.promisify)(f => this.sftp.stat(p, f))());
            return {
                name: external_path_.posix.basename(p),
                fullPath: p,
                isDirectory: stats.isDirectory(),
                isSymlink: stats.isSymbolicLink(),
                mode: stats.mode,
                size: stats.size,
                modified: new Date(stats.mtime * 1000),
            };
        });
    }
    open(p, mode) {
        return __awaiter(this, void 0, void 0, function* () {
            this.logger.debug('open', p);
            const handle = yield (0,external_tabby_core_.wrapPromise)(this.zone, (0,external_util_.promisify)(f => this.sftp.open(p, mode, f))());
            return new SFTPFileHandle(this.sftp, handle, this.zone);
        });
    }
    rmdir(p) {
        return __awaiter(this, void 0, void 0, function* () {
            this.logger.debug('rmdir', p);
            yield (0,external_util_.promisify)((f) => this.sftp.rmdir(p, f))();
        });
    }
    mkdir(p) {
        return __awaiter(this, void 0, void 0, function* () {
            this.logger.debug('mkdir', p);
            yield (0,external_util_.promisify)((f) => this.sftp.mkdir(p, f))();
        });
    }
    rename(oldPath, newPath) {
        return __awaiter(this, void 0, void 0, function* () {
            this.logger.debug('rename', oldPath, newPath);
            yield (0,external_util_.promisify)((f) => this.sftp.rename(oldPath, newPath, f))();
        });
    }
    unlink(p) {
        return __awaiter(this, void 0, void 0, function* () {
            this.logger.debug('unlink', p);
            yield (0,external_util_.promisify)((f) => this.sftp.unlink(p, f))();
        });
    }
    chmod(p, mode) {
        return __awaiter(this, void 0, void 0, function* () {
            this.logger.debug('chmod', p, mode);
            yield (0,external_util_.promisify)((f) => this.sftp.chmod(p, mode, f))();
        });
    }
    upload(path, transfer) {
        return __awaiter(this, void 0, void 0, function* () {
            this.logger.info('Uploading into', path);
            const tempPath = path + '.tabby-upload';
            try {
                const handle = yield this.open(tempPath, 'w');
                while (true) {
                    const chunk = yield transfer.read();
                    if (!chunk.length) {
                        break;
                    }
                    yield handle.write(chunk);
                }
                handle.close();
                try {
                    yield this.unlink(path);
                }
                catch (_a) { }
                yield this.rename(tempPath, path);
                transfer.close();
            }
            catch (e) {
                transfer.cancel();
                this.unlink(tempPath);
                throw e;
            }
        });
    }
    download(path, transfer) {
        return __awaiter(this, void 0, void 0, function* () {
            this.logger.info('Downloading', path);
            try {
                const handle = yield this.open(path, 'r');
                while (true) {
                    const chunk = yield handle.read();
                    if (!chunk.length) {
                        break;
                    }
                    yield transfer.write(chunk);
                }
                transfer.close();
                handle.close();
            }
            catch (e) {
                transfer.cancel();
                throw e;
            }
        });
    }
    _makeFile(p, entry) {
        return {
            fullPath: p,
            name: external_path_.posix.basename(p),
            isDirectory: (entry.attrs.mode & external_constants_.S_IFDIR) === external_constants_.S_IFDIR,
            isSymlink: (entry.attrs.mode & external_constants_.S_IFLNK) === external_constants_.S_IFLNK,
            mode: entry.attrs.mode,
            size: entry.attrs.size,
            modified: new Date(entry.attrs.mtime * 1000),
        };
    }
}

;// CONCATENATED MODULE: ./src/session/x11.ts


class X11Socket {
    constructor() {
        this.error$ = new external_rxjs_.Subject();
        this.socket = null;
    }
    static resolveDisplaySpec(spec) {
        var _a, _b;
        // eslint-disable-next-line prefer-const, @typescript-eslint/no-unused-vars
        let [_, xHost, xDisplay] = (_b = /^(.+):(\d+)(?:.(\d+))$/.exec((_a = spec !== null && spec !== void 0 ? spec : process.env.DISPLAY) !== null && _a !== void 0 ? _a : 'localhost:0')) !== null && _b !== void 0 ? _b : [];
        if (process.platform === 'win32') {
            xHost !== null && xHost !== void 0 ? xHost : (xHost = 'localhost');
        }
        else {
            xHost !== null && xHost !== void 0 ? xHost : (xHost = 'unix');
        }
        if (spec === null || spec === void 0 ? void 0 : spec.startsWith('/')) {
            xHost = spec;
        }
        const display = parseInt(xDisplay || '0');
        const port = display < 100 ? display + 6000 : display;
        if (xHost === 'unix') {
            xHost = `/tmp/.X11-unix/X${display}`;
        }
        if (xHost.startsWith('/')) {
            return {
                path: xHost,
            };
        }
        else {
            return {
                host: xHost,
                port: port,
            };
        }
    }
    connect(spec) {
        this.socket = new external_net_.Socket();
        return new Promise((resolve, reject) => {
            this.socket.on('connect', () => {
                resolve(this.socket);
            });
            this.socket.on('error', e => {
                this.error$.next(e);
                reject(e);
            });
            this.socket.connect(X11Socket.resolveDisplaySpec(spec));
        });
    }
    destroy() {
        var _a;
        (_a = this.socket) === null || _a === void 0 ? void 0 : _a.destroy();
    }
}

;// CONCATENATED MODULE: ./src/session/ssh.ts



// eslint-disable-next-line @typescript-eslint/no-duplicate-imports, no-duplicate-imports



















const WINDOWS_OPENSSH_AGENT_PIPE = '\\\\.\\pipe\\openssh-ssh-agent';
class KeyboardInteractivePrompt {
    constructor(name, instruction, prompts, callback) {
        this.name = name;
        this.instruction = instruction;
        this.prompts = prompts;
        this.callback = callback;
        this.responses = [];
        this.responses = new Array(this.prompts.length).fill('');
    }
    respond() {
        this.callback(this.responses);
    }
}
class SSHSession {
    get serviceMessage$() { return this.serviceMessage; }
    get keyboardInteractivePrompt$() { return this.keyboardInteractivePrompt; }
    get willDestroy$() { return this.willDestroy; }
    constructor(injector, profile) {
        this.injector = injector;
        this.profile = profile;
        this.forwardedPorts = [];
        this.proxyCommandStream = null;
        this.activePrivateKey = null;
        this.authUsername = null;
        this.open = false;
        this.refCount = 0;
        this.remainingAuthMethods = [];
        this.serviceMessage = new external_rxjs_.Subject();
        this.keyboardInteractivePrompt = new external_rxjs_.Subject();
        this.willDestroy = new external_rxjs_.Subject();
        this.keychainPasswordUsed = false;
        this.hostKeyDigest = '';
        this.logger = injector.get(external_tabby_core_.LogService).create(`ssh-${profile.options.host}-${profile.options.port}`);
        this.passwordStorage = injector.get(PasswordStorageService);
        this.ngbModal = injector.get(ng_bootstrap_.NgbModal);
        this.hostApp = injector.get(external_tabby_core_.HostAppService);
        this.platform = injector.get(external_tabby_core_.PlatformService);
        this.notifications = injector.get(external_tabby_core_.NotificationsService);
        this.zone = injector.get(core_.NgZone);
        this.fileProviders = injector.get(external_tabby_core_.FileProvidersService);
        this.config = injector.get(external_tabby_core_.ConfigService);
        this.translate = injector.get(external_tabby_core_.TranslateService);
        this.knownHosts = injector.get(SSHKnownHostsService);
        this.privateKeyImporters = injector.get(AutoPrivateKeyLocator, []);
        this.willDestroy$.subscribe(() => {
            for (const port of this.forwardedPorts) {
                port.stopLocalListener();
            }
        });
    }
    init() {
        var _a;
        return __awaiter(this, void 0, void 0, function* () {
            if (this.hostApp.platform === external_tabby_core_.Platform.Windows) {
                if (this.config.store.ssh.agentType === 'auto') {
                    if (yield fs.exists(WINDOWS_OPENSSH_AGENT_PIPE)) {
                        this.agentPath = WINDOWS_OPENSSH_AGENT_PIPE;
                    }
                    else {
                        if ((yield this.platform.isProcessRunning('pageant.exe')) ||
                            (yield this.platform.isProcessRunning('gpg-agent.exe'))) {
                            this.agentPath = 'pageant';
                        }
                    }
                }
                else if (this.config.store.ssh.agentType === 'pageant') {
                    this.agentPath = 'pageant';
                }
                else {
                    this.agentPath = this.config.store.ssh.agentPath || WINDOWS_OPENSSH_AGENT_PIPE;
                }
            }
            else {
                this.agentPath = process.env.SSH_AUTH_SOCK;
            }
            this.remainingAuthMethods = [{ type: 'none' }];
            if (!this.profile.options.auth || this.profile.options.auth === 'publicKey') {
                if ((_a = this.profile.options.privateKeys) === null || _a === void 0 ? void 0 : _a.length) {
                    for (const pk of this.profile.options.privateKeys) {
                        try {
                            this.remainingAuthMethods.push({
                                type: 'publickey',
                                name: pk,
                                contents: yield this.fileProviders.retrieveFile(pk),
                            });
                        }
                        catch (error) {
                            this.emitServiceMessage(ansi_colors_default().bgYellow.yellow.black(' ! ') + ` Could not load private key ${pk}: ${error}`);
                        }
                    }
                }
                else {
                    for (const importer of this.privateKeyImporters) {
                        for (const [name, contents] of yield importer.getKeys()) {
                            this.remainingAuthMethods.push({
                                type: 'publickey',
                                name,
                                contents,
                            });
                        }
                    }
                }
            }
            if (!this.profile.options.auth || this.profile.options.auth === 'agent') {
                if (!this.agentPath) {
                    this.emitServiceMessage(ansi_colors_default().bgYellow.yellow.black(' ! ') + ` Agent auth selected, but no running agent is detected`);
                }
                else {
                    this.remainingAuthMethods.push({ type: 'agent' });
                }
            }
            if (!this.profile.options.auth || this.profile.options.auth === 'password') {
                this.remainingAuthMethods.push({ type: 'password' });
            }
            if (!this.profile.options.auth || this.profile.options.auth === 'keyboardInteractive') {
                this.remainingAuthMethods.push({ type: 'keyboard-interactive' });
            }
            this.remainingAuthMethods.push({ type: 'hostbased' });
        });
    }
    openSFTP() {
        return __awaiter(this, void 0, void 0, function* () {
            if (!this.sftp) {
                this.sftp = yield (0,external_tabby_core_.wrapPromise)(this.zone, (0,external_util_.promisify)(f => this.ssh.sftp(f))());
            }
            return new SFTPSession(this.sftp, this.injector);
        });
    }
    start() {
        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
        return __awaiter(this, void 0, void 0, function* () {
            const log = (s) => this.emitServiceMessage(s);
            const ssh = new ssh2_lib.Client();
            this.ssh = ssh;
            yield this.init();
            let connected = false;
            const algorithms = {};
            for (const key of Object.values(SSHAlgorithmType)) {
                algorithms[key] = this.profile.options.algorithms[key].filter(x => supportedAlgorithms[key].includes(x));
            }
            const hostVerifiedPromise = new Promise((resolve, reject) => {
                ssh.on('handshake', (handshake) => __awaiter(this, void 0, void 0, function* () {
                    if (!(yield this.verifyHostKey(handshake))) {
                        this.ssh.end();
                        reject(new Error('Host key verification failed'));
                        return;
                    }
                    this.logger.info('Handshake complete:', handshake);
                    resolve();
                }));
            });
            const resultPromise = new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
                ssh.on('ready', () => {
                    connected = true;
                    if (this.savedPassword) {
                        this.passwordStorage.savePassword(this.profile, this.savedPassword);
                    }
                    this.zone.run(resolve);
                });
                ssh.on('error', error => {
                    if (error.message === 'All configured authentication methods failed') {
                        this.passwordStorage.deletePassword(this.profile);
                    }
                    this.zone.run(() => {
                        if (connected) {
                            // eslint-disable-next-line @typescript-eslint/no-base-to-string
                            this.notifications.error(error.toString());
                        }
                        else {
                            reject(error);
                        }
                    });
                });
                ssh.on('close', () => {
                    if (this.open) {
                        this.destroy();
                    }
                });
                ssh.on('keyboard-interactive', (name, instructions, instructionsLang, prompts, finish) => this.zone.run(() => __awaiter(this, void 0, void 0, function* () {
                    this.emitKeyboardInteractivePrompt(new KeyboardInteractivePrompt(name, instructions, prompts, finish));
                })));
                ssh.on('greeting', greeting => {
                    if (!this.profile.options.skipBanner) {
                        log('Greeting: ' + greeting);
                    }
                });
                ssh.on('banner', banner => {
                    if (!this.profile.options.skipBanner) {
                        log(banner);
                    }
                });
            }));
            try {
                if (this.profile.options.socksProxyHost) {
                    this.emitServiceMessage(ansi_colors_default().bgBlue.black(' Proxy ') + ` Using ${this.profile.options.socksProxyHost}:${this.profile.options.socksProxyPort}`);
                    this.proxyCommandStream = new SocksProxyStream(this.profile);
                }
                if (this.profile.options.httpProxyHost) {
                    this.emitServiceMessage(ansi_colors_default().bgBlue.black(' Proxy ') + ` Using ${this.profile.options.httpProxyHost}:${this.profile.options.httpProxyPort}`);
                    this.proxyCommandStream = new HTTPProxyStream(this.profile);
                }
                if (this.profile.options.proxyCommand) {
                    this.emitServiceMessage(ansi_colors_default().bgBlue.black(' Proxy command ') + ` Using ${this.profile.options.proxyCommand}`);
                    this.proxyCommandStream = new ProxyCommandStream(this.profile.options.proxyCommand);
                }
                if (this.proxyCommandStream) {
                    this.proxyCommandStream.destroyed$.subscribe(err => {
                        if (err) {
                            this.emitServiceMessage(ansi_colors_default().bgRed.black(' X ') + ` ${err.message}`);
                            this.destroy();
                        }
                    });
                    this.proxyCommandStream.message$.subscribe(message => {
                        this.emitServiceMessage(ansi_colors_default().bgBlue.black(' Proxy ') + ' ' + message.trim());
                    });
                    yield this.proxyCommandStream.start();
                }
                (_a = this.authUsername) !== null && _a !== void 0 ? _a : (this.authUsername = this.profile.options.user);
                if (!this.authUsername) {
                    const modal = this.ngbModal.open(external_tabby_core_.PromptModalComponent);
                    modal.componentInstance.prompt = `Username for ${this.profile.options.host}`;
                    try {
                        const result = yield modal.result;
                        this.authUsername = (_b = result === null || result === void 0 ? void 0 : result.value) !== null && _b !== void 0 ? _b : null;
                    }
                    catch (_k) {
                        this.authUsername = 'root';
                    }
                }
                if ((_c = this.authUsername) === null || _c === void 0 ? void 0 : _c.startsWith('$')) {
                    try {
                        const result = process.env[this.authUsername.slice(1)];
                        this.authUsername = result !== null && result !== void 0 ? result : this.authUsername;
                    }
                    catch (_l) {
                        this.authUsername = 'root';
                    }
                }
                ssh.connect({
                    host: this.profile.options.host.trim(),
                    port: (_d = this.profile.options.port) !== null && _d !== void 0 ? _d : 22,
                    sock: (_f = (_e = this.proxyCommandStream) === null || _e === void 0 ? void 0 : _e.socket) !== null && _f !== void 0 ? _f : this.jumpStream,
                    username: (_g = this.authUsername) !== null && _g !== void 0 ? _g : undefined,
                    tryKeyboard: true,
                    agent: this.agentPath,
                    agentForward: this.profile.options.agentForward && !!this.agentPath,
                    keepaliveInterval: (_h = this.profile.options.keepaliveInterval) !== null && _h !== void 0 ? _h : 15000,
                    keepaliveCountMax: this.profile.options.keepaliveCountMax,
                    readyTimeout: this.profile.options.readyTimeout,
                    hostVerifier: (key) => {
                        this.hostKeyDigest = external_crypto_.createHash('sha256').update(key).digest('base64');
                        return true;
                    },
                    algorithms,
                    authHandler: (methodsLeft, partialSuccess, callback) => {
                        this.zone.run(() => __awaiter(this, void 0, void 0, function* () {
                            callback(yield this.handleAuth(methodsLeft));
                        }));
                    },
                });
            }
            catch (e) {
                this.notifications.error(e.message);
                throw e;
            }
            yield resultPromise;
            yield hostVerifiedPromise;
            for (const fw of (_j = this.profile.options.forwardedPorts) !== null && _j !== void 0 ? _j : []) {
                this.addPortForward(Object.assign(new ForwardedPort(), fw));
            }
            this.open = true;
            this.ssh.on('tcp connection', (details, accept, reject) => {
                this.logger.info(`Incoming forwarded connection: (remote) ${details.srcIP}:${details.srcPort} -> (local) ${details.destIP}:${details.destPort}`);
                const forward = this.forwardedPorts.find(x => x.port === details.destPort);
                if (!forward) {
                    this.emitServiceMessage(ansi_colors_default().bgRed.black(' X ') + ` Rejected incoming forwarded connection for unrecognized port ${details.destPort}`);
                    reject();
                    return;
                }
                const socket = new external_net_.Socket();
                socket.connect(forward.targetPort, forward.targetAddress);
                socket.on('error', e => {
                    // eslint-disable-next-line @typescript-eslint/no-base-to-string
                    this.emitServiceMessage(ansi_colors_default().bgRed.black(' X ') + ` Could not forward the remote connection to ${forward.targetAddress}:${forward.targetPort}: ${e}`);
                    reject();
                });
                socket.on('connect', () => {
                    this.logger.info('Connection forwarded');
                    const stream = accept();
                    stream.pipe(socket);
                    socket.pipe(stream);
                    stream.on('close', () => {
                        socket.destroy();
                    });
                    socket.on('close', () => {
                        stream.close();
                    });
                });
            });
            this.ssh.on('x11', (details, accept, reject) => __awaiter(this, void 0, void 0, function* () {
                var _m;
                this.logger.info(`Incoming X11 connection from ${details.srcIP}:${details.srcPort}`);
                const displaySpec = (_m = (this.config.store.ssh.x11Display || process.env.DISPLAY)) !== null && _m !== void 0 ? _m : 'localhost:0';
                this.logger.debug(`Trying display ${displaySpec}`);
                const socket = new X11Socket();
                try {
                    const x11Stream = yield socket.connect(displaySpec);
                    this.logger.info('Connection forwarded');
                    const stream = accept();
                    stream.pipe(x11Stream);
                    x11Stream.pipe(stream);
                    stream.on('close', () => {
                        socket.destroy();
                    });
                    x11Stream.on('close', () => {
                        stream.close();
                    });
                }
                catch (e) {
                    // eslint-disable-next-line @typescript-eslint/no-base-to-string
                    this.emitServiceMessage(ansi_colors_default().bgRed.black(' X ') + ` Could not connect to the X server: ${e}`);
                    this.emitServiceMessage(`    Tabby tried to connect to ${JSON.stringify(X11Socket.resolveDisplaySpec(displaySpec))} based on the DISPLAY environment var (${displaySpec})`);
                    if (process.platform === 'win32') {
                        this.emitServiceMessage('    To use X forwarding, you need a local X server, e.g.:');
                        this.emitServiceMessage('    * VcXsrv: https://sourceforge.net/projects/vcxsrv/');
                        this.emitServiceMessage('    * Xming: https://sourceforge.net/projects/xming/');
                    }
                    reject();
                }
            }));
        });
    }
    verifyHostKey(handshake) {
        var _a;
        return __awaiter(this, void 0, void 0, function* () {
            this.emitServiceMessage('Host key fingerprint:');
            this.emitServiceMessage(ansi_colors_default().white.bgBlack(` ${handshake.serverHostKey} `) + ansi_colors_default().bgBlackBright(' ' + this.hostKeyDigest + ' '));
            if (!this.config.store.ssh.verifyHostKeys) {
                return true;
            }
            const selector = {
                host: this.profile.options.host,
                port: (_a = this.profile.options.port) !== null && _a !== void 0 ? _a : 22,
                type: handshake.serverHostKey,
            };
            const knownHost = this.knownHosts.getFor(selector);
            if (!knownHost || knownHost.digest !== this.hostKeyDigest) {
                const modal = this.ngbModal.open(HostKeyPromptModalComponent);
                modal.componentInstance.selector = selector;
                modal.componentInstance.digest = this.hostKeyDigest;
                try {
                    return yield modal.result;
                }
                catch (_b) {
                    return false;
                }
            }
            return true;
        });
    }
    emitServiceMessage(msg) {
        this.serviceMessage.next(msg);
        this.logger.info(stripAnsi(msg));
    }
    emitKeyboardInteractivePrompt(prompt) {
        this.logger.info('Keyboard-interactive auth:', prompt.name, prompt.instruction);
        this.emitServiceMessage(ansi_colors_default().bgBlackBright(' ') + ` Keyboard-interactive auth requested: ${prompt.name}`);
        if (prompt.instruction) {
            for (const line of prompt.instruction.split('\n')) {
                this.emitServiceMessage(line);
            }
        }
        this.keyboardInteractivePrompt.next(prompt);
    }
    handleAuth(methodsLeft) {
        return __awaiter(this, void 0, void 0, function* () {
            this.activePrivateKey = null;
            while (true) {
                const method = this.remainingAuthMethods.shift();
                if (!method) {
                    return false;
                }
                if (methodsLeft && !methodsLeft.includes(method.type) && method.type !== 'agent') {
                    // Agent can still be used even if not in methodsLeft
                    this.logger.info('Server does not support auth method', method.type);
                    continue;
                }
                if (method.type === 'password') {
                    if (this.profile.options.password) {
                        this.emitServiceMessage(this.translate.instant('Using preset password'));
                        return {
                            type: 'password',
                            username: this.authUsername,
                            password: this.profile.options.password,
                        };
                    }
                    if (!this.keychainPasswordUsed && this.profile.options.user) {
                        const password = yield this.passwordStorage.loadPassword(this.profile);
                        if (password) {
                            this.emitServiceMessage(this.translate.instant('Trying saved password'));
                            this.keychainPasswordUsed = true;
                            return {
                                type: 'password',
                                username: this.authUsername,
                                password,
                            };
                        }
                    }
                    const modal = this.ngbModal.open(external_tabby_core_.PromptModalComponent);
                    modal.componentInstance.prompt = `Password for ${this.authUsername}@${this.profile.options.host}`;
                    modal.componentInstance.password = true;
                    modal.componentInstance.showRememberCheckbox = true;
                    try {
                        const result = yield modal.result;
                        if (result) {
                            if (result.remember) {
                                this.savedPassword = result.value;
                            }
                            return {
                                type: 'password',
                                username: this.authUsername,
                                password: result.value,
                            };
                        }
                        else {
                            continue;
                        }
                    }
                    catch (_a) {
                        continue;
                    }
                }
                if (method.type === 'publickey' && method.contents) {
                    try {
                        const key = yield this.loadPrivateKey(method.name, method.contents);
                        return {
                            type: 'publickey',
                            username: this.authUsername,
                            key,
                        };
                    }
                    catch (e) {
                        this.emitServiceMessage(ansi_colors_default().bgYellow.yellow.black(' ! ') + ` Failed to load private key ${method.name}: ${e}`);
                        continue;
                    }
                }
                return method.type;
            }
        });
    }
    addPortForward(fw) {
        return __awaiter(this, void 0, void 0, function* () {
            if (fw.type === PortForwardType.Local || fw.type === PortForwardType.Dynamic) {
                yield fw.startLocalListener((accept, reject, sourceAddress, sourcePort, targetAddress, targetPort) => {
                    this.logger.info(`New connection on ${fw}`);
                    this.ssh.forwardOut(sourceAddress !== null && sourceAddress !== void 0 ? sourceAddress : '127.0.0.1', sourcePort !== null && sourcePort !== void 0 ? sourcePort : 0, targetAddress, targetPort, (err, stream) => {
                        if (err) {
                            // eslint-disable-next-line @typescript-eslint/no-base-to-string
                            this.emitServiceMessage(ansi_colors_default().bgRed.black(' X ') + ` Remote has rejected the forwarded connection to ${targetAddress}:${targetPort} via ${fw}: ${err}`);
                            reject();
                            return;
                        }
                        const socket = accept();
                        stream.pipe(socket);
                        socket.pipe(stream);
                        stream.on('close', () => {
                            socket.destroy();
                        });
                        socket.on('close', () => {
                            stream.close();
                        });
                    });
                }).then(() => {
                    this.emitServiceMessage(ansi_colors_default().bgGreen.black(' -> ') + ` Forwarded ${fw}`);
                    this.forwardedPorts.push(fw);
                }).catch(e => {
                    this.emitServiceMessage(ansi_colors_default().bgRed.black(' X ') + ` Failed to forward port ${fw}: ${e}`);
                    throw e;
                });
            }
            if (fw.type === PortForwardType.Remote) {
                yield new Promise((resolve, reject) => {
                    this.ssh.forwardIn(fw.host, fw.port, err => {
                        if (err) {
                            // eslint-disable-next-line @typescript-eslint/no-base-to-string
                            this.emitServiceMessage(ansi_colors_default().bgRed.black(' X ') + ` Remote rejected port forwarding for ${fw}: ${err}`);
                            reject(err);
                            return;
                        }
                        resolve();
                    });
                });
                this.emitServiceMessage(ansi_colors_default().bgGreen.black(' <- ') + ` Forwarded ${fw}`);
                this.forwardedPorts.push(fw);
            }
        });
    }
    removePortForward(fw) {
        return __awaiter(this, void 0, void 0, function* () {
            if (fw.type === PortForwardType.Local || fw.type === PortForwardType.Dynamic) {
                fw.stopLocalListener();
                this.forwardedPorts = this.forwardedPorts.filter(x => x !== fw);
            }
            if (fw.type === PortForwardType.Remote) {
                this.ssh.unforwardIn(fw.host, fw.port);
                this.forwardedPorts = this.forwardedPorts.filter(x => x !== fw);
            }
            this.emitServiceMessage(`Stopped forwarding ${fw}`);
        });
    }
    destroy() {
        var _a;
        return __awaiter(this, void 0, void 0, function* () {
            this.logger.info('Destroying');
            this.willDestroy.next();
            this.willDestroy.complete();
            this.serviceMessage.complete();
            (_a = this.proxyCommandStream) === null || _a === void 0 ? void 0 : _a.stop();
            this.ssh.end();
        });
    }
    openShellChannel(options) {
        return new Promise((resolve, reject) => {
            this.ssh.shell({ term: 'xterm-256color' }, options, (err, shell) => {
                if (err) {
                    reject(err);
                }
                else {
                    resolve(shell);
                }
            });
        });
    }
    loadPrivateKey(name, privateKeyContents) {
        return __awaiter(this, void 0, void 0, function* () {
            this.emitServiceMessage(`Loading private key: ${name}`);
            const parsedKey = yield this.parsePrivateKey(privateKeyContents.toString());
            this.activePrivateKey = parsedKey.toString('openssh');
            return this.activePrivateKey;
        });
    }
    parsePrivateKey(privateKey) {
        return __awaiter(this, void 0, void 0, function* () {
            const keyHash = external_crypto_.createHash('sha512').update(privateKey).digest('hex');
            let triedSavedPassphrase = false;
            let passphrase = null;
            while (true) {
                try {
                    return lib.parsePrivateKey(privateKey, 'auto', { passphrase });
                }
                catch (e) {
                    if (!triedSavedPassphrase) {
                        passphrase = yield this.passwordStorage.loadPrivateKeyPassword(keyHash);
                        triedSavedPassphrase = true;
                        continue;
                    }
                    if (e instanceof lib.KeyEncryptedError || e instanceof lib.KeyParseError) {
                        yield this.passwordStorage.deletePrivateKeyPassword(keyHash);
                        const modal = this.ngbModal.open(external_tabby_core_.PromptModalComponent);
                        modal.componentInstance.prompt = 'Private key passphrase';
                        modal.componentInstance.password = true;
                        modal.componentInstance.showRememberCheckbox = true;
                        const result = yield modal.result.catch(() => {
                            throw new Error('Passphrase prompt cancelled');
                        });
                        passphrase = result === null || result === void 0 ? void 0 : result.value;
                        if (passphrase && result.remember) {
                            this.passwordStorage.savePrivateKeyPassword(keyHash, passphrase);
                        }
                    }
                    else {
                        this.notifications.error('Could not read the private key', e.toString());
                        throw e;
                    }
                }
            }
        });
    }
    ref() {
        this.refCount++;
    }
    unref() {
        this.refCount--;
        if (this.refCount === 0) {
            this.destroy();
        }
    }
}

;// CONCATENATED MODULE: ./src/components/sshPortForwardingModal.component.ts


/* eslint-disable @typescript-eslint/explicit-module-boundary-types */



/** @hidden */
let SSHPortForwardingModalComponent = class SSHPortForwardingModalComponent {
    onForwardAdded(fw) {
        const newForward = new ForwardedPort();
        Object.assign(newForward, fw);
        this.session.addPortForward(newForward);
    }
    onForwardRemoved(fw) {
        this.session.removePortForward(fw);
    }
};
SSHPortForwardingModalComponent.propDecorators = {
    session: [{ type: core_.Input }]
};
SSHPortForwardingModalComponent = __decorate([
    (0,core_.Component)({
        template: (sshPortForwardingModal_componentngResource_default()),
    })
], SSHPortForwardingModalComponent);


// EXTERNAL MODULE: ./src/components/sshPortForwardingConfig.component.pug?ngResource
var sshPortForwardingConfig_componentngResource = __webpack_require__(8192);
var sshPortForwardingConfig_componentngResource_default = /*#__PURE__*/__webpack_require__.n(sshPortForwardingConfig_componentngResource);
;// CONCATENATED MODULE: ./src/components/sshPortForwardingConfig.component.ts


/* eslint-disable @typescript-eslint/explicit-module-boundary-types */


/** @hidden */
let SSHPortForwardingConfigComponent = class SSHPortForwardingConfigComponent {
    constructor() {
        this.forwardAdded = new core_.EventEmitter();
        this.forwardRemoved = new core_.EventEmitter();
        this.PortForwardType = PortForwardType;
        this.reset();
    }
    reset() {
        this.newForward = {
            type: PortForwardType.Local,
            host: '127.0.0.1',
            port: 8000,
            targetAddress: '127.0.0.1',
            targetPort: 80,
            description: '',
        };
    }
    addForward() {
        return __awaiter(this, void 0, void 0, function* () {
            try {
                this.forwardAdded.emit(this.newForward);
                this.reset();
            }
            catch (e) {
                console.error(e);
            }
        });
    }
    remove(fw) {
        this.forwardRemoved.emit(fw);
        this.newForward = fw;
    }
};
SSHPortForwardingConfigComponent.ctorParameters = () => [];
SSHPortForwardingConfigComponent.propDecorators = {
    model: [{ type: core_.Input }],
    forwardAdded: [{ type: core_.Output }],
    forwardRemoved: [{ type: core_.Output }]
};
SSHPortForwardingConfigComponent = __decorate([
    (0,core_.Component)({
        selector: 'ssh-port-forwarding-config',
        template: (sshPortForwardingConfig_componentngResource_default()),
    }),
    __metadata("design:paramtypes", [])
], SSHPortForwardingConfigComponent);


// EXTERNAL MODULE: ./src/components/sshSettingsTab.component.pug?ngResource
var sshSettingsTab_componentngResource = __webpack_require__(1602);
var sshSettingsTab_componentngResource_default = /*#__PURE__*/__webpack_require__.n(sshSettingsTab_componentngResource);
;// CONCATENATED MODULE: ./src/components/sshSettingsTab.component.ts





/** @hidden */
let SSHSettingsTabComponent = class SSHSettingsTabComponent {
    constructor(config, hostApp) {
        this.config = config;
        this.hostApp = hostApp;
        this.Platform = external_tabby_core_.Platform;
        const spec = X11Socket.resolveDisplaySpec();
        if ('path' in spec) {
            this.defaultX11Display = spec.path;
        }
        else {
            this.defaultX11Display = `${spec.host}:${spec.port}`;
        }
    }
};
SSHSettingsTabComponent.ctorParameters = () => [
    { type: external_tabby_core_.ConfigService },
    { type: external_tabby_core_.HostAppService }
];
SSHSettingsTabComponent.propDecorators = {
    true: [{ type: core_.HostBinding, args: ['class.content-box',] }]
};
SSHSettingsTabComponent = __decorate([
    (0,core_.Component)({
        template: (sshSettingsTab_componentngResource_default()),
    }),
    __metadata("design:paramtypes", [external_tabby_core_.ConfigService,
        external_tabby_core_.HostAppService])
], SSHSettingsTabComponent);


;// CONCATENATED MODULE: ../node_modules/@biesbjerg/ngx-translate-extract-marker/__ivy_ngcc__/esm2015/lib/ngx-translate-extract-marker.js
/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * @template T
 * @param {?} key
 * @return {?}
 */
function marker(key) {
  return key;
}
;// CONCATENATED MODULE: ./src/session/shell.ts





class SSHShellSession extends external_tabby_terminal_.BaseSession {
    get serviceMessage$() { return this.serviceMessage; }
    constructor(injector, ssh, profile) {
        super(injector.get(external_tabby_core_.LogService).create(`ssh-shell-${profile.options.host}-${profile.options.port}`));
        this.profile = profile;
        this.serviceMessage = new external_rxjs_.Subject();
        this.decoder = new external_tabby_core_.UTF8Splitter();
        this.ssh = ssh;
        this.setLoginScriptsOptions(this.profile.options);
        this.ssh.serviceMessage$.subscribe(m => this.serviceMessage.next(m));
    }
    start() {
        var _a, _b;
        return __awaiter(this, void 0, void 0, function* () {
            if (!this.ssh) {
                throw new Error('SSH session not set');
            }
            this.ssh.ref();
            this.ssh.willDestroy$.subscribe(() => {
                this.destroy();
            });
            this.logger.debug('Opening shell');
            try {
                this.shell = yield this.ssh.openShellChannel({ x11: (_a = this.profile.options.x11) !== null && _a !== void 0 ? _a : false });
            }
            catch (err) {
                if (err.toString().includes('Unable to request X11')) {
                    this.emitServiceMessage('    Make sure `xauth` is installed on the remote side');
                }
                throw new Error(`Remote rejected opening a shell channel: ${err}`);
            }
            this.open = true;
            this.logger.debug('Shell open');
            (_b = this.loginScriptProcessor) === null || _b === void 0 ? void 0 : _b.executeUnconditionalScripts();
            this.shell.on('greeting', greeting => {
                this.emitServiceMessage(`Shell greeting: ${greeting}`);
            });
            this.shell.on('banner', banner => {
                this.emitServiceMessage(`Shell banner: ${banner}`);
            });
            this.shell.on('data', data => {
                this.emitOutput(this.decoder.write(data));
            });
            this.shell.on('end', () => {
                const remainder = this.decoder.flush();
                if (remainder.length) {
                    this.emitOutput(remainder);
                }
                this.logger.info('Shell session ended');
                if (this.open) {
                    this.destroy();
                }
            });
        });
    }
    emitServiceMessage(msg) {
        this.serviceMessage.next(msg);
        this.logger.info(stripAnsi(msg));
    }
    resize(columns, rows) {
        if (this.shell) {
            this.shell.setWindow(rows, columns, rows, columns);
        }
    }
    write(data) {
        if (this.shell) {
            this.shell.write(data);
        }
    }
    kill(signal) {
        var _a;
        (_a = this.shell) === null || _a === void 0 ? void 0 : _a.signal(signal !== null && signal !== void 0 ? signal : 'TERM');
    }
    destroy() {
        const _super = Object.create(null, {
            destroy: { get: () => super.destroy }
        });
        var _a;
        return __awaiter(this, void 0, void 0, function* () {
            this.logger.debug('Closing shell');
            this.serviceMessage.complete();
            this.kill();
            (_a = this.ssh) === null || _a === void 0 ? void 0 : _a.unref();
            this.ssh = null;
            yield _super.destroy.call(this);
        });
    }
    getChildProcesses() {
        return __awaiter(this, void 0, void 0, function* () {
            return [];
        });
    }
    gracefullyKillProcess() {
        return __awaiter(this, void 0, void 0, function* () {
            this.kill('TERM');
        });
    }
    supportsWorkingDirectory() {
        return !!this.reportedCWD;
    }
    getWorkingDirectory() {
        var _a;
        return __awaiter(this, void 0, void 0, function* () {
            return (_a = this.reportedCWD) !== null && _a !== void 0 ? _a : null;
        });
    }
}

;// CONCATENATED MODULE: ./src/services/sshMultiplexer.service.ts



let SSHMultiplexerService = class SSHMultiplexerService {
    constructor(profilesService) {
        this.profilesService = profilesService;
        this.sessions = new Map();
    }
    addSession(session) {
        return __awaiter(this, void 0, void 0, function* () {
            const key = yield this.getMultiplexerKey(session.profile);
            this.sessions.set(key, session);
            session.willDestroy$.subscribe(() => {
                if (this.sessions.get(key) === session) {
                    this.sessions.delete(key);
                }
            });
        });
    }
    getSession(profile) {
        var _a;
        return __awaiter(this, void 0, void 0, function* () {
            const fullProfile = this.profilesService.getConfigProxyForProfile(profile);
            const key = yield this.getMultiplexerKey(fullProfile);
            return (_a = this.sessions.get(key)) !== null && _a !== void 0 ? _a : null;
        });
    }
    getMultiplexerKey(profile) {
        return __awaiter(this, void 0, void 0, function* () {
            let key = `${profile.options.host}:${profile.options.port}:${profile.options.user}:${profile.options.proxyCommand}:${profile.options.socksProxyHost}:${profile.options.socksProxyPort}`;
            if (profile.options.jumpHost) {
                const jumpConnection = (yield this.profilesService.getProfiles()).find(x => x.id === profile.options.jumpHost);
                if (!jumpConnection) {
                    return key;
                }
                const jumpProfile = this.profilesService.getConfigProxyForProfile(jumpConnection);
                key += '$' + (yield this.getMultiplexerKey(jumpProfile));
            }
            return key;
        });
    }
};
SSHMultiplexerService.ctorParameters = () => [
    { type: external_tabby_core_.ProfilesService }
];
SSHMultiplexerService = __decorate([
    (0,core_.Injectable)({ providedIn: 'root' }),
    __metadata("design:paramtypes", [external_tabby_core_.ProfilesService])
], SSHMultiplexerService);


;// CONCATENATED MODULE: ./src/components/sshTab.component.ts













/** @hidden */
let SSHTabComponent = class SSHTabComponent extends external_tabby_terminal_.BaseTerminalTabComponent {
    constructor(injector, ssh, ngbModal, profilesService, sshMultiplexer) {
        super(injector);
        this.ssh = ssh;
        this.ngbModal = ngbModal;
        this.profilesService = profilesService;
        this.sshMultiplexer = sshMultiplexer;
        this.Platform = external_tabby_core_.Platform;
        this.sshSession = null;
        this.session = null;
        this.sftpPanelVisible = false;
        this.sftpPath = '/';
        this.enableToolbar = true;
        this.activeKIPrompt = null;
        this.reconnectOffered = false;
        this.sessionChanged$.subscribe(() => {
            this.activeKIPrompt = null;
        });
    }
    ngOnInit() {
        this.logger = this.log.create('terminalTab');
        this.subscribeUntilDestroyed(this.hotkeys.hotkey$, hotkey => {
            if (!this.hasFocus) {
                return;
            }
            switch (hotkey) {
                case 'home':
                    this.sendInput('\x1bOH');
                    break;
                case 'end':
                    this.sendInput('\x1bOF');
                    break;
                case 'restart-ssh-session':
                    this.reconnect();
                    break;
                case 'launch-winscp':
                    if (this.sshSession) {
                        this.ssh.launchWinSCP(this.sshSession);
                    }
                    break;
            }
        });
        super.ngOnInit();
    }
    onFrontendReady() {
        this.initializeSession();
        super.onFrontendReady();
    }
    setupOneSession(injector, profile, multiplex = true) {
        return __awaiter(this, void 0, void 0, function* () {
            let session = yield this.sshMultiplexer.getSession(profile);
            if (!multiplex || !session || !profile.options.reuseSession) {
                session = new SSHSession(injector, profile);
                if (profile.options.jumpHost) {
                    const jumpConnection = (yield this.profilesService.getProfiles()).find(x => x.id === profile.options.jumpHost);
                    if (!jumpConnection) {
                        throw new Error(`${profile.options.host}: jump host "${profile.options.jumpHost}" not found in your config`);
                    }
                    const jumpSession = yield this.setupOneSession(this.injector, this.profilesService.getConfigProxyForProfile(jumpConnection));
                    jumpSession.ref();
                    session.willDestroy$.subscribe(() => jumpSession.unref());
                    jumpSession.willDestroy$.subscribe(() => {
                        if (session === null || session === void 0 ? void 0 : session.open) {
                            session.destroy();
                        }
                    });
                    session.jumpStream = yield new Promise((resolve, reject) => {
                        var _a;
                        return jumpSession.ssh.forwardOut('127.0.0.1', 0, profile.options.host, (_a = profile.options.port) !== null && _a !== void 0 ? _a : 22, (err, stream) => {
                            if (err) {
                                jumpSession.emitServiceMessage(ansi_colors_default().bgRed.black(' X ') + ` Could not set up port forward on ${jumpConnection.name}`);
                                reject(err);
                                return;
                            }
                            resolve(stream);
                        });
                    });
                }
            }
            this.attachSessionHandler(session.serviceMessage$, msg => {
                msg = msg.replace(/\n/g, '\r\n      ');
                this.write(`\r${ansi_colors_default().black.bgWhite(' SSH ')} ${msg}\r\n`);
            });
            this.attachSessionHandler(session.willDestroy$, () => {
                this.activeKIPrompt = null;
            });
            this.attachSessionHandler(session.keyboardInteractivePrompt$, prompt => {
                this.activeKIPrompt = prompt;
                setTimeout(() => {
                    var _a;
                    (_a = this.frontend) === null || _a === void 0 ? void 0 : _a.scrollToBottom();
                });
            });
            if (!session.open) {
                this.write('\r\n' + ansi_colors_default().black.bgWhite(' SSH ') + ` Connecting to ${session.profile.options.host}\r\n`);
                this.startSpinner(this.translate.instant(marker('Connecting')));
                try {
                    yield session.start();
                }
                finally {
                    this.stopSpinner();
                }
                this.sshMultiplexer.addSession(session);
            }
            return session;
        });
    }
    attachSessionHandlers() {
        const session = this.session;
        this.attachSessionHandler(session.destroyed$, () => {
            var _a;
            if (this.frontend) {
                // Session was closed abruptly
                this.write('\r\n' + ansi_colors_default().black.bgWhite(' SSH ') + ` ${(_a = this.sshSession) === null || _a === void 0 ? void 0 : _a.profile.options.host}: session closed\r\n`);
                if (this.profile.behaviorOnSessionEnd === 'reconnect') {
                    this.reconnect();
                }
                else if (this.profile.behaviorOnSessionEnd === 'keep' || this.profile.behaviorOnSessionEnd === 'auto' && !this.isSessionExplicitlyTerminated()) {
                    if (!this.reconnectOffered) {
                        this.reconnectOffered = true;
                        this.write(this.translate.instant(marker('Press any key to reconnect')) + '\r\n');
                        this.input$.pipe((0,external_rxjs_.first)()).subscribe(() => {
                            var _a;
                            if (!((_a = this.session) === null || _a === void 0 ? void 0 : _a.open) && this.reconnectOffered) {
                                this.reconnect();
                            }
                        });
                    }
                }
            }
        });
        super.attachSessionHandlers();
    }
    initializeSessionMaybeMultiplex(multiplex = true) {
        var _a, _b;
        return __awaiter(this, void 0, void 0, function* () {
            this.sshSession = yield this.setupOneSession(this.injector, this.profile, multiplex);
            const session = new SSHShellSession(this.injector, this.sshSession, this.profile);
            this.setSession(session);
            this.attachSessionHandler(session.serviceMessage$, msg => {
                msg = msg.replace(/\n/g, '\r\n      ');
                this.write(`\r${ansi_colors_default().black.bgWhite(' SSH ')} ${msg}\r\n`);
                session.resize(this.size.columns, this.size.rows);
            });
            yield session.start();
            if (this.config.store.ssh.clearServiceMessagesOnConnect) {
                (_a = this.frontend) === null || _a === void 0 ? void 0 : _a.clear();
            }
            (_b = this.session) === null || _b === void 0 ? void 0 : _b.resize(this.size.columns, this.size.rows);
        });
    }
    initializeSession() {
        return __awaiter(this, void 0, void 0, function* () {
            this.reconnectOffered = false;
            try {
                yield this.initializeSessionMaybeMultiplex(true);
            }
            catch (_a) {
                try {
                    yield this.initializeSessionMaybeMultiplex(false);
                }
                catch (e) {
                    this.write(ansi_colors_default().black.bgRed(' X ') + ' ' + ansi_colors_default().red(e.message) + '\r\n');
                    return;
                }
            }
        });
    }
    getRecoveryToken(options) {
        var _a;
        return __awaiter(this, void 0, void 0, function* () {
            return {
                type: 'app:ssh-tab',
                profile: this.profile,
                savedState: (options === null || options === void 0 ? void 0 : options.includeState) && ((_a = this.frontend) === null || _a === void 0 ? void 0 : _a.saveState()),
            };
        });
    }
    showPortForwarding() {
        const modal = this.ngbModal.open(SSHPortForwardingModalComponent).componentInstance;
        modal.session = this.sshSession;
    }
    reconnect() {
        var _a, _b;
        return __awaiter(this, void 0, void 0, function* () {
            (_a = this.session) === null || _a === void 0 ? void 0 : _a.destroy();
            yield this.initializeSession();
            (_b = this.session) === null || _b === void 0 ? void 0 : _b.releaseInitialDataBuffer();
        });
    }
    canClose() {
        var _a, _b;
        return __awaiter(this, void 0, void 0, function* () {
            if (!((_a = this.session) === null || _a === void 0 ? void 0 : _a.open)) {
                return true;
            }
            if (!((_b = this.profile.options.warnOnClose) !== null && _b !== void 0 ? _b : this.config.store.ssh.warnOnClose)) {
                return true;
            }
            return (yield this.platform.showMessageBox({
                type: 'warning',
                message: this.translate.instant(marker('Disconnect from {host}?'), this.profile.options),
                buttons: [
                    this.translate.instant(marker('Disconnect')),
                    this.translate.instant(marker('Do not close')),
                ],
                defaultId: 0,
                cancelId: 1,
            })).response === 0;
        });
    }
    openSFTP() {
        var _a, _b;
        return __awaiter(this, void 0, void 0, function* () {
            this.sftpPath = (_b = yield ((_a = this.session) === null || _a === void 0 ? void 0 : _a.getWorkingDirectory())) !== null && _b !== void 0 ? _b : this.sftpPath;
            setTimeout(() => {
                this.sftpPanelVisible = true;
            }, 100);
        });
    }
    onClick() {
        this.sftpPanelVisible = false;
    }
    isSessionExplicitlyTerminated() {
        return super.isSessionExplicitlyTerminated() ||
            this.recentInputs.charCodeAt(this.recentInputs.length - 1) === 4 ||
            this.recentInputs.endsWith('exit\r');
    }
};
SSHTabComponent.ctorParameters = () => [
    { type: core_.Injector },
    { type: SSHService },
    { type: ng_bootstrap_.NgbModal },
    { type: external_tabby_core_.ProfilesService },
    { type: SSHMultiplexerService }
];
SSHTabComponent.propDecorators = {
    onClick: [{ type: core_.HostListener, args: ['click',] }]
};
SSHTabComponent = __decorate([
    (0,core_.Component)({
        selector: 'ssh-tab',
        template: `${external_tabby_terminal_.BaseTerminalTabComponent.template} ${__webpack_require__(/*! ./sshTab.component.pug */ 4113)}`,
        animations: external_tabby_terminal_.BaseTerminalTabComponent.animations,
        styles: [...external_tabby_terminal_.BaseTerminalTabComponent.styles,
            __webpack_require__(/*! ./sshTab.component.scss */ 7846)]
    }),
    __metadata("design:paramtypes", [core_.Injector,
        SSHService,
        ng_bootstrap_.NgbModal,
        external_tabby_core_.ProfilesService,
        SSHMultiplexerService])
], SSHTabComponent);


// EXTERNAL MODULE: ./src/components/sftpPanel.component.pug?ngResource
var sftpPanel_componentngResource = __webpack_require__(687);
var sftpPanel_componentngResource_default = /*#__PURE__*/__webpack_require__.n(sftpPanel_componentngResource);
// EXTERNAL MODULE: ./src/components/sftpPanel.component.scss?ngResource
var components_sftpPanel_componentngResource = __webpack_require__(4987);
var components_sftpPanel_componentngResource_default = /*#__PURE__*/__webpack_require__.n(components_sftpPanel_componentngResource);
// EXTERNAL MODULE: ./src/components/sftpCreateDirectoryModal.component.pug?ngResource
var sftpCreateDirectoryModal_componentngResource = __webpack_require__(7192);
var sftpCreateDirectoryModal_componentngResource_default = /*#__PURE__*/__webpack_require__.n(sftpCreateDirectoryModal_componentngResource);
;// CONCATENATED MODULE: ./src/components/sftpCreateDirectoryModal.component.ts





/** @hidden */
let SFTPCreateDirectoryModalComponent = class SFTPCreateDirectoryModalComponent extends external_tabby_core_.BaseComponent {
    constructor(modalInstance) {
        super();
        this.modalInstance = modalInstance;
    }
    create() {
        this.modalInstance.close(this.directoryName);
    }
    cancel() {
        this.modalInstance.close('');
    }
};
SFTPCreateDirectoryModalComponent.ctorParameters = () => [
    { type: ng_bootstrap_.NgbActiveModal }
];
SFTPCreateDirectoryModalComponent = __decorate([
    (0,core_.Component)({
        template: (sftpCreateDirectoryModal_componentngResource_default()),
    }),
    __metadata("design:paramtypes", [ng_bootstrap_.NgbActiveModal])
], SFTPCreateDirectoryModalComponent);


;// CONCATENATED MODULE: ./src/components/sftpPanel.component.ts











let SFTPPanelComponent = class SFTPPanelComponent {
    constructor(ngbModal, notifications, platform, contextMenuProviders) {
        this.ngbModal = ngbModal;
        this.notifications = notifications;
        this.platform = platform;
        this.contextMenuProviders = contextMenuProviders;
        this.closed = new core_.EventEmitter();
        this.fileList = null;
        this.path = '/';
        this.pathChange = new core_.EventEmitter();
        this.pathSegments = [];
        this.cwdDetectionAvailable = false;
        this.editingPath = null;
        this.contextMenuProviders.sort((a, b) => a.weight - b.weight);
    }
    ngOnInit() {
        return __awaiter(this, void 0, void 0, function* () {
            this.sftp = yield this.session.openSFTP();
            try {
                yield this.navigate(this.path);
            }
            catch (error) {
                console.warn('Could not navigate to', this.path, ':', error);
                this.notifications.error(error.message);
                yield this.navigate('/');
            }
        });
    }
    navigate(newPath, fallbackOnError = true) {
        return __awaiter(this, void 0, void 0, function* () {
            const previousPath = this.path;
            this.path = newPath;
            this.pathChange.next(this.path);
            let p = newPath;
            this.pathSegments = [];
            while (p !== '/') {
                this.pathSegments.unshift({
                    name: external_path_.posix.basename(p),
                    path: p,
                });
                p = external_path_.posix.dirname(p);
            }
            this.fileList = null;
            try {
                this.fileList = yield this.sftp.readdir(this.path);
            }
            catch (error) {
                this.notifications.error(error.message);
                if (previousPath && fallbackOnError) {
                    this.navigate(previousPath, false);
                }
                return;
            }
            const dirKey = a => a.isDirectory ? 1 : 0;
            this.fileList.sort((a, b) => dirKey(b) - dirKey(a) ||
                a.name.localeCompare(b.name));
        });
    }
    getIcon(item) {
        if (item.isDirectory) {
            return 'fas fa-folder text-info';
        }
        if (item.isSymlink) {
            return 'fas fa-link text-warning';
        }
        return 'fas fa-file';
    }
    goUp() {
        this.navigate(external_path_.posix.dirname(this.path));
    }
    open(item) {
        return __awaiter(this, void 0, void 0, function* () {
            if (item.isDirectory) {
                yield this.navigate(item.fullPath);
            }
            else if (item.isSymlink) {
                const target = external_path_.posix.resolve(this.path, yield this.sftp.readlink(item.fullPath));
                const stat = yield this.sftp.stat(target);
                if (stat.isDirectory) {
                    yield this.navigate(item.fullPath);
                }
                else {
                    yield this.download(item.fullPath, stat.mode, stat.size);
                }
            }
            else {
                yield this.download(item.fullPath, item.mode, item.size);
            }
        });
    }
    openCreateDirectoryModal() {
        return __awaiter(this, void 0, void 0, function* () {
            const modal = this.ngbModal.open(SFTPCreateDirectoryModalComponent);
            const directoryName = yield modal.result;
            if (directoryName !== '') {
                this.sftp.mkdir(external_path_.posix.join(this.path, directoryName)).then(() => {
                    this.notifications.notice('The directory was created successfully');
                    this.navigate(external_path_.posix.join(this.path, directoryName));
                }).catch(() => {
                    this.notifications.error('The directory could not be created');
                });
            }
        });
    }
    upload() {
        return __awaiter(this, void 0, void 0, function* () {
            const transfers = yield this.platform.startUpload({ multiple: true });
            yield Promise.all(transfers.map(t => this.uploadOne(t)));
        });
    }
    uploadOne(transfer) {
        return __awaiter(this, void 0, void 0, function* () {
            const savedPath = this.path;
            yield this.sftp.upload(external_path_.posix.join(this.path, transfer.getName()), transfer);
            if (this.path === savedPath) {
                yield this.navigate(this.path);
            }
        });
    }
    download(itemPath, mode, size) {
        return __awaiter(this, void 0, void 0, function* () {
            const transfer = yield this.platform.startDownload(external_path_.posix.basename(itemPath), mode, size);
            if (!transfer) {
                return;
            }
            this.sftp.download(itemPath, transfer);
        });
    }
    getModeString(item) {
        const s = 'SGdrwxrwxrwx';
        const e = '   ---------';
        const c = [
            0o4000, 0o2000, external_constants_.S_IFDIR,
            external_constants_.S_IRUSR, external_constants_.S_IWUSR, external_constants_.S_IXUSR,
            external_constants_.S_IRGRP, external_constants_.S_IWGRP, external_constants_.S_IXGRP,
            external_constants_.S_IROTH, external_constants_.S_IWOTH, external_constants_.S_IXOTH,
        ];
        let result = '';
        for (let i = 0; i < c.length; i++) {
            result += item.mode & c[i] ? s[i] : e[i];
        }
        return result;
    }
    buildContextMenu(item) {
        return __awaiter(this, void 0, void 0, function* () {
            let items = [];
            for (const section of yield Promise.all(this.contextMenuProviders.map(x => x.getItems(item, this)))) {
                items.push({ type: 'separator' });
                items = items.concat(section);
            }
            return items.slice(1);
        });
    }
    showContextMenu(item, event) {
        return __awaiter(this, void 0, void 0, function* () {
            event.preventDefault();
            this.platform.popupContextMenu(yield this.buildContextMenu(item), event);
        });
    }
    get shouldShowCWDTip() {
        return !window.localStorage.sshCWDTipDismissed;
    }
    dismissCWDTip() {
        window.localStorage.sshCWDTipDismissed = 'true';
    }
    editPath() {
        this.editingPath = this.path;
    }
    confirmPath() {
        if (this.editingPath === null) {
            return;
        }
        this.navigate(this.editingPath);
        this.editingPath = null;
    }
    close() {
        this.closed.emit();
    }
};
SFTPPanelComponent.ctorParameters = () => [
    { type: ng_bootstrap_.NgbModal },
    { type: external_tabby_core_.NotificationsService },
    { type: external_tabby_core_.PlatformService },
    { type: Array, decorators: [{ type: core_.Optional }, { type: core_.Inject, args: [SFTPContextMenuItemProvider,] }] }
];
SFTPPanelComponent.propDecorators = {
    session: [{ type: core_.Input }],
    closed: [{ type: core_.Output }],
    path: [{ type: core_.Input }],
    pathChange: [{ type: core_.Output }],
    cwdDetectionAvailable: [{ type: core_.Input }]
};
SFTPPanelComponent = __decorate([
    (0,core_.Component)({
        selector: 'sftp-panel',
        template: (sftpPanel_componentngResource_default()),
        styles: [(components_sftpPanel_componentngResource_default())]
    }),
    __metadata("design:paramtypes", [ng_bootstrap_.NgbModal,
        external_tabby_core_.NotificationsService,
        external_tabby_core_.PlatformService, Array])
], SFTPPanelComponent);


// EXTERNAL MODULE: ./src/components/sftpDeleteModal.component.pug?ngResource
var sftpDeleteModal_componentngResource = __webpack_require__(7255);
var sftpDeleteModal_componentngResource_default = /*#__PURE__*/__webpack_require__.n(sftpDeleteModal_componentngResource);
;// CONCATENATED MODULE: ./src/components/sftpDeleteModal.component.ts





/** @hidden */
let SFTPDeleteModalComponent = class SFTPDeleteModalComponent extends external_tabby_core_.BaseComponent {
    constructor(modalInstance) {
        super();
        this.modalInstance = modalInstance;
        this.progressMessage = '';
        this.cancelled = false;
    }
    ngOnInit() {
        return __awaiter(this, void 0, void 0, function* () {
            this.destroyed$.subscribe(() => this.cancel());
            yield this.run(this.item);
            this.modalInstance.close();
        });
    }
    cancel() {
        this.cancelled = true;
        this.modalInstance.close();
    }
    run(file) {
        return __awaiter(this, void 0, void 0, function* () {
            this.progressMessage = file.fullPath;
            if (file.isDirectory) {
                for (const child of yield this.sftp.readdir(file.fullPath)) {
                    yield this.run(child);
                    if (this.cancelled) {
                        break;
                    }
                }
                yield this.sftp.rmdir(file.fullPath);
            }
            else {
                this.sftp.unlink(file.fullPath);
            }
        });
    }
};
SFTPDeleteModalComponent.ctorParameters = () => [
    { type: ng_bootstrap_.NgbActiveModal }
];
SFTPDeleteModalComponent = __decorate([
    (0,core_.Component)({
        template: (sftpDeleteModal_componentngResource_default()),
    }),
    __metadata("design:paramtypes", [ng_bootstrap_.NgbActiveModal])
], SFTPDeleteModalComponent);


// EXTERNAL MODULE: ./src/components/keyboardInteractiveAuthPanel.component.pug?ngResource
var keyboardInteractiveAuthPanel_componentngResource = __webpack_require__(5897);
var keyboardInteractiveAuthPanel_componentngResource_default = /*#__PURE__*/__webpack_require__.n(keyboardInteractiveAuthPanel_componentngResource);
// EXTERNAL MODULE: ./src/components/keyboardInteractiveAuthPanel.component.scss?ngResource
var components_keyboardInteractiveAuthPanel_componentngResource = __webpack_require__(442);
var components_keyboardInteractiveAuthPanel_componentngResource_default = /*#__PURE__*/__webpack_require__.n(components_keyboardInteractiveAuthPanel_componentngResource);
;// CONCATENATED MODULE: ./src/components/keyboardInteractiveAuthPanel.component.ts





let KeyboardInteractiveAuthComponent = class KeyboardInteractiveAuthComponent {
    constructor() {
        this.step = 0;
        this.done = new core_.EventEmitter();
    }
    isPassword() {
        return this.prompt.prompts[this.step].prompt.toLowerCase().includes('password') || !this.prompt.prompts[this.step].echo;
    }
    previous() {
        if (this.step > 0) {
            this.step--;
        }
        this.input.nativeElement.focus();
    }
    next() {
        if (this.step === this.prompt.prompts.length - 1) {
            this.prompt.respond();
            this.done.emit();
            return;
        }
        this.step++;
        this.input.nativeElement.focus();
    }
};
KeyboardInteractiveAuthComponent.propDecorators = {
    prompt: [{ type: core_.Input }],
    step: [{ type: core_.Input }],
    done: [{ type: core_.Output }],
    input: [{ type: core_.ViewChild, args: ['input',] }]
};
KeyboardInteractiveAuthComponent = __decorate([
    (0,core_.Component)({
        selector: 'keyboard-interactive-auth-panel',
        template: (keyboardInteractiveAuthPanel_componentngResource_default()),
        changeDetection: core_.ChangeDetectionStrategy.OnPush,
        styles: [(components_keyboardInteractiveAuthPanel_componentngResource_default())]
    })
], KeyboardInteractiveAuthComponent);


;// CONCATENATED MODULE: ./src/config.ts

/** @hidden */
class SSHConfigProvider extends external_tabby_core_.ConfigProvider {
    constructor() {
        super(...arguments);
        this.defaults = {
            ssh: {
                warnOnClose: false,
                winSCPPath: null,
                agentType: 'auto',
                agentPath: null,
                x11Display: null,
                knownHosts: [],
                verifyHostKeys: true,
                clearServiceMessagesOnConnect: true,
            },
            hotkeys: {
                'restart-ssh-session': [],
                'launch-winscp': [],
            },
        };
        this.platformDefaults = {};
    }
}

;// CONCATENATED MODULE: ./src/settings.ts




/** @hidden */
let SSHSettingsTabProvider = class SSHSettingsTabProvider extends external_tabby_settings_.SettingsTabProvider {
    constructor() {
        super(...arguments);
        this.id = 'ssh';
        this.icon = 'globe';
        this.title = 'SSH';
    }
    getComponentType() {
        return SSHSettingsTabComponent;
    }
};
SSHSettingsTabProvider = __decorate([
    (0,core_.Injectable)()
], SSHSettingsTabProvider);


;// CONCATENATED MODULE: ./src/recoveryProvider.ts




/** @hidden */
let RecoveryProvider = class RecoveryProvider extends external_tabby_core_.TabRecoveryProvider {
    applicableTo(recoveryToken) {
        return __awaiter(this, void 0, void 0, function* () {
            return recoveryToken.type === 'app:ssh-tab';
        });
    }
    recover(recoveryToken) {
        return __awaiter(this, void 0, void 0, function* () {
            return {
                type: SSHTabComponent,
                inputs: {
                    profile: recoveryToken['profile'],
                    savedState: recoveryToken['savedState'],
                },
            };
        });
    }
};
RecoveryProvider = __decorate([
    (0,core_.Injectable)()
], RecoveryProvider);


;// CONCATENATED MODULE: ./src/hotkeys.ts



/** @hidden */
let SSHHotkeyProvider = class SSHHotkeyProvider extends external_tabby_core_.HotkeyProvider {
    constructor(translate) {
        super();
        this.translate = translate;
        this.hotkeys = [
            {
                id: 'restart-ssh-session',
                name: this.translate.instant('Restart current SSH session'),
            },
            {
                id: 'launch-winscp',
                name: this.translate.instant('Launch WinSCP for current SSH session'),
            },
        ];
    }
    provide() {
        return __awaiter(this, void 0, void 0, function* () {
            return this.hotkeys;
        });
    }
};
SSHHotkeyProvider.ctorParameters = () => [
    { type: external_tabby_core_.TranslateService }
];
SSHHotkeyProvider = __decorate([
    (0,core_.Injectable)(),
    __metadata("design:paramtypes", [external_tabby_core_.TranslateService])
], SSHHotkeyProvider);


;// CONCATENATED MODULE: ./src/tabContextMenu.ts





/** @hidden */
let SFTPContextMenu = class SFTPContextMenu extends external_tabby_core_.TabContextMenuItemProvider {
    constructor(hostApp, ssh, translate) {
        super();
        this.hostApp = hostApp;
        this.ssh = ssh;
        this.translate = translate;
        this.weight = 10;
    }
    getItems(tab) {
        return __awaiter(this, void 0, void 0, function* () {
            if (!(tab instanceof SSHTabComponent)) {
                return [];
            }
            const items = [{
                    label: this.translate.instant('Open SFTP panel'),
                    click: () => {
                        tab.openSFTP();
                    },
                }];
            if (this.hostApp.platform === external_tabby_core_.Platform.Windows && this.ssh.getWinSCPPath()) {
                items.push({
                    label: this.translate.instant('Launch WinSCP'),
                    click: () => {
                        this.ssh.launchWinSCP(tab.sshSession);
                    },
                });
            }
            return items;
        });
    }
};
SFTPContextMenu.ctorParameters = () => [
    { type: external_tabby_core_.HostAppService },
    { type: SSHService },
    { type: external_tabby_core_.TranslateService }
];
SFTPContextMenu = __decorate([
    (0,core_.Injectable)(),
    __metadata("design:paramtypes", [external_tabby_core_.HostAppService,
        SSHService,
        external_tabby_core_.TranslateService])
], SFTPContextMenu);


;// CONCATENATED MODULE: ./src/profiles.ts









let SSHProfilesService = class SSHProfilesService extends external_tabby_core_.ProfileProvider {
    constructor(passwordStorage, translate, injector) {
        super();
        this.passwordStorage = passwordStorage;
        this.translate = translate;
        this.injector = injector;
        this.id = 'ssh';
        this.name = 'SSH';
        this.supportsQuickConnect = true;
        this.settingsComponent = SSHProfileSettingsComponent;
        this.configDefaults = {
            options: {
                host: null,
                port: 22,
                user: 'root',
                auth: null,
                password: null,
                privateKeys: [],
                keepaliveInterval: 5000,
                keepaliveCountMax: 10,
                readyTimeout: null,
                x11: false,
                skipBanner: false,
                jumpHost: null,
                agentForward: false,
                warnOnClose: null,
                algorithms: {
                    hmac: [],
                    kex: [],
                    cipher: [],
                    serverHostKey: [],
                },
                proxyCommand: null,
                forwardedPorts: [],
                scripts: [],
                socksProxyHost: null,
                socksProxyPort: null,
                httpProxyHost: null,
                httpProxyPort: null,
                reuseSession: true,
            },
        };
        for (const k of Object.values(SSHAlgorithmType)) {
            const defaultAlg = {
                [SSHAlgorithmType.KEX]: 'DEFAULT_KEX',
                [SSHAlgorithmType.HOSTKEY]: 'DEFAULT_SERVER_HOST_KEY',
                [SSHAlgorithmType.CIPHER]: 'DEFAULT_CIPHER',
                [SSHAlgorithmType.HMAC]: 'DEFAULT_MAC',
            }[k];
            this.configDefaults.options.algorithms[k] = constants[defaultAlg].filter(x => !ALGORITHM_BLACKLIST.includes(x));
            this.configDefaults.options.algorithms[k].sort();
        }
    }
    getBuiltinProfiles() {
        return __awaiter(this, void 0, void 0, function* () {
            const importers = this.injector.get(SSHProfileImporter, [], core_.InjectFlags.Optional);
            let imported = [];
            for (const importer of importers) {
                try {
                    imported = imported.concat(yield importer.getProfiles());
                }
                catch (e) {
                    console.warn('Could not import SSH profiles:', e);
                }
            }
            return [
                {
                    id: `ssh:template`,
                    type: 'ssh',
                    name: this.translate.instant('SSH connection'),
                    icon: 'fas fa-desktop',
                    options: {
                        host: '',
                        port: 22,
                        user: 'root',
                    },
                    isBuiltin: true,
                    isTemplate: true,
                    weight: -1,
                },
                ...imported.map(p => (Object.assign(Object.assign({}, p), { isBuiltin: true }))),
            ];
        });
    }
    getNewTabParameters(profile) {
        return __awaiter(this, void 0, void 0, function* () {
            return {
                type: SSHTabComponent,
                inputs: { profile },
            };
        });
    }
    getSuggestedName(profile) {
        return `${profile.options.user}@${profile.options.host}:${profile.options.port}`;
    }
    getDescription(profile) {
        var _a, _b;
        return (_b = (_a = profile.options) === null || _a === void 0 ? void 0 : _a.host) !== null && _b !== void 0 ? _b : '';
    }
    deleteProfile(profile) {
        this.passwordStorage.deletePassword(profile);
    }
    quickConnect(query) {
        let user = undefined;
        let host = query;
        let port = 22;
        if (host.includes('@')) {
            const parts = host.split(/@/g);
            host = parts[parts.length - 1];
            user = parts.slice(0, parts.length - 1).join('@');
        }
        if (host.includes('[')) {
            port = parseInt(host.split(']')[1].substring(1));
            host = host.split(']')[0].substring(1);
        }
        else if (host.includes(':')) {
            port = parseInt(host.split(/:/g)[1]);
            host = host.split(':')[0];
        }
        return {
            name: query,
            type: 'ssh',
            options: {
                host,
                user,
                port,
            },
        };
    }
    intoQuickConnectString(profile) {
        let s = profile.options.host;
        if (profile.options.user !== 'root') {
            s = `${profile.options.user}@${s}`;
        }
        if (profile.options.port !== 22) {
            s = `${s}:${profile.options.port}`;
        }
        return s;
    }
};
SSHProfilesService.ctorParameters = () => [
    { type: PasswordStorageService },
    { type: external_tabby_core_.TranslateService },
    { type: core_.Injector }
];
SSHProfilesService = __decorate([
    (0,core_.Injectable)({ providedIn: 'root' }),
    __metadata("design:paramtypes", [PasswordStorageService,
        external_tabby_core_.TranslateService,
        core_.Injector])
], SSHProfilesService);


;// CONCATENATED MODULE: ./src/sftpContextMenu.ts






/** @hidden */
let CommonSFTPContextMenu = class CommonSFTPContextMenu extends SFTPContextMenuItemProvider {
    constructor(platform, ngbModal, translate) {
        super();
        this.platform = platform;
        this.ngbModal = ngbModal;
        this.translate = translate;
        this.weight = 10;
    }
    getItems(item, panel) {
        return __awaiter(this, void 0, void 0, function* () {
            return [
                {
                    click: () => __awaiter(this, void 0, void 0, function* () {
                        yield panel.openCreateDirectoryModal();
                    }),
                    label: this.translate.instant('Create directory'),
                },
                {
                    click: () => __awaiter(this, void 0, void 0, function* () {
                        if ((yield this.platform.showMessageBox({
                            type: 'warning',
                            message: this.translate.instant('Delete {fullPath}?', item),
                            defaultId: 0,
                            cancelId: 1,
                            buttons: [
                                this.translate.instant('Delete'),
                                this.translate.instant('Cancel'),
                            ],
                        })).response === 0) {
                            yield this.deleteItem(item, panel.sftp);
                            panel.navigate(panel.path);
                        }
                    }),
                    label: this.translate.instant('Delete'),
                },
            ];
        });
    }
    deleteItem(item, session) {
        return __awaiter(this, void 0, void 0, function* () {
            const modal = this.ngbModal.open(SFTPDeleteModalComponent);
            modal.componentInstance.item = item;
            modal.componentInstance.sftp = session;
            yield modal.result;
        });
    }
};
CommonSFTPContextMenu.ctorParameters = () => [
    { type: external_tabby_core_.PlatformService },
    { type: ng_bootstrap_.NgbModal },
    { type: external_tabby_core_.TranslateService }
];
CommonSFTPContextMenu = __decorate([
    (0,core_.Injectable)(),
    __metadata("design:paramtypes", [external_tabby_core_.PlatformService,
        ng_bootstrap_.NgbModal,
        external_tabby_core_.TranslateService])
], CommonSFTPContextMenu);


;// CONCATENATED MODULE: ./src/index.ts




























/** @hidden */
let SSHModule = class SSHModule {
};
SSHModule = __decorate([
    (0,core_.NgModule)({
        imports: [
            ng_bootstrap_.NgbModule,
            NgxFilesizeModule,
            common_.CommonModule,
            forms_.FormsModule,
            external_ngx_toastr_.ToastrModule,
            (external_tabby_core_default()),
            (external_tabby_terminal_default()),
        ],
        providers: [
            { provide: external_tabby_core_.ConfigProvider, useClass: SSHConfigProvider, multi: true },
            { provide: external_tabby_settings_.SettingsTabProvider, useClass: SSHSettingsTabProvider, multi: true },
            { provide: external_tabby_core_.TabRecoveryProvider, useClass: RecoveryProvider, multi: true },
            { provide: external_tabby_core_.HotkeyProvider, useClass: SSHHotkeyProvider, multi: true },
            { provide: external_tabby_core_.TabContextMenuItemProvider, useClass: SFTPContextMenu, multi: true },
            { provide: external_tabby_core_.ProfileProvider, useExisting: SSHProfilesService, multi: true },
            { provide: SFTPContextMenuItemProvider, useClass: CommonSFTPContextMenu, multi: true },
        ],
        declarations: [
            SSHProfileSettingsComponent,
            SFTPDeleteModalComponent,
            SFTPCreateDirectoryModalComponent,
            SSHPortForwardingModalComponent,
            SSHPortForwardingConfigComponent,
            SSHSettingsTabComponent,
            SSHTabComponent,
            SFTPPanelComponent,
            KeyboardInteractiveAuthComponent,
            HostKeyPromptModalComponent,
        ],
    })
    // eslint-disable-next-line @typescript-eslint/no-extraneous-class
], SSHModule);
/* harmony default export */ const src = (SSHModule);




})();

/******/ 	return __webpack_exports__;
/******/ })()
;
});
//# sourceMappingURL=../../../app.asar.unpacked/assets/webpack/index.js.map