/*! For license information please see background.js.LICENSE.txt */ !

function(e) {
var t = {};

function r(n) {
if (t[n]) return t[n].exports;
var i = t[n] = {
i: n,
l: !1,
exports: {}
};
return e[n].call(i.exports, i, i.exports, r), i.l = !0, i.exports
}
r.m = e, r.c = t, r.d = function(e, t, n) {
r.o(e, t) || Object.defineProperty(e, t, {
enumerable: !0,
get: n
})
}, r.r = function(e) {
"undefined" != typeof Symbol && Symbol.toStringTag && Object.defineProperty(e,
Symbol.toStringTag, {
value: "Module"
}), Object.defineProperty(e, "__esModule", {
value: !0
})
}, r.t = function(e, t) {
if (1 & t && (e = r(e)), 8 & t) return e;
if (4 & t && "object" == typeof e && e && e.__esModule) return e;
var n = Object.create(null);
if (r.r(n), Object.defineProperty(n, "default", {
enumerable: !0,
value: e
}), 2 & t && "string" != typeof e)
for (var i in e) r.d(n, i, function(t) {
return e[t]
}.bind(null, i));
return n
}, r.n = function(e) {
var t = e && e.__esModule ? function() {
return e.default
} : function() {
return e
};
return r.d(t, "a", t), t
}, r.o = function(e, t) {
return Object.prototype.hasOwnProperty.call(e, t)
}, r.p = "", r(r.s = 250)
}([function(e, t) {
e.exports = require("electron")
}, function(e, t) {
e.exports = require("path")
}, function(e, t) {
e.exports = require("fs")
}, function(e, t) {
e.exports = require("util")
}, function(e, t) {
e.exports = require("url")
}, function(e, t) {
e.exports = require("crypto")
}, function(e, t, r) {
var n = r(24),
i = r(8).Stream,
a = r(3),
o = /^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]
{12}$/;

function s(e) {
return e.charAt(0).toUpperCase() + e.slice(1)
}

function c(e, t, r, i, o) {
throw new n.AssertionError({
message: a.format("%s (%s) is required", e, t),
actual: void 0 === o ? typeof i : o(i),
expected: t,
operator: r || "===",
stackStartFunction: c.caller
})
}

function u(e) {
return Object.prototype.toString.call(e).slice(8, -1)
}

function l() {}
var p = {
bool: {
check: function(e) {
return "boolean" == typeof e
}
},
func: {
check: function(e) {
return "function" == typeof e
}
},
string: {
check: function(e) {
return "string" == typeof e
}
},
object: {
check: function(e) {
return "object" == typeof e && null !== e
}
},
number: {
check: function(e) {
return "number" == typeof e && !isNaN(e)
}
},
finite: {
check: function(e) {
return "number" == typeof e && !isNaN(e) && isFinite(e)
}
},
buffer: {
check: function(e) {
return Buffer.isBuffer(e)
},
operator: "Buffer.isBuffer"
},
array: {
check: function(e) {
return Array.isArray(e)
},
operator: "Array.isArray"
},
stream: {
check: function(e) {
return e instanceof i
},
operator: "instanceof",
actual: u
},
date: {
check: function(e) {
return e instanceof Date
},
operator: "instanceof",
actual: u
},
regexp: {
check: function(e) {
return e instanceof RegExp
},
operator: "instanceof",
actual: u
},
uuid: {
check: function(e) {
return "string" == typeof e && o.test(e)
},
operator: "isUUID"
}
};
e.exports = function e(t) {
var r, i = Object.keys(p);
return r = process.env.NODE_NDEBUG ? l : function(e, t) {
e || c(t, "true", e)
}, i.forEach((function(e) {
if (t) r[e] = l;
else {
var n = p[e];
r[e] = function(t, r) {
n.check(t) || c(r, e, n.operator, t, n.actual)
}
}
})), i.forEach((function(e) {
var n = "optional" + s(e);
if (t) r[n] = l;
else {
var i = p[e];
r[n] = function(t, r) {
null != t && (i.check(t) || c(r, e, i.operator, t, i.actual))
}
}
})), i.forEach((function(e) {
var n = "arrayOf" + s(e);
if (t) r[n] = l;
else {
var i = p[e],
a = "[" + e + "]";
r[n] = function(e, t) {
var r;
for (Array.isArray(e) || c(t, a, i.operator, e, i.actual), r = 0; r < e.length; r+
+) i.check(e[r]) || c(t, a, i.operator, e, i.actual)
}
}
})), i.forEach((function(e) {
var n = "optionalArrayOf" + s(e);
if (t) r[n] = l;
else {
var i = p[e],
a = "[" + e + "]";
r[n] = function(e, t) {
var r;
if (null != e)
for (Array.isArray(e) || c(t, a, i.operator, e, i.actual), r = 0; r < e.length; r+
+) i.check(e[r]) || c(t, a, i.operator, e, i.actual)
}
}
})), Object.keys(n).forEach((function(e) {
r[e] = "AssertionError" !== e && t ? l : n[e]
})), r._setExports = e, r
}(process.env.NODE_NDEBUG)
}, function(e, t, r) {
"use strict";
var n, i = r(87),
a = i.Buffer,
o = {};
for (n in i) i.hasOwnProperty(n) && "SlowBuffer" !== n && "Buffer" !== n && (o[n] =
i[n]);
var s = o.Buffer = {};
for (n in a) a.hasOwnProperty(n) && "allocUnsafe" !== n && "allocUnsafeSlow" !== n
&& (s[n] = a[n]);
if (o.Buffer.prototype = a.prototype, s.from && s.from !== Uint8Array.from ||
(s.from = function(e, t, r) {
if ("number" == typeof e) throw new TypeError('The "value" argument must not be of
type number. Received type ' + typeof e);
if (e && void 0 === e.length) throw new TypeError("The first argument must be one
of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " +
typeof e);
return a(e, t, r)
}), s.alloc || (s.alloc = function(e, t, r) {
if ("number" != typeof e) throw new TypeError('The "size" argument must be of type
number. Received type ' + typeof e);
if (e < 0 || e >= 2 * (1 << 30)) throw new RangeError('The value "' + e + '" is
invalid for option "size"');
var n = a(e);
return t && 0 !== t.length ? "string" == typeof r ? n.fill(t, r) : n.fill(t) :
n.fill(0), n
}), !o.kStringMaxLength) try {
o.kStringMaxLength = process.binding("buffer").kStringMaxLength
} catch (e) {}
o.constants || (o.constants = {
MAX_LENGTH: o.kMaxLength
}, o.kStringMaxLength && (o.constants.MAX_STRING_LENGTH = o.kStringMaxLength)),
e.exports = o
}, function(e, t) {
e.exports = require("stream")
}, function(e, t, r) {
"use strict";
var n = r(44),
i = r(164),
a = r(88),
o = r(263),
s = r(69);

function c(e) {
return e
}

function u(e, t) {
for (var r = 0; r < e.length; ++r) t[r] = 255 & e.charCodeAt(r);
return t
}
t.newBlob = function(e, r) {
t.checkSupport("blob");
try {
return new Blob([e], {
type: r
})
} catch (t) {
try {
var n = new(self.BlobBuilder || self.WebKitBlobBuilder || self.MozBlobBuilder ||
self.MSBlobBuilder);
return n.append(e), n.getBlob(r)
} catch (e) {
throw new Error("Bug : can't construct the Blob.")
}
}
};
var l = {
stringifyByChunk: function(e, t, r) {
var n = [],
i = 0,
a = e.length;
if (a <= r) return String.fromCharCode.apply(null, e);
for (; i < a;) "array" === t || "nodebuffer" === t ?
n.push(String.fromCharCode.apply(null, e.slice(i, Math.min(i + r, a)))) :
n.push(String.fromCharCode.apply(null, e.subarray(i, Math.min(i + r, a)))), i += r;
return n.join("")
},
stringifyByChar: function(e) {
for (var t = "", r = 0; r < e.length; r++) t += String.fromCharCode(e[r]);
return t
},
applyCanBeUsed: {
uint8array: function() {
try {
return n.uint8array && 1 === String.fromCharCode.apply(null, new
Uint8Array(1)).length
} catch (e) {
return !1
}
}(),
nodebuffer: function() {
try {
return n.nodebuffer && 1 === String.fromCharCode.apply(null,
a.allocBuffer(1)).length
} catch (e) {
return !1
}
}()
}
};

function p(e) {
var r = 65536,
n = t.getTypeOf(e),
i = !0;
if ("uint8array" === n ? i = l.applyCanBeUsed.uint8array : "nodebuffer" === n && (i
= l.applyCanBeUsed.nodebuffer), i)
for (; r > 1;) try {
return l.stringifyByChunk(e, n, r)
} catch (e) {
r = Math.floor(r / 2)
}
return l.stringifyByChar(e)
}

function h(e, t) {
for (var r = 0; r < e.length; r++) t[r] = e[r];
return t
}
t.applyFromCharCode = p;
var d = {};
d.string = {
string: c,
array: function(e) {
return u(e, new Array(e.length))
},
arraybuffer: function(e) {
return d.string.uint8array(e).buffer
},
uint8array: function(e) {
return u(e, new Uint8Array(e.length))
},
nodebuffer: function(e) {
return u(e, a.allocBuffer(e.length))
}
}, d.array = {
string: p,
array: c,
arraybuffer: function(e) {
return new Uint8Array(e).buffer
},
uint8array: function(e) {
return new Uint8Array(e)
},
nodebuffer: function(e) {
return a.newBufferFrom(e)
}
}, d.arraybuffer = {
string: function(e) {
return p(new Uint8Array(e))
},
array: function(e) {
return h(new Uint8Array(e), new Array(e.byteLength))
},
arraybuffer: c,
uint8array: function(e) {
return new Uint8Array(e)
},
nodebuffer: function(e) {
return a.newBufferFrom(new Uint8Array(e))
}
}, d.uint8array = {
string: p,
array: function(e) {
return h(e, new Array(e.length))
},
arraybuffer: function(e) {
return e.buffer
},
uint8array: c,
nodebuffer: function(e) {
return a.newBufferFrom(e)
}
}, d.nodebuffer = {
string: p,
array: function(e) {
return h(e, new Array(e.length))
},
arraybuffer: function(e) {
return d.nodebuffer.uint8array(e).buffer
},
uint8array: function(e) {
return h(e, new Uint8Array(e.length))
},
nodebuffer: c
}, t.transformTo = function(e, r) {
if (r || (r = ""), !e) return r;
t.checkSupport(e);
var n = t.getTypeOf(r);
return d[n][e](r)
}, t.getTypeOf = function(e) {
return "string" == typeof e ? "string" : "[object Array]" ===
Object.prototype.toString.call(e) ? "array" : n.nodebuffer && a.isBuffer(e) ?
"nodebuffer" : n.uint8array && e instanceof Uint8Array ? "uint8array" :
n.arraybuffer && e instanceof ArrayBuffer ? "arraybuffer" : void 0
}, t.checkSupport = function(e) {
if (!n[e.toLowerCase()]) throw new Error(e + " is not supported by this platform")
}, t.MAX_VALUE_16BITS = 65535, t.MAX_VALUE_32BITS = -1, t.pretty = function(e) {
var t, r, n = "";
for (r = 0; r < (e || "").length; r++) n += "\\x" + ((t = e.charCodeAt(r)) < 16 ?
"0" : "") + t.toString(16).toUpperCase();
return n
}, t.delay = function(e, t, r) {
o((function() {
e.apply(r || null, t || [])
}))
}, t.inherits = function(e, t) {
var r = function() {};
r.prototype = t.prototype, e.prototype = new r
}, t.extend = function() {
var e, t, r = {};
for (e = 0; e < arguments.length; e++)
for (t in arguments[e]) arguments[e].hasOwnProperty(t) && void 0 === r[t] && (r[t]
= arguments[e][t]);
return r
}, t.prepareContent = function(e, r, a, o, c) {
return s.Promise.resolve(r).then((function(e) {
return n.blob && (e instanceof Blob || -1 !== ["[object File]", "[object
Blob]"].indexOf(Object.prototype.toString.call(e))) && "undefined" != typeof
FileReader ? new s.Promise((function(t, r) {
var n = new FileReader;
n.onload = function(e) {
t(e.target.result)
}, n.onerror = function(e) {
r(e.target.error)
}, n.readAsArrayBuffer(e)
})) : e
})).then((function(r) {
var l, p = t.getTypeOf(r);
return p ? ("arraybuffer" === p ? r = t.transformTo("uint8array", r) : "string" ===
p && (c ? r = i.decode(r) : a && !0 !== o && (r = u(l = r, n.uint8array ? new
Uint8Array(l.length) : new Array(l.length)))), r) : s.Promise.reject(new
Error("Can't read the data of '" + e + "'. Is it in a supported JavaScript type
(String, Blob, ArrayBuffer, etc) ?"))
}))
}
}, function(e, t, r) {
"use strict";
Object.defineProperty(t, "__esModule", {
value: !0
}), t.newError = t.asArray = t.CURRENT_APP_PACKAGE_FILE_NAME =
t.CURRENT_APP_INSTALLER_FILE_NAME = t.XElement = t.parseXml =
t.ProgressCallbackTransform = t.UUID = t.parseDn = t.githubUrl =
t.getS3LikeProviderBaseUrl = t.configureRequestUrl = t.parseJson =
t.safeStringifyJson = t.configureRequestOptionsFromUrl = t.configureRequestOptions
= t.safeGetHeader = t.DigestTransform = t.HttpExecutor = t.createHttpError =
t.HttpError = t.CancellationError = t.CancellationToken = void 0;
var n = r(184);
Object.defineProperty(t, "CancellationToken", {
enumerable: !0,
get: function() {
return n.CancellationToken
}
}), Object.defineProperty(t, "CancellationError", {
enumerable: !0,
get: function() {
return n.CancellationError
}
});
var i = r(320);
Object.defineProperty(t, "HttpError", {
enumerable: !0,
get: function() {
return i.HttpError
}
}), Object.defineProperty(t, "createHttpError", {
enumerable: !0,
get: function() {
return i.createHttpError
}
}), Object.defineProperty(t, "HttpExecutor", {
enumerable: !0,
get: function() {
return i.HttpExecutor
}
}), Object.defineProperty(t, "DigestTransform", {
enumerable: !0,
get: function() {
return i.DigestTransform
}
}), Object.defineProperty(t, "safeGetHeader", {
enumerable: !0,
get: function() {
return i.safeGetHeader
}
}), Object.defineProperty(t, "configureRequestOptions", {
enumerable: !0,
get: function() {
return i.configureRequestOptions
}
}), Object.defineProperty(t, "configureRequestOptionsFromUrl", {
enumerable: !0,
get: function() {
return i.configureRequestOptionsFromUrl
}
}), Object.defineProperty(t, "safeStringifyJson", {
enumerable: !0,
get: function() {
return i.safeStringifyJson
}
}), Object.defineProperty(t, "parseJson", {
enumerable: !0,
get: function() {
return i.parseJson
}
}), Object.defineProperty(t, "configureRequestUrl", {
enumerable: !0,
get: function() {
return i.configureRequestUrl
}
});
var a = r(327);
Object.defineProperty(t, "getS3LikeProviderBaseUrl", {
enumerable: !0,
get: function() {
return a.getS3LikeProviderBaseUrl
}
}), Object.defineProperty(t, "githubUrl", {
enumerable: !0,
get: function() {
return a.githubUrl
}
});
var o = r(328);
Object.defineProperty(t, "parseDn", {
enumerable: !0,
get: function() {
return o.parseDn
}
});
var s = r(329);
Object.defineProperty(t, "UUID", {
enumerable: !0,
get: function() {
return s.UUID
}
});
var c = r(186);
Object.defineProperty(t, "ProgressCallbackTransform", {
enumerable: !0,
get: function() {
return c.ProgressCallbackTransform
}
});
var u = r(330);
Object.defineProperty(t, "parseXml", {
enumerable: !0,
get: function() {
return u.parseXml
}
}), Object.defineProperty(t, "XElement", {
enumerable: !0,
get: function() {
return u.XElement
}
}), t.CURRENT_APP_INSTALLER_FILE_NAME = "installer.exe",
t.CURRENT_APP_PACKAGE_FILE_NAME = "package.7z", t.asArray = function(e) {
return null == e ? [] : Array.isArray(e) ? e : [e]
}, t.newError = function(e, t) {
const r = new Error(e);
return r.code = t, r
}
}, , function(e, t, r) {
e.exports = g;
var n, i = r(6),
a = r(16),
o = r(5),
s = r(72),
c = r(40),
u = r(143).DiffieHellman,
l = r(34),
p = r(13),
h = r(14);
try {
n = r(215)
} catch (e) {}
var d = l.InvalidAlgorithmError,
f = l.KeyParseError,
m = {};

function g(e) {
i.object(e, "options"), i.arrayOfObject(e.parts, "options.parts"), i.string(e.type,
"options.type"), i.optionalString(e.comment, "options.comment");
var t = a.info[e.type];
if ("object" != typeof t) throw new d(e.type);
for (var r, n = {}, o = 0; o < e.parts.length; ++o) {
var s = e.parts[o];
n[s.name] = s
}
if (this.type = e.type, this.parts = e.parts, this.part = n, this.comment = void 0,
this.source = e.source, this._rfc4253Cache = e._rfc4253Cache, this._hashCache = {},
this.curve = void 0, "ecdsa" === this.type) {
var c = this.part.curve.data.toString();
this.curve = c, r = a.curves[c].size
} else if ("ed25519" === this.type || "curve25519" === this.type) r = 256,
this.curve = "curve25519";
else {
var u = this.part[t.sizePart];
r = 8 * (r = u.data.length) - p.countZeros(u.data)
}
this.size = r
}
m.auto = r(216), m.pem = r(46), m.pkcs1 = r(144), m.pkcs8 = r(76), m.rfc4253 =
r(47), m.ssh = r(218), m["ssh-private"] = r(105), m.openssh = m["ssh-private"],
m.dnssec = r(145), m.putty = r(219), m.ppk = m.putty, g.formats = m,
g.prototype.toBuffer = function(e, t) {
return void 0 === e && (e = "ssh"), i.string(e, "format"), i.object(m[e],
"formats[format]"), i.optionalObject(t, "options"), "rfc4253" === e ? (void 0 ===
this._rfc4253Cache && (this._rfc4253Cache = m.rfc4253.write(this)),
this._rfc4253Cache) : m[e].write(this, t)
}, g.prototype.toString = function(e, t) {
return this.toBuffer(e, t).toString()
}, g.prototype.hash = function(e, t) {
if (i.string(e, "algorithm"), i.optionalString(t, "type"), void 0 === t && (t =
"ssh"), e = e.toLowerCase(), void 0 === a.hashAlgs[e]) throw new d(e);
var r, n = e + "||" + t;
if (this._hashCache[n]) return this._hashCache[n];
if ("ssh" === t) r = this.toBuffer("rfc4253");
else {
if ("spki" !== t) throw new Error("Hash type " + t + " not supported");
r = m.pkcs8.pkcs8ToBuffer(this)
}
var s = o.createHash(e).update(r).digest();
return this._hashCache[n] = s, s
}, g.prototype.fingerprint = function(e, t) {
void 0 === e && (e = "sha256"), void 0 === t && (t = "ssh"), i.string(e,
"algorithm"), i.string(t, "type");
var r = {
type: "key",
hash: this.hash(e, t),
algorithm: e,
hashType: t
};
return new s(r)
}, g.prototype.defaultHashAlgorithm = function() {
var e = "sha1";
return "rsa" === this.type && (e = "sha256"), "dsa" === this.type && this.size >
1024 && (e = "sha256"), "ed25519" === this.type && (e = "sha512"), "ecdsa" ===
this.type && (e = this.size <= 256 ? "sha256" : this.size <= 384 ? "sha384" :
"sha512"), e
}, g.prototype.createVerify = function(e) {
if (void 0 === e && (e = this.defaultHashAlgorithm()), i.string(e, "hash
algorithm"), "ed25519" === this.type && void 0 !== n) return new n.Verifier(this,
e);
if ("curve25519" === this.type) throw new Error("Curve25519 keys are not suitable
for signing or verification");
var t, r, a;
try {
r = e.toUpperCase(), t = o.createVerify(r)
} catch (e) {
a = e
}(void 0 === t || a instanceof Error && a.message.match(/Unknown message digest/))
&& (r = "RSA-", r += e.toUpperCase(), t = o.createVerify(r)), i.ok(t, "failed to
create verifier");
var s = t.verify.bind(t),
u = this.toBuffer("pkcs8"),
l = this.curve,
p = this;
return t.verify = function(t, r) {
if (c.isSignature(t, [2, 0])) return t.type === p.type && (!t.hashAlgorithm ||
t.hashAlgorithm === e) && (!t.curve || "ecdsa" !== p.type || t.curve === l) && s(u,
t.toBuffer("asn1"));
if ("string" == typeof t || Buffer.isBuffer(t)) return s(u, t, r);
throw c.isSignature(t, [1, 0]) ? new Error("signature was created by too old a
version of sshpk and cannot be verified") : new TypeError("signature must be a
string, Buffer, or Signature object")
}, t
}, g.prototype.createDiffieHellman = function() {
if ("rsa" === this.type) throw new Error("RSA keys do not support Diffie-Hellman");
return new u(this)
}, g.prototype.createDH = g.prototype.createDiffieHellman, g.parse = function(e, t,
r) {
"string" != typeof e && i.buffer(e, "data"), void 0 === t && (t = "auto"),
i.string(t, "format"), "string" == typeof r && (r = {
filename: r
}), i.optionalObject(r, "options"), void 0 === r && (r = {}),
i.optionalString(r.filename, "options.filename"), void 0 === r.filename &&
(r.filename = "(unnamed)"), i.object(m[t], "formats[format]");
try {
var n = m[t].read(e, r);
return n instanceof h && (n = n.toPublic()), n.comment || (n.comment = r.filename),
n
} catch (e) {
if ("KeyEncryptedError" === e.name) throw e;
throw new f(r.filename, t, e)
}
}, g.isKey = function(e, t) {
return p.isCompatible(e, g, t)
}, g.prototype._sshpkApiVersion = [1, 7], g._oldVersionDetect = function(e) {
return i.func(e.toBuffer), i.func(e.fingerprint), e.createDH ? [1, 4] :
e.defaultHashAlgorithm ? [1, 3] : e.formats.auto ? [1, 2] : e.formats.pkcs1 ? [1,
1] : [1, 0]
}
}, function(e, t, r) {
e.exports = {
bufferSplit: function(e, t) {
n.buffer(e), n.string(t);
for (var r = [], i = 0, a = 0, o = 0; o < e.length; ++o)
if (e[o] === t.charCodeAt(a) ? ++a : a = e[o] === t.charCodeAt(0) ? 1 : 0, a >=
t.length) {
var s = o + 1;
r.push(e.slice(i, s - a)), i = s, a = 0
}
return i <= e.length && r.push(e.slice(i, e.length)), r
},
addRSAMissing: function(e) {
n.object(e), d(e, a, [1, 1]);
var t, r = new p(e.part.d.data);
if (!e.part.dmodp) {
var i = new p(e.part.p.data);
t = g(r.mod(i.subtract(1))), e.part.dmodp = {
name: "dmodp",
data: t
}, e.parts.push(e.part.dmodp)
}
if (!e.part.dmodq) {
var o = new p(e.part.q.data);
t = g(r.mod(o.subtract(1))), e.part.dmodq = {
name: "dmodq",
data: t
}, e.parts.push(e.part.dmodq)
}
},
calculateDSAPublic: function(e, t, r) {
return n.buffer(e), n.buffer(t), n.buffer(r), e = new p(e), t = new p(t), r = new
p(r), g(e.modPow(r, t))
},
calculateED25519Public: function(e) {
n.buffer(e);
var t = h.sign.keyPair.fromSeed(new Uint8Array(e));
return i.from(t.publicKey)
},
calculateX25519Public: function(e) {
n.buffer(e);
var t = h.box.keyPair.fromSeed(new Uint8Array(e));
return i.from(t.publicKey)
},
mpNormalize: m,
mpDenormalize: function(e) {
for (n.buffer(e); e.length > 1 && 0 === e[0];) e = e.slice(1);
return e
},
ecNormalize: function(e, t) {
if (n.buffer(e), 0 === e[0] && 4 === e[1]) return t ? e : e.slice(1);
if (4 === e[0]) {
if (!t) return e
} else {
for (; 0 === e[0];) e = e.slice(1);
if (2 === e[0] || 3 === e[0]) throw new Error("Compressed elliptic curve points are
not supported");
if (4 !== e[0]) throw new Error("Not a valid elliptic curve point");
if (!t) return e
}
var r = i.alloc(e.length + 1);
return r[0] = 0, e.copy(r, 1), r
},
countZeros: function(e) {
for (var t = 0, r = 8; t < e.length;) {
var n = 1 << r;
if ((e[t] & n) === n) break;
--r < 0 && (t++, r = 8)
}
return 8 * t + (8 - r) - 1
},
assertCompatible: d,
isCompatible: function(e, t, r) {
if (null === e || "object" != typeof e) return !1;
if (void 0 === r && (r = t.prototype._sshpkApiVersion), e instanceof t &&
t.prototype._sshpkApiVersion[0] == r[0]) return !0;
for (var n = Object.getPrototypeOf(e), i = 0; n.constructor.name !== t.name;)
if (!(n = Object.getPrototypeOf(n)) || ++i > 3) return !1;
if (n.constructor.name !== t.name) return !1;
var a = n._sshpkApiVersion;
return void 0 === a && (a = t._oldVersionDetect(e)), !(a[0] != r[0] || a[1] < r[1])
},
opensslKeyDeriv: function(e, t, r, a) {
n.buffer(t, "salt"), n.buffer(r, "passphrase"), n.number(a, "iteration count");
var o, c, u, l = f[e];
n.object(l, "supported cipher"), t = t.slice(0, 8);
for (var p = i.alloc(0); p.length < l.key + l.iv;) {
u = [], c && u.push(c), u.push(r), u.push(t), o = i.concat(u);
for (var h = 0; h < a; ++h) o = s.createHash("md5").update(o).digest();
p = i.concat([p, o]), c = o
}
return {
key: p.slice(0, l.key),
iv: p.slice(l.key, l.key + l.iv)
}
},
opensshCipherInfo: function(e) {
var t = {};
switch (e) {
case "3des-cbc":
t.keySize = 24, t.blockSize = 8, t.opensslName = "des-ede3-cbc";
break;
case "blowfish-cbc":
t.keySize = 16, t.blockSize = 8, t.opensslName = "bf-cbc";
break;
case "aes128-cbc":
case "aes128-ctr":
case "[email protected]":
t.keySize = 16, t.blockSize = 16, t.opensslName = "aes-128-" + e.slice(7, 10);
break;
case "aes192-cbc":
case "aes192-ctr":
case "[email protected]":
t.keySize = 24, t.blockSize = 16, t.opensslName = "aes-192-" + e.slice(7, 10);
break;
case "aes256-cbc":
case "aes256-ctr":
case "[email protected]":
t.keySize = 32, t.blockSize = 16, t.opensslName = "aes-256-" + e.slice(7, 10);
break;
default:
throw new Error('Unsupported openssl cipher "' + e + '"')
}
return t
},
publicFromPrivateECDSA: function(e, t) {
n.string(e, "curveName"), n.buffer(t);
var r = c.curves[e],
a = new p(r.p),
s = new p(r.a),
u = new p(r.b),
h = new l.ECCurveFp(a, s, u),
d = h.decodePointHex(r.G.toString("hex")),
f = new p(m(t)),
g = d.multiply(f);
g = i.from(h.encodePointHex(g), "hex");
var v = [];
return v.push({
name: "curve",
data: i.from(e)
}), v.push({
name: "Q",
data: g
}), new o({
type: "ecdsa",
curve: h,
parts: v
})
},
zeroPadToLength: function(e, t) {
for (n.buffer(e), n.number(t); e.length > t;) n.equal(e[0], 0), e = e.slice(1);
for (; e.length < t;) {
var r = i.alloc(e.length + 1);
r[0] = 0, e.copy(r, 1), e = r
}
return e
},
writeBitString: function(e, t, r) {
void 0 === r && (r = u.Ber.BitString);
var n = i.alloc(t.length + 1);
n[0] = 0, t.copy(n, 1), e.writeBuffer(n, r)
},
readBitString: function(e, t) {
void 0 === t && (t = u.Ber.BitString);
var r = e.readString(t, !0);
return n.strictEqual(r[0], 0, "bit strings with unused bits are not supported (0x"
+ r[0].toString(16) + ")"), r.slice(1)
},
pbkdf2: function(e, t, r, n, a) {
var o = i.alloc(t.length + 4);
t.copy(o);
for (var c = 0, u = [], l = 1; c < n;) {
var p = h(l++);
c += p.length, u.push(p)
}
return i.concat(u).slice(0, n);

function h(t) {
o.writeUInt32BE(t, o.length - 4);
var n = s.createHmac(e, a);
n.update(o);
for (var i = n.digest(), c = i, u = 1; u++ < r;) {
(n = s.createHmac(e, a)).update(c), c = n.digest();
for (var l = 0; l < i.length; ++l) i[l] ^= c[l]
}
return i
}
}
};
var n = r(6),
i = r(7).Buffer,
a = r(14),
o = r(12),
s = r(5),
c = r(16),
u = r(41),
l = r(104),
p = r(73).BigInteger,
h = r(74);

function d(e, t, r, i) {
if (void 0 === i && (i = "object"), n.ok(e, i + " must not be null"), n.object(e, i
+ " must be an object"), void 0 === r && (r = t.prototype._sshpkApiVersion), !(e
instanceof t && t.prototype._sshpkApiVersion[0] == r[0])) {
for (var a = Object.getPrototypeOf(e), o = 0; a.constructor.name !== t.name;) a =
Object.getPrototypeOf(a), n.ok(a && ++o <= 3, i + " must be a " + t.name + "
instance");
n.strictEqual(a.constructor.name, t.name, i + " must be a " + t.name + "
instance");
var s = a._sshpkApiVersion;
void 0 === s && (s = t._oldVersionDetect(e)), n.ok(s[0] == r[0] && s[1] >= r[1], i
+ " must be compatible with " + t.name + " klass version " + r[0] + "." + r[1])
}
}
var f = {
"des-ede3-cbc": {
key: 24,
iv: 8
},
"aes-128-cbc": {
key: 16,
iv: 16
},
"aes-256-cbc": {
key: 32,
iv: 16
}
};

function m(e) {
for (n.buffer(e); e.length > 1 && 0 === e[0] && 0 == (128 & e[1]);) e = e.slice(1);
if (128 == (128 & e[0])) {
var t = i.alloc(e.length + 1);
t[0] = 0, e.copy(t, 1), e = t
}
return e
}

function g(e) {
var t = i.from(e.toByteArray());
return m(t)
}
}, function(e, t, r) {
e.exports = b;
var n = r(6),
i = r(7).Buffer,
a = r(16),
o = r(5),
s = (r(72), r(40)),
c = r(34),
u = r(3),
l = r(13),
p = r(143),
h = p.generateECDSA,
d = p.generateED25519,
f = r(215),
m = r(74),
g = r(12),
v = (c.InvalidAlgorithmError, c.KeyParseError),
y = (c.KeyEncryptedError, {});

function b(e) {
n.object(e, "options"), g.call(this, e), this._pubCache = void 0
}
y.auto = r(216), y.pem = r(46), y.pkcs1 = r(144), y.pkcs8 = r(76), y.rfc4253 =
r(47), y["ssh-private"] = r(105), y.openssh = y["ssh-private"], y.ssh = y["ssh-
private"], y.dnssec = r(145), u.inherits(b, g), b.formats = y, b.prototype.toBuffer
= function(e, t) {
return void 0 === e && (e = "pkcs1"), n.string(e, "format"), n.object(y[e],
"formats[format]"), n.optionalObject(t, "options"), y[e].write(this, t)
}, b.prototype.hash = function(e, t) {
return this.toPublic().hash(e, t)
}, b.prototype.fingerprint = function(e, t) {
return this.toPublic().fingerprint(e, t)
}, b.prototype.toPublic = function() {
if (this._pubCache) return this._pubCache;
for (var e = a.info[this.type], t = [], r = 0; r < e.parts.length; ++r) {
var n = e.parts[r];
t.push(this.part[n])
}
return this._pubCache = new g({
type: this.type,
source: this,
parts: t
}), this.comment && (this._pubCache.comment = this.comment), this._pubCache
}, b.prototype.derive = function(e) {
var t, r, a;
if (n.string(e, "type"), "ed25519" === this.type && "curve25519" === e) return 0
=== (t = this.part.k.data)[0] && (t = t.slice(1)), a =
m.box.keyPair.fromSecretKey(new Uint8Array(t)), r = i.from(a.publicKey), new b({
type: "curve25519",
parts: [{
name: "A",
data: l.mpNormalize(r)
}, {
name: "k",
data: l.mpNormalize(t)
}]
});
if ("curve25519" === this.type && "ed25519" === e) return 0 === (t =
this.part.k.data)[0] && (t = t.slice(1)), a = m.sign.keyPair.fromSeed(new
Uint8Array(t)), r = i.from(a.publicKey), new b({
type: "ed25519",
parts: [{
name: "A",
data: l.mpNormalize(r)
}, {
name: "k",
data: l.mpNormalize(t)
}]
});
throw new Error("Key derivation not supported from " + this.type + " to " + e)
}, b.prototype.createVerify = function(e) {
return this.toPublic().createVerify(e)
}, b.prototype.createSign = function(e) {
if (void 0 === e && (e = this.defaultHashAlgorithm()), n.string(e, "hash
algorithm"), "ed25519" === this.type && void 0 !== f) return new f.Signer(this, e);
if ("curve25519" === this.type) throw new Error("Curve25519 keys are not suitable
for signing or verification");
var t, r, a;
try {
r = e.toUpperCase(), t = o.createSign(r)
} catch (e) {
a = e
}(void 0 === t || a instanceof Error && a.message.match(/Unknown message digest/))
&& (r = "RSA-", r += e.toUpperCase(), t = o.createSign(r)), n.ok(t, "failed to
create verifier");
var c = t.sign.bind(t),
u = this.toBuffer("pkcs1"),
l = this.type,
p = this.curve;
return t.sign = function() {
var t = c(u);
return "string" == typeof t && (t = i.from(t, "binary")), (t = s.parse(t, l,
"asn1")).hashAlgorithm = e, t.curve = p, t
}, t
}, b.parse = function(e, t, r) {
"string" != typeof e && n.buffer(e, "data"), void 0 === t && (t = "auto"),
n.string(t, "format"), "string" == typeof r && (r = {
filename: r
}), n.optionalObject(r, "options"), void 0 === r && (r = {}),
n.optionalString(r.filename, "options.filename"), void 0 === r.filename &&
(r.filename = "(unnamed)"), n.object(y[t], "formats[format]");
try {
var i = y[t].read(e, r);
return n.ok(i instanceof b, "key is not a private key"), i.comment || (i.comment =
r.filename), i
} catch (e) {
if ("KeyEncryptedError" === e.name) throw e;
throw new v(r.filename, t, e)
}
}, b.isPrivateKey = function(e, t) {
return l.isCompatible(e, b, t)
}, b.generate = function(e, t) {
switch (void 0 === t && (t = {}), n.object(t, "options"), e) {
case "ecdsa":
return void 0 === t.curve && (t.curve = "nistp256"), n.string(t.curve,
"options.curve"), h(t.curve);
case "ed25519":
return d();
default:
throw new Error('Key generation not supported with key type "' + e + '"')
}
}, b.prototype._sshpkApiVersion = [1, 6], b._oldVersionDetect = function(e) {
return n.func(e.toPublic), n.func(e.createSign), e.derive ? [1, 3] :
e.defaultHashAlgorithm ? [1, 2] : e.formats.auto ? [1, 1] : [1, 0]
}
}, function(e, t, r) {
"use strict";
Object.defineProperty(t, "__esModule", {
value: !0
}), t.UpdaterSignal = t.UPDATE_DOWNLOADED = t.DOWNLOAD_PROGRESS = t.NsisUpdater =
t.MacUpdater = t.AppImageUpdater = t.Provider = t.CancellationToken = t.NoOpLogger
= t.AppUpdater = void 0;
const n = r(10);
Object.defineProperty(t, "CancellationToken", {
enumerable: !0,
get: function() {
return n.CancellationToken
}
});
var i = r(121);
Object.defineProperty(t, "AppUpdater", {
enumerable: !0,
get: function() {
return i.AppUpdater
}
}), Object.defineProperty(t, "NoOpLogger", {
enumerable: !0,
get: function() {
return i.NoOpLogger
}
});
var a = r(39);
Object.defineProperty(t, "Provider", {
enumerable: !0,
get: function() {
return a.Provider
}
});
var o = r(195);
Object.defineProperty(t, "AppImageUpdater", {
enumerable: !0,
get: function() {
return o.AppImageUpdater
}
});
var s = r(200);
Object.defineProperty(t, "MacUpdater", {
enumerable: !0,
get: function() {
return s.MacUpdater
}
});
var c = r(201);
let u;

function l(e, t, r) {
e.on(t, r)
}
Object.defineProperty(t, "NsisUpdater", {
enumerable: !0,
get: function() {
return c.NsisUpdater
}
}), Object.defineProperty(t, "autoUpdater", {
enumerable: !0,
get: () => u || (u = "win32" === process.platform ? new(r(201).NsisUpdater) :
"darwin" === process.platform ? new(r(200).MacUpdater) :
new(r(195).AppImageUpdater), u)
}), t.DOWNLOAD_PROGRESS = "download-progress", t.UPDATE_DOWNLOADED = "update-
downloaded", t.UpdaterSignal = class {
constructor(e) {
this.emitter = e
}
login(e) {
l(this.emitter, "login", e)
}
progress(e) {
l(this.emitter, t.DOWNLOAD_PROGRESS, e)
}
updateDownloaded(e) {
l(this.emitter, t.UPDATE_DOWNLOADED, e)
}
updateCancelled(e) {
l(this.emitter, "update-cancelled", e)
}
}
}, function(e, t, r) {
var n = r(7).Buffer,
i = {
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"
}
};
i.curve25519 = i.ed25519;
var a = {
dsa: {
parts: ["p", "q", "g", "y", "x"]
},
rsa: {
parts: ["n", "e", "d", "iqmp", "p", "q"]
},
ecdsa: {
parts: ["curve", "Q", "d"]
},
ed25519: {
parts: ["A", "k"]
}
};
a.curve25519 = a.ed25519;
var o = {
nistp256: {
size: 256,
pkcs8oid: "1.2.840.10045.3.1.7",
p: n.from("00ffffffff 00000001 00000000 0000000000000000 ffffffff ffffffff
ffffffff".replace(/ /g, ""), "hex"),
a: n.from("00FFFFFFFF 00000001 00000000 0000000000000000 FFFFFFFF FFFFFFFF
FFFFFFFC".replace(/ /g, ""), "hex"),
b: n.from("5ac635d8 aa3a93e7 b3ebbd55 769886bc651d06b0 cc53b0f6 3bce3c3e
27d2604b".replace(/ /g, ""), "hex"),
s: n.from("00c49d3608 86e70493 6a6678e1 139d26b7819f7e90".replace(/ /g, ""),
"hex"),
n: n.from("00ffffffff 00000000 ffffffff ffffffffbce6faad a7179e84 f3b9cac2
fc632551".replace(/ /g, ""), "hex"),
G: n.from("046b17d1f2 e12c4247 f8bce6e5 63a440f277037d81 2deb33a0 f4a13945
d898c2964fe342e2 fe1a7f9b 8ee7eb4a 7c0f9e162bce3357 6b315ece cbb64068
37bf51f5".replace(/ /g, ""), "hex")
},
nistp384: {
size: 384,
pkcs8oid: "1.3.132.0.34",
p: n.from("00ffffffff ffffffff ffffffff ffffffffffffffff ffffffff ffffffff
fffffffeffffffff 00000000 00000000 ffffffff".replace(/ /g, ""), "hex"),
a: n.from("00FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFFFFFFFFFF FFFFFFFF FFFFFFFF
FFFFFFFEFFFFFFFF 00000000 00000000 FFFFFFFC".replace(/ /g, ""), "hex"),
b: n.from("b3312fa7 e23ee7e4 988e056b e3f82d19181d9c6e fe814112 0314088f
5013875ac656398d 8a2ed19d 2a85c8ed d3ec2aef".replace(/ /g, ""), "hex"),
s: n.from("00a335926a a319a27a 1d00896a 6773a4827acdac73".replace(/ /g, ""),
"hex"),
n: n.from("00ffffffff ffffffff ffffffff ffffffffffffffff ffffffff c7634d81
f4372ddf581a0db2 48b0a77a ecec196a ccc52973".replace(/ /g, ""), "hex"),
G: n.from("04aa87ca22 be8b0537 8eb1c71e f320ad746e1d3b62 8ba79b98 59f741e0
82542a385502f25d bf55296c 3a545e38 72760ab73617de4a 96262c6f 5d9e98bf
9292dc29f8f41dbd 289a147c e9da3113 b5f0b8c00a60b1ce 1d7e819d 7a431d7c
90ea0e5f".replace(/ /g, ""), "hex")
},
nistp521: {
size: 521,
pkcs8oid: "1.3.132.0.35",
p: n.from("01ffffff ffffffff ffffffff ffffffffffffffff ffffffff ffffffff
ffffffffffffffff ffffffff ffffffff ffffffffffffffff ffffffff ffffffff
ffffffffffff".replace(/ /g, ""), "hex"),
a: n.from("01FFFFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFFFFFFFFFF FFFFFFFF FFFFFFFF
FFFFFFFFFFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFFFFFFFFFF FFFFFFFF FFFFFFFF
FFFFFFFC".replace(/ /g, ""), "hex"),
b: n.from("51953eb961 8e1c9a1f 929a21a0 b68540eea2da725b 99b315f3 b8b48991
8ef109e156193951 ec7e937b 1652c0bd 3bb1bf073573df88 3d2c34f1 ef451fd4
6b503f00".replace(/ /g, ""), "hex"),
s: n.from("00d09e8800 291cb853 96cc6717 393284aaa0da64ba".replace(/ /g, ""),
"hex"),
n: n.from("01ffffffffff ffffffff ffffffff ffffffffffffffff ffffffff ffffffff
fffffffa51868783 bf2f966b 7fcc0148 f709a5d03bb5c9b8 899c47ae bb6fb71e
91386409".replace(/ /g, ""), "hex"),
G: n.from("0400c6 858e06b7 0404e9cd 9e3ecb66 2395b4429c648139 053fb521 f828af60
6b4d3dbaa14b5e77 efe75928 fe1dc127 a2ffa8de3348b3c1 856a429b f97e7e31 c2e5bd660118
39296a78 9a3bc004 5c8a5fb4 2c7d1bd998f54449 579b4468 17afbd17 273e662c97ee7299
5ef42640 c550b901 3fad0761353c7086 a272c240 88be9476 9fd16650".replace(/ /g, ""),
"hex")
}
};
e.exports = {
info: i,
privInfo: a,
hashAlgs: {
md5: !0,
sha1: !0,
sha256: !0,
sha384: !0,
sha512: !0
},
curves: o
}
}, , function(e, t, r) {
const n = r(90),
{
MAX_LENGTH: i,
MAX_SAFE_INTEGER: a
} = r(89),
{
re: o,
t: s
} = r(56),
c = r(91),
{
compareIdentifiers: u
} = r(114);
class l {
constructor(e, t) {
if (t = c(t), e instanceof l) {
if (e.loose === !!t.loose && e.includePrerelease === !!t.includePrerelease) return
e;
e = e.version
} else if ("string" != typeof e) throw new TypeError("Invalid Version: " + e);
if (e.length > i) throw new TypeError(`version is longer than ${i} characters`);
n("SemVer", e, t), this.options = t, this.loose = !!t.loose, this.includePrerelease
= !!t.includePrerelease;
const r = e.trim().match(t.loose ? o[s.LOOSE] : o[s.FULL]);
if (!r) throw new TypeError("Invalid Version: " + e);
if (this.raw = e, this.major = +r[1], this.minor = +r[2], this.patch = +r[3],
this.major > a || this.major < 0) throw new TypeError("Invalid major version");
if (this.minor > a || this.minor < 0) throw new TypeError("Invalid minor version");
if (this.patch > a || this.patch < 0) throw new TypeError("Invalid patch version");
r[4] ? this.prerelease = r[4].split(".").map(e => {
if (/^[0-9]+$/.test(e)) {
const t = +e;
if (t >= 0 && t < a) return t
}
return e
}) : this.prerelease = [], this.build = r[5] ? r[5].split(".") : [], this.format()
}
format() {
return this.version = `${this.major}.${this.minor}.${this.patch}`,
this.prerelease.length && (this.version += "-" + this.prerelease.join(".")),
this.version
}
toString() {
return this.version
}
compare(e) {
if (n("SemVer.compare", this.version, this.options, e), !(e instanceof l)) {
if ("string" == typeof e && e === this.version) return 0;
e = new l(e, this.options)
}
return e.version === this.version ? 0 : this.compareMain(e) || this.comparePre(e)
}
compareMain(e) {
return e instanceof l || (e = new l(e, this.options)), u(this.major, e.major) ||
u(this.minor, e.minor) || u(this.patch, e.patch)
}
comparePre(e) {
if (e instanceof l || (e = new l(e, this.options)), this.prerelease.length && !
e.prerelease.length) return -1;
if (!this.prerelease.length && e.prerelease.length) return 1;
if (!this.prerelease.length && !e.prerelease.length) return 0;
let t = 0;
do {
const r = this.prerelease[t],
i = e.prerelease[t];
if (n("prerelease compare", t, r, i), void 0 === r && void 0 === i) return 0;
if (void 0 === i) return 1;
if (void 0 === r) return -1;
if (r !== i) return u(r, i)
} while (++t)
}
compareBuild(e) {
e instanceof l || (e = new l(e, this.options));
let t = 0;
do {
const r = this.build[t],
i = e.build[t];
if (n("prerelease compare", t, r, i), void 0 === r && void 0 === i) return 0;
if (void 0 === i) return 1;
if (void 0 === r) return -1;
if (r !== i) return u(r, i)
} while (++t)
}
inc(e, t) {
switch (e) {
case "premajor":
this.prerelease.length = 0, this.patch = 0, this.minor = 0, this.major++,
this.inc("pre", t);
break;
case "preminor":
this.prerelease.length = 0, this.patch = 0, this.minor++, this.inc("pre", t);
break;
case "prepatch":
this.prerelease.length = 0, this.inc("patch", t), this.inc("pre", t);
break;
case "prerelease":
0 === this.prerelease.length && this.inc("patch", t), this.inc("pre", t);
break;
case "major":
0 === this.minor && 0 === this.patch && 0 !== this.prerelease.length || this.major+
+, this.minor = 0, this.patch = 0, this.prerelease = [];
break;
case "minor":
0 === this.patch && 0 !== this.prerelease.length || this.minor++, this.patch = 0,
this.prerelease = [];
break;
case "patch":
0 === this.prerelease.length && this.patch++, this.prerelease = [];
break;
case "pre":
if (0 === this.prerelease.length) this.prerelease = [0];
else {
let e = this.prerelease.length;
for (; --e >= 0;) "number" == typeof this.prerelease[e] && (this.prerelease[e]++, e
= -2); - 1 === e && this.prerelease.push(0)
}
t && (this.prerelease[0] === t ? isNaN(this.prerelease[1]) && (this.prerelease =
[t, 0]) : this.prerelease = [t, 0]);
break;
default:
throw new Error("invalid increment argument: " + e)
}
return this.format(), this.raw = this.version, this
}
}
e.exports = l
}, function(e, t, r) {
const n = r(97),
{
MAX_LENGTH: i,
MAX_SAFE_INTEGER: a
} = r(96),
{
re: o,
t: s
} = r(61),
c = r(98),
{
compareIdentifiers: u
} = r(125);
class l {
constructor(e, t) {
if (t = c(t), e instanceof l) {
if (e.loose === !!t.loose && e.includePrerelease === !!t.includePrerelease) return
e;
e = e.version
} else if ("string" != typeof e) throw new TypeError("Invalid Version: " + e);
if (e.length > i) throw new TypeError(`version is longer than ${i} characters`);
n("SemVer", e, t), this.options = t, this.loose = !!t.loose, this.includePrerelease
= !!t.includePrerelease;
const r = e.trim().match(t.loose ? o[s.LOOSE] : o[s.FULL]);
if (!r) throw new TypeError("Invalid Version: " + e);
if (this.raw = e, this.major = +r[1], this.minor = +r[2], this.patch = +r[3],
this.major > a || this.major < 0) throw new TypeError("Invalid major version");
if (this.minor > a || this.minor < 0) throw new TypeError("Invalid minor version");
if (this.patch > a || this.patch < 0) throw new TypeError("Invalid patch version");
r[4] ? this.prerelease = r[4].split(".").map(e => {
if (/^[0-9]+$/.test(e)) {
const t = +e;
if (t >= 0 && t < a) return t
}
return e
}) : this.prerelease = [], this.build = r[5] ? r[5].split(".") : [], this.format()
}
format() {
return this.version = `${this.major}.${this.minor}.${this.patch}`,
this.prerelease.length && (this.version += "-" + this.prerelease.join(".")),
this.version
}
toString() {
return this.version
}
compare(e) {
if (n("SemVer.compare", this.version, this.options, e), !(e instanceof l)) {
if ("string" == typeof e && e === this.version) return 0;
e = new l(e, this.options)
}
return e.version === this.version ? 0 : this.compareMain(e) || this.comparePre(e)
}
compareMain(e) {
return e instanceof l || (e = new l(e, this.options)), u(this.major, e.major) ||
u(this.minor, e.minor) || u(this.patch, e.patch)
}
comparePre(e) {
if (e instanceof l || (e = new l(e, this.options)), this.prerelease.length && !
e.prerelease.length) return -1;
if (!this.prerelease.length && e.prerelease.length) return 1;
if (!this.prerelease.length && !e.prerelease.length) return 0;
let t = 0;
do {
const r = this.prerelease[t],
i = e.prerelease[t];
if (n("prerelease compare", t, r, i), void 0 === r && void 0 === i) return 0;
if (void 0 === i) return 1;
if (void 0 === r) return -1;
if (r !== i) return u(r, i)
} while (++t)
}
compareBuild(e) {
e instanceof l || (e = new l(e, this.options));
let t = 0;
do {
const r = this.build[t],
i = e.build[t];
if (n("prerelease compare", t, r, i), void 0 === r && void 0 === i) return 0;
if (void 0 === i) return 1;
if (void 0 === r) return -1;
if (r !== i) return u(r, i)
} while (++t)
}
inc(e, t) {
switch (e) {
case "premajor":
this.prerelease.length = 0, this.patch = 0, this.minor = 0, this.major++,
this.inc("pre", t);
break;
case "preminor":
this.prerelease.length = 0, this.patch = 0, this.minor++, this.inc("pre", t);
break;
case "prepatch":
this.prerelease.length = 0, this.inc("patch", t), this.inc("pre", t);
break;
case "prerelease":
0 === this.prerelease.length && this.inc("patch", t), this.inc("pre", t);
break;
case "major":
0 === this.minor && 0 === this.patch && 0 !== this.prerelease.length || this.major+
+, this.minor = 0, this.patch = 0, this.prerelease = [];
break;
case "minor":
0 === this.patch && 0 !== this.prerelease.length || this.minor++, this.patch = 0,
this.prerelease = [];
break;
case "patch":
0 === this.prerelease.length && this.patch++, this.prerelease = [];
break;
case "pre":
if (0 === this.prerelease.length) this.prerelease = [0];
else {
let e = this.prerelease.length;
for (; --e >= 0;) "number" == typeof this.prerelease[e] && (this.prerelease[e]++, e
= -2); - 1 === e && this.prerelease.push(0)
}
t && (this.prerelease[0] === t ? isNaN(this.prerelease[1]) && (this.prerelease =
[t, 0]) : this.prerelease = [t, 0]);
break;
default:
throw new Error("invalid increment argument: " + e)
}
return this.format(), this.raw = this.version, this
}
}
e.exports = l
}, function(e, t, r) {
"use strict";
var n = r(202),
i = Object.prototype.toString;

function a(e) {
return Array.isArray(e)
}

function o(e) {
return void 0 === e
}

function s(e) {
return "[object ArrayBuffer]" === i.call(e)
}

function c(e) {
return null !== e && "object" == typeof e
}

function u(e) {
if ("[object Object]" !== i.call(e)) return !1;
var t = Object.getPrototypeOf(e);
return null === t || t === Object.prototype
}

function l(e) {
return "[object Function]" === i.call(e)
}

function p(e, t) {
if (null != e)
if ("object" != typeof e && (e = [e]), a(e))
for (var r = 0, n = e.length; r < n; r++) t.call(null, e[r], r, e);
else
for (var i in e) Object.prototype.hasOwnProperty.call(e, i) && t.call(null, e[i],
i, e)
}
e.exports = {
isArray: a,
isArrayBuffer: s,
isBuffer: function(e) {
return null !== e && !o(e) && null !== e.constructor && !o(e.constructor) &&
"function" == typeof e.constructor.isBuffer && e.constructor.isBuffer(e)
},
isFormData: function(e) {
return "[object FormData]" === i.call(e)
},
isArrayBufferView: function(e) {
return "undefined" != typeof ArrayBuffer && ArrayBuffer.isView ?
ArrayBuffer.isView(e) : e && e.buffer && s(e.buffer)
},
isString: function(e) {
return "string" == typeof e
},
isNumber: function(e) {
return "number" == typeof e
},
isObject: c,
isPlainObject: u,
isUndefined: o,
isDate: function(e) {
return "[object Date]" === i.call(e)
},
isFile: function(e) {
return "[object File]" === i.call(e)
},
isBlob: function(e) {
return "[object Blob]" === i.call(e)
},
isFunction: l,
isStream: function(e) {
return c(e) && l(e.pipe)
},
isURLSearchParams: function(e) {
return "[object URLSearchParams]" === i.call(e)
},
isStandardBrowserEnv: function() {
return ("undefined" == typeof navigator || "ReactNative" !== navigator.product &&
"NativeScript" !== navigator.product && "NS" !== navigator.product) &&
"undefined" != typeof window && "undefined" != typeof document
},
forEach: p,
merge: function e() {
var t = {};

function r(r, n) {
u(t[n]) && u(r) ? t[n] = e(t[n], r) : u(r) ? t[n] = e({}, r) : a(r) ? t[n] =
r.slice() : t[n] = r
}
for (var n = 0, i = arguments.