/*! For license information please see [Link] */ !

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([Link], i, [Link], r), i.l = !0, [Link]
}
r.m = e, r.c = t, r.d = function(e, t, n) {
r.o(e, t) || [Link](e, t, {
enumerable: !0,
get: n
})
}, r.r = function(e) {
"undefined" != typeof Symbol && [Link] && [Link](e,
[Link], {
value: "Module"
}), [Link](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 = [Link](null);
if (r.r(n), [Link](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 [Link]
} : function() {
return e
};
return r.d(t, "a", t), t
}, r.o = function(e, t) {
return [Link](e, t)
}, r.p = "", r(r.s = 250)
}([function(e, t) {
[Link] = require("electron")
}, function(e, t) {
[Link] = require("path")
}, function(e, t) {
[Link] = require("fs")
}, function(e, t) {
[Link] = require("util")
}, function(e, t) {
[Link] = require("url")
}, function(e, t) {
[Link] = 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 [Link](0).toUpperCase() + [Link](1)
}

function c(e, t, r, i, o) {
throw new [Link]({
message: [Link]("%s (%s) is required", e, t),
actual: void 0 === o ? typeof i : o(i),
expected: t,
operator: r || "===",
stackStartFunction: [Link]
})
}

function u(e) {
return [Link](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 [Link](e)
},
operator: "[Link]"
},
array: {
check: function(e) {
return [Link](e)
},
operator: "[Link]"
},
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 && [Link](e)
},
operator: "isUUID"
}
};
[Link] = function e(t) {
var r, i = [Link](p);
return r = [Link].NODE_NDEBUG ? l : function(e, t) {
e || c(t, "true", e)
}, [Link]((function(e) {
if (t) r[e] = l;
else {
var n = p[e];
r[e] = function(t, r) {
[Link](t) || c(r, e, [Link], t, [Link])
}
}
})), [Link]((function(e) {
var n = "optional" + s(e);
if (t) r[n] = l;
else {
var i = p[e];
r[n] = function(t, r) {
null != t && ([Link](t) || c(r, e, [Link], t, [Link]))
}
}
})), [Link]((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 ([Link](e) || c(t, a, [Link], e, [Link]), r = 0; r < [Link]; r+
+) [Link](e[r]) || c(t, a, [Link], e, [Link])
}
}
})), [Link]((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 ([Link](e) || c(t, a, [Link], e, [Link]), r = 0; r < [Link]; r+
+) [Link](e[r]) || c(t, a, [Link], e, [Link])
}
}
})), [Link](n).forEach((function(e) {
r[e] = "AssertionError" !== e && t ? l : n[e]
})), r._setExports = e, r
}([Link].NODE_NDEBUG)
}, function(e, t, r) {
"use strict";
var n, i = r(87),
a = [Link],
o = {};
for (n in i) [Link](n) && "SlowBuffer" !== n && "Buffer" !== n && (o[n] =
i[n]);
var s = [Link] = {};
for (n in a) [Link](n) && "allocUnsafe" !== n && "allocUnsafeSlow" !== n
&& (s[n] = a[n]);
if ([Link] = [Link], [Link] && [Link] !== [Link] ||
([Link] = 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 === [Link]) 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)
}), [Link] || ([Link] = 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 !== [Link] ? "string" == typeof r ? [Link](t, r) : [Link](t) :
[Link](0), n
}), ![Link]) try {
[Link] = [Link]("buffer").kStringMaxLength
} catch (e) {}
[Link] || ([Link] = {
MAX_LENGTH: [Link]
}, [Link] && ([Link].MAX_STRING_LENGTH = [Link])),
[Link] = o
}, function(e, t) {
[Link] = 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 < [Link]; ++r) t[r] = 255 & [Link](r);
return t
}
[Link] = function(e, r) {
[Link]("blob");
try {
return new Blob([e], {
type: r
})
} catch (t) {
try {
var n = new([Link] || [Link] || [Link] ||
[Link]);
return [Link](e), [Link](r)
} catch (e) {
throw new Error("Bug : can't construct the Blob.")
}
}
};
var l = {
stringifyByChunk: function(e, t, r) {
var n = [],
i = 0,
a = [Link];
if (a <= r) return [Link](null, e);
for (; i < a;) "array" === t || "nodebuffer" === t ?
[Link]([Link](null, [Link](i, [Link](i + r, a)))) :
[Link]([Link](null, [Link](i, [Link](i + r, a)))), i += r;
return [Link]("")
},
stringifyByChar: function(e) {
for (var t = "", r = 0; r < [Link]; r++) t += [Link](e[r]);
return t
},
applyCanBeUsed: {
uint8array: function() {
try {
return n.uint8array && 1 === [Link](null, new
Uint8Array(1)).length
} catch (e) {
return !1
}
}(),
nodebuffer: function() {
try {
return [Link] && 1 === [Link](null,
[Link](1)).length
} catch (e) {
return !1
}
}()
}
};

function p(e) {
var r = 65536,
n = [Link](e),
i = !0;
if ("uint8array" === n ? i = [Link].uint8array : "nodebuffer" === n && (i
= [Link]), i)
for (; r > 1;) try {
return [Link](e, n, r)
} catch (e) {
r = [Link](r / 2)
}
return [Link](e)
}

function h(e, t) {
for (var r = 0; r < [Link]; r++) t[r] = e[r];
return t
}
[Link] = p;
var d = {};
[Link] = {
string: c,
array: function(e) {
return u(e, new Array([Link]))
},
arraybuffer: function(e) {
return [Link].uint8array(e).buffer
},
uint8array: function(e) {
return u(e, new Uint8Array([Link]))
},
nodebuffer: function(e) {
return u(e, [Link]([Link]))
}
}, [Link] = {
string: p,
array: c,
arraybuffer: function(e) {
return new Uint8Array(e).buffer
},
uint8array: function(e) {
return new Uint8Array(e)
},
nodebuffer: function(e) {
return [Link](e)
}
}, [Link] = {
string: function(e) {
return p(new Uint8Array(e))
},
array: function(e) {
return h(new Uint8Array(e), new Array([Link]))
},
arraybuffer: c,
uint8array: function(e) {
return new Uint8Array(e)
},
nodebuffer: function(e) {
return [Link](new Uint8Array(e))
}
}, d.uint8array = {
string: p,
array: function(e) {
return h(e, new Array([Link]))
},
arraybuffer: function(e) {
return [Link]
},
uint8array: c,
nodebuffer: function(e) {
return [Link](e)
}
}, [Link] = {
string: p,
array: function(e) {
return h(e, new Array([Link]))
},
arraybuffer: function(e) {
return [Link].uint8array(e).buffer
},
uint8array: function(e) {
return h(e, new Uint8Array([Link]))
},
nodebuffer: c
}, [Link] = function(e, r) {
if (r || (r = ""), !e) return r;
[Link](e);
var n = [Link](r);
return d[n][e](r)
}, [Link] = function(e) {
return "string" == typeof e ? "string" : "[object Array]" ===
[Link](e) ? "array" : [Link] && [Link](e) ?
"nodebuffer" : n.uint8array && e instanceof Uint8Array ? "uint8array" :
[Link] && e instanceof ArrayBuffer ? "arraybuffer" : void 0
}, [Link] = function(e) {
if (!n[[Link]()]) throw new Error(e + " is not supported by this platform")
}, t.MAX_VALUE_16BITS = 65535, t.MAX_VALUE_32BITS = -1, [Link] = function(e) {
var t, r, n = "";
for (r = 0; r < (e || "").length; r++) n += "\\x" + ((t = [Link](r)) < 16 ?
"0" : "") + [Link](16).toUpperCase();
return n
}, [Link] = function(e, t, r) {
o((function() {
[Link](r || null, t || [])
}))
}, [Link] = function(e, t) {
var r = function() {};
[Link] = [Link], [Link] = new r
}, [Link] = function() {
var e, t, r = {};
for (e = 0; e < [Link]; e++)
for (t in arguments[e]) arguments[e].hasOwnProperty(t) && void 0 === r[t] && (r[t]
= arguments[e][t]);
return r
}, [Link] = function(e, r, a, o, c) {
return [Link](r).then((function(e) {
return [Link] && (e instanceof Blob || -1 !== ["[object File]", "[object
Blob]"].indexOf([Link](e))) && "undefined" != typeof
FileReader ? new [Link]((function(t, r) {
var n = new FileReader;
[Link] = function(e) {
t([Link])
}, [Link] = function(e) {
r([Link])
}, [Link](e)
})) : e
})).then((function(r) {
var l, p = [Link](r);
return p ? ("arraybuffer" === p ? r = [Link]("uint8array", r) : "string" ===
p && (c ? r = [Link](r) : a && !0 !== o && (r = u(l = r, n.uint8array ? new
Uint8Array([Link]) : new Array([Link])))), r) : [Link](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";
[Link](t, "__esModule", {
value: !0
}), [Link] = [Link] = t.CURRENT_APP_PACKAGE_FILE_NAME =
t.CURRENT_APP_INSTALLER_FILE_NAME = [Link] = [Link] =
[Link] = [Link] = [Link] = [Link] =
t.getS3LikeProviderBaseUrl = [Link] = [Link] =
[Link] = [Link] = [Link]
= [Link] = [Link] = [Link] = [Link] =
[Link] = [Link] = [Link] = void 0;
var n = r(184);
[Link](t, "CancellationToken", {
enumerable: !0,
get: function() {
return [Link]
}
}), [Link](t, "CancellationError", {
enumerable: !0,
get: function() {
return [Link]
}
});
var i = r(320);
[Link](t, "HttpError", {
enumerable: !0,
get: function() {
return [Link]
}
}), [Link](t, "createHttpError", {
enumerable: !0,
get: function() {
return [Link]
}
}), [Link](t, "HttpExecutor", {
enumerable: !0,
get: function() {
return [Link]
}
}), [Link](t, "DigestTransform", {
enumerable: !0,
get: function() {
return [Link]
}
}), [Link](t, "safeGetHeader", {
enumerable: !0,
get: function() {
return [Link]
}
}), [Link](t, "configureRequestOptions", {
enumerable: !0,
get: function() {
return [Link]
}
}), [Link](t, "configureRequestOptionsFromUrl", {
enumerable: !0,
get: function() {
return [Link]
}
}), [Link](t, "safeStringifyJson", {
enumerable: !0,
get: function() {
return [Link]
}
}), [Link](t, "parseJson", {
enumerable: !0,
get: function() {
return [Link]
}
}), [Link](t, "configureRequestUrl", {
enumerable: !0,
get: function() {
return [Link]
}
});
var a = r(327);
[Link](t, "getS3LikeProviderBaseUrl", {
enumerable: !0,
get: function() {
return a.getS3LikeProviderBaseUrl
}
}), [Link](t, "githubUrl", {
enumerable: !0,
get: function() {
return [Link]
}
});
var o = r(328);
[Link](t, "parseDn", {
enumerable: !0,
get: function() {
return [Link]
}
});
var s = r(329);
[Link](t, "UUID", {
enumerable: !0,
get: function() {
return [Link]
}
});
var c = r(186);
[Link](t, "ProgressCallbackTransform", {
enumerable: !0,
get: function() {
return [Link]
}
});
var u = r(330);
[Link](t, "parseXml", {
enumerable: !0,
get: function() {
return [Link]
}
}), [Link](t, "XElement", {
enumerable: !0,
get: function() {
return [Link]
}
}), t.CURRENT_APP_INSTALLER_FILE_NAME = "[Link]",
t.CURRENT_APP_PACKAGE_FILE_NAME = "package.7z", [Link] = function(e) {
return null == e ? [] : [Link](e) ? e : [e]
}, [Link] = function(e, t) {
const r = new Error(e);
return [Link] = t, r
}
}, , function(e, t, r) {
[Link] = 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 = [Link],
f = [Link],
m = {};

function g(e) {
[Link](e, "options"), [Link]([Link], "[Link]"), [Link]([Link],
"[Link]"), [Link]([Link], "[Link]");
var t = [Link][[Link]];
if ("object" != typeof t) throw new d([Link]);
for (var r, n = {}, o = 0; o < [Link]; ++o) {
var s = [Link][o];
n[[Link]] = s
}
if ([Link] = [Link], [Link] = [Link], [Link] = n, [Link] = void 0,
[Link] = [Link], this._rfc4253Cache = e._rfc4253Cache, this._hashCache = {},
[Link] = void 0, "ecdsa" === [Link]) {
var c = [Link]();
[Link] = c, r = [Link][c].size
} else if ("ed25519" === [Link] || "curve25519" === [Link]) r = 256,
[Link] = "curve25519";
else {
var u = [Link][[Link]];
r = 8 * (r = [Link]) - [Link]([Link])
}
[Link] = r
}
[Link] = r(216), [Link] = r(46), m.pkcs1 = r(144), m.pkcs8 = r(76), m.rfc4253 =
r(47), [Link] = r(218), m["ssh-private"] = r(105), [Link] = m["ssh-private"],
[Link] = r(145), [Link] = r(219), [Link] = [Link], [Link] = m,
[Link] = function(e, t) {
return void 0 === e && (e = "ssh"), [Link](e, "format"), [Link](m[e],
"formats[format]"), [Link](t, "options"), "rfc4253" === e ? (void 0 ===
this._rfc4253Cache && (this._rfc4253Cache = [Link](this)),
this._rfc4253Cache) : m[e].write(this, t)
}, [Link] = function(e, t) {
return [Link](e, t).toString()
}, [Link] = function(e, t) {
if ([Link](e, "algorithm"), [Link](t, "type"), void 0 === t && (t =
"ssh"), e = [Link](), void 0 === [Link][e]) throw new d(e);
var r, n = e + "||" + t;
if (this._hashCache[n]) return this._hashCache[n];
if ("ssh" === t) r = [Link]("rfc4253");
else {
if ("spki" !== t) throw new Error("Hash type " + t + " not supported");
r = m.pkcs8.pkcs8ToBuffer(this)
}
var s = [Link](e).update(r).digest();
return this._hashCache[n] = s, s
}, [Link] = function(e, t) {
void 0 === e && (e = "sha256"), void 0 === t && (t = "ssh"), [Link](e,
"algorithm"), [Link](t, "type");
var r = {
type: "key",
hash: [Link](e, t),
algorithm: e,
hashType: t
};
return new s(r)
}, [Link] = function() {
var e = "sha1";
return "rsa" === [Link] && (e = "sha256"), "dsa" === [Link] && [Link] >
1024 && (e = "sha256"), "ed25519" === [Link] && (e = "sha512"), "ecdsa" ===
[Link] && (e = [Link] <= 256 ? "sha256" : [Link] <= 384 ? "sha384" :
"sha512"), e
}, [Link] = function(e) {
if (void 0 === e && (e = [Link]()), [Link](e, "hash
algorithm"), "ed25519" === [Link] && void 0 !== n) return new [Link](this,
e);
if ("curve25519" === [Link]) throw new Error("Curve25519 keys are not suitable
for signing or verification");
var t, r, a;
try {
r = [Link](), t = [Link](r)
} catch (e) {
a = e
}(void 0 === t || a instanceof Error && [Link](/Unknown message digest/))
&& (r = "RSA-", r += [Link](), t = [Link](r)), [Link](t, "failed to
create verifier");
var s = [Link](t),
u = [Link]("pkcs8"),
l = [Link],
p = this;
return [Link] = function(t, r) {
if ([Link](t, [2, 0])) return [Link] === [Link] && (![Link] ||
[Link] === e) && (![Link] || "ecdsa" !== [Link] || [Link] === l) && s(u,
[Link]("asn1"));
if ("string" == typeof t || [Link](t)) return s(u, t, r);
throw [Link](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
}, [Link] = function() {
if ("rsa" === [Link]) throw new Error("RSA keys do not support Diffie-Hellman");
return new u(this)
}, [Link] = [Link], [Link] = function(e, t,
r) {
"string" != typeof e && [Link](e, "data"), void 0 === t && (t = "auto"),
[Link](t, "format"), "string" == typeof r && (r = {
filename: r
}), [Link](r, "options"), void 0 === r && (r = {}),
[Link]([Link], "[Link]"), void 0 === [Link] &&
([Link] = "(unnamed)"), [Link](m[t], "formats[format]");
try {
var n = m[t].read(e, r);
return n instanceof h && (n = [Link]()), [Link] || ([Link] = [Link]),
n
} catch (e) {
if ("KeyEncryptedError" === [Link]) throw e;
throw new f([Link], t, e)
}
}, [Link] = function(e, t) {
return [Link](e, g, t)
}, [Link]._sshpkApiVersion = [1, 7], g._oldVersionDetect = function(e) {
return [Link]([Link]), [Link]([Link]), [Link] ? [1, 4] :
[Link] ? [1, 3] : [Link] ? [1, 2] : [Link].pkcs1 ? [1,
1] : [1, 0]
}
}, function(e, t, r) {
[Link] = {
bufferSplit: function(e, t) {
[Link](e), [Link](t);
for (var r = [], i = 0, a = 0, o = 0; o < [Link]; ++o)
if (e[o] === [Link](a) ? ++a : a = e[o] === [Link](0) ? 1 : 0, a >=
[Link]) {
var s = o + 1;
[Link]([Link](i, s - a)), i = s, a = 0
}
return i <= [Link] && [Link]([Link](i, [Link])), r
},
addRSAMissing: function(e) {
[Link](e), d(e, a, [1, 1]);
var t, r = new p([Link]);
if (![Link]) {
var i = new p([Link]);
t = g([Link]([Link](1))), [Link] = {
name: "dmodp",
data: t
}, [Link]([Link])
}
if (![Link]) {
var o = new p([Link]);
t = g([Link]([Link](1))), [Link] = {
name: "dmodq",
data: t
}, [Link]([Link])
}
},
calculateDSAPublic: function(e, t, r) {
return [Link](e), [Link](t), [Link](r), e = new p(e), t = new p(t), r = new
p(r), g([Link](r, t))
},
calculateED25519Public: function(e) {
[Link](e);
var t = [Link](new Uint8Array(e));
return [Link]([Link])
},
calculateX25519Public: function(e) {
[Link](e);
var t = [Link](new Uint8Array(e));
return [Link]([Link])
},
mpNormalize: m,
mpDenormalize: function(e) {
for ([Link](e); [Link] > 1 && 0 === e[0];) e = [Link](1);
return e
},
ecNormalize: function(e, t) {
if ([Link](e), 0 === e[0] && 4 === e[1]) return t ? e : [Link](1);
if (4 === e[0]) {
if (!t) return e
} else {
for (; 0 === e[0];) e = [Link](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 = [Link]([Link] + 1);
return r[0] = 0, [Link](r, 1), r
},
countZeros: function(e) {
for (var t = 0, r = 8; t < [Link];) {
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 = [Link]._sshpkApiVersion), e instanceof t &&
[Link]._sshpkApiVersion[0] == r[0]) return !0;
for (var n = [Link](e), i = 0; [Link] !== [Link];)
if (!(n = [Link](n)) || ++i > 3) return !1;
if ([Link] !== [Link]) 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) {
[Link](t, "salt"), [Link](r, "passphrase"), [Link](a, "iteration count");
var o, c, u, l = f[e];
[Link](l, "supported cipher"), t = [Link](0, 8);
for (var p = [Link](0); [Link] < [Link] + [Link];) {
u = [], c && [Link](c), [Link](r), [Link](t), o = [Link](u);
for (var h = 0; h < a; ++h) o = [Link]("md5").update(o).digest();
p = [Link]([p, o]), c = o
}
return {
key: [Link](0, [Link]),
iv: [Link]([Link], [Link] + [Link])
}
},
opensshCipherInfo: function(e) {
var t = {};
switch (e) {
case "3des-cbc":
[Link] = 24, [Link] = 8, [Link] = "des-ede3-cbc";
break;
case "blowfish-cbc":
[Link] = 16, [Link] = 8, [Link] = "bf-cbc";
break;
case "aes128-cbc":
case "aes128-ctr":
case "aes128-gcm@[Link]":
[Link] = 16, [Link] = 16, [Link] = "aes-128-" + [Link](7, 10);
break;
case "aes192-cbc":
case "aes192-ctr":
case "aes192-gcm@[Link]":
[Link] = 24, [Link] = 16, [Link] = "aes-192-" + [Link](7, 10);
break;
case "aes256-cbc":
case "aes256-ctr":
case "aes256-gcm@[Link]":
[Link] = 32, [Link] = 16, [Link] = "aes-256-" + [Link](7, 10);
break;
default:
throw new Error('Unsupported openssl cipher "' + e + '"')
}
return t
},
publicFromPrivateECDSA: function(e, t) {
[Link](e, "curveName"), [Link](t);
var r = [Link][e],
a = new p(r.p),
s = new p(r.a),
u = new p(r.b),
h = new [Link](a, s, u),
d = [Link]([Link]("hex")),
f = new p(m(t)),
g = [Link](f);
g = [Link]([Link](g), "hex");
var v = [];
return [Link]({
name: "curve",
data: [Link](e)
}), [Link]({
name: "Q",
data: g
}), new o({
type: "ecdsa",
curve: h,
parts: v
})
},
zeroPadToLength: function(e, t) {
for ([Link](e), [Link](t); [Link] > t;) [Link](e[0], 0), e = [Link](1);
for (; [Link] < t;) {
var r = [Link]([Link] + 1);
r[0] = 0, [Link](r, 1), e = r
}
return e
},
writeBitString: function(e, t, r) {
void 0 === r && (r = [Link]);
var n = [Link]([Link] + 1);
n[0] = 0, [Link](n, 1), [Link](n, r)
},
readBitString: function(e, t) {
void 0 === t && (t = [Link]);
var r = [Link](t, !0);
return [Link](r[0], 0, "bit strings with unused bits are not supported (0x"
+ r[0].toString(16) + ")"), [Link](1)
},
pbkdf2: function(e, t, r, n, a) {
var o = [Link]([Link] + 4);
[Link](o);
for (var c = 0, u = [], l = 1; c < n;) {
var p = h(l++);
c += [Link], [Link](p)
}
return [Link](u).slice(0, n);

function h(t) {
o.writeUInt32BE(t, [Link] - 4);
var n = [Link](e, a);
[Link](o);
for (var i = [Link](), c = i, u = 1; u++ < r;) {
(n = [Link](e, a)).update(c), c = [Link]();
for (var l = 0; l < [Link]; ++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"), [Link](e, i + " must not be null"), [Link](e, i
+ " must be an object"), void 0 === r && (r = [Link]._sshpkApiVersion), !(e
instanceof t && [Link]._sshpkApiVersion[0] == r[0])) {
for (var a = [Link](e), o = 0; [Link] !== [Link];) a =
[Link](a), [Link](a && ++o <= 3, i + " must be a " + [Link] + "
instance");
[Link]([Link], [Link], i + " must be a " + [Link] + "
instance");
var s = a._sshpkApiVersion;
void 0 === s && (s = t._oldVersionDetect(e)), [Link](s[0] == r[0] && s[1] >= r[1], i
+ " must be compatible with " + [Link] + " 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 ([Link](e); [Link] > 1 && 0 === e[0] && 0 == (128 & e[1]);) e = [Link](1);
if (128 == (128 & e[0])) {
var t = [Link]([Link] + 1);
t[0] = 0, [Link](t, 1), e = t
}
return e
}

function g(e) {
var t = [Link]([Link]());
return m(t)
}
}, function(e, t, r) {
[Link] = 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 = [Link],
d = p.generateED25519,
f = r(215),
m = r(74),
g = r(12),
v = ([Link], [Link]),
y = ([Link], {});

function b(e) {
[Link](e, "options"), [Link](this, e), this._pubCache = void 0
}
[Link] = r(216), [Link] = r(46), y.pkcs1 = r(144), y.pkcs8 = r(76), y.rfc4253 =
r(47), y["ssh-private"] = r(105), [Link] = y["ssh-private"], [Link] = y["ssh-
private"], [Link] = r(145), [Link](b, g), [Link] = y, [Link]
= function(e, t) {
return void 0 === e && (e = "pkcs1"), [Link](e, "format"), [Link](y[e],
"formats[format]"), [Link](t, "options"), y[e].write(this, t)
}, [Link] = function(e, t) {
return [Link]().hash(e, t)
}, [Link] = function(e, t) {
return [Link]().fingerprint(e, t)
}, [Link] = function() {
if (this._pubCache) return this._pubCache;
for (var e = [Link][[Link]], t = [], r = 0; r < [Link]; ++r) {
var n = [Link][r];
[Link]([Link][n])
}
return this._pubCache = new g({
type: [Link],
source: this,
parts: t
}), [Link] && (this._pubCache.comment = [Link]), this._pubCache
}, [Link] = function(e) {
var t, r, a;
if ([Link](e, "type"), "ed25519" === [Link] && "curve25519" === e) return 0
=== (t = [Link])[0] && (t = [Link](1)), a =
[Link](new Uint8Array(t)), r = [Link]([Link]), new b({
type: "curve25519",
parts: [{
name: "A",
data: [Link](r)
}, {
name: "k",
data: [Link](t)
}]
});
if ("curve25519" === [Link] && "ed25519" === e) return 0 === (t =
[Link])[0] && (t = [Link](1)), a = [Link](new
Uint8Array(t)), r = [Link]([Link]), new b({
type: "ed25519",
parts: [{
name: "A",
data: [Link](r)
}, {
name: "k",
data: [Link](t)
}]
});
throw new Error("Key derivation not supported from " + [Link] + " to " + e)
}, [Link] = function(e) {
return [Link]().createVerify(e)
}, [Link] = function(e) {
if (void 0 === e && (e = [Link]()), [Link](e, "hash
algorithm"), "ed25519" === [Link] && void 0 !== f) return new [Link](this, e);
if ("curve25519" === [Link]) throw new Error("Curve25519 keys are not suitable
for signing or verification");
var t, r, a;
try {
r = [Link](), t = [Link](r)
} catch (e) {
a = e
}(void 0 === t || a instanceof Error && [Link](/Unknown message digest/))
&& (r = "RSA-", r += [Link](), t = [Link](r)), [Link](t, "failed to
create verifier");
var c = [Link](t),
u = [Link]("pkcs1"),
l = [Link],
p = [Link];
return [Link] = function() {
var t = c(u);
return "string" == typeof t && (t = [Link](t, "binary")), (t = [Link](t, l,
"asn1")).hashAlgorithm = e, [Link] = p, t
}, t
}, [Link] = function(e, t, r) {
"string" != typeof e && [Link](e, "data"), void 0 === t && (t = "auto"),
[Link](t, "format"), "string" == typeof r && (r = {
filename: r
}), [Link](r, "options"), void 0 === r && (r = {}),
[Link]([Link], "[Link]"), void 0 === [Link] &&
([Link] = "(unnamed)"), [Link](y[t], "formats[format]");
try {
var i = y[t].read(e, r);
return [Link](i instanceof b, "key is not a private key"), [Link] || ([Link] =
[Link]), i
} catch (e) {
if ("KeyEncryptedError" === [Link]) throw e;
throw new v([Link], t, e)
}
}, [Link] = function(e, t) {
return [Link](e, b, t)
}, [Link] = function(e, t) {
switch (void 0 === t && (t = {}), [Link](t, "options"), e) {
case "ecdsa":
return void 0 === [Link] && ([Link] = "nistp256"), [Link]([Link],
"[Link]"), h([Link]);
case "ed25519":
return d();
default:
throw new Error('Key generation not supported with key type "' + e + '"')
}
}, [Link]._sshpkApiVersion = [1, 6], b._oldVersionDetect = function(e) {
return [Link]([Link]), [Link]([Link]), [Link] ? [1, 3] :
[Link] ? [1, 2] : [Link] ? [1, 1] : [1, 0]
}
}, function(e, t, r) {
"use strict";
[Link](t, "__esModule", {
value: !0
}), [Link] = t.UPDATE_DOWNLOADED = t.DOWNLOAD_PROGRESS = [Link] =
[Link] = [Link] = [Link] = [Link] = [Link]
= [Link] = void 0;
const n = r(10);
[Link](t, "CancellationToken", {
enumerable: !0,
get: function() {
return [Link]
}
});
var i = r(121);
[Link](t, "AppUpdater", {
enumerable: !0,
get: function() {
return [Link]
}
}), [Link](t, "NoOpLogger", {
enumerable: !0,
get: function() {
return [Link]
}
});
var a = r(39);
[Link](t, "Provider", {
enumerable: !0,
get: function() {
return [Link]
}
});
var o = r(195);
[Link](t, "AppImageUpdater", {
enumerable: !0,
get: function() {
return [Link]
}
});
var s = r(200);
[Link](t, "MacUpdater", {
enumerable: !0,
get: function() {
return [Link]
}
});
var c = r(201);
let u;

function l(e, t, r) {
[Link](t, r)
}
[Link](t, "NsisUpdater", {
enumerable: !0,
get: function() {
return [Link]
}
}), [Link](t, "autoUpdater", {
enumerable: !0,
get: () => u || (u = "win32" === [Link] ? new(r(201).NsisUpdater) :
"darwin" === [Link] ? new(r(200).MacUpdater) :
new(r(195).AppImageUpdater), u)
}), t.DOWNLOAD_PROGRESS = "download-progress", t.UPDATE_DOWNLOADED = "update-
downloaded", [Link] = class {
constructor(e) {
[Link] = e
}
login(e) {
l([Link], "login", e)
}
progress(e) {
l([Link], t.DOWNLOAD_PROGRESS, e)
}
updateDownloaded(e) {
l([Link], t.UPDATE_DOWNLOADED, e)
}
updateCancelled(e) {
l([Link], "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: [Link]("00ffffffff 00000001 00000000 0000000000000000 ffffffff ffffffff
ffffffff".replace(/ /g, ""), "hex"),
a: [Link]("00FFFFFFFF 00000001 00000000 0000000000000000 FFFFFFFF FFFFFFFF
FFFFFFFC".replace(/ /g, ""), "hex"),
b: [Link]("5ac635d8 aa3a93e7 b3ebbd55 769886bc651d06b0 cc53b0f6 3bce3c3e
27d2604b".replace(/ /g, ""), "hex"),
s: [Link]("00c49d3608 86e70493 6a6678e1 139d26b7819f7e90".replace(/ /g, ""),
"hex"),
n: [Link]("00ffffffff 00000000 ffffffff ffffffffbce6faad a7179e84 f3b9cac2
fc632551".replace(/ /g, ""), "hex"),
G: [Link]("046b17d1f2 e12c4247 f8bce6e5 63a440f277037d81 2deb33a0 f4a13945
d898c2964fe342e2 fe1a7f9b 8ee7eb4a 7c0f9e162bce3357 6b315ece cbb64068
37bf51f5".replace(/ /g, ""), "hex")
},
nistp384: {
size: 384,
pkcs8oid: "[Link].34",
p: [Link]("00ffffffff ffffffff ffffffff ffffffffffffffff ffffffff ffffffff
fffffffeffffffff 00000000 00000000 ffffffff".replace(/ /g, ""), "hex"),
a: [Link]("00FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFFFFFFFFFF FFFFFFFF FFFFFFFF
FFFFFFFEFFFFFFFF 00000000 00000000 FFFFFFFC".replace(/ /g, ""), "hex"),
b: [Link]("b3312fa7 e23ee7e4 988e056b e3f82d19181d9c6e fe814112 0314088f
5013875ac656398d 8a2ed19d 2a85c8ed d3ec2aef".replace(/ /g, ""), "hex"),
s: [Link]("00a335926a a319a27a 1d00896a 6773a4827acdac73".replace(/ /g, ""),
"hex"),
n: [Link]("00ffffffff ffffffff ffffffff ffffffffffffffff ffffffff c7634d81
f4372ddf581a0db2 48b0a77a ecec196a ccc52973".replace(/ /g, ""), "hex"),
G: [Link]("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: "[Link].35",
p: [Link]("01ffffff ffffffff ffffffff ffffffffffffffff ffffffff ffffffff
ffffffffffffffff ffffffff ffffffff ffffffffffffffff ffffffff ffffffff
ffffffffffff".replace(/ /g, ""), "hex"),
a: [Link]("01FFFFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFFFFFFFFFF FFFFFFFF FFFFFFFF
FFFFFFFFFFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFFFFFFFFFF FFFFFFFF FFFFFFFF
FFFFFFFC".replace(/ /g, ""), "hex"),
b: [Link]("51953eb961 8e1c9a1f 929a21a0 b68540eea2da725b 99b315f3 b8b48991
8ef109e156193951 ec7e937b 1652c0bd 3bb1bf073573df88 3d2c34f1 ef451fd4
6b503f00".replace(/ /g, ""), "hex"),
s: [Link]("00d09e8800 291cb853 96cc6717 393284aaa0da64ba".replace(/ /g, ""),
"hex"),
n: [Link]("01ffffffffff ffffffff ffffffff ffffffffffffffff ffffffff ffffffff
fffffffa51868783 bf2f966b 7fcc0148 f709a5d03bb5c9b8 899c47ae bb6fb71e
91386409".replace(/ /g, ""), "hex"),
G: [Link]("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")
}
};
[Link] = {
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 ([Link] === !![Link] && [Link] === !![Link]) return
e;
e = [Link]
} else if ("string" != typeof e) throw new TypeError("Invalid Version: " + e);
if ([Link] > i) throw new TypeError(`version is longer than ${i} characters`);
n("SemVer", e, t), [Link] = t, [Link] = !![Link], [Link]
= !![Link];
const r = [Link]().match([Link] ? o[[Link]] : o[[Link]]);
if (!r) throw new TypeError("Invalid Version: " + e);
if ([Link] = e, [Link] = +r[1], [Link] = +r[2], [Link] = +r[3],
[Link] > a || [Link] < 0) throw new TypeError("Invalid major version");
if ([Link] > a || [Link] < 0) throw new TypeError("Invalid minor version");
if ([Link] > a || [Link] < 0) throw new TypeError("Invalid patch version");
r[4] ? [Link] = r[4].split(".").map(e => {
if (/^[0-9]+$/.test(e)) {
const t = +e;
if (t >= 0 && t < a) return t
}
return e
}) : [Link] = [], [Link] = r[5] ? r[5].split(".") : [], [Link]()
}
format() {
return [Link] = `${[Link]}.${[Link]}.${[Link]}`,
[Link] && ([Link] += "-" + [Link](".")),
[Link]
}
toString() {
return [Link]
}
compare(e) {
if (n("[Link]", [Link], [Link], e), !(e instanceof l)) {
if ("string" == typeof e && e === [Link]) return 0;
e = new l(e, [Link])
}
return [Link] === [Link] ? 0 : [Link](e) || [Link](e)
}
compareMain(e) {
return e instanceof l || (e = new l(e, [Link])), u([Link], [Link]) ||
u([Link], [Link]) || u([Link], [Link])
}
comparePre(e) {
if (e instanceof l || (e = new l(e, [Link])), [Link] && !
[Link]) return -1;
if (![Link] && [Link]) return 1;
if (![Link] && ![Link]) return 0;
let t = 0;
do {
const r = [Link][t],
i = [Link][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, [Link]));
let t = 0;
do {
const r = [Link][t],
i = [Link][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":
[Link] = 0, [Link] = 0, [Link] = 0, [Link]++,
[Link]("pre", t);
break;
case "preminor":
[Link] = 0, [Link] = 0, [Link]++, [Link]("pre", t);
break;
case "prepatch":
[Link] = 0, [Link]("patch", t), [Link]("pre", t);
break;
case "prerelease":
0 === [Link] && [Link]("patch", t), [Link]("pre", t);
break;
case "major":
0 === [Link] && 0 === [Link] && 0 !== [Link] || [Link]+
+, [Link] = 0, [Link] = 0, [Link] = [];
break;
case "minor":
0 === [Link] && 0 !== [Link] || [Link]++, [Link] = 0,
[Link] = [];
break;
case "patch":
0 === [Link] && [Link]++, [Link] = [];
break;
case "pre":
if (0 === [Link]) [Link] = [0];
else {
let e = [Link];
for (; --e >= 0;) "number" == typeof [Link][e] && ([Link][e]++, e
= -2); - 1 === e && [Link](0)
}
t && ([Link][0] === t ? isNaN([Link][1]) && ([Link] =
[t, 0]) : [Link] = [t, 0]);
break;
default:
throw new Error("invalid increment argument: " + e)
}
return [Link](), [Link] = [Link], this
}
}
[Link] = 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 ([Link] === !![Link] && [Link] === !![Link]) return
e;
e = [Link]
} else if ("string" != typeof e) throw new TypeError("Invalid Version: " + e);
if ([Link] > i) throw new TypeError(`version is longer than ${i} characters`);
n("SemVer", e, t), [Link] = t, [Link] = !![Link], [Link]
= !![Link];
const r = [Link]().match([Link] ? o[[Link]] : o[[Link]]);
if (!r) throw new TypeError("Invalid Version: " + e);
if ([Link] = e, [Link] = +r[1], [Link] = +r[2], [Link] = +r[3],
[Link] > a || [Link] < 0) throw new TypeError("Invalid major version");
if ([Link] > a || [Link] < 0) throw new TypeError("Invalid minor version");
if ([Link] > a || [Link] < 0) throw new TypeError("Invalid patch version");
r[4] ? [Link] = r[4].split(".").map(e => {
if (/^[0-9]+$/.test(e)) {
const t = +e;
if (t >= 0 && t < a) return t
}
return e
}) : [Link] = [], [Link] = r[5] ? r[5].split(".") : [], [Link]()
}
format() {
return [Link] = `${[Link]}.${[Link]}.${[Link]}`,
[Link] && ([Link] += "-" + [Link](".")),
[Link]
}
toString() {
return [Link]
}
compare(e) {
if (n("[Link]", [Link], [Link], e), !(e instanceof l)) {
if ("string" == typeof e && e === [Link]) return 0;
e = new l(e, [Link])
}
return [Link] === [Link] ? 0 : [Link](e) || [Link](e)
}
compareMain(e) {
return e instanceof l || (e = new l(e, [Link])), u([Link], [Link]) ||
u([Link], [Link]) || u([Link], [Link])
}
comparePre(e) {
if (e instanceof l || (e = new l(e, [Link])), [Link] && !
[Link]) return -1;
if (![Link] && [Link]) return 1;
if (![Link] && ![Link]) return 0;
let t = 0;
do {
const r = [Link][t],
i = [Link][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, [Link]));
let t = 0;
do {
const r = [Link][t],
i = [Link][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":
[Link] = 0, [Link] = 0, [Link] = 0, [Link]++,
[Link]("pre", t);
break;
case "preminor":
[Link] = 0, [Link] = 0, [Link]++, [Link]("pre", t);
break;
case "prepatch":
[Link] = 0, [Link]("patch", t), [Link]("pre", t);
break;
case "prerelease":
0 === [Link] && [Link]("patch", t), [Link]("pre", t);
break;
case "major":
0 === [Link] && 0 === [Link] && 0 !== [Link] || [Link]+
+, [Link] = 0, [Link] = 0, [Link] = [];
break;
case "minor":
0 === [Link] && 0 !== [Link] || [Link]++, [Link] = 0,
[Link] = [];
break;
case "patch":
0 === [Link] && [Link]++, [Link] = [];
break;
case "pre":
if (0 === [Link]) [Link] = [0];
else {
let e = [Link];
for (; --e >= 0;) "number" == typeof [Link][e] && ([Link][e]++, e
= -2); - 1 === e && [Link](0)
}
t && ([Link][0] === t ? isNaN([Link][1]) && ([Link] =
[t, 0]) : [Link] = [t, 0]);
break;
default:
throw new Error("invalid increment argument: " + e)
}
return [Link](), [Link] = [Link], this
}
}
[Link] = l
}, function(e, t, r) {
"use strict";
var n = r(202),
i = [Link];

function a(e) {
return [Link](e)
}

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

function s(e) {
return "[object ArrayBuffer]" === [Link](e)
}

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

function u(e) {
if ("[object Object]" !== [Link](e)) return !1;
var t = [Link](e);
return null === t || t === [Link]
}

function l(e) {
return "[object Function]" === [Link](e)
}

function p(e, t) {
if (null != e)
if ("object" != typeof e && (e = [e]), a(e))
for (var r = 0, n = [Link]; r < n; r++) [Link](null, e[r], r, e);
else
for (var i in e) [Link](e, i) && [Link](null, e[i],
i, e)
}
[Link] = {
isArray: a,
isArrayBuffer: s,
isBuffer: function(e) {
return null !== e && !o(e) && null !== [Link] && !o([Link]) &&
"function" == typeof [Link] && [Link](e)
},
isFormData: function(e) {
return "[object FormData]" === [Link](e)
},
isArrayBufferView: function(e) {
return "undefined" != typeof ArrayBuffer && [Link] ?
[Link](e) : e && [Link] && s([Link])
},
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]" === [Link](e)
},
isFile: function(e) {
return "[object File]" === [Link](e)
},
isBlob: function(e) {
return "[object Blob]" === [Link](e)
},
isFunction: l,
isStream: function(e) {
return c(e) && l([Link])
},
isURLSearchParams: function(e) {
return "[object URLSearchParams]" === [Link](e)
},
isStandardBrowserEnv: function() {
return ("undefined" == typeof navigator || "ReactNative" !== [Link] &&
"NativeScript" !== [Link] && "NS" !== [Link]) &&
"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] =
[Link]() : t[n] = r
}
for (var n = 0, i = arguments.