Created
December 14, 2019 23:03
-
-
Save alex0112/39ebb3b76ab356f06f796b58fe339142 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
!function() { | |
return function t(e, r, n) { | |
function i(s, a) { | |
if (!r[s]) { | |
if (!e[s]) { | |
var u = "function" == typeof require && require; | |
if (!a && u) | |
return u(s, !0); | |
if (o) | |
return o(s, !0); | |
var c = new Error("Cannot find module '" + s + "'"); | |
throw c.code = "MODULE_NOT_FOUND", | |
c | |
} | |
var f = r[s] = { | |
exports: {} | |
}; | |
e[s][0].call(f.exports, function(t) { | |
return i(e[s][1][t] || t) | |
}, f, f.exports, t, e, r, n) | |
} | |
return r[s].exports | |
} | |
for (var o = "function" == typeof require && require, s = 0; s < n.length; s++) | |
i(n[s]); | |
return i | |
} | |
}()({ | |
1: [function(t, e, r) { | |
"use strict"; | |
var n = t("@babel/runtime/helpers/interopRequireDefault"); | |
Object.defineProperty(r, "__esModule", { | |
value: !0 | |
}), | |
r.default = function(t) { | |
const e = new o(t) | |
, r = t.send; | |
return t.send = ((n,i)=>"string" == typeof n && !i || Array.isArray(i) ? e.send(n, i) : r.call(t, n, i)), | |
t | |
} | |
; | |
var i = n(t("@babel/runtime/helpers/defineProperty")); | |
class o { | |
constructor(t) { | |
(0, | |
i.default)(this, "_isConnected", void 0), | |
(0, | |
i.default)(this, "_provider", void 0), | |
this._provider = t, | |
this._subscribe(), | |
setTimeout(()=>{ | |
this._onConnect() | |
} | |
) | |
} | |
_onClose() { | |
(void 0 === this._isConnected || this._isConnected) && this._provider.emit("close", { | |
code: 1011, | |
reason: "Network connection error" | |
}), | |
this._isConnected = !1 | |
} | |
_onConnect() { | |
!this._isConnected && this._provider.emit("connect"), | |
this._isConnected = !0 | |
} | |
_subscribe() { | |
this._provider.on("data", (t,{method: e, params: r})=>{ | |
t || "eth_subscription" !== e || this._provider.emit("notification", r.result) | |
} | |
) | |
} | |
send(t, e=[]) { | |
return new Promise((r,n)=>{ | |
try { | |
this._provider.sendAsync({ | |
id: 1, | |
jsonrpc: "2.0", | |
method: t, | |
params: e | |
}, (t,e)=>{ | |
(t = t || e.error) ? n(t) : r(e) | |
} | |
) | |
} catch (t) { | |
n(t) | |
} | |
} | |
) | |
} | |
} | |
} | |
, { | |
"@babel/runtime/helpers/defineProperty": 7, | |
"@babel/runtime/helpers/interopRequireDefault": 11 | |
}], | |
2: [function(t, e, r) { | |
(function(e, r) { | |
"use strict"; | |
let n; | |
(()=>{ | |
n = r.define; | |
try { | |
r.define = void 0 | |
} catch (t) { | |
console.warn("MetaMask - global.define could not be deleted.") | |
} | |
} | |
)(), | |
t("web3/dist/web3.min.js"); | |
const i = t("loglevel") | |
, o = t("post-message-stream") | |
, s = t("./lib/auto-reload.js") | |
, MetamaskInpageProvider = t("metamask-inpage-provider") | |
, a = t("./createStandardProvider").default; | |
let u = !1; | |
(()=>{ | |
try { | |
r.define = n | |
} catch (t) { | |
console.warn("MetaMask - global.define could not be overwritten.") | |
} | |
} | |
)(), | |
i.setDefaultLevel(e.env.METAMASK_DEBUG ? "debug" : "warn"); | |
const c = new MetamaskInpageProvider(new o({ | |
name: "inpage", | |
target: "contentscript" | |
})); | |
c.setMaxListeners(100), | |
c.enable = function({force: t}={}) { | |
return new Promise((e,r)=>{ | |
c.sendAsync({ | |
method: "eth_requestAccounts", | |
params: [t] | |
}, (t,n)=>{ | |
t || n.error ? r(t || n.error) : e(n.result) | |
} | |
) | |
} | |
) | |
} | |
, | |
c.autoRefreshOnNetworkChange = !0; | |
const f = async()=>{ | |
const t = c.publicConfigStore; | |
let e = t.getState(); | |
return e.networkVersion || (e = await new Promise(e=>t.once("update",e)), | |
console.log("new state", e)), | |
e | |
} | |
; | |
c._metamask = new Proxy({ | |
isEnabled: function() { | |
const {isEnabled: t} = c.publicConfigStore.getState(); | |
return Boolean(t) | |
}, | |
isApproved: async function() { | |
const {isEnabled: t} = await f(); | |
return Boolean(t) | |
}, | |
isUnlocked: async function() { | |
const {isUnlocked: t} = await f(); | |
return Boolean(t) | |
} | |
},{ | |
get: function(t, e) { | |
return !u && console.warn("Heads up! ethereum._metamask exposes methods that have not been standardized yet. This means that these methods may not be implemented in other dapp browsers and may be removed from MetaMask in the future."), | |
u = !0, | |
t[e] | |
} | |
}); | |
const l = new Proxy(c,{ | |
deleteProperty: ()=>!0 | |
}); | |
if (window.ethereum = a(l), | |
void 0 !== window.web3) | |
throw new Error("MetaMask detected another web3.\n MetaMask will not work reliably with another web3 extension.\n This usually happens if you have two MetaMasks installed,\n or MetaMask and another web3 extension. Please remove one\n and try again."); | |
const h = new Web3(l); | |
h.setProvider = function() { | |
i.debug("MetaMask - overrode web3.setProvider") | |
} | |
, | |
i.debug("MetaMask - injected web3"), | |
s(h, c.publicConfigStore), | |
c.publicConfigStore.subscribe(function(t) { | |
h.eth.defaultAccount = t.selectedAddress | |
}), | |
c.publicConfigStore.subscribe(function(t) { | |
t.onboardingcomplete && window.postMessage("onboardingcomplete", "*") | |
}) | |
} | |
).call(this, t("_process"), "undefined" != typeof global ? global : "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}) | |
} | |
, { | |
"./createStandardProvider": 1, | |
"./lib/auto-reload.js": 3, | |
_process: 42, | |
loglevel: 29, | |
"metamask-inpage-provider": 31, | |
"post-message-stream": 40, | |
"web3/dist/web3.min.js": 67 | |
}], | |
3: [function(t, e, r) { | |
(function(t) { | |
"use strict"; | |
function r() { | |
t.location.reload() | |
} | |
e.exports = function(e, n) { | |
let i, o, s = !1; | |
t.web3 = new Proxy(e,{ | |
get: (t,e)=>(i = Date.now(), | |
t[e]), | |
set: (t,e,r)=>{ | |
t[e] = r | |
} | |
}), | |
n.subscribe(function(t) { | |
if (!window.ethereum.autoRefreshOnNetworkChange) | |
return; | |
if (s) | |
return; | |
const e = t.networkVersion; | |
if (!o) | |
return void (o = e); | |
if (!i) | |
return; | |
if (e === o) | |
return; | |
s = !0; | |
const n = Date.now() - i; | |
n > 500 ? r() : setTimeout(r, 500) | |
}) | |
} | |
} | |
).call(this, "undefined" != typeof global ? global : "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}) | |
} | |
, {}], | |
4: [function(t, e, r) { | |
e.exports = function(t) { | |
if (void 0 === t) | |
throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); | |
return t | |
} | |
} | |
, {}], | |
5: [function(t, e, r) { | |
e.exports = function(t, e) { | |
if (!(t instanceof e)) | |
throw new TypeError("Cannot call a class as a function") | |
} | |
} | |
, {}], | |
6: [function(t, e, r) { | |
function n(t, e) { | |
for (var r = 0; r < e.length; r++) { | |
var n = e[r]; | |
n.enumerable = n.enumerable || !1, | |
n.configurable = !0, | |
"value"in n && (n.writable = !0), | |
Object.defineProperty(t, n.key, n) | |
} | |
} | |
e.exports = function(t, e, r) { | |
return e && n(t.prototype, e), | |
r && n(t, r), | |
t | |
} | |
} | |
, {}], | |
7: [function(t, e, r) { | |
e.exports = function(t, e, r) { | |
return e in t ? Object.defineProperty(t, e, { | |
value: r, | |
enumerable: !0, | |
configurable: !0, | |
writable: !0 | |
}) : t[e] = r, | |
t | |
} | |
} | |
, {}], | |
8: [function(t, e, r) { | |
var n = t("./superPropBase"); | |
function i(t, r, o) { | |
return "undefined" != typeof Reflect && Reflect.get ? e.exports = i = Reflect.get : e.exports = i = function(t, e, r) { | |
var i = n(t, e); | |
if (i) { | |
var o = Object.getOwnPropertyDescriptor(i, e); | |
return o.get ? o.get.call(r) : o.value | |
} | |
} | |
, | |
i(t, r, o || t) | |
} | |
e.exports = i | |
} | |
, { | |
"./superPropBase": 14 | |
}], | |
9: [function(t, e, r) { | |
function n(t) { | |
return e.exports = n = Object.setPrototypeOf ? Object.getPrototypeOf : function(t) { | |
return t.__proto__ || Object.getPrototypeOf(t) | |
} | |
, | |
n(t) | |
} | |
e.exports = n | |
} | |
, {}], | |
10: [function(t, e, r) { | |
var n = t("./setPrototypeOf"); | |
e.exports = function(t, e) { | |
if ("function" != typeof e && null !== e) | |
throw new TypeError("Super expression must either be null or a function"); | |
t.prototype = Object.create(e && e.prototype, { | |
constructor: { | |
value: t, | |
writable: !0, | |
configurable: !0 | |
} | |
}), | |
e && n(t, e) | |
} | |
} | |
, { | |
"./setPrototypeOf": 13 | |
}], | |
11: [function(t, e, r) { | |
e.exports = function(t) { | |
return t && t.__esModule ? t : { | |
default: t | |
} | |
} | |
} | |
, {}], | |
12: [function(t, e, r) { | |
var n = t("../helpers/typeof") | |
, i = t("./assertThisInitialized"); | |
e.exports = function(t, e) { | |
return !e || "object" !== n(e) && "function" != typeof e ? i(t) : e | |
} | |
} | |
, { | |
"../helpers/typeof": 15, | |
"./assertThisInitialized": 4 | |
}], | |
13: [function(t, e, r) { | |
function n(t, r) { | |
return e.exports = n = Object.setPrototypeOf || function(t, e) { | |
return t.__proto__ = e, | |
t | |
} | |
, | |
n(t, r) | |
} | |
e.exports = n | |
} | |
, {}], | |
14: [function(t, e, r) { | |
var n = t("./getPrototypeOf"); | |
e.exports = function(t, e) { | |
for (; !Object.prototype.hasOwnProperty.call(t, e) && null !== (t = n(t)); ) | |
; | |
return t | |
} | |
} | |
, { | |
"./getPrototypeOf": 9 | |
}], | |
15: [function(t, e, r) { | |
function n(t) { | |
return (n = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(t) { | |
return typeof t | |
} | |
: function(t) { | |
return t && "function" == typeof Symbol && t.constructor === Symbol && t !== Symbol.prototype ? "symbol" : typeof t | |
} | |
)(t) | |
} | |
function i(t) { | |
return "function" == typeof Symbol && "symbol" === n(Symbol.iterator) ? e.exports = i = function(t) { | |
return n(t) | |
} | |
: e.exports = i = function(t) { | |
return t && "function" == typeof Symbol && t.constructor === Symbol && t !== Symbol.prototype ? "symbol" : n(t) | |
} | |
, | |
i(t) | |
} | |
e.exports = i | |
} | |
, {}], | |
16: [function(t, e, r) { | |
(function(t, n, i) { | |
!function(t, n) { | |
"object" == typeof r && void 0 !== e ? n(r) : "function" == typeof define && define.amd ? define(["exports"], n) : n(t.async = t.async || {}) | |
}(this, function(r) { | |
"use strict"; | |
function o(t, e) { | |
e |= 0; | |
for (var r = Math.max(t.length - e, 0), n = Array(r), i = 0; i < r; i++) | |
n[i] = t[e + i]; | |
return n | |
} | |
var s = function(t) { | |
var e = o(arguments, 1); | |
return function() { | |
var r = o(arguments); | |
return t.apply(null, e.concat(r)) | |
} | |
} | |
, a = function(t) { | |
return function() { | |
var e = o(arguments) | |
, r = e.pop(); | |
t.call(this, e, r) | |
} | |
}; | |
function u(t) { | |
var e = typeof t; | |
return null != t && ("object" == e || "function" == e) | |
} | |
var c = "function" == typeof i && i | |
, f = "object" == typeof t && "function" == typeof t.nextTick; | |
function l(t) { | |
setTimeout(t, 0) | |
} | |
function h(t) { | |
return function(e) { | |
var r = o(arguments, 1); | |
t(function() { | |
e.apply(null, r) | |
}) | |
} | |
} | |
var p = h(c ? i : f ? t.nextTick : l); | |
function d(t) { | |
return a(function(e, r) { | |
var n; | |
try { | |
n = t.apply(this, e) | |
} catch (t) { | |
return r(t) | |
} | |
u(n) && "function" == typeof n.then ? n.then(function(t) { | |
y(r, null, t) | |
}, function(t) { | |
y(r, t.message ? t : new Error(t)) | |
}) : r(null, n) | |
}) | |
} | |
function y(t, e, r) { | |
try { | |
t(e, r) | |
} catch (t) { | |
p(m, t) | |
} | |
} | |
function m(t) { | |
throw t | |
} | |
var g = "function" == typeof Symbol; | |
function v(t) { | |
return g && "AsyncFunction" === t[Symbol.toStringTag] | |
} | |
function b(t) { | |
return v(t) ? d(t) : t | |
} | |
function w(t) { | |
return function(e) { | |
var r = o(arguments, 1) | |
, n = a(function(r, n) { | |
var i = this; | |
return t(e, function(t, e) { | |
b(t).apply(i, r.concat(e)) | |
}, n) | |
}); | |
return r.length ? n.apply(this, r) : n | |
} | |
} | |
var _ = "object" == typeof n && n && n.Object === Object && n | |
, x = "object" == typeof self && self && self.Object === Object && self | |
, S = _ || x || Function("return this")() | |
, k = S.Symbol | |
, E = Object.prototype | |
, A = E.hasOwnProperty | |
, C = E.toString | |
, T = k ? k.toStringTag : void 0; | |
var O = Object.prototype.toString; | |
var B = "[object Null]" | |
, j = "[object Undefined]" | |
, R = k ? k.toStringTag : void 0; | |
function M(t) { | |
return null == t ? void 0 === t ? j : B : R && R in Object(t) ? function(t) { | |
var e = A.call(t, T) | |
, r = t[T]; | |
try { | |
t[T] = void 0; | |
var n = !0 | |
} catch (t) {} | |
var i = C.call(t); | |
return n && (e ? t[T] = r : delete t[T]), | |
i | |
}(t) : function(t) { | |
return O.call(t) | |
}(t) | |
} | |
var L = "[object AsyncFunction]" | |
, I = "[object Function]" | |
, N = "[object GeneratorFunction]" | |
, P = "[object Proxy]"; | |
var D = 9007199254740991; | |
function F(t) { | |
return "number" == typeof t && t > -1 && t % 1 == 0 && t <= D | |
} | |
function U(t) { | |
return null != t && F(t.length) && !function(t) { | |
if (!u(t)) | |
return !1; | |
var e = M(t); | |
return e == I || e == N || e == L || e == P | |
}(t) | |
} | |
var q = {}; | |
function H() {} | |
function z(t) { | |
return function() { | |
if (null !== t) { | |
var e = t; | |
t = null, | |
e.apply(this, arguments) | |
} | |
} | |
} | |
var W = "function" == typeof Symbol && Symbol.iterator | |
, J = function(t) { | |
return W && t[W] && t[W]() | |
}; | |
function G(t) { | |
return null != t && "object" == typeof t | |
} | |
var K = "[object Arguments]"; | |
function V(t) { | |
return G(t) && M(t) == K | |
} | |
var X = Object.prototype | |
, $ = X.hasOwnProperty | |
, Y = X.propertyIsEnumerable | |
, Z = V(function() { | |
return arguments | |
}()) ? V : function(t) { | |
return G(t) && $.call(t, "callee") && !Y.call(t, "callee") | |
} | |
, Q = Array.isArray; | |
var tt = "object" == typeof r && r && !r.nodeType && r | |
, et = tt && "object" == typeof e && e && !e.nodeType && e | |
, rt = et && et.exports === tt ? S.Buffer : void 0 | |
, nt = (rt ? rt.isBuffer : void 0) || function() { | |
return !1 | |
} | |
, it = 9007199254740991 | |
, ot = /^(?:0|[1-9]\d*)$/; | |
function st(t, e) { | |
var r = typeof t; | |
return !!(e = null == e ? it : e) && ("number" == r || "symbol" != r && ot.test(t)) && t > -1 && t % 1 == 0 && t < e | |
} | |
var at = {}; | |
at["[object Float32Array]"] = at["[object Float64Array]"] = at["[object Int8Array]"] = at["[object Int16Array]"] = at["[object Int32Array]"] = at["[object Uint8Array]"] = at["[object Uint8ClampedArray]"] = at["[object Uint16Array]"] = at["[object Uint32Array]"] = !0, | |
at["[object Arguments]"] = at["[object Array]"] = at["[object ArrayBuffer]"] = at["[object Boolean]"] = at["[object DataView]"] = at["[object Date]"] = at["[object Error]"] = at["[object Function]"] = at["[object Map]"] = at["[object Number]"] = at["[object Object]"] = at["[object RegExp]"] = at["[object Set]"] = at["[object String]"] = at["[object WeakMap]"] = !1; | |
var ut, ct = "object" == typeof r && r && !r.nodeType && r, ft = ct && "object" == typeof e && e && !e.nodeType && e, lt = ft && ft.exports === ct && _.process, ht = function() { | |
try { | |
var t = ft && ft.require && ft.require("util").types; | |
return t || lt && lt.binding && lt.binding("util") | |
} catch (t) {} | |
}(), pt = ht && ht.isTypedArray, dt = pt ? (ut = pt, | |
function(t) { | |
return ut(t) | |
} | |
) : function(t) { | |
return G(t) && F(t.length) && !!at[M(t)] | |
} | |
, yt = Object.prototype.hasOwnProperty; | |
function mt(t, e) { | |
var r = Q(t) | |
, n = !r && Z(t) | |
, i = !r && !n && nt(t) | |
, o = !r && !n && !i && dt(t) | |
, s = r || n || i || o | |
, a = s ? function(t, e) { | |
for (var r = -1, n = Array(t); ++r < t; ) | |
n[r] = e(r); | |
return n | |
}(t.length, String) : [] | |
, u = a.length; | |
for (var c in t) | |
!e && !yt.call(t, c) || s && ("length" == c || i && ("offset" == c || "parent" == c) || o && ("buffer" == c || "byteLength" == c || "byteOffset" == c) || st(c, u)) || a.push(c); | |
return a | |
} | |
var gt = Object.prototype; | |
var vt = function(t, e) { | |
return function(r) { | |
return t(e(r)) | |
} | |
}(Object.keys, Object) | |
, bt = Object.prototype.hasOwnProperty; | |
function wt(t) { | |
if (r = (e = t) && e.constructor, | |
e !== ("function" == typeof r && r.prototype || gt)) | |
return vt(t); | |
var e, r, n = []; | |
for (var i in Object(t)) | |
bt.call(t, i) && "constructor" != i && n.push(i); | |
return n | |
} | |
function _t(t) { | |
return U(t) ? mt(t) : wt(t) | |
} | |
function xt(t) { | |
if (U(t)) | |
return function(t) { | |
var e = -1 | |
, r = t.length; | |
return function() { | |
return ++e < r ? { | |
value: t[e], | |
key: e | |
} : null | |
} | |
}(t); | |
var e, r, n, i, o = J(t); | |
return o ? function(t) { | |
var e = -1; | |
return function() { | |
var r = t.next(); | |
return r.done ? null : (e++, | |
{ | |
value: r.value, | |
key: e | |
}) | |
} | |
}(o) : (r = _t(e = t), | |
n = -1, | |
i = r.length, | |
function() { | |
var t = r[++n]; | |
return n < i ? { | |
value: e[t], | |
key: t | |
} : null | |
} | |
) | |
} | |
function St(t) { | |
return function() { | |
if (null === t) | |
throw new Error("Callback was already called."); | |
var e = t; | |
t = null, | |
e.apply(this, arguments) | |
} | |
} | |
function kt(t) { | |
return function(e, r, n) { | |
if (n = z(n || H), | |
t <= 0 || !e) | |
return n(null); | |
var i = xt(e) | |
, o = !1 | |
, s = 0 | |
, a = !1; | |
function u(t, e) { | |
if (s -= 1, | |
t) | |
o = !0, | |
n(t); | |
else { | |
if (e === q || o && s <= 0) | |
return o = !0, | |
n(null); | |
a || c() | |
} | |
} | |
function c() { | |
for (a = !0; s < t && !o; ) { | |
var e = i(); | |
if (null === e) | |
return o = !0, | |
void (s <= 0 && n(null)); | |
s += 1, | |
r(e.value, e.key, St(u)) | |
} | |
a = !1 | |
} | |
c() | |
} | |
} | |
function Et(t, e, r, n) { | |
kt(e)(t, b(r), n) | |
} | |
function At(t, e) { | |
return function(r, n, i) { | |
return t(r, e, n, i) | |
} | |
} | |
function Ct(t, e, r) { | |
r = z(r || H); | |
var n = 0 | |
, i = 0 | |
, o = t.length; | |
function s(t, e) { | |
t ? r(t) : ++i !== o && e !== q || r(null) | |
} | |
for (0 === o && r(null); n < o; n++) | |
e(t[n], n, St(s)) | |
} | |
var Tt = At(Et, 1 / 0) | |
, Ot = function(t, e, r) { | |
(U(t) ? Ct : Tt)(t, b(e), r) | |
}; | |
function Bt(t) { | |
return function(e, r, n) { | |
return t(Ot, e, b(r), n) | |
} | |
} | |
function jt(t, e, r, n) { | |
n = n || H, | |
e = e || []; | |
var i = [] | |
, o = 0 | |
, s = b(r); | |
t(e, function(t, e, r) { | |
var n = o++; | |
s(t, function(t, e) { | |
i[n] = e, | |
r(t) | |
}) | |
}, function(t) { | |
n(t, i) | |
}) | |
} | |
var Rt = Bt(jt) | |
, Mt = w(Rt); | |
function Lt(t) { | |
return function(e, r, n, i) { | |
return t(kt(r), e, b(n), i) | |
} | |
} | |
var It = Lt(jt) | |
, Nt = At(It, 1) | |
, Pt = w(Nt); | |
function Dt(t, e) { | |
for (var r = -1, n = null == t ? 0 : t.length; ++r < n && !1 !== e(t[r], r, t); ) | |
; | |
return t | |
} | |
var Ft, Ut = function(t, e, r) { | |
for (var n = -1, i = Object(t), o = r(t), s = o.length; s--; ) { | |
var a = o[Ft ? s : ++n]; | |
if (!1 === e(i[a], a, i)) | |
break | |
} | |
return t | |
}; | |
function qt(t, e) { | |
return t && Ut(t, e, _t) | |
} | |
function Ht(t) { | |
return t != t | |
} | |
function zt(t, e, r) { | |
return e == e ? function(t, e, r) { | |
for (var n = r - 1, i = t.length; ++n < i; ) | |
if (t[n] === e) | |
return n; | |
return -1 | |
}(t, e, r) : function(t, e, r, n) { | |
for (var i = t.length, o = r + (n ? 1 : -1); n ? o-- : ++o < i; ) | |
if (e(t[o], o, t)) | |
return o; | |
return -1 | |
}(t, Ht, r) | |
} | |
var Wt = function(t, e, r) { | |
"function" == typeof e && (r = e, | |
e = null), | |
r = z(r || H); | |
var n = _t(t).length; | |
if (!n) | |
return r(null); | |
e || (e = n); | |
var i = {} | |
, s = 0 | |
, a = !1 | |
, u = Object.create(null) | |
, c = [] | |
, f = [] | |
, l = {}; | |
function h(t, e) { | |
c.push(function() { | |
!function(t, e) { | |
if (a) | |
return; | |
var n = St(function(e, n) { | |
if (s--, | |
arguments.length > 2 && (n = o(arguments, 1)), | |
e) { | |
var c = {}; | |
qt(i, function(t, e) { | |
c[e] = t | |
}), | |
c[t] = n, | |
a = !0, | |
u = Object.create(null), | |
r(e, c) | |
} else | |
i[t] = n, | |
Dt(u[t] || [], function(t) { | |
t() | |
}), | |
p() | |
}); | |
s++; | |
var c = b(e[e.length - 1]); | |
e.length > 1 ? c(i, n) : c(n) | |
}(t, e) | |
}) | |
} | |
function p() { | |
if (0 === c.length && 0 === s) | |
return r(null, i); | |
for (; c.length && s < e; ) { | |
c.shift()() | |
} | |
} | |
function d(e) { | |
var r = []; | |
return qt(t, function(t, n) { | |
Q(t) && zt(t, e, 0) >= 0 && r.push(n) | |
}), | |
r | |
} | |
qt(t, function(e, r) { | |
if (!Q(e)) | |
return h(r, [e]), | |
void f.push(r); | |
var n = e.slice(0, e.length - 1) | |
, i = n.length; | |
if (0 === i) | |
return h(r, e), | |
void f.push(r); | |
l[r] = i, | |
Dt(n, function(o) { | |
if (!t[o]) | |
throw new Error("async.auto task `" + r + "` has a non-existent dependency `" + o + "` in " + n.join(", ")); | |
!function(t, e) { | |
var r = u[t]; | |
r || (r = u[t] = []); | |
r.push(e) | |
}(o, function() { | |
0 === --i && h(r, e) | |
}) | |
}) | |
}), | |
function() { | |
var t, e = 0; | |
for (; f.length; ) | |
t = f.pop(), | |
e++, | |
Dt(d(t), function(t) { | |
0 == --l[t] && f.push(t) | |
}); | |
if (e !== n) | |
throw new Error("async.auto cannot execute tasks due to a recursive dependency") | |
}(), | |
p() | |
}; | |
function Jt(t, e) { | |
for (var r = -1, n = null == t ? 0 : t.length, i = Array(n); ++r < n; ) | |
i[r] = e(t[r], r, t); | |
return i | |
} | |
var Gt = "[object Symbol]"; | |
var Kt = 1 / 0 | |
, Vt = k ? k.prototype : void 0 | |
, Xt = Vt ? Vt.toString : void 0; | |
function $t(t) { | |
if ("string" == typeof t) | |
return t; | |
if (Q(t)) | |
return Jt(t, $t) + ""; | |
if (function(t) { | |
return "symbol" == typeof t || G(t) && M(t) == Gt | |
}(t)) | |
return Xt ? Xt.call(t) : ""; | |
var e = t + ""; | |
return "0" == e && 1 / t == -Kt ? "-0" : e | |
} | |
function Yt(t, e, r) { | |
var n = t.length; | |
return r = void 0 === r ? n : r, | |
!e && r >= n ? t : function(t, e, r) { | |
var n = -1 | |
, i = t.length; | |
e < 0 && (e = -e > i ? 0 : i + e), | |
(r = r > i ? i : r) < 0 && (r += i), | |
i = e > r ? 0 : r - e >>> 0, | |
e >>>= 0; | |
for (var o = Array(i); ++n < i; ) | |
o[n] = t[n + e]; | |
return o | |
}(t, e, r) | |
} | |
var Zt = RegExp("[\\u200d\\ud800-\\udfff\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff\\ufe0e\\ufe0f]"); | |
var Qt = "[\\ud800-\\udfff]" | |
, te = "[\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]" | |
, ee = "\\ud83c[\\udffb-\\udfff]" | |
, re = "[^\\ud800-\\udfff]" | |
, ne = "(?:\\ud83c[\\udde6-\\uddff]){2}" | |
, ie = "[\\ud800-\\udbff][\\udc00-\\udfff]" | |
, oe = "(?:" + te + "|" + ee + ")" + "?" | |
, se = "[\\ufe0e\\ufe0f]?" + oe + ("(?:\\u200d(?:" + [re, ne, ie].join("|") + ")[\\ufe0e\\ufe0f]?" + oe + ")*") | |
, ae = "(?:" + [re + te + "?", te, ne, ie, Qt].join("|") + ")" | |
, ue = RegExp(ee + "(?=" + ee + ")|" + ae + se, "g"); | |
function ce(t) { | |
return function(t) { | |
return Zt.test(t) | |
}(t) ? function(t) { | |
return t.match(ue) || [] | |
}(t) : function(t) { | |
return t.split("") | |
}(t) | |
} | |
var fe = /^\s+|\s+$/g; | |
function le(t, e, r) { | |
var n; | |
if ((t = null == (n = t) ? "" : $t(n)) && (r || void 0 === e)) | |
return t.replace(fe, ""); | |
if (!t || !(e = $t(e))) | |
return t; | |
var i = ce(t) | |
, o = ce(e); | |
return Yt(i, function(t, e) { | |
for (var r = -1, n = t.length; ++r < n && zt(e, t[r], 0) > -1; ) | |
; | |
return r | |
}(i, o), function(t, e) { | |
for (var r = t.length; r-- && zt(e, t[r], 0) > -1; ) | |
; | |
return r | |
}(i, o) + 1).join("") | |
} | |
var he = /^(?:async\s+)?(function)?\s*[^\(]*\(\s*([^\)]*)\)/m | |
, pe = /,/ | |
, de = /(=.+)?(\s*)$/ | |
, ye = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm; | |
function me(t, e) { | |
var r = {}; | |
qt(t, function(t, e) { | |
var n, i, o = v(t), s = !o && 1 === t.length || o && 0 === t.length; | |
if (Q(t)) | |
n = t.slice(0, -1), | |
t = t[t.length - 1], | |
r[e] = n.concat(n.length > 0 ? a : t); | |
else if (s) | |
r[e] = t; | |
else { | |
if (n = i = (i = (i = (i = (i = t).toString().replace(ye, "")).match(he)[2].replace(" ", "")) ? i.split(pe) : []).map(function(t) { | |
return le(t.replace(de, "")) | |
}), | |
0 === t.length && !o && 0 === n.length) | |
throw new Error("autoInject task functions require explicit parameters."); | |
o || n.pop(), | |
r[e] = n.concat(a) | |
} | |
function a(e, r) { | |
var i = Jt(n, function(t) { | |
return e[t] | |
}); | |
i.push(r), | |
b(t).apply(null, i) | |
} | |
}), | |
Wt(r, e) | |
} | |
function ge() { | |
this.head = this.tail = null, | |
this.length = 0 | |
} | |
function ve(t, e) { | |
t.length = 1, | |
t.head = t.tail = e | |
} | |
function be(t, e, r) { | |
if (null == e) | |
e = 1; | |
else if (0 === e) | |
throw new Error("Concurrency must not be zero"); | |
var n = b(t) | |
, i = 0 | |
, o = [] | |
, s = !1; | |
function a(t, e, r) { | |
if (null != r && "function" != typeof r) | |
throw new Error("task callback must be a function"); | |
if (f.started = !0, | |
Q(t) || (t = [t]), | |
0 === t.length && f.idle()) | |
return p(function() { | |
f.drain() | |
}); | |
for (var n = 0, i = t.length; n < i; n++) { | |
var o = { | |
data: t[n], | |
callback: r || H | |
}; | |
e ? f._tasks.unshift(o) : f._tasks.push(o) | |
} | |
s || (s = !0, | |
p(function() { | |
s = !1, | |
f.process() | |
})) | |
} | |
function u(t) { | |
return function(e) { | |
i -= 1; | |
for (var r = 0, n = t.length; r < n; r++) { | |
var s = t[r] | |
, a = zt(o, s, 0); | |
0 === a ? o.shift() : a > 0 && o.splice(a, 1), | |
s.callback.apply(s, arguments), | |
null != e && f.error(e, s.data) | |
} | |
i <= f.concurrency - f.buffer && f.unsaturated(), | |
f.idle() && f.drain(), | |
f.process() | |
} | |
} | |
var c = !1 | |
, f = { | |
_tasks: new ge, | |
concurrency: e, | |
payload: r, | |
saturated: H, | |
unsaturated: H, | |
buffer: e / 4, | |
empty: H, | |
drain: H, | |
error: H, | |
started: !1, | |
paused: !1, | |
push: function(t, e) { | |
a(t, !1, e) | |
}, | |
kill: function() { | |
f.drain = H, | |
f._tasks.empty() | |
}, | |
unshift: function(t, e) { | |
a(t, !0, e) | |
}, | |
remove: function(t) { | |
f._tasks.remove(t) | |
}, | |
process: function() { | |
if (!c) { | |
for (c = !0; !f.paused && i < f.concurrency && f._tasks.length; ) { | |
var t = [] | |
, e = [] | |
, r = f._tasks.length; | |
f.payload && (r = Math.min(r, f.payload)); | |
for (var s = 0; s < r; s++) { | |
var a = f._tasks.shift(); | |
t.push(a), | |
o.push(a), | |
e.push(a.data) | |
} | |
i += 1, | |
0 === f._tasks.length && f.empty(), | |
i === f.concurrency && f.saturated(); | |
var l = St(u(t)); | |
n(e, l) | |
} | |
c = !1 | |
} | |
}, | |
length: function() { | |
return f._tasks.length | |
}, | |
running: function() { | |
return i | |
}, | |
workersList: function() { | |
return o | |
}, | |
idle: function() { | |
return f._tasks.length + i === 0 | |
}, | |
pause: function() { | |
f.paused = !0 | |
}, | |
resume: function() { | |
!1 !== f.paused && (f.paused = !1, | |
p(f.process)) | |
} | |
}; | |
return f | |
} | |
function we(t, e) { | |
return be(t, 1, e) | |
} | |
ge.prototype.removeLink = function(t) { | |
return t.prev ? t.prev.next = t.next : this.head = t.next, | |
t.next ? t.next.prev = t.prev : this.tail = t.prev, | |
t.prev = t.next = null, | |
this.length -= 1, | |
t | |
} | |
, | |
ge.prototype.empty = function() { | |
for (; this.head; ) | |
this.shift(); | |
return this | |
} | |
, | |
ge.prototype.insertAfter = function(t, e) { | |
e.prev = t, | |
e.next = t.next, | |
t.next ? t.next.prev = e : this.tail = e, | |
t.next = e, | |
this.length += 1 | |
} | |
, | |
ge.prototype.insertBefore = function(t, e) { | |
e.prev = t.prev, | |
e.next = t, | |
t.prev ? t.prev.next = e : this.head = e, | |
t.prev = e, | |
this.length += 1 | |
} | |
, | |
ge.prototype.unshift = function(t) { | |
this.head ? this.insertBefore(this.head, t) : ve(this, t) | |
} | |
, | |
ge.prototype.push = function(t) { | |
this.tail ? this.insertAfter(this.tail, t) : ve(this, t) | |
} | |
, | |
ge.prototype.shift = function() { | |
return this.head && this.removeLink(this.head) | |
} | |
, | |
ge.prototype.pop = function() { | |
return this.tail && this.removeLink(this.tail) | |
} | |
, | |
ge.prototype.toArray = function() { | |
for (var t = Array(this.length), e = this.head, r = 0; r < this.length; r++) | |
t[r] = e.data, | |
e = e.next; | |
return t | |
} | |
, | |
ge.prototype.remove = function(t) { | |
for (var e = this.head; e; ) { | |
var r = e.next; | |
t(e) && this.removeLink(e), | |
e = r | |
} | |
return this | |
} | |
; | |
var _e = At(Et, 1); | |
function xe(t, e, r, n) { | |
n = z(n || H); | |
var i = b(r); | |
_e(t, function(t, r, n) { | |
i(e, t, function(t, r) { | |
e = r, | |
n(t) | |
}) | |
}, function(t) { | |
n(t, e) | |
}) | |
} | |
function Se() { | |
var t = Jt(arguments, b); | |
return function() { | |
var e = o(arguments) | |
, r = this | |
, n = e[e.length - 1]; | |
"function" == typeof n ? e.pop() : n = H, | |
xe(t, e, function(t, e, n) { | |
e.apply(r, t.concat(function(t) { | |
var e = o(arguments, 1); | |
n(t, e) | |
})) | |
}, function(t, e) { | |
n.apply(r, [t].concat(e)) | |
}) | |
} | |
} | |
var ke = function() { | |
return Se.apply(null, o(arguments).reverse()) | |
} | |
, Ee = Array.prototype.concat | |
, Ae = function(t, e, r, n) { | |
n = n || H; | |
var i = b(r); | |
It(t, e, function(t, e) { | |
i(t, function(t) { | |
return t ? e(t) : e(null, o(arguments, 1)) | |
}) | |
}, function(t, e) { | |
for (var r = [], i = 0; i < e.length; i++) | |
e[i] && (r = Ee.apply(r, e[i])); | |
return n(t, r) | |
}) | |
} | |
, Ce = At(Ae, 1 / 0) | |
, Te = At(Ae, 1) | |
, Oe = function() { | |
var t = o(arguments) | |
, e = [null].concat(t); | |
return function() { | |
return arguments[arguments.length - 1].apply(this, e) | |
} | |
}; | |
function Be(t) { | |
return t | |
} | |
function je(t, e) { | |
return function(r, n, i, o) { | |
o = o || H; | |
var s, a = !1; | |
r(n, function(r, n, o) { | |
i(r, function(n, i) { | |
n ? o(n) : t(i) && !s ? (a = !0, | |
s = e(!0, r), | |
o(null, q)) : o() | |
}) | |
}, function(t) { | |
t ? o(t) : o(null, a ? s : e(!1)) | |
}) | |
} | |
} | |
function Re(t, e) { | |
return e | |
} | |
var Me = Bt(je(Be, Re)) | |
, Le = Lt(je(Be, Re)) | |
, Ie = At(Le, 1); | |
function Ne(t) { | |
return function(e) { | |
var r = o(arguments, 1); | |
r.push(function(e) { | |
var r = o(arguments, 1); | |
"object" == typeof console && (e ? console.error && console.error(e) : console[t] && Dt(r, function(e) { | |
console[t](e) | |
})) | |
}), | |
b(e).apply(null, r) | |
} | |
} | |
var Pe = Ne("dir"); | |
function De(t, e, r) { | |
r = St(r || H); | |
var n = b(t) | |
, i = b(e); | |
function s(t) { | |
if (t) | |
return r(t); | |
var e = o(arguments, 1); | |
e.push(a), | |
i.apply(this, e) | |
} | |
function a(t, e) { | |
return t ? r(t) : e ? void n(s) : r(null) | |
} | |
a(null, !0) | |
} | |
function Fe(t, e, r) { | |
r = St(r || H); | |
var n = b(t) | |
, i = function(t) { | |
if (t) | |
return r(t); | |
var s = o(arguments, 1); | |
if (e.apply(this, s)) | |
return n(i); | |
r.apply(null, [null].concat(s)) | |
}; | |
n(i) | |
} | |
function Ue(t, e, r) { | |
Fe(t, function() { | |
return !e.apply(this, arguments) | |
}, r) | |
} | |
function qe(t, e, r) { | |
r = St(r || H); | |
var n = b(e) | |
, i = b(t); | |
function o(t) { | |
if (t) | |
return r(t); | |
i(s) | |
} | |
function s(t, e) { | |
return t ? r(t) : e ? void n(o) : r(null) | |
} | |
i(s) | |
} | |
function He(t) { | |
return function(e, r, n) { | |
return t(e, n) | |
} | |
} | |
function ze(t, e, r) { | |
Ot(t, He(b(e)), r) | |
} | |
function We(t, e, r, n) { | |
kt(e)(t, He(b(r)), n) | |
} | |
var Je = At(We, 1); | |
function Ge(t) { | |
return v(t) ? t : a(function(e, r) { | |
var n = !0; | |
e.push(function() { | |
var t = arguments; | |
n ? p(function() { | |
r.apply(null, t) | |
}) : r.apply(null, t) | |
}), | |
t.apply(this, e), | |
n = !1 | |
}) | |
} | |
function Ke(t) { | |
return !t | |
} | |
var Ve = Bt(je(Ke, Ke)) | |
, Xe = Lt(je(Ke, Ke)) | |
, $e = At(Xe, 1); | |
function Ye(t) { | |
return function(e) { | |
return null == e ? void 0 : e[t] | |
} | |
} | |
function Ze(t, e, r, n) { | |
var i = new Array(e.length); | |
t(e, function(t, e, n) { | |
r(t, function(t, r) { | |
i[e] = !!r, | |
n(t) | |
}) | |
}, function(t) { | |
if (t) | |
return n(t); | |
for (var r = [], o = 0; o < e.length; o++) | |
i[o] && r.push(e[o]); | |
n(null, r) | |
}) | |
} | |
function Qe(t, e, r, n) { | |
var i = []; | |
t(e, function(t, e, n) { | |
r(t, function(r, o) { | |
r ? n(r) : (o && i.push({ | |
index: e, | |
value: t | |
}), | |
n()) | |
}) | |
}, function(t) { | |
t ? n(t) : n(null, Jt(i.sort(function(t, e) { | |
return t.index - e.index | |
}), Ye("value"))) | |
}) | |
} | |
function tr(t, e, r, n) { | |
(U(e) ? Ze : Qe)(t, e, b(r), n || H) | |
} | |
var er = Bt(tr) | |
, rr = Lt(tr) | |
, nr = At(rr, 1); | |
function ir(t, e) { | |
var r = St(e || H) | |
, n = b(Ge(t)); | |
!function t(e) { | |
if (e) | |
return r(e); | |
n(t) | |
}() | |
} | |
var or = function(t, e, r, n) { | |
n = n || H; | |
var i = b(r); | |
It(t, e, function(t, e) { | |
i(t, function(r, n) { | |
return r ? e(r) : e(null, { | |
key: n, | |
val: t | |
}) | |
}) | |
}, function(t, e) { | |
for (var r = {}, i = Object.prototype.hasOwnProperty, o = 0; o < e.length; o++) | |
if (e[o]) { | |
var s = e[o].key | |
, a = e[o].val; | |
i.call(r, s) ? r[s].push(a) : r[s] = [a] | |
} | |
return n(t, r) | |
}) | |
} | |
, sr = At(or, 1 / 0) | |
, ar = At(or, 1) | |
, ur = Ne("log"); | |
function cr(t, e, r, n) { | |
n = z(n || H); | |
var i = {} | |
, o = b(r); | |
Et(t, e, function(t, e, r) { | |
o(t, e, function(t, n) { | |
if (t) | |
return r(t); | |
i[e] = n, | |
r() | |
}) | |
}, function(t) { | |
n(t, i) | |
}) | |
} | |
var fr = At(cr, 1 / 0) | |
, lr = At(cr, 1); | |
function hr(t, e) { | |
return e in t | |
} | |
function pr(t, e) { | |
var r = Object.create(null) | |
, n = Object.create(null); | |
e = e || Be; | |
var i = b(t) | |
, s = a(function(t, s) { | |
var a = e.apply(null, t); | |
hr(r, a) ? p(function() { | |
s.apply(null, r[a]) | |
}) : hr(n, a) ? n[a].push(s) : (n[a] = [s], | |
i.apply(null, t.concat(function() { | |
var t = o(arguments); | |
r[a] = t; | |
var e = n[a]; | |
delete n[a]; | |
for (var i = 0, s = e.length; i < s; i++) | |
e[i].apply(null, t) | |
}))) | |
}); | |
return s.memo = r, | |
s.unmemoized = t, | |
s | |
} | |
var dr = h(f ? t.nextTick : c ? i : l); | |
function yr(t, e, r) { | |
r = r || H; | |
var n = U(e) ? [] : {}; | |
t(e, function(t, e, r) { | |
b(t)(function(t, i) { | |
arguments.length > 2 && (i = o(arguments, 1)), | |
n[e] = i, | |
r(t) | |
}) | |
}, function(t) { | |
r(t, n) | |
}) | |
} | |
function mr(t, e) { | |
yr(Ot, t, e) | |
} | |
function gr(t, e, r) { | |
yr(kt(e), t, r) | |
} | |
var vr = function(t, e) { | |
var r = b(t); | |
return be(function(t, e) { | |
r(t[0], e) | |
}, e, 1) | |
} | |
, br = function(t, e) { | |
var r = vr(t, e); | |
return r.push = function(t, e, n) { | |
if (null == n && (n = H), | |
"function" != typeof n) | |
throw new Error("task callback must be a function"); | |
if (r.started = !0, | |
Q(t) || (t = [t]), | |
0 === t.length) | |
return p(function() { | |
r.drain() | |
}); | |
e = e || 0; | |
for (var i = r._tasks.head; i && e >= i.priority; ) | |
i = i.next; | |
for (var o = 0, s = t.length; o < s; o++) { | |
var a = { | |
data: t[o], | |
priority: e, | |
callback: n | |
}; | |
i ? r._tasks.insertBefore(i, a) : r._tasks.push(a) | |
} | |
p(r.process) | |
} | |
, | |
delete r.unshift, | |
r | |
}; | |
function wr(t, e) { | |
if (e = z(e || H), | |
!Q(t)) | |
return e(new TypeError("First argument to race must be an array of functions")); | |
if (!t.length) | |
return e(); | |
for (var r = 0, n = t.length; r < n; r++) | |
b(t[r])(e) | |
} | |
function _r(t, e, r, n) { | |
xe(o(t).reverse(), e, r, n) | |
} | |
function xr(t) { | |
var e = b(t); | |
return a(function(t, r) { | |
return t.push(function(t, e) { | |
var n; | |
t ? r(null, { | |
error: t | |
}) : (n = arguments.length <= 2 ? e : o(arguments, 1), | |
r(null, { | |
value: n | |
})) | |
}), | |
e.apply(this, t) | |
}) | |
} | |
function Sr(t) { | |
var e; | |
return Q(t) ? e = Jt(t, xr) : (e = {}, | |
qt(t, function(t, r) { | |
e[r] = xr.call(this, t) | |
})), | |
e | |
} | |
function kr(t, e, r, n) { | |
tr(t, e, function(t, e) { | |
r(t, function(t, r) { | |
e(t, !r) | |
}) | |
}, n) | |
} | |
var Er = Bt(kr) | |
, Ar = Lt(kr) | |
, Cr = At(Ar, 1); | |
function Tr(t) { | |
return function() { | |
return t | |
} | |
} | |
function Or(t, e, r) { | |
var n = 5 | |
, i = 0 | |
, o = { | |
times: n, | |
intervalFunc: Tr(i) | |
}; | |
if (arguments.length < 3 && "function" == typeof t ? (r = e || H, | |
e = t) : (!function(t, e) { | |
if ("object" == typeof e) | |
t.times = +e.times || n, | |
t.intervalFunc = "function" == typeof e.interval ? e.interval : Tr(+e.interval || i), | |
t.errorFilter = e.errorFilter; | |
else { | |
if ("number" != typeof e && "string" != typeof e) | |
throw new Error("Invalid arguments for async.retry"); | |
t.times = +e || n | |
} | |
}(o, t), | |
r = r || H), | |
"function" != typeof e) | |
throw new Error("Invalid arguments for async.retry"); | |
var s = b(e) | |
, a = 1; | |
!function t() { | |
s(function(e) { | |
e && a++ < o.times && ("function" != typeof o.errorFilter || o.errorFilter(e)) ? setTimeout(t, o.intervalFunc(a)) : r.apply(null, arguments) | |
}) | |
}() | |
} | |
var Br = function(t, e) { | |
e || (e = t, | |
t = null); | |
var r = b(e); | |
return a(function(e, n) { | |
function i(t) { | |
r.apply(null, e.concat(t)) | |
} | |
t ? Or(t, i, n) : Or(i, n) | |
}) | |
}; | |
function jr(t, e) { | |
yr(_e, t, e) | |
} | |
var Rr = Bt(je(Boolean, Be)) | |
, Mr = Lt(je(Boolean, Be)) | |
, Lr = At(Mr, 1); | |
function Ir(t, e, r) { | |
var n = b(e); | |
function i(t, e) { | |
var r = t.criteria | |
, n = e.criteria; | |
return r < n ? -1 : r > n ? 1 : 0 | |
} | |
Rt(t, function(t, e) { | |
n(t, function(r, n) { | |
if (r) | |
return e(r); | |
e(null, { | |
value: t, | |
criteria: n | |
}) | |
}) | |
}, function(t, e) { | |
if (t) | |
return r(t); | |
r(null, Jt(e.sort(i), Ye("value"))) | |
}) | |
} | |
function Nr(t, e, r) { | |
var n = b(t); | |
return a(function(i, o) { | |
var s, a = !1; | |
i.push(function() { | |
a || (o.apply(null, arguments), | |
clearTimeout(s)) | |
}), | |
s = setTimeout(function() { | |
var e = t.name || "anonymous" | |
, n = new Error('Callback function "' + e + '" timed out.'); | |
n.code = "ETIMEDOUT", | |
r && (n.info = r), | |
a = !0, | |
o(n) | |
}, e), | |
n.apply(null, i) | |
}) | |
} | |
var Pr = Math.ceil | |
, Dr = Math.max; | |
function Fr(t, e, r, n) { | |
var i = b(r); | |
It(function(t, e, r, n) { | |
for (var i = -1, o = Dr(Pr((e - t) / (r || 1)), 0), s = Array(o); o--; ) | |
s[n ? o : ++i] = t, | |
t += r; | |
return s | |
}(0, t, 1), e, i, n) | |
} | |
var Ur = At(Fr, 1 / 0) | |
, qr = At(Fr, 1); | |
function Hr(t, e, r, n) { | |
arguments.length <= 3 && (n = r, | |
r = e, | |
e = Q(t) ? [] : {}), | |
n = z(n || H); | |
var i = b(r); | |
Ot(t, function(t, r, n) { | |
i(e, t, r, n) | |
}, function(t) { | |
n(t, e) | |
}) | |
} | |
function zr(t, e) { | |
var r, n = null; | |
e = e || H, | |
Je(t, function(t, e) { | |
b(t)(function(t, i) { | |
r = arguments.length > 2 ? o(arguments, 1) : i, | |
n = t, | |
e(!t) | |
}) | |
}, function() { | |
e(n, r) | |
}) | |
} | |
function Wr(t) { | |
return function() { | |
return (t.unmemoized || t).apply(null, arguments) | |
} | |
} | |
function Jr(t, e, r) { | |
r = St(r || H); | |
var n = b(e); | |
if (!t()) | |
return r(null); | |
var i = function(e) { | |
if (e) | |
return r(e); | |
if (t()) | |
return n(i); | |
var s = o(arguments, 1); | |
r.apply(null, [null].concat(s)) | |
}; | |
n(i) | |
} | |
function Gr(t, e, r) { | |
Jr(function() { | |
return !t.apply(this, arguments) | |
}, e, r) | |
} | |
var Kr = function(t, e) { | |
if (e = z(e || H), | |
!Q(t)) | |
return e(new Error("First argument to waterfall must be an array of functions")); | |
if (!t.length) | |
return e(); | |
var r = 0; | |
function n(e) { | |
var n = b(t[r++]); | |
e.push(St(i)), | |
n.apply(null, e) | |
} | |
function i(i) { | |
if (i || r === t.length) | |
return e.apply(null, arguments); | |
n(o(arguments, 1)) | |
} | |
n([]) | |
} | |
, Vr = { | |
apply: s, | |
applyEach: Mt, | |
applyEachSeries: Pt, | |
asyncify: d, | |
auto: Wt, | |
autoInject: me, | |
cargo: we, | |
compose: ke, | |
concat: Ce, | |
concatLimit: Ae, | |
concatSeries: Te, | |
constant: Oe, | |
detect: Me, | |
detectLimit: Le, | |
detectSeries: Ie, | |
dir: Pe, | |
doDuring: De, | |
doUntil: Ue, | |
doWhilst: Fe, | |
during: qe, | |
each: ze, | |
eachLimit: We, | |
eachOf: Ot, | |
eachOfLimit: Et, | |
eachOfSeries: _e, | |
eachSeries: Je, | |
ensureAsync: Ge, | |
every: Ve, | |
everyLimit: Xe, | |
everySeries: $e, | |
filter: er, | |
filterLimit: rr, | |
filterSeries: nr, | |
forever: ir, | |
groupBy: sr, | |
groupByLimit: or, | |
groupBySeries: ar, | |
log: ur, | |
map: Rt, | |
mapLimit: It, | |
mapSeries: Nt, | |
mapValues: fr, | |
mapValuesLimit: cr, | |
mapValuesSeries: lr, | |
memoize: pr, | |
nextTick: dr, | |
parallel: mr, | |
parallelLimit: gr, | |
priorityQueue: br, | |
queue: vr, | |
race: wr, | |
reduce: xe, | |
reduceRight: _r, | |
reflect: xr, | |
reflectAll: Sr, | |
reject: Er, | |
rejectLimit: Ar, | |
rejectSeries: Cr, | |
retry: Or, | |
retryable: Br, | |
seq: Se, | |
series: jr, | |
setImmediate: p, | |
some: Rr, | |
someLimit: Mr, | |
someSeries: Lr, | |
sortBy: Ir, | |
timeout: Nr, | |
times: Ur, | |
timesLimit: Fr, | |
timesSeries: qr, | |
transform: Hr, | |
tryEach: zr, | |
unmemoize: Wr, | |
until: Gr, | |
waterfall: Kr, | |
whilst: Jr, | |
all: Ve, | |
allLimit: Xe, | |
allSeries: $e, | |
any: Rr, | |
anyLimit: Mr, | |
anySeries: Lr, | |
find: Me, | |
findLimit: Le, | |
findSeries: Ie, | |
forEach: ze, | |
forEachSeries: Je, | |
forEachLimit: We, | |
forEachOf: Ot, | |
forEachOfSeries: _e, | |
forEachOfLimit: Et, | |
inject: xe, | |
foldl: xe, | |
foldr: _r, | |
select: er, | |
selectLimit: rr, | |
selectSeries: nr, | |
wrapSync: d | |
}; | |
r.default = Vr, | |
r.apply = s, | |
r.applyEach = Mt, | |
r.applyEachSeries = Pt, | |
r.asyncify = d, | |
r.auto = Wt, | |
r.autoInject = me, | |
r.cargo = we, | |
r.compose = ke, | |
r.concat = Ce, | |
r.concatLimit = Ae, | |
r.concatSeries = Te, | |
r.constant = Oe, | |
r.detect = Me, | |
r.detectLimit = Le, | |
r.detectSeries = Ie, | |
r.dir = Pe, | |
r.doDuring = De, | |
r.doUntil = Ue, | |
r.doWhilst = Fe, | |
r.during = qe, | |
r.each = ze, | |
r.eachLimit = We, | |
r.eachOf = Ot, | |
r.eachOfLimit = Et, | |
r.eachOfSeries = _e, | |
r.eachSeries = Je, | |
r.ensureAsync = Ge, | |
r.every = Ve, | |
r.everyLimit = Xe, | |
r.everySeries = $e, | |
r.filter = er, | |
r.filterLimit = rr, | |
r.filterSeries = nr, | |
r.forever = ir, | |
r.groupBy = sr, | |
r.groupByLimit = or, | |
r.groupBySeries = ar, | |
r.log = ur, | |
r.map = Rt, | |
r.mapLimit = It, | |
r.mapSeries = Nt, | |
r.mapValues = fr, | |
r.mapValuesLimit = cr, | |
r.mapValuesSeries = lr, | |
r.memoize = pr, | |
r.nextTick = dr, | |
r.parallel = mr, | |
r.parallelLimit = gr, | |
r.priorityQueue = br, | |
r.queue = vr, | |
r.race = wr, | |
r.reduce = xe, | |
r.reduceRight = _r, | |
r.reflect = xr, | |
r.reflectAll = Sr, | |
r.reject = Er, | |
r.rejectLimit = Ar, | |
r.rejectSeries = Cr, | |
r.retry = Or, | |
r.retryable = Br, | |
r.seq = Se, | |
r.series = jr, | |
r.setImmediate = p, | |
r.some = Rr, | |
r.someLimit = Mr, | |
r.someSeries = Lr, | |
r.sortBy = Ir, | |
r.timeout = Nr, | |
r.times = Ur, | |
r.timesLimit = Fr, | |
r.timesSeries = qr, | |
r.transform = Hr, | |
r.tryEach = zr, | |
r.unmemoize = Wr, | |
r.until = Gr, | |
r.waterfall = Kr, | |
r.whilst = Jr, | |
r.all = Ve, | |
r.allLimit = Xe, | |
r.allSeries = $e, | |
r.any = Rr, | |
r.anyLimit = Mr, | |
r.anySeries = Lr, | |
r.find = Me, | |
r.findLimit = Le, | |
r.findSeries = Ie, | |
r.forEach = ze, | |
r.forEachSeries = Je, | |
r.forEachLimit = We, | |
r.forEachOf = Ot, | |
r.forEachOfSeries = _e, | |
r.forEachOfLimit = Et, | |
r.inject = xe, | |
r.foldl = xe, | |
r.foldr = _r, | |
r.select = er, | |
r.selectLimit = rr, | |
r.selectSeries = nr, | |
r.wrapSync = d, | |
Object.defineProperty(r, "__esModule", { | |
value: !0 | |
}) | |
}) | |
} | |
).call(this, t("_process"), "undefined" != typeof global ? global : "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}, t("timers").setImmediate) | |
} | |
, { | |
_process: 42, | |
timers: 62 | |
}], | |
17: [function(t, e, r) { | |
"use strict"; | |
r.byteLength = function(t) { | |
var e = c(t) | |
, r = e[0] | |
, n = e[1]; | |
return 3 * (r + n) / 4 - n | |
} | |
, | |
r.toByteArray = function(t) { | |
var e, r, n = c(t), s = n[0], a = n[1], u = new o(function(t, e, r) { | |
return 3 * (e + r) / 4 - r | |
}(0, s, a)), f = 0, l = a > 0 ? s - 4 : s; | |
for (r = 0; r < l; r += 4) | |
e = i[t.charCodeAt(r)] << 18 | i[t.charCodeAt(r + 1)] << 12 | i[t.charCodeAt(r + 2)] << 6 | i[t.charCodeAt(r + 3)], | |
u[f++] = e >> 16 & 255, | |
u[f++] = e >> 8 & 255, | |
u[f++] = 255 & e; | |
2 === a && (e = i[t.charCodeAt(r)] << 2 | i[t.charCodeAt(r + 1)] >> 4, | |
u[f++] = 255 & e); | |
1 === a && (e = i[t.charCodeAt(r)] << 10 | i[t.charCodeAt(r + 1)] << 4 | i[t.charCodeAt(r + 2)] >> 2, | |
u[f++] = e >> 8 & 255, | |
u[f++] = 255 & e); | |
return u | |
} | |
, | |
r.fromByteArray = function(t) { | |
for (var e, r = t.length, i = r % 3, o = [], s = 0, a = r - i; s < a; s += 16383) | |
o.push(f(t, s, s + 16383 > a ? a : s + 16383)); | |
1 === i ? (e = t[r - 1], | |
o.push(n[e >> 2] + n[e << 4 & 63] + "==")) : 2 === i && (e = (t[r - 2] << 8) + t[r - 1], | |
o.push(n[e >> 10] + n[e >> 4 & 63] + n[e << 2 & 63] + "=")); | |
return o.join("") | |
} | |
; | |
for (var n = [], i = [], o = "undefined" != typeof Uint8Array ? Uint8Array : Array, s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", a = 0, u = s.length; a < u; ++a) | |
n[a] = s[a], | |
i[s.charCodeAt(a)] = a; | |
function c(t) { | |
var e = t.length; | |
if (e % 4 > 0) | |
throw new Error("Invalid string. Length must be a multiple of 4"); | |
var r = t.indexOf("="); | |
return -1 === r && (r = e), | |
[r, r === e ? 0 : 4 - r % 4] | |
} | |
function f(t, e, r) { | |
for (var i, o, s = [], a = e; a < r; a += 3) | |
i = (t[a] << 16 & 16711680) + (t[a + 1] << 8 & 65280) + (255 & t[a + 2]), | |
s.push(n[(o = i) >> 18 & 63] + n[o >> 12 & 63] + n[o >> 6 & 63] + n[63 & o]); | |
return s.join("") | |
} | |
i["-".charCodeAt(0)] = 62, | |
i["_".charCodeAt(0)] = 63 | |
} | |
, {}], | |
18: [function(t, e, r) {} | |
, {}], | |
19: [function(t, e, r) { | |
"use strict"; | |
var n = t("base64-js") | |
, i = t("ieee754"); | |
r.Buffer = a, | |
r.SlowBuffer = function(t) { | |
+t != t && (t = 0); | |
return a.alloc(+t) | |
} | |
, | |
r.INSPECT_MAX_BYTES = 50; | |
var o = 2147483647; | |
function s(t) { | |
if (t > o) | |
throw new RangeError('The value "' + t + '" is invalid for option "size"'); | |
var e = new Uint8Array(t); | |
return e.__proto__ = a.prototype, | |
e | |
} | |
function a(t, e, r) { | |
if ("number" == typeof t) { | |
if ("string" == typeof e) | |
throw new TypeError('The "string" argument must be of type string. Received type number'); | |
return f(t) | |
} | |
return u(t, e, r) | |
} | |
function u(t, e, r) { | |
if ("string" == typeof t) | |
return function(t, e) { | |
"string" == typeof e && "" !== e || (e = "utf8"); | |
if (!a.isEncoding(e)) | |
throw new TypeError("Unknown encoding: " + e); | |
var r = 0 | p(t, e) | |
, n = s(r) | |
, i = n.write(t, e); | |
i !== r && (n = n.slice(0, i)); | |
return n | |
}(t, e); | |
if (ArrayBuffer.isView(t)) | |
return l(t); | |
if (null == t) | |
throw TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof t); | |
if (U(t, ArrayBuffer) || t && U(t.buffer, ArrayBuffer)) | |
return function(t, e, r) { | |
if (e < 0 || t.byteLength < e) | |
throw new RangeError('"offset" is outside of buffer bounds'); | |
if (t.byteLength < e + (r || 0)) | |
throw new RangeError('"length" is outside of buffer bounds'); | |
var n; | |
n = void 0 === e && void 0 === r ? new Uint8Array(t) : void 0 === r ? new Uint8Array(t,e) : new Uint8Array(t,e,r); | |
return n.__proto__ = a.prototype, | |
n | |
}(t, e, r); | |
if ("number" == typeof t) | |
throw new TypeError('The "value" argument must not be of type number. Received type number'); | |
var n = t.valueOf && t.valueOf(); | |
if (null != n && n !== t) | |
return a.from(n, e, r); | |
var i = function(t) { | |
if (a.isBuffer(t)) { | |
var e = 0 | h(t.length) | |
, r = s(e); | |
return 0 === r.length ? r : (t.copy(r, 0, 0, e), | |
r) | |
} | |
if (void 0 !== t.length) | |
return "number" != typeof t.length || q(t.length) ? s(0) : l(t); | |
if ("Buffer" === t.type && Array.isArray(t.data)) | |
return l(t.data) | |
}(t); | |
if (i) | |
return i; | |
if ("undefined" != typeof Symbol && null != Symbol.toPrimitive && "function" == typeof t[Symbol.toPrimitive]) | |
return a.from(t[Symbol.toPrimitive]("string"), e, r); | |
throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof t) | |
} | |
function c(t) { | |
if ("number" != typeof t) | |
throw new TypeError('"size" argument must be of type number'); | |
if (t < 0) | |
throw new RangeError('The value "' + t + '" is invalid for option "size"') | |
} | |
function f(t) { | |
return c(t), | |
s(t < 0 ? 0 : 0 | h(t)) | |
} | |
function l(t) { | |
for (var e = t.length < 0 ? 0 : 0 | h(t.length), r = s(e), n = 0; n < e; n += 1) | |
r[n] = 255 & t[n]; | |
return r | |
} | |
function h(t) { | |
if (t >= o) | |
throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + o.toString(16) + " bytes"); | |
return 0 | t | |
} | |
function p(t, e) { | |
if (a.isBuffer(t)) | |
return t.length; | |
if (ArrayBuffer.isView(t) || U(t, ArrayBuffer)) | |
return t.byteLength; | |
if ("string" != typeof t) | |
throw new TypeError('The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof t); | |
var r = t.length | |
, n = arguments.length > 2 && !0 === arguments[2]; | |
if (!n && 0 === r) | |
return 0; | |
for (var i = !1; ; ) | |
switch (e) { | |
case "ascii": | |
case "latin1": | |
case "binary": | |
return r; | |
case "utf8": | |
case "utf-8": | |
return P(t).length; | |
case "ucs2": | |
case "ucs-2": | |
case "utf16le": | |
case "utf-16le": | |
return 2 * r; | |
case "hex": | |
return r >>> 1; | |
case "base64": | |
return D(t).length; | |
default: | |
if (i) | |
return n ? -1 : P(t).length; | |
e = ("" + e).toLowerCase(), | |
i = !0 | |
} | |
} | |
function d(t, e, r) { | |
var n = t[e]; | |
t[e] = t[r], | |
t[r] = n | |
} | |
function y(t, e, r, n, i) { | |
if (0 === t.length) | |
return -1; | |
if ("string" == typeof r ? (n = r, | |
r = 0) : r > 2147483647 ? r = 2147483647 : r < -2147483648 && (r = -2147483648), | |
q(r = +r) && (r = i ? 0 : t.length - 1), | |
r < 0 && (r = t.length + r), | |
r >= t.length) { | |
if (i) | |
return -1; | |
r = t.length - 1 | |
} else if (r < 0) { | |
if (!i) | |
return -1; | |
r = 0 | |
} | |
if ("string" == typeof e && (e = a.from(e, n)), | |
a.isBuffer(e)) | |
return 0 === e.length ? -1 : m(t, e, r, n, i); | |
if ("number" == typeof e) | |
return e &= 255, | |
"function" == typeof Uint8Array.prototype.indexOf ? i ? Uint8Array.prototype.indexOf.call(t, e, r) : Uint8Array.prototype.lastIndexOf.call(t, e, r) : m(t, [e], r, n, i); | |
throw new TypeError("val must be string, number or Buffer") | |
} | |
function m(t, e, r, n, i) { | |
var o, s = 1, a = t.length, u = e.length; | |
if (void 0 !== n && ("ucs2" === (n = String(n).toLowerCase()) || "ucs-2" === n || "utf16le" === n || "utf-16le" === n)) { | |
if (t.length < 2 || e.length < 2) | |
return -1; | |
s = 2, | |
a /= 2, | |
u /= 2, | |
r /= 2 | |
} | |
function c(t, e) { | |
return 1 === s ? t[e] : t.readUInt16BE(e * s) | |
} | |
if (i) { | |
var f = -1; | |
for (o = r; o < a; o++) | |
if (c(t, o) === c(e, -1 === f ? 0 : o - f)) { | |
if (-1 === f && (f = o), | |
o - f + 1 === u) | |
return f * s | |
} else | |
-1 !== f && (o -= o - f), | |
f = -1 | |
} else | |
for (r + u > a && (r = a - u), | |
o = r; o >= 0; o--) { | |
for (var l = !0, h = 0; h < u; h++) | |
if (c(t, o + h) !== c(e, h)) { | |
l = !1; | |
break | |
} | |
if (l) | |
return o | |
} | |
return -1 | |
} | |
function g(t, e, r, n) { | |
r = Number(r) || 0; | |
var i = t.length - r; | |
n ? (n = Number(n)) > i && (n = i) : n = i; | |
var o = e.length; | |
n > o / 2 && (n = o / 2); | |
for (var s = 0; s < n; ++s) { | |
var a = parseInt(e.substr(2 * s, 2), 16); | |
if (q(a)) | |
return s; | |
t[r + s] = a | |
} | |
return s | |
} | |
function v(t, e, r, n) { | |
return F(P(e, t.length - r), t, r, n) | |
} | |
function b(t, e, r, n) { | |
return F(function(t) { | |
for (var e = [], r = 0; r < t.length; ++r) | |
e.push(255 & t.charCodeAt(r)); | |
return e | |
}(e), t, r, n) | |
} | |
function w(t, e, r, n) { | |
return b(t, e, r, n) | |
} | |
function _(t, e, r, n) { | |
return F(D(e), t, r, n) | |
} | |
function x(t, e, r, n) { | |
return F(function(t, e) { | |
for (var r, n, i, o = [], s = 0; s < t.length && !((e -= 2) < 0); ++s) | |
r = t.charCodeAt(s), | |
n = r >> 8, | |
i = r % 256, | |
o.push(i), | |
o.push(n); | |
return o | |
}(e, t.length - r), t, r, n) | |
} | |
function S(t, e, r) { | |
return 0 === e && r === t.length ? n.fromByteArray(t) : n.fromByteArray(t.slice(e, r)) | |
} | |
function k(t, e, r) { | |
r = Math.min(t.length, r); | |
for (var n = [], i = e; i < r; ) { | |
var o, s, a, u, c = t[i], f = null, l = c > 239 ? 4 : c > 223 ? 3 : c > 191 ? 2 : 1; | |
if (i + l <= r) | |
switch (l) { | |
case 1: | |
c < 128 && (f = c); | |
break; | |
case 2: | |
128 == (192 & (o = t[i + 1])) && (u = (31 & c) << 6 | 63 & o) > 127 && (f = u); | |
break; | |
case 3: | |
o = t[i + 1], | |
s = t[i + 2], | |
128 == (192 & o) && 128 == (192 & s) && (u = (15 & c) << 12 | (63 & o) << 6 | 63 & s) > 2047 && (u < 55296 || u > 57343) && (f = u); | |
break; | |
case 4: | |
o = t[i + 1], | |
s = t[i + 2], | |
a = t[i + 3], | |
128 == (192 & o) && 128 == (192 & s) && 128 == (192 & a) && (u = (15 & c) << 18 | (63 & o) << 12 | (63 & s) << 6 | 63 & a) > 65535 && u < 1114112 && (f = u) | |
} | |
null === f ? (f = 65533, | |
l = 1) : f > 65535 && (f -= 65536, | |
n.push(f >>> 10 & 1023 | 55296), | |
f = 56320 | 1023 & f), | |
n.push(f), | |
i += l | |
} | |
return function(t) { | |
var e = t.length; | |
if (e <= E) | |
return String.fromCharCode.apply(String, t); | |
var r = "" | |
, n = 0; | |
for (; n < e; ) | |
r += String.fromCharCode.apply(String, t.slice(n, n += E)); | |
return r | |
}(n) | |
} | |
r.kMaxLength = o, | |
a.TYPED_ARRAY_SUPPORT = function() { | |
try { | |
var t = new Uint8Array(1); | |
return t.__proto__ = { | |
__proto__: Uint8Array.prototype, | |
foo: function() { | |
return 42 | |
} | |
}, | |
42 === t.foo() | |
} catch (t) { | |
return !1 | |
} | |
}(), | |
a.TYPED_ARRAY_SUPPORT || "undefined" == typeof console || "function" != typeof console.error || console.error("This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support."), | |
Object.defineProperty(a.prototype, "parent", { | |
enumerable: !0, | |
get: function() { | |
if (a.isBuffer(this)) | |
return this.buffer | |
} | |
}), | |
Object.defineProperty(a.prototype, "offset", { | |
enumerable: !0, | |
get: function() { | |
if (a.isBuffer(this)) | |
return this.byteOffset | |
} | |
}), | |
"undefined" != typeof Symbol && null != Symbol.species && a[Symbol.species] === a && Object.defineProperty(a, Symbol.species, { | |
value: null, | |
configurable: !0, | |
enumerable: !1, | |
writable: !1 | |
}), | |
a.poolSize = 8192, | |
a.from = function(t, e, r) { | |
return u(t, e, r) | |
} | |
, | |
a.prototype.__proto__ = Uint8Array.prototype, | |
a.__proto__ = Uint8Array, | |
a.alloc = function(t, e, r) { | |
return function(t, e, r) { | |
return c(t), | |
t <= 0 ? s(t) : void 0 !== e ? "string" == typeof r ? s(t).fill(e, r) : s(t).fill(e) : s(t) | |
}(t, e, r) | |
} | |
, | |
a.allocUnsafe = function(t) { | |
return f(t) | |
} | |
, | |
a.allocUnsafeSlow = function(t) { | |
return f(t) | |
} | |
, | |
a.isBuffer = function(t) { | |
return null != t && !0 === t._isBuffer && t !== a.prototype | |
} | |
, | |
a.compare = function(t, e) { | |
if (U(t, Uint8Array) && (t = a.from(t, t.offset, t.byteLength)), | |
U(e, Uint8Array) && (e = a.from(e, e.offset, e.byteLength)), | |
!a.isBuffer(t) || !a.isBuffer(e)) | |
throw new TypeError('The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'); | |
if (t === e) | |
return 0; | |
for (var r = t.length, n = e.length, i = 0, o = Math.min(r, n); i < o; ++i) | |
if (t[i] !== e[i]) { | |
r = t[i], | |
n = e[i]; | |
break | |
} | |
return r < n ? -1 : n < r ? 1 : 0 | |
} | |
, | |
a.isEncoding = function(t) { | |
switch (String(t).toLowerCase()) { | |
case "hex": | |
case "utf8": | |
case "utf-8": | |
case "ascii": | |
case "latin1": | |
case "binary": | |
case "base64": | |
case "ucs2": | |
case "ucs-2": | |
case "utf16le": | |
case "utf-16le": | |
return !0; | |
default: | |
return !1 | |
} | |
} | |
, | |
a.concat = function(t, e) { | |
if (!Array.isArray(t)) | |
throw new TypeError('"list" argument must be an Array of Buffers'); | |
if (0 === t.length) | |
return a.alloc(0); | |
var r; | |
if (void 0 === e) | |
for (e = 0, | |
r = 0; r < t.length; ++r) | |
e += t[r].length; | |
var n = a.allocUnsafe(e) | |
, i = 0; | |
for (r = 0; r < t.length; ++r) { | |
var o = t[r]; | |
if (U(o, Uint8Array) && (o = a.from(o)), | |
!a.isBuffer(o)) | |
throw new TypeError('"list" argument must be an Array of Buffers'); | |
o.copy(n, i), | |
i += o.length | |
} | |
return n | |
} | |
, | |
a.byteLength = p, | |
a.prototype._isBuffer = !0, | |
a.prototype.swap16 = function() { | |
var t = this.length; | |
if (t % 2 != 0) | |
throw new RangeError("Buffer size must be a multiple of 16-bits"); | |
for (var e = 0; e < t; e += 2) | |
d(this, e, e + 1); | |
return this | |
} | |
, | |
a.prototype.swap32 = function() { | |
var t = this.length; | |
if (t % 4 != 0) | |
throw new RangeError("Buffer size must be a multiple of 32-bits"); | |
for (var e = 0; e < t; e += 4) | |
d(this, e, e + 3), | |
d(this, e + 1, e + 2); | |
return this | |
} | |
, | |
a.prototype.swap64 = function() { | |
var t = this.length; | |
if (t % 8 != 0) | |
throw new RangeError("Buffer size must be a multiple of 64-bits"); | |
for (var e = 0; e < t; e += 8) | |
d(this, e, e + 7), | |
d(this, e + 1, e + 6), | |
d(this, e + 2, e + 5), | |
d(this, e + 3, e + 4); | |
return this | |
} | |
, | |
a.prototype.toString = function() { | |
var t = this.length; | |
return 0 === t ? "" : 0 === arguments.length ? k(this, 0, t) : function(t, e, r) { | |
var n = !1; | |
if ((void 0 === e || e < 0) && (e = 0), | |
e > this.length) | |
return ""; | |
if ((void 0 === r || r > this.length) && (r = this.length), | |
r <= 0) | |
return ""; | |
if ((r >>>= 0) <= (e >>>= 0)) | |
return ""; | |
for (t || (t = "utf8"); ; ) | |
switch (t) { | |
case "hex": | |
return T(this, e, r); | |
case "utf8": | |
case "utf-8": | |
return k(this, e, r); | |
case "ascii": | |
return A(this, e, r); | |
case "latin1": | |
case "binary": | |
return C(this, e, r); | |
case "base64": | |
return S(this, e, r); | |
case "ucs2": | |
case "ucs-2": | |
case "utf16le": | |
case "utf-16le": | |
return O(this, e, r); | |
default: | |
if (n) | |
throw new TypeError("Unknown encoding: " + t); | |
t = (t + "").toLowerCase(), | |
n = !0 | |
} | |
} | |
.apply(this, arguments) | |
} | |
, | |
a.prototype.toLocaleString = a.prototype.toString, | |
a.prototype.equals = function(t) { | |
if (!a.isBuffer(t)) | |
throw new TypeError("Argument must be a Buffer"); | |
return this === t || 0 === a.compare(this, t) | |
} | |
, | |
a.prototype.inspect = function() { | |
var t = "" | |
, e = r.INSPECT_MAX_BYTES; | |
return t = this.toString("hex", 0, e).replace(/(.{2})/g, "$1 ").trim(), | |
this.length > e && (t += " ... "), | |
"<Buffer " + t + ">" | |
} | |
, | |
a.prototype.compare = function(t, e, r, n, i) { | |
if (U(t, Uint8Array) && (t = a.from(t, t.offset, t.byteLength)), | |
!a.isBuffer(t)) | |
throw new TypeError('The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof t); | |
if (void 0 === e && (e = 0), | |
void 0 === r && (r = t ? t.length : 0), | |
void 0 === n && (n = 0), | |
void 0 === i && (i = this.length), | |
e < 0 || r > t.length || n < 0 || i > this.length) | |
throw new RangeError("out of range index"); | |
if (n >= i && e >= r) | |
return 0; | |
if (n >= i) | |
return -1; | |
if (e >= r) | |
return 1; | |
if (this === t) | |
return 0; | |
for (var o = (i >>>= 0) - (n >>>= 0), s = (r >>>= 0) - (e >>>= 0), u = Math.min(o, s), c = this.slice(n, i), f = t.slice(e, r), l = 0; l < u; ++l) | |
if (c[l] !== f[l]) { | |
o = c[l], | |
s = f[l]; | |
break | |
} | |
return o < s ? -1 : s < o ? 1 : 0 | |
} | |
, | |
a.prototype.includes = function(t, e, r) { | |
return -1 !== this.indexOf(t, e, r) | |
} | |
, | |
a.prototype.indexOf = function(t, e, r) { | |
return y(this, t, e, r, !0) | |
} | |
, | |
a.prototype.lastIndexOf = function(t, e, r) { | |
return y(this, t, e, r, !1) | |
} | |
, | |
a.prototype.write = function(t, e, r, n) { | |
if (void 0 === e) | |
n = "utf8", | |
r = this.length, | |
e = 0; | |
else if (void 0 === r && "string" == typeof e) | |
n = e, | |
r = this.length, | |
e = 0; | |
else { | |
if (!isFinite(e)) | |
throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported"); | |
e >>>= 0, | |
isFinite(r) ? (r >>>= 0, | |
void 0 === n && (n = "utf8")) : (n = r, | |
r = void 0) | |
} | |
var i = this.length - e; | |
if ((void 0 === r || r > i) && (r = i), | |
t.length > 0 && (r < 0 || e < 0) || e > this.length) | |
throw new RangeError("Attempt to write outside buffer bounds"); | |
n || (n = "utf8"); | |
for (var o = !1; ; ) | |
switch (n) { | |
case "hex": | |
return g(this, t, e, r); | |
case "utf8": | |
case "utf-8": | |
return v(this, t, e, r); | |
case "ascii": | |
return b(this, t, e, r); | |
case "latin1": | |
case "binary": | |
return w(this, t, e, r); | |
case "base64": | |
return _(this, t, e, r); | |
case "ucs2": | |
case "ucs-2": | |
case "utf16le": | |
case "utf-16le": | |
return x(this, t, e, r); | |
default: | |
if (o) | |
throw new TypeError("Unknown encoding: " + n); | |
n = ("" + n).toLowerCase(), | |
o = !0 | |
} | |
} | |
, | |
a.prototype.toJSON = function() { | |
return { | |
type: "Buffer", | |
data: Array.prototype.slice.call(this._arr || this, 0) | |
} | |
} | |
; | |
var E = 4096; | |
function A(t, e, r) { | |
var n = ""; | |
r = Math.min(t.length, r); | |
for (var i = e; i < r; ++i) | |
n += String.fromCharCode(127 & t[i]); | |
return n | |
} | |
function C(t, e, r) { | |
var n = ""; | |
r = Math.min(t.length, r); | |
for (var i = e; i < r; ++i) | |
n += String.fromCharCode(t[i]); | |
return n | |
} | |
function T(t, e, r) { | |
var n = t.length; | |
(!e || e < 0) && (e = 0), | |
(!r || r < 0 || r > n) && (r = n); | |
for (var i = "", o = e; o < r; ++o) | |
i += N(t[o]); | |
return i | |
} | |
function O(t, e, r) { | |
for (var n = t.slice(e, r), i = "", o = 0; o < n.length; o += 2) | |
i += String.fromCharCode(n[o] + 256 * n[o + 1]); | |
return i | |
} | |
function B(t, e, r) { | |
if (t % 1 != 0 || t < 0) | |
throw new RangeError("offset is not uint"); | |
if (t + e > r) | |
throw new RangeError("Trying to access beyond buffer length") | |
} | |
function j(t, e, r, n, i, o) { | |
if (!a.isBuffer(t)) | |
throw new TypeError('"buffer" argument must be a Buffer instance'); | |
if (e > i || e < o) | |
throw new RangeError('"value" argument is out of bounds'); | |
if (r + n > t.length) | |
throw new RangeError("Index out of range") | |
} | |
function R(t, e, r, n, i, o) { | |
if (r + n > t.length) | |
throw new RangeError("Index out of range"); | |
if (r < 0) | |
throw new RangeError("Index out of range") | |
} | |
function M(t, e, r, n, o) { | |
return e = +e, | |
r >>>= 0, | |
o || R(t, 0, r, 4), | |
i.write(t, e, r, n, 23, 4), | |
r + 4 | |
} | |
function L(t, e, r, n, o) { | |
return e = +e, | |
r >>>= 0, | |
o || R(t, 0, r, 8), | |
i.write(t, e, r, n, 52, 8), | |
r + 8 | |
} | |
a.prototype.slice = function(t, e) { | |
var r = this.length; | |
(t = ~~t) < 0 ? (t += r) < 0 && (t = 0) : t > r && (t = r), | |
(e = void 0 === e ? r : ~~e) < 0 ? (e += r) < 0 && (e = 0) : e > r && (e = r), | |
e < t && (e = t); | |
var n = this.subarray(t, e); | |
return n.__proto__ = a.prototype, | |
n | |
} | |
, | |
a.prototype.readUIntLE = function(t, e, r) { | |
t >>>= 0, | |
e >>>= 0, | |
r || B(t, e, this.length); | |
for (var n = this[t], i = 1, o = 0; ++o < e && (i *= 256); ) | |
n += this[t + o] * i; | |
return n | |
} | |
, | |
a.prototype.readUIntBE = function(t, e, r) { | |
t >>>= 0, | |
e >>>= 0, | |
r || B(t, e, this.length); | |
for (var n = this[t + --e], i = 1; e > 0 && (i *= 256); ) | |
n += this[t + --e] * i; | |
return n | |
} | |
, | |
a.prototype.readUInt8 = function(t, e) { | |
return t >>>= 0, | |
e || B(t, 1, this.length), | |
this[t] | |
} | |
, | |
a.prototype.readUInt16LE = function(t, e) { | |
return t >>>= 0, | |
e || B(t, 2, this.length), | |
this[t] | this[t + 1] << 8 | |
} | |
, | |
a.prototype.readUInt16BE = function(t, e) { | |
return t >>>= 0, | |
e || B(t, 2, this.length), | |
this[t] << 8 | this[t + 1] | |
} | |
, | |
a.prototype.readUInt32LE = function(t, e) { | |
return t >>>= 0, | |
e || B(t, 4, this.length), | |
(this[t] | this[t + 1] << 8 | this[t + 2] << 16) + 16777216 * this[t + 3] | |
} | |
, | |
a.prototype.readUInt32BE = function(t, e) { | |
return t >>>= 0, | |
e || B(t, 4, this.length), | |
16777216 * this[t] + (this[t + 1] << 16 | this[t + 2] << 8 | this[t + 3]) | |
} | |
, | |
a.prototype.readIntLE = function(t, e, r) { | |
t >>>= 0, | |
e >>>= 0, | |
r || B(t, e, this.length); | |
for (var n = this[t], i = 1, o = 0; ++o < e && (i *= 256); ) | |
n += this[t + o] * i; | |
return n >= (i *= 128) && (n -= Math.pow(2, 8 * e)), | |
n | |
} | |
, | |
a.prototype.readIntBE = function(t, e, r) { | |
t >>>= 0, | |
e >>>= 0, | |
r || B(t, e, this.length); | |
for (var n = e, i = 1, o = this[t + --n]; n > 0 && (i *= 256); ) | |
o += this[t + --n] * i; | |
return o >= (i *= 128) && (o -= Math.pow(2, 8 * e)), | |
o | |
} | |
, | |
a.prototype.readInt8 = function(t, e) { | |
return t >>>= 0, | |
e || B(t, 1, this.length), | |
128 & this[t] ? -1 * (255 - this[t] + 1) : this[t] | |
} | |
, | |
a.prototype.readInt16LE = function(t, e) { | |
t >>>= 0, | |
e || B(t, 2, this.length); | |
var r = this[t] | this[t + 1] << 8; | |
return 32768 & r ? 4294901760 | r : r | |
} | |
, | |
a.prototype.readInt16BE = function(t, e) { | |
t >>>= 0, | |
e || B(t, 2, this.length); | |
var r = this[t + 1] | this[t] << 8; | |
return 32768 & r ? 4294901760 | r : r | |
} | |
, | |
a.prototype.readInt32LE = function(t, e) { | |
return t >>>= 0, | |
e || B(t, 4, this.length), | |
this[t] | this[t + 1] << 8 | this[t + 2] << 16 | this[t + 3] << 24 | |
} | |
, | |
a.prototype.readInt32BE = function(t, e) { | |
return t >>>= 0, | |
e || B(t, 4, this.length), | |
this[t] << 24 | this[t + 1] << 16 | this[t + 2] << 8 | this[t + 3] | |
} | |
, | |
a.prototype.readFloatLE = function(t, e) { | |
return t >>>= 0, | |
e || B(t, 4, this.length), | |
i.read(this, t, !0, 23, 4) | |
} | |
, | |
a.prototype.readFloatBE = function(t, e) { | |
return t >>>= 0, | |
e || B(t, 4, this.length), | |
i.read(this, t, !1, 23, 4) | |
} | |
, | |
a.prototype.readDoubleLE = function(t, e) { | |
return t >>>= 0, | |
e || B(t, 8, this.length), | |
i.read(this, t, !0, 52, 8) | |
} | |
, | |
a.prototype.readDoubleBE = function(t, e) { | |
return t >>>= 0, | |
e || B(t, 8, this.length), | |
i.read(this, t, !1, 52, 8) | |
} | |
, | |
a.prototype.writeUIntLE = function(t, e, r, n) { | |
(t = +t, | |
e >>>= 0, | |
r >>>= 0, | |
n) || j(this, t, e, r, Math.pow(2, 8 * r) - 1, 0); | |
var i = 1 | |
, o = 0; | |
for (this[e] = 255 & t; ++o < r && (i *= 256); ) | |
this[e + o] = t / i & 255; | |
return e + r | |
} | |
, | |
a.prototype.writeUIntBE = function(t, e, r, n) { | |
(t = +t, | |
e >>>= 0, | |
r >>>= 0, | |
n) || j(this, t, e, r, Math.pow(2, 8 * r) - 1, 0); | |
var i = r - 1 | |
, o = 1; | |
for (this[e + i] = 255 & t; --i >= 0 && (o *= 256); ) | |
this[e + i] = t / o & 255; | |
return e + r | |
} | |
, | |
a.prototype.writeUInt8 = function(t, e, r) { | |
return t = +t, | |
e >>>= 0, | |
r || j(this, t, e, 1, 255, 0), | |
this[e] = 255 & t, | |
e + 1 | |
} | |
, | |
a.prototype.writeUInt16LE = function(t, e, r) { | |
return t = +t, | |
e >>>= 0, | |
r || j(this, t, e, 2, 65535, 0), | |
this[e] = 255 & t, | |
this[e + 1] = t >>> 8, | |
e + 2 | |
} | |
, | |
a.prototype.writeUInt16BE = function(t, e, r) { | |
return t = +t, | |
e >>>= 0, | |
r || j(this, t, e, 2, 65535, 0), | |
this[e] = t >>> 8, | |
this[e + 1] = 255 & t, | |
e + 2 | |
} | |
, | |
a.prototype.writeUInt32LE = function(t, e, r) { | |
return t = +t, | |
e >>>= 0, | |
r || j(this, t, e, 4, 4294967295, 0), | |
this[e + 3] = t >>> 24, | |
this[e + 2] = t >>> 16, | |
this[e + 1] = t >>> 8, | |
this[e] = 255 & t, | |
e + 4 | |
} | |
, | |
a.prototype.writeUInt32BE = function(t, e, r) { | |
return t = +t, | |
e >>>= 0, | |
r || j(this, t, e, 4, 4294967295, 0), | |
this[e] = t >>> 24, | |
this[e + 1] = t >>> 16, | |
this[e + 2] = t >>> 8, | |
this[e + 3] = 255 & t, | |
e + 4 | |
} | |
, | |
a.prototype.writeIntLE = function(t, e, r, n) { | |
if (t = +t, | |
e >>>= 0, | |
!n) { | |
var i = Math.pow(2, 8 * r - 1); | |
j(this, t, e, r, i - 1, -i) | |
} | |
var o = 0 | |
, s = 1 | |
, a = 0; | |
for (this[e] = 255 & t; ++o < r && (s *= 256); ) | |
t < 0 && 0 === a && 0 !== this[e + o - 1] && (a = 1), | |
this[e + o] = (t / s >> 0) - a & 255; | |
return e + r | |
} | |
, | |
a.prototype.writeIntBE = function(t, e, r, n) { | |
if (t = +t, | |
e >>>= 0, | |
!n) { | |
var i = Math.pow(2, 8 * r - 1); | |
j(this, t, e, r, i - 1, -i) | |
} | |
var o = r - 1 | |
, s = 1 | |
, a = 0; | |
for (this[e + o] = 255 & t; --o >= 0 && (s *= 256); ) | |
t < 0 && 0 === a && 0 !== this[e + o + 1] && (a = 1), | |
this[e + o] = (t / s >> 0) - a & 255; | |
return e + r | |
} | |
, | |
a.prototype.writeInt8 = function(t, e, r) { | |
return t = +t, | |
e >>>= 0, | |
r || j(this, t, e, 1, 127, -128), | |
t < 0 && (t = 255 + t + 1), | |
this[e] = 255 & t, | |
e + 1 | |
} | |
, | |
a.prototype.writeInt16LE = function(t, e, r) { | |
return t = +t, | |
e >>>= 0, | |
r || j(this, t, e, 2, 32767, -32768), | |
this[e] = 255 & t, | |
this[e + 1] = t >>> 8, | |
e + 2 | |
} | |
, | |
a.prototype.writeInt16BE = function(t, e, r) { | |
return t = +t, | |
e >>>= 0, | |
r || j(this, t, e, 2, 32767, -32768), | |
this[e] = t >>> 8, | |
this[e + 1] = 255 & t, | |
e + 2 | |
} | |
, | |
a.prototype.writeInt32LE = function(t, e, r) { | |
return t = +t, | |
e >>>= 0, | |
r || j(this, t, e, 4, 2147483647, -2147483648), | |
this[e] = 255 & t, | |
this[e + 1] = t >>> 8, | |
this[e + 2] = t >>> 16, | |
this[e + 3] = t >>> 24, | |
e + 4 | |
} | |
, | |
a.prototype.writeInt32BE = function(t, e, r) { | |
return t = +t, | |
e >>>= 0, | |
r || j(this, t, e, 4, 2147483647, -2147483648), | |
t < 0 && (t = 4294967295 + t + 1), | |
this[e] = t >>> 24, | |
this[e + 1] = t >>> 16, | |
this[e + 2] = t >>> 8, | |
this[e + 3] = 255 & t, | |
e + 4 | |
} | |
, | |
a.prototype.writeFloatLE = function(t, e, r) { | |
return M(this, t, e, !0, r) | |
} | |
, | |
a.prototype.writeFloatBE = function(t, e, r) { | |
return M(this, t, e, !1, r) | |
} | |
, | |
a.prototype.writeDoubleLE = function(t, e, r) { | |
return L(this, t, e, !0, r) | |
} | |
, | |
a.prototype.writeDoubleBE = function(t, e, r) { | |
return L(this, t, e, !1, r) | |
} | |
, | |
a.prototype.copy = function(t, e, r, n) { | |
if (!a.isBuffer(t)) | |
throw new TypeError("argument should be a Buffer"); | |
if (r || (r = 0), | |
n || 0 === n || (n = this.length), | |
e >= t.length && (e = t.length), | |
e || (e = 0), | |
n > 0 && n < r && (n = r), | |
n === r) | |
return 0; | |
if (0 === t.length || 0 === this.length) | |
return 0; | |
if (e < 0) | |
throw new RangeError("targetStart out of bounds"); | |
if (r < 0 || r >= this.length) | |
throw new RangeError("Index out of range"); | |
if (n < 0) | |
throw new RangeError("sourceEnd out of bounds"); | |
n > this.length && (n = this.length), | |
t.length - e < n - r && (n = t.length - e + r); | |
var i = n - r; | |
if (this === t && "function" == typeof Uint8Array.prototype.copyWithin) | |
this.copyWithin(e, r, n); | |
else if (this === t && r < e && e < n) | |
for (var o = i - 1; o >= 0; --o) | |
t[o + e] = this[o + r]; | |
else | |
Uint8Array.prototype.set.call(t, this.subarray(r, n), e); | |
return i | |
} | |
, | |
a.prototype.fill = function(t, e, r, n) { | |
if ("string" == typeof t) { | |
if ("string" == typeof e ? (n = e, | |
e = 0, | |
r = this.length) : "string" == typeof r && (n = r, | |
r = this.length), | |
void 0 !== n && "string" != typeof n) | |
throw new TypeError("encoding must be a string"); | |
if ("string" == typeof n && !a.isEncoding(n)) | |
throw new TypeError("Unknown encoding: " + n); | |
if (1 === t.length) { | |
var i = t.charCodeAt(0); | |
("utf8" === n && i < 128 || "latin1" === n) && (t = i) | |
} | |
} else | |
"number" == typeof t && (t &= 255); | |
if (e < 0 || this.length < e || this.length < r) | |
throw new RangeError("Out of range index"); | |
if (r <= e) | |
return this; | |
var o; | |
if (e >>>= 0, | |
r = void 0 === r ? this.length : r >>> 0, | |
t || (t = 0), | |
"number" == typeof t) | |
for (o = e; o < r; ++o) | |
this[o] = t; | |
else { | |
var s = a.isBuffer(t) ? t : a.from(t, n) | |
, u = s.length; | |
if (0 === u) | |
throw new TypeError('The value "' + t + '" is invalid for argument "value"'); | |
for (o = 0; o < r - e; ++o) | |
this[o + e] = s[o % u] | |
} | |
return this | |
} | |
; | |
var I = /[^+\/0-9A-Za-z-_]/g; | |
function N(t) { | |
return t < 16 ? "0" + t.toString(16) : t.toString(16) | |
} | |
function P(t, e) { | |
var r; | |
e = e || 1 / 0; | |
for (var n = t.length, i = null, o = [], s = 0; s < n; ++s) { | |
if ((r = t.charCodeAt(s)) > 55295 && r < 57344) { | |
if (!i) { | |
if (r > 56319) { | |
(e -= 3) > -1 && o.push(239, 191, 189); | |
continue | |
} | |
if (s + 1 === n) { | |
(e -= 3) > -1 && o.push(239, 191, 189); | |
continue | |
} | |
i = r; | |
continue | |
} | |
if (r < 56320) { | |
(e -= 3) > -1 && o.push(239, 191, 189), | |
i = r; | |
continue | |
} | |
r = 65536 + (i - 55296 << 10 | r - 56320) | |
} else | |
i && (e -= 3) > -1 && o.push(239, 191, 189); | |
if (i = null, | |
r < 128) { | |
if ((e -= 1) < 0) | |
break; | |
o.push(r) | |
} else if (r < 2048) { | |
if ((e -= 2) < 0) | |
break; | |
o.push(r >> 6 | 192, 63 & r | 128) | |
} else if (r < 65536) { | |
if ((e -= 3) < 0) | |
break; | |
o.push(r >> 12 | 224, r >> 6 & 63 | 128, 63 & r | 128) | |
} else { | |
if (!(r < 1114112)) | |
throw new Error("Invalid code point"); | |
if ((e -= 4) < 0) | |
break; | |
o.push(r >> 18 | 240, r >> 12 & 63 | 128, r >> 6 & 63 | 128, 63 & r | 128) | |
} | |
} | |
return o | |
} | |
function D(t) { | |
return n.toByteArray(function(t) { | |
if ((t = (t = t.split("=")[0]).trim().replace(I, "")).length < 2) | |
return ""; | |
for (; t.length % 4 != 0; ) | |
t += "="; | |
return t | |
}(t)) | |
} | |
function F(t, e, r, n) { | |
for (var i = 0; i < n && !(i + r >= e.length || i >= t.length); ++i) | |
e[i + r] = t[i]; | |
return i | |
} | |
function U(t, e) { | |
return t instanceof e || null != t && null != t.constructor && null != t.constructor.name && t.constructor.name === e.name | |
} | |
function q(t) { | |
return t != t | |
} | |
} | |
, { | |
"base64-js": 17, | |
ieee754: 24 | |
}], | |
20: [function(t, e, r) { | |
var n = Object.create || function(t) { | |
var e = function() {}; | |
return e.prototype = t, | |
new e | |
} | |
, i = Object.keys || function(t) { | |
var e = []; | |
for (var r in t) | |
Object.prototype.hasOwnProperty.call(t, r) && e.push(r); | |
return r | |
} | |
, o = Function.prototype.bind || function(t) { | |
var e = this; | |
return function() { | |
return e.apply(t, arguments) | |
} | |
} | |
; | |
function s() { | |
this._events && Object.prototype.hasOwnProperty.call(this, "_events") || (this._events = n(null), | |
this._eventsCount = 0), | |
this._maxListeners = this._maxListeners || void 0 | |
} | |
e.exports = s, | |
s.EventEmitter = s, | |
s.prototype._events = void 0, | |
s.prototype._maxListeners = void 0; | |
var a, u = 10; | |
try { | |
var c = {}; | |
Object.defineProperty && Object.defineProperty(c, "x", { | |
value: 0 | |
}), | |
a = 0 === c.x | |
} catch (t) { | |
a = !1 | |
} | |
function f(t) { | |
return void 0 === t._maxListeners ? s.defaultMaxListeners : t._maxListeners | |
} | |
function l(t, e, r, i) { | |
var o, s, a; | |
if ("function" != typeof r) | |
throw new TypeError('"listener" argument must be a function'); | |
if ((s = t._events) ? (s.newListener && (t.emit("newListener", e, r.listener ? r.listener : r), | |
s = t._events), | |
a = s[e]) : (s = t._events = n(null), | |
t._eventsCount = 0), | |
a) { | |
if ("function" == typeof a ? a = s[e] = i ? [r, a] : [a, r] : i ? a.unshift(r) : a.push(r), | |
!a.warned && (o = f(t)) && o > 0 && a.length > o) { | |
a.warned = !0; | |
var u = new Error("Possible EventEmitter memory leak detected. " + a.length + ' "' + String(e) + '" listeners added. Use emitter.setMaxListeners() to increase limit.'); | |
u.name = "MaxListenersExceededWarning", | |
u.emitter = t, | |
u.type = e, | |
u.count = a.length, | |
"object" == typeof console && console.warn && console.warn("%s: %s", u.name, u.message) | |
} | |
} else | |
a = s[e] = r, | |
++t._eventsCount; | |
return t | |
} | |
function h() { | |
if (!this.fired) | |
switch (this.target.removeListener(this.type, this.wrapFn), | |
this.fired = !0, | |
arguments.length) { | |
case 0: | |
return this.listener.call(this.target); | |
case 1: | |
return this.listener.call(this.target, arguments[0]); | |
case 2: | |
return this.listener.call(this.target, arguments[0], arguments[1]); | |
case 3: | |
return this.listener.call(this.target, arguments[0], arguments[1], arguments[2]); | |
default: | |
for (var t = new Array(arguments.length), e = 0; e < t.length; ++e) | |
t[e] = arguments[e]; | |
this.listener.apply(this.target, t) | |
} | |
} | |
function p(t, e, r) { | |
var n = { | |
fired: !1, | |
wrapFn: void 0, | |
target: t, | |
type: e, | |
listener: r | |
} | |
, i = o.call(h, n); | |
return i.listener = r, | |
n.wrapFn = i, | |
i | |
} | |
function d(t, e, r) { | |
var n = t._events; | |
if (!n) | |
return []; | |
var i = n[e]; | |
return i ? "function" == typeof i ? r ? [i.listener || i] : [i] : r ? function(t) { | |
for (var e = new Array(t.length), r = 0; r < e.length; ++r) | |
e[r] = t[r].listener || t[r]; | |
return e | |
}(i) : m(i, i.length) : [] | |
} | |
function y(t) { | |
var e = this._events; | |
if (e) { | |
var r = e[t]; | |
if ("function" == typeof r) | |
return 1; | |
if (r) | |
return r.length | |
} | |
return 0 | |
} | |
function m(t, e) { | |
for (var r = new Array(e), n = 0; n < e; ++n) | |
r[n] = t[n]; | |
return r | |
} | |
a ? Object.defineProperty(s, "defaultMaxListeners", { | |
enumerable: !0, | |
get: function() { | |
return u | |
}, | |
set: function(t) { | |
if ("number" != typeof t || t < 0 || t != t) | |
throw new TypeError('"defaultMaxListeners" must be a positive number'); | |
u = t | |
} | |
}) : s.defaultMaxListeners = u, | |
s.prototype.setMaxListeners = function(t) { | |
if ("number" != typeof t || t < 0 || isNaN(t)) | |
throw new TypeError('"n" argument must be a positive number'); | |
return this._maxListeners = t, | |
this | |
} | |
, | |
s.prototype.getMaxListeners = function() { | |
return f(this) | |
} | |
, | |
s.prototype.emit = function(t) { | |
var e, r, n, i, o, s, a = "error" === t; | |
if (s = this._events) | |
a = a && null == s.error; | |
else if (!a) | |
return !1; | |
if (a) { | |
if (arguments.length > 1 && (e = arguments[1]), | |
e instanceof Error) | |
throw e; | |
var u = new Error('Unhandled "error" event. (' + e + ")"); | |
throw u.context = e, | |
u | |
} | |
if (!(r = s[t])) | |
return !1; | |
var c = "function" == typeof r; | |
switch (n = arguments.length) { | |
case 1: | |
!function(t, e, r) { | |
if (e) | |
t.call(r); | |
else | |
for (var n = t.length, i = m(t, n), o = 0; o < n; ++o) | |
i[o].call(r) | |
}(r, c, this); | |
break; | |
case 2: | |
!function(t, e, r, n) { | |
if (e) | |
t.call(r, n); | |
else | |
for (var i = t.length, o = m(t, i), s = 0; s < i; ++s) | |
o[s].call(r, n) | |
}(r, c, this, arguments[1]); | |
break; | |
case 3: | |
!function(t, e, r, n, i) { | |
if (e) | |
t.call(r, n, i); | |
else | |
for (var o = t.length, s = m(t, o), a = 0; a < o; ++a) | |
s[a].call(r, n, i) | |
}(r, c, this, arguments[1], arguments[2]); | |
break; | |
case 4: | |
!function(t, e, r, n, i, o) { | |
if (e) | |
t.call(r, n, i, o); | |
else | |
for (var s = t.length, a = m(t, s), u = 0; u < s; ++u) | |
a[u].call(r, n, i, o) | |
}(r, c, this, arguments[1], arguments[2], arguments[3]); | |
break; | |
default: | |
for (i = new Array(n - 1), | |
o = 1; o < n; o++) | |
i[o - 1] = arguments[o]; | |
!function(t, e, r, n) { | |
if (e) | |
t.apply(r, n); | |
else | |
for (var i = t.length, o = m(t, i), s = 0; s < i; ++s) | |
o[s].apply(r, n) | |
}(r, c, this, i) | |
} | |
return !0 | |
} | |
, | |
s.prototype.addListener = function(t, e) { | |
return l(this, t, e, !1) | |
} | |
, | |
s.prototype.on = s.prototype.addListener, | |
s.prototype.prependListener = function(t, e) { | |
return l(this, t, e, !0) | |
} | |
, | |
s.prototype.once = function(t, e) { | |
if ("function" != typeof e) | |
throw new TypeError('"listener" argument must be a function'); | |
return this.on(t, p(this, t, e)), | |
this | |
} | |
, | |
s.prototype.prependOnceListener = function(t, e) { | |
if ("function" != typeof e) | |
throw new TypeError('"listener" argument must be a function'); | |
return this.prependListener(t, p(this, t, e)), | |
this | |
} | |
, | |
s.prototype.removeListener = function(t, e) { | |
var r, i, o, s, a; | |
if ("function" != typeof e) | |
throw new TypeError('"listener" argument must be a function'); | |
if (!(i = this._events)) | |
return this; | |
if (!(r = i[t])) | |
return this; | |
if (r === e || r.listener === e) | |
0 == --this._eventsCount ? this._events = n(null) : (delete i[t], | |
i.removeListener && this.emit("removeListener", t, r.listener || e)); | |
else if ("function" != typeof r) { | |
for (o = -1, | |
s = r.length - 1; s >= 0; s--) | |
if (r[s] === e || r[s].listener === e) { | |
a = r[s].listener, | |
o = s; | |
break | |
} | |
if (o < 0) | |
return this; | |
0 === o ? r.shift() : function(t, e) { | |
for (var r = e, n = r + 1, i = t.length; n < i; r += 1, | |
n += 1) | |
t[r] = t[n]; | |
t.pop() | |
}(r, o), | |
1 === r.length && (i[t] = r[0]), | |
i.removeListener && this.emit("removeListener", t, a || e) | |
} | |
return this | |
} | |
, | |
s.prototype.removeAllListeners = function(t) { | |
var e, r, o; | |
if (!(r = this._events)) | |
return this; | |
if (!r.removeListener) | |
return 0 === arguments.length ? (this._events = n(null), | |
this._eventsCount = 0) : r[t] && (0 == --this._eventsCount ? this._events = n(null) : delete r[t]), | |
this; | |
if (0 === arguments.length) { | |
var s, a = i(r); | |
for (o = 0; o < a.length; ++o) | |
"removeListener" !== (s = a[o]) && this.removeAllListeners(s); | |
return this.removeAllListeners("removeListener"), | |
this._events = n(null), | |
this._eventsCount = 0, | |
this | |
} | |
if ("function" == typeof (e = r[t])) | |
this.removeListener(t, e); | |
else if (e) | |
for (o = e.length - 1; o >= 0; o--) | |
this.removeListener(t, e[o]); | |
return this | |
} | |
, | |
s.prototype.listeners = function(t) { | |
return d(this, t, !0) | |
} | |
, | |
s.prototype.rawListeners = function(t) { | |
return d(this, t, !1) | |
} | |
, | |
s.listenerCount = function(t, e) { | |
return "function" == typeof t.listenerCount ? t.listenerCount(e) : y.call(t, e) | |
} | |
, | |
s.prototype.listenerCount = y, | |
s.prototype.eventNames = function() { | |
return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [] | |
} | |
} | |
, {}], | |
21: [function(t, e, r) { | |
(function(t) { | |
function e(t) { | |
return Object.prototype.toString.call(t) | |
} | |
r.isArray = function(t) { | |
return Array.isArray ? Array.isArray(t) : "[object Array]" === e(t) | |
} | |
, | |
r.isBoolean = function(t) { | |
return "boolean" == typeof t | |
} | |
, | |
r.isNull = function(t) { | |
return null === t | |
} | |
, | |
r.isNullOrUndefined = function(t) { | |
return null == t | |
} | |
, | |
r.isNumber = function(t) { | |
return "number" == typeof t | |
} | |
, | |
r.isString = function(t) { | |
return "string" == typeof t | |
} | |
, | |
r.isSymbol = function(t) { | |
return "symbol" == typeof t | |
} | |
, | |
r.isUndefined = function(t) { | |
return void 0 === t | |
} | |
, | |
r.isRegExp = function(t) { | |
return "[object RegExp]" === e(t) | |
} | |
, | |
r.isObject = function(t) { | |
return "object" == typeof t && null !== t | |
} | |
, | |
r.isDate = function(t) { | |
return "[object Date]" === e(t) | |
} | |
, | |
r.isError = function(t) { | |
return "[object Error]" === e(t) || t instanceof Error | |
} | |
, | |
r.isFunction = function(t) { | |
return "function" == typeof t | |
} | |
, | |
r.isPrimitive = function(t) { | |
return null === t || "boolean" == typeof t || "number" == typeof t || "string" == typeof t || "symbol" == typeof t || void 0 === t | |
} | |
, | |
r.isBuffer = t.isBuffer | |
} | |
).call(this, { | |
isBuffer: t("../../is-buffer/index.js") | |
}) | |
} | |
, { | |
"../../is-buffer/index.js": 26 | |
}], | |
22: [function(t, e, r) { | |
var n = t("once") | |
, i = function() {} | |
, o = function(t, e, r) { | |
if ("function" == typeof e) | |
return o(t, null, e); | |
e || (e = {}), | |
r = n(r || i); | |
var s = t._writableState | |
, a = t._readableState | |
, u = e.readable || !1 !== e.readable && t.readable | |
, c = e.writable || !1 !== e.writable && t.writable | |
, f = function() { | |
t.writable || l() | |
} | |
, l = function() { | |
c = !1, | |
u || r.call(t) | |
} | |
, h = function() { | |
u = !1, | |
c || r.call(t) | |
} | |
, p = function(e) { | |
r.call(t, e ? new Error("exited with error code: " + e) : null) | |
} | |
, d = function() { | |
return (!u || a && a.ended) && (!c || s && s.ended) ? void 0 : r.call(t, new Error("premature close")) | |
} | |
, y = function() { | |
t.req.on("finish", l) | |
}; | |
return !function(t) { | |
return t.setHeader && "function" == typeof t.abort | |
}(t) ? c && !s && (t.on("end", f), | |
t.on("close", f)) : (t.on("complete", l), | |
t.on("abort", d), | |
t.req ? y() : t.on("request", y)), | |
function(t) { | |
return t.stdio && Array.isArray(t.stdio) && 3 === t.stdio.length | |
}(t) && t.on("exit", p), | |
t.on("end", h), | |
t.on("finish", l), | |
!1 !== e.error && t.on("error", r), | |
t.on("close", d), | |
function() { | |
t.removeListener("complete", l), | |
t.removeListener("abort", d), | |
t.removeListener("request", y), | |
t.req && t.req.removeListener("finish", l), | |
t.removeListener("end", f), | |
t.removeListener("close", f), | |
t.removeListener("finish", l), | |
t.removeListener("exit", p), | |
t.removeListener("end", h), | |
t.removeListener("error", r), | |
t.removeListener("close", d) | |
} | |
}; | |
e.exports = o | |
} | |
, { | |
once: 39 | |
}], | |
23: [function(t, e, r) { | |
"use strict"; | |
var n, i = "object" == typeof Reflect ? Reflect : null, o = i && "function" == typeof i.apply ? i.apply : function(t, e, r) { | |
return Function.prototype.apply.call(t, e, r) | |
} | |
; | |
n = i && "function" == typeof i.ownKeys ? i.ownKeys : Object.getOwnPropertySymbols ? function(t) { | |
return Object.getOwnPropertyNames(t).concat(Object.getOwnPropertySymbols(t)) | |
} | |
: function(t) { | |
return Object.getOwnPropertyNames(t) | |
} | |
; | |
var s = Number.isNaN || function(t) { | |
return t != t | |
} | |
; | |
function a() { | |
a.init.call(this) | |
} | |
e.exports = a, | |
a.EventEmitter = a, | |
a.prototype._events = void 0, | |
a.prototype._eventsCount = 0, | |
a.prototype._maxListeners = void 0; | |
var u = 10; | |
function c(t) { | |
return void 0 === t._maxListeners ? a.defaultMaxListeners : t._maxListeners | |
} | |
function f(t, e, r, n) { | |
var i, o, s, a; | |
if ("function" != typeof r) | |
throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof r); | |
if (void 0 === (o = t._events) ? (o = t._events = Object.create(null), | |
t._eventsCount = 0) : (void 0 !== o.newListener && (t.emit("newListener", e, r.listener ? r.listener : r), | |
o = t._events), | |
s = o[e]), | |
void 0 === s) | |
s = o[e] = r, | |
++t._eventsCount; | |
else if ("function" == typeof s ? s = o[e] = n ? [r, s] : [s, r] : n ? s.unshift(r) : s.push(r), | |
(i = c(t)) > 0 && s.length > i && !s.warned) { | |
s.warned = !0; | |
var u = new Error("Possible EventEmitter memory leak detected. " + s.length + " " + String(e) + " listeners added. Use emitter.setMaxListeners() to increase limit"); | |
u.name = "MaxListenersExceededWarning", | |
u.emitter = t, | |
u.type = e, | |
u.count = s.length, | |
a = u, | |
console && console.warn && console.warn(a) | |
} | |
return t | |
} | |
function l(t, e, r) { | |
var n = { | |
fired: !1, | |
wrapFn: void 0, | |
target: t, | |
type: e, | |
listener: r | |
} | |
, i = function() { | |
for (var t = [], e = 0; e < arguments.length; e++) | |
t.push(arguments[e]); | |
this.fired || (this.target.removeListener(this.type, this.wrapFn), | |
this.fired = !0, | |
o(this.listener, this.target, t)) | |
} | |
.bind(n); | |
return i.listener = r, | |
n.wrapFn = i, | |
i | |
} | |
function h(t, e, r) { | |
var n = t._events; | |
if (void 0 === n) | |
return []; | |
var i = n[e]; | |
return void 0 === i ? [] : "function" == typeof i ? r ? [i.listener || i] : [i] : r ? function(t) { | |
for (var e = new Array(t.length), r = 0; r < e.length; ++r) | |
e[r] = t[r].listener || t[r]; | |
return e | |
}(i) : d(i, i.length) | |
} | |
function p(t) { | |
var e = this._events; | |
if (void 0 !== e) { | |
var r = e[t]; | |
if ("function" == typeof r) | |
return 1; | |
if (void 0 !== r) | |
return r.length | |
} | |
return 0 | |
} | |
function d(t, e) { | |
for (var r = new Array(e), n = 0; n < e; ++n) | |
r[n] = t[n]; | |
return r | |
} | |
Object.defineProperty(a, "defaultMaxListeners", { | |
enumerable: !0, | |
get: function() { | |
return u | |
}, | |
set: function(t) { | |
if ("number" != typeof t || t < 0 || s(t)) | |
throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + t + "."); | |
u = t | |
} | |
}), | |
a.init = function() { | |
void 0 !== this._events && this._events !== Object.getPrototypeOf(this)._events || (this._events = Object.create(null), | |
this._eventsCount = 0), | |
this._maxListeners = this._maxListeners || void 0 | |
} | |
, | |
a.prototype.setMaxListeners = function(t) { | |
if ("number" != typeof t || t < 0 || s(t)) | |
throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + t + "."); | |
return this._maxListeners = t, | |
this | |
} | |
, | |
a.prototype.getMaxListeners = function() { | |
return c(this) | |
} | |
, | |
a.prototype.emit = function(t) { | |
for (var e = [], r = 1; r < arguments.length; r++) | |
e.push(arguments[r]); | |
var n = "error" === t | |
, i = this._events; | |
if (void 0 !== i) | |
n = n && void 0 === i.error; | |
else if (!n) | |
return !1; | |
if (n) { | |
var s; | |
if (e.length > 0 && (s = e[0]), | |
s instanceof Error) | |
throw s; | |
var a = new Error("Unhandled error." + (s ? " (" + s.message + ")" : "")); | |
throw a.context = s, | |
a | |
} | |
var u = i[t]; | |
if (void 0 === u) | |
return !1; | |
if ("function" == typeof u) | |
o(u, this, e); | |
else { | |
var c = u.length | |
, f = d(u, c); | |
for (r = 0; r < c; ++r) | |
o(f[r], this, e) | |
} | |
return !0 | |
} | |
, | |
a.prototype.addListener = function(t, e) { | |
return f(this, t, e, !1) | |
} | |
, | |
a.prototype.on = a.prototype.addListener, | |
a.prototype.prependListener = function(t, e) { | |
return f(this, t, e, !0) | |
} | |
, | |
a.prototype.once = function(t, e) { | |
if ("function" != typeof e) | |
throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof e); | |
return this.on(t, l(this, t, e)), | |
this | |
} | |
, | |
a.prototype.prependOnceListener = function(t, e) { | |
if ("function" != typeof e) | |
throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof e); | |
return this.prependListener(t, l(this, t, e)), | |
this | |
} | |
, | |
a.prototype.removeListener = function(t, e) { | |
var r, n, i, o, s; | |
if ("function" != typeof e) | |
throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof e); | |
if (void 0 === (n = this._events)) | |
return this; | |
if (void 0 === (r = n[t])) | |
return this; | |
if (r === e || r.listener === e) | |
0 == --this._eventsCount ? this._events = Object.create(null) : (delete n[t], | |
n.removeListener && this.emit("removeListener", t, r.listener || e)); | |
else if ("function" != typeof r) { | |
for (i = -1, | |
o = r.length - 1; o >= 0; o--) | |
if (r[o] === e || r[o].listener === e) { | |
s = r[o].listener, | |
i = o; | |
break | |
} | |
if (i < 0) | |
return this; | |
0 === i ? r.shift() : function(t, e) { | |
for (; e + 1 < t.length; e++) | |
t[e] = t[e + 1]; | |
t.pop() | |
}(r, i), | |
1 === r.length && (n[t] = r[0]), | |
void 0 !== n.removeListener && this.emit("removeListener", t, s || e) | |
} | |
return this | |
} | |
, | |
a.prototype.off = a.prototype.removeListener, | |
a.prototype.removeAllListeners = function(t) { | |
var e, r, n; | |
if (void 0 === (r = this._events)) | |
return this; | |
if (void 0 === r.removeListener) | |
return 0 === arguments.length ? (this._events = Object.create(null), | |
this._eventsCount = 0) : void 0 !== r[t] && (0 == --this._eventsCount ? this._events = Object.create(null) : delete r[t]), | |
this; | |
if (0 === arguments.length) { | |
var i, o = Object.keys(r); | |
for (n = 0; n < o.length; ++n) | |
"removeListener" !== (i = o[n]) && this.removeAllListeners(i); | |
return this.removeAllListeners("removeListener"), | |
this._events = Object.create(null), | |
this._eventsCount = 0, | |
this | |
} | |
if ("function" == typeof (e = r[t])) | |
this.removeListener(t, e); | |
else if (void 0 !== e) | |
for (n = e.length - 1; n >= 0; n--) | |
this.removeListener(t, e[n]); | |
return this | |
} | |
, | |
a.prototype.listeners = function(t) { | |
return h(this, t, !0) | |
} | |
, | |
a.prototype.rawListeners = function(t) { | |
return h(this, t, !1) | |
} | |
, | |
a.listenerCount = function(t, e) { | |
return "function" == typeof t.listenerCount ? t.listenerCount(e) : p.call(t, e) | |
} | |
, | |
a.prototype.listenerCount = p, | |
a.prototype.eventNames = function() { | |
return this._eventsCount > 0 ? n(this._events) : [] | |
} | |
} | |
, {}], | |
24: [function(t, e, r) { | |
r.read = function(t, e, r, n, i) { | |
var o, s, a = 8 * i - n - 1, u = (1 << a) - 1, c = u >> 1, f = -7, l = r ? i - 1 : 0, h = r ? -1 : 1, p = t[e + l]; | |
for (l += h, | |
o = p & (1 << -f) - 1, | |
p >>= -f, | |
f += a; f > 0; o = 256 * o + t[e + l], | |
l += h, | |
f -= 8) | |
; | |
for (s = o & (1 << -f) - 1, | |
o >>= -f, | |
f += n; f > 0; s = 256 * s + t[e + l], | |
l += h, | |
f -= 8) | |
; | |
if (0 === o) | |
o = 1 - c; | |
else { | |
if (o === u) | |
return s ? NaN : 1 / 0 * (p ? -1 : 1); | |
s += Math.pow(2, n), | |
o -= c | |
} | |
return (p ? -1 : 1) * s * Math.pow(2, o - n) | |
} | |
, | |
r.write = function(t, e, r, n, i, o) { | |
var s, a, u, c = 8 * o - i - 1, f = (1 << c) - 1, l = f >> 1, h = 23 === i ? Math.pow(2, -24) - Math.pow(2, -77) : 0, p = n ? 0 : o - 1, d = n ? 1 : -1, y = e < 0 || 0 === e && 1 / e < 0 ? 1 : 0; | |
for (e = Math.abs(e), | |
isNaN(e) || e === 1 / 0 ? (a = isNaN(e) ? 1 : 0, | |
s = f) : (s = Math.floor(Math.log(e) / Math.LN2), | |
e * (u = Math.pow(2, -s)) < 1 && (s--, | |
u *= 2), | |
(e += s + l >= 1 ? h / u : h * Math.pow(2, 1 - l)) * u >= 2 && (s++, | |
u /= 2), | |
s + l >= f ? (a = 0, | |
s = f) : s + l >= 1 ? (a = (e * u - 1) * Math.pow(2, i), | |
s += l) : (a = e * Math.pow(2, l - 1) * Math.pow(2, i), | |
s = 0)); i >= 8; t[r + p] = 255 & a, | |
p += d, | |
a /= 256, | |
i -= 8) | |
; | |
for (s = s << i | a, | |
c += i; c > 0; t[r + p] = 255 & s, | |
p += d, | |
s /= 256, | |
c -= 8) | |
; | |
t[r + p - d] |= 128 * y | |
} | |
} | |
, {}], | |
25: [function(t, e, r) { | |
"function" == typeof Object.create ? e.exports = function(t, e) { | |
e && (t.super_ = e, | |
t.prototype = Object.create(e.prototype, { | |
constructor: { | |
value: t, | |
enumerable: !1, | |
writable: !0, | |
configurable: !0 | |
} | |
})) | |
} | |
: e.exports = function(t, e) { | |
if (e) { | |
t.super_ = e; | |
var r = function() {}; | |
r.prototype = e.prototype, | |
t.prototype = new r, | |
t.prototype.constructor = t | |
} | |
} | |
} | |
, {}], | |
26: [function(t, e, r) { | |
function n(t) { | |
return !!t.constructor && "function" == typeof t.constructor.isBuffer && t.constructor.isBuffer(t) | |
} | |
e.exports = function(t) { | |
return null != t && (n(t) || function(t) { | |
return "function" == typeof t.readFloatLE && "function" == typeof t.slice && n(t.slice(0, 0)) | |
}(t) || !!t._isBuffer) | |
} | |
} | |
, {}], | |
27: [function(t, e, r) { | |
var n = {}.toString; | |
e.exports = Array.isArray || function(t) { | |
return "[object Array]" == n.call(t) | |
} | |
} | |
, {}], | |
28: [function(t, e, r) { | |
const n = t("safe-event-emitter") | |
, i = t("readable-stream").Duplex; | |
e.exports = function() { | |
const t = {} | |
, e = new i({ | |
objectMode: !0, | |
read: function() { | |
return !1 | |
}, | |
write: function(e, n, i) { | |
let o; | |
try { | |
const n = !e.id; | |
n ? function(t) { | |
r.emit("notification", t) | |
}(e) : function(e) { | |
const r = t[e.id]; | |
if (!r) | |
throw new Error(`StreamMiddleware - Unknown response id ${e.id}`); | |
delete t[e.id], | |
Object.assign(r.res, e), | |
setTimeout(r.end) | |
}(e) | |
} catch (t) { | |
o = t | |
} | |
i(o) | |
} | |
}) | |
, r = new n; | |
return { | |
events: r, | |
middleware: (r,n,i,o)=>{ | |
e.push(r), | |
t[r.id] = { | |
req: r, | |
res: n, | |
next: i, | |
end: o | |
} | |
} | |
, | |
stream: e | |
} | |
} | |
} | |
, { | |
"readable-stream": 56, | |
"safe-event-emitter": 59 | |
}], | |
29: [function(t, e, r) { | |
!function(t, r) { | |
"use strict"; | |
"function" == typeof define && define.amd ? define(r) : "object" == typeof e && e.exports ? e.exports = r() : t.log = r() | |
}(this, function() { | |
"use strict"; | |
var t = function() {} | |
, e = "undefined" | |
, r = ["trace", "debug", "info", "warn", "error"]; | |
function n(t, e) { | |
var r = t[e]; | |
if ("function" == typeof r.bind) | |
return r.bind(t); | |
try { | |
return Function.prototype.bind.call(r, t) | |
} catch (e) { | |
return function() { | |
return Function.prototype.apply.apply(r, [t, arguments]) | |
} | |
} | |
} | |
function i(e, n) { | |
for (var i = 0; i < r.length; i++) { | |
var o = r[i]; | |
this[o] = i < e ? t : this.methodFactory(o, e, n) | |
} | |
this.log = this.debug | |
} | |
function o(r, o, s) { | |
return function(r) { | |
return "debug" === r && (r = "log"), | |
typeof console !== e && (void 0 !== console[r] ? n(console, r) : void 0 !== console.log ? n(console, "log") : t) | |
}(r) || function(t, r, n) { | |
return function() { | |
typeof console !== e && (i.call(this, r, n), | |
this[t].apply(this, arguments)) | |
} | |
} | |
.apply(this, arguments) | |
} | |
function s(t, n, s) { | |
var a, u = this, c = "loglevel"; | |
function f() { | |
var t; | |
if (typeof window !== e) { | |
try { | |
t = window.localStorage[c] | |
} catch (t) {} | |
if (typeof t === e) | |
try { | |
var r = window.document.cookie | |
, n = r.indexOf(encodeURIComponent(c) + "="); | |
-1 !== n && (t = /^([^;]+)/.exec(r.slice(n))[1]) | |
} catch (t) {} | |
return void 0 === u.levels[t] && (t = void 0), | |
t | |
} | |
} | |
t && (c += ":" + t), | |
u.name = t, | |
u.levels = { | |
TRACE: 0, | |
DEBUG: 1, | |
INFO: 2, | |
WARN: 3, | |
ERROR: 4, | |
SILENT: 5 | |
}, | |
u.methodFactory = s || o, | |
u.getLevel = function() { | |
return a | |
} | |
, | |
u.setLevel = function(n, o) { | |
if ("string" == typeof n && void 0 !== u.levels[n.toUpperCase()] && (n = u.levels[n.toUpperCase()]), | |
!("number" == typeof n && n >= 0 && n <= u.levels.SILENT)) | |
throw "log.setLevel() called with invalid level: " + n; | |
if (a = n, | |
!1 !== o && function(t) { | |
var n = (r[t] || "silent").toUpperCase(); | |
if (typeof window !== e) { | |
try { | |
return void (window.localStorage[c] = n) | |
} catch (t) {} | |
try { | |
window.document.cookie = encodeURIComponent(c) + "=" + n + ";" | |
} catch (t) {} | |
} | |
}(n), | |
i.call(u, n, t), | |
typeof console === e && n < u.levels.SILENT) | |
return "No console available for logging" | |
} | |
, | |
u.setDefaultLevel = function(t) { | |
f() || u.setLevel(t, !1) | |
} | |
, | |
u.enableAll = function(t) { | |
u.setLevel(u.levels.TRACE, t) | |
} | |
, | |
u.disableAll = function(t) { | |
u.setLevel(u.levels.SILENT, t) | |
} | |
; | |
var l = f(); | |
null == l && (l = null == n ? "WARN" : n), | |
u.setLevel(l, !1) | |
} | |
var a = new s | |
, u = {}; | |
a.getLogger = function(t) { | |
if ("string" != typeof t || "" === t) | |
throw new TypeError("You must supply a name when creating a logger."); | |
var e = u[t]; | |
return e || (e = u[t] = new s(t,a.getLevel(),a.methodFactory)), | |
e | |
} | |
; | |
var c = typeof window !== e ? window.log : void 0; | |
return a.noConflict = function() { | |
return typeof window !== e && window.log === a && (window.log = c), | |
a | |
} | |
, | |
a.getLoggers = function() { | |
return u | |
} | |
, | |
a | |
}) | |
} | |
, {}], | |
30: [function(t, e, r) { | |
const n = t("loglevel") | |
, i = { | |
1: "An unauthorized action was attempted.", | |
2: "A disallowed action was attempted.", | |
3: "An execution error occurred.", | |
[-32600]: "The JSON sent is not a valid Request object.", | |
[-32601]: "The method does not exist / is not available.", | |
[-32602]: "Invalid method parameter(s).", | |
[-32603]: "Internal JSON-RPC error.", | |
[-32700]: "Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text.", | |
internal: "Internal server error.", | |
unknown: "Unknown JSON-RPC error." | |
}; | |
e.exports = function({override: t=!0}={}) { | |
return (t,e,r)=>{ | |
r(t=>{ | |
const {error: r} = e; | |
if (!r) | |
return t(); | |
!function(t, e) { | |
if (t.message && !e) | |
return t; | |
const r = t.code > -31099 && t.code < -32100 ? i.internal : i[t.code]; | |
t.message = r || i.unknown | |
}(r), | |
n.error(`MetaMask - RPC Error: ${r.message}`, r), | |
t() | |
} | |
) | |
} | |
} | |
} | |
, { | |
loglevel: 35 | |
}], | |
31: [function(t, e, r) { | |
const n = t("pump") | |
, i = t("json-rpc-engine") | |
, o = t("./createErrorMiddleware") | |
, s = t("json-rpc-engine/src/idRemapMiddleware") | |
, a = t("json-rpc-middleware-stream") | |
, u = t("obs-store") | |
, c = t("obs-store/lib/asStream") | |
, f = t("obj-multiplex") | |
, l = t("util") | |
, h = t("safe-event-emitter"); | |
function MetamaskInpageProvider(t) { | |
const e = this; | |
e.selectedAddress = void 0, | |
e.networkVersion = void 0, | |
h.call(e); | |
const r = e.mux = new f; | |
n(t, r, t, p.bind(this, "MetaMask")), | |
e.publicConfigStore = new u({ | |
storageKey: "MetaMask-Config" | |
}), | |
e.publicConfigStore.subscribe(function(t) { | |
"selectedAddress"in t && t.selectedAddress !== e.selectedAddress && (e.selectedAddress = t.selectedAddress, | |
e.emit("accountsChanged", [e.selectedAddress])), | |
"networkVersion"in t && t.networkVersion !== e.networkVersion && (e.networkVersion = t.networkVersion, | |
e.emit("networkChanged", t.networkVersion)) | |
}), | |
n(r.createStream("publicConfig"), c(e.publicConfigStore), p.bind(this, "MetaMask PublicConfigStore")), | |
r.ignoreStream("phishing"); | |
const l = a(); | |
n(l.stream, r.createStream("provider"), l.stream, p.bind(this, "MetaMask RpcProvider")); | |
const d = new i; | |
d.push(s()), | |
d.push(o()), | |
d.push(l.middleware), | |
e.rpcEngine = d, | |
l.events.on("notification", function(t) { | |
e.emit("data", null, t) | |
}), | |
e.send = e.send.bind(e), | |
e.sendAsync = e.sendAsync.bind(e) | |
} | |
function p(t, e) { | |
let r = `MetamaskInpageProvider - lost connection to ${t}`; | |
e && (r += "\n" + e.stack), | |
console.warn(r), | |
this.listenerCount("error") > 0 && this.emit("error", r) | |
} | |
function d() {} | |
e.exports = MetamaskInpageProvider, | |
l.inherits(MetamaskInpageProvider, h), | |
MetamaskInpageProvider.prototype.send = function(t, e) { | |
const r = this; | |
if (!e) | |
return r._sendSync(t); | |
r.sendAsync(t, e) | |
} | |
, | |
MetamaskInpageProvider.prototype.sendAsync = function(t, e) { | |
"eth_signTypedData" === t.method && console.warn("MetaMask: This experimental version of eth_signTypedData will be deprecated in the next release in favor of the standard as defined in EIP-712. See https://git.io/fNzPl for more information on the new standard."), | |
this.rpcEngine.handle(t, e) | |
} | |
, | |
MetamaskInpageProvider.prototype._sendSync = function(t) { | |
const e = this; | |
let r, n = null; | |
switch (t.method) { | |
case "eth_accounts": | |
n = (r = e.publicConfigStore.getState().selectedAddress) ? [r] : []; | |
break; | |
case "eth_coinbase": | |
n = (r = e.publicConfigStore.getState().selectedAddress) || null; | |
break; | |
case "eth_uninstallFilter": | |
e.sendAsync(t, d), | |
n = !0; | |
break; | |
case "net_version": | |
n = e.publicConfigStore.getState().networkVersion || null; | |
break; | |
default: | |
var i = `The MetaMask Web3 object does not support synchronous methods like ${t.method} without a callback parameter. See https://github.com/MetaMask/faq/blob/master/DEVELOPERS.md#dizzy-all-async---think-of-metamask-as-a-light-client for details.`; | |
throw new Error(i) | |
} | |
return { | |
id: t.id, | |
jsonrpc: t.jsonrpc, | |
result: n | |
} | |
} | |
, | |
MetamaskInpageProvider.prototype.isConnected = function() { | |
return !0 | |
} | |
, | |
MetamaskInpageProvider.prototype.isMetaMask = !0 | |
} | |
, { | |
"./createErrorMiddleware": 30, | |
"json-rpc-engine": 34, | |
"json-rpc-engine/src/idRemapMiddleware": 33, | |
"json-rpc-middleware-stream": 28, | |
"obj-multiplex": 38, | |
"obs-store": 36, | |
"obs-store/lib/asStream": 37, | |
pump: 43, | |
"safe-event-emitter": 59, | |
util: 66 | |
}], | |
32: [function(t, e, r) { | |
"use strict"; | |
var n = 4294967295 | |
, i = Math.floor(Math.random() * n); | |
e.exports = function() { | |
return i = (i + 1) % n | |
} | |
} | |
, {}], | |
33: [function(t, e, r) { | |
"use strict"; | |
var n = t("./getUniqueId"); | |
e.exports = function() { | |
return function(t, e, r, i) { | |
var o = t.id | |
, s = n(); | |
t.id = s, | |
e.id = s, | |
r(function(r) { | |
t.id = o, | |
e.id = o, | |
r() | |
}) | |
} | |
} | |
} | |
, { | |
"./getUniqueId": 32 | |
}], | |
34: [function(t, e, r) { | |
"use strict"; | |
var n = t("@babel/runtime/helpers/interopRequireDefault") | |
, i = n(t("@babel/runtime/helpers/classCallCheck")) | |
, o = n(t("@babel/runtime/helpers/createClass")) | |
, s = n(t("@babel/runtime/helpers/possibleConstructorReturn")) | |
, a = n(t("@babel/runtime/helpers/getPrototypeOf")) | |
, u = n(t("@babel/runtime/helpers/inherits")) | |
, c = t("async") | |
, f = function(t) { | |
function e() { | |
var t; | |
return (0, | |
i.default)(this, e), | |
(t = (0, | |
s.default)(this, (0, | |
a.default)(e).call(this)))._middleware = [], | |
t | |
} | |
return (0, | |
u.default)(e, t), | |
(0, | |
o.default)(e, [{ | |
key: "push", | |
value: function(t) { | |
this._middleware.push(t) | |
} | |
}, { | |
key: "handle", | |
value: function(t, e) { | |
Array.isArray(t) ? c.map(t, this._handle.bind(this), e) : this._handle(t, e) | |
} | |
}, { | |
key: "_handle", | |
value: function(t, e) { | |
var r = Object.assign({}, t) | |
, n = { | |
id: r.id, | |
jsonrpc: r.jsonrpc | |
}; | |
this._runMiddleware(r, n, function(t) { | |
var r = n._originalError; | |
if (delete n._originalError, | |
r) | |
return delete n.result, | |
e(r, n); | |
e(t, n) | |
}) | |
} | |
}, { | |
key: "_runMiddleware", | |
value: function(t, e, r) { | |
var n = this; | |
c.waterfall([function(r) { | |
return n._runMiddlewareDown(t, e, r) | |
} | |
, function(r, n) { | |
var i = r.isComplete | |
, o = r.returnHandlers; | |
if (!("result"in e || "error"in e)) { | |
var s = JSON.stringify(t, null, 2) | |
, a = "JsonRpcEngine - response has no error or result for request:\n" + s; | |
return n(new Error(a)) | |
} | |
if (!i) { | |
var u = JSON.stringify(t, null, 2) | |
, c = "JsonRpcEngine - nothing ended request:\n" + u; | |
return n(new Error(c)) | |
} | |
return n(null, o) | |
} | |
, function(t, e) { | |
return n._runReturnHandlersUp(t, e) | |
} | |
], r) | |
} | |
}, { | |
key: "_runMiddlewareDown", | |
value: function(t, e, r) { | |
var n = [] | |
, i = !1; | |
c.mapSeries(this._middleware, function(r, o) { | |
if (i) | |
return o(); | |
r(t, e, function(t) { | |
n.push(t), | |
o() | |
}, function(t) { | |
t && (e.error = l(t), | |
e._originalError = t); | |
i = !0, | |
o() | |
}) | |
}, function(t) { | |
if (t) | |
return e.error = l(t), | |
r(t, e); | |
var o = n.filter(Boolean).reverse(); | |
r(null, { | |
isComplete: i, | |
returnHandlers: o | |
}) | |
}) | |
} | |
}, { | |
key: "_runReturnHandlersUp", | |
value: function(t, e) { | |
c.eachSeries(t, function(t, e) { | |
return t(e) | |
}, e) | |
} | |
}]), | |
e | |
}(t("safe-event-emitter")); | |
function l(t) { | |
return { | |
code: t.code || -32603, | |
message: t.stack | |
} | |
} | |
e.exports = f | |
} | |
, { | |
"@babel/runtime/helpers/classCallCheck": 5, | |
"@babel/runtime/helpers/createClass": 6, | |
"@babel/runtime/helpers/getPrototypeOf": 9, | |
"@babel/runtime/helpers/inherits": 10, | |
"@babel/runtime/helpers/interopRequireDefault": 11, | |
"@babel/runtime/helpers/possibleConstructorReturn": 12, | |
async: 16, | |
"safe-event-emitter": 59 | |
}], | |
35: [function(t, e, r) { | |
arguments[4][29][0].apply(r, arguments) | |
} | |
, { | |
dup: 29 | |
}], | |
36: [function(t, e, r) { | |
"use strict"; | |
var n = t("@babel/runtime/helpers/interopRequireDefault") | |
, i = n(t("@babel/runtime/helpers/typeof")) | |
, o = n(t("@babel/runtime/helpers/classCallCheck")) | |
, s = n(t("@babel/runtime/helpers/createClass")) | |
, a = n(t("@babel/runtime/helpers/possibleConstructorReturn")) | |
, u = n(t("@babel/runtime/helpers/getPrototypeOf")) | |
, c = n(t("@babel/runtime/helpers/inherits")) | |
, f = (t("xtend"), | |
function(t) { | |
function e() { | |
var t, r = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {}; | |
return (0, | |
o.default)(this, e), | |
(t = (0, | |
a.default)(this, (0, | |
u.default)(e).call(this)))._state = r, | |
t | |
} | |
return (0, | |
c.default)(e, t), | |
(0, | |
s.default)(e, [{ | |
key: "getState", | |
value: function() { | |
return this._getState() | |
} | |
}, { | |
key: "putState", | |
value: function(t) { | |
this._putState(t), | |
this.emit("update", t) | |
} | |
}, { | |
key: "updateState", | |
value: function(t) { | |
if (t && "object" === (0, | |
i.default)(t)) { | |
var e = this.getState() | |
, r = Object.assign({}, e, t); | |
this.putState(r) | |
} else | |
this.putState(t) | |
} | |
}, { | |
key: "subscribe", | |
value: function(t) { | |
this.on("update", t) | |
} | |
}, { | |
key: "unsubscribe", | |
value: function(t) { | |
this.removeListener("update", t) | |
} | |
}, { | |
key: "_getState", | |
value: function() { | |
return this._state | |
} | |
}, { | |
key: "_putState", | |
value: function(t) { | |
this._state = t | |
} | |
}]), | |
e | |
}(t("safe-event-emitter"))); | |
e.exports = f | |
} | |
, { | |
"@babel/runtime/helpers/classCallCheck": 5, | |
"@babel/runtime/helpers/createClass": 6, | |
"@babel/runtime/helpers/getPrototypeOf": 9, | |
"@babel/runtime/helpers/inherits": 10, | |
"@babel/runtime/helpers/interopRequireDefault": 11, | |
"@babel/runtime/helpers/possibleConstructorReturn": 12, | |
"@babel/runtime/helpers/typeof": 15, | |
"safe-event-emitter": 59, | |
xtend: 69 | |
}], | |
37: [function(t, e, r) { | |
"use strict"; | |
var n = t("@babel/runtime/helpers/interopRequireDefault") | |
, i = n(t("@babel/runtime/helpers/classCallCheck")) | |
, o = n(t("@babel/runtime/helpers/createClass")) | |
, s = n(t("@babel/runtime/helpers/possibleConstructorReturn")) | |
, a = n(t("@babel/runtime/helpers/getPrototypeOf")) | |
, u = n(t("@babel/runtime/helpers/get")) | |
, c = n(t("@babel/runtime/helpers/inherits")) | |
, f = t("stream").Duplex; | |
e.exports = function(t) { | |
return new l(t) | |
} | |
; | |
var l = function(t) { | |
function e(t) { | |
var r; | |
return (0, | |
i.default)(this, e), | |
(r = (0, | |
s.default)(this, (0, | |
a.default)(e).call(this, { | |
objectMode: !0 | |
}))).resume(), | |
r.handler = function(t) { | |
return r.push(t) | |
} | |
, | |
r.obsStore = t, | |
r.obsStore.subscribe(r.handler), | |
r | |
} | |
return (0, | |
c.default)(e, t), | |
(0, | |
o.default)(e, [{ | |
key: "pipe", | |
value: function(t, e) { | |
var r = f.prototype.pipe.call(this, t, e); | |
return t.write(this.obsStore.getState()), | |
r | |
} | |
}, { | |
key: "_write", | |
value: function(t, e, r) { | |
this.obsStore.putState(t), | |
r() | |
} | |
}, { | |
key: "_read", | |
value: function(t) {} | |
}, { | |
key: "_destroy", | |
value: function(t, r) { | |
this.obsStore.unsubscribe(this.handler), | |
(0, | |
u.default)((0, | |
a.default)(e.prototype), "_destroy", this).call(this, t, r) | |
} | |
}]), | |
e | |
}(f) | |
} | |
, { | |
"@babel/runtime/helpers/classCallCheck": 5, | |
"@babel/runtime/helpers/createClass": 6, | |
"@babel/runtime/helpers/get": 8, | |
"@babel/runtime/helpers/getPrototypeOf": 9, | |
"@babel/runtime/helpers/inherits": 10, | |
"@babel/runtime/helpers/interopRequireDefault": 11, | |
"@babel/runtime/helpers/possibleConstructorReturn": 12, | |
stream: 60 | |
}], | |
38: [function(t, e, r) { | |
const {Duplex: n} = t("readable-stream") | |
, i = t("end-of-stream") | |
, o = t("once") | |
, s = {}; | |
class a extends n { | |
constructor({parent: t, name: e}) { | |
super({ | |
objectMode: !0 | |
}), | |
this._parent = t, | |
this._name = e | |
} | |
_read() {} | |
_write(t, e, r) { | |
this._parent.push({ | |
name: this._name, | |
data: t | |
}), | |
r() | |
} | |
} | |
e.exports = class extends n { | |
constructor(t={}) { | |
super(Object.assign({}, t, { | |
objectMode: !0 | |
})), | |
this._substreams = {} | |
} | |
createStream(t) { | |
if (!t) | |
throw new Error("ObjectMultiplex - name must not be empty"); | |
if (this._substreams[t]) | |
throw new Error('ObjectMultiplex - Substream for name "${name}" already exists'); | |
const e = new a({ | |
parent: this, | |
name: t | |
}); | |
return this._substreams[t] = e, | |
function(t, e) { | |
const r = o(e); | |
i(t, { | |
readable: !1 | |
}, r), | |
i(t, { | |
writable: !1 | |
}, r) | |
}(this, t=>{ | |
e.destroy(t) | |
} | |
), | |
e | |
} | |
ignoreStream(t) { | |
if (!t) | |
throw new Error("ObjectMultiplex - name must not be empty"); | |
if (this._substreams[t]) | |
throw new Error('ObjectMultiplex - Substream for name "${name}" already exists'); | |
this._substreams[t] = s | |
} | |
_read() {} | |
_write(t, e, r) { | |
const n = t.name | |
, i = t.data; | |
if (!n) | |
return console.warn(`ObjectMultiplex - malformed chunk without name "${t}"`), | |
r(); | |
const o = this._substreams[n]; | |
if (!o) | |
return console.warn(`ObjectMultiplex - orphaned data for stream "${n}"`), | |
r(); | |
o !== s && o.push(i), | |
r() | |
} | |
} | |
} | |
, { | |
"end-of-stream": 22, | |
once: 39, | |
"readable-stream": 56 | |
}], | |
39: [function(t, e, r) { | |
var n = t("wrappy"); | |
function i(t) { | |
var e = function() { | |
return e.called ? e.value : (e.called = !0, | |
e.value = t.apply(this, arguments)) | |
}; | |
return e.called = !1, | |
e | |
} | |
function o(t) { | |
var e = function() { | |
if (e.called) | |
throw new Error(e.onceError); | |
return e.called = !0, | |
e.value = t.apply(this, arguments) | |
} | |
, r = t.name || "Function wrapped with `once`"; | |
return e.onceError = r + " shouldn't be called more than once", | |
e.called = !1, | |
e | |
} | |
e.exports = n(i), | |
e.exports.strict = n(o), | |
i.proto = i(function() { | |
Object.defineProperty(Function.prototype, "once", { | |
value: function() { | |
return i(this) | |
}, | |
configurable: !0 | |
}), | |
Object.defineProperty(Function.prototype, "onceStrict", { | |
value: function() { | |
return o(this) | |
}, | |
configurable: !0 | |
}) | |
}) | |
} | |
, { | |
wrappy: 68 | |
}], | |
40: [function(t, e, r) { | |
const n = t("readable-stream").Duplex | |
, i = t("util").inherits; | |
function o(t) { | |
n.call(this, { | |
objectMode: !0 | |
}), | |
this._name = t.name, | |
this._target = t.target, | |
this._targetWindow = t.targetWindow || window, | |
this._origin = t.targetWindow ? "*" : location.origin, | |
this._init = !1, | |
this._haveSyn = !1, | |
window.addEventListener("message", this._onMessage.bind(this), !1), | |
this._write("SYN", null, s), | |
this.cork() | |
} | |
function s() {} | |
e.exports = o, | |
i(o, n), | |
o.prototype._onMessage = function(t) { | |
var e = t.data; | |
if (("*" === this._origin || t.origin === this._origin) && t.source === this._targetWindow && "object" == typeof e && e.target === this._name && e.data) | |
if (this._init) | |
try { | |
this.push(e.data) | |
} catch (t) { | |
this.emit("error", t) | |
} | |
else | |
"SYN" === e.data ? (this._haveSyn = !0, | |
this._write("ACK", null, s)) : "ACK" === e.data && (this._init = !0, | |
this._haveSyn || this._write("ACK", null, s), | |
this.uncork()) | |
} | |
, | |
o.prototype._read = s, | |
o.prototype._write = function(t, e, r) { | |
var n = { | |
target: this._target, | |
data: t | |
}; | |
this._targetWindow.postMessage(n, this._origin), | |
r() | |
} | |
} | |
, { | |
"readable-stream": 56, | |
util: 66 | |
}], | |
41: [function(t, e, r) { | |
(function(t) { | |
"use strict"; | |
!t.version || 0 === t.version.indexOf("v0.") || 0 === t.version.indexOf("v1.") && 0 !== t.version.indexOf("v1.8.") ? e.exports = function(e, r, n, i) { | |
if ("function" != typeof e) | |
throw new TypeError('"callback" argument must be a function'); | |
var o, s, a = arguments.length; | |
switch (a) { | |
case 0: | |
case 1: | |
return t.nextTick(e); | |
case 2: | |
return t.nextTick(function() { | |
e.call(null, r) | |
}); | |
case 3: | |
return t.nextTick(function() { | |
e.call(null, r, n) | |
}); | |
case 4: | |
return t.nextTick(function() { | |
e.call(null, r, n, i) | |
}); | |
default: | |
for (o = new Array(a - 1), | |
s = 0; s < o.length; ) | |
o[s++] = arguments[s]; | |
return t.nextTick(function() { | |
e.apply(null, o) | |
}) | |
} | |
} | |
: e.exports = t.nextTick | |
} | |
).call(this, t("_process")) | |
} | |
, { | |
_process: 42 | |
}], | |
42: [function(t, e, r) { | |
var n, i, o = e.exports = {}; | |
function s() { | |
throw new Error("setTimeout has not been defined") | |
} | |
function a() { | |
throw new Error("clearTimeout has not been defined") | |
} | |
function u(t) { | |
if (n === setTimeout) | |
return setTimeout(t, 0); | |
if ((n === s || !n) && setTimeout) | |
return n = setTimeout, | |
setTimeout(t, 0); | |
try { | |
return n(t, 0) | |
} catch (e) { | |
try { | |
return n.call(null, t, 0) | |
} catch (e) { | |
return n.call(this, t, 0) | |
} | |
} | |
} | |
!function() { | |
try { | |
n = "function" == typeof setTimeout ? setTimeout : s | |
} catch (t) { | |
n = s | |
} | |
try { | |
i = "function" == typeof clearTimeout ? clearTimeout : a | |
} catch (t) { | |
i = a | |
} | |
}(); | |
var c, f = [], l = !1, h = -1; | |
function p() { | |
l && c && (l = !1, | |
c.length ? f = c.concat(f) : h = -1, | |
f.length && d()) | |
} | |
function d() { | |
if (!l) { | |
var t = u(p); | |
l = !0; | |
for (var e = f.length; e; ) { | |
for (c = f, | |
f = []; ++h < e; ) | |
c && c[h].run(); | |
h = -1, | |
e = f.length | |
} | |
c = null, | |
l = !1, | |
function(t) { | |
if (i === clearTimeout) | |
return clearTimeout(t); | |
if ((i === a || !i) && clearTimeout) | |
return i = clearTimeout, | |
clearTimeout(t); | |
try { | |
i(t) | |
} catch (e) { | |
try { | |
return i.call(null, t) | |
} catch (e) { | |
return i.call(this, t) | |
} | |
} | |
}(t) | |
} | |
} | |
function y(t, e) { | |
this.fun = t, | |
this.array = e | |
} | |
function m() {} | |
o.nextTick = function(t) { | |
var e = new Array(arguments.length - 1); | |
if (arguments.length > 1) | |
for (var r = 1; r < arguments.length; r++) | |
e[r - 1] = arguments[r]; | |
f.push(new y(t,e)), | |
1 !== f.length || l || u(d) | |
} | |
, | |
y.prototype.run = function() { | |
this.fun.apply(null, this.array) | |
} | |
, | |
o.title = "browser", | |
o.browser = !0, | |
o.env = {}, | |
o.argv = [], | |
o.version = "", | |
o.versions = {}, | |
o.on = m, | |
o.addListener = m, | |
o.once = m, | |
o.off = m, | |
o.removeListener = m, | |
o.removeAllListeners = m, | |
o.emit = m, | |
o.prependListener = m, | |
o.prependOnceListener = m, | |
o.listeners = function(t) { | |
return [] | |
} | |
, | |
o.binding = function(t) { | |
throw new Error("process.binding is not supported") | |
} | |
, | |
o.cwd = function() { | |
return "/" | |
} | |
, | |
o.chdir = function(t) { | |
throw new Error("process.chdir is not supported") | |
} | |
, | |
o.umask = function() { | |
return 0 | |
} | |
} | |
, {}], | |
43: [function(t, e, r) { | |
(function(r) { | |
var n = t("once") | |
, i = t("end-of-stream") | |
, o = t("fs") | |
, s = function() {} | |
, a = /^v?\.0/.test(r.version) | |
, u = function(t) { | |
return "function" == typeof t | |
} | |
, c = function(t, e, r, c) { | |
c = n(c); | |
var f = !1; | |
t.on("close", function() { | |
f = !0 | |
}), | |
i(t, { | |
readable: e, | |
writable: r | |
}, function(t) { | |
if (t) | |
return c(t); | |
f = !0, | |
c() | |
}); | |
var l = !1; | |
return function(e) { | |
if (!f && !l) | |
return l = !0, | |
function(t) { | |
return !!a && !!o && (t instanceof (o.ReadStream || s) || t instanceof (o.WriteStream || s)) && u(t.close) | |
}(t) ? t.close(s) : function(t) { | |
return t.setHeader && u(t.abort) | |
}(t) ? t.abort() : u(t.destroy) ? t.destroy() : void c(e || new Error("stream was destroyed")) | |
} | |
} | |
, f = function(t) { | |
t() | |
} | |
, l = function(t, e) { | |
return t.pipe(e) | |
}; | |
e.exports = function() { | |
var t, e = Array.prototype.slice.call(arguments), r = u(e[e.length - 1] || s) && e.pop() || s; | |
if (Array.isArray(e[0]) && (e = e[0]), | |
e.length < 2) | |
throw new Error("pump requires two streams per minimum"); | |
var n = e.map(function(i, o) { | |
var s = o < e.length - 1; | |
return c(i, s, o > 0, function(e) { | |
t || (t = e), | |
e && n.forEach(f), | |
s || (n.forEach(f), | |
r(t)) | |
}) | |
}); | |
return e.reduce(l) | |
} | |
} | |
).call(this, t("_process")) | |
} | |
, { | |
_process: 42, | |
"end-of-stream": 22, | |
fs: 18, | |
once: 39 | |
}], | |
44: [function(t, e, r) { | |
e.exports = t("./lib/_stream_duplex.js") | |
} | |
, { | |
"./lib/_stream_duplex.js": 45 | |
}], | |
45: [function(t, e, r) { | |
"use strict"; | |
var n = t("process-nextick-args") | |
, i = Object.keys || function(t) { | |
var e = []; | |
for (var r in t) | |
e.push(r); | |
return e | |
} | |
; | |
e.exports = l; | |
var o = t("core-util-is"); | |
o.inherits = t("inherits"); | |
var s = t("./_stream_readable") | |
, a = t("./_stream_writable"); | |
o.inherits(l, s); | |
for (var u = i(a.prototype), c = 0; c < u.length; c++) { | |
var f = u[c]; | |
l.prototype[f] || (l.prototype[f] = a.prototype[f]) | |
} | |
function l(t) { | |
if (!(this instanceof l)) | |
return new l(t); | |
s.call(this, t), | |
a.call(this, t), | |
t && !1 === t.readable && (this.readable = !1), | |
t && !1 === t.writable && (this.writable = !1), | |
this.allowHalfOpen = !0, | |
t && !1 === t.allowHalfOpen && (this.allowHalfOpen = !1), | |
this.once("end", h) | |
} | |
function h() { | |
this.allowHalfOpen || this._writableState.ended || n(p, this) | |
} | |
function p(t) { | |
t.end() | |
} | |
Object.defineProperty(l.prototype, "destroyed", { | |
get: function() { | |
return void 0 !== this._readableState && void 0 !== this._writableState && (this._readableState.destroyed && this._writableState.destroyed) | |
}, | |
set: function(t) { | |
void 0 !== this._readableState && void 0 !== this._writableState && (this._readableState.destroyed = t, | |
this._writableState.destroyed = t) | |
} | |
}), | |
l.prototype._destroy = function(t, e) { | |
this.push(null), | |
this.end(), | |
n(e, t) | |
} | |
} | |
, { | |
"./_stream_readable": 47, | |
"./_stream_writable": 49, | |
"core-util-is": 21, | |
inherits: 25, | |
"process-nextick-args": 41 | |
}], | |
46: [function(t, e, r) { | |
"use strict"; | |
e.exports = o; | |
var n = t("./_stream_transform") | |
, i = t("core-util-is"); | |
function o(t) { | |
if (!(this instanceof o)) | |
return new o(t); | |
n.call(this, t) | |
} | |
i.inherits = t("inherits"), | |
i.inherits(o, n), | |
o.prototype._transform = function(t, e, r) { | |
r(null, t) | |
} | |
} | |
, { | |
"./_stream_transform": 48, | |
"core-util-is": 21, | |
inherits: 25 | |
}], | |
47: [function(t, e, r) { | |
(function(r, n) { | |
"use strict"; | |
var i = t("process-nextick-args"); | |
e.exports = b; | |
var o, s = t("isarray"); | |
b.ReadableState = v; | |
t("events").EventEmitter; | |
var a = function(t, e) { | |
return t.listeners(e).length | |
} | |
, u = t("./internal/streams/stream") | |
, c = t("safe-buffer").Buffer | |
, f = n.Uint8Array || function() {} | |
; | |
var l = t("core-util-is"); | |
l.inherits = t("inherits"); | |
var h = t("util") | |
, p = void 0; | |
p = h && h.debuglog ? h.debuglog("stream") : function() {} | |
; | |
var d, y = t("./internal/streams/BufferList"), m = t("./internal/streams/destroy"); | |
l.inherits(b, u); | |
var g = ["error", "close", "destroy", "pause", "resume"]; | |
function v(e, r) { | |
o = o || t("./_stream_duplex"), | |
e = e || {}, | |
this.objectMode = !!e.objectMode, | |
r instanceof o && (this.objectMode = this.objectMode || !!e.readableObjectMode); | |
var n = e.highWaterMark | |
, i = this.objectMode ? 16 : 16384; | |
this.highWaterMark = n || 0 === n ? n : i, | |
this.highWaterMark = Math.floor(this.highWaterMark), | |
this.buffer = new y, | |
this.length = 0, | |
this.pipes = null, | |
this.pipesCount = 0, | |
this.flowing = null, | |
this.ended = !1, | |
this.endEmitted = !1, | |
this.reading = !1, | |
this.sync = !0, | |
this.needReadable = !1, | |
this.emittedReadable = !1, | |
this.readableListening = !1, | |
this.resumeScheduled = !1, | |
this.destroyed = !1, | |
this.defaultEncoding = e.defaultEncoding || "utf8", | |
this.awaitDrain = 0, | |
this.readingMore = !1, | |
this.decoder = null, | |
this.encoding = null, | |
e.encoding && (d || (d = t("string_decoder/").StringDecoder), | |
this.decoder = new d(e.encoding), | |
this.encoding = e.encoding) | |
} | |
function b(e) { | |
if (o = o || t("./_stream_duplex"), | |
!(this instanceof b)) | |
return new b(e); | |
this._readableState = new v(e,this), | |
this.readable = !0, | |
e && ("function" == typeof e.read && (this._read = e.read), | |
"function" == typeof e.destroy && (this._destroy = e.destroy)), | |
u.call(this) | |
} | |
function w(t, e, r, n, i) { | |
var o, s = t._readableState; | |
null === e ? (s.reading = !1, | |
function(t, e) { | |
if (e.ended) | |
return; | |
if (e.decoder) { | |
var r = e.decoder.end(); | |
r && r.length && (e.buffer.push(r), | |
e.length += e.objectMode ? 1 : r.length) | |
} | |
e.ended = !0, | |
k(t) | |
}(t, s)) : (i || (o = function(t, e) { | |
var r; | |
n = e, | |
c.isBuffer(n) || n instanceof f || "string" == typeof e || void 0 === e || t.objectMode || (r = new TypeError("Invalid non-string/buffer chunk")); | |
var n; | |
return r | |
}(s, e)), | |
o ? t.emit("error", o) : s.objectMode || e && e.length > 0 ? ("string" == typeof e || s.objectMode || Object.getPrototypeOf(e) === c.prototype || (e = function(t) { | |
return c.from(t) | |
}(e)), | |
n ? s.endEmitted ? t.emit("error", new Error("stream.unshift() after end event")) : _(t, s, e, !0) : s.ended ? t.emit("error", new Error("stream.push() after EOF")) : (s.reading = !1, | |
s.decoder && !r ? (e = s.decoder.write(e), | |
s.objectMode || 0 !== e.length ? _(t, s, e, !1) : A(t, s)) : _(t, s, e, !1))) : n || (s.reading = !1)); | |
return function(t) { | |
return !t.ended && (t.needReadable || t.length < t.highWaterMark || 0 === t.length) | |
}(s) | |
} | |
function _(t, e, r, n) { | |
e.flowing && 0 === e.length && !e.sync ? (t.emit("data", r), | |
t.read(0)) : (e.length += e.objectMode ? 1 : r.length, | |
n ? e.buffer.unshift(r) : e.buffer.push(r), | |
e.needReadable && k(t)), | |
A(t, e) | |
} | |
Object.defineProperty(b.prototype, "destroyed", { | |
get: function() { | |
return void 0 !== this._readableState && this._readableState.destroyed | |
}, | |
set: function(t) { | |
this._readableState && (this._readableState.destroyed = t) | |
} | |
}), | |
b.prototype.destroy = m.destroy, | |
b.prototype._undestroy = m.undestroy, | |
b.prototype._destroy = function(t, e) { | |
this.push(null), | |
e(t) | |
} | |
, | |
b.prototype.push = function(t, e) { | |
var r, n = this._readableState; | |
return n.objectMode ? r = !0 : "string" == typeof t && ((e = e || n.defaultEncoding) !== n.encoding && (t = c.from(t, e), | |
e = ""), | |
r = !0), | |
w(this, t, e, !1, r) | |
} | |
, | |
b.prototype.unshift = function(t) { | |
return w(this, t, null, !0, !1) | |
} | |
, | |
b.prototype.isPaused = function() { | |
return !1 === this._readableState.flowing | |
} | |
, | |
b.prototype.setEncoding = function(e) { | |
return d || (d = t("string_decoder/").StringDecoder), | |
this._readableState.decoder = new d(e), | |
this._readableState.encoding = e, | |
this | |
} | |
; | |
var x = 8388608; | |
function S(t, e) { | |
return t <= 0 || 0 === e.length && e.ended ? 0 : e.objectMode ? 1 : t != t ? e.flowing && e.length ? e.buffer.head.data.length : e.length : (t > e.highWaterMark && (e.highWaterMark = function(t) { | |
return t >= x ? t = x : (t--, | |
t |= t >>> 1, | |
t |= t >>> 2, | |
t |= t >>> 4, | |
t |= t >>> 8, | |
t |= t >>> 16, | |
t++), | |
t | |
}(t)), | |
t <= e.length ? t : e.ended ? e.length : (e.needReadable = !0, | |
0)) | |
} | |
function k(t) { | |
var e = t._readableState; | |
e.needReadable = !1, | |
e.emittedReadable || (p("emitReadable", e.flowing), | |
e.emittedReadable = !0, | |
e.sync ? i(E, t) : E(t)) | |
} | |
function E(t) { | |
p("emit readable"), | |
t.emit("readable"), | |
B(t) | |
} | |
function A(t, e) { | |
e.readingMore || (e.readingMore = !0, | |
i(C, t, e)) | |
} | |
function C(t, e) { | |
for (var r = e.length; !e.reading && !e.flowing && !e.ended && e.length < e.highWaterMark && (p("maybeReadMore read 0"), | |
t.read(0), | |
r !== e.length); ) | |
r = e.length; | |
e.readingMore = !1 | |
} | |
function T(t) { | |
p("readable nexttick read 0"), | |
t.read(0) | |
} | |
function O(t, e) { | |
e.reading || (p("resume read 0"), | |
t.read(0)), | |
e.resumeScheduled = !1, | |
e.awaitDrain = 0, | |
t.emit("resume"), | |
B(t), | |
e.flowing && !e.reading && t.read(0) | |
} | |
function B(t) { | |
var e = t._readableState; | |
for (p("flow", e.flowing); e.flowing && null !== t.read(); ) | |
; | |
} | |
function j(t, e) { | |
return 0 === e.length ? null : (e.objectMode ? r = e.buffer.shift() : !t || t >= e.length ? (r = e.decoder ? e.buffer.join("") : 1 === e.buffer.length ? e.buffer.head.data : e.buffer.concat(e.length), | |
e.buffer.clear()) : r = function(t, e, r) { | |
var n; | |
t < e.head.data.length ? (n = e.head.data.slice(0, t), | |
e.head.data = e.head.data.slice(t)) : n = t === e.head.data.length ? e.shift() : r ? function(t, e) { | |
var r = e.head | |
, n = 1 | |
, i = r.data; | |
t -= i.length; | |
for (; r = r.next; ) { | |
var o = r.data | |
, s = t > o.length ? o.length : t; | |
if (s === o.length ? i += o : i += o.slice(0, t), | |
0 === (t -= s)) { | |
s === o.length ? (++n, | |
r.next ? e.head = r.next : e.head = e.tail = null) : (e.head = r, | |
r.data = o.slice(s)); | |
break | |
} | |
++n | |
} | |
return e.length -= n, | |
i | |
}(t, e) : function(t, e) { | |
var r = c.allocUnsafe(t) | |
, n = e.head | |
, i = 1; | |
n.data.copy(r), | |
t -= n.data.length; | |
for (; n = n.next; ) { | |
var o = n.data | |
, s = t > o.length ? o.length : t; | |
if (o.copy(r, r.length - t, 0, s), | |
0 === (t -= s)) { | |
s === o.length ? (++i, | |
n.next ? e.head = n.next : e.head = e.tail = null) : (e.head = n, | |
n.data = o.slice(s)); | |
break | |
} | |
++i | |
} | |
return e.length -= i, | |
r | |
}(t, e); | |
return n | |
}(t, e.buffer, e.decoder), | |
r); | |
var r | |
} | |
function R(t) { | |
var e = t._readableState; | |
if (e.length > 0) | |
throw new Error('"endReadable()" called on non-empty stream'); | |
e.endEmitted || (e.ended = !0, | |
i(M, e, t)) | |
} | |
function M(t, e) { | |
t.endEmitted || 0 !== t.length || (t.endEmitted = !0, | |
e.readable = !1, | |
e.emit("end")) | |
} | |
function L(t, e) { | |
for (var r = 0, n = t.length; r < n; r++) | |
if (t[r] === e) | |
return r; | |
return -1 | |
} | |
b.prototype.read = function(t) { | |
p("read", t), | |
t = parseInt(t, 10); | |
var e = this._readableState | |
, r = t; | |
if (0 !== t && (e.emittedReadable = !1), | |
0 === t && e.needReadable && (e.length >= e.highWaterMark || e.ended)) | |
return p("read: emitReadable", e.length, e.ended), | |
0 === e.length && e.ended ? R(this) : k(this), | |
null; | |
if (0 === (t = S(t, e)) && e.ended) | |
return 0 === e.length && R(this), | |
null; | |
var n, i = e.needReadable; | |
return p("need readable", i), | |
(0 === e.length || e.length - t < e.highWaterMark) && p("length less than watermark", i = !0), | |
e.ended || e.reading ? p("reading or ended", i = !1) : i && (p("do read"), | |
e.reading = !0, | |
e.sync = !0, | |
0 === e.length && (e.needReadable = !0), | |
this._read(e.highWaterMark), | |
e.sync = !1, | |
e.reading || (t = S(r, e))), | |
null === (n = t > 0 ? j(t, e) : null) ? (e.needReadable = !0, | |
t = 0) : e.length -= t, | |
0 === e.length && (e.ended || (e.needReadable = !0), | |
r !== t && e.ended && R(this)), | |
null !== n && this.emit("data", n), | |
n | |
} | |
, | |
b.prototype._read = function(t) { | |
this.emit("error", new Error("_read() is not implemented")) | |
} | |
, | |
b.prototype.pipe = function(t, e) { | |
var n = this | |
, o = this._readableState; | |
switch (o.pipesCount) { | |
case 0: | |
o.pipes = t; | |
break; | |
case 1: | |
o.pipes = [o.pipes, t]; | |
break; | |
default: | |
o.pipes.push(t) | |
} | |
o.pipesCount += 1, | |
p("pipe count=%d opts=%j", o.pipesCount, e); | |
var u = (!e || !1 !== e.end) && t !== r.stdout && t !== r.stderr ? f : b; | |
function c(e, r) { | |
p("onunpipe"), | |
e === n && r && !1 === r.hasUnpiped && (r.hasUnpiped = !0, | |
p("cleanup"), | |
t.removeListener("close", g), | |
t.removeListener("finish", v), | |
t.removeListener("drain", l), | |
t.removeListener("error", m), | |
t.removeListener("unpipe", c), | |
n.removeListener("end", f), | |
n.removeListener("end", b), | |
n.removeListener("data", y), | |
h = !0, | |
!o.awaitDrain || t._writableState && !t._writableState.needDrain || l()) | |
} | |
function f() { | |
p("onend"), | |
t.end() | |
} | |
o.endEmitted ? i(u) : n.once("end", u), | |
t.on("unpipe", c); | |
var l = function(t) { | |
return function() { | |
var e = t._readableState; | |
p("pipeOnDrain", e.awaitDrain), | |
e.awaitDrain && e.awaitDrain--, | |
0 === e.awaitDrain && a(t, "data") && (e.flowing = !0, | |
B(t)) | |
} | |
}(n); | |
t.on("drain", l); | |
var h = !1; | |
var d = !1; | |
function y(e) { | |
p("ondata"), | |
d = !1, | |
!1 !== t.write(e) || d || ((1 === o.pipesCount && o.pipes === t || o.pipesCount > 1 && -1 !== L(o.pipes, t)) && !h && (p("false write response, pause", n._readableState.awaitDrain), | |
n._readableState.awaitDrain++, | |
d = !0), | |
n.pause()) | |
} | |
function m(e) { | |
p("onerror", e), | |
b(), | |
t.removeListener("error", m), | |
0 === a(t, "error") && t.emit("error", e) | |
} | |
function g() { | |
t.removeListener("finish", v), | |
b() | |
} | |
function v() { | |
p("onfinish"), | |
t.removeListener("close", g), | |
b() | |
} | |
function b() { | |
p("unpipe"), | |
n.unpipe(t) | |
} | |
return n.on("data", y), | |
function(t, e, r) { | |
if ("function" == typeof t.prependListener) | |
return t.prependListener(e, r); | |
t._events && t._events[e] ? s(t._events[e]) ? t._events[e].unshift(r) : t._events[e] = [r, t._events[e]] : t.on(e, r) | |
}(t, "error", m), | |
t.once("close", g), | |
t.once("finish", v), | |
t.emit("pipe", n), | |
o.flowing || (p("pipe resume"), | |
n.resume()), | |
t | |
} | |
, | |
b.prototype.unpipe = function(t) { | |
var e = this._readableState | |
, r = { | |
hasUnpiped: !1 | |
}; | |
if (0 === e.pipesCount) | |
return this; | |
if (1 === e.pipesCount) | |
return t && t !== e.pipes ? this : (t || (t = e.pipes), | |
e.pipes = null, | |
e.pipesCount = 0, | |
e.flowing = !1, | |
t && t.emit("unpipe", this, r), | |
this); | |
if (!t) { | |
var n = e.pipes | |
, i = e.pipesCount; | |
e.pipes = null, | |
e.pipesCount = 0, | |
e.flowing = !1; | |
for (var o = 0; o < i; o++) | |
n[o].emit("unpipe", this, r); | |
return this | |
} | |
var s = L(e.pipes, t); | |
return -1 === s ? this : (e.pipes.splice(s, 1), | |
e.pipesCount -= 1, | |
1 === e.pipesCount && (e.pipes = e.pipes[0]), | |
t.emit("unpipe", this, r), | |
this) | |
} | |
, | |
b.prototype.on = function(t, e) { | |
var r = u.prototype.on.call(this, t, e); | |
if ("data" === t) | |
!1 !== this._readableState.flowing && this.resume(); | |
else if ("readable" === t) { | |
var n = this._readableState; | |
n.endEmitted || n.readableListening || (n.readableListening = n.needReadable = !0, | |
n.emittedReadable = !1, | |
n.reading ? n.length && k(this) : i(T, this)) | |
} | |
return r | |
} | |
, | |
b.prototype.addListener = b.prototype.on, | |
b.prototype.resume = function() { | |
var t = this._readableState; | |
return t.flowing || (p("resume"), | |
t.flowing = !0, | |
function(t, e) { | |
e.resumeScheduled || (e.resumeScheduled = !0, | |
i(O, t, e)) | |
}(this, t)), | |
this | |
} | |
, | |
b.prototype.pause = function() { | |
return p("call pause flowing=%j", this._readableState.flowing), | |
!1 !== this._readableState.flowing && (p("pause"), | |
this._readableState.flowing = !1, | |
this.emit("pause")), | |
this | |
} | |
, | |
b.prototype.wrap = function(t) { | |
var e = this._readableState | |
, r = !1 | |
, n = this; | |
for (var i in t.on("end", function() { | |
if (p("wrapped end"), | |
e.decoder && !e.ended) { | |
var t = e.decoder.end(); | |
t && t.length && n.push(t) | |
} | |
n.push(null) | |
}), | |
t.on("data", function(i) { | |
(p("wrapped data"), | |
e.decoder && (i = e.decoder.write(i)), | |
e.objectMode && null == i) || (e.objectMode || i && i.length) && (n.push(i) || (r = !0, | |
t.pause())) | |
}), | |
t) | |
void 0 === this[i] && "function" == typeof t[i] && (this[i] = function(e) { | |
return function() { | |
return t[e].apply(t, arguments) | |
} | |
}(i)); | |
for (var o = 0; o < g.length; o++) | |
t.on(g[o], n.emit.bind(n, g[o])); | |
return n._read = function(e) { | |
p("wrapped _read", e), | |
r && (r = !1, | |
t.resume()) | |
} | |
, | |
n | |
} | |
, | |
b._fromList = j | |
} | |
).call(this, t("_process"), "undefined" != typeof global ? global : "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}) | |
} | |
, { | |
"./_stream_duplex": 45, | |
"./internal/streams/BufferList": 50, | |
"./internal/streams/destroy": 51, | |
"./internal/streams/stream": 52, | |
_process: 42, | |
"core-util-is": 21, | |
events: 20, | |
inherits: 25, | |
isarray: 27, | |
"process-nextick-args": 41, | |
"safe-buffer": 53, | |
"string_decoder/": 54, | |
util: 18 | |
}], | |
48: [function(t, e, r) { | |
"use strict"; | |
e.exports = s; | |
var n = t("./_stream_duplex") | |
, i = t("core-util-is"); | |
function o(t) { | |
this.afterTransform = function(e, r) { | |
return function(t, e, r) { | |
var n = t._transformState; | |
n.transforming = !1; | |
var i = n.writecb; | |
if (!i) | |
return t.emit("error", new Error("write callback called multiple times")); | |
n.writechunk = null, | |
n.writecb = null, | |
null != r && t.push(r); | |
i(e); | |
var o = t._readableState; | |
o.reading = !1, | |
(o.needReadable || o.length < o.highWaterMark) && t._read(o.highWaterMark) | |
}(t, e, r) | |
} | |
, | |
this.needTransform = !1, | |
this.transforming = !1, | |
this.writecb = null, | |
this.writechunk = null, | |
this.writeencoding = null | |
} | |
function s(t) { | |
if (!(this instanceof s)) | |
return new s(t); | |
n.call(this, t), | |
this._transformState = new o(this); | |
var e = this; | |
this._readableState.needReadable = !0, | |
this._readableState.sync = !1, | |
t && ("function" == typeof t.transform && (this._transform = t.transform), | |
"function" == typeof t.flush && (this._flush = t.flush)), | |
this.once("prefinish", function() { | |
"function" == typeof this._flush ? this._flush(function(t, r) { | |
a(e, t, r) | |
}) : a(e) | |
}) | |
} | |
function a(t, e, r) { | |
if (e) | |
return t.emit("error", e); | |
null != r && t.push(r); | |
var n = t._writableState | |
, i = t._transformState; | |
if (n.length) | |
throw new Error("Calling transform done when ws.length != 0"); | |
if (i.transforming) | |
throw new Error("Calling transform done when still transforming"); | |
return t.push(null) | |
} | |
i.inherits = t("inherits"), | |
i.inherits(s, n), | |
s.prototype.push = function(t, e) { | |
return this._transformState.needTransform = !1, | |
n.prototype.push.call(this, t, e) | |
} | |
, | |
s.prototype._transform = function(t, e, r) { | |
throw new Error("_transform() is not implemented") | |
} | |
, | |
s.prototype._write = function(t, e, r) { | |
var n = this._transformState; | |
if (n.writecb = r, | |
n.writechunk = t, | |
n.writeencoding = e, | |
!n.transforming) { | |
var i = this._readableState; | |
(n.needTransform || i.needReadable || i.length < i.highWaterMark) && this._read(i.highWaterMark) | |
} | |
} | |
, | |
s.prototype._read = function(t) { | |
var e = this._transformState; | |
null !== e.writechunk && e.writecb && !e.transforming ? (e.transforming = !0, | |
this._transform(e.writechunk, e.writeencoding, e.afterTransform)) : e.needTransform = !0 | |
} | |
, | |
s.prototype._destroy = function(t, e) { | |
var r = this; | |
n.prototype._destroy.call(this, t, function(t) { | |
e(t), | |
r.emit("close") | |
}) | |
} | |
} | |
, { | |
"./_stream_duplex": 45, | |
"core-util-is": 21, | |
inherits: 25 | |
}], | |
49: [function(t, e, r) { | |
(function(r, n, i) { | |
"use strict"; | |
var o = t("process-nextick-args"); | |
function s(t) { | |
var e = this; | |
this.next = null, | |
this.entry = null, | |
this.finish = function() { | |
!function(t, e, r) { | |
var n = t.entry; | |
t.entry = null; | |
for (; n; ) { | |
var i = n.callback; | |
e.pendingcb--, | |
i(r), | |
n = n.next | |
} | |
e.corkedRequestsFree ? e.corkedRequestsFree.next = t : e.corkedRequestsFree = t | |
}(e, t) | |
} | |
} | |
e.exports = v; | |
var a, u = !r.browser && ["v0.10", "v0.9."].indexOf(r.version.slice(0, 5)) > -1 ? i : o; | |
v.WritableState = g; | |
var c = t("core-util-is"); | |
c.inherits = t("inherits"); | |
var f = { | |
deprecate: t("util-deprecate") | |
} | |
, l = t("./internal/streams/stream") | |
, h = t("safe-buffer").Buffer | |
, p = n.Uint8Array || function() {} | |
; | |
var d, y = t("./internal/streams/destroy"); | |
function m() {} | |
function g(e, r) { | |
a = a || t("./_stream_duplex"), | |
e = e || {}, | |
this.objectMode = !!e.objectMode, | |
r instanceof a && (this.objectMode = this.objectMode || !!e.writableObjectMode); | |
var n = e.highWaterMark | |
, i = this.objectMode ? 16 : 16384; | |
this.highWaterMark = n || 0 === n ? n : i, | |
this.highWaterMark = Math.floor(this.highWaterMark), | |
this.finalCalled = !1, | |
this.needDrain = !1, | |
this.ending = !1, | |
this.ended = !1, | |
this.finished = !1, | |
this.destroyed = !1; | |
var c = !1 === e.decodeStrings; | |
this.decodeStrings = !c, | |
this.defaultEncoding = e.defaultEncoding || "utf8", | |
this.length = 0, | |
this.writing = !1, | |
this.corked = 0, | |
this.sync = !0, | |
this.bufferProcessing = !1, | |
this.onwrite = function(t) { | |
!function(t, e) { | |
var r = t._writableState | |
, n = r.sync | |
, i = r.writecb; | |
if (function(t) { | |
t.writing = !1, | |
t.writecb = null, | |
t.length -= t.writelen, | |
t.writelen = 0 | |
}(r), | |
e) | |
!function(t, e, r, n, i) { | |
--e.pendingcb, | |
r ? (o(i, n), | |
o(k, t, e), | |
t._writableState.errorEmitted = !0, | |
t.emit("error", n)) : (i(n), | |
t._writableState.errorEmitted = !0, | |
t.emit("error", n), | |
k(t, e)) | |
}(t, r, n, e, i); | |
else { | |
var s = x(r); | |
s || r.corked || r.bufferProcessing || !r.bufferedRequest || _(t, r), | |
n ? u(w, t, r, s, i) : w(t, r, s, i) | |
} | |
}(r, t) | |
} | |
, | |
this.writecb = null, | |
this.writelen = 0, | |
this.bufferedRequest = null, | |
this.lastBufferedRequest = null, | |
this.pendingcb = 0, | |
this.prefinished = !1, | |
this.errorEmitted = !1, | |
this.bufferedRequestCount = 0, | |
this.corkedRequestsFree = new s(this) | |
} | |
function v(e) { | |
if (a = a || t("./_stream_duplex"), | |
!(d.call(v, this) || this instanceof a)) | |
return new v(e); | |
this._writableState = new g(e,this), | |
this.writable = !0, | |
e && ("function" == typeof e.write && (this._write = e.write), | |
"function" == typeof e.writev && (this._writev = e.writev), | |
"function" == typeof e.destroy && (this._destroy = e.destroy), | |
"function" == typeof e.final && (this._final = e.final)), | |
l.call(this) | |
} | |
function b(t, e, r, n, i, o, s) { | |
e.writelen = n, | |
e.writecb = s, | |
e.writing = !0, | |
e.sync = !0, | |
r ? t._writev(i, e.onwrite) : t._write(i, o, e.onwrite), | |
e.sync = !1 | |
} | |
function w(t, e, r, n) { | |
r || function(t, e) { | |
0 === e.length && e.needDrain && (e.needDrain = !1, | |
t.emit("drain")) | |
}(t, e), | |
e.pendingcb--, | |
n(), | |
k(t, e) | |
} | |
function _(t, e) { | |
e.bufferProcessing = !0; | |
var r = e.bufferedRequest; | |
if (t._writev && r && r.next) { | |
var n = e.bufferedRequestCount | |
, i = new Array(n) | |
, o = e.corkedRequestsFree; | |
o.entry = r; | |
for (var a = 0, u = !0; r; ) | |
i[a] = r, | |
r.isBuf || (u = !1), | |
r = r.next, | |
a += 1; | |
i.allBuffers = u, | |
b(t, e, !0, e.length, i, "", o.finish), | |
e.pendingcb++, | |
e.lastBufferedRequest = null, | |
o.next ? (e.corkedRequestsFree = o.next, | |
o.next = null) : e.corkedRequestsFree = new s(e) | |
} else { | |
for (; r; ) { | |
var c = r.chunk | |
, f = r.encoding | |
, l = r.callback; | |
if (b(t, e, !1, e.objectMode ? 1 : c.length, c, f, l), | |
r = r.next, | |
e.writing) | |
break | |
} | |
null === r && (e.lastBufferedRequest = null) | |
} | |
e.bufferedRequestCount = 0, | |
e.bufferedRequest = r, | |
e.bufferProcessing = !1 | |
} | |
function x(t) { | |
return t.ending && 0 === t.length && null === t.bufferedRequest && !t.finished && !t.writing | |
} | |
function S(t, e) { | |
t._final(function(r) { | |
e.pendingcb--, | |
r && t.emit("error", r), | |
e.prefinished = !0, | |
t.emit("prefinish"), | |
k(t, e) | |
}) | |
} | |
function k(t, e) { | |
var r = x(e); | |
return r && (!function(t, e) { | |
e.prefinished || e.finalCalled || ("function" == typeof t._final ? (e.pendingcb++, | |
e.finalCalled = !0, | |
o(S, t, e)) : (e.prefinished = !0, | |
t.emit("prefinish"))) | |
}(t, e), | |
0 === e.pendingcb && (e.finished = !0, | |
t.emit("finish"))), | |
r | |
} | |
c.inherits(v, l), | |
g.prototype.getBuffer = function() { | |
for (var t = this.bufferedRequest, e = []; t; ) | |
e.push(t), | |
t = t.next; | |
return e | |
} | |
, | |
function() { | |
try { | |
Object.defineProperty(g.prototype, "buffer", { | |
get: f.deprecate(function() { | |
return this.getBuffer() | |
}, "_writableState.buffer is deprecated. Use _writableState.getBuffer instead.", "DEP0003") | |
}) | |
} catch (t) {} | |
}(), | |
"function" == typeof Symbol && Symbol.hasInstance && "function" == typeof Function.prototype[Symbol.hasInstance] ? (d = Function.prototype[Symbol.hasInstance], | |
Object.defineProperty(v, Symbol.hasInstance, { | |
value: function(t) { | |
return !!d.call(this, t) || t && t._writableState instanceof g | |
} | |
})) : d = function(t) { | |
return t instanceof this | |
} | |
, | |
v.prototype.pipe = function() { | |
this.emit("error", new Error("Cannot pipe, not readable")) | |
} | |
, | |
v.prototype.write = function(t, e, r) { | |
var n, i = this._writableState, s = !1, a = (n = t, | |
(h.isBuffer(n) || n instanceof p) && !i.objectMode); | |
return a && !h.isBuffer(t) && (t = function(t) { | |
return h.from(t) | |
}(t)), | |
"function" == typeof e && (r = e, | |
e = null), | |
a ? e = "buffer" : e || (e = i.defaultEncoding), | |
"function" != typeof r && (r = m), | |
i.ended ? function(t, e) { | |
var r = new Error("write after end"); | |
t.emit("error", r), | |
o(e, r) | |
}(this, r) : (a || function(t, e, r, n) { | |
var i = !0 | |
, s = !1; | |
return null === r ? s = new TypeError("May not write null values to stream") : "string" == typeof r || void 0 === r || e.objectMode || (s = new TypeError("Invalid non-string/buffer chunk")), | |
s && (t.emit("error", s), | |
o(n, s), | |
i = !1), | |
i | |
}(this, i, t, r)) && (i.pendingcb++, | |
s = function(t, e, r, n, i, o) { | |
if (!r) { | |
var s = function(t, e, r) { | |
t.objectMode || !1 === t.decodeStrings || "string" != typeof e || (e = h.from(e, r)); | |
return e | |
}(e, n, i); | |
n !== s && (r = !0, | |
i = "buffer", | |
n = s) | |
} | |
var a = e.objectMode ? 1 : n.length; | |
e.length += a; | |
var u = e.length < e.highWaterMark; | |
u || (e.needDrain = !0); | |
if (e.writing || e.corked) { | |
var c = e.lastBufferedRequest; | |
e.lastBufferedRequest = { | |
chunk: n, | |
encoding: i, | |
isBuf: r, | |
callback: o, | |
next: null | |
}, | |
c ? c.next = e.lastBufferedRequest : e.bufferedRequest = e.lastBufferedRequest, | |
e.bufferedRequestCount += 1 | |
} else | |
b(t, e, !1, a, n, i, o); | |
return u | |
}(this, i, a, t, e, r)), | |
s | |
} | |
, | |
v.prototype.cork = function() { | |
this._writableState.corked++ | |
} | |
, | |
v.prototype.uncork = function() { | |
var t = this._writableState; | |
t.corked && (t.corked--, | |
t.writing || t.corked || t.finished || t.bufferProcessing || !t.bufferedRequest || _(this, t)) | |
} | |
, | |
v.prototype.setDefaultEncoding = function(t) { | |
if ("string" == typeof t && (t = t.toLowerCase()), | |
!(["hex", "utf8", "utf-8", "ascii", "binary", "base64", "ucs2", "ucs-2", "utf16le", "utf-16le", "raw"].indexOf((t + "").toLowerCase()) > -1)) | |
throw new TypeError("Unknown encoding: " + t); | |
return this._writableState.defaultEncoding = t, | |
this | |
} | |
, | |
v.prototype._write = function(t, e, r) { | |
r(new Error("_write() is not implemented")) | |
} | |
, | |
v.prototype._writev = null, | |
v.prototype.end = function(t, e, r) { | |
var n = this._writableState; | |
"function" == typeof t ? (r = t, | |
t = null, | |
e = null) : "function" == typeof e && (r = e, | |
e = null), | |
null != t && this.write(t, e), | |
n.corked && (n.corked = 1, | |
this.uncork()), | |
n.ending || n.finished || function(t, e, r) { | |
e.ending = !0, | |
k(t, e), | |
r && (e.finished ? o(r) : t.once("finish", r)); | |
e.ended = !0, | |
t.writable = !1 | |
}(this, n, r) | |
} | |
, | |
Object.defineProperty(v.prototype, "destroyed", { | |
get: function() { | |
return void 0 !== this._writableState && this._writableState.destroyed | |
}, | |
set: function(t) { | |
this._writableState && (this._writableState.destroyed = t) | |
} | |
}), | |
v.prototype.destroy = y.destroy, | |
v.prototype._undestroy = y.undestroy, | |
v.prototype._destroy = function(t, e) { | |
this.end(), | |
e(t) | |
} | |
} | |
).call(this, t("_process"), "undefined" != typeof global ? global : "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}, t("timers").setImmediate) | |
} | |
, { | |
"./_stream_duplex": 45, | |
"./internal/streams/destroy": 51, | |
"./internal/streams/stream": 52, | |
_process: 42, | |
"core-util-is": 21, | |
inherits: 25, | |
"process-nextick-args": 41, | |
"safe-buffer": 53, | |
timers: 62, | |
"util-deprecate": 63 | |
}], | |
50: [function(t, e, r) { | |
"use strict"; | |
var n = t("safe-buffer").Buffer; | |
e.exports = function() { | |
function t() { | |
!function(t, e) { | |
if (!(t instanceof e)) | |
throw new TypeError("Cannot call a class as a function") | |
}(this, t), | |
this.head = null, | |
this.tail = null, | |
this.length = 0 | |
} | |
return t.prototype.push = function(t) { | |
var e = { | |
data: t, | |
next: null | |
}; | |
this.length > 0 ? this.tail.next = e : this.head = e, | |
this.tail = e, | |
++this.length | |
} | |
, | |
t.prototype.unshift = function(t) { | |
var e = { | |
data: t, | |
next: this.head | |
}; | |
0 === this.length && (this.tail = e), | |
this.head = e, | |
++this.length | |
} | |
, | |
t.prototype.shift = function() { | |
if (0 !== this.length) { | |
var t = this.head.data; | |
return 1 === this.length ? this.head = this.tail = null : this.head = this.head.next, | |
--this.length, | |
t | |
} | |
} | |
, | |
t.prototype.clear = function() { | |
this.head = this.tail = null, | |
this.length = 0 | |
} | |
, | |
t.prototype.join = function(t) { | |
if (0 === this.length) | |
return ""; | |
for (var e = this.head, r = "" + e.data; e = e.next; ) | |
r += t + e.data; | |
return r | |
} | |
, | |
t.prototype.concat = function(t) { | |
if (0 === this.length) | |
return n.alloc(0); | |
if (1 === this.length) | |
return this.head.data; | |
for (var e, r, i, o = n.allocUnsafe(t >>> 0), s = this.head, a = 0; s; ) | |
e = s.data, | |
r = o, | |
i = a, | |
e.copy(r, i), | |
a += s.data.length, | |
s = s.next; | |
return o | |
} | |
, | |
t | |
}() | |
} | |
, { | |
"safe-buffer": 53 | |
}], | |
51: [function(t, e, r) { | |
"use strict"; | |
var n = t("process-nextick-args"); | |
function i(t, e) { | |
t.emit("error", e) | |
} | |
e.exports = { | |
destroy: function(t, e) { | |
var r = this | |
, o = this._readableState && this._readableState.destroyed | |
, s = this._writableState && this._writableState.destroyed; | |
o || s ? e ? e(t) : !t || this._writableState && this._writableState.errorEmitted || n(i, this, t) : (this._readableState && (this._readableState.destroyed = !0), | |
this._writableState && (this._writableState.destroyed = !0), | |
this._destroy(t || null, function(t) { | |
!e && t ? (n(i, r, t), | |
r._writableState && (r._writableState.errorEmitted = !0)) : e && e(t) | |
})) | |
}, | |
undestroy: function() { | |
this._readableState && (this._readableState.destroyed = !1, | |
this._readableState.reading = !1, | |
this._readableState.ended = !1, | |
this._readableState.endEmitted = !1), | |
this._writableState && (this._writableState.destroyed = !1, | |
this._writableState.ended = !1, | |
this._writableState.ending = !1, | |
this._writableState.finished = !1, | |
this._writableState.errorEmitted = !1) | |
} | |
} | |
} | |
, { | |
"process-nextick-args": 41 | |
}], | |
52: [function(t, e, r) { | |
e.exports = t("events").EventEmitter | |
} | |
, { | |
events: 20 | |
}], | |
53: [function(t, e, r) { | |
var n = t("buffer") | |
, i = n.Buffer; | |
function o(t, e) { | |
for (var r in t) | |
e[r] = t[r] | |
} | |
function s(t, e, r) { | |
return i(t, e, r) | |
} | |
i.from && i.alloc && i.allocUnsafe && i.allocUnsafeSlow ? e.exports = n : (o(n, r), | |
r.Buffer = s), | |
o(i, s), | |
s.from = function(t, e, r) { | |
if ("number" == typeof t) | |
throw new TypeError("Argument must not be a number"); | |
return i(t, e, r) | |
} | |
, | |
s.alloc = function(t, e, r) { | |
if ("number" != typeof t) | |
throw new TypeError("Argument must be a number"); | |
var n = i(t); | |
return void 0 !== e ? "string" == typeof r ? n.fill(e, r) : n.fill(e) : n.fill(0), | |
n | |
} | |
, | |
s.allocUnsafe = function(t) { | |
if ("number" != typeof t) | |
throw new TypeError("Argument must be a number"); | |
return i(t) | |
} | |
, | |
s.allocUnsafeSlow = function(t) { | |
if ("number" != typeof t) | |
throw new TypeError("Argument must be a number"); | |
return n.SlowBuffer(t) | |
} | |
} | |
, { | |
buffer: 19 | |
}], | |
54: [function(t, e, r) { | |
"use strict"; | |
var n = t("safe-buffer").Buffer | |
, i = n.isEncoding || function(t) { | |
switch ((t = "" + t) && t.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 !0; | |
default: | |
return !1 | |
} | |
} | |
; | |
function o(t) { | |
var e; | |
switch (this.encoding = function(t) { | |
var e = function(t) { | |
if (!t) | |
return "utf8"; | |
for (var e; ; ) | |
switch (t) { | |
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 t; | |
default: | |
if (e) | |
return; | |
t = ("" + t).toLowerCase(), | |
e = !0 | |
} | |
}(t); | |
if ("string" != typeof e && (n.isEncoding === i || !i(t))) | |
throw new Error("Unknown encoding: " + t); | |
return e || t | |
}(t), | |
this.encoding) { | |
case "utf16le": | |
this.text = u, | |
this.end = c, | |
e = 4; | |
break; | |
case "utf8": | |
this.fillLast = a, | |
e = 4; | |
break; | |
case "base64": | |
this.text = f, | |
this.end = l, | |
e = 3; | |
break; | |
default: | |
return this.write = h, | |
void (this.end = p) | |
} | |
this.lastNeed = 0, | |
this.lastTotal = 0, | |
this.lastChar = n.allocUnsafe(e) | |
} | |
function s(t) { | |
return t <= 127 ? 0 : t >> 5 == 6 ? 2 : t >> 4 == 14 ? 3 : t >> 3 == 30 ? 4 : -1 | |
} | |
function a(t) { | |
var e = this.lastTotal - this.lastNeed | |
, r = function(t, e, r) { | |
if (128 != (192 & e[0])) | |
return t.lastNeed = 0, | |
"�".repeat(r); | |
if (t.lastNeed > 1 && e.length > 1) { | |
if (128 != (192 & e[1])) | |
return t.lastNeed = 1, | |
"�".repeat(r + 1); | |
if (t.lastNeed > 2 && e.length > 2 && 128 != (192 & e[2])) | |
return t.lastNeed = 2, | |
"�".repeat(r + 2) | |
} | |
}(this, t, e); | |
return void 0 !== r ? r : this.lastNeed <= t.length ? (t.copy(this.lastChar, e, 0, this.lastNeed), | |
this.lastChar.toString(this.encoding, 0, this.lastTotal)) : (t.copy(this.lastChar, e, 0, t.length), | |
void (this.lastNeed -= t.length)) | |
} | |
function u(t, e) { | |
if ((t.length - e) % 2 == 0) { | |
var r = t.toString("utf16le", e); | |
if (r) { | |
var n = r.charCodeAt(r.length - 1); | |
if (n >= 55296 && n <= 56319) | |
return this.lastNeed = 2, | |
this.lastTotal = 4, | |
this.lastChar[0] = t[t.length - 2], | |
this.lastChar[1] = t[t.length - 1], | |
r.slice(0, -1) | |
} | |
return r | |
} | |
return this.lastNeed = 1, | |
this.lastTotal = 2, | |
this.lastChar[0] = t[t.length - 1], | |
t.toString("utf16le", e, t.length - 1) | |
} | |
function c(t) { | |
var e = t && t.length ? this.write(t) : ""; | |
if (this.lastNeed) { | |
var r = this.lastTotal - this.lastNeed; | |
return e + this.lastChar.toString("utf16le", 0, r) | |
} | |
return e | |
} | |
function f(t, e) { | |
var r = (t.length - e) % 3; | |
return 0 === r ? t.toString("base64", e) : (this.lastNeed = 3 - r, | |
this.lastTotal = 3, | |
1 === r ? this.lastChar[0] = t[t.length - 1] : (this.lastChar[0] = t[t.length - 2], | |
this.lastChar[1] = t[t.length - 1]), | |
t.toString("base64", e, t.length - r)) | |
} | |
function l(t) { | |
var e = t && t.length ? this.write(t) : ""; | |
return this.lastNeed ? e + this.lastChar.toString("base64", 0, 3 - this.lastNeed) : e | |
} | |
function h(t) { | |
return t.toString(this.encoding) | |
} | |
function p(t) { | |
return t && t.length ? this.write(t) : "" | |
} | |
r.StringDecoder = o, | |
o.prototype.write = function(t) { | |
if (0 === t.length) | |
return ""; | |
var e, r; | |
if (this.lastNeed) { | |
if (void 0 === (e = this.fillLast(t))) | |
return ""; | |
r = this.lastNeed, | |
this.lastNeed = 0 | |
} else | |
r = 0; | |
return r < t.length ? e ? e + this.text(t, r) : this.text(t, r) : e || "" | |
} | |
, | |
o.prototype.end = function(t) { | |
var e = t && t.length ? this.write(t) : ""; | |
return this.lastNeed ? e + "�".repeat(this.lastTotal - this.lastNeed) : e | |
} | |
, | |
o.prototype.text = function(t, e) { | |
var r = function(t, e, r) { | |
var n = e.length - 1; | |
if (n < r) | |
return 0; | |
var i = s(e[n]); | |
if (i >= 0) | |
return i > 0 && (t.lastNeed = i - 1), | |
i; | |
if (--n < r) | |
return 0; | |
if ((i = s(e[n])) >= 0) | |
return i > 0 && (t.lastNeed = i - 2), | |
i; | |
if (--n < r) | |
return 0; | |
if ((i = s(e[n])) >= 0) | |
return i > 0 && (2 === i ? i = 0 : t.lastNeed = i - 3), | |
i; | |
return 0 | |
}(this, t, e); | |
if (!this.lastNeed) | |
return t.toString("utf8", e); | |
this.lastTotal = r; | |
var n = t.length - (r - this.lastNeed); | |
return t.copy(this.lastChar, 0, n), | |
t.toString("utf8", e, n) | |
} | |
, | |
o.prototype.fillLast = function(t) { | |
if (this.lastNeed <= t.length) | |
return t.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed), | |
this.lastChar.toString(this.encoding, 0, this.lastTotal); | |
t.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, t.length), | |
this.lastNeed -= t.length | |
} | |
} | |
, { | |
"safe-buffer": 53 | |
}], | |
55: [function(t, e, r) { | |
e.exports = t("./readable").PassThrough | |
} | |
, { | |
"./readable": 56 | |
}], | |
56: [function(t, e, r) { | |
(r = e.exports = t("./lib/_stream_readable.js")).Stream = r, | |
r.Readable = r, | |
r.Writable = t("./lib/_stream_writable.js"), | |
r.Duplex = t("./lib/_stream_duplex.js"), | |
r.Transform = t("./lib/_stream_transform.js"), | |
r.PassThrough = t("./lib/_stream_passthrough.js") | |
} | |
, { | |
"./lib/_stream_duplex.js": 45, | |
"./lib/_stream_passthrough.js": 46, | |
"./lib/_stream_readable.js": 47, | |
"./lib/_stream_transform.js": 48, | |
"./lib/_stream_writable.js": 49 | |
}], | |
57: [function(t, e, r) { | |
e.exports = t("./readable").Transform | |
} | |
, { | |
"./readable": 56 | |
}], | |
58: [function(t, e, r) { | |
e.exports = t("./lib/_stream_writable.js") | |
} | |
, { | |
"./lib/_stream_writable.js": 49 | |
}], | |
59: [function(t, e, r) { | |
const n = t("util") | |
, i = t("events/"); | |
var o = "object" == typeof Reflect ? Reflect : null | |
, s = o && "function" == typeof o.apply ? o.apply : function(t, e, r) { | |
return Function.prototype.apply.call(t, e, r) | |
} | |
; | |
function a() { | |
i.call(this) | |
} | |
function u(t, e, r) { | |
try { | |
s(t, e, r) | |
} catch (t) { | |
setTimeout(()=>{ | |
throw t | |
} | |
) | |
} | |
} | |
e.exports = a, | |
n.inherits(a, i), | |
a.prototype.emit = function(t) { | |
for (var e = [], r = 1; r < arguments.length; r++) | |
e.push(arguments[r]); | |
var n = "error" === t | |
, i = this._events; | |
if (void 0 !== i) | |
n = n && void 0 === i.error; | |
else if (!n) | |
return !1; | |
if (n) { | |
var o; | |
if (e.length > 0 && (o = e[0]), | |
o instanceof Error) | |
throw o; | |
var s = new Error("Unhandled error." + (o ? " (" + o.message + ")" : "")); | |
throw s.context = o, | |
s | |
} | |
var a = i[t]; | |
if (void 0 === a) | |
return !1; | |
if ("function" == typeof a) | |
u(a, this, e); | |
else { | |
var c = a.length | |
, f = function(t, e) { | |
for (var r = new Array(e), n = 0; n < e; ++n) | |
r[n] = t[n]; | |
return r | |
}(a, c); | |
for (r = 0; r < c; ++r) | |
u(f[r], this, e) | |
} | |
return !0 | |
} | |
} | |
, { | |
"events/": 23, | |
util: 66 | |
}], | |
60: [function(t, e, r) { | |
e.exports = i; | |
var n = t("events").EventEmitter; | |
function i() { | |
n.call(this) | |
} | |
t("inherits")(i, n), | |
i.Readable = t("readable-stream/readable.js"), | |
i.Writable = t("readable-stream/writable.js"), | |
i.Duplex = t("readable-stream/duplex.js"), | |
i.Transform = t("readable-stream/transform.js"), | |
i.PassThrough = t("readable-stream/passthrough.js"), | |
i.Stream = i, | |
i.prototype.pipe = function(t, e) { | |
var r = this; | |
function i(e) { | |
t.writable && !1 === t.write(e) && r.pause && r.pause() | |
} | |
function o() { | |
r.readable && r.resume && r.resume() | |
} | |
r.on("data", i), | |
t.on("drain", o), | |
t._isStdio || e && !1 === e.end || (r.on("end", a), | |
r.on("close", u)); | |
var s = !1; | |
function a() { | |
s || (s = !0, | |
t.end()) | |
} | |
function u() { | |
s || (s = !0, | |
"function" == typeof t.destroy && t.destroy()) | |
} | |
function c(t) { | |
if (f(), | |
0 === n.listenerCount(this, "error")) | |
throw t | |
} | |
function f() { | |
r.removeListener("data", i), | |
t.removeListener("drain", o), | |
r.removeListener("end", a), | |
r.removeListener("close", u), | |
r.removeListener("error", c), | |
t.removeListener("error", c), | |
r.removeListener("end", f), | |
r.removeListener("close", f), | |
t.removeListener("close", f) | |
} | |
return r.on("error", c), | |
t.on("error", c), | |
r.on("end", f), | |
r.on("close", f), | |
t.on("close", f), | |
t.emit("pipe", r), | |
t | |
} | |
} | |
, { | |
events: 20, | |
inherits: 61, | |
"readable-stream/duplex.js": 44, | |
"readable-stream/passthrough.js": 55, | |
"readable-stream/readable.js": 56, | |
"readable-stream/transform.js": 57, | |
"readable-stream/writable.js": 58 | |
}], | |
61: [function(t, e, r) { | |
"function" == typeof Object.create ? e.exports = function(t, e) { | |
t.super_ = e, | |
t.prototype = Object.create(e.prototype, { | |
constructor: { | |
value: t, | |
enumerable: !1, | |
writable: !0, | |
configurable: !0 | |
} | |
}) | |
} | |
: e.exports = function(t, e) { | |
t.super_ = e; | |
var r = function() {}; | |
r.prototype = e.prototype, | |
t.prototype = new r, | |
t.prototype.constructor = t | |
} | |
} | |
, {}], | |
62: [function(t, e, r) { | |
(function(e, n) { | |
var i = t("process/browser.js").nextTick | |
, o = Function.prototype.apply | |
, s = Array.prototype.slice | |
, a = {} | |
, u = 0; | |
function c(t, e) { | |
this._id = t, | |
this._clearFn = e | |
} | |
r.setTimeout = function() { | |
return new c(o.call(setTimeout, window, arguments),clearTimeout) | |
} | |
, | |
r.setInterval = function() { | |
return new c(o.call(setInterval, window, arguments),clearInterval) | |
} | |
, | |
r.clearTimeout = r.clearInterval = function(t) { | |
t.close() | |
} | |
, | |
c.prototype.unref = c.prototype.ref = function() {} | |
, | |
c.prototype.close = function() { | |
this._clearFn.call(window, this._id) | |
} | |
, | |
r.enroll = function(t, e) { | |
clearTimeout(t._idleTimeoutId), | |
t._idleTimeout = e | |
} | |
, | |
r.unenroll = function(t) { | |
clearTimeout(t._idleTimeoutId), | |
t._idleTimeout = -1 | |
} | |
, | |
r._unrefActive = r.active = function(t) { | |
clearTimeout(t._idleTimeoutId); | |
var e = t._idleTimeout; | |
e >= 0 && (t._idleTimeoutId = setTimeout(function() { | |
t._onTimeout && t._onTimeout() | |
}, e)) | |
} | |
, | |
r.setImmediate = "function" == typeof e ? e : function(t) { | |
var e = u++ | |
, n = !(arguments.length < 2) && s.call(arguments, 1); | |
return a[e] = !0, | |
i(function() { | |
a[e] && (n ? t.apply(null, n) : t.call(null), | |
r.clearImmediate(e)) | |
}), | |
e | |
} | |
, | |
r.clearImmediate = "function" == typeof n ? n : function(t) { | |
delete a[t] | |
} | |
} | |
).call(this, t("timers").setImmediate, t("timers").clearImmediate) | |
} | |
, { | |
"process/browser.js": 42, | |
timers: 62 | |
}], | |
63: [function(t, e, r) { | |
(function(t) { | |
function r(e) { | |
try { | |
if (!t.localStorage) | |
return !1 | |
} catch (t) { | |
return !1 | |
} | |
var r = t.localStorage[e]; | |
return null != r && "true" === String(r).toLowerCase() | |
} | |
e.exports = function(t, e) { | |
if (r("noDeprecation")) | |
return t; | |
var n = !1; | |
return function() { | |
if (!n) { | |
if (r("throwDeprecation")) | |
throw new Error(e); | |
r("traceDeprecation") ? console.trace(e) : console.warn(e), | |
n = !0 | |
} | |
return t.apply(this, arguments) | |
} | |
} | |
} | |
).call(this, "undefined" != typeof global ? global : "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}) | |
} | |
, {}], | |
64: [function(t, e, r) { | |
arguments[4][61][0].apply(r, arguments) | |
} | |
, { | |
dup: 61 | |
}], | |
65: [function(t, e, r) { | |
e.exports = function(t) { | |
return t && "object" == typeof t && "function" == typeof t.copy && "function" == typeof t.fill && "function" == typeof t.readUInt8 | |
} | |
} | |
, {}], | |
66: [function(t, e, r) { | |
(function(e, n) { | |
var i = /%[sdj%]/g; | |
r.format = function(t) { | |
if (!g(t)) { | |
for (var e = [], r = 0; r < arguments.length; r++) | |
e.push(a(arguments[r])); | |
return e.join(" ") | |
} | |
r = 1; | |
for (var n = arguments, o = n.length, s = String(t).replace(i, function(t) { | |
if ("%%" === t) | |
return "%"; | |
if (r >= o) | |
return t; | |
switch (t) { | |
case "%s": | |
return String(n[r++]); | |
case "%d": | |
return Number(n[r++]); | |
case "%j": | |
try { | |
return JSON.stringify(n[r++]) | |
} catch (t) { | |
return "[Circular]" | |
} | |
default: | |
return t | |
} | |
}), u = n[r]; r < o; u = n[++r]) | |
y(u) || !w(u) ? s += " " + u : s += " " + a(u); | |
return s | |
} | |
, | |
r.deprecate = function(t, i) { | |
if (v(n.process)) | |
return function() { | |
return r.deprecate(t, i).apply(this, arguments) | |
} | |
; | |
if (!0 === e.noDeprecation) | |
return t; | |
var o = !1; | |
return function() { | |
if (!o) { | |
if (e.throwDeprecation) | |
throw new Error(i); | |
e.traceDeprecation ? console.trace(i) : console.error(i), | |
o = !0 | |
} | |
return t.apply(this, arguments) | |
} | |
} | |
; | |
var o, s = {}; | |
function a(t, e) { | |
var n = { | |
seen: [], | |
stylize: c | |
}; | |
return arguments.length >= 3 && (n.depth = arguments[2]), | |
arguments.length >= 4 && (n.colors = arguments[3]), | |
d(e) ? n.showHidden = e : e && r._extend(n, e), | |
v(n.showHidden) && (n.showHidden = !1), | |
v(n.depth) && (n.depth = 2), | |
v(n.colors) && (n.colors = !1), | |
v(n.customInspect) && (n.customInspect = !0), | |
n.colors && (n.stylize = u), | |
f(n, t, n.depth) | |
} | |
function u(t, e) { | |
var r = a.styles[e]; | |
return r ? "[" + a.colors[r][0] + "m" + t + "[" + a.colors[r][1] + "m" : t | |
} | |
function c(t, e) { | |
return t | |
} | |
function f(t, e, n) { | |
if (t.customInspect && e && S(e.inspect) && e.inspect !== r.inspect && (!e.constructor || e.constructor.prototype !== e)) { | |
var i = e.inspect(n, t); | |
return g(i) || (i = f(t, i, n)), | |
i | |
} | |
var o = function(t, e) { | |
if (v(e)) | |
return t.stylize("undefined", "undefined"); | |
if (g(e)) { | |
var r = "'" + JSON.stringify(e).replace(/^"|"$/g, "").replace(/'/g, "\\'").replace(/\\"/g, '"') + "'"; | |
return t.stylize(r, "string") | |
} | |
if (m(e)) | |
return t.stylize("" + e, "number"); | |
if (d(e)) | |
return t.stylize("" + e, "boolean"); | |
if (y(e)) | |
return t.stylize("null", "null") | |
}(t, e); | |
if (o) | |
return o; | |
var s = Object.keys(e) | |
, a = function(t) { | |
var e = {}; | |
return t.forEach(function(t, r) { | |
e[t] = !0 | |
}), | |
e | |
}(s); | |
if (t.showHidden && (s = Object.getOwnPropertyNames(e)), | |
x(e) && (s.indexOf("message") >= 0 || s.indexOf("description") >= 0)) | |
return l(e); | |
if (0 === s.length) { | |
if (S(e)) { | |
var u = e.name ? ": " + e.name : ""; | |
return t.stylize("[Function" + u + "]", "special") | |
} | |
if (b(e)) | |
return t.stylize(RegExp.prototype.toString.call(e), "regexp"); | |
if (_(e)) | |
return t.stylize(Date.prototype.toString.call(e), "date"); | |
if (x(e)) | |
return l(e) | |
} | |
var c, w = "", k = !1, E = ["{", "}"]; | |
(p(e) && (k = !0, | |
E = ["[", "]"]), | |
S(e)) && (w = " [Function" + (e.name ? ": " + e.name : "") + "]"); | |
return b(e) && (w = " " + RegExp.prototype.toString.call(e)), | |
_(e) && (w = " " + Date.prototype.toUTCString.call(e)), | |
x(e) && (w = " " + l(e)), | |
0 !== s.length || k && 0 != e.length ? n < 0 ? b(e) ? t.stylize(RegExp.prototype.toString.call(e), "regexp") : t.stylize("[Object]", "special") : (t.seen.push(e), | |
c = k ? function(t, e, r, n, i) { | |
for (var o = [], s = 0, a = e.length; s < a; ++s) | |
C(e, String(s)) ? o.push(h(t, e, r, n, String(s), !0)) : o.push(""); | |
return i.forEach(function(i) { | |
i.match(/^\d+$/) || o.push(h(t, e, r, n, i, !0)) | |
}), | |
o | |
}(t, e, n, a, s) : s.map(function(r) { | |
return h(t, e, n, a, r, k) | |
}), | |
t.seen.pop(), | |
function(t, e, r) { | |
if (t.reduce(function(t, e) { | |
return 0, | |
e.indexOf("\n") >= 0 && 0, | |
t + e.replace(/\u001b\[\d\d?m/g, "").length + 1 | |
}, 0) > 60) | |
return r[0] + ("" === e ? "" : e + "\n ") + " " + t.join(",\n ") + " " + r[1]; | |
return r[0] + e + " " + t.join(", ") + " " + r[1] | |
}(c, w, E)) : E[0] + w + E[1] | |
} | |
function l(t) { | |
return "[" + Error.prototype.toString.call(t) + "]" | |
} | |
function h(t, e, r, n, i, o) { | |
var s, a, u; | |
if ((u = Object.getOwnPropertyDescriptor(e, i) || { | |
value: e[i] | |
}).get ? a = u.set ? t.stylize("[Getter/Setter]", "special") : t.stylize("[Getter]", "special") : u.set && (a = t.stylize("[Setter]", "special")), | |
C(n, i) || (s = "[" + i + "]"), | |
a || (t.seen.indexOf(u.value) < 0 ? (a = y(r) ? f(t, u.value, null) : f(t, u.value, r - 1)).indexOf("\n") > -1 && (a = o ? a.split("\n").map(function(t) { | |
return " " + t | |
}).join("\n").substr(2) : "\n" + a.split("\n").map(function(t) { | |
return " " + t | |
}).join("\n")) : a = t.stylize("[Circular]", "special")), | |
v(s)) { | |
if (o && i.match(/^\d+$/)) | |
return a; | |
(s = JSON.stringify("" + i)).match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/) ? (s = s.substr(1, s.length - 2), | |
s = t.stylize(s, "name")) : (s = s.replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'"), | |
s = t.stylize(s, "string")) | |
} | |
return s + ": " + a | |
} | |
function p(t) { | |
return Array.isArray(t) | |
} | |
function d(t) { | |
return "boolean" == typeof t | |
} | |
function y(t) { | |
return null === t | |
} | |
function m(t) { | |
return "number" == typeof t | |
} | |
function g(t) { | |
return "string" == typeof t | |
} | |
function v(t) { | |
return void 0 === t | |
} | |
function b(t) { | |
return w(t) && "[object RegExp]" === k(t) | |
} | |
function w(t) { | |
return "object" == typeof t && null !== t | |
} | |
function _(t) { | |
return w(t) && "[object Date]" === k(t) | |
} | |
function x(t) { | |
return w(t) && ("[object Error]" === k(t) || t instanceof Error) | |
} | |
function S(t) { | |
return "function" == typeof t | |
} | |
function k(t) { | |
return Object.prototype.toString.call(t) | |
} | |
function E(t) { | |
return t < 10 ? "0" + t.toString(10) : t.toString(10) | |
} | |
r.debuglog = function(t) { | |
if (v(o) && (o = e.env.NODE_DEBUG || ""), | |
t = t.toUpperCase(), | |
!s[t]) | |
if (new RegExp("\\b" + t + "\\b","i").test(o)) { | |
var n = e.pid; | |
s[t] = function() { | |
var e = r.format.apply(r, arguments); | |
console.error("%s %d: %s", t, n, e) | |
} | |
} else | |
s[t] = function() {} | |
; | |
return s[t] | |
} | |
, | |
r.inspect = a, | |
a.colors = { | |
bold: [1, 22], | |
italic: [3, 23], | |
underline: [4, 24], | |
inverse: [7, 27], | |
white: [37, 39], | |
grey: [90, 39], | |
black: [30, 39], | |
blue: [34, 39], | |
cyan: [36, 39], | |
green: [32, 39], | |
magenta: [35, 39], | |
red: [31, 39], | |
yellow: [33, 39] | |
}, | |
a.styles = { | |
special: "cyan", | |
number: "yellow", | |
boolean: "yellow", | |
undefined: "grey", | |
null: "bold", | |
string: "green", | |
date: "magenta", | |
regexp: "red" | |
}, | |
r.isArray = p, | |
r.isBoolean = d, | |
r.isNull = y, | |
r.isNullOrUndefined = function(t) { | |
return null == t | |
} | |
, | |
r.isNumber = m, | |
r.isString = g, | |
r.isSymbol = function(t) { | |
return "symbol" == typeof t | |
} | |
, | |
r.isUndefined = v, | |
r.isRegExp = b, | |
r.isObject = w, | |
r.isDate = _, | |
r.isError = x, | |
r.isFunction = S, | |
r.isPrimitive = function(t) { | |
return null === t || "boolean" == typeof t || "number" == typeof t || "string" == typeof t || "symbol" == typeof t || void 0 === t | |
} | |
, | |
r.isBuffer = t("./support/isBuffer"); | |
var A = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]; | |
function C(t, e) { | |
return Object.prototype.hasOwnProperty.call(t, e) | |
} | |
r.log = function() { | |
var t, e; | |
console.log("%s - %s", (t = new Date, | |
e = [E(t.getHours()), E(t.getMinutes()), E(t.getSeconds())].join(":"), | |
[t.getDate(), A[t.getMonth()], e].join(" ")), r.format.apply(r, arguments)) | |
} | |
, | |
r.inherits = t("inherits"), | |
r._extend = function(t, e) { | |
if (!e || !w(e)) | |
return t; | |
for (var r = Object.keys(e), n = r.length; n--; ) | |
t[r[n]] = e[r[n]]; | |
return t | |
} | |
} | |
).call(this, t("_process"), "undefined" != typeof global ? global : "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}) | |
} | |
, { | |
"./support/isBuffer": 65, | |
_process: 42, | |
inherits: 64 | |
}], | |
67: [function(t, e, r) { | |
(function(e) { | |
t = function e(r, n, i) { | |
function o(a, u) { | |
if (!n[a]) { | |
if (!r[a]) { | |
var c = "function" == typeof t && t; | |
if (!u && c) | |
return c(a, !0); | |
if (s) | |
return s(a, !0); | |
var f = new Error("Cannot find module '" + a + "'"); | |
throw f.code = "MODULE_NOT_FOUND", | |
f | |
} | |
var l = n[a] = { | |
exports: {} | |
}; | |
r[a][0].call(l.exports, function(t) { | |
return o(r[a][1][t] || t) | |
}, l, l.exports, e, r, n, i) | |
} | |
return n[a].exports | |
} | |
for (var s = "function" == typeof t && t, a = 0; a < i.length; a++) | |
o(i[a]); | |
return o | |
}({ | |
1: [function(t, e, r) { | |
e.exports = [{ | |
constant: !0, | |
inputs: [{ | |
name: "_owner", | |
type: "address" | |
}], | |
name: "name", | |
outputs: [{ | |
name: "o_name", | |
type: "bytes32" | |
}], | |
type: "function" | |
}, { | |
constant: !0, | |
inputs: [{ | |
name: "_name", | |
type: "bytes32" | |
}], | |
name: "owner", | |
outputs: [{ | |
name: "", | |
type: "address" | |
}], | |
type: "function" | |
}, { | |
constant: !0, | |
inputs: [{ | |
name: "_name", | |
type: "bytes32" | |
}], | |
name: "content", | |
outputs: [{ | |
name: "", | |
type: "bytes32" | |
}], | |
type: "function" | |
}, { | |
constant: !0, | |
inputs: [{ | |
name: "_name", | |
type: "bytes32" | |
}], | |
name: "addr", | |
outputs: [{ | |
name: "", | |
type: "address" | |
}], | |
type: "function" | |
}, { | |
constant: !1, | |
inputs: [{ | |
name: "_name", | |
type: "bytes32" | |
}], | |
name: "reserve", | |
outputs: [], | |
type: "function" | |
}, { | |
constant: !0, | |
inputs: [{ | |
name: "_name", | |
type: "bytes32" | |
}], | |
name: "subRegistrar", | |
outputs: [{ | |
name: "", | |
type: "address" | |
}], | |
type: "function" | |
}, { | |
constant: !1, | |
inputs: [{ | |
name: "_name", | |
type: "bytes32" | |
}, { | |
name: "_newOwner", | |
type: "address" | |
}], | |
name: "transfer", | |
outputs: [], | |
type: "function" | |
}, { | |
constant: !1, | |
inputs: [{ | |
name: "_name", | |
type: "bytes32" | |
}, { | |
name: "_registrar", | |
type: "address" | |
}], | |
name: "setSubRegistrar", | |
outputs: [], | |
type: "function" | |
}, { | |
constant: !1, | |
inputs: [], | |
name: "Registrar", | |
outputs: [], | |
type: "function" | |
}, { | |
constant: !1, | |
inputs: [{ | |
name: "_name", | |
type: "bytes32" | |
}, { | |
name: "_a", | |
type: "address" | |
}, { | |
name: "_primary", | |
type: "bool" | |
}], | |
name: "setAddress", | |
outputs: [], | |
type: "function" | |
}, { | |
constant: !1, | |
inputs: [{ | |
name: "_name", | |
type: "bytes32" | |
}, { | |
name: "_content", | |
type: "bytes32" | |
}], | |
name: "setContent", | |
outputs: [], | |
type: "function" | |
}, { | |
constant: !1, | |
inputs: [{ | |
name: "_name", | |
type: "bytes32" | |
}], | |
name: "disown", | |
outputs: [], | |
type: "function" | |
}, { | |
anonymous: !1, | |
inputs: [{ | |
indexed: !0, | |
name: "_name", | |
type: "bytes32" | |
}, { | |
indexed: !1, | |
name: "_winner", | |
type: "address" | |
}], | |
name: "AuctionEnded", | |
type: "event" | |
}, { | |
anonymous: !1, | |
inputs: [{ | |
indexed: !0, | |
name: "_name", | |
type: "bytes32" | |
}, { | |
indexed: !1, | |
name: "_bidder", | |
type: "address" | |
}, { | |
indexed: !1, | |
name: "_value", | |
type: "uint256" | |
}], | |
name: "NewBid", | |
type: "event" | |
}, { | |
anonymous: !1, | |
inputs: [{ | |
indexed: !0, | |
name: "name", | |
type: "bytes32" | |
}], | |
name: "Changed", | |
type: "event" | |
}, { | |
anonymous: !1, | |
inputs: [{ | |
indexed: !0, | |
name: "name", | |
type: "bytes32" | |
}, { | |
indexed: !0, | |
name: "addr", | |
type: "address" | |
}], | |
name: "PrimaryChanged", | |
type: "event" | |
}] | |
} | |
, {}], | |
2: [function(t, e, r) { | |
e.exports = [{ | |
constant: !0, | |
inputs: [{ | |
name: "_name", | |
type: "bytes32" | |
}], | |
name: "owner", | |
outputs: [{ | |
name: "", | |
type: "address" | |
}], | |
type: "function" | |
}, { | |
constant: !1, | |
inputs: [{ | |
name: "_name", | |
type: "bytes32" | |
}, { | |
name: "_refund", | |
type: "address" | |
}], | |
name: "disown", | |
outputs: [], | |
type: "function" | |
}, { | |
constant: !0, | |
inputs: [{ | |
name: "_name", | |
type: "bytes32" | |
}], | |
name: "addr", | |
outputs: [{ | |
name: "", | |
type: "address" | |
}], | |
type: "function" | |
}, { | |
constant: !1, | |
inputs: [{ | |
name: "_name", | |
type: "bytes32" | |
}], | |
name: "reserve", | |
outputs: [], | |
type: "function" | |
}, { | |
constant: !1, | |
inputs: [{ | |
name: "_name", | |
type: "bytes32" | |
}, { | |
name: "_newOwner", | |
type: "address" | |
}], | |
name: "transfer", | |
outputs: [], | |
type: "function" | |
}, { | |
constant: !1, | |
inputs: [{ | |
name: "_name", | |
type: "bytes32" | |
}, { | |
name: "_a", | |
type: "address" | |
}], | |
name: "setAddr", | |
outputs: [], | |
type: "function" | |
}, { | |
anonymous: !1, | |
inputs: [{ | |
indexed: !0, | |
name: "name", | |
type: "bytes32" | |
}], | |
name: "Changed", | |
type: "event" | |
}] | |
} | |
, {}], | |
3: [function(t, e, r) { | |
e.exports = [{ | |
constant: !1, | |
inputs: [{ | |
name: "from", | |
type: "bytes32" | |
}, { | |
name: "to", | |
type: "address" | |
}, { | |
name: "value", | |
type: "uint256" | |
}], | |
name: "transfer", | |
outputs: [], | |
type: "function" | |
}, { | |
constant: !1, | |
inputs: [{ | |
name: "from", | |
type: "bytes32" | |
}, { | |
name: "to", | |
type: "address" | |
}, { | |
name: "indirectId", | |
type: "bytes32" | |
}, { | |
name: "value", | |
type: "uint256" | |
}], | |
name: "icapTransfer", | |
outputs: [], | |
type: "function" | |
}, { | |
constant: !1, | |
inputs: [{ | |
name: "to", | |
type: "bytes32" | |
}], | |
name: "deposit", | |
outputs: [], | |
payable: !0, | |
type: "function" | |
}, { | |
anonymous: !1, | |
inputs: [{ | |
indexed: !0, | |
name: "from", | |
type: "address" | |
}, { | |
indexed: !1, | |
name: "value", | |
type: "uint256" | |
}], | |
name: "AnonymousDeposit", | |
type: "event" | |
}, { | |
anonymous: !1, | |
inputs: [{ | |
indexed: !0, | |
name: "from", | |
type: "address" | |
}, { | |
indexed: !0, | |
name: "to", | |
type: "bytes32" | |
}, { | |
indexed: !1, | |
name: "value", | |
type: "uint256" | |
}], | |
name: "Deposit", | |
type: "event" | |
}, { | |
anonymous: !1, | |
inputs: [{ | |
indexed: !0, | |
name: "from", | |
type: "bytes32" | |
}, { | |
indexed: !0, | |
name: "to", | |
type: "address" | |
}, { | |
indexed: !1, | |
name: "value", | |
type: "uint256" | |
}], | |
name: "Transfer", | |
type: "event" | |
}, { | |
anonymous: !1, | |
inputs: [{ | |
indexed: !0, | |
name: "from", | |
type: "bytes32" | |
}, { | |
indexed: !0, | |
name: "to", | |
type: "address" | |
}, { | |
indexed: !1, | |
name: "indirectId", | |
type: "bytes32" | |
}, { | |
indexed: !1, | |
name: "value", | |
type: "uint256" | |
}], | |
name: "IcapTransfer", | |
type: "event" | |
}] | |
} | |
, {}], | |
4: [function(t, e, r) { | |
var n = t("./formatters") | |
, i = t("./type") | |
, o = function() { | |
this._inputFormatter = n.formatInputInt, | |
this._outputFormatter = n.formatOutputAddress | |
}; | |
((o.prototype = new i({})).constructor = o).prototype.isType = function(t) { | |
return !!t.match(/address(\[([0-9]*)\])?/) | |
} | |
, | |
e.exports = o | |
} | |
, { | |
"./formatters": 9, | |
"./type": 14 | |
}], | |
5: [function(t, e, r) { | |
var n = t("./formatters") | |
, i = t("./type") | |
, o = function() { | |
this._inputFormatter = n.formatInputBool, | |
this._outputFormatter = n.formatOutputBool | |
}; | |
((o.prototype = new i({})).constructor = o).prototype.isType = function(t) { | |
return !!t.match(/^bool(\[([0-9]*)\])*$/) | |
} | |
, | |
e.exports = o | |
} | |
, { | |
"./formatters": 9, | |
"./type": 14 | |
}], | |
6: [function(t, e, r) { | |
var n = t("./formatters") | |
, i = t("./type") | |
, o = function() { | |
this._inputFormatter = n.formatInputBytes, | |
this._outputFormatter = n.formatOutputBytes | |
}; | |
((o.prototype = new i({})).constructor = o).prototype.isType = function(t) { | |
return !!t.match(/^bytes([0-9]{1,})(\[([0-9]*)\])*$/) | |
} | |
, | |
e.exports = o | |
} | |
, { | |
"./formatters": 9, | |
"./type": 14 | |
}], | |
7: [function(t, e, r) { | |
var n = t("./formatters") | |
, i = t("./address") | |
, o = t("./bool") | |
, s = t("./int") | |
, a = t("./uint") | |
, u = t("./dynamicbytes") | |
, c = t("./string") | |
, f = t("./real") | |
, l = t("./ureal") | |
, h = t("./bytes") | |
, p = function(t, e) { | |
return t.isDynamicType(e) || t.isDynamicArray(e) | |
} | |
, d = function(t) { | |
this._types = t | |
}; | |
d.prototype._requireType = function(t) { | |
var e = this._types.filter(function(e) { | |
return e.isType(t) | |
})[0]; | |
if (!e) | |
throw Error("invalid solidity type!: " + t); | |
return e | |
} | |
, | |
d.prototype.encodeParam = function(t, e) { | |
return this.encodeParams([t], [e]) | |
} | |
, | |
d.prototype.encodeParams = function(t, e) { | |
var r = this.getSolidityTypes(t) | |
, n = r.map(function(r, n) { | |
return r.encode(e[n], t[n]) | |
}) | |
, i = r.reduce(function(e, n, i) { | |
var o = n.staticPartLength(t[i]) | |
, s = 32 * Math.floor((o + 31) / 32); | |
return e + (p(r[i], t[i]) ? 32 : s) | |
}, 0); | |
return this.encodeMultiWithOffset(t, r, n, i) | |
} | |
, | |
d.prototype.encodeMultiWithOffset = function(t, e, r, i) { | |
var o = "" | |
, s = this; | |
return t.forEach(function(a, u) { | |
if (p(e[u], t[u])) { | |
o += n.formatInputInt(i).encode(); | |
var c = s.encodeWithOffset(t[u], e[u], r[u], i); | |
i += c.length / 2 | |
} else | |
o += s.encodeWithOffset(t[u], e[u], r[u], i) | |
}), | |
t.forEach(function(n, a) { | |
if (p(e[a], t[a])) { | |
var u = s.encodeWithOffset(t[a], e[a], r[a], i); | |
i += u.length / 2, | |
o += u | |
} | |
}), | |
o | |
} | |
, | |
d.prototype.encodeWithOffset = function(t, e, r, i) { | |
var o = e.isDynamicArray(t) ? 1 : e.isStaticArray(t) ? 2 : 3; | |
if (3 !== o) { | |
var s = e.nestedName(t) | |
, a = e.staticPartLength(s) | |
, u = 1 === o ? r[0] : ""; | |
if (e.isDynamicArray(s)) | |
for (var c = 1 === o ? 2 : 0, f = 0; f < r.length; f++) | |
1 === o ? c += +r[f - 1][0] || 0 : 2 === o && (c += +(r[f - 1] || [])[0] || 0), | |
u += n.formatInputInt(i + f * a + 32 * c).encode(); | |
for (var l = 1 === o ? r.length - 1 : r.length, h = 0; h < l; h++) { | |
var p = u / 2; | |
1 === o ? u += this.encodeWithOffset(s, e, r[h + 1], i + p) : 2 === o && (u += this.encodeWithOffset(s, e, r[h], i + p)) | |
} | |
return u | |
} | |
return r | |
} | |
, | |
d.prototype.decodeParam = function(t, e) { | |
return this.decodeParams([t], e)[0] | |
} | |
, | |
d.prototype.decodeParams = function(t, e) { | |
var r = this.getSolidityTypes(t) | |
, n = this.getOffsets(t, r); | |
return r.map(function(r, i) { | |
return r.decode(e, n[i], t[i], i) | |
}) | |
} | |
, | |
d.prototype.getOffsets = function(t, e) { | |
for (var r = e.map(function(e, r) { | |
return e.staticPartLength(t[r]) | |
}), n = 1; n < r.length; n++) | |
r[n] += r[n - 1]; | |
return r.map(function(r, n) { | |
return r - e[n].staticPartLength(t[n]) | |
}) | |
} | |
, | |
d.prototype.getSolidityTypes = function(t) { | |
var e = this; | |
return t.map(function(t) { | |
return e._requireType(t) | |
}) | |
} | |
; | |
var y = new d([new i, new o, new s, new a, new u, new h, new c, new f, new l]); | |
e.exports = y | |
} | |
, { | |
"./address": 4, | |
"./bool": 5, | |
"./bytes": 6, | |
"./dynamicbytes": 8, | |
"./formatters": 9, | |
"./int": 10, | |
"./real": 12, | |
"./string": 13, | |
"./uint": 15, | |
"./ureal": 16 | |
}], | |
8: [function(t, e, r) { | |
var n = t("./formatters") | |
, i = t("./type") | |
, o = function() { | |
this._inputFormatter = n.formatInputDynamicBytes, | |
this._outputFormatter = n.formatOutputDynamicBytes | |
}; | |
((o.prototype = new i({})).constructor = o).prototype.isType = function(t) { | |
return !!t.match(/^bytes(\[([0-9]*)\])*$/) | |
} | |
, | |
o.prototype.isDynamicType = function() { | |
return !0 | |
} | |
, | |
e.exports = o | |
} | |
, { | |
"./formatters": 9, | |
"./type": 14 | |
}], | |
9: [function(t, e, r) { | |
var n = t("bignumber.js") | |
, i = t("../utils/utils") | |
, o = t("../utils/config") | |
, s = t("./param") | |
, a = function(t) { | |
n.config(o.ETH_BIGNUMBER_ROUNDING_MODE); | |
var e = i.padLeft(i.toTwosComplement(t).toString(16), 64); | |
return new s(e) | |
} | |
, u = function(t) { | |
var e = t.staticPart() || "0"; | |
return "1" === new n(e.substr(0, 1),16).toString(2).substr(0, 1) ? new n(e,16).minus(new n("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",16)).minus(1) : new n(e,16) | |
} | |
, c = function(t) { | |
var e = t.staticPart() || "0"; | |
return new n(e,16) | |
}; | |
e.exports = { | |
formatInputInt: a, | |
formatInputBytes: function(t) { | |
var e = i.toHex(t).substr(2) | |
, r = Math.floor((e.length + 63) / 64); | |
return e = i.padRight(e, 64 * r), | |
new s(e) | |
}, | |
formatInputDynamicBytes: function(t) { | |
var e = i.toHex(t).substr(2) | |
, r = e.length / 2 | |
, n = Math.floor((e.length + 63) / 64); | |
return e = i.padRight(e, 64 * n), | |
new s(a(r).value + e) | |
}, | |
formatInputString: function(t) { | |
var e = i.fromUtf8(t).substr(2) | |
, r = e.length / 2 | |
, n = Math.floor((e.length + 63) / 64); | |
return e = i.padRight(e, 64 * n), | |
new s(a(r).value + e) | |
}, | |
formatInputBool: function(t) { | |
return new s("000000000000000000000000000000000000000000000000000000000000000" + (t ? "1" : "0")) | |
}, | |
formatInputReal: function(t) { | |
return a(new n(t).times(new n(2).pow(128))) | |
}, | |
formatOutputInt: u, | |
formatOutputUInt: c, | |
formatOutputReal: function(t) { | |
return u(t).dividedBy(new n(2).pow(128)) | |
}, | |
formatOutputUReal: function(t) { | |
return c(t).dividedBy(new n(2).pow(128)) | |
}, | |
formatOutputBool: function(t) { | |
return "0000000000000000000000000000000000000000000000000000000000000001" === t.staticPart() | |
}, | |
formatOutputBytes: function(t, e) { | |
var r = e.match(/^bytes([0-9]*)/) | |
, n = parseInt(r[1]); | |
return "0x" + t.staticPart().slice(0, 2 * n) | |
}, | |
formatOutputDynamicBytes: function(t) { | |
var e = 2 * new n(t.dynamicPart().slice(0, 64),16).toNumber(); | |
return "0x" + t.dynamicPart().substr(64, e) | |
}, | |
formatOutputString: function(t) { | |
var e = 2 * new n(t.dynamicPart().slice(0, 64),16).toNumber(); | |
return i.toUtf8(t.dynamicPart().substr(64, e)) | |
}, | |
formatOutputAddress: function(t) { | |
var e = t.staticPart(); | |
return "0x" + e.slice(e.length - 40, e.length) | |
} | |
} | |
} | |
, { | |
"../utils/config": 18, | |
"../utils/utils": 20, | |
"./param": 11, | |
"bignumber.js": "bignumber.js" | |
}], | |
10: [function(t, e, r) { | |
var n = t("./formatters") | |
, i = t("./type") | |
, o = function() { | |
this._inputFormatter = n.formatInputInt, | |
this._outputFormatter = n.formatOutputInt | |
}; | |
((o.prototype = new i({})).constructor = o).prototype.isType = function(t) { | |
return !!t.match(/^int([0-9]*)?(\[([0-9]*)\])*$/) | |
} | |
, | |
e.exports = o | |
} | |
, { | |
"./formatters": 9, | |
"./type": 14 | |
}], | |
11: [function(t, e, r) { | |
var n = t("../utils/utils") | |
, i = function(t, e) { | |
this.value = t || "", | |
this.offset = e | |
}; | |
i.prototype.dynamicPartLength = function() { | |
return this.dynamicPart().length / 2 | |
} | |
, | |
i.prototype.withOffset = function(t) { | |
return new i(this.value,t) | |
} | |
, | |
i.prototype.combine = function(t) { | |
return new i(this.value + t.value) | |
} | |
, | |
i.prototype.isDynamic = function() { | |
return void 0 !== this.offset | |
} | |
, | |
i.prototype.offsetAsBytes = function() { | |
return this.isDynamic() ? n.padLeft(n.toTwosComplement(this.offset).toString(16), 64) : "" | |
} | |
, | |
i.prototype.staticPart = function() { | |
return this.isDynamic() ? this.offsetAsBytes() : this.value | |
} | |
, | |
i.prototype.dynamicPart = function() { | |
return this.isDynamic() ? this.value : "" | |
} | |
, | |
i.prototype.encode = function() { | |
return this.staticPart() + this.dynamicPart() | |
} | |
, | |
i.encodeList = function(t) { | |
var e = 32 * t.length | |
, r = t.map(function(t) { | |
if (!t.isDynamic()) | |
return t; | |
var r = e; | |
return e += t.dynamicPartLength(), | |
t.withOffset(r) | |
}); | |
return r.reduce(function(t, e) { | |
return t + e.dynamicPart() | |
}, r.reduce(function(t, e) { | |
return t + e.staticPart() | |
}, "")) | |
} | |
, | |
e.exports = i | |
} | |
, { | |
"../utils/utils": 20 | |
}], | |
12: [function(t, e, r) { | |
var n = t("./formatters") | |
, i = t("./type") | |
, o = function() { | |
this._inputFormatter = n.formatInputReal, | |
this._outputFormatter = n.formatOutputReal | |
}; | |
((o.prototype = new i({})).constructor = o).prototype.isType = function(t) { | |
return !!t.match(/real([0-9]*)?(\[([0-9]*)\])?/) | |
} | |
, | |
e.exports = o | |
} | |
, { | |
"./formatters": 9, | |
"./type": 14 | |
}], | |
13: [function(t, e, r) { | |
var n = t("./formatters") | |
, i = t("./type") | |
, o = function() { | |
this._inputFormatter = n.formatInputString, | |
this._outputFormatter = n.formatOutputString | |
}; | |
((o.prototype = new i({})).constructor = o).prototype.isType = function(t) { | |
return !!t.match(/^string(\[([0-9]*)\])*$/) | |
} | |
, | |
o.prototype.isDynamicType = function() { | |
return !0 | |
} | |
, | |
e.exports = o | |
} | |
, { | |
"./formatters": 9, | |
"./type": 14 | |
}], | |
14: [function(t, e, r) { | |
var n = t("./formatters") | |
, i = t("./param") | |
, o = function(t) { | |
this._inputFormatter = t.inputFormatter, | |
this._outputFormatter = t.outputFormatter | |
}; | |
o.prototype.isType = function(t) { | |
throw "this method should be overrwritten for type " + t | |
} | |
, | |
o.prototype.staticPartLength = function(t) { | |
return (this.nestedTypes(t) || ["[1]"]).map(function(t) { | |
return parseInt(t.slice(1, -1), 10) || 1 | |
}).reduce(function(t, e) { | |
return t * e | |
}, 32) | |
} | |
, | |
o.prototype.isDynamicArray = function(t) { | |
var e = this.nestedTypes(t); | |
return !!e && !e[e.length - 1].match(/[0-9]{1,}/g) | |
} | |
, | |
o.prototype.isStaticArray = function(t) { | |
var e = this.nestedTypes(t); | |
return !!e && !!e[e.length - 1].match(/[0-9]{1,}/g) | |
} | |
, | |
o.prototype.staticArrayLength = function(t) { | |
var e = this.nestedTypes(t); | |
return e ? parseInt(e[e.length - 1].match(/[0-9]{1,}/g) || 1) : 1 | |
} | |
, | |
o.prototype.nestedName = function(t) { | |
var e = this.nestedTypes(t); | |
return e ? t.substr(0, t.length - e[e.length - 1].length) : t | |
} | |
, | |
o.prototype.isDynamicType = function() { | |
return !1 | |
} | |
, | |
o.prototype.nestedTypes = function(t) { | |
return t.match(/(\[[0-9]*\])/g) | |
} | |
, | |
o.prototype.encode = function(t, e) { | |
var r, i, o, s = this; | |
return this.isDynamicArray(e) ? (r = t.length, | |
i = s.nestedName(e), | |
(o = []).push(n.formatInputInt(r).encode()), | |
t.forEach(function(t) { | |
o.push(s.encode(t, i)) | |
}), | |
o) : this.isStaticArray(e) ? function() { | |
for (var r = s.staticArrayLength(e), n = s.nestedName(e), i = [], o = 0; o < r; o++) | |
i.push(s.encode(t[o], n)); | |
return i | |
}() : this._inputFormatter(t, e).encode() | |
} | |
, | |
o.prototype.decode = function(t, e, r) { | |
var n, o, s, a, u = this; | |
if (this.isDynamicArray(r)) | |
return function() { | |
for (var n = parseInt("0x" + t.substr(2 * e, 64)), i = parseInt("0x" + t.substr(2 * n, 64)), o = n + 32, s = u.nestedName(r), a = u.staticPartLength(s), c = 32 * Math.floor((a + 31) / 32), f = [], l = 0; l < i * c; l += c) | |
f.push(u.decode(t, o + l, s)); | |
return f | |
}(); | |
if (this.isStaticArray(r)) | |
return function() { | |
for (var n = u.staticArrayLength(r), i = e, o = u.nestedName(r), s = u.staticPartLength(o), a = 32 * Math.floor((s + 31) / 32), c = [], f = 0; f < n * a; f += a) | |
c.push(u.decode(t, i + f, o)); | |
return c | |
}(); | |
if (this.isDynamicType(r)) | |
return n = parseInt("0x" + t.substr(2 * e, 64)), | |
o = parseInt("0x" + t.substr(2 * n, 64)), | |
s = Math.floor((o + 31) / 32), | |
a = new i(t.substr(2 * n, 64 * (1 + s)),0), | |
u._outputFormatter(a, r); | |
var c = this.staticPartLength(r) | |
, f = new i(t.substr(2 * e, 2 * c)); | |
return this._outputFormatter(f, r) | |
} | |
, | |
e.exports = o | |
} | |
, { | |
"./formatters": 9, | |
"./param": 11 | |
}], | |
15: [function(t, e, r) { | |
var n = t("./formatters") | |
, i = t("./type") | |
, o = function() { | |
this._inputFormatter = n.formatInputInt, | |
this._outputFormatter = n.formatOutputUInt | |
}; | |
((o.prototype = new i({})).constructor = o).prototype.isType = function(t) { | |
return !!t.match(/^uint([0-9]*)?(\[([0-9]*)\])*$/) | |
} | |
, | |
e.exports = o | |
} | |
, { | |
"./formatters": 9, | |
"./type": 14 | |
}], | |
16: [function(t, e, r) { | |
var n = t("./formatters") | |
, i = t("./type") | |
, o = function() { | |
this._inputFormatter = n.formatInputReal, | |
this._outputFormatter = n.formatOutputUReal | |
}; | |
((o.prototype = new i({})).constructor = o).prototype.isType = function(t) { | |
return !!t.match(/^ureal([0-9]*)?(\[([0-9]*)\])*$/) | |
} | |
, | |
e.exports = o | |
} | |
, { | |
"./formatters": 9, | |
"./type": 14 | |
}], | |
17: [function(t, e, r) { | |
"use strict"; | |
"undefined" == typeof XMLHttpRequest ? r.XMLHttpRequest = {} : r.XMLHttpRequest = XMLHttpRequest | |
} | |
, {}], | |
18: [function(t, e, r) { | |
var n = t("bignumber.js"); | |
e.exports = { | |
ETH_PADDING: 32, | |
ETH_SIGNATURE_LENGTH: 4, | |
ETH_UNITS: ["wei", "kwei", "Mwei", "Gwei", "szabo", "finney", "femtoether", "picoether", "nanoether", "microether", "milliether", "nano", "micro", "milli", "ether", "grand", "Mether", "Gether", "Tether", "Pether", "Eether", "Zether", "Yether", "Nether", "Dether", "Vether", "Uether"], | |
ETH_BIGNUMBER_ROUNDING_MODE: { | |
ROUNDING_MODE: n.ROUND_DOWN | |
}, | |
ETH_POLLING_TIMEOUT: 500, | |
defaultBlock: "latest", | |
defaultAccount: void 0 | |
} | |
} | |
, { | |
"bignumber.js": "bignumber.js" | |
}], | |
19: [function(t, e, r) { | |
var n = t("crypto-js") | |
, i = t("crypto-js/sha3"); | |
e.exports = function(t, e) { | |
return e && "hex" === e.encoding && (2 < t.length && "0x" === t.substr(0, 2) && (t = t.substr(2)), | |
t = n.enc.Hex.parse(t)), | |
i(t, { | |
outputLength: 256 | |
}).toString() | |
} | |
} | |
, { | |
"crypto-js": 65, | |
"crypto-js/sha3": 86 | |
}], | |
20: [function(t, e, r) { | |
var n = t("bignumber.js") | |
, i = t("./sha3.js") | |
, o = t("utf8") | |
, s = { | |
noether: "0", | |
wei: "1", | |
kwei: "1000", | |
Kwei: "1000", | |
babbage: "1000", | |
femtoether: "1000", | |
mwei: "1000000", | |
Mwei: "1000000", | |
lovelace: "1000000", | |
picoether: "1000000", | |
gwei: "1000000000", | |
Gwei: "1000000000", | |
shannon: "1000000000", | |
nanoether: "1000000000", | |
nano: "1000000000", | |
szabo: "1000000000000", | |
microether: "1000000000000", | |
micro: "1000000000000", | |
finney: "1000000000000000", | |
milliether: "1000000000000000", | |
milli: "1000000000000000", | |
ether: "1000000000000000000", | |
kether: "1000000000000000000000", | |
grand: "1000000000000000000000", | |
mether: "1000000000000000000000000", | |
gether: "1000000000000000000000000000", | |
tether: "1000000000000000000000000000000" | |
} | |
, a = function(t, e, r) { | |
return new Array(e - t.length + 1).join(r || "0") + t | |
} | |
, u = function(t, e) { | |
t = o.encode(t); | |
for (var r = "", n = 0; n < t.length; n++) { | |
var i = t.charCodeAt(n); | |
if (0 === i) { | |
if (!e) | |
break; | |
r += "00" | |
} else { | |
var s = i.toString(16); | |
r += s.length < 2 ? "0" + s : s | |
} | |
} | |
return "0x" + r | |
} | |
, c = function(t) { | |
var e = h(t) | |
, r = e.toString(16); | |
return e.lessThan(0) ? "-0x" + r.substr(1) : "0x" + r | |
} | |
, f = function(t) { | |
if (g(t)) | |
return c(+t); | |
if (y(t)) | |
return c(t); | |
if ("object" == typeof t) | |
return u(JSON.stringify(t)); | |
if (m(t)) { | |
if (0 === t.indexOf("-0x")) | |
return c(t); | |
if (0 === t.indexOf("0x")) | |
return t; | |
if (!isFinite(t)) | |
return u(t, 1) | |
} | |
return c(t) | |
} | |
, l = function(t) { | |
t = t ? t.toLowerCase() : "ether"; | |
var e = s[t]; | |
if (void 0 === e) | |
throw new Error("This unit doesn't exists, please use the one of the following units" + JSON.stringify(s, null, 2)); | |
return new n(e,10) | |
} | |
, h = function(t) { | |
return y(t = t || 0) ? t : !m(t) || 0 !== t.indexOf("0x") && 0 !== t.indexOf("-0x") ? new n(t.toString(10),10) : new n(t.replace("0x", ""),16) | |
} | |
, p = function(t) { | |
return /^0x[0-9a-f]{40}$/i.test(t) | |
} | |
, d = function(t) { | |
t = t.replace("0x", ""); | |
for (var e = i(t.toLowerCase()), r = 0; r < 40; r++) | |
if (7 < parseInt(e[r], 16) && t[r].toUpperCase() !== t[r] || parseInt(e[r], 16) <= 7 && t[r].toLowerCase() !== t[r]) | |
return !1; | |
return !0 | |
} | |
, y = function(t) { | |
return t instanceof n || t && t.constructor && "BigNumber" === t.constructor.name | |
} | |
, m = function(t) { | |
return "string" == typeof t || t && t.constructor && "String" === t.constructor.name | |
} | |
, g = function(t) { | |
return "boolean" == typeof t | |
}; | |
e.exports = { | |
padLeft: a, | |
padRight: function(t, e, r) { | |
return t + new Array(e - t.length + 1).join(r || "0") | |
}, | |
toHex: f, | |
toDecimal: function(t) { | |
return h(t).toNumber() | |
}, | |
fromDecimal: c, | |
toUtf8: function(t) { | |
var e = "" | |
, r = 0 | |
, n = t.length; | |
for ("0x" === t.substring(0, 2) && (r = 2); r < n; r += 2) { | |
var i = parseInt(t.substr(r, 2), 16); | |
if (0 === i) | |
break; | |
e += String.fromCharCode(i) | |
} | |
return o.decode(e) | |
}, | |
toAscii: function(t) { | |
var e = "" | |
, r = 0 | |
, n = t.length; | |
for ("0x" === t.substring(0, 2) && (r = 2); r < n; r += 2) { | |
var i = parseInt(t.substr(r, 2), 16); | |
e += String.fromCharCode(i) | |
} | |
return e | |
}, | |
fromUtf8: u, | |
fromAscii: function(t, e) { | |
for (var r = "", n = 0; n < t.length; n++) { | |
var i = t.charCodeAt(n).toString(16); | |
r += i.length < 2 ? "0" + i : i | |
} | |
return "0x" + r.padEnd(e, "0") | |
}, | |
transformToFullName: function(t) { | |
if (-1 !== t.name.indexOf("(")) | |
return t.name; | |
var e = t.inputs.map(function(t) { | |
return t.type | |
}).join(); | |
return t.name + "(" + e + ")" | |
}, | |
extractDisplayName: function(t) { | |
var e = t.indexOf("(") | |
, r = t.indexOf(")"); | |
return -1 !== e && -1 !== r ? t.substr(0, e) : t | |
}, | |
extractTypeName: function(t) { | |
var e = t.indexOf("(") | |
, r = t.indexOf(")"); | |
return -1 !== e && -1 !== r ? t.substr(e + 1, r - e - 1).replace(" ", "") : "" | |
}, | |
toWei: function(t, e) { | |
var r = h(t).times(l(e)); | |
return y(t) ? r : r.toString(10) | |
}, | |
fromWei: function(t, e) { | |
var r = h(t).dividedBy(l(e)); | |
return y(t) ? r : r.toString(10) | |
}, | |
toBigNumber: h, | |
toTwosComplement: function(t) { | |
var e = h(t).round(); | |
return e.lessThan(0) ? new n("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",16).plus(e).plus(1) : e | |
}, | |
toAddress: function(t) { | |
return p(t) ? t : /^[0-9a-f]{40}$/.test(t) ? "0x" + t : "0x" + a(f(t).substr(2), 40) | |
}, | |
isBigNumber: y, | |
isStrictAddress: p, | |
isAddress: function(t) { | |
return !!/^(0x)?[0-9a-f]{40}$/i.test(t) && (!(!/^(0x)?[0-9a-f]{40}$/.test(t) && !/^(0x)?[0-9A-F]{40}$/.test(t)) || d(t)) | |
}, | |
isChecksumAddress: d, | |
toChecksumAddress: function(t) { | |
if (void 0 === t) | |
return ""; | |
t = t.toLowerCase().replace("0x", ""); | |
for (var e = i(t), r = "0x", n = 0; n < t.length; n++) | |
7 < parseInt(e[n], 16) ? r += t[n].toUpperCase() : r += t[n]; | |
return r | |
}, | |
isFunction: function(t) { | |
return "function" == typeof t | |
}, | |
isString: m, | |
isObject: function(t) { | |
return null !== t && !Array.isArray(t) && "object" == typeof t | |
}, | |
isBoolean: g, | |
isArray: function(t) { | |
return Array.isArray(t) | |
}, | |
isJson: function(t) { | |
try { | |
return !!JSON.parse(t) | |
} catch (t) { | |
return !1 | |
} | |
}, | |
isBloom: function(t) { | |
return !(!/^(0x)?[0-9a-f]{512}$/i.test(t) || !/^(0x)?[0-9a-f]{512}$/.test(t) && !/^(0x)?[0-9A-F]{512}$/.test(t)) | |
}, | |
isTopic: function(t) { | |
return !(!/^(0x)?[0-9a-f]{64}$/i.test(t) || !/^(0x)?[0-9a-f]{64}$/.test(t) && !/^(0x)?[0-9A-F]{64}$/.test(t)) | |
} | |
} | |
} | |
, { | |
"./sha3.js": 19, | |
"bignumber.js": "bignumber.js", | |
utf8: 123 | |
}], | |
21: [function(t, e, r) { | |
e.exports = { | |
version: "0.20.7" | |
} | |
} | |
, {}], | |
22: [function(t, e, r) { | |
var n = t("./web3/requestmanager") | |
, i = t("./web3/iban") | |
, o = t("./web3/methods/eth") | |
, s = t("./web3/methods/db") | |
, a = t("./web3/methods/shh") | |
, u = t("./web3/methods/net") | |
, c = t("./web3/methods/personal") | |
, f = t("./web3/methods/swarm") | |
, l = t("./web3/settings") | |
, h = t("./version.json") | |
, p = t("./utils/utils") | |
, d = t("./utils/sha3") | |
, y = t("./web3/extend") | |
, m = t("./web3/batch") | |
, g = t("./web3/property") | |
, v = t("./web3/httpprovider") | |
, b = t("./web3/ipcprovider") | |
, w = t("bignumber.js"); | |
function _(t) { | |
this._requestManager = new n(t), | |
this.currentProvider = t, | |
this.eth = new o(this), | |
this.db = new s(this), | |
this.shh = new a(this), | |
this.net = new u(this), | |
this.personal = new c(this), | |
this.bzz = new f(this), | |
this.settings = new l, | |
this.version = { | |
api: h.version | |
}, | |
this.providers = { | |
HttpProvider: v, | |
IpcProvider: b | |
}, | |
this._extend = y(this), | |
this._extend({ | |
properties: x() | |
}) | |
} | |
_.providers = { | |
HttpProvider: v, | |
IpcProvider: b | |
}, | |
_.prototype.setProvider = function(t) { | |
this._requestManager.setProvider(t), | |
this.currentProvider = t | |
} | |
, | |
_.prototype.reset = function(t) { | |
this._requestManager.reset(t), | |
this.settings = new l | |
} | |
, | |
_.prototype.BigNumber = w, | |
_.prototype.toHex = p.toHex, | |
_.prototype.toAscii = p.toAscii, | |
_.prototype.toUtf8 = p.toUtf8, | |
_.prototype.fromAscii = p.fromAscii, | |
_.prototype.fromUtf8 = p.fromUtf8, | |
_.prototype.toDecimal = p.toDecimal, | |
_.prototype.fromDecimal = p.fromDecimal, | |
_.prototype.toBigNumber = p.toBigNumber, | |
_.prototype.toWei = p.toWei, | |
_.prototype.fromWei = p.fromWei, | |
_.prototype.isAddress = p.isAddress, | |
_.prototype.isChecksumAddress = p.isChecksumAddress, | |
_.prototype.toChecksumAddress = p.toChecksumAddress, | |
_.prototype.isIBAN = p.isIBAN, | |
_.prototype.padLeft = p.padLeft, | |
_.prototype.padRight = p.padRight, | |
_.prototype.sha3 = function(t, e) { | |
return "0x" + d(t, e) | |
} | |
, | |
_.prototype.fromICAP = function(t) { | |
return new i(t).address() | |
} | |
; | |
var x = function() { | |
return [new g({ | |
name: "version.node", | |
getter: "web3_clientVersion" | |
}), new g({ | |
name: "version.network", | |
getter: "net_version", | |
inputFormatter: p.toDecimal | |
}), new g({ | |
name: "version.ethereum", | |
getter: "eth_protocolVersion", | |
inputFormatter: p.toDecimal | |
}), new g({ | |
name: "version.whisper", | |
getter: "shh_version", | |
inputFormatter: p.toDecimal | |
})] | |
}; | |
_.prototype.isConnected = function() { | |
return this.currentProvider && this.currentProvider.isConnected() | |
} | |
, | |
_.prototype.createBatch = function() { | |
return new m(this) | |
} | |
, | |
e.exports = _ | |
} | |
, { | |
"./utils/sha3": 19, | |
"./utils/utils": 20, | |
"./version.json": 21, | |
"./web3/batch": 24, | |
"./web3/extend": 28, | |
"./web3/httpprovider": 32, | |
"./web3/iban": 33, | |
"./web3/ipcprovider": 34, | |
"./web3/methods/db": 37, | |
"./web3/methods/eth": 38, | |
"./web3/methods/net": 39, | |
"./web3/methods/personal": 40, | |
"./web3/methods/shh": 41, | |
"./web3/methods/swarm": 42, | |
"./web3/property": 45, | |
"./web3/requestmanager": 46, | |
"./web3/settings": 47, | |
"bignumber.js": "bignumber.js" | |
}], | |
23: [function(t, e, r) { | |
var n = t("../utils/sha3") | |
, i = t("./event") | |
, o = t("./formatters") | |
, s = t("../utils/utils") | |
, a = t("./filter") | |
, u = t("./methods/watches") | |
, c = function(t, e, r) { | |
this._requestManager = t, | |
this._json = e, | |
this._address = r | |
}; | |
c.prototype.encode = function(t) { | |
t = t || {}; | |
var e = {}; | |
return ["fromBlock", "toBlock"].filter(function(e) { | |
return void 0 !== t[e] | |
}).forEach(function(r) { | |
e[r] = o.inputBlockNumberFormatter(t[r]) | |
}), | |
e.address = this._address, | |
e | |
} | |
, | |
c.prototype.decode = function(t) { | |
t.data = t.data || ""; | |
var e = s.isArray(t.topics) && s.isString(t.topics[0]) ? t.topics[0].slice(2) : "" | |
, r = this._json.filter(function(t) { | |
return e === n(s.transformToFullName(t)) | |
})[0]; | |
return r ? new i(this._requestManager,r,this._address).decode(t) : o.outputLogFormatter(t) | |
} | |
, | |
c.prototype.execute = function(t, e) { | |
s.isFunction(arguments[arguments.length - 1]) && (e = arguments[arguments.length - 1], | |
1 === arguments.length && (t = null)); | |
var r = this.encode(t) | |
, n = this.decode.bind(this); | |
return new a(r,"eth",this._requestManager,u.eth(),n,e) | |
} | |
, | |
c.prototype.attachToContract = function(t) { | |
var e = this.execute.bind(this); | |
t.allEvents = e | |
} | |
, | |
e.exports = c | |
} | |
, { | |
"../utils/sha3": 19, | |
"../utils/utils": 20, | |
"./event": 27, | |
"./filter": 29, | |
"./formatters": 30, | |
"./methods/watches": 43 | |
}], | |
24: [function(t, e, r) { | |
var n = t("./jsonrpc") | |
, i = t("./errors") | |
, o = function(t) { | |
this.requestManager = t._requestManager, | |
this.requests = [] | |
}; | |
o.prototype.add = function(t) { | |
this.requests.push(t) | |
} | |
, | |
o.prototype.execute = function() { | |
var t = this.requests; | |
this.requestManager.sendBatch(t, function(e, r) { | |
r = r || [], | |
t.map(function(t, e) { | |
return r[e] || {} | |
}).forEach(function(e, r) { | |
if (t[r].callback) { | |
if (!n.isValidResponse(e)) | |
return t[r].callback(i.InvalidResponse(e)); | |
t[r].callback(null, t[r].format ? t[r].format(e.result) : e.result) | |
} | |
}) | |
}) | |
} | |
, | |
e.exports = o | |
} | |
, { | |
"./errors": 26, | |
"./jsonrpc": 35 | |
}], | |
25: [function(t, e, r) { | |
var n = t("../utils/utils") | |
, i = t("../solidity/coder") | |
, o = t("./event") | |
, s = t("./function") | |
, a = t("./allevents") | |
, u = function(t, e) { | |
return t.filter(function(t) { | |
return "constructor" === t.type && t.inputs.length === e.length | |
}).map(function(t) { | |
return t.inputs.map(function(t) { | |
return t.type | |
}) | |
}).map(function(t) { | |
return i.encodeParams(t, e) | |
})[0] || "" | |
} | |
, c = function(t) { | |
t.abi.filter(function(t) { | |
return "function" === t.type | |
}).map(function(e) { | |
return new s(t._eth,e,t.address) | |
}).forEach(function(e) { | |
e.attachToContract(t) | |
}) | |
} | |
, f = function(t) { | |
var e = t.abi.filter(function(t) { | |
return "event" === t.type | |
}); | |
new a(t._eth._requestManager,e,t.address).attachToContract(t), | |
e.map(function(e) { | |
return new o(t._eth._requestManager,e,t.address) | |
}).forEach(function(e) { | |
e.attachToContract(t) | |
}) | |
} | |
, l = function(t, e) { | |
var r = 0 | |
, n = !1 | |
, i = t._eth.filter("latest", function(o) { | |
if (!o && !n) | |
if (50 < ++r) { | |
if (i.stopWatching(function() {}), | |
n = !0, | |
!e) | |
throw new Error("Contract transaction couldn't be found after 50 blocks"); | |
e(new Error("Contract transaction couldn't be found after 50 blocks")) | |
} else | |
t._eth.getTransactionReceipt(t.transactionHash, function(r, o) { | |
o && o.blockHash && !n && t._eth.getCode(o.contractAddress, function(r, s) { | |
if (!n && s) | |
if (i.stopWatching(function() {}), | |
n = !0, | |
3 < s.length) | |
t.address = o.contractAddress, | |
c(t), | |
f(t), | |
e && e(null, t); | |
else { | |
if (!e) | |
throw new Error("The contract code couldn't be stored, please check your gas amount."); | |
e(new Error("The contract code couldn't be stored, please check your gas amount.")) | |
} | |
}) | |
}) | |
}) | |
} | |
, h = function(t, e) { | |
this.eth = t, | |
this.abi = e, | |
this.new = function() { | |
var t, r = new p(this.eth,this.abi), i = {}, o = Array.prototype.slice.call(arguments); | |
n.isFunction(o[o.length - 1]) && (t = o.pop()); | |
var s = o[o.length - 1]; | |
if (n.isObject(s) && !n.isArray(s) && (i = o.pop()), | |
0 < i.value && !(e.filter(function(t) { | |
return "constructor" === t.type && t.inputs.length === o.length | |
})[0] || {}).payable) | |
throw new Error("Cannot send value to non-payable constructor"); | |
var a = u(this.abi, o); | |
if (i.data += a, | |
t) | |
this.eth.sendTransaction(i, function(e, n) { | |
e ? t(e) : (r.transactionHash = n, | |
t(null, r), | |
l(r, t)) | |
}); | |
else { | |
var c = this.eth.sendTransaction(i); | |
r.transactionHash = c, | |
l(r) | |
} | |
return r | |
} | |
, | |
this.new.getData = this.getData.bind(this) | |
}; | |
h.prototype.at = function(t, e) { | |
var r = new p(this.eth,this.abi,t); | |
return c(r), | |
f(r), | |
e && e(null, r), | |
r | |
} | |
, | |
h.prototype.getData = function() { | |
var t = {} | |
, e = Array.prototype.slice.call(arguments) | |
, r = e[e.length - 1]; | |
n.isObject(r) && !n.isArray(r) && (t = e.pop()); | |
var i = u(this.abi, e); | |
return t.data += i, | |
t.data | |
} | |
; | |
var p = function(t, e, r) { | |
this._eth = t, | |
this.transactionHash = null, | |
this.address = r, | |
this.abi = e | |
}; | |
e.exports = h | |
} | |
, { | |
"../solidity/coder": 7, | |
"../utils/utils": 20, | |
"./allevents": 23, | |
"./event": 27, | |
"./function": 31 | |
}], | |
26: [function(t, e, r) { | |
e.exports = { | |
InvalidNumberOfSolidityArgs: function() { | |
return new Error("Invalid number of arguments to Solidity function") | |
}, | |
InvalidNumberOfRPCParams: function() { | |
return new Error("Invalid number of input parameters to RPC method") | |
}, | |
InvalidConnection: function(t) { | |
return new Error("CONNECTION ERROR: Couldn't connect to node " + t + ".") | |
}, | |
InvalidProvider: function() { | |
return new Error("Provider not set or invalid") | |
}, | |
InvalidResponse: function(t) { | |
var e = t && t.error && t.error.message ? t.error.message : "Invalid JSON RPC response: " + JSON.stringify(t); | |
return new Error(e) | |
}, | |
ConnectionTimeout: function(t) { | |
return new Error("CONNECTION TIMEOUT: timeout of " + t + " ms achived") | |
} | |
} | |
} | |
, {}], | |
27: [function(t, e, r) { | |
var n = t("../utils/utils") | |
, i = t("../solidity/coder") | |
, o = t("./formatters") | |
, s = t("../utils/sha3") | |
, a = t("./filter") | |
, u = t("./methods/watches") | |
, c = function(t, e, r) { | |
this._requestManager = t, | |
this._params = e.inputs, | |
this._name = n.transformToFullName(e), | |
this._address = r, | |
this._anonymous = e.anonymous | |
}; | |
c.prototype.types = function(t) { | |
return this._params.filter(function(e) { | |
return e.indexed === t | |
}).map(function(t) { | |
return t.type | |
}) | |
} | |
, | |
c.prototype.displayName = function() { | |
return n.extractDisplayName(this._name) | |
} | |
, | |
c.prototype.typeName = function() { | |
return n.extractTypeName(this._name) | |
} | |
, | |
c.prototype.signature = function() { | |
return s(this._name) | |
} | |
, | |
c.prototype.encode = function(t, e) { | |
t = t || {}, | |
e = e || {}; | |
var r = {}; | |
["fromBlock", "toBlock"].filter(function(t) { | |
return void 0 !== e[t] | |
}).forEach(function(t) { | |
r[t] = o.inputBlockNumberFormatter(e[t]) | |
}), | |
r.topics = [], | |
r.address = this._address, | |
this._anonymous || r.topics.push("0x" + this.signature()); | |
var s = this._params.filter(function(t) { | |
return !0 === t.indexed | |
}).map(function(e) { | |
var r = t[e.name]; | |
return null == r ? null : n.isArray(r) ? r.map(function(t) { | |
return "0x" + i.encodeParam(e.type, t) | |
}) : "0x" + i.encodeParam(e.type, r) | |
}); | |
return r.topics = r.topics.concat(s), | |
r | |
} | |
, | |
c.prototype.decode = function(t) { | |
t.data = t.data || "", | |
t.topics = t.topics || []; | |
var e = (this._anonymous ? t.topics : t.topics.slice(1)).map(function(t) { | |
return t.slice(2) | |
}).join("") | |
, r = i.decodeParams(this.types(!0), e) | |
, n = t.data.slice(2) | |
, s = i.decodeParams(this.types(!1), n) | |
, a = o.outputLogFormatter(t); | |
return a.event = this.displayName(), | |
a.address = t.address, | |
a.args = this._params.reduce(function(t, e) { | |
return t[e.name] = e.indexed ? r.shift() : s.shift(), | |
t | |
}, {}), | |
delete a.data, | |
delete a.topics, | |
a | |
} | |
, | |
c.prototype.execute = function(t, e, r) { | |
n.isFunction(arguments[arguments.length - 1]) && (r = arguments[arguments.length - 1], | |
2 === arguments.length && (e = null), | |
1 === arguments.length && (e = null, | |
t = {})); | |
var i = this.encode(t, e) | |
, o = this.decode.bind(this); | |
return new a(i,"eth",this._requestManager,u.eth(),o,r) | |
} | |
, | |
c.prototype.attachToContract = function(t) { | |
var e = this.execute.bind(this) | |
, r = this.displayName(); | |
t[r] || (t[r] = e), | |
t[r][this.typeName()] = this.execute.bind(this, t) | |
} | |
, | |
e.exports = c | |
} | |
, { | |
"../solidity/coder": 7, | |
"../utils/sha3": 19, | |
"../utils/utils": 20, | |
"./filter": 29, | |
"./formatters": 30, | |
"./methods/watches": 43 | |
}], | |
28: [function(t, e, r) { | |
var n = t("./formatters") | |
, i = t("./../utils/utils") | |
, o = t("./method") | |
, s = t("./property"); | |
e.exports = function(t) { | |
var e = function(e) { | |
var r; | |
e.property ? (t[e.property] || (t[e.property] = {}), | |
r = t[e.property]) : r = t, | |
e.methods && e.methods.forEach(function(e) { | |
e.attachToObject(r), | |
e.setRequestManager(t._requestManager) | |
}), | |
e.properties && e.properties.forEach(function(e) { | |
e.attachToObject(r), | |
e.setRequestManager(t._requestManager) | |
}) | |
}; | |
return e.formatters = n, | |
e.utils = i, | |
e.Method = o, | |
e.Property = s, | |
e | |
} | |
} | |
, { | |
"./../utils/utils": 20, | |
"./formatters": 30, | |
"./method": 36, | |
"./property": 45 | |
}], | |
29: [function(t, e, r) { | |
var n = t("./formatters") | |
, i = t("../utils/utils") | |
, o = function(t) { | |
return null == t ? null : 0 === (t = String(t)).indexOf("0x") ? t : i.fromUtf8(t) | |
} | |
, s = function(t, e) { | |
i.isString(t.options) || t.get(function(t, r) { | |
t && e(t), | |
i.isArray(r) && r.forEach(function(t) { | |
e(null, t) | |
}) | |
}) | |
} | |
, a = function(t) { | |
t.requestManager.startPolling({ | |
method: t.implementation.poll.call, | |
params: [t.filterId] | |
}, t.filterId, function(e, r) { | |
if (e) | |
return t.callbacks.forEach(function(t) { | |
t(e) | |
}); | |
i.isArray(r) && r.forEach(function(e) { | |
e = t.formatter ? t.formatter(e) : e, | |
t.callbacks.forEach(function(t) { | |
t(null, e) | |
}) | |
}) | |
}, t.stopWatching.bind(t)) | |
} | |
, u = function(t, e, r, u, c, f, l) { | |
var h = this | |
, p = {}; | |
return u.forEach(function(t) { | |
t.setRequestManager(r), | |
t.attachToObject(p) | |
}), | |
this.requestManager = r, | |
this.options = function(t, e) { | |
if (i.isString(t)) | |
return t; | |
switch (t = t || {}, | |
e) { | |
case "eth": | |
return t.topics = t.topics || [], | |
t.topics = t.topics.map(function(t) { | |
return i.isArray(t) ? t.map(o) : o(t) | |
}), | |
{ | |
topics: t.topics, | |
from: t.from, | |
to: t.to, | |
address: t.address, | |
fromBlock: n.inputBlockNumberFormatter(t.fromBlock), | |
toBlock: n.inputBlockNumberFormatter(t.toBlock) | |
}; | |
case "shh": | |
return t | |
} | |
}(t, e), | |
this.implementation = p, | |
this.filterId = null, | |
this.callbacks = [], | |
this.getLogsCallbacks = [], | |
this.pollFilters = [], | |
this.formatter = c, | |
this.implementation.newFilter(this.options, function(t, e) { | |
if (t) | |
h.callbacks.forEach(function(e) { | |
e(t) | |
}), | |
"function" == typeof l && l(t); | |
else if (h.filterId = e, | |
h.getLogsCallbacks.forEach(function(t) { | |
h.get(t) | |
}), | |
h.getLogsCallbacks = [], | |
h.callbacks.forEach(function(t) { | |
s(h, t) | |
}), | |
0 < h.callbacks.length && a(h), | |
"function" == typeof f) | |
return h.watch(f) | |
}), | |
this | |
}; | |
u.prototype.watch = function(t) { | |
return this.callbacks.push(t), | |
this.filterId && (s(this, t), | |
a(this)), | |
this | |
} | |
, | |
u.prototype.stopWatching = function(t) { | |
if (this.requestManager.stopPolling(this.filterId), | |
this.callbacks = [], | |
!t) | |
return this.implementation.uninstallFilter(this.filterId); | |
this.implementation.uninstallFilter(this.filterId, t) | |
} | |
, | |
u.prototype.get = function(t) { | |
var e = this; | |
if (!i.isFunction(t)) { | |
if (null === this.filterId) | |
throw new Error("Filter ID Error: filter().get() can't be chained synchronous, please provide a callback for the get() method."); | |
return this.implementation.getLogs(this.filterId).map(function(t) { | |
return e.formatter ? e.formatter(t) : t | |
}) | |
} | |
return null === this.filterId ? this.getLogsCallbacks.push(t) : this.implementation.getLogs(this.filterId, function(r, n) { | |
r ? t(r) : t(null, n.map(function(t) { | |
return e.formatter ? e.formatter(t) : t | |
})) | |
}), | |
this | |
} | |
, | |
e.exports = u | |
} | |
, { | |
"../utils/utils": 20, | |
"./formatters": 30 | |
}], | |
30: [function(t, e, r) { | |
"use strict"; | |
var n = t("../utils/utils") | |
, i = t("../utils/config") | |
, o = t("./iban") | |
, s = function(t) { | |
var e; | |
if (void 0 !== t) | |
return "latest" === (e = t) || "pending" === e || "earliest" === e ? t : n.toHex(t) | |
} | |
, a = function(t) { | |
return null !== t.blockNumber && (t.blockNumber = n.toDecimal(t.blockNumber)), | |
null !== t.transactionIndex && (t.transactionIndex = n.toDecimal(t.transactionIndex)), | |
t.nonce = n.toDecimal(t.nonce), | |
t.gas = n.toDecimal(t.gas), | |
t.gasPrice = n.toBigNumber(t.gasPrice), | |
t.value = n.toBigNumber(t.value), | |
t | |
} | |
, u = function(t) { | |
return t.blockNumber && (t.blockNumber = n.toDecimal(t.blockNumber)), | |
t.transactionIndex && (t.transactionIndex = n.toDecimal(t.transactionIndex)), | |
t.logIndex && (t.logIndex = n.toDecimal(t.logIndex)), | |
t | |
} | |
, c = function(t) { | |
var e = new o(t); | |
if (e.isValid() && e.isDirect()) | |
return "0x" + e.address(); | |
if (n.isStrictAddress(t)) | |
return t; | |
if (n.isAddress(t)) | |
return "0x" + t; | |
throw new Error("invalid address") | |
}; | |
e.exports = { | |
inputDefaultBlockNumberFormatter: function(t) { | |
return void 0 === t ? i.defaultBlock : s(t) | |
}, | |
inputBlockNumberFormatter: s, | |
inputCallFormatter: function(t) { | |
return t.from = t.from || i.defaultAccount, | |
t.from && (t.from = c(t.from)), | |
t.to && (t.to = c(t.to)), | |
["gasPrice", "gas", "value", "nonce"].filter(function(e) { | |
return void 0 !== t[e] | |
}).forEach(function(e) { | |
t[e] = n.fromDecimal(t[e]) | |
}), | |
t | |
}, | |
inputTransactionFormatter: function(t) { | |
return t.from = t.from || i.defaultAccount, | |
t.from = c(t.from), | |
t.to && (t.to = c(t.to)), | |
["gasPrice", "gas", "value", "nonce"].filter(function(e) { | |
return void 0 !== t[e] | |
}).forEach(function(e) { | |
t[e] = n.fromDecimal(t[e]) | |
}), | |
t | |
}, | |
inputAddressFormatter: c, | |
inputPostFormatter: function(t) { | |
return t.ttl = n.fromDecimal(t.ttl), | |
t.workToProve = n.fromDecimal(t.workToProve), | |
t.priority = n.fromDecimal(t.priority), | |
n.isArray(t.topics) || (t.topics = t.topics ? [t.topics] : []), | |
t.topics = t.topics.map(function(t) { | |
return 0 === t.indexOf("0x") ? t : n.fromUtf8(t) | |
}), | |
t | |
}, | |
outputBigNumberFormatter: function(t) { | |
return n.toBigNumber(t) | |
}, | |
outputTransactionFormatter: a, | |
outputTransactionReceiptFormatter: function(t) { | |
return null !== t.blockNumber && (t.blockNumber = n.toDecimal(t.blockNumber)), | |
null !== t.transactionIndex && (t.transactionIndex = n.toDecimal(t.transactionIndex)), | |
t.cumulativeGasUsed = n.toDecimal(t.cumulativeGasUsed), | |
t.gasUsed = n.toDecimal(t.gasUsed), | |
n.isArray(t.logs) && (t.logs = t.logs.map(function(t) { | |
return u(t) | |
})), | |
t | |
}, | |
outputBlockFormatter: function(t) { | |
return t.gasLimit = n.toDecimal(t.gasLimit), | |
t.gasUsed = n.toDecimal(t.gasUsed), | |
t.size = n.toDecimal(t.size), | |
t.timestamp = n.toDecimal(t.timestamp), | |
null !== t.number && (t.number = n.toDecimal(t.number)), | |
t.difficulty = n.toBigNumber(t.difficulty), | |
t.totalDifficulty = n.toBigNumber(t.totalDifficulty), | |
n.isArray(t.transactions) && t.transactions.forEach(function(t) { | |
if (!n.isString(t)) | |
return a(t) | |
}), | |
t | |
}, | |
outputLogFormatter: u, | |
outputPostFormatter: function(t) { | |
return t.expiry = n.toDecimal(t.expiry), | |
t.sent = n.toDecimal(t.sent), | |
t.ttl = n.toDecimal(t.ttl), | |
t.workProved = n.toDecimal(t.workProved), | |
t.topics || (t.topics = []), | |
t.topics = t.topics.map(function(t) { | |
return n.toAscii(t) | |
}), | |
t | |
}, | |
outputSyncingFormatter: function(t) { | |
return t && (t.startingBlock = n.toDecimal(t.startingBlock), | |
t.currentBlock = n.toDecimal(t.currentBlock), | |
t.highestBlock = n.toDecimal(t.highestBlock), | |
t.knownStates && (t.knownStates = n.toDecimal(t.knownStates), | |
t.pulledStates = n.toDecimal(t.pulledStates))), | |
t | |
} | |
} | |
} | |
, { | |
"../utils/config": 18, | |
"../utils/utils": 20, | |
"./iban": 33 | |
}], | |
31: [function(t, e, r) { | |
var n = t("../solidity/coder") | |
, i = t("../utils/utils") | |
, o = t("./errors") | |
, s = t("./formatters") | |
, a = t("../utils/sha3") | |
, u = function(t, e, r) { | |
this._eth = t, | |
this._inputTypes = e.inputs.map(function(t) { | |
return t.type | |
}), | |
this._outputTypes = e.outputs.map(function(t) { | |
return t.type | |
}), | |
this._constant = "view" === e.stateMutability || "pure" === e.stateMutability || e.constant, | |
this._payable = "payable" === e.stateMutability || e.payable, | |
this._name = i.transformToFullName(e), | |
this._address = r | |
}; | |
u.prototype.extractCallback = function(t) { | |
if (i.isFunction(t[t.length - 1])) | |
return t.pop() | |
} | |
, | |
u.prototype.extractDefaultBlock = function(t) { | |
if (t.length > this._inputTypes.length && !i.isObject(t[t.length - 1])) | |
return s.inputDefaultBlockNumberFormatter(t.pop()) | |
} | |
, | |
u.prototype.validateArgs = function(t) { | |
if (t.filter(function(t) { | |
return !(!0 === i.isObject(t) && !1 === i.isArray(t) && !1 === i.isBigNumber(t)) | |
}).length !== this._inputTypes.length) | |
throw o.InvalidNumberOfSolidityArgs() | |
} | |
, | |
u.prototype.toPayload = function(t) { | |
var e = {}; | |
return t.length > this._inputTypes.length && i.isObject(t[t.length - 1]) && (e = t[t.length - 1]), | |
this.validateArgs(t), | |
e.to = this._address, | |
e.data = "0x" + this.signature() + n.encodeParams(this._inputTypes, t), | |
e | |
} | |
, | |
u.prototype.signature = function() { | |
return a(this._name).slice(0, 8) | |
} | |
, | |
u.prototype.unpackOutput = function(t) { | |
if (t) { | |
t = 2 <= t.length ? t.slice(2) : t; | |
var e = n.decodeParams(this._outputTypes, t); | |
return 1 === e.length ? e[0] : e | |
} | |
} | |
, | |
u.prototype.call = function() { | |
var t = Array.prototype.slice.call(arguments).filter(function(t) { | |
return void 0 !== t | |
}) | |
, e = this.extractCallback(t) | |
, r = this.extractDefaultBlock(t) | |
, n = this.toPayload(t); | |
if (!e) { | |
var i = this._eth.call(n, r); | |
return this.unpackOutput(i) | |
} | |
var o = this; | |
this._eth.call(n, r, function(t, r) { | |
if (t) | |
return e(t, null); | |
var n = null; | |
try { | |
n = o.unpackOutput(r) | |
} catch (r) { | |
t = r | |
} | |
e(t, n) | |
}) | |
} | |
, | |
u.prototype.sendTransaction = function() { | |
var t = Array.prototype.slice.call(arguments).filter(function(t) { | |
return void 0 !== t | |
}) | |
, e = this.extractCallback(t) | |
, r = this.toPayload(t); | |
if (0 < r.value && !this._payable) | |
throw new Error("Cannot send value to non-payable function"); | |
if (!e) | |
return this._eth.sendTransaction(r); | |
this._eth.sendTransaction(r, e) | |
} | |
, | |
u.prototype.estimateGas = function() { | |
var t = Array.prototype.slice.call(arguments) | |
, e = this.extractCallback(t) | |
, r = this.toPayload(t); | |
if (!e) | |
return this._eth.estimateGas(r); | |
this._eth.estimateGas(r, e) | |
} | |
, | |
u.prototype.getData = function() { | |
var t = Array.prototype.slice.call(arguments); | |
return this.toPayload(t).data | |
} | |
, | |
u.prototype.displayName = function() { | |
return i.extractDisplayName(this._name) | |
} | |
, | |
u.prototype.typeName = function() { | |
return i.extractTypeName(this._name) | |
} | |
, | |
u.prototype.request = function() { | |
var t = Array.prototype.slice.call(arguments) | |
, e = this.extractCallback(t) | |
, r = this.toPayload(t) | |
, n = this.unpackOutput.bind(this); | |
return { | |
method: this._constant ? "eth_call" : "eth_sendTransaction", | |
callback: e, | |
params: [r], | |
format: n | |
} | |
} | |
, | |
u.prototype.execute = function() { | |
return this._constant ? this.call.apply(this, Array.prototype.slice.call(arguments)) : this.sendTransaction.apply(this, Array.prototype.slice.call(arguments)) | |
} | |
, | |
u.prototype.attachToContract = function(t) { | |
var e = this.execute.bind(this); | |
e.request = this.request.bind(this), | |
e.call = this.call.bind(this), | |
e.sendTransaction = this.sendTransaction.bind(this), | |
e.estimateGas = this.estimateGas.bind(this), | |
e.getData = this.getData.bind(this); | |
var r = this.displayName(); | |
t[r] || (t[r] = e), | |
t[r][this.typeName()] = e | |
} | |
, | |
e.exports = u | |
} | |
, { | |
"../solidity/coder": 7, | |
"../utils/sha3": 19, | |
"../utils/utils": 20, | |
"./errors": 26, | |
"./formatters": 30 | |
}], | |
32: [function(t, e, r) { | |
(function(r) { | |
var n = t("./errors"); | |
"undefined" != typeof window && window.XMLHttpRequest ? XMLHttpRequest = window.XMLHttpRequest : XMLHttpRequest = t("xmlhttprequest").XMLHttpRequest; | |
var i = t("xhr2-cookies").XMLHttpRequest | |
, o = function(t, e, r, n, i) { | |
this.host = t || "http://localhost:8545", | |
this.timeout = e || 0, | |
this.user = r, | |
this.password = n, | |
this.headers = i | |
}; | |
o.prototype.prepareRequest = function(t) { | |
var e; | |
if (t ? (e = new i).timeout = this.timeout : e = new XMLHttpRequest, | |
e.withCredentials = !0, | |
e.open("POST", this.host, t), | |
this.user && this.password) { | |
var n = "Basic " + new r(this.user + ":" + this.password).toString("base64"); | |
e.setRequestHeader("Authorization", n) | |
} | |
return e.setRequestHeader("Content-Type", "application/json"), | |
this.headers && this.headers.forEach(function(t) { | |
e.setRequestHeader(t.name, t.value) | |
}), | |
e | |
} | |
, | |
o.prototype.send = function(t) { | |
var e = this.prepareRequest(!1); | |
try { | |
e.send(JSON.stringify(t)) | |
} catch (t) { | |
throw n.InvalidConnection(this.host) | |
} | |
var r = e.responseText; | |
try { | |
r = JSON.parse(r) | |
} catch (t) { | |
throw n.InvalidResponse(e.responseText) | |
} | |
return r | |
} | |
, | |
o.prototype.sendAsync = function(t, e) { | |
var r = this.prepareRequest(!0); | |
r.onreadystatechange = function() { | |
if (4 === r.readyState && 1 !== r.timeout) { | |
var t = r.responseText | |
, i = null; | |
try { | |
t = JSON.parse(t) | |
} catch (t) { | |
i = n.InvalidResponse(r.responseText) | |
} | |
e(i, t) | |
} | |
} | |
, | |
r.ontimeout = function() { | |
e(n.ConnectionTimeout(this.timeout)) | |
} | |
; | |
try { | |
r.send(JSON.stringify(t)) | |
} catch (t) { | |
e(n.InvalidConnection(this.host)) | |
} | |
} | |
, | |
o.prototype.isConnected = function() { | |
try { | |
return this.send({ | |
id: 9999999999, | |
jsonrpc: "2.0", | |
method: "net_listening", | |
params: [] | |
}), | |
!0 | |
} catch (t) { | |
return !1 | |
} | |
} | |
, | |
e.exports = o | |
} | |
).call(this, t("buffer").Buffer) | |
} | |
, { | |
"./errors": 26, | |
buffer: 53, | |
"xhr2-cookies": 126, | |
xmlhttprequest: 17 | |
}], | |
33: [function(t, e, r) { | |
var n = t("bignumber.js") | |
, i = function(t, e) { | |
for (var r = t; r.length < 2 * e; ) | |
r = "0" + r; | |
return r | |
} | |
, o = function(t) { | |
var e = "A".charCodeAt(0) | |
, r = "Z".charCodeAt(0); | |
return (t = (t = t.toUpperCase()).substr(4) + t.substr(0, 4)).split("").map(function(t) { | |
var n = t.charCodeAt(0); | |
return e <= n && n <= r ? n - e + 10 : t | |
}).join("") | |
} | |
, s = function(t) { | |
for (var e, r = t; 2 < r.length; ) | |
e = r.slice(0, 9), | |
r = parseInt(e, 10) % 97 + r.slice(e.length); | |
return parseInt(r, 10) % 97 | |
} | |
, a = function(t) { | |
this._iban = t | |
}; | |
a.fromAddress = function(t) { | |
var e = new n(t,16).toString(36) | |
, r = i(e, 15); | |
return a.fromBban(r.toUpperCase()) | |
} | |
, | |
a.fromBban = function(t) { | |
var e = ("0" + (98 - s(o("XE00" + t)))).slice(-2); | |
return new a("XE" + e + t) | |
} | |
, | |
a.createIndirect = function(t) { | |
return a.fromBban("ETH" + t.institution + t.identifier) | |
} | |
, | |
a.isValid = function(t) { | |
return new a(t).isValid() | |
} | |
, | |
a.prototype.isValid = function() { | |
return /^XE[0-9]{2}(ETH[0-9A-Z]{13}|[0-9A-Z]{30,31})$/.test(this._iban) && 1 === s(o(this._iban)) | |
} | |
, | |
a.prototype.isDirect = function() { | |
return 34 === this._iban.length || 35 === this._iban.length | |
} | |
, | |
a.prototype.isIndirect = function() { | |
return 20 === this._iban.length | |
} | |
, | |
a.prototype.checksum = function() { | |
return this._iban.substr(2, 2) | |
} | |
, | |
a.prototype.institution = function() { | |
return this.isIndirect() ? this._iban.substr(7, 4) : "" | |
} | |
, | |
a.prototype.client = function() { | |
return this.isIndirect() ? this._iban.substr(11) : "" | |
} | |
, | |
a.prototype.address = function() { | |
if (this.isDirect()) { | |
var t = this._iban.substr(4) | |
, e = new n(t,36); | |
return i(e.toString(16), 20) | |
} | |
return "" | |
} | |
, | |
a.prototype.toString = function() { | |
return this._iban | |
} | |
, | |
e.exports = a | |
} | |
, { | |
"bignumber.js": "bignumber.js" | |
}], | |
34: [function(t, e, r) { | |
"use strict"; | |
var n = t("../utils/utils") | |
, i = t("./errors") | |
, o = function(t, e) { | |
var r = this; | |
this.responseCallbacks = {}, | |
this.path = t, | |
this.connection = e.connect({ | |
path: this.path | |
}), | |
this.connection.on("error", function(t) { | |
console.error("IPC Connection Error", t), | |
r._timeout() | |
}), | |
this.connection.on("end", function() { | |
r._timeout() | |
}), | |
this.connection.on("data", function(t) { | |
r._parseResponse(t.toString()).forEach(function(t) { | |
var e = null; | |
n.isArray(t) ? t.forEach(function(t) { | |
r.responseCallbacks[t.id] && (e = t.id) | |
}) : e = t.id, | |
r.responseCallbacks[e] && (r.responseCallbacks[e](null, t), | |
delete r.responseCallbacks[e]) | |
}) | |
}) | |
}; | |
o.prototype._parseResponse = function(t) { | |
var e = this | |
, r = []; | |
return t.replace(/\}[\n\r]?\{/g, "}|--|{").replace(/\}\][\n\r]?\[\{/g, "}]|--|[{").replace(/\}[\n\r]?\[\{/g, "}|--|[{").replace(/\}\][\n\r]?\{/g, "}]|--|{").split("|--|").forEach(function(t) { | |
e.lastChunk && (t = e.lastChunk + t); | |
var n = null; | |
try { | |
n = JSON.parse(t) | |
} catch (n) { | |
return e.lastChunk = t, | |
clearTimeout(e.lastChunkTimeout), | |
void (e.lastChunkTimeout = setTimeout(function() { | |
throw e._timeout(), | |
i.InvalidResponse(t) | |
}, 15e3)) | |
} | |
clearTimeout(e.lastChunkTimeout), | |
e.lastChunk = null, | |
n && r.push(n) | |
}), | |
r | |
} | |
, | |
o.prototype._addResponseCallback = function(t, e) { | |
var r = t.id || t[0].id | |
, n = t.method || t[0].method; | |
this.responseCallbacks[r] = e, | |
this.responseCallbacks[r].method = n | |
} | |
, | |
o.prototype._timeout = function() { | |
for (var t in this.responseCallbacks) | |
this.responseCallbacks.hasOwnProperty(t) && (this.responseCallbacks[t](i.InvalidConnection("on IPC")), | |
delete this.responseCallbacks[t]) | |
} | |
, | |
o.prototype.isConnected = function() { | |
return this.connection.writable || this.connection.connect({ | |
path: this.path | |
}), | |
!!this.connection.writable | |
} | |
, | |
o.prototype.send = function(t) { | |
if (this.connection.writeSync) { | |
var e; | |
this.connection.writable || this.connection.connect({ | |
path: this.path | |
}); | |
var r = this.connection.writeSync(JSON.stringify(t)); | |
try { | |
e = JSON.parse(r) | |
} catch (t) { | |
throw i.InvalidResponse(r) | |
} | |
return e | |
} | |
throw new Error('You tried to send "' + t.method + '" synchronously. Synchronous requests are not supported by the IPC provider.') | |
} | |
, | |
o.prototype.sendAsync = function(t, e) { | |
this.connection.writable || this.connection.connect({ | |
path: this.path | |
}), | |
this.connection.write(JSON.stringify(t)), | |
this._addResponseCallback(t, e) | |
} | |
, | |
e.exports = o | |
} | |
, { | |
"../utils/utils": 20, | |
"./errors": 26 | |
}], | |
35: [function(t, e, r) { | |
var n = { | |
messageId: 0, | |
toPayload: function(t, e) { | |
return t || console.error("jsonrpc method should be specified!"), | |
n.messageId++, | |
{ | |
jsonrpc: "2.0", | |
id: n.messageId, | |
method: t, | |
params: e || [] | |
} | |
}, | |
isValidResponse: function(t) { | |
return Array.isArray(t) ? t.every(e) : e(t); | |
function e(t) { | |
return !!t && !t.error && "2.0" === t.jsonrpc && "number" == typeof t.id && void 0 !== t.result | |
} | |
}, | |
toBatchPayload: function(t) { | |
return t.map(function(t) { | |
return n.toPayload(t.method, t.params) | |
}) | |
} | |
}; | |
e.exports = n | |
} | |
, {}], | |
36: [function(t, e, r) { | |
var n = t("../utils/utils") | |
, i = t("./errors") | |
, o = function(t) { | |
this.name = t.name, | |
this.call = t.call, | |
this.params = t.params || 0, | |
this.inputFormatter = t.inputFormatter, | |
this.outputFormatter = t.outputFormatter, | |
this.requestManager = null | |
}; | |
o.prototype.setRequestManager = function(t) { | |
this.requestManager = t | |
} | |
, | |
o.prototype.getCall = function(t) { | |
return n.isFunction(this.call) ? this.call(t) : this.call | |
} | |
, | |
o.prototype.extractCallback = function(t) { | |
if (n.isFunction(t[t.length - 1])) | |
return t.pop() | |
} | |
, | |
o.prototype.validateArgs = function(t) { | |
if (t.length !== this.params) | |
throw i.InvalidNumberOfRPCParams() | |
} | |
, | |
o.prototype.formatInput = function(t) { | |
return this.inputFormatter ? this.inputFormatter.map(function(e, r) { | |
return e ? e(t[r]) : t[r] | |
}) : t | |
} | |
, | |
o.prototype.formatOutput = function(t) { | |
return this.outputFormatter && t ? this.outputFormatter(t) : t | |
} | |
, | |
o.prototype.toPayload = function(t) { | |
var e = this.getCall(t) | |
, r = this.extractCallback(t) | |
, n = this.formatInput(t); | |
return this.validateArgs(n), | |
{ | |
method: e, | |
params: n, | |
callback: r | |
} | |
} | |
, | |
o.prototype.attachToObject = function(t) { | |
var e = this.buildCall(); | |
e.call = this.call; | |
var r = this.name.split("."); | |
1 < r.length ? (t[r[0]] = t[r[0]] || {}, | |
t[r[0]][r[1]] = e) : t[r[0]] = e | |
} | |
, | |
o.prototype.buildCall = function() { | |
var t = this | |
, e = function() { | |
var e = t.toPayload(Array.prototype.slice.call(arguments)); | |
return e.callback ? t.requestManager.sendAsync(e, function(r, n) { | |
e.callback(r, t.formatOutput(n)) | |
}) : t.formatOutput(t.requestManager.send(e)) | |
}; | |
return e.request = this.request.bind(this), | |
e | |
} | |
, | |
o.prototype.request = function() { | |
var t = this.toPayload(Array.prototype.slice.call(arguments)); | |
return t.format = this.formatOutput.bind(this), | |
t | |
} | |
, | |
e.exports = o | |
} | |
, { | |
"../utils/utils": 20, | |
"./errors": 26 | |
}], | |
37: [function(t, e, r) { | |
var n = t("../method"); | |
e.exports = function(t) { | |
this._requestManager = t._requestManager; | |
var e = this; | |
[new n({ | |
name: "putString", | |
call: "db_putString", | |
params: 3 | |
}), new n({ | |
name: "getString", | |
call: "db_getString", | |
params: 2 | |
}), new n({ | |
name: "putHex", | |
call: "db_putHex", | |
params: 3 | |
}), new n({ | |
name: "getHex", | |
call: "db_getHex", | |
params: 2 | |
})].forEach(function(r) { | |
r.attachToObject(e), | |
r.setRequestManager(t._requestManager) | |
}) | |
} | |
} | |
, { | |
"../method": 36 | |
}], | |
38: [function(t, e, r) { | |
"use strict"; | |
var n = t("../formatters") | |
, i = t("../../utils/utils") | |
, o = t("../method") | |
, s = t("../property") | |
, a = t("../../utils/config") | |
, u = t("../contract") | |
, c = t("./watches") | |
, f = t("../filter") | |
, l = t("../syncing") | |
, h = t("../namereg") | |
, p = t("../iban") | |
, d = t("../transfer") | |
, y = function(t) { | |
return i.isString(t[0]) && 0 === t[0].indexOf("0x") ? "eth_getBlockByHash" : "eth_getBlockByNumber" | |
} | |
, m = function(t) { | |
return i.isString(t[0]) && 0 === t[0].indexOf("0x") ? "eth_getTransactionByBlockHashAndIndex" : "eth_getTransactionByBlockNumberAndIndex" | |
} | |
, g = function(t) { | |
return i.isString(t[0]) && 0 === t[0].indexOf("0x") ? "eth_getUncleByBlockHashAndIndex" : "eth_getUncleByBlockNumberAndIndex" | |
} | |
, v = function(t) { | |
return i.isString(t[0]) && 0 === t[0].indexOf("0x") ? "eth_getBlockTransactionCountByHash" : "eth_getBlockTransactionCountByNumber" | |
} | |
, b = function(t) { | |
return i.isString(t[0]) && 0 === t[0].indexOf("0x") ? "eth_getUncleCountByBlockHash" : "eth_getUncleCountByBlockNumber" | |
}; | |
function w(t) { | |
this._requestManager = t._requestManager; | |
var e = this; | |
_().forEach(function(t) { | |
t.attachToObject(e), | |
t.setRequestManager(e._requestManager) | |
}), | |
x().forEach(function(t) { | |
t.attachToObject(e), | |
t.setRequestManager(e._requestManager) | |
}), | |
this.iban = p, | |
this.sendIBANTransaction = d.bind(null, this) | |
} | |
Object.defineProperty(w.prototype, "defaultBlock", { | |
get: function() { | |
return a.defaultBlock | |
}, | |
set: function(t) { | |
return a.defaultBlock = t | |
} | |
}), | |
Object.defineProperty(w.prototype, "defaultAccount", { | |
get: function() { | |
return a.defaultAccount | |
}, | |
set: function(t) { | |
return a.defaultAccount = t | |
} | |
}); | |
var _ = function() { | |
var t = new o({ | |
name: "getBalance", | |
call: "eth_getBalance", | |
params: 2, | |
inputFormatter: [n.inputAddressFormatter, n.inputDefaultBlockNumberFormatter], | |
outputFormatter: n.outputBigNumberFormatter | |
}) | |
, e = new o({ | |
name: "getStorageAt", | |
call: "eth_getStorageAt", | |
params: 3, | |
inputFormatter: [null, i.toHex, n.inputDefaultBlockNumberFormatter] | |
}) | |
, r = new o({ | |
name: "getCode", | |
call: "eth_getCode", | |
params: 2, | |
inputFormatter: [n.inputAddressFormatter, n.inputDefaultBlockNumberFormatter] | |
}) | |
, s = new o({ | |
name: "getBlock", | |
call: y, | |
params: 2, | |
inputFormatter: [n.inputBlockNumberFormatter, function(t) { | |
return !!t | |
} | |
], | |
outputFormatter: n.outputBlockFormatter | |
}) | |
, a = new o({ | |
name: "getUncle", | |
call: g, | |
params: 2, | |
inputFormatter: [n.inputBlockNumberFormatter, i.toHex], | |
outputFormatter: n.outputBlockFormatter | |
}) | |
, u = new o({ | |
name: "getCompilers", | |
call: "eth_getCompilers", | |
params: 0 | |
}) | |
, c = new o({ | |
name: "getBlockTransactionCount", | |
call: v, | |
params: 1, | |
inputFormatter: [n.inputBlockNumberFormatter], | |
outputFormatter: i.toDecimal | |
}) | |
, f = new o({ | |
name: "getBlockUncleCount", | |
call: b, | |
params: 1, | |
inputFormatter: [n.inputBlockNumberFormatter], | |
outputFormatter: i.toDecimal | |
}) | |
, l = new o({ | |
name: "getTransaction", | |
call: "eth_getTransactionByHash", | |
params: 1, | |
outputFormatter: n.outputTransactionFormatter | |
}) | |
, h = new o({ | |
name: "getTransactionFromBlock", | |
call: m, | |
params: 2, | |
inputFormatter: [n.inputBlockNumberFormatter, i.toHex], | |
outputFormatter: n.outputTransactionFormatter | |
}) | |
, p = new o({ | |
name: "getTransactionReceipt", | |
call: "eth_getTransactionReceipt", | |
params: 1, | |
outputFormatter: n.outputTransactionReceiptFormatter | |
}) | |
, d = new o({ | |
name: "getTransactionCount", | |
call: "eth_getTransactionCount", | |
params: 2, | |
inputFormatter: [null, n.inputDefaultBlockNumberFormatter], | |
outputFormatter: i.toDecimal | |
}) | |
, w = new o({ | |
name: "sendRawTransaction", | |
call: "eth_sendRawTransaction", | |
params: 1, | |
inputFormatter: [null] | |
}) | |
, _ = new o({ | |
name: "sendTransaction", | |
call: "eth_sendTransaction", | |
params: 1, | |
inputFormatter: [n.inputTransactionFormatter] | |
}) | |
, x = new o({ | |
name: "signTransaction", | |
call: "eth_signTransaction", | |
params: 1, | |
inputFormatter: [n.inputTransactionFormatter] | |
}) | |
, S = new o({ | |
name: "sign", | |
call: "eth_sign", | |
params: 2, | |
inputFormatter: [n.inputAddressFormatter, null] | |
}); | |
return [t, e, r, s, a, u, c, f, l, h, p, d, new o({ | |
name: "call", | |
call: "eth_call", | |
params: 2, | |
inputFormatter: [n.inputCallFormatter, n.inputDefaultBlockNumberFormatter] | |
}), new o({ | |
name: "estimateGas", | |
call: "eth_estimateGas", | |
params: 1, | |
inputFormatter: [n.inputCallFormatter], | |
outputFormatter: i.toDecimal | |
}), w, x, _, S, new o({ | |
name: "compile.solidity", | |
call: "eth_compileSolidity", | |
params: 1 | |
}), new o({ | |
name: "compile.lll", | |
call: "eth_compileLLL", | |
params: 1 | |
}), new o({ | |
name: "compile.serpent", | |
call: "eth_compileSerpent", | |
params: 1 | |
}), new o({ | |
name: "submitWork", | |
call: "eth_submitWork", | |
params: 3 | |
}), new o({ | |
name: "getWork", | |
call: "eth_getWork", | |
params: 0 | |
})] | |
} | |
, x = function() { | |
return [new s({ | |
name: "coinbase", | |
getter: "eth_coinbase" | |
}), new s({ | |
name: "mining", | |
getter: "eth_mining" | |
}), new s({ | |
name: "hashrate", | |
getter: "eth_hashrate", | |
outputFormatter: i.toDecimal | |
}), new s({ | |
name: "syncing", | |
getter: "eth_syncing", | |
outputFormatter: n.outputSyncingFormatter | |
}), new s({ | |
name: "gasPrice", | |
getter: "eth_gasPrice", | |
outputFormatter: n.outputBigNumberFormatter | |
}), new s({ | |
name: "accounts", | |
getter: "eth_accounts" | |
}), new s({ | |
name: "blockNumber", | |
getter: "eth_blockNumber", | |
outputFormatter: i.toDecimal | |
}), new s({ | |
name: "protocolVersion", | |
getter: "eth_protocolVersion" | |
})] | |
}; | |
w.prototype.contract = function(t) { | |
return new u(this,t) | |
} | |
, | |
w.prototype.filter = function(t, e, r) { | |
return new f(t,"eth",this._requestManager,c.eth(),n.outputLogFormatter,e,r) | |
} | |
, | |
w.prototype.namereg = function() { | |
return this.contract(h.global.abi).at(h.global.address) | |
} | |
, | |
w.prototype.icapNamereg = function() { | |
return this.contract(h.icap.abi).at(h.icap.address) | |
} | |
, | |
w.prototype.isSyncing = function(t) { | |
return new l(this._requestManager,t) | |
} | |
, | |
e.exports = w | |
} | |
, { | |
"../../utils/config": 18, | |
"../../utils/utils": 20, | |
"../contract": 25, | |
"../filter": 29, | |
"../formatters": 30, | |
"../iban": 33, | |
"../method": 36, | |
"../namereg": 44, | |
"../property": 45, | |
"../syncing": 48, | |
"../transfer": 49, | |
"./watches": 43 | |
}], | |
39: [function(t, e, r) { | |
var n = t("../../utils/utils") | |
, i = t("../property"); | |
e.exports = function(t) { | |
this._requestManager = t._requestManager; | |
var e = this; | |
[new i({ | |
name: "listening", | |
getter: "net_listening" | |
}), new i({ | |
name: "peerCount", | |
getter: "net_peerCount", | |
outputFormatter: n.toDecimal | |
})].forEach(function(r) { | |
r.attachToObject(e), | |
r.setRequestManager(t._requestManager) | |
}) | |
} | |
} | |
, { | |
"../../utils/utils": 20, | |
"../property": 45 | |
}], | |
40: [function(t, e, r) { | |
"use strict"; | |
var n = t("../method") | |
, i = t("../property") | |
, o = t("../formatters"); | |
e.exports = function(t) { | |
this._requestManager = t._requestManager; | |
var e, r, s, a, u, c, f, l = this; | |
(e = new n({ | |
name: "newAccount", | |
call: "personal_newAccount", | |
params: 1, | |
inputFormatter: [null] | |
}), | |
r = new n({ | |
name: "importRawKey", | |
call: "personal_importRawKey", | |
params: 2 | |
}), | |
s = new n({ | |
name: "sign", | |
call: "personal_sign", | |
params: 3, | |
inputFormatter: [null, o.inputAddressFormatter, null] | |
}), | |
a = new n({ | |
name: "ecRecover", | |
call: "personal_ecRecover", | |
params: 2 | |
}), | |
u = new n({ | |
name: "unlockAccount", | |
call: "personal_unlockAccount", | |
params: 3, | |
inputFormatter: [o.inputAddressFormatter, null, null] | |
}), | |
c = new n({ | |
name: "sendTransaction", | |
call: "personal_sendTransaction", | |
params: 2, | |
inputFormatter: [o.inputTransactionFormatter, null] | |
}), | |
f = new n({ | |
name: "lockAccount", | |
call: "personal_lockAccount", | |
params: 1, | |
inputFormatter: [o.inputAddressFormatter] | |
}), | |
[e, r, u, a, s, c, f]).forEach(function(t) { | |
t.attachToObject(l), | |
t.setRequestManager(l._requestManager) | |
}), | |
[new i({ | |
name: "listAccounts", | |
getter: "personal_listAccounts" | |
})].forEach(function(t) { | |
t.attachToObject(l), | |
t.setRequestManager(l._requestManager) | |
}) | |
} | |
} | |
, { | |
"../formatters": 30, | |
"../method": 36, | |
"../property": 45 | |
}], | |
41: [function(t, e, r) { | |
var n = t("../method") | |
, i = t("../filter") | |
, o = t("./watches") | |
, s = function(t) { | |
this._requestManager = t._requestManager; | |
var e = this; | |
a().forEach(function(t) { | |
t.attachToObject(e), | |
t.setRequestManager(e._requestManager) | |
}) | |
}; | |
s.prototype.newMessageFilter = function(t, e, r) { | |
return new i(t,"shh",this._requestManager,o.shh(),null,e,r) | |
} | |
; | |
var a = function() { | |
return [new n({ | |
name: "version", | |
call: "shh_version", | |
params: 0 | |
}), new n({ | |
name: "info", | |
call: "shh_info", | |
params: 0 | |
}), new n({ | |
name: "setMaxMessageSize", | |
call: "shh_setMaxMessageSize", | |
params: 1 | |
}), new n({ | |
name: "setMinPoW", | |
call: "shh_setMinPoW", | |
params: 1 | |
}), new n({ | |
name: "markTrustedPeer", | |
call: "shh_markTrustedPeer", | |
params: 1 | |
}), new n({ | |
name: "newKeyPair", | |
call: "shh_newKeyPair", | |
params: 0 | |
}), new n({ | |
name: "addPrivateKey", | |
call: "shh_addPrivateKey", | |
params: 1 | |
}), new n({ | |
name: "deleteKeyPair", | |
call: "shh_deleteKeyPair", | |
params: 1 | |
}), new n({ | |
name: "hasKeyPair", | |
call: "shh_hasKeyPair", | |
params: 1 | |
}), new n({ | |
name: "getPublicKey", | |
call: "shh_getPublicKey", | |
params: 1 | |
}), new n({ | |
name: "getPrivateKey", | |
call: "shh_getPrivateKey", | |
params: 1 | |
}), new n({ | |
name: "newSymKey", | |
call: "shh_newSymKey", | |
params: 0 | |
}), new n({ | |
name: "addSymKey", | |
call: "shh_addSymKey", | |
params: 1 | |
}), new n({ | |
name: "generateSymKeyFromPassword", | |
call: "shh_generateSymKeyFromPassword", | |
params: 1 | |
}), new n({ | |
name: "hasSymKey", | |
call: "shh_hasSymKey", | |
params: 1 | |
}), new n({ | |
name: "getSymKey", | |
call: "shh_getSymKey", | |
params: 1 | |
}), new n({ | |
name: "deleteSymKey", | |
call: "shh_deleteSymKey", | |
params: 1 | |
}), new n({ | |
name: "post", | |
call: "shh_post", | |
params: 1, | |
inputFormatter: [null] | |
})] | |
}; | |
e.exports = s | |
} | |
, { | |
"../filter": 29, | |
"../method": 36, | |
"./watches": 43 | |
}], | |
42: [function(t, e, r) { | |
"use strict"; | |
var n = t("../method") | |
, i = t("../property"); | |
e.exports = function(t) { | |
this._requestManager = t._requestManager; | |
var e, r, o, s, a, u, c, f, l, h, p = this; | |
(e = new n({ | |
name: "blockNetworkRead", | |
call: "bzz_blockNetworkRead", | |
params: 1, | |
inputFormatter: [null] | |
}), | |
r = new n({ | |
name: "syncEnabled", | |
call: "bzz_syncEnabled", | |
params: 1, | |
inputFormatter: [null] | |
}), | |
o = new n({ | |
name: "swapEnabled", | |
call: "bzz_swapEnabled", | |
params: 1, | |
inputFormatter: [null] | |
}), | |
s = new n({ | |
name: "download", | |
call: "bzz_download", | |
params: 2, | |
inputFormatter: [null, null] | |
}), | |
a = new n({ | |
name: "upload", | |
call: "bzz_upload", | |
params: 2, | |
inputFormatter: [null, null] | |
}), | |
u = new n({ | |
name: "retrieve", | |
call: "bzz_retrieve", | |
params: 1, | |
inputFormatter: [null] | |
}), | |
c = new n({ | |
name: "store", | |
call: "bzz_store", | |
params: 2, | |
inputFormatter: [null, null] | |
}), | |
f = new n({ | |
name: "get", | |
call: "bzz_get", | |
params: 1, | |
inputFormatter: [null] | |
}), | |
l = new n({ | |
name: "put", | |
call: "bzz_put", | |
params: 2, | |
inputFormatter: [null, null] | |
}), | |
h = new n({ | |
name: "modify", | |
call: "bzz_modify", | |
params: 4, | |
inputFormatter: [null, null, null, null] | |
}), | |
[e, r, o, s, a, u, c, f, l, h]).forEach(function(t) { | |
t.attachToObject(p), | |
t.setRequestManager(p._requestManager) | |
}), | |
[new i({ | |
name: "hive", | |
getter: "bzz_hive" | |
}), new i({ | |
name: "info", | |
getter: "bzz_info" | |
})].forEach(function(t) { | |
t.attachToObject(p), | |
t.setRequestManager(p._requestManager) | |
}) | |
} | |
} | |
, { | |
"../method": 36, | |
"../property": 45 | |
}], | |
43: [function(t, e, r) { | |
var n = t("../method"); | |
e.exports = { | |
eth: function() { | |
return [new n({ | |
name: "newFilter", | |
call: function(t) { | |
switch (t[0]) { | |
case "latest": | |
return t.shift(), | |
this.params = 0, | |
"eth_newBlockFilter"; | |
case "pending": | |
return t.shift(), | |
this.params = 0, | |
"eth_newPendingTransactionFilter"; | |
default: | |
return "eth_newFilter" | |
} | |
}, | |
params: 1 | |
}), new n({ | |
name: "uninstallFilter", | |
call: "eth_uninstallFilter", | |
params: 1 | |
}), new n({ | |
name: "getLogs", | |
call: "eth_getFilterLogs", | |
params: 1 | |
}), new n({ | |
name: "poll", | |
call: "eth_getFilterChanges", | |
params: 1 | |
})] | |
}, | |
shh: function() { | |
return [new n({ | |
name: "newFilter", | |
call: "shh_newMessageFilter", | |
params: 1 | |
}), new n({ | |
name: "uninstallFilter", | |
call: "shh_deleteMessageFilter", | |
params: 1 | |
}), new n({ | |
name: "getLogs", | |
call: "shh_getFilterMessages", | |
params: 1 | |
}), new n({ | |
name: "poll", | |
call: "shh_getFilterMessages", | |
params: 1 | |
})] | |
} | |
} | |
} | |
, { | |
"../method": 36 | |
}], | |
44: [function(t, e, r) { | |
var n = t("../contracts/GlobalRegistrar.json") | |
, i = t("../contracts/ICAPRegistrar.json"); | |
e.exports = { | |
global: { | |
abi: n, | |
address: "0xc6d9d2cd449a754c494264e1809c50e34d64562b" | |
}, | |
icap: { | |
abi: i, | |
address: "0xa1a111bc074c9cfa781f0c38e63bd51c91b8af00" | |
} | |
} | |
} | |
, { | |
"../contracts/GlobalRegistrar.json": 1, | |
"../contracts/ICAPRegistrar.json": 2 | |
}], | |
45: [function(t, e, r) { | |
var n = t("../utils/utils") | |
, i = function(t) { | |
this.name = t.name, | |
this.getter = t.getter, | |
this.setter = t.setter, | |
this.outputFormatter = t.outputFormatter, | |
this.inputFormatter = t.inputFormatter, | |
this.requestManager = null | |
}; | |
i.prototype.setRequestManager = function(t) { | |
this.requestManager = t | |
} | |
, | |
i.prototype.formatInput = function(t) { | |
return this.inputFormatter ? this.inputFormatter(t) : t | |
} | |
, | |
i.prototype.formatOutput = function(t) { | |
return this.outputFormatter && null != t ? this.outputFormatter(t) : t | |
} | |
, | |
i.prototype.extractCallback = function(t) { | |
if (n.isFunction(t[t.length - 1])) | |
return t.pop() | |
} | |
, | |
i.prototype.attachToObject = function(t) { | |
var e = { | |
get: this.buildGet(), | |
enumerable: !0 | |
} | |
, r = this.name.split(".") | |
, n = r[0]; | |
1 < r.length && (t[r[0]] = t[r[0]] || {}, | |
t = t[r[0]], | |
n = r[1]), | |
Object.defineProperty(t, n, e), | |
t[o(n)] = this.buildAsyncGet() | |
} | |
; | |
var o = function(t) { | |
return "get" + t.charAt(0).toUpperCase() + t.slice(1) | |
}; | |
i.prototype.buildGet = function() { | |
var t = this; | |
return function() { | |
return t.formatOutput(t.requestManager.send({ | |
method: t.getter | |
})) | |
} | |
} | |
, | |
i.prototype.buildAsyncGet = function() { | |
var t = this | |
, e = function(e) { | |
t.requestManager.sendAsync({ | |
method: t.getter | |
}, function(r, n) { | |
e(r, t.formatOutput(n)) | |
}) | |
}; | |
return e.request = this.request.bind(this), | |
e | |
} | |
, | |
i.prototype.request = function() { | |
var t = { | |
method: this.getter, | |
params: [], | |
callback: this.extractCallback(Array.prototype.slice.call(arguments)) | |
}; | |
return t.format = this.formatOutput.bind(this), | |
t | |
} | |
, | |
e.exports = i | |
} | |
, { | |
"../utils/utils": 20 | |
}], | |
46: [function(t, e, r) { | |
var n = t("./jsonrpc") | |
, i = t("../utils/utils") | |
, o = t("../utils/config") | |
, s = t("./errors") | |
, a = function(t) { | |
this.provider = t, | |
this.polls = {}, | |
this.timeout = null | |
}; | |
a.prototype.send = function(t) { | |
if (!this.provider) | |
return console.error(s.InvalidProvider()), | |
null; | |
var e = n.toPayload(t.method, t.params) | |
, r = this.provider.send(e); | |
if (!n.isValidResponse(r)) | |
throw s.InvalidResponse(r); | |
return r.result | |
} | |
, | |
a.prototype.sendAsync = function(t, e) { | |
if (!this.provider) | |
return e(s.InvalidProvider()); | |
var r = n.toPayload(t.method, t.params); | |
this.provider.sendAsync(r, function(t, r) { | |
return t ? e(t) : n.isValidResponse(r) ? void e(null, r.result) : e(s.InvalidResponse(r)) | |
}) | |
} | |
, | |
a.prototype.sendBatch = function(t, e) { | |
if (!this.provider) | |
return e(s.InvalidProvider()); | |
var r = n.toBatchPayload(t); | |
this.provider.sendAsync(r, function(t, r) { | |
return t ? e(t) : i.isArray(r) ? void e(t, r) : e(s.InvalidResponse(r)) | |
}) | |
} | |
, | |
a.prototype.setProvider = function(t) { | |
this.provider = t | |
} | |
, | |
a.prototype.startPolling = function(t, e, r, n) { | |
this.polls[e] = { | |
data: t, | |
id: e, | |
callback: r, | |
uninstall: n | |
}, | |
this.timeout || this.poll() | |
} | |
, | |
a.prototype.stopPolling = function(t) { | |
delete this.polls[t], | |
0 === Object.keys(this.polls).length && this.timeout && (clearTimeout(this.timeout), | |
this.timeout = null) | |
} | |
, | |
a.prototype.reset = function(t) { | |
for (var e in this.polls) | |
t && -1 !== e.indexOf("syncPoll_") || (this.polls[e].uninstall(), | |
delete this.polls[e]); | |
0 === Object.keys(this.polls).length && this.timeout && (clearTimeout(this.timeout), | |
this.timeout = null) | |
} | |
, | |
a.prototype.poll = function() { | |
if (this.timeout = setTimeout(this.poll.bind(this), o.ETH_POLLING_TIMEOUT), | |
0 !== Object.keys(this.polls).length) | |
if (this.provider) { | |
var t = [] | |
, e = []; | |
for (var r in this.polls) | |
t.push(this.polls[r].data), | |
e.push(r); | |
if (0 !== t.length) { | |
var a = n.toBatchPayload(t) | |
, u = {}; | |
a.forEach(function(t, r) { | |
u[t.id] = e[r] | |
}); | |
var c = this; | |
this.provider.sendAsync(a, function(t, e) { | |
if (!t) { | |
if (!i.isArray(e)) | |
throw s.InvalidResponse(e); | |
e.map(function(t) { | |
var e = u[t.id]; | |
return !!c.polls[e] && (t.callback = c.polls[e].callback, | |
t) | |
}).filter(function(t) { | |
return !!t | |
}).filter(function(t) { | |
var e = n.isValidResponse(t); | |
return e || t.callback(s.InvalidResponse(t)), | |
e | |
}).forEach(function(t) { | |
t.callback(null, t.result) | |
}) | |
} | |
}) | |
} | |
} else | |
console.error(s.InvalidProvider()) | |
} | |
, | |
e.exports = a | |
} | |
, { | |
"../utils/config": 18, | |
"../utils/utils": 20, | |
"./errors": 26, | |
"./jsonrpc": 35 | |
}], | |
47: [function(t, e, r) { | |
e.exports = function() { | |
this.defaultBlock = "latest", | |
this.defaultAccount = void 0 | |
} | |
} | |
, {}], | |
48: [function(t, e, r) { | |
var n = t("./formatters") | |
, i = t("../utils/utils") | |
, o = 1 | |
, s = function(t, e) { | |
var r; | |
return this.requestManager = t, | |
this.pollId = "syncPoll_" + o++, | |
this.callbacks = [], | |
this.addCallback(e), | |
this.lastSyncState = !1, | |
(r = this).requestManager.startPolling({ | |
method: "eth_syncing", | |
params: [] | |
}, r.pollId, function(t, e) { | |
if (t) | |
return r.callbacks.forEach(function(e) { | |
e(t) | |
}); | |
i.isObject(e) && e.startingBlock && (e = n.outputSyncingFormatter(e)), | |
r.callbacks.forEach(function(t) { | |
r.lastSyncState !== e && (!r.lastSyncState && i.isObject(e) && t(null, !0), | |
setTimeout(function() { | |
t(null, e) | |
}, 0), | |
r.lastSyncState = e) | |
}) | |
}, r.stopWatching.bind(r)), | |
this | |
}; | |
s.prototype.addCallback = function(t) { | |
return t && this.callbacks.push(t), | |
this | |
} | |
, | |
s.prototype.stopWatching = function() { | |
this.requestManager.stopPolling(this.pollId), | |
this.callbacks = [] | |
} | |
, | |
e.exports = s | |
} | |
, { | |
"../utils/utils": 20, | |
"./formatters": 30 | |
}], | |
49: [function(t, e, r) { | |
var n = t("./iban") | |
, i = t("../contracts/SmartExchange.json") | |
, o = function(t, e, r, n, o, s) { | |
var a = i; | |
return t.contract(a).at(r).deposit(o, { | |
from: e, | |
value: n | |
}, s) | |
}; | |
e.exports = function(t, e, r, i, s) { | |
var a = new n(r); | |
if (!a.isValid()) | |
throw new Error("invalid iban address"); | |
if (a.isDirect()) | |
return function(t, e, r, n, i) { | |
return t.sendTransaction({ | |
address: r, | |
from: e, | |
value: n | |
}, i) | |
}(t, e, a.address(), i, s); | |
if (!s) { | |
var u = t.icapNamereg().addr(a.institution()); | |
return o(t, e, u, i, a.client()) | |
} | |
t.icapNamereg().addr(a.institution(), function(r, n) { | |
return o(t, e, n, i, a.client(), s) | |
}) | |
} | |
} | |
, { | |
"../contracts/SmartExchange.json": 3, | |
"./iban": 33 | |
}], | |
50: [function(t, e, r) { | |
"use strict"; | |
r.byteLength = function(t) { | |
var e = c(t) | |
, r = e[0] | |
, n = e[1]; | |
return 3 * (r + n) / 4 - n | |
} | |
, | |
r.toByteArray = function(t) { | |
for (var e, r = c(t), n = r[0], s = r[1], a = new o(3 * (n + (h = s)) / 4 - h), u = 0, f = 0 < s ? n - 4 : n, l = 0; l < f; l += 4) | |
e = i[t.charCodeAt(l)] << 18 | i[t.charCodeAt(l + 1)] << 12 | i[t.charCodeAt(l + 2)] << 6 | i[t.charCodeAt(l + 3)], | |
a[u++] = e >> 16 & 255, | |
a[u++] = e >> 8 & 255, | |
a[u++] = 255 & e; | |
var h; | |
return 2 === s && (e = i[t.charCodeAt(l)] << 2 | i[t.charCodeAt(l + 1)] >> 4, | |
a[u++] = 255 & e), | |
1 === s && (e = i[t.charCodeAt(l)] << 10 | i[t.charCodeAt(l + 1)] << 4 | i[t.charCodeAt(l + 2)] >> 2, | |
a[u++] = e >> 8 & 255, | |
a[u++] = 255 & e), | |
a | |
} | |
, | |
r.fromByteArray = function(t) { | |
for (var e, r = t.length, i = r % 3, o = [], s = 0, a = r - i; s < a; s += 16383) | |
o.push(f(t, s, a < s + 16383 ? a : s + 16383)); | |
return 1 === i ? (e = t[r - 1], | |
o.push(n[e >> 2] + n[e << 4 & 63] + "==")) : 2 === i && (e = (t[r - 2] << 8) + t[r - 1], | |
o.push(n[e >> 10] + n[e >> 4 & 63] + n[e << 2 & 63] + "=")), | |
o.join("") | |
} | |
; | |
for (var n = [], i = [], o = "undefined" != typeof Uint8Array ? Uint8Array : Array, s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", a = 0, u = s.length; a < u; ++a) | |
n[a] = s[a], | |
i[s.charCodeAt(a)] = a; | |
function c(t) { | |
var e = t.length; | |
if (0 < e % 4) | |
throw new Error("Invalid string. Length must be a multiple of 4"); | |
var r = t.indexOf("="); | |
return -1 === r && (r = e), | |
[r, r === e ? 0 : 4 - r % 4] | |
} | |
function f(t, e, r) { | |
for (var i, o, s = [], a = e; a < r; a += 3) | |
i = (t[a] << 16 & 16711680) + (t[a + 1] << 8 & 65280) + (255 & t[a + 2]), | |
s.push(n[(o = i) >> 18 & 63] + n[o >> 12 & 63] + n[o >> 6 & 63] + n[63 & o]); | |
return s.join("") | |
} | |
i["-".charCodeAt(0)] = 62, | |
i["_".charCodeAt(0)] = 63 | |
} | |
, {}], | |
51: [function(t, e, r) {} | |
, {}], | |
52: [function(t, e, r) { | |
arguments[4][51][0].apply(r, arguments) | |
} | |
, { | |
dup: 51 | |
}], | |
53: [function(t, e, r) { | |
"use strict"; | |
var n = t("base64-js") | |
, i = t("ieee754"); | |
r.Buffer = a, | |
r.SlowBuffer = function(t) { | |
return +t != t && (t = 0), | |
a.alloc(+t) | |
} | |
, | |
r.INSPECT_MAX_BYTES = 50; | |
var o = 2147483647; | |
function s(t) { | |
if (o < t) | |
throw new RangeError("Invalid typed array length"); | |
var e = new Uint8Array(t); | |
return e.__proto__ = a.prototype, | |
e | |
} | |
function a(t, e, r) { | |
if ("number" == typeof t) { | |
if ("string" == typeof e) | |
throw new Error("If encoding is specified then the first argument must be a string"); | |
return f(t) | |
} | |
return u(t, e, r) | |
} | |
function u(t, e, r) { | |
if ("number" == typeof t) | |
throw new TypeError('"value" argument must not be a number'); | |
return N(t) || t && N(t.buffer) ? function(t, e, r) { | |
if (e < 0 || t.byteLength < e) | |
throw new RangeError('"offset" is outside of buffer bounds'); | |
if (t.byteLength < e + (r || 0)) | |
throw new RangeError('"length" is outside of buffer bounds'); | |
var n; | |
return (n = void 0 === e && void 0 === r ? new Uint8Array(t) : void 0 === r ? new Uint8Array(t,e) : new Uint8Array(t,e,r)).__proto__ = a.prototype, | |
n | |
}(t, e, r) : "string" == typeof t ? function(t, e) { | |
if ("string" == typeof e && "" !== e || (e = "utf8"), | |
!a.isEncoding(e)) | |
throw new TypeError("Unknown encoding: " + e); | |
var r = 0 | p(t, e) | |
, n = s(r) | |
, i = n.write(t, e); | |
return i !== r && (n = n.slice(0, i)), | |
n | |
}(t, e) : function(t) { | |
if (a.isBuffer(t)) { | |
var e = 0 | h(t.length) | |
, r = s(e); | |
return 0 === r.length || t.copy(r, 0, 0, e), | |
r | |
} | |
if (t) { | |
if (ArrayBuffer.isView(t) || "length"in t) | |
return "number" != typeof t.length || P(t.length) ? s(0) : l(t); | |
if ("Buffer" === t.type && Array.isArray(t.data)) | |
return l(t.data) | |
} | |
throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object.") | |
}(t) | |
} | |
function c(t) { | |
if ("number" != typeof t) | |
throw new TypeError('"size" argument must be of type number'); | |
if (t < 0) | |
throw new RangeError('"size" argument must not be negative') | |
} | |
function f(t) { | |
return c(t), | |
s(t < 0 ? 0 : 0 | h(t)) | |
} | |
function l(t) { | |
for (var e = t.length < 0 ? 0 : 0 | h(t.length), r = s(e), n = 0; n < e; n += 1) | |
r[n] = 255 & t[n]; | |
return r | |
} | |
function h(t) { | |
if (o <= t) | |
throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + o.toString(16) + " bytes"); | |
return 0 | t | |
} | |
function p(t, e) { | |
if (a.isBuffer(t)) | |
return t.length; | |
if (ArrayBuffer.isView(t) || N(t)) | |
return t.byteLength; | |
"string" != typeof t && (t = "" + t); | |
var r = t.length; | |
if (0 === r) | |
return 0; | |
for (var n = !1; ; ) | |
switch (e) { | |
case "ascii": | |
case "latin1": | |
case "binary": | |
return r; | |
case "utf8": | |
case "utf-8": | |
case void 0: | |
return M(t).length; | |
case "ucs2": | |
case "ucs-2": | |
case "utf16le": | |
case "utf-16le": | |
return 2 * r; | |
case "hex": | |
return r >>> 1; | |
case "base64": | |
return L(t).length; | |
default: | |
if (n) | |
return M(t).length; | |
e = ("" + e).toLowerCase(), | |
n = !0 | |
} | |
} | |
function d(t, e, r) { | |
var n = t[e]; | |
t[e] = t[r], | |
t[r] = n | |
} | |
function y(t, e, r, n, i) { | |
if (0 === t.length) | |
return -1; | |
if ("string" == typeof r ? (n = r, | |
r = 0) : 2147483647 < r ? r = 2147483647 : r < -2147483648 && (r = -2147483648), | |
P(r = +r) && (r = i ? 0 : t.length - 1), | |
r < 0 && (r = t.length + r), | |
r >= t.length) { | |
if (i) | |
return -1; | |
r = t.length - 1 | |
} else if (r < 0) { | |
if (!i) | |
return -1; | |
r = 0 | |
} | |
if ("string" == typeof e && (e = a.from(e, n)), | |
a.isBuffer(e)) | |
return 0 === e.length ? -1 : m(t, e, r, n, i); | |
if ("number" == typeof e) | |
return e &= 255, | |
"function" == typeof Uint8Array.prototype.indexOf ? i ? Uint8Array.prototype.indexOf.call(t, e, r) : Uint8Array.prototype.lastIndexOf.call(t, e, r) : m(t, [e], r, n, i); | |
throw new TypeError("val must be string, number or Buffer") | |
} | |
function m(t, e, r, n, i) { | |
var o, s = 1, a = t.length, u = e.length; | |
if (void 0 !== n && ("ucs2" === (n = String(n).toLowerCase()) || "ucs-2" === n || "utf16le" === n || "utf-16le" === n)) { | |
if (t.length < 2 || e.length < 2) | |
return -1; | |
a /= s = 2, | |
u /= 2, | |
r /= 2 | |
} | |
function c(t, e) { | |
return 1 === s ? t[e] : t.readUInt16BE(e * s) | |
} | |
if (i) { | |
var f = -1; | |
for (o = r; o < a; o++) | |
if (c(t, o) === c(e, -1 === f ? 0 : o - f)) { | |
if (-1 === f && (f = o), | |
o - f + 1 === u) | |
return f * s | |
} else | |
-1 !== f && (o -= o - f), | |
f = -1 | |
} else | |
for (a < r + u && (r = a - u), | |
o = r; 0 <= o; o--) { | |
for (var l = !0, h = 0; h < u; h++) | |
if (c(t, o + h) !== c(e, h)) { | |
l = !1; | |
break | |
} | |
if (l) | |
return o | |
} | |
return -1 | |
} | |
function g(t, e, r, n) { | |
r = Number(r) || 0; | |
var i = t.length - r; | |
n ? i < (n = Number(n)) && (n = i) : n = i; | |
var o = e.length; | |
o / 2 < n && (n = o / 2); | |
for (var s = 0; s < n; ++s) { | |
var a = parseInt(e.substr(2 * s, 2), 16); | |
if (P(a)) | |
return s; | |
t[r + s] = a | |
} | |
return s | |
} | |
function v(t, e, r, n) { | |
return I(function(t) { | |
for (var e = [], r = 0; r < t.length; ++r) | |
e.push(255 & t.charCodeAt(r)); | |
return e | |
}(e), t, r, n) | |
} | |
function b(t, e, r) { | |
return 0 === e && r === t.length ? n.fromByteArray(t) : n.fromByteArray(t.slice(e, r)) | |
} | |
function w(t, e, r) { | |
r = Math.min(t.length, r); | |
for (var n = [], i = e; i < r; ) { | |
var o, s, a, u, c = t[i], f = null, l = 239 < c ? 4 : 223 < c ? 3 : 191 < c ? 2 : 1; | |
if (i + l <= r) | |
switch (l) { | |
case 1: | |
c < 128 && (f = c); | |
break; | |
case 2: | |
128 == (192 & (o = t[i + 1])) && 127 < (u = (31 & c) << 6 | 63 & o) && (f = u); | |
break; | |
case 3: | |
o = t[i + 1], | |
s = t[i + 2], | |
128 == (192 & o) && 128 == (192 & s) && 2047 < (u = (15 & c) << 12 | (63 & o) << 6 | 63 & s) && (u < 55296 || 57343 < u) && (f = u); | |
break; | |
case 4: | |
o = t[i + 1], | |
s = t[i + 2], | |
a = t[i + 3], | |
128 == (192 & o) && 128 == (192 & s) && 128 == (192 & a) && 65535 < (u = (15 & c) << 18 | (63 & o) << 12 | (63 & s) << 6 | 63 & a) && u < 1114112 && (f = u) | |
} | |
null === f ? (f = 65533, | |
l = 1) : 65535 < f && (f -= 65536, | |
n.push(f >>> 10 & 1023 | 55296), | |
f = 56320 | 1023 & f), | |
n.push(f), | |
i += l | |
} | |
return function(t) { | |
var e = t.length; | |
if (e <= _) | |
return String.fromCharCode.apply(String, t); | |
for (var r = "", n = 0; n < e; ) | |
r += String.fromCharCode.apply(String, t.slice(n, n += _)); | |
return r | |
}(n) | |
} | |
r.kMaxLength = o, | |
(a.TYPED_ARRAY_SUPPORT = function() { | |
try { | |
var t = new Uint8Array(1); | |
return t.__proto__ = { | |
__proto__: Uint8Array.prototype, | |
foo: function() { | |
return 42 | |
} | |
}, | |
42 === t.foo() | |
} catch (t) { | |
return !1 | |
} | |
}()) || "undefined" == typeof console || "function" != typeof console.error || console.error("This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support."), | |
Object.defineProperty(a.prototype, "parent", { | |
get: function() { | |
if (this instanceof a) | |
return this.buffer | |
} | |
}), | |
Object.defineProperty(a.prototype, "offset", { | |
get: function() { | |
if (this instanceof a) | |
return this.byteOffset | |
} | |
}), | |
"undefined" != typeof Symbol && Symbol.species && a[Symbol.species] === a && Object.defineProperty(a, Symbol.species, { | |
value: null, | |
configurable: !0, | |
enumerable: !1, | |
writable: !1 | |
}), | |
a.poolSize = 8192, | |
a.from = function(t, e, r) { | |
return u(t, e, r) | |
} | |
, | |
a.prototype.__proto__ = Uint8Array.prototype, | |
a.__proto__ = Uint8Array, | |
a.alloc = function(t, e, r) { | |
return i = e, | |
o = r, | |
c(n = t), | |
n <= 0 ? s(n) : void 0 !== i ? "string" == typeof o ? s(n).fill(i, o) : s(n).fill(i) : s(n); | |
var n, i, o | |
} | |
, | |
a.allocUnsafe = function(t) { | |
return f(t) | |
} | |
, | |
a.allocUnsafeSlow = function(t) { | |
return f(t) | |
} | |
, | |
a.isBuffer = function(t) { | |
return null != t && !0 === t._isBuffer | |
} | |
, | |
a.compare = function(t, e) { | |
if (!a.isBuffer(t) || !a.isBuffer(e)) | |
throw new TypeError("Arguments must be Buffers"); | |
if (t === e) | |
return 0; | |
for (var r = t.length, n = e.length, i = 0, o = Math.min(r, n); i < o; ++i) | |
if (t[i] !== e[i]) { | |
r = t[i], | |
n = e[i]; | |
break | |
} | |
return r < n ? -1 : n < r ? 1 : 0 | |
} | |
, | |
a.isEncoding = function(t) { | |
switch (String(t).toLowerCase()) { | |
case "hex": | |
case "utf8": | |
case "utf-8": | |
case "ascii": | |
case "latin1": | |
case "binary": | |
case "base64": | |
case "ucs2": | |
case "ucs-2": | |
case "utf16le": | |
case "utf-16le": | |
return !0; | |
default: | |
return !1 | |
} | |
} | |
, | |
a.concat = function(t, e) { | |
if (!Array.isArray(t)) | |
throw new TypeError('"list" argument must be an Array of Buffers'); | |
if (0 === t.length) | |
return a.alloc(0); | |
var r; | |
if (void 0 === e) | |
for (r = e = 0; r < t.length; ++r) | |
e += t[r].length; | |
var n = a.allocUnsafe(e) | |
, i = 0; | |
for (r = 0; r < t.length; ++r) { | |
var o = t[r]; | |
if (ArrayBuffer.isView(o) && (o = a.from(o)), | |
!a.isBuffer(o)) | |
throw new TypeError('"list" argument must be an Array of Buffers'); | |
o.copy(n, i), | |
i += o.length | |
} | |
return n | |
} | |
, | |
a.byteLength = p, | |
a.prototype._isBuffer = !0, | |
a.prototype.swap16 = function() { | |
var t = this.length; | |
if (t % 2 != 0) | |
throw new RangeError("Buffer size must be a multiple of 16-bits"); | |
for (var e = 0; e < t; e += 2) | |
d(this, e, e + 1); | |
return this | |
} | |
, | |
a.prototype.swap32 = function() { | |
var t = this.length; | |
if (t % 4 != 0) | |
throw new RangeError("Buffer size must be a multiple of 32-bits"); | |
for (var e = 0; e < t; e += 4) | |
d(this, e, e + 3), | |
d(this, e + 1, e + 2); | |
return this | |
} | |
, | |
a.prototype.swap64 = function() { | |
var t = this.length; | |
if (t % 8 != 0) | |
throw new RangeError("Buffer size must be a multiple of 64-bits"); | |
for (var e = 0; e < t; e += 8) | |
d(this, e, e + 7), | |
d(this, e + 1, e + 6), | |
d(this, e + 2, e + 5), | |
d(this, e + 3, e + 4); | |
return this | |
} | |
, | |
a.prototype.toLocaleString = a.prototype.toString = function() { | |
var t = this.length; | |
return 0 === t ? "" : 0 === arguments.length ? w(this, 0, t) : function(t, e, r) { | |
var n = !1; | |
if ((void 0 === e || e < 0) && (e = 0), | |
e > this.length) | |
return ""; | |
if ((void 0 === r || r > this.length) && (r = this.length), | |
r <= 0) | |
return ""; | |
if ((r >>>= 0) <= (e >>>= 0)) | |
return ""; | |
for (t || (t = "utf8"); ; ) | |
switch (t) { | |
case "hex": | |
return k(this, e, r); | |
case "utf8": | |
case "utf-8": | |
return w(this, e, r); | |
case "ascii": | |
return x(this, e, r); | |
case "latin1": | |
case "binary": | |
return S(this, e, r); | |
case "base64": | |
return b(this, e, r); | |
case "ucs2": | |
case "ucs-2": | |
case "utf16le": | |
case "utf-16le": | |
return E(this, e, r); | |
default: | |
if (n) | |
throw new TypeError("Unknown encoding: " + t); | |
t = (t + "").toLowerCase(), | |
n = !0 | |
} | |
} | |
.apply(this, arguments) | |
} | |
, | |
a.prototype.equals = function(t) { | |
if (!a.isBuffer(t)) | |
throw new TypeError("Argument must be a Buffer"); | |
return this === t || 0 === a.compare(this, t) | |
} | |
, | |
a.prototype.inspect = function() { | |
var t = "" | |
, e = r.INSPECT_MAX_BYTES; | |
return 0 < this.length && (t = this.toString("hex", 0, e).match(/.{2}/g).join(" "), | |
this.length > e && (t += " ... ")), | |
"<Buffer " + t + ">" | |
} | |
, | |
a.prototype.compare = function(t, e, r, n, i) { | |
if (!a.isBuffer(t)) | |
throw new TypeError("Argument must be a Buffer"); | |
if (void 0 === e && (e = 0), | |
void 0 === r && (r = t ? t.length : 0), | |
void 0 === n && (n = 0), | |
void 0 === i && (i = this.length), | |
e < 0 || r > t.length || n < 0 || i > this.length) | |
throw new RangeError("out of range index"); | |
if (i <= n && r <= e) | |
return 0; | |
if (i <= n) | |
return -1; | |
if (r <= e) | |
return 1; | |
if (this === t) | |
return 0; | |
for (var o = (i >>>= 0) - (n >>>= 0), s = (r >>>= 0) - (e >>>= 0), u = Math.min(o, s), c = this.slice(n, i), f = t.slice(e, r), l = 0; l < u; ++l) | |
if (c[l] !== f[l]) { | |
o = c[l], | |
s = f[l]; | |
break | |
} | |
return o < s ? -1 : s < o ? 1 : 0 | |
} | |
, | |
a.prototype.includes = function(t, e, r) { | |
return -1 !== this.indexOf(t, e, r) | |
} | |
, | |
a.prototype.indexOf = function(t, e, r) { | |
return y(this, t, e, r, !0) | |
} | |
, | |
a.prototype.lastIndexOf = function(t, e, r) { | |
return y(this, t, e, r, !1) | |
} | |
, | |
a.prototype.write = function(t, e, r, n) { | |
if (void 0 === e) | |
n = "utf8", | |
r = this.length, | |
e = 0; | |
else if (void 0 === r && "string" == typeof e) | |
n = e, | |
r = this.length, | |
e = 0; | |
else { | |
if (!isFinite(e)) | |
throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported"); | |
e >>>= 0, | |
isFinite(r) ? (r >>>= 0, | |
void 0 === n && (n = "utf8")) : (n = r, | |
r = void 0) | |
} | |
var i = this.length - e; | |
if ((void 0 === r || i < r) && (r = i), | |
0 < t.length && (r < 0 || e < 0) || e > this.length) | |
throw new RangeError("Attempt to write outside buffer bounds"); | |
n || (n = "utf8"); | |
for (var o, s, a, u, c, f, l = !1; ; ) | |
switch (n) { | |
case "hex": | |
return g(this, t, e, r); | |
case "utf8": | |
case "utf-8": | |
return c = e, | |
f = r, | |
I(M(t, this.length - c), this, c, f); | |
case "ascii": | |
return v(this, t, e, r); | |
case "latin1": | |
case "binary": | |
return v(this, t, e, r); | |
case "base64": | |
return this, | |
a = e, | |
u = r, | |
I(L(t), this, a, u); | |
case "ucs2": | |
case "ucs-2": | |
case "utf16le": | |
case "utf-16le": | |
return o = e, | |
s = r, | |
I(function(t, e) { | |
for (var r, n, i, o = [], s = 0; s < t.length && !((e -= 2) < 0); ++s) | |
n = (r = t.charCodeAt(s)) >> 8, | |
i = r % 256, | |
o.push(i), | |
o.push(n); | |
return o | |
}(t, this.length - o), this, o, s); | |
default: | |
if (l) | |
throw new TypeError("Unknown encoding: " + n); | |
n = ("" + n).toLowerCase(), | |
l = !0 | |
} | |
} | |
, | |
a.prototype.toJSON = function() { | |
return { | |
type: "Buffer", | |
data: Array.prototype.slice.call(this._arr || this, 0) | |
} | |
} | |
; | |
var _ = 4096; | |
function x(t, e, r) { | |
var n = ""; | |
r = Math.min(t.length, r); | |
for (var i = e; i < r; ++i) | |
n += String.fromCharCode(127 & t[i]); | |
return n | |
} | |
function S(t, e, r) { | |
var n = ""; | |
r = Math.min(t.length, r); | |
for (var i = e; i < r; ++i) | |
n += String.fromCharCode(t[i]); | |
return n | |
} | |
function k(t, e, r) { | |
var n = t.length; | |
(!e || e < 0) && (e = 0), | |
(!r || r < 0 || n < r) && (r = n); | |
for (var i = "", o = e; o < r; ++o) | |
i += R(t[o]); | |
return i | |
} | |
function E(t, e, r) { | |
for (var n = t.slice(e, r), i = "", o = 0; o < n.length; o += 2) | |
i += String.fromCharCode(n[o] + 256 * n[o + 1]); | |
return i | |
} | |
function A(t, e, r) { | |
if (t % 1 != 0 || t < 0) | |
throw new RangeError("offset is not uint"); | |
if (r < t + e) | |
throw new RangeError("Trying to access beyond buffer length") | |
} | |
function C(t, e, r, n, i, o) { | |
if (!a.isBuffer(t)) | |
throw new TypeError('"buffer" argument must be a Buffer instance'); | |
if (i < e || e < o) | |
throw new RangeError('"value" argument is out of bounds'); | |
if (r + n > t.length) | |
throw new RangeError("Index out of range") | |
} | |
function T(t, e, r, n, i, o) { | |
if (r + n > t.length) | |
throw new RangeError("Index out of range"); | |
if (r < 0) | |
throw new RangeError("Index out of range") | |
} | |
function O(t, e, r, n, o) { | |
return e = +e, | |
r >>>= 0, | |
o || T(t, 0, r, 4), | |
i.write(t, e, r, n, 23, 4), | |
r + 4 | |
} | |
function B(t, e, r, n, o) { | |
return e = +e, | |
r >>>= 0, | |
o || T(t, 0, r, 8), | |
i.write(t, e, r, n, 52, 8), | |
r + 8 | |
} | |
a.prototype.slice = function(t, e) { | |
var r = this.length; | |
(t = ~~t) < 0 ? (t += r) < 0 && (t = 0) : r < t && (t = r), | |
(e = void 0 === e ? r : ~~e) < 0 ? (e += r) < 0 && (e = 0) : r < e && (e = r), | |
e < t && (e = t); | |
var n = this.subarray(t, e); | |
return n.__proto__ = a.prototype, | |
n | |
} | |
, | |
a.prototype.readUIntLE = function(t, e, r) { | |
t >>>= 0, | |
e >>>= 0, | |
r || A(t, e, this.length); | |
for (var n = this[t], i = 1, o = 0; ++o < e && (i *= 256); ) | |
n += this[t + o] * i; | |
return n | |
} | |
, | |
a.prototype.readUIntBE = function(t, e, r) { | |
t >>>= 0, | |
e >>>= 0, | |
r || A(t, e, this.length); | |
for (var n = this[t + --e], i = 1; 0 < e && (i *= 256); ) | |
n += this[t + --e] * i; | |
return n | |
} | |
, | |
a.prototype.readUInt8 = function(t, e) { | |
return t >>>= 0, | |
e || A(t, 1, this.length), | |
this[t] | |
} | |
, | |
a.prototype.readUInt16LE = function(t, e) { | |
return t >>>= 0, | |
e || A(t, 2, this.length), | |
this[t] | this[t + 1] << 8 | |
} | |
, | |
a.prototype.readUInt16BE = function(t, e) { | |
return t >>>= 0, | |
e || A(t, 2, this.length), | |
this[t] << 8 | this[t + 1] | |
} | |
, | |
a.prototype.readUInt32LE = function(t, e) { | |
return t >>>= 0, | |
e || A(t, 4, this.length), | |
(this[t] | this[t + 1] << 8 | this[t + 2] << 16) + 16777216 * this[t + 3] | |
} | |
, | |
a.prototype.readUInt32BE = function(t, e) { | |
return t >>>= 0, | |
e || A(t, 4, this.length), | |
16777216 * this[t] + (this[t + 1] << 16 | this[t + 2] << 8 | this[t + 3]) | |
} | |
, | |
a.prototype.readIntLE = function(t, e, r) { | |
t >>>= 0, | |
e >>>= 0, | |
r || A(t, e, this.length); | |
for (var n = this[t], i = 1, o = 0; ++o < e && (i *= 256); ) | |
n += this[t + o] * i; | |
return (i *= 128) <= n && (n -= Math.pow(2, 8 * e)), | |
n | |
} | |
, | |
a.prototype.readIntBE = function(t, e, r) { | |
t >>>= 0, | |
e >>>= 0, | |
r || A(t, e, this.length); | |
for (var n = e, i = 1, o = this[t + --n]; 0 < n && (i *= 256); ) | |
o += this[t + --n] * i; | |
return (i *= 128) <= o && (o -= Math.pow(2, 8 * e)), | |
o | |
} | |
, | |
a.prototype.readInt8 = function(t, e) { | |
return t >>>= 0, | |
e || A(t, 1, this.length), | |
128 & this[t] ? -1 * (255 - this[t] + 1) : this[t] | |
} | |
, | |
a.prototype.readInt16LE = function(t, e) { | |
t >>>= 0, | |
e || A(t, 2, this.length); | |
var r = this[t] | this[t + 1] << 8; | |
return 32768 & r ? 4294901760 | r : r | |
} | |
, | |
a.prototype.readInt16BE = function(t, e) { | |
t >>>= 0, | |
e || A(t, 2, this.length); | |
var r = this[t + 1] | this[t] << 8; | |
return 32768 & r ? 4294901760 | r : r | |
} | |
, | |
a.prototype.readInt32LE = function(t, e) { | |
return t >>>= 0, | |
e || A(t, 4, this.length), | |
this[t] | this[t + 1] << 8 | this[t + 2] << 16 | this[t + 3] << 24 | |
} | |
, | |
a.prototype.readInt32BE = function(t, e) { | |
return t >>>= 0, | |
e || A(t, 4, this.length), | |
this[t] << 24 | this[t + 1] << 16 | this[t + 2] << 8 | this[t + 3] | |
} | |
, | |
a.prototype.readFloatLE = function(t, e) { | |
return t >>>= 0, | |
e || A(t, 4, this.length), | |
i.read(this, t, !0, 23, 4) | |
} | |
, | |
a.prototype.readFloatBE = function(t, e) { | |
return t >>>= 0, | |
e || A(t, 4, this.length), | |
i.read(this, t, !1, 23, 4) | |
} | |
, | |
a.prototype.readDoubleLE = function(t, e) { | |
return t >>>= 0, | |
e || A(t, 8, this.length), | |
i.read(this, t, !0, 52, 8) | |
} | |
, | |
a.prototype.readDoubleBE = function(t, e) { | |
return t >>>= 0, | |
e || A(t, 8, this.length), | |
i.read(this, t, !1, 52, 8) | |
} | |
, | |
a.prototype.writeUIntLE = function(t, e, r, n) { | |
t = +t, | |
e >>>= 0, | |
r >>>= 0, | |
n || C(this, t, e, r, Math.pow(2, 8 * r) - 1, 0); | |
var i = 1 | |
, o = 0; | |
for (this[e] = 255 & t; ++o < r && (i *= 256); ) | |
this[e + o] = t / i & 255; | |
return e + r | |
} | |
, | |
a.prototype.writeUIntBE = function(t, e, r, n) { | |
t = +t, | |
e >>>= 0, | |
r >>>= 0, | |
n || C(this, t, e, r, Math.pow(2, 8 * r) - 1, 0); | |
var i = r - 1 | |
, o = 1; | |
for (this[e + i] = 255 & t; 0 <= --i && (o *= 256); ) | |
this[e + i] = t / o & 255; | |
return e + r | |
} | |
, | |
a.prototype.writeUInt8 = function(t, e, r) { | |
return t = +t, | |
e >>>= 0, | |
r || C(this, t, e, 1, 255, 0), | |
this[e] = 255 & t, | |
e + 1 | |
} | |
, | |
a.prototype.writeUInt16LE = function(t, e, r) { | |
return t = +t, | |
e >>>= 0, | |
r || C(this, t, e, 2, 65535, 0), | |
this[e] = 255 & t, | |
this[e + 1] = t >>> 8, | |
e + 2 | |
} | |
, | |
a.prototype.writeUInt16BE = function(t, e, r) { | |
return t = +t, | |
e >>>= 0, | |
r || C(this, t, e, 2, 65535, 0), | |
this[e] = t >>> 8, | |
this[e + 1] = 255 & t, | |
e + 2 | |
} | |
, | |
a.prototype.writeUInt32LE = function(t, e, r) { | |
return t = +t, | |
e >>>= 0, | |
r || C(this, t, e, 4, 4294967295, 0), | |
this[e + 3] = t >>> 24, | |
this[e + 2] = t >>> 16, | |
this[e + 1] = t >>> 8, | |
this[e] = 255 & t, | |
e + 4 | |
} | |
, | |
a.prototype.writeUInt32BE = function(t, e, r) { | |
return t = +t, | |
e >>>= 0, | |
r || C(this, t, e, 4, 4294967295, 0), | |
this[e] = t >>> 24, | |
this[e + 1] = t >>> 16, | |
this[e + 2] = t >>> 8, | |
this[e + 3] = 255 & t, | |
e + 4 | |
} | |
, | |
a.prototype.writeIntLE = function(t, e, r, n) { | |
if (t = +t, | |
e >>>= 0, | |
!n) { | |
var i = Math.pow(2, 8 * r - 1); | |
C(this, t, e, r, i - 1, -i) | |
} | |
var o = 0 | |
, s = 1 | |
, a = 0; | |
for (this[e] = 255 & t; ++o < r && (s *= 256); ) | |
t < 0 && 0 === a && 0 !== this[e + o - 1] && (a = 1), | |
this[e + o] = (t / s >> 0) - a & 255; | |
return e + r | |
} | |
, | |
a.prototype.writeIntBE = function(t, e, r, n) { | |
if (t = +t, | |
e >>>= 0, | |
!n) { | |
var i = Math.pow(2, 8 * r - 1); | |
C(this, t, e, r, i - 1, -i) | |
} | |
var o = r - 1 | |
, s = 1 | |
, a = 0; | |
for (this[e + o] = 255 & t; 0 <= --o && (s *= 256); ) | |
t < 0 && 0 === a && 0 !== this[e + o + 1] && (a = 1), | |
this[e + o] = (t / s >> 0) - a & 255; | |
return e + r | |
} | |
, | |
a.prototype.writeInt8 = function(t, e, r) { | |
return t = +t, | |
e >>>= 0, | |
r || C(this, t, e, 1, 127, -128), | |
t < 0 && (t = 255 + t + 1), | |
this[e] = 255 & t, | |
e + 1 | |
} | |
, | |
a.prototype.writeInt16LE = function(t, e, r) { | |
return t = +t, | |
e >>>= 0, | |
r || C(this, t, e, 2, 32767, -32768), | |
this[e] = 255 & t, | |
this[e + 1] = t >>> 8, | |
e + 2 | |
} | |
, | |
a.prototype.writeInt16BE = function(t, e, r) { | |
return t = +t, | |
e >>>= 0, | |
r || C(this, t, e, 2, 32767, -32768), | |
this[e] = t >>> 8, | |
this[e + 1] = 255 & t, | |
e + 2 | |
} | |
, | |
a.prototype.writeInt32LE = function(t, e, r) { | |
return t = +t, | |
e >>>= 0, | |
r || C(this, t, e, 4, 2147483647, -2147483648), | |
this[e] = 255 & t, | |
this[e + 1] = t >>> 8, | |
this[e + 2] = t >>> 16, | |
this[e + 3] = t >>> 24, | |
e + 4 | |
} | |
, | |
a.prototype.writeInt32BE = function(t, e, r) { | |
return t = +t, | |
e >>>= 0, | |
r || C(this, t, e, 4, 2147483647, -2147483648), | |
t < 0 && (t = 4294967295 + t + 1), | |
this[e] = t >>> 24, | |
this[e + 1] = t >>> 16, | |
this[e + 2] = t >>> 8, | |
this[e + 3] = 255 & t, | |
e + 4 | |
} | |
, | |
a.prototype.writeFloatLE = function(t, e, r) { | |
return O(this, t, e, !0, r) | |
} | |
, | |
a.prototype.writeFloatBE = function(t, e, r) { | |
return O(this, t, e, !1, r) | |
} | |
, | |
a.prototype.writeDoubleLE = function(t, e, r) { | |
return B(this, t, e, !0, r) | |
} | |
, | |
a.prototype.writeDoubleBE = function(t, e, r) { | |
return B(this, t, e, !1, r) | |
} | |
, | |
a.prototype.copy = function(t, e, r, n) { | |
if (!a.isBuffer(t)) | |
throw new TypeError("argument should be a Buffer"); | |
if (r || (r = 0), | |
n || 0 === n || (n = this.length), | |
e >= t.length && (e = t.length), | |
e || (e = 0), | |
0 < n && n < r && (n = r), | |
n === r) | |
return 0; | |
if (0 === t.length || 0 === this.length) | |
return 0; | |
if (e < 0) | |
throw new RangeError("targetStart out of bounds"); | |
if (r < 0 || r >= this.length) | |
throw new RangeError("Index out of range"); | |
if (n < 0) | |
throw new RangeError("sourceEnd out of bounds"); | |
n > this.length && (n = this.length), | |
t.length - e < n - r && (n = t.length - e + r); | |
var i = n - r; | |
if (this === t && "function" == typeof Uint8Array.prototype.copyWithin) | |
this.copyWithin(e, r, n); | |
else if (this === t && r < e && e < n) | |
for (var o = i - 1; 0 <= o; --o) | |
t[o + e] = this[o + r]; | |
else | |
Uint8Array.prototype.set.call(t, this.subarray(r, n), e); | |
return i | |
} | |
, | |
a.prototype.fill = function(t, e, r, n) { | |
if ("string" == typeof t) { | |
if ("string" == typeof e ? (n = e, | |
e = 0, | |
r = this.length) : "string" == typeof r && (n = r, | |
r = this.length), | |
void 0 !== n && "string" != typeof n) | |
throw new TypeError("encoding must be a string"); | |
if ("string" == typeof n && !a.isEncoding(n)) | |
throw new TypeError("Unknown encoding: " + n); | |
if (1 === t.length) { | |
var i = t.charCodeAt(0); | |
("utf8" === n && i < 128 || "latin1" === n) && (t = i) | |
} | |
} else | |
"number" == typeof t && (t &= 255); | |
if (e < 0 || this.length < e || this.length < r) | |
throw new RangeError("Out of range index"); | |
if (r <= e) | |
return this; | |
var o; | |
if (e >>>= 0, | |
r = void 0 === r ? this.length : r >>> 0, | |
t || (t = 0), | |
"number" == typeof t) | |
for (o = e; o < r; ++o) | |
this[o] = t; | |
else { | |
var s = a.isBuffer(t) ? t : new a(t,n) | |
, u = s.length; | |
if (0 === u) | |
throw new TypeError('The value "' + t + '" is invalid for argument "value"'); | |
for (o = 0; o < r - e; ++o) | |
this[o + e] = s[o % u] | |
} | |
return this | |
} | |
; | |
var j = /[^+\/0-9A-Za-z-_]/g; | |
function R(t) { | |
return t < 16 ? "0" + t.toString(16) : t.toString(16) | |
} | |
function M(t, e) { | |
var r; | |
e = e || 1 / 0; | |
for (var n = t.length, i = null, o = [], s = 0; s < n; ++s) { | |
if (55295 < (r = t.charCodeAt(s)) && r < 57344) { | |
if (!i) { | |
if (56319 < r) { | |
-1 < (e -= 3) && o.push(239, 191, 189); | |
continue | |
} | |
if (s + 1 === n) { | |
-1 < (e -= 3) && o.push(239, 191, 189); | |
continue | |
} | |
i = r; | |
continue | |
} | |
if (r < 56320) { | |
-1 < (e -= 3) && o.push(239, 191, 189), | |
i = r; | |
continue | |
} | |
r = 65536 + (i - 55296 << 10 | r - 56320) | |
} else | |
i && -1 < (e -= 3) && o.push(239, 191, 189); | |
if (i = null, | |
r < 128) { | |
if ((e -= 1) < 0) | |
break; | |
o.push(r) | |
} else if (r < 2048) { | |
if ((e -= 2) < 0) | |
break; | |
o.push(r >> 6 | 192, 63 & r | 128) | |
} else if (r < 65536) { | |
if ((e -= 3) < 0) | |
break; | |
o.push(r >> 12 | 224, r >> 6 & 63 | 128, 63 & r | 128) | |
} else { | |
if (!(r < 1114112)) | |
throw new Error("Invalid code point"); | |
if ((e -= 4) < 0) | |
break; | |
o.push(r >> 18 | 240, r >> 12 & 63 | 128, r >> 6 & 63 | 128, 63 & r | 128) | |
} | |
} | |
return o | |
} | |
function L(t) { | |
return n.toByteArray(function(t) { | |
if ((t = (t = t.split("=")[0]).trim().replace(j, "")).length < 2) | |
return ""; | |
for (; t.length % 4 != 0; ) | |
t += "="; | |
return t | |
}(t)) | |
} | |
function I(t, e, r, n) { | |
for (var i = 0; i < n && !(i + r >= e.length || i >= t.length); ++i) | |
e[i + r] = t[i]; | |
return i | |
} | |
function N(t) { | |
return t instanceof ArrayBuffer || null != t && null != t.constructor && "ArrayBuffer" === t.constructor.name && "number" == typeof t.byteLength | |
} | |
function P(t) { | |
return t != t | |
} | |
} | |
, { | |
"base64-js": 50, | |
ieee754: 93 | |
}], | |
54: [function(t, e, r) { | |
e.exports = { | |
100: "Continue", | |
101: "Switching Protocols", | |
102: "Processing", | |
200: "OK", | |
201: "Created", | |
202: "Accepted", | |
203: "Non-Authoritative Information", | |
204: "No Content", | |
205: "Reset Content", | |
206: "Partial Content", | |
207: "Multi-Status", | |
208: "Already Reported", | |
226: "IM Used", | |
300: "Multiple Choices", | |
301: "Moved Permanently", | |
302: "Found", | |
303: "See Other", | |
304: "Not Modified", | |
305: "Use Proxy", | |
307: "Temporary Redirect", | |
308: "Permanent Redirect", | |
400: "Bad Request", | |
401: "Unauthorized", | |
402: "Payment Required", | |
403: "Forbidden", | |
404: "Not Found", | |
405: "Method Not Allowed", | |
406: "Not Acceptable", | |
407: "Proxy Authentication Required", | |
408: "Request Timeout", | |
409: "Conflict", | |
410: "Gone", | |
411: "Length Required", | |
412: "Precondition Failed", | |
413: "Payload Too Large", | |
414: "URI Too Long", | |
415: "Unsupported Media Type", | |
416: "Range Not Satisfiable", | |
417: "Expectation Failed", | |
418: "I'm a teapot", | |
421: "Misdirected Request", | |
422: "Unprocessable Entity", | |
423: "Locked", | |
424: "Failed Dependency", | |
425: "Unordered Collection", | |
426: "Upgrade Required", | |
428: "Precondition Required", | |
429: "Too Many Requests", | |
431: "Request Header Fields Too Large", | |
451: "Unavailable For Legal Reasons", | |
500: "Internal Server Error", | |
501: "Not Implemented", | |
502: "Bad Gateway", | |
503: "Service Unavailable", | |
504: "Gateway Timeout", | |
505: "HTTP Version Not Supported", | |
506: "Variant Also Negotiates", | |
507: "Insufficient Storage", | |
508: "Loop Detected", | |
509: "Bandwidth Limit Exceeded", | |
510: "Not Extended", | |
511: "Network Authentication Required" | |
} | |
} | |
, {}], | |
55: [function(t, e, r) { | |
!function() { | |
"use strict"; | |
function t(e, r, n, i) { | |
return this instanceof t ? (this.domain = e || void 0, | |
this.path = r || "/", | |
this.secure = !!n, | |
this.script = !!i, | |
this) : new t(e,r,n,i) | |
} | |
function e(t, r, n) { | |
return t instanceof e ? t : this instanceof e ? (this.name = null, | |
this.value = null, | |
this.expiration_date = 1 / 0, | |
this.path = String(n || "/"), | |
this.explicit_path = !1, | |
this.domain = r || null, | |
this.explicit_domain = !1, | |
this.secure = !1, | |
this.noscript = !1, | |
t && this.parse(t, r, n), | |
this) : new e(t,r,n) | |
} | |
t.All = Object.freeze(Object.create(null)), | |
r.CookieAccessInfo = t, | |
(r.Cookie = e).prototype.toString = function() { | |
var t = [this.name + "=" + this.value]; | |
return this.expiration_date !== 1 / 0 && t.push("expires=" + new Date(this.expiration_date).toGMTString()), | |
this.domain && t.push("domain=" + this.domain), | |
this.path && t.push("path=" + this.path), | |
this.secure && t.push("secure"), | |
this.noscript && t.push("httponly"), | |
t.join("; ") | |
} | |
, | |
e.prototype.toValueString = function() { | |
return this.name + "=" + this.value | |
} | |
; | |
var n = /[:](?=\s*[a-zA-Z0-9_\-]+\s*[=])/g; | |
e.prototype.parse = function(t, r, n) { | |
if (this instanceof e) { | |
var i, o = t.split(";").filter(function(t) { | |
return !!t | |
}), s = o[0].match(/([^=]+)=([\s\S]*)/); | |
if (!s) | |
return void console.warn("Invalid cookie header encountered. Header: '" + t + "'"); | |
var a = s[1] | |
, u = s[2]; | |
if ("string" != typeof a || 0 === a.length || "string" != typeof u) | |
return void console.warn("Unable to extract values from cookie header. Cookie: '" + t + "'"); | |
for (this.name = a, | |
this.value = u, | |
i = 1; i < o.length; i += 1) | |
switch (a = (s = o[i].match(/([^=]+)(?:=([\s\S]*))?/))[1].trim().toLowerCase(), | |
u = s[2], | |
a) { | |
case "httponly": | |
this.noscript = !0; | |
break; | |
case "expires": | |
this.expiration_date = u ? Number(Date.parse(u)) : 1 / 0; | |
break; | |
case "path": | |
this.path = u ? u.trim() : "", | |
this.explicit_path = !0; | |
break; | |
case "domain": | |
this.domain = u ? u.trim() : "", | |
this.explicit_domain = !!this.domain; | |
break; | |
case "secure": | |
this.secure = !0 | |
} | |
return this.explicit_path || (this.path = n || "/"), | |
this.explicit_domain || (this.domain = r), | |
this | |
} | |
return (new e).parse(t, r, n) | |
} | |
, | |
e.prototype.matches = function(e) { | |
return e === t.All || !(this.noscript && e.script || this.secure && !e.secure || !this.collidesWith(e)) | |
} | |
, | |
e.prototype.collidesWith = function(t) { | |
if (this.path && !t.path || this.domain && !t.domain) | |
return !1; | |
if (this.path && 0 !== t.path.indexOf(this.path)) | |
return !1; | |
if (this.explicit_path && 0 !== t.path.indexOf(this.path)) | |
return !1; | |
var e = t.domain && t.domain.replace(/^[\.]/, "") | |
, r = this.domain && this.domain.replace(/^[\.]/, ""); | |
if (r === e) | |
return !0; | |
if (r) { | |
if (!this.explicit_domain) | |
return !1; | |
var n = e.indexOf(r); | |
return -1 !== n && n === e.length - r.length | |
} | |
return !0 | |
} | |
, | |
(r.CookieJar = function t() { | |
var r, n; | |
return this instanceof t ? (r = Object.create(null), | |
this.setCookie = function(t, i, o) { | |
var s, a; | |
if (s = (t = new e(t,i,o)).expiration_date <= Date.now(), | |
void 0 !== r[t.name]) { | |
for (n = r[t.name], | |
a = 0; a < n.length; a += 1) | |
if (n[a].collidesWith(t)) | |
return s ? (n.splice(a, 1), | |
0 === n.length && delete r[t.name], | |
!1) : n[a] = t; | |
return !s && (n.push(t), | |
t) | |
} | |
return !s && (r[t.name] = [t], | |
r[t.name]) | |
} | |
, | |
this.getCookie = function(t, e) { | |
var i, o; | |
if (n = r[t]) | |
for (o = 0; o < n.length; o += 1) | |
if ((i = n[o]).expiration_date <= Date.now()) | |
0 === n.length && delete r[i.name]; | |
else if (i.matches(e)) | |
return i | |
} | |
, | |
this.getCookies = function(t) { | |
var e, n, i = []; | |
for (e in r) | |
(n = this.getCookie(e, t)) && i.push(n); | |
return i.toString = function() { | |
return i.join(":") | |
} | |
, | |
i.toValueString = function() { | |
return i.map(function(t) { | |
return t.toValueString() | |
}).join(";") | |
} | |
, | |
i | |
} | |
, | |
this) : new t | |
} | |
).prototype.setCookies = function(t, r, i) { | |
var o, s, a = []; | |
for (t = (t = Array.isArray(t) ? t : t.split(n)).map(function(t) { | |
return new e(t,r,i) | |
}), | |
o = 0; o < t.length; o += 1) | |
s = t[o], | |
this.setCookie(s, r, i) && a.push(s); | |
return a | |
} | |
}() | |
} | |
, {}], | |
56: [function(t, e, r) { | |
(function(t) { | |
function e(t) { | |
return Object.prototype.toString.call(t) | |
} | |
r.isArray = function(t) { | |
return Array.isArray ? Array.isArray(t) : "[object Array]" === e(t) | |
} | |
, | |
r.isBoolean = function(t) { | |
return "boolean" == typeof t | |
} | |
, | |
r.isNull = function(t) { | |
return null === t | |
} | |
, | |
r.isNullOrUndefined = function(t) { | |
return null == t | |
} | |
, | |
r.isNumber = function(t) { | |
return "number" == typeof t | |
} | |
, | |
r.isString = function(t) { | |
return "string" == typeof t | |
} | |
, | |
r.isSymbol = function(t) { | |
return "symbol" == typeof t | |
} | |
, | |
r.isUndefined = function(t) { | |
return void 0 === t | |
} | |
, | |
r.isRegExp = function(t) { | |
return "[object RegExp]" === e(t) | |
} | |
, | |
r.isObject = function(t) { | |
return "object" == typeof t && null !== t | |
} | |
, | |
r.isDate = function(t) { | |
return "[object Date]" === e(t) | |
} | |
, | |
r.isError = function(t) { | |
return "[object Error]" === e(t) || t instanceof Error | |
} | |
, | |
r.isFunction = function(t) { | |
return "function" == typeof t | |
} | |
, | |
r.isPrimitive = function(t) { | |
return null === t || "boolean" == typeof t || "number" == typeof t || "string" == typeof t || "symbol" == typeof t || void 0 === t | |
} | |
, | |
r.isBuffer = t.isBuffer | |
} | |
).call(this, { | |
isBuffer: t("../../is-buffer/index.js") | |
}) | |
} | |
, { | |
"../../is-buffer/index.js": 95 | |
}], | |
57: [function(t, e, r) { | |
var n; | |
n = function(t) { | |
return function() { | |
var e = t | |
, r = e.lib.BlockCipher | |
, n = e.algo | |
, i = [] | |
, o = [] | |
, s = [] | |
, a = [] | |
, u = [] | |
, c = [] | |
, f = [] | |
, l = [] | |
, h = [] | |
, p = []; | |
!function() { | |
for (var t = [], e = 0; e < 256; e++) | |
t[e] = e < 128 ? e << 1 : e << 1 ^ 283; | |
var r = 0 | |
, n = 0; | |
for (e = 0; e < 256; e++) { | |
var d = n ^ n << 1 ^ n << 2 ^ n << 3 ^ n << 4; | |
d = d >>> 8 ^ 255 & d ^ 99, | |
i[r] = d; | |
var y = t[o[d] = r] | |
, m = t[y] | |
, g = t[m] | |
, v = 257 * t[d] ^ 16843008 * d; | |
s[r] = v << 24 | v >>> 8, | |
a[r] = v << 16 | v >>> 16, | |
u[r] = v << 8 | v >>> 24, | |
c[r] = v, | |
v = 16843009 * g ^ 65537 * m ^ 257 * y ^ 16843008 * r, | |
f[d] = v << 24 | v >>> 8, | |
l[d] = v << 16 | v >>> 16, | |
h[d] = v << 8 | v >>> 24, | |
p[d] = v, | |
r ? (r = y ^ t[t[t[g ^ y]]], | |
n ^= t[t[n]]) : r = n = 1 | |
} | |
}(); | |
var d = [0, 1, 2, 4, 8, 16, 32, 64, 128, 27, 54] | |
, y = n.AES = r.extend({ | |
_doReset: function() { | |
if (!this._nRounds || this._keyPriorReset !== this._key) { | |
for (var t = this._keyPriorReset = this._key, e = t.words, r = t.sigBytes / 4, n = 4 * ((this._nRounds = r + 6) + 1), o = this._keySchedule = [], s = 0; s < n; s++) | |
if (s < r) | |
o[s] = e[s]; | |
else { | |
var a = o[s - 1]; | |
s % r ? 6 < r && s % r == 4 && (a = i[a >>> 24] << 24 | i[a >>> 16 & 255] << 16 | i[a >>> 8 & 255] << 8 | i[255 & a]) : (a = i[(a = a << 8 | a >>> 24) >>> 24] << 24 | i[a >>> 16 & 255] << 16 | i[a >>> 8 & 255] << 8 | i[255 & a], | |
a ^= d[s / r | 0] << 24), | |
o[s] = o[s - r] ^ a | |
} | |
for (var u = this._invKeySchedule = [], c = 0; c < n; c++) | |
s = n - c, | |
a = c % 4 ? o[s] : o[s - 4], | |
u[c] = c < 4 || s <= 4 ? a : f[i[a >>> 24]] ^ l[i[a >>> 16 & 255]] ^ h[i[a >>> 8 & 255]] ^ p[i[255 & a]] | |
} | |
}, | |
encryptBlock: function(t, e) { | |
this._doCryptBlock(t, e, this._keySchedule, s, a, u, c, i) | |
}, | |
decryptBlock: function(t, e) { | |
var r = t[e + 1]; | |
t[e + 1] = t[e + 3], | |
t[e + 3] = r, | |
this._doCryptBlock(t, e, this._invKeySchedule, f, l, h, p, o), | |
r = t[e + 1], | |
t[e + 1] = t[e + 3], | |
t[e + 3] = r | |
}, | |
_doCryptBlock: function(t, e, r, n, i, o, s, a) { | |
for (var u = this._nRounds, c = t[e] ^ r[0], f = t[e + 1] ^ r[1], l = t[e + 2] ^ r[2], h = t[e + 3] ^ r[3], p = 4, d = 1; d < u; d++) { | |
var y = n[c >>> 24] ^ i[f >>> 16 & 255] ^ o[l >>> 8 & 255] ^ s[255 & h] ^ r[p++] | |
, m = n[f >>> 24] ^ i[l >>> 16 & 255] ^ o[h >>> 8 & 255] ^ s[255 & c] ^ r[p++] | |
, g = n[l >>> 24] ^ i[h >>> 16 & 255] ^ o[c >>> 8 & 255] ^ s[255 & f] ^ r[p++] | |
, v = n[h >>> 24] ^ i[c >>> 16 & 255] ^ o[f >>> 8 & 255] ^ s[255 & l] ^ r[p++]; | |
c = y, | |
f = m, | |
l = g, | |
h = v | |
} | |
y = (a[c >>> 24] << 24 | a[f >>> 16 & 255] << 16 | a[l >>> 8 & 255] << 8 | a[255 & h]) ^ r[p++], | |
m = (a[f >>> 24] << 24 | a[l >>> 16 & 255] << 16 | a[h >>> 8 & 255] << 8 | a[255 & c]) ^ r[p++], | |
g = (a[l >>> 24] << 24 | a[h >>> 16 & 255] << 16 | a[c >>> 8 & 255] << 8 | a[255 & f]) ^ r[p++], | |
v = (a[h >>> 24] << 24 | a[c >>> 16 & 255] << 16 | a[f >>> 8 & 255] << 8 | a[255 & l]) ^ r[p++], | |
t[e] = y, | |
t[e + 1] = m, | |
t[e + 2] = g, | |
t[e + 3] = v | |
}, | |
keySize: 8 | |
}); | |
e.AES = r._createHelper(y) | |
}(), | |
t.AES | |
} | |
, | |
"object" == typeof r ? e.exports = r = n(t("./core"), t("./enc-base64"), t("./md5"), t("./evpkdf"), t("./cipher-core")) : "function" == typeof define && define.amd ? define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], n) : n(this.CryptoJS) | |
} | |
, { | |
"./cipher-core": 58, | |
"./core": 59, | |
"./enc-base64": 60, | |
"./evpkdf": 62, | |
"./md5": 67 | |
}], | |
58: [function(t, e, r) { | |
var n; | |
n = function(t) { | |
var e, r, n, i, o, s, a, u, c, f, l, h, p, d, y, m, g, v; | |
t.lib.Cipher || (n = (r = (e = t).lib).Base, | |
i = r.WordArray, | |
o = r.BufferedBlockAlgorithm, | |
(s = e.enc).Utf8, | |
a = s.Base64, | |
u = e.algo.EvpKDF, | |
c = r.Cipher = o.extend({ | |
cfg: n.extend(), | |
createEncryptor: function(t, e) { | |
return this.create(this._ENC_XFORM_MODE, t, e) | |
}, | |
createDecryptor: function(t, e) { | |
return this.create(this._DEC_XFORM_MODE, t, e) | |
}, | |
init: function(t, e, r) { | |
this.cfg = this.cfg.extend(r), | |
this._xformMode = t, | |
this._key = e, | |
this.reset() | |
}, | |
reset: function() { | |
o.reset.call(this), | |
this._doReset() | |
}, | |
process: function(t) { | |
return this._append(t), | |
this._process() | |
}, | |
finalize: function(t) { | |
return t && this._append(t), | |
this._doFinalize() | |
}, | |
keySize: 4, | |
ivSize: 4, | |
_ENC_XFORM_MODE: 1, | |
_DEC_XFORM_MODE: 2, | |
_createHelper: function() { | |
function t(t) { | |
return "string" == typeof t ? v : m | |
} | |
return function(e) { | |
return { | |
encrypt: function(r, n, i) { | |
return t(n).encrypt(e, r, n, i) | |
}, | |
decrypt: function(r, n, i) { | |
return t(n).decrypt(e, r, n, i) | |
} | |
} | |
} | |
}() | |
}), | |
r.StreamCipher = c.extend({ | |
_doFinalize: function() { | |
return this._process(!0) | |
}, | |
blockSize: 1 | |
}), | |
f = e.mode = {}, | |
l = r.BlockCipherMode = n.extend({ | |
createEncryptor: function(t, e) { | |
return this.Encryptor.create(t, e) | |
}, | |
createDecryptor: function(t, e) { | |
return this.Decryptor.create(t, e) | |
}, | |
init: function(t, e) { | |
this._cipher = t, | |
this._iv = e | |
} | |
}), | |
h = f.CBC = function() { | |
var t = l.extend(); | |
function e(t, e, r) { | |
var n = this._iv; | |
if (n) { | |
var i = n; | |
this._iv = void 0 | |
} else | |
i = this._prevBlock; | |
for (var o = 0; o < r; o++) | |
t[e + o] ^= i[o] | |
} | |
return t.Encryptor = t.extend({ | |
processBlock: function(t, r) { | |
var n = this._cipher | |
, i = n.blockSize; | |
e.call(this, t, r, i), | |
n.encryptBlock(t, r), | |
this._prevBlock = t.slice(r, r + i) | |
} | |
}), | |
t.Decryptor = t.extend({ | |
processBlock: function(t, r) { | |
var n = this._cipher | |
, i = n.blockSize | |
, o = t.slice(r, r + i); | |
n.decryptBlock(t, r), | |
e.call(this, t, r, i), | |
this._prevBlock = o | |
} | |
}), | |
t | |
}(), | |
p = (e.pad = {}).Pkcs7 = { | |
pad: function(t, e) { | |
for (var r = 4 * e, n = r - t.sigBytes % r, o = n << 24 | n << 16 | n << 8 | n, s = [], a = 0; a < n; a += 4) | |
s.push(o); | |
var u = i.create(s, n); | |
t.concat(u) | |
}, | |
unpad: function(t) { | |
var e = 255 & t.words[t.sigBytes - 1 >>> 2]; | |
t.sigBytes -= e | |
} | |
}, | |
r.BlockCipher = c.extend({ | |
cfg: c.cfg.extend({ | |
mode: h, | |
padding: p | |
}), | |
reset: function() { | |
c.reset.call(this); | |
var t = this.cfg | |
, e = t.iv | |
, r = t.mode; | |
if (this._xformMode == this._ENC_XFORM_MODE) | |
var n = r.createEncryptor; | |
else | |
n = r.createDecryptor, | |
this._minBufferSize = 1; | |
this._mode = n.call(r, this, e && e.words) | |
}, | |
_doProcessBlock: function(t, e) { | |
this._mode.processBlock(t, e) | |
}, | |
_doFinalize: function() { | |
var t = this.cfg.padding; | |
if (this._xformMode == this._ENC_XFORM_MODE) { | |
t.pad(this._data, this.blockSize); | |
var e = this._process(!0) | |
} else | |
e = this._process(!0), | |
t.unpad(e); | |
return e | |
}, | |
blockSize: 4 | |
}), | |
d = r.CipherParams = n.extend({ | |
init: function(t) { | |
this.mixIn(t) | |
}, | |
toString: function(t) { | |
return (t || this.formatter).stringify(this) | |
} | |
}), | |
y = (e.format = {}).OpenSSL = { | |
stringify: function(t) { | |
var e = t.ciphertext | |
, r = t.salt; | |
if (r) | |
var n = i.create([1398893684, 1701076831]).concat(r).concat(e); | |
else | |
n = e; | |
return n.toString(a) | |
}, | |
parse: function(t) { | |
var e = a.parse(t) | |
, r = e.words; | |
if (1398893684 == r[0] && 1701076831 == r[1]) { | |
var n = i.create(r.slice(2, 4)); | |
r.splice(0, 4), | |
e.sigBytes -= 16 | |
} | |
return d.create({ | |
ciphertext: e, | |
salt: n | |
}) | |
} | |
}, | |
m = r.SerializableCipher = n.extend({ | |
cfg: n.extend({ | |
format: y | |
}), | |
encrypt: function(t, e, r, n) { | |
n = this.cfg.extend(n); | |
var i = t.createEncryptor(r, n) | |
, o = i.finalize(e) | |
, s = i.cfg; | |
return d.create({ | |
ciphertext: o, | |
key: r, | |
iv: s.iv, | |
algorithm: t, | |
mode: s.mode, | |
padding: s.padding, | |
blockSize: t.blockSize, | |
formatter: n.format | |
}) | |
}, | |
decrypt: function(t, e, r, n) { | |
return n = this.cfg.extend(n), | |
e = this._parse(e, n.format), | |
t.createDecryptor(r, n).finalize(e.ciphertext) | |
}, | |
_parse: function(t, e) { | |
return "string" == typeof t ? e.parse(t, this) : t | |
} | |
}), | |
g = (e.kdf = {}).OpenSSL = { | |
execute: function(t, e, r, n) { | |
n || (n = i.random(8)); | |
var o = u.create({ | |
keySize: e + r | |
}).compute(t, n) | |
, s = i.create(o.words.slice(e), 4 * r); | |
return o.sigBytes = 4 * e, | |
d.create({ | |
key: o, | |
iv: s, | |
salt: n | |
}) | |
} | |
}, | |
v = r.PasswordBasedCipher = m.extend({ | |
cfg: m.cfg.extend({ | |
kdf: g | |
}), | |
encrypt: function(t, e, r, n) { | |
var i = (n = this.cfg.extend(n)).kdf.execute(r, t.keySize, t.ivSize); | |
n.iv = i.iv; | |
var o = m.encrypt.call(this, t, e, i.key, n); | |
return o.mixIn(i), | |
o | |
}, | |
decrypt: function(t, e, r, n) { | |
n = this.cfg.extend(n), | |
e = this._parse(e, n.format); | |
var i = n.kdf.execute(r, t.keySize, t.ivSize, e.salt); | |
return n.iv = i.iv, | |
m.decrypt.call(this, t, e, i.key, n) | |
} | |
})) | |
} | |
, | |
"object" == typeof r ? e.exports = r = n(t("./core")) : "function" == typeof define && define.amd ? define(["./core"], n) : n(this.CryptoJS) | |
} | |
, { | |
"./core": 59 | |
}], | |
59: [function(t, e, r) { | |
var n; | |
n = function() { | |
var t, e, r, n, i, o, s, a, u, c, f, l, h = h || (t = Math, | |
e = Object.create || function() { | |
function t() {} | |
return function(e) { | |
var r; | |
return t.prototype = e, | |
r = new t, | |
t.prototype = null, | |
r | |
} | |
}(), | |
n = (r = {}).lib = {}, | |
i = n.Base = { | |
extend: function(t) { | |
var r = e(this); | |
return t && r.mixIn(t), | |
r.hasOwnProperty("init") && this.init !== r.init || (r.init = function() { | |
r.$super.init.apply(this, arguments) | |
} | |
), | |
(r.init.prototype = r).$super = this, | |
r | |
}, | |
create: function() { | |
var t = this.extend(); | |
return t.init.apply(t, arguments), | |
t | |
}, | |
init: function() {}, | |
mixIn: function(t) { | |
for (var e in t) | |
t.hasOwnProperty(e) && (this[e] = t[e]); | |
t.hasOwnProperty("toString") && (this.toString = t.toString) | |
}, | |
clone: function() { | |
return this.init.prototype.extend(this) | |
} | |
}, | |
o = n.WordArray = i.extend({ | |
init: function(t, e) { | |
t = this.words = t || [], | |
this.sigBytes = null != e ? e : 4 * t.length | |
}, | |
toString: function(t) { | |
return (t || a).stringify(this) | |
}, | |
concat: function(t) { | |
var e = this.words | |
, r = t.words | |
, n = this.sigBytes | |
, i = t.sigBytes; | |
if (this.clamp(), | |
n % 4) | |
for (var o = 0; o < i; o++) { | |
var s = r[o >>> 2] >>> 24 - o % 4 * 8 & 255; | |
e[n + o >>> 2] |= s << 24 - (n + o) % 4 * 8 | |
} | |
else | |
for (o = 0; o < i; o += 4) | |
e[n + o >>> 2] = r[o >>> 2]; | |
return this.sigBytes += i, | |
this | |
}, | |
clamp: function() { | |
var e = this.words | |
, r = this.sigBytes; | |
e[r >>> 2] &= 4294967295 << 32 - r % 4 * 8, | |
e.length = t.ceil(r / 4) | |
}, | |
clone: function() { | |
var t = i.clone.call(this); | |
return t.words = this.words.slice(0), | |
t | |
}, | |
random: function(e) { | |
for (var r, n = [], i = function(e) { | |
e = e; | |
var r = 987654321 | |
, n = 4294967295; | |
return function() { | |
var i = ((r = 36969 * (65535 & r) + (r >> 16) & n) << 16) + (e = 18e3 * (65535 & e) + (e >> 16) & n) & n; | |
return i /= 4294967296, | |
(i += .5) * (.5 < t.random() ? 1 : -1) | |
} | |
}, s = 0; s < e; s += 4) { | |
var a = i(4294967296 * (r || t.random())); | |
r = 987654071 * a(), | |
n.push(4294967296 * a() | 0) | |
} | |
return new o.init(n,e) | |
} | |
}), | |
s = r.enc = {}, | |
a = s.Hex = { | |
stringify: function(t) { | |
for (var e = t.words, r = t.sigBytes, n = [], i = 0; i < r; i++) { | |
var o = e[i >>> 2] >>> 24 - i % 4 * 8 & 255; | |
n.push((o >>> 4).toString(16)), | |
n.push((15 & o).toString(16)) | |
} | |
return n.join("") | |
}, | |
parse: function(t) { | |
for (var e = t.length, r = [], n = 0; n < e; n += 2) | |
r[n >>> 3] |= parseInt(t.substr(n, 2), 16) << 24 - n % 8 * 4; | |
return new o.init(r,e / 2) | |
} | |
}, | |
u = s.Latin1 = { | |
stringify: function(t) { | |
for (var e = t.words, r = t.sigBytes, n = [], i = 0; i < r; i++) { | |
var o = e[i >>> 2] >>> 24 - i % 4 * 8 & 255; | |
n.push(String.fromCharCode(o)) | |
} | |
return n.join("") | |
}, | |
parse: function(t) { | |
for (var e = t.length, r = [], n = 0; n < e; n++) | |
r[n >>> 2] |= (255 & t.charCodeAt(n)) << 24 - n % 4 * 8; | |
return new o.init(r,e) | |
} | |
}, | |
c = s.Utf8 = { | |
stringify: function(t) { | |
try { | |
return decodeURIComponent(escape(u.stringify(t))) | |
} catch (t) { | |
throw new Error("Malformed UTF-8 data") | |
} | |
}, | |
parse: function(t) { | |
return u.parse(unescape(encodeURIComponent(t))) | |
} | |
}, | |
f = n.BufferedBlockAlgorithm = i.extend({ | |
reset: function() { | |
this._data = new o.init, | |
this._nDataBytes = 0 | |
}, | |
_append: function(t) { | |
"string" == typeof t && (t = c.parse(t)), | |
this._data.concat(t), | |
this._nDataBytes += t.sigBytes | |
}, | |
_process: function(e) { | |
var r = this._data | |
, n = r.words | |
, i = r.sigBytes | |
, s = this.blockSize | |
, a = i / (4 * s) | |
, u = (a = e ? t.ceil(a) : t.max((0 | a) - this._minBufferSize, 0)) * s | |
, c = t.min(4 * u, i); | |
if (u) { | |
for (var f = 0; f < u; f += s) | |
this._doProcessBlock(n, f); | |
var l = n.splice(0, u); | |
r.sigBytes -= c | |
} | |
return new o.init(l,c) | |
}, | |
clone: function() { | |
var t = i.clone.call(this); | |
return t._data = this._data.clone(), | |
t | |
}, | |
_minBufferSize: 0 | |
}), | |
n.Hasher = f.extend({ | |
cfg: i.extend(), | |
init: function(t) { | |
this.cfg = this.cfg.extend(t), | |
this.reset() | |
}, | |
reset: function() { | |
f.reset.call(this), | |
this._doReset() | |
}, | |
update: function(t) { | |
return this._append(t), | |
this._process(), | |
this | |
}, | |
finalize: function(t) { | |
return t && this._append(t), | |
this._doFinalize() | |
}, | |
blockSize: 16, | |
_createHelper: function(t) { | |
return function(e, r) { | |
return new t.init(r).finalize(e) | |
} | |
}, | |
_createHmacHelper: function(t) { | |
return function(e, r) { | |
return new l.HMAC.init(t,r).finalize(e) | |
} | |
} | |
}), | |
l = r.algo = {}, | |
r); | |
return h | |
} | |
, | |
"object" == typeof r ? e.exports = r = n() : "function" == typeof define && define.amd ? define([], n) : this.CryptoJS = n() | |
} | |
, {}], | |
60: [function(t, e, r) { | |
var n; | |
n = function(t) { | |
var e, r; | |
return r = (e = t).lib.WordArray, | |
e.enc.Base64 = { | |
stringify: function(t) { | |
var e = t.words | |
, r = t.sigBytes | |
, n = this._map; | |
t.clamp(); | |
for (var i = [], o = 0; o < r; o += 3) | |
for (var s = (e[o >>> 2] >>> 24 - o % 4 * 8 & 255) << 16 | (e[o + 1 >>> 2] >>> 24 - (o + 1) % 4 * 8 & 255) << 8 | e[o + 2 >>> 2] >>> 24 - (o + 2) % 4 * 8 & 255, a = 0; a < 4 && o + .75 * a < r; a++) | |
i.push(n.charAt(s >>> 6 * (3 - a) & 63)); | |
var u = n.charAt(64); | |
if (u) | |
for (; i.length % 4; ) | |
i.push(u); | |
return i.join("") | |
}, | |
parse: function(t) { | |
var e = t.length | |
, n = this._map | |
, i = this._reverseMap; | |
if (!i) { | |
i = this._reverseMap = []; | |
for (var o = 0; o < n.length; o++) | |
i[n.charCodeAt(o)] = o | |
} | |
var s = n.charAt(64); | |
if (s) { | |
var a = t.indexOf(s); | |
-1 !== a && (e = a) | |
} | |
return function(t, e, n) { | |
for (var i = [], o = 0, s = 0; s < e; s++) | |
if (s % 4) { | |
var a = n[t.charCodeAt(s - 1)] << s % 4 * 2 | |
, u = n[t.charCodeAt(s)] >>> 6 - s % 4 * 2; | |
i[o >>> 2] |= (a | u) << 24 - o % 4 * 8, | |
o++ | |
} | |
return r.create(i, o) | |
}(t, e, i) | |
}, | |
_map: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=" | |
}, | |
t.enc.Base64 | |
} | |
, | |
"object" == typeof r ? e.exports = r = n(t("./core")) : "function" == typeof define && define.amd ? define(["./core"], n) : n(this.CryptoJS) | |
} | |
, { | |
"./core": 59 | |
}], | |
61: [function(t, e, r) { | |
var n; | |
n = function(t) { | |
return function() { | |
var e = t | |
, r = e.lib.WordArray | |
, n = e.enc; | |
function i(t) { | |
return t << 8 & 4278255360 | t >>> 8 & 16711935 | |
} | |
n.Utf16 = n.Utf16BE = { | |
stringify: function(t) { | |
for (var e = t.words, r = t.sigBytes, n = [], i = 0; i < r; i += 2) { | |
var o = e[i >>> 2] >>> 16 - i % 4 * 8 & 65535; | |
n.push(String.fromCharCode(o)) | |
} | |
return n.join("") | |
}, | |
parse: function(t) { | |
for (var e = t.length, n = [], i = 0; i < e; i++) | |
n[i >>> 1] |= t.charCodeAt(i) << 16 - i % 2 * 16; | |
return r.create(n, 2 * e) | |
} | |
}, | |
n.Utf16LE = { | |
stringify: function(t) { | |
for (var e = t.words, r = t.sigBytes, n = [], o = 0; o < r; o += 2) { | |
var s = i(e[o >>> 2] >>> 16 - o % 4 * 8 & 65535); | |
n.push(String.fromCharCode(s)) | |
} | |
return n.join("") | |
}, | |
parse: function(t) { | |
for (var e = t.length, n = [], o = 0; o < e; o++) | |
n[o >>> 1] |= i(t.charCodeAt(o) << 16 - o % 2 * 16); | |
return r.create(n, 2 * e) | |
} | |
} | |
}(), | |
t.enc.Utf16 | |
} | |
, | |
"object" == typeof r ? e.exports = r = n(t("./core")) : "function" == typeof define && define.amd ? define(["./core"], n) : n(this.CryptoJS) | |
} | |
, { | |
"./core": 59 | |
}], | |
62: [function(t, e, r) { | |
var n; | |
n = function(t) { | |
var e, r, n, i, o, s, a; | |
return n = (r = (e = t).lib).Base, | |
i = r.WordArray, | |
s = (o = e.algo).MD5, | |
a = o.EvpKDF = n.extend({ | |
cfg: n.extend({ | |
keySize: 4, | |
hasher: s, | |
iterations: 1 | |
}), | |
init: function(t) { | |
this.cfg = this.cfg.extend(t) | |
}, | |
compute: function(t, e) { | |
for (var r = this.cfg, n = r.hasher.create(), o = i.create(), s = o.words, a = r.keySize, u = r.iterations; s.length < a; ) { | |
c && n.update(c); | |
var c = n.update(t).finalize(e); | |
n.reset(); | |
for (var f = 1; f < u; f++) | |
c = n.finalize(c), | |
n.reset(); | |
o.concat(c) | |
} | |
return o.sigBytes = 4 * a, | |
o | |
} | |
}), | |
e.EvpKDF = function(t, e, r) { | |
return a.create(r).compute(t, e) | |
} | |
, | |
t.EvpKDF | |
} | |
, | |
"object" == typeof r ? e.exports = r = n(t("./core"), t("./sha1"), t("./hmac")) : "function" == typeof define && define.amd ? define(["./core", "./sha1", "./hmac"], n) : n(this.CryptoJS) | |
} | |
, { | |
"./core": 59, | |
"./hmac": 64, | |
"./sha1": 83 | |
}], | |
63: [function(t, e, r) { | |
var n; | |
n = function(t) { | |
var e, r, n; | |
return r = (e = t).lib.CipherParams, | |
n = e.enc.Hex, | |
e.format.Hex = { | |
stringify: function(t) { | |
return t.ciphertext.toString(n) | |
}, | |
parse: function(t) { | |
var e = n.parse(t); | |
return r.create({ | |
ciphertext: e | |
}) | |
} | |
}, | |
t.format.Hex | |
} | |
, | |
"object" == typeof r ? e.exports = r = n(t("./core"), t("./cipher-core")) : "function" == typeof define && define.amd ? define(["./core", "./cipher-core"], n) : n(this.CryptoJS) | |
} | |
, { | |
"./cipher-core": 58, | |
"./core": 59 | |
}], | |
64: [function(t, e, r) { | |
var n; | |
n = function(t) { | |
var e, r, n; | |
r = (e = t).lib.Base, | |
n = e.enc.Utf8, | |
e.algo.HMAC = r.extend({ | |
init: function(t, e) { | |
t = this._hasher = new t.init, | |
"string" == typeof e && (e = n.parse(e)); | |
var r = t.blockSize | |
, i = 4 * r; | |
e.sigBytes > i && (e = t.finalize(e)), | |
e.clamp(); | |
for (var o = this._oKey = e.clone(), s = this._iKey = e.clone(), a = o.words, u = s.words, c = 0; c < r; c++) | |
a[c] ^= 1549556828, | |
u[c] ^= 909522486; | |
o.sigBytes = s.sigBytes = i, | |
this.reset() | |
}, | |
reset: function() { | |
var t = this._hasher; | |
t.reset(), | |
t.update(this._iKey) | |
}, | |
update: function(t) { | |
return this._hasher.update(t), | |
this | |
}, | |
finalize: function(t) { | |
var e = this._hasher | |
, r = e.finalize(t); | |
return e.reset(), | |
e.finalize(this._oKey.clone().concat(r)) | |
} | |
}) | |
} | |
, | |
"object" == typeof r ? e.exports = r = n(t("./core")) : "function" == typeof define && define.amd ? define(["./core"], n) : n(this.CryptoJS) | |
} | |
, { | |
"./core": 59 | |
}], | |
65: [function(t, e, r) { | |
var n; | |
n = function(t) { | |
return t | |
} | |
, | |
"object" == typeof r ? e.exports = r = n(t("./core"), t("./x64-core"), t("./lib-typedarrays"), t("./enc-utf16"), t("./enc-base64"), t("./md5"), t("./sha1"), t("./sha256"), t("./sha224"), t("./sha512"), t("./sha384"), t("./sha3"), t("./ripemd160"), t("./hmac"), t("./pbkdf2"), t("./evpkdf"), t("./cipher-core"), t("./mode-cfb"), t("./mode-ctr"), t("./mode-ctr-gladman"), t("./mode-ofb"), t("./mode-ecb"), t("./pad-ansix923"), t("./pad-iso10126"), t("./pad-iso97971"), t("./pad-zeropadding"), t("./pad-nopadding"), t("./format-hex"), t("./aes"), t("./tripledes"), t("./rc4"), t("./rabbit"), t("./rabbit-legacy")) : "function" == typeof define && define.amd ? define(["./core", "./x64-core", "./lib-typedarrays", "./enc-utf16", "./enc-base64", "./md5", "./sha1", "./sha256", "./sha224", "./sha512", "./sha384", "./sha3", "./ripemd160", "./hmac", "./pbkdf2", "./evpkdf", "./cipher-core", "./mode-cfb", "./mode-ctr", "./mode-ctr-gladman", "./mode-ofb", "./mode-ecb", "./pad-ansix923", "./pad-iso10126", "./pad-iso97971", "./pad-zeropadding", "./pad-nopadding", "./format-hex", "./aes", "./tripledes", "./rc4", "./rabbit", "./rabbit-legacy"], n) : this.CryptoJS = n(this.CryptoJS) | |
} | |
, { | |
"./aes": 57, | |
"./cipher-core": 58, | |
"./core": 59, | |
"./enc-base64": 60, | |
"./enc-utf16": 61, | |
"./evpkdf": 62, | |
"./format-hex": 63, | |
"./hmac": 64, | |
"./lib-typedarrays": 66, | |
"./md5": 67, | |
"./mode-cfb": 68, | |
"./mode-ctr": 70, | |
"./mode-ctr-gladman": 69, | |
"./mode-ecb": 71, | |
"./mode-ofb": 72, | |
"./pad-ansix923": 73, | |
"./pad-iso10126": 74, | |
"./pad-iso97971": 75, | |
"./pad-nopadding": 76, | |
"./pad-zeropadding": 77, | |
"./pbkdf2": 78, | |
"./rabbit": 80, | |
"./rabbit-legacy": 79, | |
"./rc4": 81, | |
"./ripemd160": 82, | |
"./sha1": 83, | |
"./sha224": 84, | |
"./sha256": 85, | |
"./sha3": 86, | |
"./sha384": 87, | |
"./sha512": 88, | |
"./tripledes": 89, | |
"./x64-core": 90 | |
}], | |
66: [function(t, e, r) { | |
var n; | |
n = function(t) { | |
return function() { | |
if ("function" == typeof ArrayBuffer) { | |
var e = t.lib.WordArray | |
, r = e.init; | |
(e.init = function(t) { | |
if (t instanceof ArrayBuffer && (t = new Uint8Array(t)), | |
(t instanceof Int8Array || "undefined" != typeof Uint8ClampedArray && t instanceof Uint8ClampedArray || t instanceof Int16Array || t instanceof Uint16Array || t instanceof Int32Array || t instanceof Uint32Array || t instanceof Float32Array || t instanceof Float64Array) && (t = new Uint8Array(t.buffer,t.byteOffset,t.byteLength)), | |
t instanceof Uint8Array) { | |
for (var e = t.byteLength, n = [], i = 0; i < e; i++) | |
n[i >>> 2] |= t[i] << 24 - i % 4 * 8; | |
r.call(this, n, e) | |
} else | |
r.apply(this, arguments) | |
} | |
).prototype = e | |
} | |
}(), | |
t.lib.WordArray | |
} | |
, | |
"object" == typeof r ? e.exports = r = n(t("./core")) : "function" == typeof define && define.amd ? define(["./core"], n) : n(this.CryptoJS) | |
} | |
, { | |
"./core": 59 | |
}], | |
67: [function(t, e, r) { | |
var n; | |
n = function(t) { | |
return function(e) { | |
var r = t | |
, n = r.lib | |
, i = n.WordArray | |
, o = n.Hasher | |
, s = r.algo | |
, a = []; | |
!function() { | |
for (var t = 0; t < 64; t++) | |
a[t] = 4294967296 * e.abs(e.sin(t + 1)) | 0 | |
}(); | |
var u = s.MD5 = o.extend({ | |
_doReset: function() { | |
this._hash = new i.init([1732584193, 4023233417, 2562383102, 271733878]) | |
}, | |
_doProcessBlock: function(t, e) { | |
for (var r = 0; r < 16; r++) { | |
var n = e + r | |
, i = t[n]; | |
t[n] = 16711935 & (i << 8 | i >>> 24) | 4278255360 & (i << 24 | i >>> 8) | |
} | |
var o = this._hash.words | |
, s = t[e + 0] | |
, u = t[e + 1] | |
, p = t[e + 2] | |
, d = t[e + 3] | |
, y = t[e + 4] | |
, m = t[e + 5] | |
, g = t[e + 6] | |
, v = t[e + 7] | |
, b = t[e + 8] | |
, w = t[e + 9] | |
, _ = t[e + 10] | |
, x = t[e + 11] | |
, S = t[e + 12] | |
, k = t[e + 13] | |
, E = t[e + 14] | |
, A = t[e + 15] | |
, C = o[0] | |
, T = o[1] | |
, O = o[2] | |
, B = o[3]; | |
T = h(T = h(T = h(T = h(T = l(T = l(T = l(T = l(T = f(T = f(T = f(T = f(T = c(T = c(T = c(T = c(T, O = c(O, B = c(B, C = c(C, T, O, B, s, 7, a[0]), T, O, u, 12, a[1]), C, T, p, 17, a[2]), B, C, d, 22, a[3]), O = c(O, B = c(B, C = c(C, T, O, B, y, 7, a[4]), T, O, m, 12, a[5]), C, T, g, 17, a[6]), B, C, v, 22, a[7]), O = c(O, B = c(B, C = c(C, T, O, B, b, 7, a[8]), T, O, w, 12, a[9]), C, T, _, 17, a[10]), B, C, x, 22, a[11]), O = c(O, B = c(B, C = c(C, T, O, B, S, 7, a[12]), T, O, k, 12, a[13]), C, T, E, 17, a[14]), B, C, A, 22, a[15]), O = f(O, B = f(B, C = f(C, T, O, B, u, 5, a[16]), T, O, g, 9, a[17]), C, T, x, 14, a[18]), B, C, s, 20, a[19]), O = f(O, B = f(B, C = f(C, T, O, B, m, 5, a[20]), T, O, _, 9, a[21]), C, T, A, 14, a[22]), B, C, y, 20, a[23]), O = f(O, B = f(B, C = f(C, T, O, B, w, 5, a[24]), T, O, E, 9, a[25]), C, T, d, 14, a[26]), B, C, b, 20, a[27]), O = f(O, B = f(B, C = f(C, T, O, B, k, 5, a[28]), T, O, p, 9, a[29]), C, T, v, 14, a[30]), B, C, S, 20, a[31]), O = l(O, B = l(B, C = l(C, T, O, B, m, 4, a[32]), T, O, b, 11, a[33]), C, T, x, 16, a[34]), B, C, E, 23, a[35]), O = l(O, B = l(B, C = l(C, T, O, B, u, 4, a[36]), T, O, y, 11, a[37]), C, T, v, 16, a[38]), B, C, _, 23, a[39]), O = l(O, B = l(B, C = l(C, T, O, B, k, 4, a[40]), T, O, s, 11, a[41]), C, T, d, 16, a[42]), B, C, g, 23, a[43]), O = l(O, B = l(B, C = l(C, T, O, B, w, 4, a[44]), T, O, S, 11, a[45]), C, T, A, 16, a[46]), B, C, p, 23, a[47]), O = h(O, B = h(B, C = h(C, T, O, B, s, 6, a[48]), T, O, v, 10, a[49]), C, T, E, 15, a[50]), B, C, m, 21, a[51]), O = h(O, B = h(B, C = h(C, T, O, B, S, 6, a[52]), T, O, d, 10, a[53]), C, T, _, 15, a[54]), B, C, u, 21, a[55]), O = h(O, B = h(B, C = h(C, T, O, B, b, 6, a[56]), T, O, A, 10, a[57]), C, T, g, 15, a[58]), B, C, k, 21, a[59]), O = h(O, B = h(B, C = h(C, T, O, B, y, 6, a[60]), T, O, x, 10, a[61]), C, T, p, 15, a[62]), B, C, w, 21, a[63]), | |
o[0] = o[0] + C | 0, | |
o[1] = o[1] + T | 0, | |
o[2] = o[2] + O | 0, | |
o[3] = o[3] + B | 0 | |
}, | |
_doFinalize: function() { | |
var t = this._data | |
, r = t.words | |
, n = 8 * this._nDataBytes | |
, i = 8 * t.sigBytes; | |
r[i >>> 5] |= 128 << 24 - i % 32; | |
var o = e.floor(n / 4294967296) | |
, s = n; | |
r[15 + (i + 64 >>> 9 << 4)] = 16711935 & (o << 8 | o >>> 24) | 4278255360 & (o << 24 | o >>> 8), | |
r[14 + (i + 64 >>> 9 << 4)] = 16711935 & (s << 8 | s >>> 24) | 4278255360 & (s << 24 | s >>> 8), | |
t.sigBytes = 4 * (r.length + 1), | |
this._process(); | |
for (var a = this._hash, u = a.words, c = 0; c < 4; c++) { | |
var f = u[c]; | |
u[c] = 16711935 & (f << 8 | f >>> 24) | 4278255360 & (f << 24 | f >>> 8) | |
} | |
return a | |
}, | |
clone: function() { | |
var t = o.clone.call(this); | |
return t._hash = this._hash.clone(), | |
t | |
} | |
}); | |
function c(t, e, r, n, i, o, s) { | |
var a = t + (e & r | ~e & n) + i + s; | |
return (a << o | a >>> 32 - o) + e | |
} | |
function f(t, e, r, n, i, o, s) { | |
var a = t + (e & n | r & ~n) + i + s; | |
return (a << o | a >>> 32 - o) + e | |
} | |
function l(t, e, r, n, i, o, s) { | |
var a = t + (e ^ r ^ n) + i + s; | |
return (a << o | a >>> 32 - o) + e | |
} | |
function h(t, e, r, n, i, o, s) { | |
var a = t + (r ^ (e | ~n)) + i + s; | |
return (a << o | a >>> 32 - o) + e | |
} | |
r.MD5 = o._createHelper(u), | |
r.HmacMD5 = o._createHmacHelper(u) | |
}(Math), | |
t.MD5 | |
} | |
, | |
"object" == typeof r ? e.exports = r = n(t("./core")) : "function" == typeof define && define.amd ? define(["./core"], n) : n(this.CryptoJS) | |
} | |
, { | |
"./core": 59 | |
}], | |
68: [function(t, e, r) { | |
var n; | |
n = function(t) { | |
return t.mode.CFB = function() { | |
var e = t.lib.BlockCipherMode.extend(); | |
function r(t, e, r, n) { | |
var i = this._iv; | |
if (i) { | |
var o = i.slice(0); | |
this._iv = void 0 | |
} else | |
o = this._prevBlock; | |
n.encryptBlock(o, 0); | |
for (var s = 0; s < r; s++) | |
t[e + s] ^= o[s] | |
} | |
return e.Encryptor = e.extend({ | |
processBlock: function(t, e) { | |
var n = this._cipher | |
, i = n.blockSize; | |
r.call(this, t, e, i, n), | |
this._prevBlock = t.slice(e, e + i) | |
} | |
}), | |
e.Decryptor = e.extend({ | |
processBlock: function(t, e) { | |
var n = this._cipher | |
, i = n.blockSize | |
, o = t.slice(e, e + i); | |
r.call(this, t, e, i, n), | |
this._prevBlock = o | |
} | |
}), | |
e | |
}(), | |
t.mode.CFB | |
} | |
, | |
"object" == typeof r ? e.exports = r = n(t("./core"), t("./cipher-core")) : "function" == typeof define && define.amd ? define(["./core", "./cipher-core"], n) : n(this.CryptoJS) | |
} | |
, { | |
"./cipher-core": 58, | |
"./core": 59 | |
}], | |
69: [function(t, e, r) { | |
var n; | |
n = function(t) { | |
return t.mode.CTRGladman = function() { | |
var e = t.lib.BlockCipherMode.extend(); | |
function r(t) { | |
if (255 == (t >> 24 & 255)) { | |
var e = t >> 16 & 255 | |
, r = t >> 8 & 255 | |
, n = 255 & t; | |
255 === e ? (e = 0, | |
255 === r ? (r = 0, | |
255 === n ? n = 0 : ++n) : ++r) : ++e, | |
t = 0, | |
t += e << 16, | |
t += r << 8, | |
t += n | |
} else | |
t += 1 << 24; | |
return t | |
} | |
var n = e.Encryptor = e.extend({ | |
processBlock: function(t, e) { | |
var n, i = this._cipher, o = i.blockSize, s = this._iv, a = this._counter; | |
s && (a = this._counter = s.slice(0), | |
this._iv = void 0), | |
0 === ((n = a)[0] = r(n[0])) && (n[1] = r(n[1])); | |
var u = a.slice(0); | |
i.encryptBlock(u, 0); | |
for (var c = 0; c < o; c++) | |
t[e + c] ^= u[c] | |
} | |
}); | |
return e.Decryptor = n, | |
e | |
}(), | |
t.mode.CTRGladman | |
} | |
, | |
"object" == typeof r ? e.exports = r = n(t("./core"), t("./cipher-core")) : "function" == typeof define && define.amd ? define(["./core", "./cipher-core"], n) : n(this.CryptoJS) | |
} | |
, { | |
"./cipher-core": 58, | |
"./core": 59 | |
}], | |
70: [function(t, e, r) { | |
var n; | |
n = function(t) { | |
var e, r; | |
return t.mode.CTR = (r = (e = t.lib.BlockCipherMode.extend()).Encryptor = e.extend({ | |
processBlock: function(t, e) { | |
var r = this._cipher | |
, n = r.blockSize | |
, i = this._iv | |
, o = this._counter; | |
i && (o = this._counter = i.slice(0), | |
this._iv = void 0); | |
var s = o.slice(0); | |
r.encryptBlock(s, 0), | |
o[n - 1] = o[n - 1] + 1 | 0; | |
for (var a = 0; a < n; a++) | |
t[e + a] ^= s[a] | |
} | |
}), | |
e.Decryptor = r, | |
e), | |
t.mode.CTR | |
} | |
, | |
"object" == typeof r ? e.exports = r = n(t("./core"), t("./cipher-core")) : "function" == typeof define && define.amd ? define(["./core", "./cipher-core"], n) : n(this.CryptoJS) | |
} | |
, { | |
"./cipher-core": 58, | |
"./core": 59 | |
}], | |
71: [function(t, e, r) { | |
var n; | |
n = function(t) { | |
var e; | |
return t.mode.ECB = ((e = t.lib.BlockCipherMode.extend()).Encryptor = e.extend({ | |
processBlock: function(t, e) { | |
this._cipher.encryptBlock(t, e) | |
} | |
}), | |
e.Decryptor = e.extend({ | |
processBlock: function(t, e) { | |
this._cipher.decryptBlock(t, e) | |
} | |
}), | |
e), | |
t.mode.ECB | |
} | |
, | |
"object" == typeof r ? e.exports = r = n(t("./core"), t("./cipher-core")) : "function" == typeof define && define.amd ? define(["./core", "./cipher-core"], n) : n(this.CryptoJS) | |
} | |
, { | |
"./cipher-core": 58, | |
"./core": 59 | |
}], | |
72: [function(t, e, r) { | |
var n; | |
n = function(t) { | |
var e, r; | |
return t.mode.OFB = (r = (e = t.lib.BlockCipherMode.extend()).Encryptor = e.extend({ | |
processBlock: function(t, e) { | |
var r = this._cipher | |
, n = r.blockSize | |
, i = this._iv | |
, o = this._keystream; | |
i && (o = this._keystream = i.slice(0), | |
this._iv = void 0), | |
r.encryptBlock(o, 0); | |
for (var s = 0; s < n; s++) | |
t[e + s] ^= o[s] | |
} | |
}), | |
e.Decryptor = r, | |
e), | |
t.mode.OFB | |
} | |
, | |
"object" == typeof r ? e.exports = r = n(t("./core"), t("./cipher-core")) : "function" == typeof define && define.amd ? define(["./core", "./cipher-core"], n) : n(this.CryptoJS) | |
} | |
, { | |
"./cipher-core": 58, | |
"./core": 59 | |
}], | |
73: [function(t, e, r) { | |
var n; | |
n = function(t) { | |
return t.pad.AnsiX923 = { | |
pad: function(t, e) { | |
var r = t.sigBytes | |
, n = 4 * e | |
, i = n - r % n | |
, o = r + i - 1; | |
t.clamp(), | |
t.words[o >>> 2] |= i << 24 - o % 4 * 8, | |
t.sigBytes += i | |
}, | |
unpad: function(t) { | |
var e = 255 & t.words[t.sigBytes - 1 >>> 2]; | |
t.sigBytes -= e | |
} | |
}, | |
t.pad.Ansix923 | |
} | |
, | |
"object" == typeof r ? e.exports = r = n(t("./core"), t("./cipher-core")) : "function" == typeof define && define.amd ? define(["./core", "./cipher-core"], n) : n(this.CryptoJS) | |
} | |
, { | |
"./cipher-core": 58, | |
"./core": 59 | |
}], | |
74: [function(t, e, r) { | |
var n; | |
n = function(t) { | |
return t.pad.Iso10126 = { | |
pad: function(e, r) { | |
var n = 4 * r | |
, i = n - e.sigBytes % n; | |
e.concat(t.lib.WordArray.random(i - 1)).concat(t.lib.WordArray.create([i << 24], 1)) | |
}, | |
unpad: function(t) { | |
var e = 255 & t.words[t.sigBytes - 1 >>> 2]; | |
t.sigBytes -= e | |
} | |
}, | |
t.pad.Iso10126 | |
} | |
, | |
"object" == typeof r ? e.exports = r = n(t("./core"), t("./cipher-core")) : "function" == typeof define && define.amd ? define(["./core", "./cipher-core"], n) : n(this.CryptoJS) | |
} | |
, { | |
"./cipher-core": 58, | |
"./core": 59 | |
}], | |
75: [function(t, e, r) { | |
var n; | |
n = function(t) { | |
return t.pad.Iso97971 = { | |
pad: function(e, r) { | |
e.concat(t.lib.WordArray.create([2147483648], 1)), | |
t.pad.ZeroPadding.pad(e, r) | |
}, | |
unpad: function(e) { | |
t.pad.ZeroPadding.unpad(e), | |
e.sigBytes-- | |
} | |
}, | |
t.pad.Iso97971 | |
} | |
, | |
"object" == typeof r ? e.exports = r = n(t("./core"), t("./cipher-core")) : "function" == typeof define && define.amd ? define(["./core", "./cipher-core"], n) : n(this.CryptoJS) | |
} | |
, { | |
"./cipher-core": 58, | |
"./core": 59 | |
}], | |
76: [function(t, e, r) { | |
var n; | |
n = function(t) { | |
return t.pad.NoPadding = { | |
pad: function() {}, | |
unpad: function() {} | |
}, | |
t.pad.NoPadding | |
} | |
, | |
"object" == typeof r ? e.exports = r = n(t("./core"), t("./cipher-core")) : "function" == typeof define && define.amd ? define(["./core", "./cipher-core"], n) : n(this.CryptoJS) | |
} | |
, { | |
"./cipher-core": 58, | |
"./core": 59 | |
}], | |
77: [function(t, e, r) { | |
var n; | |
n = function(t) { | |
return t.pad.ZeroPadding = { | |
pad: function(t, e) { | |
var r = 4 * e; | |
t.clamp(), | |
t.sigBytes += r - (t.sigBytes % r || r) | |
}, | |
unpad: function(t) { | |
for (var e = t.words, r = t.sigBytes - 1; !(e[r >>> 2] >>> 24 - r % 4 * 8 & 255); ) | |
r--; | |
t.sigBytes = r + 1 | |
} | |
}, | |
t.pad.ZeroPadding | |
} | |
, | |
"object" == typeof r ? e.exports = r = n(t("./core"), t("./cipher-core")) : "function" == typeof define && define.amd ? define(["./core", "./cipher-core"], n) : n(this.CryptoJS) | |
} | |
, { | |
"./cipher-core": 58, | |
"./core": 59 | |
}], | |
78: [function(t, e, r) { | |
var n; | |
n = function(t) { | |
var e, r, n, i, o, s, a, u; | |
return n = (r = (e = t).lib).Base, | |
i = r.WordArray, | |
s = (o = e.algo).SHA1, | |
a = o.HMAC, | |
u = o.PBKDF2 = n.extend({ | |
cfg: n.extend({ | |
keySize: 4, | |
hasher: s, | |
iterations: 1 | |
}), | |
init: function(t) { | |
this.cfg = this.cfg.extend(t) | |
}, | |
compute: function(t, e) { | |
for (var r = this.cfg, n = a.create(r.hasher, t), o = i.create(), s = i.create([1]), u = o.words, c = s.words, f = r.keySize, l = r.iterations; u.length < f; ) { | |
var h = n.update(e).finalize(s); | |
n.reset(); | |
for (var p = h.words, d = p.length, y = h, m = 1; m < l; m++) { | |
y = n.finalize(y), | |
n.reset(); | |
for (var g = y.words, v = 0; v < d; v++) | |
p[v] ^= g[v] | |
} | |
o.concat(h), | |
c[0]++ | |
} | |
return o.sigBytes = 4 * f, | |
o | |
} | |
}), | |
e.PBKDF2 = function(t, e, r) { | |
return u.create(r).compute(t, e) | |
} | |
, | |
t.PBKDF2 | |
} | |
, | |
"object" == typeof r ? e.exports = r = n(t("./core"), t("./sha1"), t("./hmac")) : "function" == typeof define && define.amd ? define(["./core", "./sha1", "./hmac"], n) : n(this.CryptoJS) | |
} | |
, { | |
"./core": 59, | |
"./hmac": 64, | |
"./sha1": 83 | |
}], | |
79: [function(t, e, r) { | |
var n; | |
n = function(t) { | |
return function() { | |
var e = t | |
, r = e.lib.StreamCipher | |
, n = e.algo | |
, i = [] | |
, o = [] | |
, s = [] | |
, a = n.RabbitLegacy = r.extend({ | |
_doReset: function() { | |
for (var t = this._key.words, e = this.cfg.iv, r = this._X = [t[0], t[3] << 16 | t[2] >>> 16, t[1], t[0] << 16 | t[3] >>> 16, t[2], t[1] << 16 | t[0] >>> 16, t[3], t[2] << 16 | t[1] >>> 16], n = this._C = [t[2] << 16 | t[2] >>> 16, 4294901760 & t[0] | 65535 & t[1], t[3] << 16 | t[3] >>> 16, 4294901760 & t[1] | 65535 & t[2], t[0] << 16 | t[0] >>> 16, 4294901760 & t[2] | 65535 & t[3], t[1] << 16 | t[1] >>> 16, 4294901760 & t[3] | 65535 & t[0]], i = this._b = 0; i < 4; i++) | |
u.call(this); | |
for (i = 0; i < 8; i++) | |
n[i] ^= r[i + 4 & 7]; | |
if (e) { | |
var o = e.words | |
, s = o[0] | |
, a = o[1] | |
, c = 16711935 & (s << 8 | s >>> 24) | 4278255360 & (s << 24 | s >>> 8) | |
, f = 16711935 & (a << 8 | a >>> 24) | 4278255360 & (a << 24 | a >>> 8) | |
, l = c >>> 16 | 4294901760 & f | |
, h = f << 16 | 65535 & c; | |
for (n[0] ^= c, | |
n[1] ^= l, | |
n[2] ^= f, | |
n[3] ^= h, | |
n[4] ^= c, | |
n[5] ^= l, | |
n[6] ^= f, | |
n[7] ^= h, | |
i = 0; i < 4; i++) | |
u.call(this) | |
} | |
}, | |
_doProcessBlock: function(t, e) { | |
var r = this._X; | |
u.call(this), | |
i[0] = r[0] ^ r[5] >>> 16 ^ r[3] << 16, | |
i[1] = r[2] ^ r[7] >>> 16 ^ r[5] << 16, | |
i[2] = r[4] ^ r[1] >>> 16 ^ r[7] << 16, | |
i[3] = r[6] ^ r[3] >>> 16 ^ r[1] << 16; | |
for (var n = 0; n < 4; n++) | |
i[n] = 16711935 & (i[n] << 8 | i[n] >>> 24) | 4278255360 & (i[n] << 24 | i[n] >>> 8), | |
t[e + n] ^= i[n] | |
}, | |
blockSize: 4, | |
ivSize: 2 | |
}); | |
function u() { | |
for (var t = this._X, e = this._C, r = 0; r < 8; r++) | |
o[r] = e[r]; | |
for (e[0] = e[0] + 1295307597 + this._b | 0, | |
e[1] = e[1] + 3545052371 + (e[0] >>> 0 < o[0] >>> 0 ? 1 : 0) | 0, | |
e[2] = e[2] + 886263092 + (e[1] >>> 0 < o[1] >>> 0 ? 1 : 0) | 0, | |
e[3] = e[3] + 1295307597 + (e[2] >>> 0 < o[2] >>> 0 ? 1 : 0) | 0, | |
e[4] = e[4] + 3545052371 + (e[3] >>> 0 < o[3] >>> 0 ? 1 : 0) | 0, | |
e[5] = e[5] + 886263092 + (e[4] >>> 0 < o[4] >>> 0 ? 1 : 0) | 0, | |
e[6] = e[6] + 1295307597 + (e[5] >>> 0 < o[5] >>> 0 ? 1 : 0) | 0, | |
e[7] = e[7] + 3545052371 + (e[6] >>> 0 < o[6] >>> 0 ? 1 : 0) | 0, | |
this._b = e[7] >>> 0 < o[7] >>> 0 ? 1 : 0, | |
r = 0; r < 8; r++) { | |
var n = t[r] + e[r] | |
, i = 65535 & n | |
, a = n >>> 16 | |
, u = ((i * i >>> 17) + i * a >>> 15) + a * a | |
, c = ((4294901760 & n) * n | 0) + ((65535 & n) * n | 0); | |
s[r] = u ^ c | |
} | |
t[0] = s[0] + (s[7] << 16 | s[7] >>> 16) + (s[6] << 16 | s[6] >>> 16) | 0, | |
t[1] = s[1] + (s[0] << 8 | s[0] >>> 24) + s[7] | 0, | |
t[2] = s[2] + (s[1] << 16 | s[1] >>> 16) + (s[0] << 16 | s[0] >>> 16) | 0, | |
t[3] = s[3] + (s[2] << 8 | s[2] >>> 24) + s[1] | 0, | |
t[4] = s[4] + (s[3] << 16 | s[3] >>> 16) + (s[2] << 16 | s[2] >>> 16) | 0, | |
t[5] = s[5] + (s[4] << 8 | s[4] >>> 24) + s[3] | 0, | |
t[6] = s[6] + (s[5] << 16 | s[5] >>> 16) + (s[4] << 16 | s[4] >>> 16) | 0, | |
t[7] = s[7] + (s[6] << 8 | s[6] >>> 24) + s[5] | 0 | |
} | |
e.RabbitLegacy = r._createHelper(a) | |
}(), | |
t.RabbitLegacy | |
} | |
, | |
"object" == typeof r ? e.exports = r = n(t("./core"), t("./enc-base64"), t("./md5"), t("./evpkdf"), t("./cipher-core")) : "function" == typeof define && define.amd ? define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], n) : n(this.CryptoJS) | |
} | |
, { | |
"./cipher-core": 58, | |
"./core": 59, | |
"./enc-base64": 60, | |
"./evpkdf": 62, | |
"./md5": 67 | |
}], | |
80: [function(t, e, r) { | |
var n; | |
n = function(t) { | |
return function() { | |
var e = t | |
, r = e.lib.StreamCipher | |
, n = e.algo | |
, i = [] | |
, o = [] | |
, s = [] | |
, a = n.Rabbit = r.extend({ | |
_doReset: function() { | |
for (var t = this._key.words, e = this.cfg.iv, r = 0; r < 4; r++) | |
t[r] = 16711935 & (t[r] << 8 | t[r] >>> 24) | 4278255360 & (t[r] << 24 | t[r] >>> 8); | |
var n = this._X = [t[0], t[3] << 16 | t[2] >>> 16, t[1], t[0] << 16 | t[3] >>> 16, t[2], t[1] << 16 | t[0] >>> 16, t[3], t[2] << 16 | t[1] >>> 16] | |
, i = this._C = [t[2] << 16 | t[2] >>> 16, 4294901760 & t[0] | 65535 & t[1], t[3] << 16 | t[3] >>> 16, 4294901760 & t[1] | 65535 & t[2], t[0] << 16 | t[0] >>> 16, 4294901760 & t[2] | 65535 & t[3], t[1] << 16 | t[1] >>> 16, 4294901760 & t[3] | 65535 & t[0]]; | |
for (r = this._b = 0; r < 4; r++) | |
u.call(this); | |
for (r = 0; r < 8; r++) | |
i[r] ^= n[r + 4 & 7]; | |
if (e) { | |
var o = e.words | |
, s = o[0] | |
, a = o[1] | |
, c = 16711935 & (s << 8 | s >>> 24) | 4278255360 & (s << 24 | s >>> 8) | |
, f = 16711935 & (a << 8 | a >>> 24) | 4278255360 & (a << 24 | a >>> 8) | |
, l = c >>> 16 | 4294901760 & f | |
, h = f << 16 | 65535 & c; | |
for (i[0] ^= c, | |
i[1] ^= l, | |
i[2] ^= f, | |
i[3] ^= h, | |
i[4] ^= c, | |
i[5] ^= l, | |
i[6] ^= f, | |
i[7] ^= h, | |
r = 0; r < 4; r++) | |
u.call(this) | |
} | |
}, | |
_doProcessBlock: function(t, e) { | |
var r = this._X; | |
u.call(this), | |
i[0] = r[0] ^ r[5] >>> 16 ^ r[3] << 16, | |
i[1] = r[2] ^ r[7] >>> 16 ^ r[5] << 16, | |
i[2] = r[4] ^ r[1] >>> 16 ^ r[7] << 16, | |
i[3] = r[6] ^ r[3] >>> 16 ^ r[1] << 16; | |
for (var n = 0; n < 4; n++) | |
i[n] = 16711935 & (i[n] << 8 | i[n] >>> 24) | 4278255360 & (i[n] << 24 | i[n] >>> 8), | |
t[e + n] ^= i[n] | |
}, | |
blockSize: 4, | |
ivSize: 2 | |
}); | |
function u() { | |
for (var t = this._X, e = this._C, r = 0; r < 8; r++) | |
o[r] = e[r]; | |
for (e[0] = e[0] + 1295307597 + this._b | 0, | |
e[1] = e[1] + 3545052371 + (e[0] >>> 0 < o[0] >>> 0 ? 1 : 0) | 0, | |
e[2] = e[2] + 886263092 + (e[1] >>> 0 < o[1] >>> 0 ? 1 : 0) | 0, | |
e[3] = e[3] + 1295307597 + (e[2] >>> 0 < o[2] >>> 0 ? 1 : 0) | 0, | |
e[4] = e[4] + 3545052371 + (e[3] >>> 0 < o[3] >>> 0 ? 1 : 0) | 0, | |
e[5] = e[5] + 886263092 + (e[4] >>> 0 < o[4] >>> 0 ? 1 : 0) | 0, | |
e[6] = e[6] + 1295307597 + (e[5] >>> 0 < o[5] >>> 0 ? 1 : 0) | 0, | |
e[7] = e[7] + 3545052371 + (e[6] >>> 0 < o[6] >>> 0 ? 1 : 0) | 0, | |
this._b = e[7] >>> 0 < o[7] >>> 0 ? 1 : 0, | |
r = 0; r < 8; r++) { | |
var n = t[r] + e[r] | |
, i = 65535 & n | |
, a = n >>> 16 | |
, u = ((i * i >>> 17) + i * a >>> 15) + a * a | |
, c = ((4294901760 & n) * n | 0) + ((65535 & n) * n | 0); | |
s[r] = u ^ c | |
} | |
t[0] = s[0] + (s[7] << 16 | s[7] >>> 16) + (s[6] << 16 | s[6] >>> 16) | 0, | |
t[1] = s[1] + (s[0] << 8 | s[0] >>> 24) + s[7] | 0, | |
t[2] = s[2] + (s[1] << 16 | s[1] >>> 16) + (s[0] << 16 | s[0] >>> 16) | 0, | |
t[3] = s[3] + (s[2] << 8 | s[2] >>> 24) + s[1] | 0, | |
t[4] = s[4] + (s[3] << 16 | s[3] >>> 16) + (s[2] << 16 | s[2] >>> 16) | 0, | |
t[5] = s[5] + (s[4] << 8 | s[4] >>> 24) + s[3] | 0, | |
t[6] = s[6] + (s[5] << 16 | s[5] >>> 16) + (s[4] << 16 | s[4] >>> 16) | 0, | |
t[7] = s[7] + (s[6] << 8 | s[6] >>> 24) + s[5] | 0 | |
} | |
e.Rabbit = r._createHelper(a) | |
}(), | |
t.Rabbit | |
} | |
, | |
"object" == typeof r ? e.exports = r = n(t("./core"), t("./enc-base64"), t("./md5"), t("./evpkdf"), t("./cipher-core")) : "function" == typeof define && define.amd ? define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], n) : n(this.CryptoJS) | |
} | |
, { | |
"./cipher-core": 58, | |
"./core": 59, | |
"./enc-base64": 60, | |
"./evpkdf": 62, | |
"./md5": 67 | |
}], | |
81: [function(t, e, r) { | |
var n; | |
n = function(t) { | |
return function() { | |
var e = t | |
, r = e.lib.StreamCipher | |
, n = e.algo | |
, i = n.RC4 = r.extend({ | |
_doReset: function() { | |
for (var t = this._key, e = t.words, r = t.sigBytes, n = this._S = [], i = 0; i < 256; i++) | |
n[i] = i; | |
i = 0; | |
for (var o = 0; i < 256; i++) { | |
var s = i % r | |
, a = e[s >>> 2] >>> 24 - s % 4 * 8 & 255; | |
o = (o + n[i] + a) % 256; | |
var u = n[i]; | |
n[i] = n[o], | |
n[o] = u | |
} | |
this._i = this._j = 0 | |
}, | |
_doProcessBlock: function(t, e) { | |
t[e] ^= o.call(this) | |
}, | |
keySize: 8, | |
ivSize: 0 | |
}); | |
function o() { | |
for (var t = this._S, e = this._i, r = this._j, n = 0, i = 0; i < 4; i++) { | |
r = (r + t[e = (e + 1) % 256]) % 256; | |
var o = t[e]; | |
t[e] = t[r], | |
t[r] = o, | |
n |= t[(t[e] + t[r]) % 256] << 24 - 8 * i | |
} | |
return this._i = e, | |
this._j = r, | |
n | |
} | |
e.RC4 = r._createHelper(i); | |
var s = n.RC4Drop = i.extend({ | |
cfg: i.cfg.extend({ | |
drop: 192 | |
}), | |
_doReset: function() { | |
i._doReset.call(this); | |
for (var t = this.cfg.drop; 0 < t; t--) | |
o.call(this) | |
} | |
}); | |
e.RC4Drop = r._createHelper(s) | |
}(), | |
t.RC4 | |
} | |
, | |
"object" == typeof r ? e.exports = r = n(t("./core"), t("./enc-base64"), t("./md5"), t("./evpkdf"), t("./cipher-core")) : "function" == typeof define && define.amd ? define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], n) : n(this.CryptoJS) | |
} | |
, { | |
"./cipher-core": 58, | |
"./core": 59, | |
"./enc-base64": 60, | |
"./evpkdf": 62, | |
"./md5": 67 | |
}], | |
82: [function(t, e, r) { | |
var n; | |
n = function(t) { | |
return function(e) { | |
var r = t | |
, n = r.lib | |
, i = n.WordArray | |
, o = n.Hasher | |
, s = r.algo | |
, a = i.create([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8, 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12, 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2, 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13]) | |
, u = i.create([5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12, 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2, 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13, 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14, 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11]) | |
, c = i.create([11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8, 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12, 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5, 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12, 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6]) | |
, f = i.create([8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6, 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11, 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5, 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8, 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11]) | |
, l = i.create([0, 1518500249, 1859775393, 2400959708, 2840853838]) | |
, h = i.create([1352829926, 1548603684, 1836072691, 2053994217, 0]) | |
, p = s.RIPEMD160 = o.extend({ | |
_doReset: function() { | |
this._hash = i.create([1732584193, 4023233417, 2562383102, 271733878, 3285377520]) | |
}, | |
_doProcessBlock: function(t, e) { | |
for (var r = 0; r < 16; r++) { | |
var n = e + r | |
, i = t[n]; | |
t[n] = 16711935 & (i << 8 | i >>> 24) | 4278255360 & (i << 24 | i >>> 8) | |
} | |
var o, s, p, w, _, x, S, k, E, A, C, T = this._hash.words, O = l.words, B = h.words, j = a.words, R = u.words, M = c.words, L = f.words; | |
for (x = o = T[0], | |
S = s = T[1], | |
k = p = T[2], | |
E = w = T[3], | |
A = _ = T[4], | |
r = 0; r < 80; r += 1) | |
C = o + t[e + j[r]] | 0, | |
C += r < 16 ? d(s, p, w) + O[0] : r < 32 ? y(s, p, w) + O[1] : r < 48 ? m(s, p, w) + O[2] : r < 64 ? g(s, p, w) + O[3] : v(s, p, w) + O[4], | |
C = (C = b(C |= 0, M[r])) + _ | 0, | |
o = _, | |
_ = w, | |
w = b(p, 10), | |
p = s, | |
s = C, | |
C = x + t[e + R[r]] | 0, | |
C += r < 16 ? v(S, k, E) + B[0] : r < 32 ? g(S, k, E) + B[1] : r < 48 ? m(S, k, E) + B[2] : r < 64 ? y(S, k, E) + B[3] : d(S, k, E) + B[4], | |
C = (C = b(C |= 0, L[r])) + A | 0, | |
x = A, | |
A = E, | |
E = b(k, 10), | |
k = S, | |
S = C; | |
C = T[1] + p + E | 0, | |
T[1] = T[2] + w + A | 0, | |
T[2] = T[3] + _ + x | 0, | |
T[3] = T[4] + o + S | 0, | |
T[4] = T[0] + s + k | 0, | |
T[0] = C | |
}, | |
_doFinalize: function() { | |
var t = this._data | |
, e = t.words | |
, r = 8 * this._nDataBytes | |
, n = 8 * t.sigBytes; | |
e[n >>> 5] |= 128 << 24 - n % 32, | |
e[14 + (n + 64 >>> 9 << 4)] = 16711935 & (r << 8 | r >>> 24) | 4278255360 & (r << 24 | r >>> 8), | |
t.sigBytes = 4 * (e.length + 1), | |
this._process(); | |
for (var i = this._hash, o = i.words, s = 0; s < 5; s++) { | |
var a = o[s]; | |
o[s] = 16711935 & (a << 8 | a >>> 24) | 4278255360 & (a << 24 | a >>> 8) | |
} | |
return i | |
}, | |
clone: function() { | |
var t = o.clone.call(this); | |
return t._hash = this._hash.clone(), | |
t | |
} | |
}); | |
function d(t, e, r) { | |
return t ^ e ^ r | |
} | |
function y(t, e, r) { | |
return t & e | ~t & r | |
} | |
function m(t, e, r) { | |
return (t | ~e) ^ r | |
} | |
function g(t, e, r) { | |
return t & r | e & ~r | |
} | |
function v(t, e, r) { | |
return t ^ (e | ~r) | |
} | |
function b(t, e) { | |
return t << e | t >>> 32 - e | |
} | |
r.RIPEMD160 = o._createHelper(p), | |
r.HmacRIPEMD160 = o._createHmacHelper(p) | |
}(Math), | |
t.RIPEMD160 | |
} | |
, | |
"object" == typeof r ? e.exports = r = n(t("./core")) : "function" == typeof define && define.amd ? define(["./core"], n) : n(this.CryptoJS) | |
} | |
, { | |
"./core": 59 | |
}], | |
83: [function(t, e, r) { | |
var n; | |
n = function(t) { | |
var e, r, n, i, o, s, a; | |
return r = (e = t).lib, | |
n = r.WordArray, | |
i = r.Hasher, | |
o = e.algo, | |
s = [], | |
a = o.SHA1 = i.extend({ | |
_doReset: function() { | |
this._hash = new n.init([1732584193, 4023233417, 2562383102, 271733878, 3285377520]) | |
}, | |
_doProcessBlock: function(t, e) { | |
for (var r = this._hash.words, n = r[0], i = r[1], o = r[2], a = r[3], u = r[4], c = 0; c < 80; c++) { | |
if (c < 16) | |
s[c] = 0 | t[e + c]; | |
else { | |
var f = s[c - 3] ^ s[c - 8] ^ s[c - 14] ^ s[c - 16]; | |
s[c] = f << 1 | f >>> 31 | |
} | |
var l = (n << 5 | n >>> 27) + u + s[c]; | |
l += c < 20 ? 1518500249 + (i & o | ~i & a) : c < 40 ? 1859775393 + (i ^ o ^ a) : c < 60 ? (i & o | i & a | o & a) - 1894007588 : (i ^ o ^ a) - 899497514, | |
u = a, | |
a = o, | |
o = i << 30 | i >>> 2, | |
i = n, | |
n = l | |
} | |
r[0] = r[0] + n | 0, | |
r[1] = r[1] + i | 0, | |
r[2] = r[2] + o | 0, | |
r[3] = r[3] + a | 0, | |
r[4] = r[4] + u | 0 | |
}, | |
_doFinalize: function() { | |
var t = this._data | |
, e = t.words | |
, r = 8 * this._nDataBytes | |
, n = 8 * t.sigBytes; | |
return e[n >>> 5] |= 128 << 24 - n % 32, | |
e[14 + (n + 64 >>> 9 << 4)] = Math.floor(r / 4294967296), | |
e[15 + (n + 64 >>> 9 << 4)] = r, | |
t.sigBytes = 4 * e.length, | |
this._process(), | |
this._hash | |
}, | |
clone: function() { | |
var t = i.clone.call(this); | |
return t._hash = this._hash.clone(), | |
t | |
} | |
}), | |
e.SHA1 = i._createHelper(a), | |
e.HmacSHA1 = i._createHmacHelper(a), | |
t.SHA1 | |
} | |
, | |
"object" == typeof r ? e.exports = r = n(t("./core")) : "function" == typeof define && define.amd ? define(["./core"], n) : n(this.CryptoJS) | |
} | |
, { | |
"./core": 59 | |
}], | |
84: [function(t, e, r) { | |
var n; | |
n = function(t) { | |
var e, r, n, i, o; | |
return r = (e = t).lib.WordArray, | |
n = e.algo, | |
i = n.SHA256, | |
o = n.SHA224 = i.extend({ | |
_doReset: function() { | |
this._hash = new r.init([3238371032, 914150663, 812702999, 4144912697, 4290775857, 1750603025, 1694076839, 3204075428]) | |
}, | |
_doFinalize: function() { | |
var t = i._doFinalize.call(this); | |
return t.sigBytes -= 4, | |
t | |
} | |
}), | |
e.SHA224 = i._createHelper(o), | |
e.HmacSHA224 = i._createHmacHelper(o), | |
t.SHA224 | |
} | |
, | |
"object" == typeof r ? e.exports = r = n(t("./core"), t("./sha256")) : "function" == typeof define && define.amd ? define(["./core", "./sha256"], n) : n(this.CryptoJS) | |
} | |
, { | |
"./core": 59, | |
"./sha256": 85 | |
}], | |
85: [function(t, e, r) { | |
var n; | |
n = function(t) { | |
return function(e) { | |
var r = t | |
, n = r.lib | |
, i = n.WordArray | |
, o = n.Hasher | |
, s = r.algo | |
, a = [] | |
, u = []; | |
!function() { | |
function t(t) { | |
for (var r = e.sqrt(t), n = 2; n <= r; n++) | |
if (!(t % n)) | |
return !1; | |
return !0 | |
} | |
function r(t) { | |
return 4294967296 * (t - (0 | t)) | 0 | |
} | |
for (var n = 2, i = 0; i < 64; ) | |
t(n) && (i < 8 && (a[i] = r(e.pow(n, .5))), | |
u[i] = r(e.pow(n, 1 / 3)), | |
i++), | |
n++ | |
}(); | |
var c = [] | |
, f = s.SHA256 = o.extend({ | |
_doReset: function() { | |
this._hash = new i.init(a.slice(0)) | |
}, | |
_doProcessBlock: function(t, e) { | |
for (var r = this._hash.words, n = r[0], i = r[1], o = r[2], s = r[3], a = r[4], f = r[5], l = r[6], h = r[7], p = 0; p < 64; p++) { | |
if (p < 16) | |
c[p] = 0 | t[e + p]; | |
else { | |
var d = c[p - 15] | |
, y = (d << 25 | d >>> 7) ^ (d << 14 | d >>> 18) ^ d >>> 3 | |
, m = c[p - 2] | |
, g = (m << 15 | m >>> 17) ^ (m << 13 | m >>> 19) ^ m >>> 10; | |
c[p] = y + c[p - 7] + g + c[p - 16] | |
} | |
var v = n & i ^ n & o ^ i & o | |
, b = (n << 30 | n >>> 2) ^ (n << 19 | n >>> 13) ^ (n << 10 | n >>> 22) | |
, w = h + ((a << 26 | a >>> 6) ^ (a << 21 | a >>> 11) ^ (a << 7 | a >>> 25)) + (a & f ^ ~a & l) + u[p] + c[p]; | |
h = l, | |
l = f, | |
f = a, | |
a = s + w | 0, | |
s = o, | |
o = i, | |
i = n, | |
n = w + (b + v) | 0 | |
} | |
r[0] = r[0] + n | 0, | |
r[1] = r[1] + i | 0, | |
r[2] = r[2] + o | 0, | |
r[3] = r[3] + s | 0, | |
r[4] = r[4] + a | 0, | |
r[5] = r[5] + f | 0, | |
r[6] = r[6] + l | 0, | |
r[7] = r[7] + h | 0 | |
}, | |
_doFinalize: function() { | |
var t = this._data | |
, r = t.words | |
, n = 8 * this._nDataBytes | |
, i = 8 * t.sigBytes; | |
return r[i >>> 5] |= 128 << 24 - i % 32, | |
r[14 + (i + 64 >>> 9 << 4)] = e.floor(n / 4294967296), | |
r[15 + (i + 64 >>> 9 << 4)] = n, | |
t.sigBytes = 4 * r.length, | |
this._process(), | |
this._hash | |
}, | |
clone: function() { | |
var t = o.clone.call(this); | |
return t._hash = this._hash.clone(), | |
t | |
} | |
}); | |
r.SHA256 = o._createHelper(f), | |
r.HmacSHA256 = o._createHmacHelper(f) | |
}(Math), | |
t.SHA256 | |
} | |
, | |
"object" == typeof r ? e.exports = r = n(t("./core")) : "function" == typeof define && define.amd ? define(["./core"], n) : n(this.CryptoJS) | |
} | |
, { | |
"./core": 59 | |
}], | |
86: [function(t, e, r) { | |
var n; | |
n = function(t) { | |
return function(e) { | |
var r = t | |
, n = r.lib | |
, i = n.WordArray | |
, o = n.Hasher | |
, s = r.x64.Word | |
, a = r.algo | |
, u = [] | |
, c = [] | |
, f = []; | |
!function() { | |
for (var t = 1, e = 0, r = 0; r < 24; r++) { | |
u[t + 5 * e] = (r + 1) * (r + 2) / 2 % 64; | |
var n = (2 * t + 3 * e) % 5; | |
t = e % 5, | |
e = n | |
} | |
for (t = 0; t < 5; t++) | |
for (e = 0; e < 5; e++) | |
c[t + 5 * e] = e + (2 * t + 3 * e) % 5 * 5; | |
for (var i = 1, o = 0; o < 24; o++) { | |
for (var a = 0, l = 0, h = 0; h < 7; h++) { | |
if (1 & i) { | |
var p = (1 << h) - 1; | |
p < 32 ? l ^= 1 << p : a ^= 1 << p - 32 | |
} | |
128 & i ? i = i << 1 ^ 113 : i <<= 1 | |
} | |
f[o] = s.create(a, l) | |
} | |
}(); | |
var l = []; | |
!function() { | |
for (var t = 0; t < 25; t++) | |
l[t] = s.create() | |
}(); | |
var h = a.SHA3 = o.extend({ | |
cfg: o.cfg.extend({ | |
outputLength: 512 | |
}), | |
_doReset: function() { | |
for (var t = this._state = [], e = 0; e < 25; e++) | |
t[e] = new s.init; | |
this.blockSize = (1600 - 2 * this.cfg.outputLength) / 32 | |
}, | |
_doProcessBlock: function(t, e) { | |
for (var r = this._state, n = this.blockSize / 2, i = 0; i < n; i++) { | |
var o = t[e + 2 * i] | |
, s = t[e + 2 * i + 1]; | |
o = 16711935 & (o << 8 | o >>> 24) | 4278255360 & (o << 24 | o >>> 8), | |
s = 16711935 & (s << 8 | s >>> 24) | 4278255360 & (s << 24 | s >>> 8), | |
(T = r[i]).high ^= s, | |
T.low ^= o | |
} | |
for (var a = 0; a < 24; a++) { | |
for (var h = 0; h < 5; h++) { | |
for (var p = 0, d = 0, y = 0; y < 5; y++) | |
p ^= (T = r[h + 5 * y]).high, | |
d ^= T.low; | |
var m = l[h]; | |
m.high = p, | |
m.low = d | |
} | |
for (h = 0; h < 5; h++) { | |
var g = l[(h + 4) % 5] | |
, v = l[(h + 1) % 5] | |
, b = v.high | |
, w = v.low; | |
for (p = g.high ^ (b << 1 | w >>> 31), | |
d = g.low ^ (w << 1 | b >>> 31), | |
y = 0; y < 5; y++) | |
(T = r[h + 5 * y]).high ^= p, | |
T.low ^= d | |
} | |
for (var _ = 1; _ < 25; _++) { | |
var x = (T = r[_]).high | |
, S = T.low | |
, k = u[_]; | |
k < 32 ? (p = x << k | S >>> 32 - k, | |
d = S << k | x >>> 32 - k) : (p = S << k - 32 | x >>> 64 - k, | |
d = x << k - 32 | S >>> 64 - k); | |
var E = l[c[_]]; | |
E.high = p, | |
E.low = d | |
} | |
var A = l[0] | |
, C = r[0]; | |
for (A.high = C.high, | |
A.low = C.low, | |
h = 0; h < 5; h++) | |
for (y = 0; y < 5; y++) { | |
var T = r[_ = h + 5 * y] | |
, O = l[_] | |
, B = l[(h + 1) % 5 + 5 * y] | |
, j = l[(h + 2) % 5 + 5 * y]; | |
T.high = O.high ^ ~B.high & j.high, | |
T.low = O.low ^ ~B.low & j.low | |
} | |
T = r[0]; | |
var R = f[a]; | |
T.high ^= R.high, | |
T.low ^= R.low | |
} | |
}, | |
_doFinalize: function() { | |
var t = this._data | |
, r = t.words | |
, n = (this._nDataBytes, | |
8 * t.sigBytes) | |
, o = 32 * this.blockSize; | |
r[n >>> 5] |= 1 << 24 - n % 32, | |
r[(e.ceil((n + 1) / o) * o >>> 5) - 1] |= 128, | |
t.sigBytes = 4 * r.length, | |
this._process(); | |
for (var s = this._state, a = this.cfg.outputLength / 8, u = a / 8, c = [], f = 0; f < u; f++) { | |
var l = s[f] | |
, h = l.high | |
, p = l.low; | |
h = 16711935 & (h << 8 | h >>> 24) | 4278255360 & (h << 24 | h >>> 8), | |
p = 16711935 & (p << 8 | p >>> 24) | 4278255360 & (p << 24 | p >>> 8), | |
c.push(p), | |
c.push(h) | |
} | |
return new i.init(c,a) | |
}, | |
clone: function() { | |
for (var t = o.clone.call(this), e = t._state = this._state.slice(0), r = 0; r < 25; r++) | |
e[r] = e[r].clone(); | |
return t | |
} | |
}); | |
r.SHA3 = o._createHelper(h), | |
r.HmacSHA3 = o._createHmacHelper(h) | |
}(Math), | |
t.SHA3 | |
} | |
, | |
"object" == typeof r ? e.exports = r = n(t("./core"), t("./x64-core")) : "function" == typeof define && define.amd ? define(["./core", "./x64-core"], n) : n(this.CryptoJS) | |
} | |
, { | |
"./core": 59, | |
"./x64-core": 90 | |
}], | |
87: [function(t, e, r) { | |
var n; | |
n = function(t) { | |
var e, r, n, i, o, s, a; | |
return r = (e = t).x64, | |
n = r.Word, | |
i = r.WordArray, | |
o = e.algo, | |
s = o.SHA512, | |
a = o.SHA384 = s.extend({ | |
_doReset: function() { | |
this._hash = new i.init([new n.init(3418070365,3238371032), new n.init(1654270250,914150663), new n.init(2438529370,812702999), new n.init(355462360,4144912697), new n.init(1731405415,4290775857), new n.init(2394180231,1750603025), new n.init(3675008525,1694076839), new n.init(1203062813,3204075428)]) | |
}, | |
_doFinalize: function() { | |
var t = s._doFinalize.call(this); | |
return t.sigBytes -= 16, | |
t | |
} | |
}), | |
e.SHA384 = s._createHelper(a), | |
e.HmacSHA384 = s._createHmacHelper(a), | |
t.SHA384 | |
} | |
, | |
"object" == typeof r ? e.exports = r = n(t("./core"), t("./x64-core"), t("./sha512")) : "function" == typeof define && define.amd ? define(["./core", "./x64-core", "./sha512"], n) : n(this.CryptoJS) | |
} | |
, { | |
"./core": 59, | |
"./sha512": 88, | |
"./x64-core": 90 | |
}], | |
88: [function(t, e, r) { | |
var n; | |
n = function(t) { | |
return function() { | |
var e = t | |
, r = e.lib.Hasher | |
, n = e.x64 | |
, i = n.Word | |
, o = n.WordArray | |
, s = e.algo; | |
function a() { | |
return i.create.apply(i, arguments) | |
} | |
var u = [a(1116352408, 3609767458), a(1899447441, 602891725), a(3049323471, 3964484399), a(3921009573, 2173295548), a(961987163, 4081628472), a(1508970993, 3053834265), a(2453635748, 2937671579), a(2870763221, 3664609560), a(3624381080, 2734883394), a(310598401, 1164996542), a(607225278, 1323610764), a(1426881987, 3590304994), a(1925078388, 4068182383), a(2162078206, 991336113), a(2614888103, 633803317), a(3248222580, 3479774868), a(3835390401, 2666613458), a(4022224774, 944711139), a(264347078, 2341262773), a(604807628, 2007800933), a(770255983, 1495990901), a(1249150122, 1856431235), a(1555081692, 3175218132), a(1996064986, 2198950837), a(2554220882, 3999719339), a(2821834349, 766784016), a(2952996808, 2566594879), a(3210313671, 3203337956), a(3336571891, 1034457026), a(3584528711, 2466948901), a(113926993, 3758326383), a(338241895, 168717936), a(666307205, 1188179964), a(773529912, 1546045734), a(1294757372, 1522805485), a(1396182291, 2643833823), a(1695183700, 2343527390), a(1986661051, 1014477480), a(2177026350, 1206759142), a(2456956037, 344077627), a(2730485921, 1290863460), a(2820302411, 3158454273), a(3259730800, 3505952657), a(3345764771, 106217008), a(3516065817, 3606008344), a(3600352804, 1432725776), a(4094571909, 1467031594), a(275423344, 851169720), a(430227734, 3100823752), a(506948616, 1363258195), a(659060556, 3750685593), a(883997877, 3785050280), a(958139571, 3318307427), a(1322822218, 3812723403), a(1537002063, 2003034995), a(1747873779, 3602036899), a(1955562222, 1575990012), a(2024104815, 1125592928), a(2227730452, 2716904306), a(2361852424, 442776044), a(2428436474, 593698344), a(2756734187, 3733110249), a(3204031479, 2999351573), a(3329325298, 3815920427), a(3391569614, 3928383900), a(3515267271, 566280711), a(3940187606, 3454069534), a(4118630271, 4000239992), a(116418474, 1914138554), a(174292421, 2731055270), a(289380356, 3203993006), a(460393269, 320620315), a(685471733, 587496836), a(852142971, 1086792851), a(1017036298, 365543100), a(1126000580, 2618297676), a(1288033470, 3409855158), a(1501505948, 4234509866), a(1607167915, 987167468), a(1816402316, 1246189591)] | |
, c = []; | |
!function() { | |
for (var t = 0; t < 80; t++) | |
c[t] = a() | |
}(); | |
var f = s.SHA512 = r.extend({ | |
_doReset: function() { | |
this._hash = new o.init([new i.init(1779033703,4089235720), new i.init(3144134277,2227873595), new i.init(1013904242,4271175723), new i.init(2773480762,1595750129), new i.init(1359893119,2917565137), new i.init(2600822924,725511199), new i.init(528734635,4215389547), new i.init(1541459225,327033209)]) | |
}, | |
_doProcessBlock: function(t, e) { | |
for (var r = this._hash.words, n = r[0], i = r[1], o = r[2], s = r[3], a = r[4], f = r[5], l = r[6], h = r[7], p = n.high, d = n.low, y = i.high, m = i.low, g = o.high, v = o.low, b = s.high, w = s.low, _ = a.high, x = a.low, S = f.high, k = f.low, E = l.high, A = l.low, C = h.high, T = h.low, O = p, B = d, j = y, R = m, M = g, L = v, I = b, N = w, P = _, D = x, F = S, U = k, q = E, H = A, z = C, W = T, J = 0; J < 80; J++) { | |
var G = c[J]; | |
if (J < 16) | |
var K = G.high = 0 | t[e + 2 * J] | |
, V = G.low = 0 | t[e + 2 * J + 1]; | |
else { | |
var X = c[J - 15] | |
, $ = X.high | |
, Y = X.low | |
, Z = ($ >>> 1 | Y << 31) ^ ($ >>> 8 | Y << 24) ^ $ >>> 7 | |
, Q = (Y >>> 1 | $ << 31) ^ (Y >>> 8 | $ << 24) ^ (Y >>> 7 | $ << 25) | |
, tt = c[J - 2] | |
, et = tt.high | |
, rt = tt.low | |
, nt = (et >>> 19 | rt << 13) ^ (et << 3 | rt >>> 29) ^ et >>> 6 | |
, it = (rt >>> 19 | et << 13) ^ (rt << 3 | et >>> 29) ^ (rt >>> 6 | et << 26) | |
, ot = c[J - 7] | |
, st = ot.high | |
, at = ot.low | |
, ut = c[J - 16] | |
, ct = ut.high | |
, ft = ut.low; | |
K = (K = (K = Z + st + ((V = Q + at) >>> 0 < Q >>> 0 ? 1 : 0)) + nt + ((V += it) >>> 0 < it >>> 0 ? 1 : 0)) + ct + ((V += ft) >>> 0 < ft >>> 0 ? 1 : 0), | |
G.high = K, | |
G.low = V | |
} | |
var lt, ht = P & F ^ ~P & q, pt = D & U ^ ~D & H, dt = O & j ^ O & M ^ j & M, yt = B & R ^ B & L ^ R & L, mt = (O >>> 28 | B << 4) ^ (O << 30 | B >>> 2) ^ (O << 25 | B >>> 7), gt = (B >>> 28 | O << 4) ^ (B << 30 | O >>> 2) ^ (B << 25 | O >>> 7), vt = (P >>> 14 | D << 18) ^ (P >>> 18 | D << 14) ^ (P << 23 | D >>> 9), bt = (D >>> 14 | P << 18) ^ (D >>> 18 | P << 14) ^ (D << 23 | P >>> 9), wt = u[J], _t = wt.high, xt = wt.low, St = z + vt + ((lt = W + bt) >>> 0 < W >>> 0 ? 1 : 0), kt = gt + yt; | |
z = q, | |
W = H, | |
q = F, | |
H = U, | |
F = P, | |
U = D, | |
P = I + (St = (St = (St = St + ht + ((lt += pt) >>> 0 < pt >>> 0 ? 1 : 0)) + _t + ((lt += xt) >>> 0 < xt >>> 0 ? 1 : 0)) + K + ((lt += V) >>> 0 < V >>> 0 ? 1 : 0)) + ((D = N + lt | 0) >>> 0 < N >>> 0 ? 1 : 0) | 0, | |
I = M, | |
N = L, | |
M = j, | |
L = R, | |
j = O, | |
R = B, | |
O = St + (mt + dt + (kt >>> 0 < gt >>> 0 ? 1 : 0)) + ((B = lt + kt | 0) >>> 0 < lt >>> 0 ? 1 : 0) | 0 | |
} | |
d = n.low = d + B, | |
n.high = p + O + (d >>> 0 < B >>> 0 ? 1 : 0), | |
m = i.low = m + R, | |
i.high = y + j + (m >>> 0 < R >>> 0 ? 1 : 0), | |
v = o.low = v + L, | |
o.high = g + M + (v >>> 0 < L >>> 0 ? 1 : 0), | |
w = s.low = w + N, | |
s.high = b + I + (w >>> 0 < N >>> 0 ? 1 : 0), | |
x = a.low = x + D, | |
a.high = _ + P + (x >>> 0 < D >>> 0 ? 1 : 0), | |
k = f.low = k + U, | |
f.high = S + F + (k >>> 0 < U >>> 0 ? 1 : 0), | |
A = l.low = A + H, | |
l.high = E + q + (A >>> 0 < H >>> 0 ? 1 : 0), | |
T = h.low = T + W, | |
h.high = C + z + (T >>> 0 < W >>> 0 ? 1 : 0) | |
}, | |
_doFinalize: function() { | |
var t = this._data | |
, e = t.words | |
, r = 8 * this._nDataBytes | |
, n = 8 * t.sigBytes; | |
return e[n >>> 5] |= 128 << 24 - n % 32, | |
e[30 + (n + 128 >>> 10 << 5)] = Math.floor(r / 4294967296), | |
e[31 + (n + 128 >>> 10 << 5)] = r, | |
t.sigBytes = 4 * e.length, | |
this._process(), | |
this._hash.toX32() | |
}, | |
clone: function() { | |
var t = r.clone.call(this); | |
return t._hash = this._hash.clone(), | |
t | |
}, | |
blockSize: 32 | |
}); | |
e.SHA512 = r._createHelper(f), | |
e.HmacSHA512 = r._createHmacHelper(f) | |
}(), | |
t.SHA512 | |
} | |
, | |
"object" == typeof r ? e.exports = r = n(t("./core"), t("./x64-core")) : "function" == typeof define && define.amd ? define(["./core", "./x64-core"], n) : n(this.CryptoJS) | |
} | |
, { | |
"./core": 59, | |
"./x64-core": 90 | |
}], | |
89: [function(t, e, r) { | |
var n; | |
n = function(t) { | |
return function() { | |
var e = t | |
, r = e.lib | |
, n = r.WordArray | |
, i = r.BlockCipher | |
, o = e.algo | |
, s = [57, 49, 41, 33, 25, 17, 9, 1, 58, 50, 42, 34, 26, 18, 10, 2, 59, 51, 43, 35, 27, 19, 11, 3, 60, 52, 44, 36, 63, 55, 47, 39, 31, 23, 15, 7, 62, 54, 46, 38, 30, 22, 14, 6, 61, 53, 45, 37, 29, 21, 13, 5, 28, 20, 12, 4] | |
, a = [14, 17, 11, 24, 1, 5, 3, 28, 15, 6, 21, 10, 23, 19, 12, 4, 26, 8, 16, 7, 27, 20, 13, 2, 41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48, 44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32] | |
, u = [1, 2, 4, 6, 8, 10, 12, 14, 15, 17, 19, 21, 23, 25, 27, 28] | |
, c = [{ | |
0: 8421888, | |
268435456: 32768, | |
536870912: 8421378, | |
805306368: 2, | |
1073741824: 512, | |
1342177280: 8421890, | |
1610612736: 8389122, | |
1879048192: 8388608, | |
2147483648: 514, | |
2415919104: 8389120, | |
2684354560: 33280, | |
2952790016: 8421376, | |
3221225472: 32770, | |
3489660928: 8388610, | |
3758096384: 0, | |
4026531840: 33282, | |
134217728: 0, | |
402653184: 8421890, | |
671088640: 33282, | |
939524096: 32768, | |
1207959552: 8421888, | |
1476395008: 512, | |
1744830464: 8421378, | |
2013265920: 2, | |
2281701376: 8389120, | |
2550136832: 33280, | |
2818572288: 8421376, | |
3087007744: 8389122, | |
3355443200: 8388610, | |
3623878656: 32770, | |
3892314112: 514, | |
4160749568: 8388608, | |
1: 32768, | |
268435457: 2, | |
536870913: 8421888, | |
805306369: 8388608, | |
1073741825: 8421378, | |
1342177281: 33280, | |
1610612737: 512, | |
1879048193: 8389122, | |
2147483649: 8421890, | |
2415919105: 8421376, | |
2684354561: 8388610, | |
2952790017: 33282, | |
3221225473: 514, | |
3489660929: 8389120, | |
3758096385: 32770, | |
4026531841: 0, | |
134217729: 8421890, | |
402653185: 8421376, | |
671088641: 8388608, | |
939524097: 512, | |
1207959553: 32768, | |
1476395009: 8388610, | |
1744830465: 2, | |
2013265921: 33282, | |
2281701377: 32770, | |
2550136833: 8389122, | |
2818572289: 514, | |
3087007745: 8421888, | |
3355443201: 8389120, | |
3623878657: 0, | |
3892314113: 33280, | |
4160749569: 8421378 | |
}, { | |
0: 1074282512, | |
16777216: 16384, | |
33554432: 524288, | |
50331648: 1074266128, | |
67108864: 1073741840, | |
83886080: 1074282496, | |
100663296: 1073758208, | |
117440512: 16, | |
134217728: 540672, | |
150994944: 1073758224, | |
167772160: 1073741824, | |
184549376: 540688, | |
201326592: 524304, | |
218103808: 0, | |
234881024: 16400, | |
251658240: 1074266112, | |
8388608: 1073758208, | |
25165824: 540688, | |
41943040: 16, | |
58720256: 1073758224, | |
75497472: 1074282512, | |
92274688: 1073741824, | |
109051904: 524288, | |
125829120: 1074266128, | |
142606336: 524304, | |
159383552: 0, | |
176160768: 16384, | |
192937984: 1074266112, | |
209715200: 1073741840, | |
226492416: 540672, | |
243269632: 1074282496, | |
260046848: 16400, | |
268435456: 0, | |
285212672: 1074266128, | |
301989888: 1073758224, | |
318767104: 1074282496, | |
335544320: 1074266112, | |
352321536: 16, | |
369098752: 540688, | |
385875968: 16384, | |
402653184: 16400, | |
419430400: 524288, | |
436207616: 524304, | |
452984832: 1073741840, | |
469762048: 540672, | |
486539264: 1073758208, | |
503316480: 1073741824, | |
520093696: 1074282512, | |
276824064: 540688, | |
293601280: 524288, | |
310378496: 1074266112, | |
327155712: 16384, | |
343932928: 1073758208, | |
360710144: 1074282512, | |
377487360: 16, | |
394264576: 1073741824, | |
411041792: 1074282496, | |
427819008: 1073741840, | |
444596224: 1073758224, | |
461373440: 524304, | |
478150656: 0, | |
494927872: 16400, | |
511705088: 1074266128, | |
528482304: 540672 | |
}, { | |
0: 260, | |
1048576: 0, | |
2097152: 67109120, | |
3145728: 65796, | |
4194304: 65540, | |
5242880: 67108868, | |
6291456: 67174660, | |
7340032: 67174400, | |
8388608: 67108864, | |
9437184: 67174656, | |
10485760: 65792, | |
11534336: 67174404, | |
12582912: 67109124, | |
13631488: 65536, | |
14680064: 4, | |
15728640: 256, | |
524288: 67174656, | |
1572864: 67174404, | |
2621440: 0, | |
3670016: 67109120, | |
4718592: 67108868, | |
5767168: 65536, | |
6815744: 65540, | |
7864320: 260, | |
8912896: 4, | |
9961472: 256, | |
11010048: 67174400, | |
12058624: 65796, | |
13107200: 65792, | |
14155776: 67109124, | |
15204352: 67174660, | |
16252928: 67108864, | |
16777216: 67174656, | |
17825792: 65540, | |
18874368: 65536, | |
19922944: 67109120, | |
20971520: 256, | |
22020096: 67174660, | |
23068672: 67108868, | |
24117248: 0, | |
25165824: 67109124, | |
26214400: 67108864, | |
27262976: 4, | |
28311552: 65792, | |
29360128: 67174400, | |
30408704: 260, | |
31457280: 65796, | |
32505856: 67174404, | |
17301504: 67108864, | |
18350080: 260, | |
19398656: 67174656, | |
20447232: 0, | |
21495808: 65540, | |
22544384: 67109120, | |
23592960: 256, | |
24641536: 67174404, | |
25690112: 65536, | |
26738688: 67174660, | |
27787264: 65796, | |
28835840: 67108868, | |
29884416: 67109124, | |
30932992: 67174400, | |
31981568: 4, | |
33030144: 65792 | |
}, { | |
0: 2151682048, | |
65536: 2147487808, | |
131072: 4198464, | |
196608: 2151677952, | |
262144: 0, | |
327680: 4198400, | |
393216: 2147483712, | |
458752: 4194368, | |
524288: 2147483648, | |
589824: 4194304, | |
655360: 64, | |
720896: 2147487744, | |
786432: 2151678016, | |
851968: 4160, | |
917504: 4096, | |
983040: 2151682112, | |
32768: 2147487808, | |
98304: 64, | |
163840: 2151678016, | |
229376: 2147487744, | |
294912: 4198400, | |
360448: 2151682112, | |
425984: 0, | |
491520: 2151677952, | |
557056: 4096, | |
622592: 2151682048, | |
688128: 4194304, | |
753664: 4160, | |
819200: 2147483648, | |
884736: 4194368, | |
950272: 4198464, | |
1015808: 2147483712, | |
1048576: 4194368, | |
1114112: 4198400, | |
1179648: 2147483712, | |
1245184: 0, | |
1310720: 4160, | |
1376256: 2151678016, | |
1441792: 2151682048, | |
1507328: 2147487808, | |
1572864: 2151682112, | |
1638400: 2147483648, | |
1703936: 2151677952, | |
1769472: 4198464, | |
1835008: 2147487744, | |
1900544: 4194304, | |
1966080: 64, | |
2031616: 4096, | |
1081344: 2151677952, | |
1146880: 2151682112, | |
1212416: 0, | |
1277952: 4198400, | |
1343488: 4194368, | |
1409024: 2147483648, | |
1474560: 2147487808, | |
1540096: 64, | |
1605632: 2147483712, | |
1671168: 4096, | |
1736704: 2147487744, | |
1802240: 2151678016, | |
1867776: 4160, | |
1933312: 2151682048, | |
1998848: 4194304, | |
2064384: 4198464 | |
}, { | |
0: 128, | |
4096: 17039360, | |
8192: 262144, | |
12288: 536870912, | |
16384: 537133184, | |
20480: 16777344, | |
24576: 553648256, | |
28672: 262272, | |
32768: 16777216, | |
36864: 537133056, | |
40960: 536871040, | |
45056: 553910400, | |
49152: 553910272, | |
53248: 0, | |
57344: 17039488, | |
61440: 553648128, | |
2048: 17039488, | |
6144: 553648256, | |
10240: 128, | |
14336: 17039360, | |
18432: 262144, | |
22528: 537133184, | |
26624: 553910272, | |
30720: 536870912, | |
34816: 537133056, | |
38912: 0, | |
43008: 553910400, | |
47104: 16777344, | |
51200: 536871040, | |
55296: 553648128, | |
59392: 16777216, | |
63488: 262272, | |
65536: 262144, | |
69632: 128, | |
73728: 536870912, | |
77824: 553648256, | |
81920: 16777344, | |
86016: 553910272, | |
90112: 537133184, | |
94208: 16777216, | |
98304: 553910400, | |
102400: 553648128, | |
106496: 17039360, | |
110592: 537133056, | |
114688: 262272, | |
118784: 536871040, | |
122880: 0, | |
126976: 17039488, | |
67584: 553648256, | |
71680: 16777216, | |
75776: 17039360, | |
79872: 537133184, | |
83968: 536870912, | |
88064: 17039488, | |
92160: 128, | |
96256: 553910272, | |
100352: 262272, | |
104448: 553910400, | |
108544: 0, | |
112640: 553648128, | |
116736: 16777344, | |
120832: 262144, | |
124928: 537133056, | |
129024: 536871040 | |
}, { | |
0: 268435464, | |
256: 8192, | |
512: 270532608, | |
768: 270540808, | |
1024: 268443648, | |
1280: 2097152, | |
1536: 2097160, | |
1792: 268435456, | |
2048: 0, | |
2304: 268443656, | |
2560: 2105344, | |
2816: 8, | |
3072: 270532616, | |
3328: 2105352, | |
3584: 8200, | |
3840: 270540800, | |
128: 270532608, | |
384: 270540808, | |
640: 8, | |
896: 2097152, | |
1152: 2105352, | |
1408: 268435464, | |
1664: 268443648, | |
1920: 8200, | |
2176: 2097160, | |
2432: 8192, | |
2688: 268443656, | |
2944: 270532616, | |
3200: 0, | |
3456: 270540800, | |
3712: 2105344, | |
3968: 268435456, | |
4096: 268443648, | |
4352: 270532616, | |
4608: 270540808, | |
4864: 8200, | |
5120: 2097152, | |
5376: 268435456, | |
5632: 268435464, | |
5888: 2105344, | |
6144: 2105352, | |
6400: 0, | |
6656: 8, | |
6912: 270532608, | |
7168: 8192, | |
7424: 268443656, | |
7680: 270540800, | |
7936: 2097160, | |
4224: 8, | |
4480: 2105344, | |
4736: 2097152, | |
4992: 268435464, | |
5248: 268443648, | |
5504: 8200, | |
5760: 270540808, | |
6016: 270532608, | |
6272: 270540800, | |
6528: 270532616, | |
6784: 8192, | |
7040: 2105352, | |
7296: 2097160, | |
7552: 0, | |
7808: 268435456, | |
8064: 268443656 | |
}, { | |
0: 1048576, | |
16: 33555457, | |
32: 1024, | |
48: 1049601, | |
64: 34604033, | |
80: 0, | |
96: 1, | |
112: 34603009, | |
128: 33555456, | |
144: 1048577, | |
160: 33554433, | |
176: 34604032, | |
192: 34603008, | |
208: 1025, | |
224: 1049600, | |
240: 33554432, | |
8: 34603009, | |
24: 0, | |
40: 33555457, | |
56: 34604032, | |
72: 1048576, | |
88: 33554433, | |
104: 33554432, | |
120: 1025, | |
136: 1049601, | |
152: 33555456, | |
168: 34603008, | |
184: 1048577, | |
200: 1024, | |
216: 34604033, | |
232: 1, | |
248: 1049600, | |
256: 33554432, | |
272: 1048576, | |
288: 33555457, | |
304: 34603009, | |
320: 1048577, | |
336: 33555456, | |
352: 34604032, | |
368: 1049601, | |
384: 1025, | |
400: 34604033, | |
416: 1049600, | |
432: 1, | |
448: 0, | |
464: 34603008, | |
480: 33554433, | |
496: 1024, | |
264: 1049600, | |
280: 33555457, | |
296: 34603009, | |
312: 1, | |
328: 33554432, | |
344: 1048576, | |
360: 1025, | |
376: 34604032, | |
392: 33554433, | |
408: 34603008, | |
424: 0, | |
440: 34604033, | |
456: 1049601, | |
472: 1024, | |
488: 33555456, | |
504: 1048577 | |
}, { | |
0: 134219808, | |
1: 131072, | |
2: 134217728, | |
3: 32, | |
4: 131104, | |
5: 134350880, | |
6: 134350848, | |
7: 2048, | |
8: 134348800, | |
9: 134219776, | |
10: 133120, | |
11: 134348832, | |
12: 2080, | |
13: 0, | |
14: 134217760, | |
15: 133152, | |
2147483648: 2048, | |
2147483649: 134350880, | |
2147483650: 134219808, | |
2147483651: 134217728, | |
2147483652: 134348800, | |
2147483653: 133120, | |
2147483654: 133152, | |
2147483655: 32, | |
2147483656: 134217760, | |
2147483657: 2080, | |
2147483658: 131104, | |
2147483659: 134350848, | |
2147483660: 0, | |
2147483661: 134348832, | |
2147483662: 134219776, | |
2147483663: 131072, | |
16: 133152, | |
17: 134350848, | |
18: 32, | |
19: 2048, | |
20: 134219776, | |
21: 134217760, | |
22: 134348832, | |
23: 131072, | |
24: 0, | |
25: 131104, | |
26: 134348800, | |
27: 134219808, | |
28: 134350880, | |
29: 133120, | |
30: 2080, | |
31: 134217728, | |
2147483664: 131072, | |
2147483665: 2048, | |
2147483666: 134348832, | |
2147483667: 133152, | |
2147483668: 32, | |
2147483669: 134348800, | |
2147483670: 134217728, | |
2147483671: 134219808, | |
2147483672: 134350880, | |
2147483673: 134217760, | |
2147483674: 134219776, | |
2147483675: 0, | |
2147483676: 133120, | |
2147483677: 2080, | |
2147483678: 131104, | |
2147483679: 134350848 | |
}] | |
, f = [4160749569, 528482304, 33030144, 2064384, 129024, 8064, 504, 2147483679] | |
, l = o.DES = i.extend({ | |
_doReset: function() { | |
for (var t = this._key.words, e = [], r = 0; r < 56; r++) { | |
var n = s[r] - 1; | |
e[r] = t[n >>> 5] >>> 31 - n % 32 & 1 | |
} | |
for (var i = this._subKeys = [], o = 0; o < 16; o++) { | |
var c = i[o] = [] | |
, f = u[o]; | |
for (r = 0; r < 24; r++) | |
c[r / 6 | 0] |= e[(a[r] - 1 + f) % 28] << 31 - r % 6, | |
c[4 + (r / 6 | 0)] |= e[28 + (a[r + 24] - 1 + f) % 28] << 31 - r % 6; | |
for (c[0] = c[0] << 1 | c[0] >>> 31, | |
r = 1; r < 7; r++) | |
c[r] = c[r] >>> 4 * (r - 1) + 3; | |
c[7] = c[7] << 5 | c[7] >>> 27 | |
} | |
var l = this._invSubKeys = []; | |
for (r = 0; r < 16; r++) | |
l[r] = i[15 - r] | |
}, | |
encryptBlock: function(t, e) { | |
this._doCryptBlock(t, e, this._subKeys) | |
}, | |
decryptBlock: function(t, e) { | |
this._doCryptBlock(t, e, this._invSubKeys) | |
}, | |
_doCryptBlock: function(t, e, r) { | |
this._lBlock = t[e], | |
this._rBlock = t[e + 1], | |
h.call(this, 4, 252645135), | |
h.call(this, 16, 65535), | |
p.call(this, 2, 858993459), | |
p.call(this, 8, 16711935), | |
h.call(this, 1, 1431655765); | |
for (var n = 0; n < 16; n++) { | |
for (var i = r[n], o = this._lBlock, s = this._rBlock, a = 0, u = 0; u < 8; u++) | |
a |= c[u][((s ^ i[u]) & f[u]) >>> 0]; | |
this._lBlock = s, | |
this._rBlock = o ^ a | |
} | |
var l = this._lBlock; | |
this._lBlock = this._rBlock, | |
this._rBlock = l, | |
h.call(this, 1, 1431655765), | |
p.call(this, 8, 16711935), | |
p.call(this, 2, 858993459), | |
h.call(this, 16, 65535), | |
h.call(this, 4, 252645135), | |
t[e] = this._lBlock, | |
t[e + 1] = this._rBlock | |
}, | |
keySize: 2, | |
ivSize: 2, | |
blockSize: 2 | |
}); | |
function h(t, e) { | |
var r = (this._lBlock >>> t ^ this._rBlock) & e; | |
this._rBlock ^= r, | |
this._lBlock ^= r << t | |
} | |
function p(t, e) { | |
var r = (this._rBlock >>> t ^ this._lBlock) & e; | |
this._lBlock ^= r, | |
this._rBlock ^= r << t | |
} | |
e.DES = i._createHelper(l); | |
var d = o.TripleDES = i.extend({ | |
_doReset: function() { | |
var t = this._key.words; | |
this._des1 = l.createEncryptor(n.create(t.slice(0, 2))), | |
this._des2 = l.createEncryptor(n.create(t.slice(2, 4))), | |
this._des3 = l.createEncryptor(n.create(t.slice(4, 6))) | |
}, | |
encryptBlock: function(t, e) { | |
this._des1.encryptBlock(t, e), | |
this._des2.decryptBlock(t, e), | |
this._des3.encryptBlock(t, e) | |
}, | |
decryptBlock: function(t, e) { | |
this._des3.decryptBlock(t, e), | |
this._des2.encryptBlock(t, e), | |
this._des1.decryptBlock(t, e) | |
}, | |
keySize: 6, | |
ivSize: 2, | |
blockSize: 2 | |
}); | |
e.TripleDES = i._createHelper(d) | |
}(), | |
t.TripleDES | |
} | |
, | |
"object" == typeof r ? e.exports = r = n(t("./core"), t("./enc-base64"), t("./md5"), t("./evpkdf"), t("./cipher-core")) : "function" == typeof define && define.amd ? define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], n) : n(this.CryptoJS) | |
} | |
, { | |
"./cipher-core": 58, | |
"./core": 59, | |
"./enc-base64": 60, | |
"./evpkdf": 62, | |
"./md5": 67 | |
}], | |
90: [function(t, e, r) { | |
var n; | |
n = function(t) { | |
var e, r, n, i, o; | |
return r = (e = t).lib, | |
n = r.Base, | |
i = r.WordArray, | |
(o = e.x64 = {}).Word = n.extend({ | |
init: function(t, e) { | |
this.high = t, | |
this.low = e | |
} | |
}), | |
o.WordArray = n.extend({ | |
init: function(t, e) { | |
t = this.words = t || [], | |
this.sigBytes = null != e ? e : 8 * t.length | |
}, | |
toX32: function() { | |
for (var t = this.words, e = t.length, r = [], n = 0; n < e; n++) { | |
var o = t[n]; | |
r.push(o.high), | |
r.push(o.low) | |
} | |
return i.create(r, this.sigBytes) | |
}, | |
clone: function() { | |
for (var t = n.clone.call(this), e = t.words = this.words.slice(0), r = e.length, i = 0; i < r; i++) | |
e[i] = e[i].clone(); | |
return t | |
} | |
}), | |
t | |
} | |
, | |
"object" == typeof r ? e.exports = r = n(t("./core")) : "function" == typeof define && define.amd ? define(["./core"], n) : n(this.CryptoJS) | |
} | |
, { | |
"./core": 59 | |
}], | |
91: [function(t, e, r) { | |
var n = Object.create || function(t) { | |
var e = function() {}; | |
return e.prototype = t, | |
new e | |
} | |
, i = Object.keys || function(t) { | |
var e = []; | |
for (var r in t) | |
Object.prototype.hasOwnProperty.call(t, r) && e.push(r); | |
return r | |
} | |
, o = Function.prototype.bind || function(t) { | |
var e = this; | |
return function() { | |
return e.apply(t, arguments) | |
} | |
} | |
; | |
function s() { | |
this._events && Object.prototype.hasOwnProperty.call(this, "_events") || (this._events = n(null), | |
this._eventsCount = 0), | |
this._maxListeners = this._maxListeners || void 0 | |
} | |
((e.exports = s).EventEmitter = s).prototype._events = void 0, | |
s.prototype._maxListeners = void 0; | |
var a, u = 10; | |
try { | |
var c = {}; | |
Object.defineProperty && Object.defineProperty(c, "x", { | |
value: 0 | |
}), | |
a = 0 === c.x | |
} catch (t) { | |
a = !1 | |
} | |
function f(t) { | |
return void 0 === t._maxListeners ? s.defaultMaxListeners : t._maxListeners | |
} | |
function l(t, e, r, i) { | |
var o, s, a; | |
if ("function" != typeof r) | |
throw new TypeError('"listener" argument must be a function'); | |
if ((s = t._events) ? (s.newListener && (t.emit("newListener", e, r.listener ? r.listener : r), | |
s = t._events), | |
a = s[e]) : (s = t._events = n(null), | |
t._eventsCount = 0), | |
a) { | |
if ("function" == typeof a ? a = s[e] = i ? [r, a] : [a, r] : i ? a.unshift(r) : a.push(r), | |
!a.warned && (o = f(t)) && 0 < o && a.length > o) { | |
a.warned = !0; | |
var u = new Error("Possible EventEmitter memory leak detected. " + a.length + ' "' + String(e) + '" listeners added. Use emitter.setMaxListeners() to increase limit.'); | |
u.name = "MaxListenersExceededWarning", | |
u.emitter = t, | |
u.type = e, | |
u.count = a.length, | |
"object" == typeof console && console.warn && console.warn("%s: %s", u.name, u.message) | |
} | |
} else | |
a = s[e] = r, | |
++t._eventsCount; | |
return t | |
} | |
function h() { | |
if (!this.fired) | |
switch (this.target.removeListener(this.type, this.wrapFn), | |
this.fired = !0, | |
arguments.length) { | |
case 0: | |
return this.listener.call(this.target); | |
case 1: | |
return this.listener.call(this.target, arguments[0]); | |
case 2: | |
return this.listener.call(this.target, arguments[0], arguments[1]); | |
case 3: | |
return this.listener.call(this.target, arguments[0], arguments[1], arguments[2]); | |
default: | |
for (var t = new Array(arguments.length), e = 0; e < t.length; ++e) | |
t[e] = arguments[e]; | |
this.listener.apply(this.target, t) | |
} | |
} | |
function p(t, e, r) { | |
var n = { | |
fired: !1, | |
wrapFn: void 0, | |
target: t, | |
type: e, | |
listener: r | |
} | |
, i = o.call(h, n); | |
return i.listener = r, | |
n.wrapFn = i | |
} | |
function d(t, e, r) { | |
var n = t._events; | |
if (!n) | |
return []; | |
var i = n[e]; | |
return i ? "function" == typeof i ? r ? [i.listener || i] : [i] : r ? function(t) { | |
for (var e = new Array(t.length), r = 0; r < e.length; ++r) | |
e[r] = t[r].listener || t[r]; | |
return e | |
}(i) : m(i, i.length) : [] | |
} | |
function y(t) { | |
var e = this._events; | |
if (e) { | |
var r = e[t]; | |
if ("function" == typeof r) | |
return 1; | |
if (r) | |
return r.length | |
} | |
return 0 | |
} | |
function m(t, e) { | |
for (var r = new Array(e), n = 0; n < e; ++n) | |
r[n] = t[n]; | |
return r | |
} | |
a ? Object.defineProperty(s, "defaultMaxListeners", { | |
enumerable: !0, | |
get: function() { | |
return u | |
}, | |
set: function(t) { | |
if ("number" != typeof t || t < 0 || t != t) | |
throw new TypeError('"defaultMaxListeners" must be a positive number'); | |
u = t | |
} | |
}) : s.defaultMaxListeners = u, | |
s.prototype.setMaxListeners = function(t) { | |
if ("number" != typeof t || t < 0 || isNaN(t)) | |
throw new TypeError('"n" argument must be a positive number'); | |
return this._maxListeners = t, | |
this | |
} | |
, | |
s.prototype.getMaxListeners = function() { | |
return f(this) | |
} | |
, | |
s.prototype.emit = function(t) { | |
var e, r, n, i, o, s, a = "error" === t; | |
if (s = this._events) | |
a = a && null == s.error; | |
else if (!a) | |
return !1; | |
if (a) { | |
if (1 < arguments.length && (e = arguments[1]), | |
e instanceof Error) | |
throw e; | |
var u = new Error('Unhandled "error" event. (' + e + ")"); | |
throw u.context = e, | |
u | |
} | |
if (!(r = s[t])) | |
return !1; | |
var c = "function" == typeof r; | |
switch (n = arguments.length) { | |
case 1: | |
!function(t, e, r) { | |
if (c) | |
t.call(r); | |
else | |
for (var n = t.length, i = m(t, n), o = 0; o < n; ++o) | |
i[o].call(r) | |
}(r, 0, this); | |
break; | |
case 2: | |
!function(t, e, r, n) { | |
if (e) | |
t.call(r, n); | |
else | |
for (var i = t.length, o = m(t, i), s = 0; s < i; ++s) | |
o[s].call(r, n) | |
}(r, c, this, arguments[1]); | |
break; | |
case 3: | |
!function(t, e, r, n, i) { | |
if (e) | |
t.call(r, n, i); | |
else | |
for (var o = t.length, s = m(t, o), a = 0; a < o; ++a) | |
s[a].call(r, n, i) | |
}(r, c, this, arguments[1], arguments[2]); | |
break; | |
case 4: | |
!function(t, e, r, n, i, o) { | |
if (e) | |
t.call(r, n, i, o); | |
else | |
for (var s = t.length, a = m(t, s), u = 0; u < s; ++u) | |
a[u].call(r, n, i, o) | |
}(r, c, this, arguments[1], arguments[2], arguments[3]); | |
break; | |
default: | |
for (i = new Array(n - 1), | |
o = 1; o < n; o++) | |
i[o - 1] = arguments[o]; | |
!function(t, e, r, n) { | |
if (c) | |
t.apply(r, n); | |
else | |
for (var i = t.length, o = m(t, i), s = 0; s < i; ++s) | |
o[s].apply(r, n) | |
}(r, 0, this, i) | |
} | |
return !0 | |
} | |
, | |
s.prototype.on = s.prototype.addListener = function(t, e) { | |
return l(this, t, e, !1) | |
} | |
, | |
s.prototype.prependListener = function(t, e) { | |
return l(this, t, e, !0) | |
} | |
, | |
s.prototype.once = function(t, e) { | |
if ("function" != typeof e) | |
throw new TypeError('"listener" argument must be a function'); | |
return this.on(t, p(this, t, e)), | |
this | |
} | |
, | |
s.prototype.prependOnceListener = function(t, e) { | |
if ("function" != typeof e) | |
throw new TypeError('"listener" argument must be a function'); | |
return this.prependListener(t, p(this, t, e)), | |
this | |
} | |
, | |
s.prototype.removeListener = function(t, e) { | |
var r, i, o, s, a; | |
if ("function" != typeof e) | |
throw new TypeError('"listener" argument must be a function'); | |
if (!(i = this._events)) | |
return this; | |
if (!(r = i[t])) | |
return this; | |
if (r === e || r.listener === e) | |
0 == --this._eventsCount ? this._events = n(null) : (delete i[t], | |
i.removeListener && this.emit("removeListener", t, r.listener || e)); | |
else if ("function" != typeof r) { | |
for (o = -1, | |
s = r.length - 1; 0 <= s; s--) | |
if (r[s] === e || r[s].listener === e) { | |
a = r[s].listener, | |
o = s; | |
break | |
} | |
if (o < 0) | |
return this; | |
0 === o ? r.shift() : function(t, e) { | |
for (var r = e, n = r + 1, i = t.length; n < i; r += 1, | |
n += 1) | |
t[r] = t[n]; | |
t.pop() | |
}(r, o), | |
1 === r.length && (i[t] = r[0]), | |
i.removeListener && this.emit("removeListener", t, a || e) | |
} | |
return this | |
} | |
, | |
s.prototype.removeAllListeners = function(t) { | |
var e, r, o; | |
if (!(r = this._events)) | |
return this; | |
if (!r.removeListener) | |
return 0 === arguments.length ? (this._events = n(null), | |
this._eventsCount = 0) : r[t] && (0 == --this._eventsCount ? this._events = n(null) : delete r[t]), | |
this; | |
if (0 === arguments.length) { | |
var s, a = i(r); | |
for (o = 0; o < a.length; ++o) | |
"removeListener" !== (s = a[o]) && this.removeAllListeners(s); | |
return this.removeAllListeners("removeListener"), | |
this._events = n(null), | |
this._eventsCount = 0, | |
this | |
} | |
if ("function" == typeof (e = r[t])) | |
this.removeListener(t, e); | |
else if (e) | |
for (o = e.length - 1; 0 <= o; o--) | |
this.removeListener(t, e[o]); | |
return this | |
} | |
, | |
s.prototype.listeners = function(t) { | |
return d(this, t, !0) | |
} | |
, | |
s.prototype.rawListeners = function(t) { | |
return d(this, t, !1) | |
} | |
, | |
s.listenerCount = function(t, e) { | |
return "function" == typeof t.listenerCount ? t.listenerCount(e) : y.call(t, e) | |
} | |
, | |
s.prototype.listenerCount = y, | |
s.prototype.eventNames = function() { | |
return 0 < this._eventsCount ? Reflect.ownKeys(this._events) : [] | |
} | |
} | |
, {}], | |
92: [function(t, e, r) { | |
var n = t("http") | |
, i = t("url") | |
, o = e.exports; | |
for (var s in n) | |
n.hasOwnProperty(s) && (o[s] = n[s]); | |
function a(t) { | |
if ("string" == typeof t && (t = i.parse(t)), | |
t.protocol || (t.protocol = "https:"), | |
"https:" !== t.protocol) | |
throw new Error('Protocol "' + t.protocol + '" not supported. Expected "https:"'); | |
return t | |
} | |
o.request = function(t, e) { | |
return t = a(t), | |
n.request.call(this, t, e) | |
} | |
, | |
o.get = function(t, e) { | |
return t = a(t), | |
n.get.call(this, t, e) | |
} | |
} | |
, { | |
http: 114, | |
url: 121 | |
}], | |
93: [function(t, e, r) { | |
r.read = function(t, e, r, n, i) { | |
var o, s, a = 8 * i - n - 1, u = (1 << a) - 1, c = u >> 1, f = -7, l = r ? i - 1 : 0, h = r ? -1 : 1, p = t[e + l]; | |
for (l += h, | |
o = p & (1 << -f) - 1, | |
p >>= -f, | |
f += a; 0 < f; o = 256 * o + t[e + l], | |
l += h, | |
f -= 8) | |
; | |
for (s = o & (1 << -f) - 1, | |
o >>= -f, | |
f += n; 0 < f; s = 256 * s + t[e + l], | |
l += h, | |
f -= 8) | |
; | |
if (0 === o) | |
o = 1 - c; | |
else { | |
if (o === u) | |
return s ? NaN : 1 / 0 * (p ? -1 : 1); | |
s += Math.pow(2, n), | |
o -= c | |
} | |
return (p ? -1 : 1) * s * Math.pow(2, o - n) | |
} | |
, | |
r.write = function(t, e, r, n, i, o) { | |
var s, a, u, c = 8 * o - i - 1, f = (1 << c) - 1, l = f >> 1, h = 23 === i ? Math.pow(2, -24) - Math.pow(2, -77) : 0, p = n ? 0 : o - 1, d = n ? 1 : -1, y = e < 0 || 0 === e && 1 / e < 0 ? 1 : 0; | |
for (e = Math.abs(e), | |
isNaN(e) || e === 1 / 0 ? (a = isNaN(e) ? 1 : 0, | |
s = f) : (s = Math.floor(Math.log(e) / Math.LN2), | |
e * (u = Math.pow(2, -s)) < 1 && (s--, | |
u *= 2), | |
2 <= (e += 1 <= s + l ? h / u : h * Math.pow(2, 1 - l)) * u && (s++, | |
u /= 2), | |
f <= s + l ? (a = 0, | |
s = f) : 1 <= s + l ? (a = (e * u - 1) * Math.pow(2, i), | |
s += l) : (a = e * Math.pow(2, l - 1) * Math.pow(2, i), | |
s = 0)); 8 <= i; t[r + p] = 255 & a, | |
p += d, | |
a /= 256, | |
i -= 8) | |
; | |
for (s = s << i | a, | |
c += i; 0 < c; t[r + p] = 255 & s, | |
p += d, | |
s /= 256, | |
c -= 8) | |
; | |
t[r + p - d] |= 128 * y | |
} | |
} | |
, {}], | |
94: [function(t, e, r) { | |
"function" == typeof Object.create ? e.exports = function(t, e) { | |
t.super_ = e, | |
t.prototype = Object.create(e.prototype, { | |
constructor: { | |
value: t, | |
enumerable: !1, | |
writable: !0, | |
configurable: !0 | |
} | |
}) | |
} | |
: e.exports = function(t, e) { | |
t.super_ = e; | |
var r = function() {}; | |
r.prototype = e.prototype, | |
t.prototype = new r, | |
t.prototype.constructor = t | |
} | |
} | |
, {}], | |
95: [function(t, e, r) { | |
function n(t) { | |
return !!t.constructor && "function" == typeof t.constructor.isBuffer && t.constructor.isBuffer(t) | |
} | |
e.exports = function(t) { | |
return null != t && (n(t) || "function" == typeof (e = t).readFloatLE && "function" == typeof e.slice && n(e.slice(0, 0)) || !!t._isBuffer); | |
var e | |
} | |
} | |
, {}], | |
96: [function(t, e, r) { | |
var n = {}.toString; | |
e.exports = Array.isArray || function(t) { | |
return "[object Array]" == n.call(t) | |
} | |
} | |
, {}], | |
97: [function(t, e, r) { | |
r.endianness = function() { | |
return "LE" | |
} | |
, | |
r.hostname = function() { | |
return "undefined" != typeof location ? location.hostname : "" | |
} | |
, | |
r.loadavg = function() { | |
return [] | |
} | |
, | |
r.uptime = function() { | |
return 0 | |
} | |
, | |
r.freemem = function() { | |
return Number.MAX_VALUE | |
} | |
, | |
r.totalmem = function() { | |
return Number.MAX_VALUE | |
} | |
, | |
r.cpus = function() { | |
return [] | |
} | |
, | |
r.type = function() { | |
return "Browser" | |
} | |
, | |
r.release = function() { | |
return "undefined" != typeof navigator ? navigator.appVersion : "" | |
} | |
, | |
r.networkInterfaces = r.getNetworkInterfaces = function() { | |
return {} | |
} | |
, | |
r.arch = function() { | |
return "javascript" | |
} | |
, | |
r.platform = function() { | |
return "browser" | |
} | |
, | |
r.tmpdir = r.tmpDir = function() { | |
return "/tmp" | |
} | |
, | |
r.EOL = "\n", | |
r.homedir = function() { | |
return "/" | |
} | |
} | |
, {}], | |
98: [function(t, e, r) { | |
(function(t) { | |
"use strict"; | |
!t.version || 0 === t.version.indexOf("v0.") || 0 === t.version.indexOf("v1.") && 0 !== t.version.indexOf("v1.8.") ? e.exports = { | |
nextTick: function(e, r, n, i) { | |
if ("function" != typeof e) | |
throw new TypeError('"callback" argument must be a function'); | |
var o, s, a = arguments.length; | |
switch (a) { | |
case 0: | |
case 1: | |
return t.nextTick(e); | |
case 2: | |
return t.nextTick(function() { | |
e.call(null, r) | |
}); | |
case 3: | |
return t.nextTick(function() { | |
e.call(null, r, n) | |
}); | |
case 4: | |
return t.nextTick(function() { | |
e.call(null, r, n, i) | |
}); | |
default: | |
for (o = new Array(a - 1), | |
s = 0; s < o.length; ) | |
o[s++] = arguments[s]; | |
return t.nextTick(function() { | |
e.apply(null, o) | |
}) | |
} | |
} | |
} : e.exports = t | |
} | |
).call(this, t("_process")) | |
} | |
, { | |
_process: 99 | |
}], | |
99: [function(t, e, r) { | |
var n, i, o = e.exports = {}; | |
function s() { | |
throw new Error("setTimeout has not been defined") | |
} | |
function a() { | |
throw new Error("clearTimeout has not been defined") | |
} | |
function u(t) { | |
if (n === setTimeout) | |
return setTimeout(t, 0); | |
if ((n === s || !n) && setTimeout) | |
return n = setTimeout, | |
setTimeout(t, 0); | |
try { | |
return n(t, 0) | |
} catch (e) { | |
try { | |
return n.call(null, t, 0) | |
} catch (e) { | |
return n.call(this, t, 0) | |
} | |
} | |
} | |
!function() { | |
try { | |
n = "function" == typeof setTimeout ? setTimeout : s | |
} catch (t) { | |
n = s | |
} | |
try { | |
i = "function" == typeof clearTimeout ? clearTimeout : a | |
} catch (t) { | |
i = a | |
} | |
}(); | |
var c, f = [], l = !1, h = -1; | |
function p() { | |
l && c && (l = !1, | |
c.length ? f = c.concat(f) : h = -1, | |
f.length && d()) | |
} | |
function d() { | |
if (!l) { | |
var t = u(p); | |
l = !0; | |
for (var e = f.length; e; ) { | |
for (c = f, | |
f = []; ++h < e; ) | |
c && c[h].run(); | |
h = -1, | |
e = f.length | |
} | |
c = null, | |
l = !1, | |
function(t) { | |
if (i === clearTimeout) | |
return clearTimeout(t); | |
if ((i === a || !i) && clearTimeout) | |
return i = clearTimeout, | |
clearTimeout(t); | |
try { | |
i(t) | |
} catch (e) { | |
try { | |
return i.call(null, t) | |
} catch (e) { | |
return i.call(this, t) | |
} | |
} | |
}(t) | |
} | |
} | |
function y(t, e) { | |
this.fun = t, | |
this.array = e | |
} | |
function m() {} | |
o.nextTick = function(t) { | |
var e = new Array(arguments.length - 1); | |
if (1 < arguments.length) | |
for (var r = 1; r < arguments.length; r++) | |
e[r - 1] = arguments[r]; | |
f.push(new y(t,e)), | |
1 !== f.length || l || u(d) | |
} | |
, | |
y.prototype.run = function() { | |
this.fun.apply(null, this.array) | |
} | |
, | |
o.title = "browser", | |
o.browser = !0, | |
o.env = {}, | |
o.argv = [], | |
o.version = "", | |
o.versions = {}, | |
o.on = m, | |
o.addListener = m, | |
o.once = m, | |
o.off = m, | |
o.removeListener = m, | |
o.removeAllListeners = m, | |
o.emit = m, | |
o.prependListener = m, | |
o.prependOnceListener = m, | |
o.listeners = function(t) { | |
return [] | |
} | |
, | |
o.binding = function(t) { | |
throw new Error("process.binding is not supported") | |
} | |
, | |
o.cwd = function() { | |
return "/" | |
} | |
, | |
o.chdir = function(t) { | |
throw new Error("process.chdir is not supported") | |
} | |
, | |
o.umask = function() { | |
return 0 | |
} | |
} | |
, {}], | |
100: [function(t, r, n) { | |
(function(t) { | |
!function(e) { | |
var i = "object" == typeof n && n && !n.nodeType && n | |
, o = "object" == typeof r && r && !r.nodeType && r | |
, s = "object" == typeof t && t; | |
s.global !== s && s.window !== s && s.self !== s || (e = s); | |
var a, u, c = 2147483647, f = 36, l = 1, h = 26, p = 38, d = 700, y = 72, m = 128, g = "-", v = /^xn--/, b = /[^\x20-\x7E]/, w = /[\x2E\u3002\uFF0E\uFF61]/g, _ = { | |
overflow: "Overflow: input needs wider integers to process", | |
"not-basic": "Illegal input >= 0x80 (not a basic code point)", | |
"invalid-input": "Invalid input" | |
}, x = f - l, S = Math.floor, k = String.fromCharCode; | |
function E(t) { | |
throw new RangeError(_[t]) | |
} | |
function A(t, e) { | |
for (var r = t.length, n = []; r--; ) | |
n[r] = e(t[r]); | |
return n | |
} | |
function C(t, e) { | |
var r = t.split("@") | |
, n = ""; | |
return 1 < r.length && (n = r[0] + "@", | |
t = r[1]), | |
n + A((t = t.replace(w, ".")).split("."), e).join(".") | |
} | |
function T(t) { | |
for (var e, r, n = [], i = 0, o = t.length; i < o; ) | |
55296 <= (e = t.charCodeAt(i++)) && e <= 56319 && i < o ? 56320 == (64512 & (r = t.charCodeAt(i++))) ? n.push(((1023 & e) << 10) + (1023 & r) + 65536) : (n.push(e), | |
i--) : n.push(e); | |
return n | |
} | |
function O(t) { | |
return A(t, function(t) { | |
var e = ""; | |
return 65535 < t && (e += k((t -= 65536) >>> 10 & 1023 | 55296), | |
t = 56320 | 1023 & t), | |
e + k(t) | |
}).join("") | |
} | |
function B(t, e) { | |
return t + 22 + 75 * (t < 26) - ((0 != e) << 5) | |
} | |
function j(t, e, r) { | |
var n = 0; | |
for (t = r ? S(t / d) : t >> 1, | |
t += S(t / e); x * h >> 1 < t; n += f) | |
t = S(t / x); | |
return S(n + (x + 1) * t / (t + p)) | |
} | |
function R(t) { | |
var e, r, n, i, o, s, a, u, p, d, v, b = [], w = t.length, _ = 0, x = m, k = y; | |
for ((r = t.lastIndexOf(g)) < 0 && (r = 0), | |
n = 0; n < r; ++n) | |
128 <= t.charCodeAt(n) && E("not-basic"), | |
b.push(t.charCodeAt(n)); | |
for (i = 0 < r ? r + 1 : 0; i < w; ) { | |
for (o = _, | |
s = 1, | |
a = f; w <= i && E("invalid-input"), | |
v = t.charCodeAt(i++), | |
(f <= (u = v - 48 < 10 ? v - 22 : v - 65 < 26 ? v - 65 : v - 97 < 26 ? v - 97 : f) || u > S((c - _) / s)) && E("overflow"), | |
_ += u * s, | |
!(u < (p = a <= k ? l : k + h <= a ? h : a - k)); a += f) | |
s > S(c / (d = f - p)) && E("overflow"), | |
s *= d; | |
k = j(_ - o, e = b.length + 1, 0 == o), | |
S(_ / e) > c - x && E("overflow"), | |
x += S(_ / e), | |
_ %= e, | |
b.splice(_++, 0, x) | |
} | |
return O(b) | |
} | |
function M(t) { | |
var e, r, n, i, o, s, a, u, p, d, v, b, w, _, x, A = []; | |
for (b = (t = T(t)).length, | |
e = m, | |
o = y, | |
s = r = 0; s < b; ++s) | |
(v = t[s]) < 128 && A.push(k(v)); | |
for (n = i = A.length, | |
i && A.push(g); n < b; ) { | |
for (a = c, | |
s = 0; s < b; ++s) | |
e <= (v = t[s]) && v < a && (a = v); | |
for (a - e > S((c - r) / (w = n + 1)) && E("overflow"), | |
r += (a - e) * w, | |
e = a, | |
s = 0; s < b; ++s) | |
if ((v = t[s]) < e && ++r > c && E("overflow"), | |
v == e) { | |
for (u = r, | |
p = f; !(u < (d = p <= o ? l : o + h <= p ? h : p - o)); p += f) | |
x = u - d, | |
_ = f - d, | |
A.push(k(B(d + x % _, 0))), | |
u = S(x / _); | |
A.push(k(B(u, 0))), | |
o = j(r, w, n == i), | |
r = 0, | |
++n | |
} | |
++r, | |
++e | |
} | |
return A.join("") | |
} | |
if (a = { | |
version: "1.4.1", | |
ucs2: { | |
decode: T, | |
encode: O | |
}, | |
decode: R, | |
encode: M, | |
toASCII: function(t) { | |
return C(t, function(t) { | |
return b.test(t) ? "xn--" + M(t) : t | |
}) | |
}, | |
toUnicode: function(t) { | |
return C(t, function(t) { | |
return v.test(t) ? R(t.slice(4).toLowerCase()) : t | |
}) | |
} | |
}, | |
"function" == typeof define && "object" == typeof define.amd && define.amd) | |
define("punycode", function() { | |
return a | |
}); | |
else if (i && o) | |
if (r.exports == i) | |
o.exports = a; | |
else | |
for (u in a) | |
a.hasOwnProperty(u) && (i[u] = a[u]); | |
else | |
e.punycode = a | |
}(this) | |
} | |
).call(this, void 0 !== e ? e : "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}) | |
} | |
, {}], | |
101: [function(t, e, r) { | |
"use strict"; | |
e.exports = function(t, e, r, i) { | |
e = e || "&", | |
r = r || "="; | |
var o = {}; | |
if ("string" != typeof t || 0 === t.length) | |
return o; | |
var s = /\+/g; | |
t = t.split(e); | |
var a = 1e3; | |
i && "number" == typeof i.maxKeys && (a = i.maxKeys); | |
var u, c, f = t.length; | |
0 < a && a < f && (f = a); | |
for (var l = 0; l < f; ++l) { | |
var h, p, d, y, m = t[l].replace(s, "%20"), g = m.indexOf(r); | |
0 <= g ? (h = m.substr(0, g), | |
p = m.substr(g + 1)) : (h = m, | |
p = ""), | |
d = decodeURIComponent(h), | |
y = decodeURIComponent(p), | |
u = o, | |
c = d, | |
Object.prototype.hasOwnProperty.call(u, c) ? n(o[d]) ? o[d].push(y) : o[d] = [o[d], y] : o[d] = y | |
} | |
return o | |
} | |
; | |
var n = Array.isArray || function(t) { | |
return "[object Array]" === Object.prototype.toString.call(t) | |
} | |
} | |
, {}], | |
102: [function(t, e, r) { | |
"use strict"; | |
var n = function(t) { | |
switch (typeof t) { | |
case "string": | |
return t; | |
case "boolean": | |
return t ? "true" : "false"; | |
case "number": | |
return isFinite(t) ? t : ""; | |
default: | |
return "" | |
} | |
}; | |
e.exports = function(t, e, r, a) { | |
return e = e || "&", | |
r = r || "=", | |
null === t && (t = void 0), | |
"object" == typeof t ? o(s(t), function(s) { | |
var a = encodeURIComponent(n(s)) + r; | |
return i(t[s]) ? o(t[s], function(t) { | |
return a + encodeURIComponent(n(t)) | |
}).join(e) : a + encodeURIComponent(n(t[s])) | |
}).join(e) : a ? encodeURIComponent(n(a)) + r + encodeURIComponent(n(t)) : "" | |
} | |
; | |
var i = Array.isArray || function(t) { | |
return "[object Array]" === Object.prototype.toString.call(t) | |
} | |
; | |
function o(t, e) { | |
if (t.map) | |
return t.map(e); | |
for (var r = [], n = 0; n < t.length; n++) | |
r.push(e(t[n], n)); | |
return r | |
} | |
var s = Object.keys || function(t) { | |
var e = []; | |
for (var r in t) | |
Object.prototype.hasOwnProperty.call(t, r) && e.push(r); | |
return e | |
} | |
} | |
, {}], | |
103: [function(t, e, r) { | |
"use strict"; | |
r.decode = r.parse = t("./decode"), | |
r.encode = r.stringify = t("./encode") | |
} | |
, { | |
"./decode": 101, | |
"./encode": 102 | |
}], | |
104: [function(t, e, r) { | |
"use strict"; | |
var n = t("process-nextick-args") | |
, i = Object.keys || function(t) { | |
var e = []; | |
for (var r in t) | |
e.push(r); | |
return e | |
} | |
; | |
e.exports = l; | |
var o = t("core-util-is"); | |
o.inherits = t("inherits"); | |
var s = t("./_stream_readable") | |
, a = t("./_stream_writable"); | |
o.inherits(l, s); | |
for (var u = i(a.prototype), c = 0; c < u.length; c++) { | |
var f = u[c]; | |
l.prototype[f] || (l.prototype[f] = a.prototype[f]) | |
} | |
function l(t) { | |
if (!(this instanceof l)) | |
return new l(t); | |
s.call(this, t), | |
a.call(this, t), | |
t && !1 === t.readable && (this.readable = !1), | |
t && !1 === t.writable && (this.writable = !1), | |
this.allowHalfOpen = !0, | |
t && !1 === t.allowHalfOpen && (this.allowHalfOpen = !1), | |
this.once("end", h) | |
} | |
function h() { | |
this.allowHalfOpen || this._writableState.ended || n.nextTick(p, this) | |
} | |
function p(t) { | |
t.end() | |
} | |
Object.defineProperty(l.prototype, "writableHighWaterMark", { | |
enumerable: !1, | |
get: function() { | |
return this._writableState.highWaterMark | |
} | |
}), | |
Object.defineProperty(l.prototype, "destroyed", { | |
get: function() { | |
return void 0 !== this._readableState && void 0 !== this._writableState && this._readableState.destroyed && this._writableState.destroyed | |
}, | |
set: function(t) { | |
void 0 !== this._readableState && void 0 !== this._writableState && (this._readableState.destroyed = t, | |
this._writableState.destroyed = t) | |
} | |
}), | |
l.prototype._destroy = function(t, e) { | |
this.push(null), | |
this.end(), | |
n.nextTick(e, t) | |
} | |
} | |
, { | |
"./_stream_readable": 106, | |
"./_stream_writable": 108, | |
"core-util-is": 56, | |
inherits: 94, | |
"process-nextick-args": 98 | |
}], | |
105: [function(t, e, r) { | |
"use strict"; | |
e.exports = o; | |
var n = t("./_stream_transform") | |
, i = t("core-util-is"); | |
function o(t) { | |
if (!(this instanceof o)) | |
return new o(t); | |
n.call(this, t) | |
} | |
i.inherits = t("inherits"), | |
i.inherits(o, n), | |
o.prototype._transform = function(t, e, r) { | |
r(null, t) | |
} | |
} | |
, { | |
"./_stream_transform": 107, | |
"core-util-is": 56, | |
inherits: 94 | |
}], | |
106: [function(t, r, n) { | |
(function(e, n) { | |
"use strict"; | |
var i = t("process-nextick-args"); | |
r.exports = b; | |
var o, s = t("isarray"); | |
b.ReadableState = v, | |
t("events").EventEmitter; | |
var a = function(t, e) { | |
return t.listeners(e).length | |
} | |
, u = t("./internal/streams/stream") | |
, c = t("safe-buffer").Buffer | |
, f = n.Uint8Array || function() {} | |
, l = t("core-util-is"); | |
l.inherits = t("inherits"); | |
var h = t("util") | |
, p = void 0; | |
p = h && h.debuglog ? h.debuglog("stream") : function() {} | |
; | |
var d, y = t("./internal/streams/BufferList"), m = t("./internal/streams/destroy"); | |
l.inherits(b, u); | |
var g = ["error", "close", "destroy", "pause", "resume"]; | |
function v(e, r) { | |
e = e || {}; | |
var n = r instanceof (o = o || t("./_stream_duplex")); | |
this.objectMode = !!e.objectMode, | |
n && (this.objectMode = this.objectMode || !!e.readableObjectMode); | |
var i = e.highWaterMark | |
, s = e.readableHighWaterMark | |
, a = this.objectMode ? 16 : 16384; | |
this.highWaterMark = i || 0 === i ? i : n && (s || 0 === s) ? s : a, | |
this.highWaterMark = Math.floor(this.highWaterMark), | |
this.buffer = new y, | |
this.length = 0, | |
this.pipes = null, | |
this.pipesCount = 0, | |
this.flowing = null, | |
this.ended = !1, | |
this.endEmitted = !1, | |
this.reading = !1, | |
this.sync = !0, | |
this.needReadable = !1, | |
this.emittedReadable = !1, | |
this.readableListening = !1, | |
this.resumeScheduled = !1, | |
this.destroyed = !1, | |
this.defaultEncoding = e.defaultEncoding || "utf8", | |
this.awaitDrain = 0, | |
this.readingMore = !1, | |
this.decoder = null, | |
this.encoding = null, | |
e.encoding && (d || (d = t("string_decoder/").StringDecoder), | |
this.decoder = new d(e.encoding), | |
this.encoding = e.encoding) | |
} | |
function b(e) { | |
if (o = o || t("./_stream_duplex"), | |
!(this instanceof b)) | |
return new b(e); | |
this._readableState = new v(e,this), | |
this.readable = !0, | |
e && ("function" == typeof e.read && (this._read = e.read), | |
"function" == typeof e.destroy && (this._destroy = e.destroy)), | |
u.call(this) | |
} | |
function w(t, e, r, n, i) { | |
var o, s, a, u = t._readableState; | |
return null === e ? (u.reading = !1, | |
function(t, e) { | |
if (!e.ended) { | |
if (e.decoder) { | |
var r = e.decoder.end(); | |
r && r.length && (e.buffer.push(r), | |
e.length += e.objectMode ? 1 : r.length) | |
} | |
e.ended = !0, | |
k(t) | |
} | |
}(t, u)) : (i || (o = function(t, e) { | |
var r, n; | |
return n = e, | |
c.isBuffer(n) || n instanceof f || "string" == typeof e || void 0 === e || t.objectMode || (r = new TypeError("Invalid non-string/buffer chunk")), | |
r | |
}(u, e)), | |
o ? t.emit("error", o) : u.objectMode || e && 0 < e.length ? ("string" == typeof e || u.objectMode || Object.getPrototypeOf(e) === c.prototype || (s = e, | |
e = c.from(s)), | |
n ? u.endEmitted ? t.emit("error", new Error("stream.unshift() after end event")) : _(t, u, e, !0) : u.ended ? t.emit("error", new Error("stream.push() after EOF")) : (u.reading = !1, | |
u.decoder && !r ? (e = u.decoder.write(e), | |
u.objectMode || 0 !== e.length ? _(t, u, e, !1) : A(t, u)) : _(t, u, e, !1))) : n || (u.reading = !1)), | |
!(a = u).ended && (a.needReadable || a.length < a.highWaterMark || 0 === a.length) | |
} | |
function _(t, e, r, n) { | |
e.flowing && 0 === e.length && !e.sync ? (t.emit("data", r), | |
t.read(0)) : (e.length += e.objectMode ? 1 : r.length, | |
n ? e.buffer.unshift(r) : e.buffer.push(r), | |
e.needReadable && k(t)), | |
A(t, e) | |
} | |
Object.defineProperty(b.prototype, "destroyed", { | |
get: function() { | |
return void 0 !== this._readableState && this._readableState.destroyed | |
}, | |
set: function(t) { | |
this._readableState && (this._readableState.destroyed = t) | |
} | |
}), | |
b.prototype.destroy = m.destroy, | |
b.prototype._undestroy = m.undestroy, | |
b.prototype._destroy = function(t, e) { | |
this.push(null), | |
e(t) | |
} | |
, | |
b.prototype.push = function(t, e) { | |
var r, n = this._readableState; | |
return n.objectMode ? r = !0 : "string" == typeof t && ((e = e || n.defaultEncoding) !== n.encoding && (t = c.from(t, e), | |
e = ""), | |
r = !0), | |
w(this, t, e, !1, r) | |
} | |
, | |
b.prototype.unshift = function(t) { | |
return w(this, t, null, !0, !1) | |
} | |
, | |
b.prototype.isPaused = function() { | |
return !1 === this._readableState.flowing | |
} | |
, | |
b.prototype.setEncoding = function(e) { | |
return d || (d = t("string_decoder/").StringDecoder), | |
this._readableState.decoder = new d(e), | |
this._readableState.encoding = e, | |
this | |
} | |
; | |
var x = 8388608; | |
function S(t, e) { | |
return t <= 0 || 0 === e.length && e.ended ? 0 : e.objectMode ? 1 : t != t ? e.flowing && e.length ? e.buffer.head.data.length : e.length : (t > e.highWaterMark && (e.highWaterMark = (x <= (r = t) ? r = x : (r--, | |
r |= r >>> 1, | |
r |= r >>> 2, | |
r |= r >>> 4, | |
r |= r >>> 8, | |
r |= r >>> 16, | |
r++), | |
r)), | |
t <= e.length ? t : e.ended ? e.length : (e.needReadable = !0, | |
0)); | |
var r | |
} | |
function k(t) { | |
var e = t._readableState; | |
e.needReadable = !1, | |
e.emittedReadable || (p("emitReadable", e.flowing), | |
e.emittedReadable = !0, | |
e.sync ? i.nextTick(E, t) : E(t)) | |
} | |
function E(t) { | |
p("emit readable"), | |
t.emit("readable"), | |
B(t) | |
} | |
function A(t, e) { | |
e.readingMore || (e.readingMore = !0, | |
i.nextTick(C, t, e)) | |
} | |
function C(t, e) { | |
for (var r = e.length; !e.reading && !e.flowing && !e.ended && e.length < e.highWaterMark && (p("maybeReadMore read 0"), | |
t.read(0), | |
r !== e.length); ) | |
r = e.length; | |
e.readingMore = !1 | |
} | |
function T(t) { | |
p("readable nexttick read 0"), | |
t.read(0) | |
} | |
function O(t, e) { | |
e.reading || (p("resume read 0"), | |
t.read(0)), | |
e.resumeScheduled = !1, | |
e.awaitDrain = 0, | |
t.emit("resume"), | |
B(t), | |
e.flowing && !e.reading && t.read(0) | |
} | |
function B(t) { | |
var e = t._readableState; | |
for (p("flow", e.flowing); e.flowing && null !== t.read(); ) | |
; | |
} | |
function j(t, e) { | |
return 0 === e.length ? null : (e.objectMode ? r = e.buffer.shift() : !t || t >= e.length ? (r = e.decoder ? e.buffer.join("") : 1 === e.buffer.length ? e.buffer.head.data : e.buffer.concat(e.length), | |
e.buffer.clear()) : r = function(t, e, r) { | |
var n; | |
return t < e.head.data.length ? (n = e.head.data.slice(0, t), | |
e.head.data = e.head.data.slice(t)) : n = t === e.head.data.length ? e.shift() : r ? function(t, e) { | |
var r = e.head | |
, n = 1 | |
, i = r.data; | |
for (t -= i.length; r = r.next; ) { | |
var o = r.data | |
, s = t > o.length ? o.length : t; | |
if (s === o.length ? i += o : i += o.slice(0, t), | |
0 == (t -= s)) { | |
s === o.length ? (++n, | |
r.next ? e.head = r.next : e.head = e.tail = null) : (e.head = r).data = o.slice(s); | |
break | |
} | |
++n | |
} | |
return e.length -= n, | |
i | |
}(t, e) : function(t, e) { | |
var r = c.allocUnsafe(t) | |
, n = e.head | |
, i = 1; | |
for (n.data.copy(r), | |
t -= n.data.length; n = n.next; ) { | |
var o = n.data | |
, s = t > o.length ? o.length : t; | |
if (o.copy(r, r.length - t, 0, s), | |
0 == (t -= s)) { | |
s === o.length ? (++i, | |
n.next ? e.head = n.next : e.head = e.tail = null) : (e.head = n).data = o.slice(s); | |
break | |
} | |
++i | |
} | |
return e.length -= i, | |
r | |
}(t, e), | |
n | |
}(t, e.buffer, e.decoder), | |
r); | |
var r | |
} | |
function R(t) { | |
var e = t._readableState; | |
if (0 < e.length) | |
throw new Error('"endReadable()" called on non-empty stream'); | |
e.endEmitted || (e.ended = !0, | |
i.nextTick(M, e, t)) | |
} | |
function M(t, e) { | |
t.endEmitted || 0 !== t.length || (t.endEmitted = !0, | |
e.readable = !1, | |
e.emit("end")) | |
} | |
function L(t, e) { | |
for (var r = 0, n = t.length; r < n; r++) | |
if (t[r] === e) | |
return r; | |
return -1 | |
} | |
b.prototype.read = function(t) { | |
p("read", t), | |
t = parseInt(t, 10); | |
var e = this._readableState | |
, r = t; | |
if (0 !== t && (e.emittedReadable = !1), | |
0 === t && e.needReadable && (e.length >= e.highWaterMark || e.ended)) | |
return p("read: emitReadable", e.length, e.ended), | |
0 === e.length && e.ended ? R(this) : k(this), | |
null; | |
if (0 === (t = S(t, e)) && e.ended) | |
return 0 === e.length && R(this), | |
null; | |
var n, i = e.needReadable; | |
return p("need readable", i), | |
(0 === e.length || e.length - t < e.highWaterMark) && p("length less than watermark", i = !0), | |
e.ended || e.reading ? p("reading or ended", i = !1) : i && (p("do read"), | |
e.reading = !0, | |
e.sync = !0, | |
0 === e.length && (e.needReadable = !0), | |
this._read(e.highWaterMark), | |
e.sync = !1, | |
e.reading || (t = S(r, e))), | |
null === (n = 0 < t ? j(t, e) : null) ? (e.needReadable = !0, | |
t = 0) : e.length -= t, | |
0 === e.length && (e.ended || (e.needReadable = !0), | |
r !== t && e.ended && R(this)), | |
null !== n && this.emit("data", n), | |
n | |
} | |
, | |
b.prototype._read = function(t) { | |
this.emit("error", new Error("_read() is not implemented")) | |
} | |
, | |
b.prototype.pipe = function(t, r) { | |
var n = this | |
, o = this._readableState; | |
switch (o.pipesCount) { | |
case 0: | |
o.pipes = t; | |
break; | |
case 1: | |
o.pipes = [o.pipes, t]; | |
break; | |
default: | |
o.pipes.push(t) | |
} | |
o.pipesCount += 1, | |
p("pipe count=%d opts=%j", o.pipesCount, r); | |
var u = r && !1 === r.end || t === e.stdout || t === e.stderr ? b : c; | |
function c() { | |
p("onend"), | |
t.end() | |
} | |
o.endEmitted ? i.nextTick(u) : n.once("end", u), | |
t.on("unpipe", function e(r, i) { | |
p("onunpipe"), | |
r === n && i && !1 === i.hasUnpiped && (i.hasUnpiped = !0, | |
p("cleanup"), | |
t.removeListener("close", g), | |
t.removeListener("finish", v), | |
t.removeListener("drain", l), | |
t.removeListener("error", m), | |
t.removeListener("unpipe", e), | |
n.removeListener("end", c), | |
n.removeListener("end", b), | |
n.removeListener("data", y), | |
h = !0, | |
!o.awaitDrain || t._writableState && !t._writableState.needDrain || l()) | |
}); | |
var f, l = (f = n, | |
function() { | |
var t = f._readableState; | |
p("pipeOnDrain", t.awaitDrain), | |
t.awaitDrain && t.awaitDrain--, | |
0 === t.awaitDrain && a(f, "data") && (t.flowing = !0, | |
B(f)) | |
} | |
); | |
t.on("drain", l); | |
var h = !1 | |
, d = !1; | |
function y(e) { | |
p("ondata"), | |
(d = !1) !== t.write(e) || d || ((1 === o.pipesCount && o.pipes === t || 1 < o.pipesCount && -1 !== L(o.pipes, t)) && !h && (p("false write response, pause", n._readableState.awaitDrain), | |
n._readableState.awaitDrain++, | |
d = !0), | |
n.pause()) | |
} | |
function m(e) { | |
p("onerror", e), | |
b(), | |
t.removeListener("error", m), | |
0 === a(t, "error") && t.emit("error", e) | |
} | |
function g() { | |
t.removeListener("finish", v), | |
b() | |
} | |
function v() { | |
p("onfinish"), | |
t.removeListener("close", g), | |
b() | |
} | |
function b() { | |
p("unpipe"), | |
n.unpipe(t) | |
} | |
return n.on("data", y), | |
function(t, e, r) { | |
if ("function" == typeof t.prependListener) | |
return t.prependListener(e, r); | |
t._events && t._events[e] ? s(t._events[e]) ? t._events[e].unshift(r) : t._events[e] = [r, t._events[e]] : t.on(e, r) | |
}(t, "error", m), | |
t.once("close", g), | |
t.once("finish", v), | |
t.emit("pipe", n), | |
o.flowing || (p("pipe resume"), | |
n.resume()), | |
t | |
} | |
, | |
b.prototype.unpipe = function(t) { | |
var e = this._readableState | |
, r = { | |
hasUnpiped: !1 | |
}; | |
if (0 === e.pipesCount) | |
return this; | |
if (1 === e.pipesCount) | |
return t && t !== e.pipes || (t || (t = e.pipes), | |
e.pipes = null, | |
e.pipesCount = 0, | |
e.flowing = !1, | |
t && t.emit("unpipe", this, r)), | |
this; | |
if (!t) { | |
var n = e.pipes | |
, i = e.pipesCount; | |
e.pipes = null, | |
e.pipesCount = 0, | |
e.flowing = !1; | |
for (var o = 0; o < i; o++) | |
n[o].emit("unpipe", this, r); | |
return this | |
} | |
var s = L(e.pipes, t); | |
return -1 === s || (e.pipes.splice(s, 1), | |
e.pipesCount -= 1, | |
1 === e.pipesCount && (e.pipes = e.pipes[0]), | |
t.emit("unpipe", this, r)), | |
this | |
} | |
, | |
b.prototype.addListener = b.prototype.on = function(t, e) { | |
var r = u.prototype.on.call(this, t, e); | |
if ("data" === t) | |
!1 !== this._readableState.flowing && this.resume(); | |
else if ("readable" === t) { | |
var n = this._readableState; | |
n.endEmitted || n.readableListening || (n.readableListening = n.needReadable = !0, | |
n.emittedReadable = !1, | |
n.reading ? n.length && k(this) : i.nextTick(T, this)) | |
} | |
return r | |
} | |
, | |
b.prototype.resume = function() { | |
var t, e = this._readableState; | |
return e.flowing || (p("resume"), | |
e.flowing = !0, | |
this, | |
(t = e).resumeScheduled || (t.resumeScheduled = !0, | |
i.nextTick(O, this, t))), | |
this | |
} | |
, | |
b.prototype.pause = function() { | |
return p("call pause flowing=%j", this._readableState.flowing), | |
!1 !== this._readableState.flowing && (p("pause"), | |
this._readableState.flowing = !1, | |
this.emit("pause")), | |
this | |
} | |
, | |
b.prototype.wrap = function(t) { | |
var e = this | |
, r = this._readableState | |
, n = !1; | |
for (var i in t.on("end", function() { | |
if (p("wrapped end"), | |
r.decoder && !r.ended) { | |
var t = r.decoder.end(); | |
t && t.length && e.push(t) | |
} | |
e.push(null) | |
}), | |
t.on("data", function(i) { | |
p("wrapped data"), | |
r.decoder && (i = r.decoder.write(i)), | |
r.objectMode && null == i || (r.objectMode || i && i.length) && (e.push(i) || (n = !0, | |
t.pause())) | |
}), | |
t) | |
void 0 === this[i] && "function" == typeof t[i] && (this[i] = function(e) { | |
return function() { | |
return t[e].apply(t, arguments) | |
} | |
}(i)); | |
for (var o = 0; o < g.length; o++) | |
t.on(g[o], this.emit.bind(this, g[o])); | |
return this._read = function(e) { | |
p("wrapped _read", e), | |
n && (n = !1, | |
t.resume()) | |
} | |
, | |
this | |
} | |
, | |
Object.defineProperty(b.prototype, "readableHighWaterMark", { | |
enumerable: !1, | |
get: function() { | |
return this._readableState.highWaterMark | |
} | |
}), | |
b._fromList = j | |
} | |
).call(this, t("_process"), void 0 !== e ? e : "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}) | |
} | |
, { | |
"./_stream_duplex": 104, | |
"./internal/streams/BufferList": 109, | |
"./internal/streams/destroy": 110, | |
"./internal/streams/stream": 111, | |
_process: 99, | |
"core-util-is": 56, | |
events: 91, | |
inherits: 94, | |
isarray: 96, | |
"process-nextick-args": 98, | |
"safe-buffer": 113, | |
"string_decoder/": 118, | |
util: 51 | |
}], | |
107: [function(t, e, r) { | |
"use strict"; | |
e.exports = o; | |
var n = t("./_stream_duplex") | |
, i = t("core-util-is"); | |
function o(t) { | |
if (!(this instanceof o)) | |
return new o(t); | |
n.call(this, t), | |
this._transformState = { | |
afterTransform: function(t, e) { | |
var r = this._transformState; | |
r.transforming = !1; | |
var n = r.writecb; | |
if (!n) | |
return this.emit("error", new Error("write callback called multiple times")); | |
r.writechunk = null, | |
(r.writecb = null) != e && this.push(e), | |
n(t); | |
var i = this._readableState; | |
i.reading = !1, | |
(i.needReadable || i.length < i.highWaterMark) && this._read(i.highWaterMark) | |
} | |
.bind(this), | |
needTransform: !1, | |
transforming: !1, | |
writecb: null, | |
writechunk: null, | |
writeencoding: null | |
}, | |
this._readableState.needReadable = !0, | |
this._readableState.sync = !1, | |
t && ("function" == typeof t.transform && (this._transform = t.transform), | |
"function" == typeof t.flush && (this._flush = t.flush)), | |
this.on("prefinish", s) | |
} | |
function s() { | |
var t = this; | |
"function" == typeof this._flush ? this._flush(function(e, r) { | |
a(t, e, r) | |
}) : a(this, null, null) | |
} | |
function a(t, e, r) { | |
if (e) | |
return t.emit("error", e); | |
if (null != r && t.push(r), | |
t._writableState.length) | |
throw new Error("Calling transform done when ws.length != 0"); | |
if (t._transformState.transforming) | |
throw new Error("Calling transform done when still transforming"); | |
return t.push(null) | |
} | |
i.inherits = t("inherits"), | |
i.inherits(o, n), | |
o.prototype.push = function(t, e) { | |
return this._transformState.needTransform = !1, | |
n.prototype.push.call(this, t, e) | |
} | |
, | |
o.prototype._transform = function(t, e, r) { | |
throw new Error("_transform() is not implemented") | |
} | |
, | |
o.prototype._write = function(t, e, r) { | |
var n = this._transformState; | |
if (n.writecb = r, | |
n.writechunk = t, | |
n.writeencoding = e, | |
!n.transforming) { | |
var i = this._readableState; | |
(n.needTransform || i.needReadable || i.length < i.highWaterMark) && this._read(i.highWaterMark) | |
} | |
} | |
, | |
o.prototype._read = function(t) { | |
var e = this._transformState; | |
null !== e.writechunk && e.writecb && !e.transforming ? (e.transforming = !0, | |
this._transform(e.writechunk, e.writeencoding, e.afterTransform)) : e.needTransform = !0 | |
} | |
, | |
o.prototype._destroy = function(t, e) { | |
var r = this; | |
n.prototype._destroy.call(this, t, function(t) { | |
e(t), | |
r.emit("close") | |
}) | |
} | |
} | |
, { | |
"./_stream_duplex": 104, | |
"core-util-is": 56, | |
inherits: 94 | |
}], | |
108: [function(t, r, n) { | |
(function(e, n, i) { | |
"use strict"; | |
var o = t("process-nextick-args"); | |
function s(t) { | |
var e = this; | |
this.next = null, | |
this.entry = null, | |
this.finish = function() { | |
!function(t, e, r) { | |
var n = t.entry; | |
for (t.entry = null; n; ) { | |
var i = n.callback; | |
e.pendingcb--, | |
i(void 0), | |
n = n.next | |
} | |
e.corkedRequestsFree ? e.corkedRequestsFree.next = t : e.corkedRequestsFree = t | |
}(e, t) | |
} | |
} | |
r.exports = v; | |
var a, u = !e.browser && -1 < ["v0.10", "v0.9."].indexOf(e.version.slice(0, 5)) ? i : o.nextTick; | |
v.WritableState = g; | |
var c = t("core-util-is"); | |
c.inherits = t("inherits"); | |
var f, l = { | |
deprecate: t("util-deprecate") | |
}, h = t("./internal/streams/stream"), p = t("safe-buffer").Buffer, d = n.Uint8Array || function() {} | |
, y = t("./internal/streams/destroy"); | |
function m() {} | |
function g(e, r) { | |
a = a || t("./_stream_duplex"), | |
e = e || {}; | |
var n = r instanceof a; | |
this.objectMode = !!e.objectMode, | |
n && (this.objectMode = this.objectMode || !!e.writableObjectMode); | |
var i = e.highWaterMark | |
, c = e.writableHighWaterMark | |
, f = this.objectMode ? 16 : 16384; | |
this.highWaterMark = i || 0 === i ? i : n && (c || 0 === c) ? c : f, | |
this.highWaterMark = Math.floor(this.highWaterMark), | |
this.finalCalled = !1, | |
this.needDrain = !1, | |
this.ending = !1, | |
this.ended = !1, | |
this.finished = !1; | |
var l = (this.destroyed = !1) === e.decodeStrings; | |
this.decodeStrings = !l, | |
this.defaultEncoding = e.defaultEncoding || "utf8", | |
this.length = 0, | |
this.writing = !1, | |
this.corked = 0, | |
this.sync = !0, | |
this.bufferProcessing = !1, | |
this.onwrite = function(t) { | |
!function(t, e) { | |
var r, n, i, s, a, c, f = t._writableState, l = f.sync, h = f.writecb; | |
if ((c = f).writing = !1, | |
c.writecb = null, | |
c.length -= c.writelen, | |
c.writelen = 0, | |
e) | |
r = t, | |
i = l, | |
s = e, | |
a = h, | |
--(n = f).pendingcb, | |
i ? (o.nextTick(a, s), | |
o.nextTick(k, r, n), | |
r._writableState.errorEmitted = !0, | |
r.emit("error", s)) : (a(s), | |
r._writableState.errorEmitted = !0, | |
r.emit("error", s), | |
k(r, n)); | |
else { | |
var p = x(f); | |
p || f.corked || f.bufferProcessing || !f.bufferedRequest || _(t, f), | |
l ? u(w, t, f, p, h) : w(t, f, p, h) | |
} | |
}(r, t) | |
} | |
, | |
this.writecb = null, | |
this.writelen = 0, | |
this.bufferedRequest = null, | |
this.lastBufferedRequest = null, | |
this.pendingcb = 0, | |
this.prefinished = !1, | |
this.errorEmitted = !1, | |
this.bufferedRequestCount = 0, | |
this.corkedRequestsFree = new s(this) | |
} | |
function v(e) { | |
if (a = a || t("./_stream_duplex"), | |
!(f.call(v, this) || this instanceof a)) | |
return new v(e); | |
this._writableState = new g(e,this), | |
this.writable = !0, | |
e && ("function" == typeof e.write && (this._write = e.write), | |
"function" == typeof e.writev && (this._writev = e.writev), | |
"function" == typeof e.destroy && (this._destroy = e.destroy), | |
"function" == typeof e.final && (this._final = e.final)), | |
h.call(this) | |
} | |
function b(t, e, r, n, i, o, s) { | |
e.writelen = n, | |
e.writecb = s, | |
e.writing = !0, | |
e.sync = !0, | |
r ? t._writev(i, e.onwrite) : t._write(i, o, e.onwrite), | |
e.sync = !1 | |
} | |
function w(t, e, r, n) { | |
var i, o; | |
r || (i = t, | |
0 === (o = e).length && o.needDrain && (o.needDrain = !1, | |
i.emit("drain"))), | |
e.pendingcb--, | |
n(), | |
k(t, e) | |
} | |
function _(t, e) { | |
e.bufferProcessing = !0; | |
var r = e.bufferedRequest; | |
if (t._writev && r && r.next) { | |
var n = e.bufferedRequestCount | |
, i = new Array(n) | |
, o = e.corkedRequestsFree; | |
o.entry = r; | |
for (var a = 0, u = !0; r; ) | |
(i[a] = r).isBuf || (u = !1), | |
r = r.next, | |
a += 1; | |
i.allBuffers = u, | |
b(t, e, !0, e.length, i, "", o.finish), | |
e.pendingcb++, | |
e.lastBufferedRequest = null, | |
o.next ? (e.corkedRequestsFree = o.next, | |
o.next = null) : e.corkedRequestsFree = new s(e), | |
e.bufferedRequestCount = 0 | |
} else { | |
for (; r; ) { | |
var c = r.chunk | |
, f = r.encoding | |
, l = r.callback; | |
if (b(t, e, !1, e.objectMode ? 1 : c.length, c, f, l), | |
r = r.next, | |
e.bufferedRequestCount--, | |
e.writing) | |
break | |
} | |
null === r && (e.lastBufferedRequest = null) | |
} | |
e.bufferedRequest = r, | |
e.bufferProcessing = !1 | |
} | |
function x(t) { | |
return t.ending && 0 === t.length && null === t.bufferedRequest && !t.finished && !t.writing | |
} | |
function S(t, e) { | |
t._final(function(r) { | |
e.pendingcb--, | |
r && t.emit("error", r), | |
e.prefinished = !0, | |
t.emit("prefinish"), | |
k(t, e) | |
}) | |
} | |
function k(t, e) { | |
var r, n, i = x(e); | |
return i && (r = t, | |
(n = e).prefinished || n.finalCalled || ("function" == typeof r._final ? (n.pendingcb++, | |
n.finalCalled = !0, | |
o.nextTick(S, r, n)) : (n.prefinished = !0, | |
r.emit("prefinish"))), | |
0 === e.pendingcb && (e.finished = !0, | |
t.emit("finish"))), | |
i | |
} | |
c.inherits(v, h), | |
g.prototype.getBuffer = function() { | |
for (var t = this.bufferedRequest, e = []; t; ) | |
e.push(t), | |
t = t.next; | |
return e | |
} | |
, | |
function() { | |
try { | |
Object.defineProperty(g.prototype, "buffer", { | |
get: l.deprecate(function() { | |
return this.getBuffer() | |
}, "_writableState.buffer is deprecated. Use _writableState.getBuffer instead.", "DEP0003") | |
}) | |
} catch (t) {} | |
}(), | |
"function" == typeof Symbol && Symbol.hasInstance && "function" == typeof Function.prototype[Symbol.hasInstance] ? (f = Function.prototype[Symbol.hasInstance], | |
Object.defineProperty(v, Symbol.hasInstance, { | |
value: function(t) { | |
return !!f.call(this, t) || this === v && t && t._writableState instanceof g | |
} | |
})) : f = function(t) { | |
return t instanceof this | |
} | |
, | |
v.prototype.pipe = function() { | |
this.emit("error", new Error("Cannot pipe, not readable")) | |
} | |
, | |
v.prototype.write = function(t, e, r) { | |
var n, i, s, a, u, c, f, l, h, y = this._writableState, g = !1, v = !y.objectMode && (n = t, | |
p.isBuffer(n) || n instanceof d); | |
return v && !p.isBuffer(t) && (i = t, | |
t = p.from(i)), | |
"function" == typeof e && (r = e, | |
e = null), | |
v ? e = "buffer" : e || (e = y.defaultEncoding), | |
"function" != typeof r && (r = m), | |
y.ended ? (this, | |
l = r, | |
h = new Error("write after end"), | |
this.emit("error", h), | |
o.nextTick(l, h)) : (v || (this, | |
s = y, | |
u = r, | |
f = !(c = !0), | |
null === (a = t) ? f = new TypeError("May not write null values to stream") : "string" == typeof a || void 0 === a || s.objectMode || (f = new TypeError("Invalid non-string/buffer chunk")), | |
f && (this.emit("error", f), | |
o.nextTick(u, f), | |
c = !1), | |
c)) && (y.pendingcb++, | |
g = function(t, e, r, n, i, o) { | |
if (!r) { | |
var s = function(t, e, r) { | |
return t.objectMode || !1 === t.decodeStrings || "string" != typeof e || (e = p.from(e, r)), | |
e | |
}(e, n, i); | |
n !== s && (r = !0, | |
i = "buffer", | |
n = s) | |
} | |
var a = e.objectMode ? 1 : n.length; | |
e.length += a; | |
var u = e.length < e.highWaterMark; | |
if (u || (e.needDrain = !0), | |
e.writing || e.corked) { | |
var c = e.lastBufferedRequest; | |
e.lastBufferedRequest = { | |
chunk: n, | |
encoding: i, | |
isBuf: r, | |
callback: o, | |
next: null | |
}, | |
c ? c.next = e.lastBufferedRequest : e.bufferedRequest = e.lastBufferedRequest, | |
e.bufferedRequestCount += 1 | |
} else | |
b(t, e, !1, a, n, i, o); | |
return u | |
}(this, y, v, t, e, r)), | |
g | |
} | |
, | |
v.prototype.cork = function() { | |
this._writableState.corked++ | |
} | |
, | |
v.prototype.uncork = function() { | |
var t = this._writableState; | |
t.corked && (t.corked--, | |
t.writing || t.corked || t.finished || t.bufferProcessing || !t.bufferedRequest || _(this, t)) | |
} | |
, | |
v.prototype.setDefaultEncoding = function(t) { | |
if ("string" == typeof t && (t = t.toLowerCase()), | |
!(-1 < ["hex", "utf8", "utf-8", "ascii", "binary", "base64", "ucs2", "ucs-2", "utf16le", "utf-16le", "raw"].indexOf((t + "").toLowerCase()))) | |
throw new TypeError("Unknown encoding: " + t); | |
return this._writableState.defaultEncoding = t, | |
this | |
} | |
, | |
Object.defineProperty(v.prototype, "writableHighWaterMark", { | |
enumerable: !1, | |
get: function() { | |
return this._writableState.highWaterMark | |
} | |
}), | |
v.prototype._write = function(t, e, r) { | |
r(new Error("_write() is not implemented")) | |
} | |
, | |
v.prototype._writev = null, | |
v.prototype.end = function(t, e, r) { | |
var n = this._writableState; | |
"function" == typeof t ? (r = t, | |
e = t = null) : "function" == typeof e && (r = e, | |
e = null), | |
null != t && this.write(t, e), | |
n.corked && (n.corked = 1, | |
this.uncork()), | |
n.ending || n.finished || function(t, e, r) { | |
e.ending = !0, | |
k(t, e), | |
r && (e.finished ? o.nextTick(r) : t.once("finish", r)), | |
e.ended = !0, | |
t.writable = !1 | |
}(this, n, r) | |
} | |
, | |
Object.defineProperty(v.prototype, "destroyed", { | |
get: function() { | |
return void 0 !== this._writableState && this._writableState.destroyed | |
}, | |
set: function(t) { | |
this._writableState && (this._writableState.destroyed = t) | |
} | |
}), | |
v.prototype.destroy = y.destroy, | |
v.prototype._undestroy = y.undestroy, | |
v.prototype._destroy = function(t, e) { | |
this.end(), | |
e(t) | |
} | |
} | |
).call(this, t("_process"), void 0 !== e ? e : "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}, t("timers").setImmediate) | |
} | |
, { | |
"./_stream_duplex": 104, | |
"./internal/streams/destroy": 110, | |
"./internal/streams/stream": 111, | |
_process: 99, | |
"core-util-is": 56, | |
inherits: 94, | |
"process-nextick-args": 98, | |
"safe-buffer": 113, | |
timers: 119, | |
"util-deprecate": 124 | |
}], | |
109: [function(t, e, r) { | |
"use strict"; | |
var n = t("safe-buffer").Buffer | |
, i = t("util"); | |
e.exports = function() { | |
function t() { | |
!function(t, e) { | |
if (!(t instanceof e)) | |
throw new TypeError("Cannot call a class as a function") | |
}(this, t), | |
this.head = null, | |
this.tail = null, | |
this.length = 0 | |
} | |
return t.prototype.push = function(t) { | |
var e = { | |
data: t, | |
next: null | |
}; | |
0 < this.length ? this.tail.next = e : this.head = e, | |
this.tail = e, | |
++this.length | |
} | |
, | |
t.prototype.unshift = function(t) { | |
var e = { | |
data: t, | |
next: this.head | |
}; | |
0 === this.length && (this.tail = e), | |
this.head = e, | |
++this.length | |
} | |
, | |
t.prototype.shift = function() { | |
if (0 !== this.length) { | |
var t = this.head.data; | |
return 1 === this.length ? this.head = this.tail = null : this.head = this.head.next, | |
--this.length, | |
t | |
} | |
} | |
, | |
t.prototype.clear = function() { | |
this.head = this.tail = null, | |
this.length = 0 | |
} | |
, | |
t.prototype.join = function(t) { | |
if (0 === this.length) | |
return ""; | |
for (var e = this.head, r = "" + e.data; e = e.next; ) | |
r += t + e.data; | |
return r | |
} | |
, | |
t.prototype.concat = function(t) { | |
if (0 === this.length) | |
return n.alloc(0); | |
if (1 === this.length) | |
return this.head.data; | |
for (var e, r, i = n.allocUnsafe(t >>> 0), o = this.head, s = 0; o; ) | |
e = i, | |
r = s, | |
o.data.copy(e, r), | |
s += o.data.length, | |
o = o.next; | |
return i | |
} | |
, | |
t | |
}(), | |
i && i.inspect && i.inspect.custom && (e.exports.prototype[i.inspect.custom] = function() { | |
var t = i.inspect({ | |
length: this.length | |
}); | |
return this.constructor.name + " " + t | |
} | |
) | |
} | |
, { | |
"safe-buffer": 113, | |
util: 51 | |
}], | |
110: [function(t, e, r) { | |
"use strict"; | |
var n = t("process-nextick-args"); | |
function i(t, e) { | |
t.emit("error", e) | |
} | |
e.exports = { | |
destroy: function(t, e) { | |
var r = this | |
, o = this._readableState && this._readableState.destroyed | |
, s = this._writableState && this._writableState.destroyed; | |
return o || s ? e ? e(t) : !t || this._writableState && this._writableState.errorEmitted || n.nextTick(i, this, t) : (this._readableState && (this._readableState.destroyed = !0), | |
this._writableState && (this._writableState.destroyed = !0), | |
this._destroy(t || null, function(t) { | |
!e && t ? (n.nextTick(i, r, t), | |
r._writableState && (r._writableState.errorEmitted = !0)) : e && e(t) | |
})), | |
this | |
}, | |
undestroy: function() { | |
this._readableState && (this._readableState.destroyed = !1, | |
this._readableState.reading = !1, | |
this._readableState.ended = !1, | |
this._readableState.endEmitted = !1), | |
this._writableState && (this._writableState.destroyed = !1, | |
this._writableState.ended = !1, | |
this._writableState.ending = !1, | |
this._writableState.finished = !1, | |
this._writableState.errorEmitted = !1) | |
} | |
} | |
} | |
, { | |
"process-nextick-args": 98 | |
}], | |
111: [function(t, e, r) { | |
e.exports = t("events").EventEmitter | |
} | |
, { | |
events: 91 | |
}], | |
112: [function(t, e, r) { | |
(((r = e.exports = t("./lib/_stream_readable.js")).Stream = r).Readable = r).Writable = t("./lib/_stream_writable.js"), | |
r.Duplex = t("./lib/_stream_duplex.js"), | |
r.Transform = t("./lib/_stream_transform.js"), | |
r.PassThrough = t("./lib/_stream_passthrough.js") | |
} | |
, { | |
"./lib/_stream_duplex.js": 104, | |
"./lib/_stream_passthrough.js": 105, | |
"./lib/_stream_readable.js": 106, | |
"./lib/_stream_transform.js": 107, | |
"./lib/_stream_writable.js": 108 | |
}], | |
113: [function(t, e, r) { | |
var n = t("buffer") | |
, i = n.Buffer; | |
function o(t, e) { | |
for (var r in t) | |
e[r] = t[r] | |
} | |
function s(t, e, r) { | |
return i(t, e, r) | |
} | |
i.from && i.alloc && i.allocUnsafe && i.allocUnsafeSlow ? e.exports = n : (o(n, r), | |
r.Buffer = s), | |
o(i, s), | |
s.from = function(t, e, r) { | |
if ("number" == typeof t) | |
throw new TypeError("Argument must not be a number"); | |
return i(t, e, r) | |
} | |
, | |
s.alloc = function(t, e, r) { | |
if ("number" != typeof t) | |
throw new TypeError("Argument must be a number"); | |
var n = i(t); | |
return void 0 !== e ? "string" == typeof r ? n.fill(e, r) : n.fill(e) : n.fill(0), | |
n | |
} | |
, | |
s.allocUnsafe = function(t) { | |
if ("number" != typeof t) | |
throw new TypeError("Argument must be a number"); | |
return i(t) | |
} | |
, | |
s.allocUnsafeSlow = function(t) { | |
if ("number" != typeof t) | |
throw new TypeError("Argument must be a number"); | |
return n.SlowBuffer(t) | |
} | |
} | |
, { | |
buffer: 53 | |
}], | |
114: [function(t, r, n) { | |
(function(e) { | |
var r = t("./lib/request") | |
, i = t("./lib/response") | |
, o = t("xtend") | |
, s = t("builtin-status-codes") | |
, a = t("url") | |
, u = n; | |
u.request = function(t, n) { | |
t = "string" == typeof t ? a.parse(t) : o(t); | |
var i = -1 === e.location.protocol.search(/^https?:$/) ? "http:" : "" | |
, s = t.protocol || i | |
, u = t.hostname || t.host | |
, c = t.port | |
, f = t.path || "/"; | |
u && -1 !== u.indexOf(":") && (u = "[" + u + "]"), | |
t.url = (u ? s + "//" + u : "") + (c ? ":" + c : "") + f, | |
t.method = (t.method || "GET").toUpperCase(), | |
t.headers = t.headers || {}; | |
var l = new r(t); | |
return n && l.on("response", n), | |
l | |
} | |
, | |
u.get = function(t, e) { | |
var r = u.request(t, e); | |
return r.end(), | |
r | |
} | |
, | |
u.ClientRequest = r, | |
u.IncomingMessage = i.IncomingMessage, | |
u.Agent = function() {} | |
, | |
u.Agent.defaultMaxSockets = 4, | |
u.globalAgent = new u.Agent, | |
u.STATUS_CODES = s, | |
u.METHODS = ["CHECKOUT", "CONNECT", "COPY", "DELETE", "GET", "HEAD", "LOCK", "M-SEARCH", "MERGE", "MKACTIVITY", "MKCOL", "MOVE", "NOTIFY", "OPTIONS", "PATCH", "POST", "PROPFIND", "PROPPATCH", "PURGE", "PUT", "REPORT", "SEARCH", "SUBSCRIBE", "TRACE", "UNLOCK", "UNSUBSCRIBE"] | |
} | |
).call(this, void 0 !== e ? e : "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}) | |
} | |
, { | |
"./lib/request": 116, | |
"./lib/response": 117, | |
"builtin-status-codes": 54, | |
url: 121, | |
xtend: 131 | |
}], | |
115: [function(t, r, n) { | |
(function(t) { | |
n.fetch = a(t.fetch) && a(t.ReadableStream), | |
n.writableStream = a(t.WritableStream), | |
n.abortController = a(t.AbortController), | |
n.blobConstructor = !1; | |
try { | |
new Blob([new ArrayBuffer(1)]), | |
n.blobConstructor = !0 | |
} catch (t) {} | |
var e; | |
function r() { | |
if (void 0 !== e) | |
return e; | |
if (t.XMLHttpRequest) { | |
e = new t.XMLHttpRequest; | |
try { | |
e.open("GET", t.XDomainRequest ? "/" : "https://example.com") | |
} catch (t) { | |
e = null | |
} | |
} else | |
e = null; | |
return e | |
} | |
function i(t) { | |
var e = r(); | |
if (!e) | |
return !1; | |
try { | |
return e.responseType = t, | |
e.responseType === t | |
} catch (t) {} | |
return !1 | |
} | |
var o = void 0 !== t.ArrayBuffer | |
, s = o && a(t.ArrayBuffer.prototype.slice); | |
function a(t) { | |
return "function" == typeof t | |
} | |
n.arraybuffer = n.fetch || o && i("arraybuffer"), | |
n.msstream = !n.fetch && s && i("ms-stream"), | |
n.mozchunkedarraybuffer = !n.fetch && o && i("moz-chunked-arraybuffer"), | |
n.overrideMimeType = n.fetch || !!r() && a(r().overrideMimeType), | |
n.vbArray = a(t.VBArray), | |
e = null | |
} | |
).call(this, void 0 !== e ? e : "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}) | |
} | |
, {}], | |
116: [function(t, r, n) { | |
(function(e, n, i) { | |
var o = t("./capability") | |
, s = t("inherits") | |
, a = t("./response") | |
, u = t("readable-stream") | |
, c = t("to-arraybuffer") | |
, f = a.IncomingMessage | |
, l = a.readyStates | |
, h = r.exports = function(t) { | |
var e, r = this; | |
u.Writable.call(r), | |
r._opts = t, | |
r._body = [], | |
r._headers = {}, | |
t.auth && r.setHeader("Authorization", "Basic " + new i(t.auth).toString("base64")), | |
Object.keys(t.headers).forEach(function(e) { | |
r.setHeader(e, t.headers[e]) | |
}); | |
var n, s, a = !0; | |
if ("disable-fetch" === t.mode || "requestTimeout"in t && !o.abortController) | |
e = !(a = !1); | |
else if ("prefer-streaming" === t.mode) | |
e = !1; | |
else if ("allow-wrong-content-type" === t.mode) | |
e = !o.overrideMimeType; | |
else { | |
if (t.mode && "default" !== t.mode && "prefer-fast" !== t.mode) | |
throw new Error("Invalid value for opts.mode"); | |
e = !0 | |
} | |
r._mode = (n = e, | |
s = a, | |
o.fetch && s ? "fetch" : o.mozchunkedarraybuffer ? "moz-chunked-arraybuffer" : o.msstream ? "ms-stream" : o.arraybuffer && n ? "arraybuffer" : o.vbArray && n ? "text:vbarray" : "text"), | |
r._fetchTimer = null, | |
r.on("finish", function() { | |
r._onFinish() | |
}) | |
} | |
; | |
s(h, u.Writable), | |
h.prototype.setHeader = function(t, e) { | |
var r = t.toLowerCase(); | |
-1 === p.indexOf(r) && (this._headers[r] = { | |
name: t, | |
value: e | |
}) | |
} | |
, | |
h.prototype.getHeader = function(t) { | |
var e = this._headers[t.toLowerCase()]; | |
return e ? e.value : null | |
} | |
, | |
h.prototype.removeHeader = function(t) { | |
delete this._headers[t.toLowerCase()] | |
} | |
, | |
h.prototype._onFinish = function() { | |
var t = this; | |
if (!t._destroyed) { | |
var r = t._opts | |
, s = t._headers | |
, a = null; | |
"GET" !== r.method && "HEAD" !== r.method && (a = o.arraybuffer ? c(i.concat(t._body)) : o.blobConstructor ? new n.Blob(t._body.map(function(t) { | |
return c(t) | |
}),{ | |
type: (s["content-type"] || {}).value || "" | |
}) : i.concat(t._body).toString()); | |
var u = []; | |
if (Object.keys(s).forEach(function(t) { | |
var e = s[t].name | |
, r = s[t].value; | |
Array.isArray(r) ? r.forEach(function(t) { | |
u.push([e, t]) | |
}) : u.push([e, r]) | |
}), | |
"fetch" === t._mode) { | |
var f = null; | |
if (o.abortController) { | |
var h = new AbortController; | |
f = h.signal, | |
t._fetchAbortController = h, | |
"requestTimeout"in r && 0 !== r.requestTimeout && (t._fetchTimer = n.setTimeout(function() { | |
t.emit("requestTimeout"), | |
t._fetchAbortController && t._fetchAbortController.abort() | |
}, r.requestTimeout)) | |
} | |
n.fetch(t._opts.url, { | |
method: t._opts.method, | |
headers: u, | |
body: a || void 0, | |
mode: "cors", | |
credentials: r.withCredentials ? "include" : "same-origin", | |
signal: f | |
}).then(function(e) { | |
t._fetchResponse = e, | |
t._connect() | |
}, function(e) { | |
n.clearTimeout(t._fetchTimer), | |
t._destroyed || t.emit("error", e) | |
}) | |
} else { | |
var p = t._xhr = new n.XMLHttpRequest; | |
try { | |
p.open(t._opts.method, t._opts.url, !0) | |
} catch (r) { | |
return void e.nextTick(function() { | |
t.emit("error", r) | |
}) | |
} | |
"responseType"in p && (p.responseType = t._mode.split(":")[0]), | |
"withCredentials"in p && (p.withCredentials = !!r.withCredentials), | |
"text" === t._mode && "overrideMimeType"in p && p.overrideMimeType("text/plain; charset=x-user-defined"), | |
"requestTimeout"in r && (p.timeout = r.requestTimeout, | |
p.ontimeout = function() { | |
t.emit("requestTimeout") | |
} | |
), | |
u.forEach(function(t) { | |
p.setRequestHeader(t[0], t[1]) | |
}), | |
t._response = null, | |
p.onreadystatechange = function() { | |
switch (p.readyState) { | |
case l.LOADING: | |
case l.DONE: | |
t._onXHRProgress() | |
} | |
} | |
, | |
"moz-chunked-arraybuffer" === t._mode && (p.onprogress = function() { | |
t._onXHRProgress() | |
} | |
), | |
p.onerror = function() { | |
t._destroyed || t.emit("error", new Error("XHR error")) | |
} | |
; | |
try { | |
p.send(a) | |
} catch (r) { | |
return void e.nextTick(function() { | |
t.emit("error", r) | |
}) | |
} | |
} | |
} | |
} | |
, | |
h.prototype._onXHRProgress = function() { | |
(function(t) { | |
try { | |
var e = t.status; | |
return null !== e && 0 !== e | |
} catch (t) { | |
return !1 | |
} | |
} | |
)(this._xhr) && !this._destroyed && (this._response || this._connect(), | |
this._response._onXHRProgress()) | |
} | |
, | |
h.prototype._connect = function() { | |
var t = this; | |
t._destroyed || (t._response = new f(t._xhr,t._fetchResponse,t._mode,t._fetchTimer), | |
t._response.on("error", function(e) { | |
t.emit("error", e) | |
}), | |
t.emit("response", t._response)) | |
} | |
, | |
h.prototype._write = function(t, e, r) { | |
this._body.push(t), | |
r() | |
} | |
, | |
h.prototype.abort = h.prototype.destroy = function() { | |
this._destroyed = !0, | |
n.clearTimeout(this._fetchTimer), | |
this._response && (this._response._destroyed = !0), | |
this._xhr ? this._xhr.abort() : this._fetchAbortController && this._fetchAbortController.abort() | |
} | |
, | |
h.prototype.end = function(t, e, r) { | |
"function" == typeof t && (r = t, | |
t = void 0), | |
u.Writable.prototype.end.call(this, t, e, r) | |
} | |
, | |
h.prototype.flushHeaders = function() {} | |
, | |
h.prototype.setTimeout = function() {} | |
, | |
h.prototype.setNoDelay = function() {} | |
, | |
h.prototype.setSocketKeepAlive = function() {} | |
; | |
var p = ["accept-charset", "accept-encoding", "access-control-request-headers", "access-control-request-method", "connection", "content-length", "cookie", "cookie2", "date", "dnt", "expect", "host", "keep-alive", "origin", "referer", "te", "trailer", "transfer-encoding", "upgrade", "via"] | |
} | |
).call(this, t("_process"), void 0 !== e ? e : "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}, t("buffer").Buffer) | |
} | |
, { | |
"./capability": 115, | |
"./response": 117, | |
_process: 99, | |
buffer: 53, | |
inherits: 94, | |
"readable-stream": 112, | |
"to-arraybuffer": 120 | |
}], | |
117: [function(t, r, n) { | |
(function(e, r, i) { | |
var o = t("./capability") | |
, s = t("inherits") | |
, a = t("readable-stream") | |
, u = n.readyStates = { | |
UNSENT: 0, | |
OPENED: 1, | |
HEADERS_RECEIVED: 2, | |
LOADING: 3, | |
DONE: 4 | |
} | |
, c = n.IncomingMessage = function(t, n, s, u) { | |
var c = this; | |
if (a.Readable.call(c), | |
c._mode = s, | |
c.headers = {}, | |
c.rawHeaders = [], | |
c.trailers = {}, | |
c.rawTrailers = [], | |
c.on("end", function() { | |
e.nextTick(function() { | |
c.emit("close") | |
}) | |
}), | |
"fetch" === s) { | |
if (c._fetchResponse = n, | |
c.url = n.url, | |
c.statusCode = n.status, | |
c.statusMessage = n.statusText, | |
n.headers.forEach(function(t, e) { | |
c.headers[e.toLowerCase()] = t, | |
c.rawHeaders.push(e, t) | |
}), | |
o.writableStream) { | |
var f = new WritableStream({ | |
write: function(t) { | |
return new Promise(function(e, r) { | |
c._destroyed ? r() : c.push(new i(t)) ? e() : c._resumeFetch = e | |
} | |
) | |
}, | |
close: function() { | |
r.clearTimeout(u), | |
c._destroyed || c.push(null) | |
}, | |
abort: function(t) { | |
c._destroyed || c.emit("error", t) | |
} | |
}); | |
try { | |
return void n.body.pipeTo(f).catch(function(t) { | |
r.clearTimeout(u), | |
c._destroyed || c.emit("error", t) | |
}) | |
} catch (t) {} | |
} | |
var l = n.body.getReader(); | |
!function t() { | |
l.read().then(function(e) { | |
if (!c._destroyed) { | |
if (e.done) | |
return r.clearTimeout(u), | |
void c.push(null); | |
c.push(new i(e.value)), | |
t() | |
} | |
}).catch(function(t) { | |
r.clearTimeout(u), | |
c._destroyed || c.emit("error", t) | |
}) | |
}() | |
} else if (c._xhr = t, | |
c._pos = 0, | |
c.url = t.responseURL, | |
c.statusCode = t.status, | |
c.statusMessage = t.statusText, | |
t.getAllResponseHeaders().split(/\r?\n/).forEach(function(t) { | |
var e = t.match(/^([^:]+):\s*(.*)/); | |
if (e) { | |
var r = e[1].toLowerCase(); | |
"set-cookie" === r ? (void 0 === c.headers[r] && (c.headers[r] = []), | |
c.headers[r].push(e[2])) : void 0 !== c.headers[r] ? c.headers[r] += ", " + e[2] : c.headers[r] = e[2], | |
c.rawHeaders.push(e[1], e[2]) | |
} | |
}), | |
c._charset = "x-user-defined", | |
!o.overrideMimeType) { | |
var h = c.rawHeaders["mime-type"]; | |
if (h) { | |
var p = h.match(/;\s*charset=([^;])(;|$)/); | |
p && (c._charset = p[1].toLowerCase()) | |
} | |
c._charset || (c._charset = "utf-8") | |
} | |
} | |
; | |
s(c, a.Readable), | |
c.prototype._read = function() { | |
var t = this._resumeFetch; | |
t && (this._resumeFetch = null, | |
t()) | |
} | |
, | |
c.prototype._onXHRProgress = function() { | |
var t = this | |
, e = t._xhr | |
, n = null; | |
switch (t._mode) { | |
case "text:vbarray": | |
if (e.readyState !== u.DONE) | |
break; | |
try { | |
n = new r.VBArray(e.responseBody).toArray() | |
} catch (e) {} | |
if (null !== n) { | |
t.push(new i(n)); | |
break | |
} | |
case "text": | |
try { | |
n = e.responseText | |
} catch (e) { | |
t._mode = "text:vbarray"; | |
break | |
} | |
if (n.length > t._pos) { | |
var o = n.substr(t._pos); | |
if ("x-user-defined" === t._charset) { | |
for (var s = new i(o.length), a = 0; a < o.length; a++) | |
s[a] = 255 & o.charCodeAt(a); | |
t.push(s) | |
} else | |
t.push(o, t._charset); | |
t._pos = n.length | |
} | |
break; | |
case "arraybuffer": | |
if (e.readyState !== u.DONE || !e.response) | |
break; | |
n = e.response, | |
t.push(new i(new Uint8Array(n))); | |
break; | |
case "moz-chunked-arraybuffer": | |
if (n = e.response, | |
e.readyState !== u.LOADING || !n) | |
break; | |
t.push(new i(new Uint8Array(n))); | |
break; | |
case "ms-stream": | |
if (n = e.response, | |
e.readyState !== u.LOADING) | |
break; | |
var c = new r.MSStreamReader; | |
c.onprogress = function() { | |
c.result.byteLength > t._pos && (t.push(new i(new Uint8Array(c.result.slice(t._pos)))), | |
t._pos = c.result.byteLength) | |
} | |
, | |
c.onload = function() { | |
t.push(null) | |
} | |
, | |
c.readAsArrayBuffer(n) | |
} | |
t._xhr.readyState === u.DONE && "ms-stream" !== t._mode && t.push(null) | |
} | |
} | |
).call(this, t("_process"), void 0 !== e ? e : "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}, t("buffer").Buffer) | |
} | |
, { | |
"./capability": 115, | |
_process: 99, | |
buffer: 53, | |
inherits: 94, | |
"readable-stream": 112 | |
}], | |
118: [function(t, e, r) { | |
"use strict"; | |
var n = t("safe-buffer").Buffer | |
, i = n.isEncoding || function(t) { | |
switch ((t = "" + t) && t.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 !0; | |
default: | |
return !1 | |
} | |
} | |
; | |
function o(t) { | |
var e; | |
switch (this.encoding = function(t) { | |
var e = function(t) { | |
if (!t) | |
return "utf8"; | |
for (var e; ; ) | |
switch (t) { | |
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 t; | |
default: | |
if (e) | |
return; | |
t = ("" + t).toLowerCase(), | |
e = !0 | |
} | |
}(t); | |
if ("string" != typeof e && (n.isEncoding === i || !i(t))) | |
throw new Error("Unknown encoding: " + t); | |
return e || t | |
}(t), | |
this.encoding) { | |
case "utf16le": | |
this.text = u, | |
this.end = c, | |
e = 4; | |
break; | |
case "utf8": | |
this.fillLast = a, | |
e = 4; | |
break; | |
case "base64": | |
this.text = f, | |
this.end = l, | |
e = 3; | |
break; | |
default: | |
return this.write = h, | |
void (this.end = p) | |
} | |
this.lastNeed = 0, | |
this.lastTotal = 0, | |
this.lastChar = n.allocUnsafe(e) | |
} | |
function s(t) { | |
return t <= 127 ? 0 : t >> 5 == 6 ? 2 : t >> 4 == 14 ? 3 : t >> 3 == 30 ? 4 : t >> 6 == 2 ? -1 : -2 | |
} | |
function a(t) { | |
var e = this.lastTotal - this.lastNeed | |
, r = function(t, e, r) { | |
if (128 != (192 & e[0])) | |
return t.lastNeed = 0, | |
"�"; | |
if (1 < t.lastNeed && 1 < e.length) { | |
if (128 != (192 & e[1])) | |
return t.lastNeed = 1, | |
"�"; | |
if (2 < t.lastNeed && 2 < e.length && 128 != (192 & e[2])) | |
return t.lastNeed = 2, | |
"�" | |
} | |
}(this, t); | |
return void 0 !== r ? r : this.lastNeed <= t.length ? (t.copy(this.lastChar, e, 0, this.lastNeed), | |
this.lastChar.toString(this.encoding, 0, this.lastTotal)) : (t.copy(this.lastChar, e, 0, t.length), | |
void (this.lastNeed -= t.length)) | |
} | |
function u(t, e) { | |
if ((t.length - e) % 2 == 0) { | |
var r = t.toString("utf16le", e); | |
if (r) { | |
var n = r.charCodeAt(r.length - 1); | |
if (55296 <= n && n <= 56319) | |
return this.lastNeed = 2, | |
this.lastTotal = 4, | |
this.lastChar[0] = t[t.length - 2], | |
this.lastChar[1] = t[t.length - 1], | |
r.slice(0, -1) | |
} | |
return r | |
} | |
return this.lastNeed = 1, | |
this.lastTotal = 2, | |
this.lastChar[0] = t[t.length - 1], | |
t.toString("utf16le", e, t.length - 1) | |
} | |
function c(t) { | |
var e = t && t.length ? this.write(t) : ""; | |
if (this.lastNeed) { | |
var r = this.lastTotal - this.lastNeed; | |
return e + this.lastChar.toString("utf16le", 0, r) | |
} | |
return e | |
} | |
function f(t, e) { | |
var r = (t.length - e) % 3; | |
return 0 === r ? t.toString("base64", e) : (this.lastNeed = 3 - r, | |
this.lastTotal = 3, | |
1 === r ? this.lastChar[0] = t[t.length - 1] : (this.lastChar[0] = t[t.length - 2], | |
this.lastChar[1] = t[t.length - 1]), | |
t.toString("base64", e, t.length - r)) | |
} | |
function l(t) { | |
var e = t && t.length ? this.write(t) : ""; | |
return this.lastNeed ? e + this.lastChar.toString("base64", 0, 3 - this.lastNeed) : e | |
} | |
function h(t) { | |
return t.toString(this.encoding) | |
} | |
function p(t) { | |
return t && t.length ? this.write(t) : "" | |
} | |
(r.StringDecoder = o).prototype.write = function(t) { | |
if (0 === t.length) | |
return ""; | |
var e, r; | |
if (this.lastNeed) { | |
if (void 0 === (e = this.fillLast(t))) | |
return ""; | |
r = this.lastNeed, | |
this.lastNeed = 0 | |
} else | |
r = 0; | |
return r < t.length ? e ? e + this.text(t, r) : this.text(t, r) : e || "" | |
} | |
, | |
o.prototype.end = function(t) { | |
var e = t && t.length ? this.write(t) : ""; | |
return this.lastNeed ? e + "�" : e | |
} | |
, | |
o.prototype.text = function(t, e) { | |
var r = function(t, e, r) { | |
var n = e.length - 1; | |
if (n < r) | |
return 0; | |
var i = s(e[n]); | |
return 0 <= i ? (0 < i && (t.lastNeed = i - 1), | |
i) : --n < r || -2 === i ? 0 : 0 <= (i = s(e[n])) ? (0 < i && (t.lastNeed = i - 2), | |
i) : --n < r || -2 === i ? 0 : 0 <= (i = s(e[n])) ? (0 < i && (2 === i ? i = 0 : t.lastNeed = i - 3), | |
i) : 0 | |
}(this, t, e); | |
if (!this.lastNeed) | |
return t.toString("utf8", e); | |
this.lastTotal = r; | |
var n = t.length - (r - this.lastNeed); | |
return t.copy(this.lastChar, 0, n), | |
t.toString("utf8", e, n) | |
} | |
, | |
o.prototype.fillLast = function(t) { | |
if (this.lastNeed <= t.length) | |
return t.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed), | |
this.lastChar.toString(this.encoding, 0, this.lastTotal); | |
t.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, t.length), | |
this.lastNeed -= t.length | |
} | |
} | |
, { | |
"safe-buffer": 113 | |
}], | |
119: [function(t, e, r) { | |
(function(e, n) { | |
var i = t("process/browser.js").nextTick | |
, o = Function.prototype.apply | |
, s = Array.prototype.slice | |
, a = {} | |
, u = 0; | |
function c(t, e) { | |
this._id = t, | |
this._clearFn = e | |
} | |
r.setTimeout = function() { | |
return new c(o.call(setTimeout, window, arguments),clearTimeout) | |
} | |
, | |
r.setInterval = function() { | |
return new c(o.call(setInterval, window, arguments),clearInterval) | |
} | |
, | |
r.clearTimeout = r.clearInterval = function(t) { | |
t.close() | |
} | |
, | |
c.prototype.unref = c.prototype.ref = function() {} | |
, | |
c.prototype.close = function() { | |
this._clearFn.call(window, this._id) | |
} | |
, | |
r.enroll = function(t, e) { | |
clearTimeout(t._idleTimeoutId), | |
t._idleTimeout = e | |
} | |
, | |
r.unenroll = function(t) { | |
clearTimeout(t._idleTimeoutId), | |
t._idleTimeout = -1 | |
} | |
, | |
r._unrefActive = r.active = function(t) { | |
clearTimeout(t._idleTimeoutId); | |
var e = t._idleTimeout; | |
0 <= e && (t._idleTimeoutId = setTimeout(function() { | |
t._onTimeout && t._onTimeout() | |
}, e)) | |
} | |
, | |
r.setImmediate = "function" == typeof e ? e : function(t) { | |
var e = u++ | |
, n = !(arguments.length < 2) && s.call(arguments, 1); | |
return a[e] = !0, | |
i(function() { | |
a[e] && (n ? t.apply(null, n) : t.call(null), | |
r.clearImmediate(e)) | |
}), | |
e | |
} | |
, | |
r.clearImmediate = "function" == typeof n ? n : function(t) { | |
delete a[t] | |
} | |
} | |
).call(this, t("timers").setImmediate, t("timers").clearImmediate) | |
} | |
, { | |
"process/browser.js": 99, | |
timers: 119 | |
}], | |
120: [function(t, e, r) { | |
var n = t("buffer").Buffer; | |
e.exports = function(t) { | |
if (t instanceof Uint8Array) { | |
if (0 === t.byteOffset && t.byteLength === t.buffer.byteLength) | |
return t.buffer; | |
if ("function" == typeof t.buffer.slice) | |
return t.buffer.slice(t.byteOffset, t.byteOffset + t.byteLength) | |
} | |
if (n.isBuffer(t)) { | |
for (var e = new Uint8Array(t.length), r = t.length, i = 0; i < r; i++) | |
e[i] = t[i]; | |
return e.buffer | |
} | |
throw new Error("Argument must be a Buffer") | |
} | |
} | |
, { | |
buffer: 53 | |
}], | |
121: [function(t, e, r) { | |
"use strict"; | |
var n = t("punycode") | |
, i = t("./util"); | |
function o() { | |
this.protocol = null, | |
this.slashes = null, | |
this.auth = null, | |
this.host = null, | |
this.port = null, | |
this.hostname = null, | |
this.hash = null, | |
this.search = null, | |
this.query = null, | |
this.pathname = null, | |
this.path = null, | |
this.href = null | |
} | |
r.parse = b, | |
r.resolve = function(t, e) { | |
return b(t, !1, !0).resolve(e) | |
} | |
, | |
r.resolveObject = function(t, e) { | |
return t ? b(t, !1, !0).resolveObject(e) : e | |
} | |
, | |
r.format = function(t) { | |
return i.isString(t) && (t = b(t)), | |
t instanceof o ? t.format() : o.prototype.format.call(t) | |
} | |
, | |
r.Url = o; | |
var s = /^([a-z0-9.+-]+:)/i | |
, a = /:[0-9]*$/ | |
, u = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/ | |
, c = ["{", "}", "|", "\\", "^", "`"].concat(["<", ">", '"', "`", " ", "\r", "\n", "\t"]) | |
, f = ["'"].concat(c) | |
, l = ["%", "/", "?", ";", "#"].concat(f) | |
, h = ["/", "?", "#"] | |
, p = /^[+a-z0-9A-Z_-]{0,63}$/ | |
, d = /^([+a-z0-9A-Z_-]{0,63})(.*)$/ | |
, y = { | |
javascript: !0, | |
"javascript:": !0 | |
} | |
, m = { | |
javascript: !0, | |
"javascript:": !0 | |
} | |
, g = { | |
http: !0, | |
https: !0, | |
ftp: !0, | |
gopher: !0, | |
file: !0, | |
"http:": !0, | |
"https:": !0, | |
"ftp:": !0, | |
"gopher:": !0, | |
"file:": !0 | |
} | |
, v = t("querystring"); | |
function b(t, e, r) { | |
if (t && i.isObject(t) && t instanceof o) | |
return t; | |
var n = new o; | |
return n.parse(t, e, r), | |
n | |
} | |
o.prototype.parse = function(t, e, r) { | |
if (!i.isString(t)) | |
throw new TypeError("Parameter 'url' must be a string, not " + typeof t); | |
var o = t.indexOf("?") | |
, a = -1 !== o && o < t.indexOf("#") ? "?" : "#" | |
, c = t.split(a); | |
c[0] = c[0].replace(/\\/g, "/"); | |
var b = t = c.join(a); | |
if (b = b.trim(), | |
!r && 1 === t.split("#").length) { | |
var w = u.exec(b); | |
if (w) | |
return this.path = b, | |
this.href = b, | |
this.pathname = w[1], | |
w[2] ? (this.search = w[2], | |
this.query = e ? v.parse(this.search.substr(1)) : this.search.substr(1)) : e && (this.search = "", | |
this.query = {}), | |
this | |
} | |
var _ = s.exec(b); | |
if (_) { | |
var x = (_ = _[0]).toLowerCase(); | |
this.protocol = x, | |
b = b.substr(_.length) | |
} | |
if (r || _ || b.match(/^\/\/[^@\/]+@[^@\/]+/)) { | |
var S = "//" === b.substr(0, 2); | |
!S || _ && m[_] || (b = b.substr(2), | |
this.slashes = !0) | |
} | |
if (!m[_] && (S || _ && !g[_])) { | |
for (var k, E, A = -1, C = 0; C < h.length; C++) | |
-1 !== (T = b.indexOf(h[C])) && (-1 === A || T < A) && (A = T); | |
for (-1 !== (E = -1 === A ? b.lastIndexOf("@") : b.lastIndexOf("@", A)) && (k = b.slice(0, E), | |
b = b.slice(E + 1), | |
this.auth = decodeURIComponent(k)), | |
A = -1, | |
C = 0; C < l.length; C++) { | |
var T; | |
-1 !== (T = b.indexOf(l[C])) && (-1 === A || T < A) && (A = T) | |
} | |
-1 === A && (A = b.length), | |
this.host = b.slice(0, A), | |
b = b.slice(A), | |
this.parseHost(), | |
this.hostname = this.hostname || ""; | |
var O = "[" === this.hostname[0] && "]" === this.hostname[this.hostname.length - 1]; | |
if (!O) | |
for (var B = this.hostname.split(/\./), j = (C = 0, | |
B.length); C < j; C++) { | |
var R = B[C]; | |
if (R && !R.match(p)) { | |
for (var M = "", L = 0, I = R.length; L < I; L++) | |
127 < R.charCodeAt(L) ? M += "x" : M += R[L]; | |
if (!M.match(p)) { | |
var N = B.slice(0, C) | |
, P = B.slice(C + 1) | |
, D = R.match(d); | |
D && (N.push(D[1]), | |
P.unshift(D[2])), | |
P.length && (b = "/" + P.join(".") + b), | |
this.hostname = N.join("."); | |
break | |
} | |
} | |
} | |
255 < this.hostname.length ? this.hostname = "" : this.hostname = this.hostname.toLowerCase(), | |
O || (this.hostname = n.toASCII(this.hostname)); | |
var F = this.port ? ":" + this.port : "" | |
, U = this.hostname || ""; | |
this.host = U + F, | |
this.href += this.host, | |
O && (this.hostname = this.hostname.substr(1, this.hostname.length - 2), | |
"/" !== b[0] && (b = "/" + b)) | |
} | |
if (!y[x]) | |
for (C = 0, | |
j = f.length; C < j; C++) { | |
var q = f[C]; | |
if (-1 !== b.indexOf(q)) { | |
var H = encodeURIComponent(q); | |
H === q && (H = escape(q)), | |
b = b.split(q).join(H) | |
} | |
} | |
var z = b.indexOf("#"); | |
-1 !== z && (this.hash = b.substr(z), | |
b = b.slice(0, z)); | |
var W = b.indexOf("?"); | |
if (-1 !== W ? (this.search = b.substr(W), | |
this.query = b.substr(W + 1), | |
e && (this.query = v.parse(this.query)), | |
b = b.slice(0, W)) : e && (this.search = "", | |
this.query = {}), | |
b && (this.pathname = b), | |
g[x] && this.hostname && !this.pathname && (this.pathname = "/"), | |
this.pathname || this.search) { | |
F = this.pathname || ""; | |
var J = this.search || ""; | |
this.path = F + J | |
} | |
return this.href = this.format(), | |
this | |
} | |
, | |
o.prototype.format = function() { | |
var t = this.auth || ""; | |
t && (t = (t = encodeURIComponent(t)).replace(/%3A/i, ":"), | |
t += "@"); | |
var e = this.protocol || "" | |
, r = this.pathname || "" | |
, n = this.hash || "" | |
, o = !1 | |
, s = ""; | |
this.host ? o = t + this.host : this.hostname && (o = t + (-1 === this.hostname.indexOf(":") ? this.hostname : "[" + this.hostname + "]"), | |
this.port && (o += ":" + this.port)), | |
this.query && i.isObject(this.query) && Object.keys(this.query).length && (s = v.stringify(this.query)); | |
var a = this.search || s && "?" + s || ""; | |
return e && ":" !== e.substr(-1) && (e += ":"), | |
this.slashes || (!e || g[e]) && !1 !== o ? (o = "//" + (o || ""), | |
r && "/" !== r.charAt(0) && (r = "/" + r)) : o || (o = ""), | |
n && "#" !== n.charAt(0) && (n = "#" + n), | |
a && "?" !== a.charAt(0) && (a = "?" + a), | |
e + o + (r = r.replace(/[?#]/g, function(t) { | |
return encodeURIComponent(t) | |
})) + (a = a.replace("#", "%23")) + n | |
} | |
, | |
o.prototype.resolve = function(t) { | |
return this.resolveObject(b(t, !1, !0)).format() | |
} | |
, | |
o.prototype.resolveObject = function(t) { | |
if (i.isString(t)) { | |
var e = new o; | |
e.parse(t, !1, !0), | |
t = e | |
} | |
for (var r = new o, n = Object.keys(this), s = 0; s < n.length; s++) { | |
var a = n[s]; | |
r[a] = this[a] | |
} | |
if (r.hash = t.hash, | |
"" === t.href) | |
return r.href = r.format(), | |
r; | |
if (t.slashes && !t.protocol) { | |
for (var u = Object.keys(t), c = 0; c < u.length; c++) { | |
var f = u[c]; | |
"protocol" !== f && (r[f] = t[f]) | |
} | |
return g[r.protocol] && r.hostname && !r.pathname && (r.path = r.pathname = "/"), | |
r.href = r.format(), | |
r | |
} | |
if (t.protocol && t.protocol !== r.protocol) { | |
if (!g[t.protocol]) { | |
for (var l = Object.keys(t), h = 0; h < l.length; h++) { | |
var p = l[h]; | |
r[p] = t[p] | |
} | |
return r.href = r.format(), | |
r | |
} | |
if (r.protocol = t.protocol, | |
t.host || m[t.protocol]) | |
r.pathname = t.pathname; | |
else { | |
for (var d = (t.pathname || "").split("/"); d.length && !(t.host = d.shift()); ) | |
; | |
t.host || (t.host = ""), | |
t.hostname || (t.hostname = ""), | |
"" !== d[0] && d.unshift(""), | |
d.length < 2 && d.unshift(""), | |
r.pathname = d.join("/") | |
} | |
if (r.search = t.search, | |
r.query = t.query, | |
r.host = t.host || "", | |
r.auth = t.auth, | |
r.hostname = t.hostname || t.host, | |
r.port = t.port, | |
r.pathname || r.search) { | |
var y = r.pathname || "" | |
, v = r.search || ""; | |
r.path = y + v | |
} | |
return r.slashes = r.slashes || t.slashes, | |
r.href = r.format(), | |
r | |
} | |
var b = r.pathname && "/" === r.pathname.charAt(0) | |
, w = t.host || t.pathname && "/" === t.pathname.charAt(0) | |
, _ = w || b || r.host && t.pathname | |
, x = _ | |
, S = r.pathname && r.pathname.split("/") || [] | |
, k = (d = t.pathname && t.pathname.split("/") || [], | |
r.protocol && !g[r.protocol]); | |
if (k && (r.hostname = "", | |
r.port = null, | |
r.host && ("" === S[0] ? S[0] = r.host : S.unshift(r.host)), | |
r.host = "", | |
t.protocol && (t.hostname = null, | |
t.port = null, | |
t.host && ("" === d[0] ? d[0] = t.host : d.unshift(t.host)), | |
t.host = null), | |
_ = _ && ("" === d[0] || "" === S[0])), | |
w) | |
r.host = t.host || "" === t.host ? t.host : r.host, | |
r.hostname = t.hostname || "" === t.hostname ? t.hostname : r.hostname, | |
r.search = t.search, | |
r.query = t.query, | |
S = d; | |
else if (d.length) | |
S || (S = []), | |
S.pop(), | |
S = S.concat(d), | |
r.search = t.search, | |
r.query = t.query; | |
else if (!i.isNullOrUndefined(t.search)) | |
return k && (r.hostname = r.host = S.shift(), | |
(O = !!(r.host && 0 < r.host.indexOf("@")) && r.host.split("@")) && (r.auth = O.shift(), | |
r.host = r.hostname = O.shift())), | |
r.search = t.search, | |
r.query = t.query, | |
i.isNull(r.pathname) && i.isNull(r.search) || (r.path = (r.pathname ? r.pathname : "") + (r.search ? r.search : "")), | |
r.href = r.format(), | |
r; | |
if (!S.length) | |
return r.pathname = null, | |
r.search ? r.path = "/" + r.search : r.path = null, | |
r.href = r.format(), | |
r; | |
for (var E = S.slice(-1)[0], A = (r.host || t.host || 1 < S.length) && ("." === E || ".." === E) || "" === E, C = 0, T = S.length; 0 <= T; T--) | |
"." === (E = S[T]) ? S.splice(T, 1) : ".." === E ? (S.splice(T, 1), | |
C++) : C && (S.splice(T, 1), | |
C--); | |
if (!_ && !x) | |
for (; C--; C) | |
S.unshift(".."); | |
!_ || "" === S[0] || S[0] && "/" === S[0].charAt(0) || S.unshift(""), | |
A && "/" !== S.join("/").substr(-1) && S.push(""); | |
var O, B = "" === S[0] || S[0] && "/" === S[0].charAt(0); | |
return k && (r.hostname = r.host = B ? "" : S.length ? S.shift() : "", | |
(O = !!(r.host && 0 < r.host.indexOf("@")) && r.host.split("@")) && (r.auth = O.shift(), | |
r.host = r.hostname = O.shift())), | |
(_ = _ || r.host && S.length) && !B && S.unshift(""), | |
S.length ? r.pathname = S.join("/") : (r.pathname = null, | |
r.path = null), | |
i.isNull(r.pathname) && i.isNull(r.search) || (r.path = (r.pathname ? r.pathname : "") + (r.search ? r.search : "")), | |
r.auth = t.auth || r.auth, | |
r.slashes = r.slashes || t.slashes, | |
r.href = r.format(), | |
r | |
} | |
, | |
o.prototype.parseHost = function() { | |
var t = this.host | |
, e = a.exec(t); | |
e && (":" !== (e = e[0]) && (this.port = e.substr(1)), | |
t = t.substr(0, t.length - e.length)), | |
t && (this.hostname = t) | |
} | |
} | |
, { | |
"./util": 122, | |
punycode: 100, | |
querystring: 103 | |
}], | |
122: [function(t, e, r) { | |
"use strict"; | |
e.exports = { | |
isString: function(t) { | |
return "string" == typeof t | |
}, | |
isObject: function(t) { | |
return "object" == typeof t && null !== t | |
}, | |
isNull: function(t) { | |
return null === t | |
}, | |
isNullOrUndefined: function(t) { | |
return null == t | |
} | |
} | |
} | |
, {}], | |
123: [function(t, r, n) { | |
(function(t) { | |
!function(e) { | |
var i = "object" == typeof n && n | |
, o = "object" == typeof r && r && r.exports == i && r | |
, s = "object" == typeof t && t; | |
s.global !== s && s.window !== s || (e = s); | |
var a, u, c, f = String.fromCharCode; | |
function l(t) { | |
for (var e, r, n = [], i = 0, o = t.length; i < o; ) | |
55296 <= (e = t.charCodeAt(i++)) && e <= 56319 && i < o ? 56320 == (64512 & (r = t.charCodeAt(i++))) ? n.push(((1023 & e) << 10) + (1023 & r) + 65536) : (n.push(e), | |
i--) : n.push(e); | |
return n | |
} | |
function h(t) { | |
if (55296 <= t && t <= 57343) | |
throw Error("Lone surrogate U+" + t.toString(16).toUpperCase() + " is not a scalar value") | |
} | |
function p(t, e) { | |
return f(t >> e & 63 | 128) | |
} | |
function d(t) { | |
if (0 == (4294967168 & t)) | |
return f(t); | |
var e = ""; | |
return 0 == (4294965248 & t) ? e = f(t >> 6 & 31 | 192) : 0 == (4294901760 & t) ? (h(t), | |
e = f(t >> 12 & 15 | 224), | |
e += p(t, 6)) : 0 == (4292870144 & t) && (e = f(t >> 18 & 7 | 240), | |
e += p(t, 12), | |
e += p(t, 6)), | |
e + f(63 & t | 128) | |
} | |
function y() { | |
if (u <= c) | |
throw Error("Invalid byte index"); | |
var t = 255 & a[c]; | |
if (c++, | |
128 == (192 & t)) | |
return 63 & t; | |
throw Error("Invalid continuation byte") | |
} | |
function m() { | |
var t, e; | |
if (u < c) | |
throw Error("Invalid byte index"); | |
if (c == u) | |
return !1; | |
if (t = 255 & a[c], | |
c++, | |
0 == (128 & t)) | |
return t; | |
if (192 == (224 & t)) { | |
if (128 <= (e = (31 & t) << 6 | y())) | |
return e; | |
throw Error("Invalid continuation byte") | |
} | |
if (224 == (240 & t)) { | |
if (2048 <= (e = (15 & t) << 12 | y() << 6 | y())) | |
return h(e), | |
e; | |
throw Error("Invalid continuation byte") | |
} | |
if (240 == (248 & t) && 65536 <= (e = (7 & t) << 18 | y() << 12 | y() << 6 | y()) && e <= 1114111) | |
return e; | |
throw Error("Invalid UTF-8 detected") | |
} | |
var g = { | |
version: "2.1.2", | |
encode: function(t) { | |
for (var e = l(t), r = e.length, n = -1, i = ""; ++n < r; ) | |
i += d(e[n]); | |
return i | |
}, | |
decode: function(t) { | |
a = l(t), | |
u = a.length, | |
c = 0; | |
for (var e, r = []; !1 !== (e = m()); ) | |
r.push(e); | |
return function(t) { | |
for (var e, r = t.length, n = -1, i = ""; ++n < r; ) | |
65535 < (e = t[n]) && (i += f((e -= 65536) >>> 10 & 1023 | 55296), | |
e = 56320 | 1023 & e), | |
i += f(e); | |
return i | |
}(r) | |
} | |
}; | |
if ("function" == typeof define && "object" == typeof define.amd && define.amd) | |
define(function() { | |
return g | |
}); | |
else if (i && !i.nodeType) | |
if (o) | |
o.exports = g; | |
else { | |
var v = {}.hasOwnProperty; | |
for (var b in g) | |
v.call(g, b) && (i[b] = g[b]) | |
} | |
else | |
e.utf8 = g | |
}(this) | |
} | |
).call(this, void 0 !== e ? e : "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}) | |
} | |
, {}], | |
124: [function(t, r, n) { | |
(function(t) { | |
function e(e) { | |
try { | |
if (!t.localStorage) | |
return !1 | |
} catch (e) { | |
return !1 | |
} | |
var r = t.localStorage[e]; | |
return null != r && "true" === String(r).toLowerCase() | |
} | |
r.exports = function(t, r) { | |
if (e("noDeprecation")) | |
return t; | |
var n = !1; | |
return function() { | |
if (!n) { | |
if (e("throwDeprecation")) | |
throw new Error(r); | |
e("traceDeprecation") ? console.trace(r) : console.warn(r), | |
n = !0 | |
} | |
return t.apply(this, arguments) | |
} | |
} | |
} | |
).call(this, void 0 !== e ? e : "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}) | |
} | |
, {}], | |
125: [function(t, e, r) { | |
"use strict"; | |
var n, i = this && this.__extends || (n = Object.setPrototypeOf || { | |
__proto__: [] | |
}instanceof Array && function(t, e) { | |
t.__proto__ = e | |
} | |
|| function(t, e) { | |
for (var r in e) | |
e.hasOwnProperty(r) && (t[r] = e[r]) | |
} | |
, | |
function(t, e) { | |
function r() { | |
this.constructor = t | |
} | |
n(t, e), | |
t.prototype = null === e ? Object.create(e) : (r.prototype = e.prototype, | |
new r) | |
} | |
); | |
Object.defineProperty(r, "__esModule", { | |
value: !0 | |
}); | |
var o = function(t) { | |
function e() { | |
return null !== t && t.apply(this, arguments) || this | |
} | |
return i(e, t), | |
e | |
}(Error); | |
r.SecurityError = o; | |
var s = function(t) { | |
function e() { | |
return null !== t && t.apply(this, arguments) || this | |
} | |
return i(e, t), | |
e | |
}(Error); | |
r.InvalidStateError = s; | |
var a = function(t) { | |
function e() { | |
return null !== t && t.apply(this, arguments) || this | |
} | |
return i(e, t), | |
e | |
}(Error); | |
r.NetworkError = a; | |
var u = function(t) { | |
function e() { | |
return null !== t && t.apply(this, arguments) || this | |
} | |
return i(e, t), | |
e | |
}(Error); | |
r.SyntaxError = u | |
} | |
, {}], | |
126: [function(t, e, r) { | |
"use strict"; | |
Object.defineProperty(r, "__esModule", { | |
value: !0 | |
}), | |
function(t) { | |
for (var e in t) | |
r.hasOwnProperty(e) || (r[e] = t[e]) | |
}(t("./xml-http-request")); | |
var n = t("./xml-http-request-event-target"); | |
r.XMLHttpRequestEventTarget = n.XMLHttpRequestEventTarget | |
} | |
, { | |
"./xml-http-request": 130, | |
"./xml-http-request-event-target": 128 | |
}], | |
127: [function(t, e, r) { | |
"use strict"; | |
Object.defineProperty(r, "__esModule", { | |
value: !0 | |
}); | |
r.ProgressEvent = function(t) { | |
this.type = t, | |
this.bubbles = !1, | |
this.cancelable = !1, | |
this.loaded = 0, | |
this.lengthComputable = !1, | |
this.total = 0 | |
} | |
} | |
, {}], | |
128: [function(t, e, r) { | |
"use strict"; | |
Object.defineProperty(r, "__esModule", { | |
value: !0 | |
}); | |
var n = function() { | |
function t() { | |
this.listeners = {} | |
} | |
return t.prototype.addEventListener = function(t, e) { | |
t = t.toLowerCase(), | |
this.listeners[t] = this.listeners[t] || [], | |
this.listeners[t].push(e.handleEvent || e) | |
} | |
, | |
t.prototype.removeEventListener = function(t, e) { | |
if (t = t.toLowerCase(), | |
this.listeners[t]) { | |
var r = this.listeners[t].indexOf(e.handleEvent || e); | |
r < 0 || this.listeners[t].splice(r, 1) | |
} | |
} | |
, | |
t.prototype.dispatchEvent = function(t) { | |
var e = t.type.toLowerCase(); | |
if ((t.target = this).listeners[e]) | |
for (var r = 0, n = this.listeners[e]; r < n.length; r++) | |
n[r].call(this, t); | |
var i = this["on" + e]; | |
return i && i.call(this, t), | |
!0 | |
} | |
, | |
t | |
}(); | |
r.XMLHttpRequestEventTarget = n | |
} | |
, {}], | |
129: [function(t, e, r) { | |
(function(e) { | |
"use strict"; | |
var n, i = this && this.__extends || (n = Object.setPrototypeOf || { | |
__proto__: [] | |
}instanceof Array && function(t, e) { | |
t.__proto__ = e | |
} | |
|| function(t, e) { | |
for (var r in e) | |
e.hasOwnProperty(r) && (t[r] = e[r]) | |
} | |
, | |
function(t, e) { | |
function r() { | |
this.constructor = t | |
} | |
n(t, e), | |
t.prototype = null === e ? Object.create(e) : (r.prototype = e.prototype, | |
new r) | |
} | |
); | |
Object.defineProperty(r, "__esModule", { | |
value: !0 | |
}); | |
var o = function(t) { | |
function r() { | |
var e = t.call(this) || this; | |
return e._contentType = null, | |
e._body = null, | |
e._reset(), | |
e | |
} | |
return i(r, t), | |
r.prototype._reset = function() { | |
this._contentType = null, | |
this._body = null | |
} | |
, | |
r.prototype._setData = function(t) { | |
if (null != t) | |
if ("string" == typeof t) | |
0 !== t.length && (this._contentType = "text/plain;charset=UTF-8"), | |
this._body = new e(t,"utf-8"); | |
else if (e.isBuffer(t)) | |
this._body = t; | |
else if (t instanceof ArrayBuffer) { | |
for (var r = new e(t.byteLength), n = new Uint8Array(t), i = 0; i < t.byteLength; i++) | |
r[i] = n[i]; | |
this._body = r | |
} else { | |
if (!(t.buffer && t.buffer instanceof ArrayBuffer)) | |
throw new Error("Unsupported send() data " + t); | |
r = new e(t.byteLength); | |
var o = t.byteOffset; | |
for (n = new Uint8Array(t.buffer), | |
i = 0; i < t.byteLength; i++) | |
r[i] = n[i + o]; | |
this._body = r | |
} | |
} | |
, | |
r.prototype._finalizeHeaders = function(t, e) { | |
this._contentType && !e["content-type"] && (t["Content-Type"] = this._contentType), | |
this._body && (t["Content-Length"] = this._body.length.toString()) | |
} | |
, | |
r.prototype._startUpload = function(t) { | |
this._body && t.write(this._body), | |
t.end() | |
} | |
, | |
r | |
}(t("./xml-http-request-event-target").XMLHttpRequestEventTarget); | |
r.XMLHttpRequestUpload = o | |
} | |
).call(this, t("buffer").Buffer) | |
} | |
, { | |
"./xml-http-request-event-target": 128, | |
buffer: 53 | |
}], | |
130: [function(t, e, r) { | |
(function(e, n) { | |
"use strict"; | |
var i, o = this && this.__extends || (i = Object.setPrototypeOf || { | |
__proto__: [] | |
}instanceof Array && function(t, e) { | |
t.__proto__ = e | |
} | |
|| function(t, e) { | |
for (var r in e) | |
e.hasOwnProperty(r) && (t[r] = e[r]) | |
} | |
, | |
function(t, e) { | |
function r() { | |
this.constructor = t | |
} | |
i(t, e), | |
t.prototype = null === e ? Object.create(e) : (r.prototype = e.prototype, | |
new r) | |
} | |
), s = this && this.__assign || Object.assign || function(t) { | |
for (var e, r = 1, n = arguments.length; r < n; r++) | |
for (var i in e = arguments[r]) | |
Object.prototype.hasOwnProperty.call(e, i) && (t[i] = e[i]); | |
return t | |
} | |
; | |
Object.defineProperty(r, "__esModule", { | |
value: !0 | |
}); | |
var a = t("http") | |
, u = t("https") | |
, c = t("os") | |
, f = t("url") | |
, l = t("./progress-event") | |
, h = t("./errors") | |
, p = t("./xml-http-request-event-target") | |
, d = t("./xml-http-request-upload") | |
, y = t("cookiejar") | |
, m = function(t) { | |
function r(n) { | |
void 0 === n && (n = {}); | |
var i = t.call(this) || this; | |
return i.UNSENT = r.UNSENT, | |
i.OPENED = r.OPENED, | |
i.HEADERS_RECEIVED = r.HEADERS_RECEIVED, | |
i.LOADING = r.LOADING, | |
i.DONE = r.DONE, | |
i.onreadystatechange = null, | |
i.readyState = r.UNSENT, | |
i.response = null, | |
i.responseText = "", | |
i.responseType = "", | |
i.status = 0, | |
i.statusText = "", | |
i.timeout = 0, | |
i.upload = new d.XMLHttpRequestUpload, | |
i.responseUrl = "", | |
i.withCredentials = !1, | |
i._method = null, | |
i._url = null, | |
i._sync = !1, | |
i._headers = {}, | |
i._loweredHeaders = {}, | |
i._mimeOverride = null, | |
i._request = null, | |
i._response = null, | |
i._responseParts = null, | |
i._responseHeaders = null, | |
i._aborting = null, | |
i._error = null, | |
i._loadedBytes = 0, | |
i._totalBytes = 0, | |
i._lengthComputable = !1, | |
i._restrictedMethods = { | |
CONNECT: !0, | |
TRACE: !0, | |
TRACK: !0 | |
}, | |
i._restrictedHeaders = { | |
"accept-charset": !0, | |
"accept-encoding": !0, | |
"access-control-request-headers": !0, | |
"access-control-request-method": !0, | |
connection: !0, | |
"content-length": !0, | |
cookie: !0, | |
cookie2: !0, | |
date: !0, | |
dnt: !0, | |
expect: !0, | |
host: !0, | |
"keep-alive": !0, | |
origin: !0, | |
referer: !0, | |
te: !0, | |
trailer: !0, | |
"transfer-encoding": !0, | |
upgrade: !0, | |
"user-agent": !0, | |
via: !0 | |
}, | |
i._privateHeaders = { | |
"set-cookie": !0, | |
"set-cookie2": !0 | |
}, | |
i._userAgent = "Mozilla/5.0 (" + c.type() + " " + c.arch() + ") node.js/" + e.versions.node + " v8/" + e.versions.v8, | |
i._anonymous = n.anon || !1, | |
i | |
} | |
return o(r, t), | |
r.prototype.open = function(t, e, n, i, o) { | |
if (void 0 === n && (n = !0), | |
t = t.toUpperCase(), | |
this._restrictedMethods[t]) | |
throw new r.SecurityError("HTTP method " + t + " is not allowed in XHR"); | |
var s = this._parseUrl(e, i, o); | |
this.readyState === r.HEADERS_RECEIVED || this.readyState, | |
this._method = t, | |
this._url = s, | |
this._sync = !n, | |
this._headers = {}, | |
this._loweredHeaders = {}, | |
this._mimeOverride = null, | |
this._setReadyState(r.OPENED), | |
this._request = null, | |
this._response = null, | |
this.status = 0, | |
this.statusText = "", | |
this._responseParts = [], | |
this._responseHeaders = null, | |
this._loadedBytes = 0, | |
this._totalBytes = 0, | |
this._lengthComputable = !1 | |
} | |
, | |
r.prototype.setRequestHeader = function(t, e) { | |
if (this.readyState !== r.OPENED) | |
throw new r.InvalidStateError("XHR readyState must be OPENED"); | |
var n = t.toLowerCase(); | |
this._restrictedHeaders[n] || /^sec-/.test(n) || /^proxy-/.test(n) ? console.warn('Refused to set unsafe header "' + t + '"') : (e = e.toString(), | |
null != this._loweredHeaders[n] ? (t = this._loweredHeaders[n], | |
this._headers[t] = this._headers[t] + ", " + e) : (this._loweredHeaders[n] = t, | |
this._headers[t] = e)) | |
} | |
, | |
r.prototype.send = function(t) { | |
if (this.readyState !== r.OPENED) | |
throw new r.InvalidStateError("XHR readyState must be OPENED"); | |
if (this._request) | |
throw new r.InvalidStateError("send() already called"); | |
switch (this._url.protocol) { | |
case "file:": | |
return this._sendFile(t); | |
case "http:": | |
case "https:": | |
return this._sendHttp(t); | |
default: | |
throw new r.NetworkError("Unsupported protocol " + this._url.protocol) | |
} | |
} | |
, | |
r.prototype.abort = function() { | |
null != this._request && (this._request.abort(), | |
this._setError(), | |
this._dispatchProgress("abort"), | |
this._dispatchProgress("loadend")) | |
} | |
, | |
r.prototype.getResponseHeader = function(t) { | |
if (null == this._responseHeaders || null == t) | |
return null; | |
var e = t.toLowerCase(); | |
return this._responseHeaders.hasOwnProperty(e) ? this._responseHeaders[t.toLowerCase()] : null | |
} | |
, | |
r.prototype.getAllResponseHeaders = function() { | |
var t = this; | |
return null == this._responseHeaders ? "" : Object.keys(this._responseHeaders).map(function(e) { | |
return e + ": " + t._responseHeaders[e] | |
}).join("\r\n") | |
} | |
, | |
r.prototype.overrideMimeType = function(t) { | |
if (this.readyState === r.LOADING || this.readyState === r.DONE) | |
throw new r.InvalidStateError("overrideMimeType() not allowed in LOADING or DONE"); | |
this._mimeOverride = t.toLowerCase() | |
} | |
, | |
r.prototype.nodejsSet = function(t) { | |
if (this.nodejsHttpAgent = t.httpAgent || this.nodejsHttpAgent, | |
this.nodejsHttpsAgent = t.httpsAgent || this.nodejsHttpsAgent, | |
t.hasOwnProperty("baseUrl")) { | |
if (null != t.baseUrl && !f.parse(t.baseUrl, !1, !0).protocol) | |
throw new r.SyntaxError("baseUrl must be an absolute URL"); | |
this.nodejsBaseUrl = t.baseUrl | |
} | |
} | |
, | |
r.nodejsSet = function(t) { | |
r.prototype.nodejsSet(t) | |
} | |
, | |
r.prototype._setReadyState = function(t) { | |
this.readyState = t, | |
this.dispatchEvent(new l.ProgressEvent("readystatechange")) | |
} | |
, | |
r.prototype._sendFile = function(t) { | |
throw new Error("Protocol file: not implemented") | |
} | |
, | |
r.prototype._sendHttp = function(t) { | |
if (this._sync) | |
throw new Error("Synchronous XHR processing not implemented"); | |
!t || "GET" !== this._method && "HEAD" !== this._method ? t = t || "" : (console.warn("Discarding entity body for " + this._method + " requests"), | |
t = null), | |
this.upload._setData(t), | |
this._finalizeHeaders(), | |
this._sendHxxpRequest() | |
} | |
, | |
r.prototype._sendHxxpRequest = function() { | |
var t = this; | |
if (this.withCredentials) { | |
var e = r.cookieJar.getCookies(y.CookieAccessInfo(this._url.hostname, this._url.pathname, "https:" === this._url.protocol)).toValueString(); | |
this._headers.cookie = this._headers.cookie2 = e | |
} | |
var n = "http:" === this._url.protocol ? [a, this.nodejsHttpAgent] : [u, this.nodejsHttpsAgent] | |
, i = n[0] | |
, o = n[1] | |
, s = i.request.bind(i)({ | |
hostname: this._url.hostname, | |
port: +this._url.port, | |
path: this._url.path, | |
auth: this._url.auth, | |
method: this._method, | |
headers: this._headers, | |
agent: o | |
}); | |
this._request = s, | |
this.timeout && s.setTimeout(this.timeout, function() { | |
return t._onHttpTimeout(s) | |
}), | |
s.on("response", function(e) { | |
return t._onHttpResponse(s, e) | |
}), | |
s.on("error", function(e) { | |
return t._onHttpRequestError(s, e) | |
}), | |
this.upload._startUpload(s), | |
this._request === s && this._dispatchProgress("loadstart") | |
} | |
, | |
r.prototype._finalizeHeaders = function() { | |
this._headers = s({}, this._headers, { | |
Connection: "keep-alive", | |
Host: this._url.host, | |
"User-Agent": this._userAgent | |
}, this._anonymous ? { | |
Referer: "about:blank" | |
} : {}), | |
this.upload._finalizeHeaders(this._headers, this._loweredHeaders) | |
} | |
, | |
r.prototype._onHttpResponse = function(t, e) { | |
var n = this; | |
if (this._request === t) { | |
if (this.withCredentials && (e.headers["set-cookie"] || e.headers["set-cookie2"]) && r.cookieJar.setCookies(e.headers["set-cookie"] || e.headers["set-cookie2"]), | |
0 <= [301, 302, 303, 307, 308].indexOf(e.statusCode)) | |
return this._url = this._parseUrl(e.headers.location), | |
this._method = "GET", | |
this._loweredHeaders["content-type"] && (delete this._headers[this._loweredHeaders["content-type"]], | |
delete this._loweredHeaders["content-type"]), | |
null != this._headers["Content-Type"] && delete this._headers["Content-Type"], | |
delete this._headers["Content-Length"], | |
this.upload._reset(), | |
this._finalizeHeaders(), | |
void this._sendHxxpRequest(); | |
this._response = e, | |
this._response.on("data", function(t) { | |
return n._onHttpResponseData(e, t) | |
}), | |
this._response.on("end", function() { | |
return n._onHttpResponseEnd(e) | |
}), | |
this._response.on("close", function() { | |
return n._onHttpResponseClose(e) | |
}), | |
this.responseUrl = this._url.href.split("#")[0], | |
this.status = e.statusCode, | |
this.statusText = a.STATUS_CODES[this.status], | |
this._parseResponseHeaders(e); | |
var i = this._responseHeaders["content-length"] || ""; | |
this._totalBytes = +i, | |
this._lengthComputable = !!i, | |
this._setReadyState(r.HEADERS_RECEIVED) | |
} | |
} | |
, | |
r.prototype._onHttpResponseData = function(t, e) { | |
this._response === t && (this._responseParts.push(new n(e)), | |
this._loadedBytes += e.length, | |
this.readyState !== r.LOADING && this._setReadyState(r.LOADING), | |
this._dispatchProgress("progress")) | |
} | |
, | |
r.prototype._onHttpResponseEnd = function(t) { | |
this._response === t && (this._parseResponse(), | |
this._request = null, | |
this._response = null, | |
this._setReadyState(r.DONE), | |
this._dispatchProgress("load"), | |
this._dispatchProgress("loadend")) | |
} | |
, | |
r.prototype._onHttpResponseClose = function(t) { | |
if (this._response === t) { | |
var e = this._request; | |
this._setError(), | |
e.abort(), | |
this._setReadyState(r.DONE), | |
this._dispatchProgress("error"), | |
this._dispatchProgress("loadend") | |
} | |
} | |
, | |
r.prototype._onHttpTimeout = function(t) { | |
this._request === t && (this._setError(), | |
t.abort(), | |
this._setReadyState(r.DONE), | |
this._dispatchProgress("timeout"), | |
this._dispatchProgress("loadend")) | |
} | |
, | |
r.prototype._onHttpRequestError = function(t, e) { | |
this._request === t && (this._setError(), | |
t.abort(), | |
this._setReadyState(r.DONE), | |
this._dispatchProgress("error"), | |
this._dispatchProgress("loadend")) | |
} | |
, | |
r.prototype._dispatchProgress = function(t) { | |
var e = new r.ProgressEvent(t); | |
e.lengthComputable = this._lengthComputable, | |
e.loaded = this._loadedBytes, | |
e.total = this._totalBytes, | |
this.dispatchEvent(e) | |
} | |
, | |
r.prototype._setError = function() { | |
this._request = null, | |
this._response = null, | |
this._responseHeaders = null, | |
this._responseParts = null | |
} | |
, | |
r.prototype._parseUrl = function(t, e, r) { | |
var n = null == this.nodejsBaseUrl ? t : f.resolve(this.nodejsBaseUrl, t) | |
, i = f.parse(n, !1, !0); | |
i.hash = null; | |
var o = (i.auth || "").split(":") | |
, s = o[0] | |
, a = o[1]; | |
return (s || a || e || r) && (i.auth = (e || s || "") + ":" + (r || a || "")), | |
i | |
} | |
, | |
r.prototype._parseResponseHeaders = function(t) { | |
for (var e in this._responseHeaders = {}, | |
t.headers) { | |
var r = e.toLowerCase(); | |
this._privateHeaders[r] || (this._responseHeaders[r] = t.headers[e]) | |
} | |
null != this._mimeOverride && (this._responseHeaders["content-type"] = this._mimeOverride) | |
} | |
, | |
r.prototype._parseResponse = function() { | |
var t = n.concat(this._responseParts); | |
switch (this._responseParts = null, | |
this.responseType) { | |
case "json": | |
this.responseText = null; | |
try { | |
this.response = JSON.parse(t.toString("utf-8")) | |
} catch (e) { | |
this.response = null | |
} | |
return; | |
case "buffer": | |
return this.responseText = null, | |
void (this.response = t); | |
case "arraybuffer": | |
this.responseText = null; | |
for (var e = new ArrayBuffer(t.length), r = new Uint8Array(e), i = 0; i < t.length; i++) | |
r[i] = t[i]; | |
return void (this.response = e); | |
case "text": | |
default: | |
try { | |
this.responseText = t.toString(this._parseResponseEncoding()) | |
} catch (e) { | |
this.responseText = t.toString("binary") | |
} | |
this.response = this.responseText | |
} | |
} | |
, | |
r.prototype._parseResponseEncoding = function() { | |
return /;\s*charset=(.*)$/.exec(this._responseHeaders["content-type"] || "")[1] || "utf-8" | |
} | |
, | |
r.ProgressEvent = l.ProgressEvent, | |
r.InvalidStateError = h.InvalidStateError, | |
r.NetworkError = h.NetworkError, | |
r.SecurityError = h.SecurityError, | |
r.SyntaxError = h.SyntaxError, | |
r.XMLHttpRequestUpload = d.XMLHttpRequestUpload, | |
r.UNSENT = 0, | |
r.OPENED = 1, | |
r.HEADERS_RECEIVED = 2, | |
r.LOADING = 3, | |
r.DONE = 4, | |
r.cookieJar = y.CookieJar(), | |
r | |
}(p.XMLHttpRequestEventTarget); | |
(r.XMLHttpRequest = m).prototype.nodejsHttpAgent = a.globalAgent, | |
m.prototype.nodejsHttpsAgent = u.globalAgent, | |
m.prototype.nodejsBaseUrl = null | |
} | |
).call(this, t("_process"), t("buffer").Buffer) | |
} | |
, { | |
"./errors": 125, | |
"./progress-event": 127, | |
"./xml-http-request-event-target": 128, | |
"./xml-http-request-upload": 129, | |
_process: 99, | |
buffer: 53, | |
cookiejar: 55, | |
http: 114, | |
https: 92, | |
os: 97, | |
url: 121 | |
}], | |
131: [function(t, e, r) { | |
e.exports = function() { | |
for (var t = {}, e = 0; e < arguments.length; e++) { | |
var r = arguments[e]; | |
for (var i in r) | |
n.call(r, i) && (t[i] = r[i]) | |
} | |
return t | |
} | |
; | |
var n = Object.prototype.hasOwnProperty | |
} | |
, {}], | |
"bignumber.js": [function(t, e, r) { | |
!function(r) { | |
"use strict"; | |
var n, i, o, s = /^-?(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i, a = Math.ceil, u = Math.floor, c = " not a boolean or binary digit", f = "rounding mode", l = "number type has more than 15 significant digits", h = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_", p = 1e14, d = 14, y = 9007199254740991, m = [1, 10, 100, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13], g = 1e7, v = 1e9; | |
function b(t) { | |
var e = 0 | t; | |
return 0 < t || t === e ? e : e - 1 | |
} | |
function w(t) { | |
for (var e, r, n = 1, i = t.length, o = t[0] + ""; n < i; ) { | |
for (e = t[n++] + "", | |
r = d - e.length; r--; e = "0" + e) | |
; | |
o += e | |
} | |
for (i = o.length; 48 === o.charCodeAt(--i); ) | |
; | |
return o.slice(0, i + 1 || 1) | |
} | |
function _(t, e) { | |
var r, n, i = t.c, o = e.c, s = t.s, a = e.s, u = t.e, c = e.e; | |
if (!s || !a) | |
return null; | |
if (r = i && !i[0], | |
n = o && !o[0], | |
r || n) | |
return r ? n ? 0 : -a : s; | |
if (s != a) | |
return s; | |
if (r = s < 0, | |
n = u == c, | |
!i || !o) | |
return n ? 0 : !i ^ r ? 1 : -1; | |
if (!n) | |
return c < u ^ r ? 1 : -1; | |
for (a = (u = i.length) < (c = o.length) ? u : c, | |
s = 0; s < a; s++) | |
if (i[s] != o[s]) | |
return i[s] > o[s] ^ r ? 1 : -1; | |
return u == c ? 0 : c < u ^ r ? 1 : -1 | |
} | |
function x(t, e, r) { | |
return (t = C(t)) >= e && t <= r | |
} | |
function S(t) { | |
return "[object Array]" == Object.prototype.toString.call(t) | |
} | |
function k(t, e, r) { | |
for (var n, i, o = [0], s = 0, a = t.length; s < a; ) { | |
for (i = o.length; i--; o[i] *= e) | |
; | |
for (o[n = 0] += h.indexOf(t.charAt(s++)); n < o.length; n++) | |
o[n] > r - 1 && (null == o[n + 1] && (o[n + 1] = 0), | |
o[n + 1] += o[n] / r | 0, | |
o[n] %= r) | |
} | |
return o.reverse() | |
} | |
function E(t, e) { | |
return (1 < t.length ? t.charAt(0) + "." + t.slice(1) : t) + (e < 0 ? "e" : "e+") + e | |
} | |
function A(t, e) { | |
var r, n; | |
if (e < 0) { | |
for (n = "0."; ++e; n += "0") | |
; | |
t = n + t | |
} else if (++e > (r = t.length)) { | |
for (n = "0", | |
e -= r; --e; n += "0") | |
; | |
t += n | |
} else | |
e < r && (t = t.slice(0, e) + "." + t.slice(e)); | |
return t | |
} | |
function C(t) { | |
return (t = parseFloat(t)) < 0 ? a(t) : u(t) | |
} | |
if (n = function t(e) { | |
var r, n, T, O, B, j, R, M, L = 0, I = X.prototype, N = new X(1), P = 20, D = 4, F = -7, U = 21, q = -1e7, H = 1e7, z = !0, W = Q, J = !1, G = 1, K = 100, V = { | |
decimalSeparator: ".", | |
groupSeparator: ",", | |
groupSize: 3, | |
secondaryGroupSize: 0, | |
fractionGroupSeparator: " ", | |
fractionGroupSize: 0 | |
}; | |
function X(t, e) { | |
var r, n, i, a, u, c, f = this; | |
if (!(f instanceof X)) | |
return z && et(26, "constructor call without new", t), | |
new X(t,e); | |
if (null != e && W(e, 2, 64, L, "base")) { | |
if (c = t + "", | |
10 == (e |= 0)) | |
return rt(f = new X(t instanceof X ? t : c), P + f.e + 1, D); | |
if ((a = "number" == typeof t) && 0 * t != 0 || !new RegExp("^-?" + (r = "[" + h.slice(0, e) + "]+") + "(?:\\." + r + ")?$",e < 37 ? "i" : "").test(c)) | |
return o(f, c, a, e); | |
a ? (f.s = 1 / t < 0 ? (c = c.slice(1), | |
-1) : 1, | |
z && 15 < c.replace(/^0\.0*|\./, "").length && et(L, l, t), | |
a = !1) : f.s = 45 === c.charCodeAt(0) ? (c = c.slice(1), | |
-1) : 1, | |
c = $(c, 10, e, f.s) | |
} else { | |
if (t instanceof X) | |
return f.s = t.s, | |
f.e = t.e, | |
f.c = (t = t.c) ? t.slice() : t, | |
void (L = 0); | |
if ((a = "number" == typeof t) && 0 * t == 0) { | |
if (f.s = 1 / t < 0 ? (t = -t, | |
-1) : 1, | |
t === ~~t) { | |
for (n = 0, | |
i = t; 10 <= i; i /= 10, | |
n++) | |
; | |
return f.e = n, | |
f.c = [t], | |
void (L = 0) | |
} | |
c = t + "" | |
} else { | |
if (!s.test(c = t + "")) | |
return o(f, c, a); | |
f.s = 45 === c.charCodeAt(0) ? (c = c.slice(1), | |
-1) : 1 | |
} | |
} | |
for (-1 < (n = c.indexOf(".")) && (c = c.replace(".", "")), | |
0 < (i = c.search(/e/i)) ? (n < 0 && (n = i), | |
n += +c.slice(i + 1), | |
c = c.substring(0, i)) : n < 0 && (n = c.length), | |
i = 0; 48 === c.charCodeAt(i); i++) | |
; | |
for (u = c.length; 48 === c.charCodeAt(--u); ) | |
; | |
if (c = c.slice(i, u + 1)) | |
if (u = c.length, | |
a && z && 15 < u && et(L, l, f.s * t), | |
H < (n = n - i - 1)) | |
f.c = f.e = null; | |
else if (n < q) | |
f.c = [f.e = 0]; | |
else { | |
if (f.e = n, | |
f.c = [], | |
i = (n + 1) % d, | |
n < 0 && (i += d), | |
i < u) { | |
for (i && f.c.push(+c.slice(0, i)), | |
u -= d; i < u; ) | |
f.c.push(+c.slice(i, i += d)); | |
c = c.slice(i), | |
i = d - c.length | |
} else | |
i -= u; | |
for (; i--; c += "0") | |
; | |
f.c.push(+c) | |
} | |
else | |
f.c = [f.e = 0]; | |
L = 0 | |
} | |
function $(t, e, n, i) { | |
var o, s, a, u, c, f, l, p = t.indexOf("."), d = P, y = D; | |
for (n < 37 && (t = t.toLowerCase()), | |
0 <= p && (a = K, | |
K = 0, | |
t = t.replace(".", ""), | |
c = (l = new X(n)).pow(t.length - p), | |
K = a, | |
l.c = k(A(w(c.c), c.e), 10, e), | |
l.e = l.c.length), | |
s = a = (f = k(t, n, e)).length; 0 == f[--a]; f.pop()) | |
; | |
if (!f[0]) | |
return "0"; | |
if (p < 0 ? --s : (c.c = f, | |
c.e = s, | |
c.s = i, | |
f = (c = r(c, l, d, y, e)).c, | |
u = c.r, | |
s = c.e), | |
p = f[o = s + d + 1], | |
a = e / 2, | |
u = u || o < 0 || null != f[o + 1], | |
u = y < 4 ? (null != p || u) && (0 == y || y == (c.s < 0 ? 3 : 2)) : a < p || p == a && (4 == y || u || 6 == y && 1 & f[o - 1] || y == (c.s < 0 ? 8 : 7)), | |
o < 1 || !f[0]) | |
t = u ? A("1", -d) : "0"; | |
else { | |
if (f.length = o, | |
u) | |
for (--e; ++f[--o] > e; ) | |
f[o] = 0, | |
o || (++s, | |
f.unshift(1)); | |
for (a = f.length; !f[--a]; ) | |
; | |
for (p = 0, | |
t = ""; p <= a; t += h.charAt(f[p++])) | |
; | |
t = A(t, s) | |
} | |
return t | |
} | |
function Y(t, e, r, n) { | |
var i, o, s, a, u; | |
if (r = null != r && W(r, 0, 8, n, f) ? 0 | r : D, | |
!t.c) | |
return t.toString(); | |
if (i = t.c[0], | |
s = t.e, | |
null == e) | |
u = w(t.c), | |
u = 19 == n || 24 == n && s <= F ? E(u, s) : A(u, s); | |
else if (o = (t = rt(new X(t), e, r)).e, | |
a = (u = w(t.c)).length, | |
19 == n || 24 == n && (e <= o || o <= F)) { | |
for (; a < e; u += "0", | |
a++) | |
; | |
u = E(u, o) | |
} else if (e -= s, | |
u = A(u, o), | |
a < o + 1) { | |
if (0 < --e) | |
for (u += "."; e--; u += "0") | |
; | |
} else if (0 < (e += o - a)) | |
for (o + 1 == a && (u += "."); e--; u += "0") | |
; | |
return t.s < 0 && i ? "-" + u : u | |
} | |
function Z(t, e) { | |
var r, n, i = 0; | |
for (S(t[0]) && (t = t[0]), | |
r = new X(t[0]); ++i < t.length; ) { | |
if (!(n = new X(t[i])).s) { | |
r = n; | |
break | |
} | |
e.call(r, n) && (r = n) | |
} | |
return r | |
} | |
function Q(t, e, r, n, i) { | |
return (t < e || r < t || t != C(t)) && et(n, (i || "decimal places") + (t < e || r < t ? " out of range" : " not an integer"), t), | |
!0 | |
} | |
function tt(t, e, r) { | |
for (var n = 1, i = e.length; !e[--i]; e.pop()) | |
; | |
for (i = e[0]; 10 <= i; i /= 10, | |
n++) | |
; | |
return (r = n + r * d - 1) > H ? t.c = t.e = null : r < q ? t.c = [t.e = 0] : (t.e = r, | |
t.c = e), | |
t | |
} | |
function et(t, e, r) { | |
var n = new Error(["new BigNumber", "cmp", "config", "div", "divToInt", "eq", "gt", "gte", "lt", "lte", "minus", "mod", "plus", "precision", "random", "round", "shift", "times", "toDigits", "toExponential", "toFixed", "toFormat", "toFraction", "pow", "toPrecision", "toString", "BigNumber"][t] + "() " + e + ": " + r); | |
throw n.name = "BigNumber Error", | |
L = 0, | |
n | |
} | |
function rt(t, e, r, n) { | |
var i, o, s, c, f, l, h, y = t.c, g = m; | |
if (y) { | |
t: { | |
for (i = 1, | |
c = y[0]; 10 <= c; c /= 10, | |
i++) | |
; | |
if ((o = e - i) < 0) | |
o += d, | |
s = e, | |
h = (f = y[l = 0]) / g[i - s - 1] % 10 | 0; | |
else if ((l = a((o + 1) / d)) >= y.length) { | |
if (!n) | |
break t; | |
for (; y.length <= l; y.push(0)) | |
; | |
f = h = 0, | |
s = (o %= d) - d + (i = 1) | |
} else { | |
for (f = c = y[l], | |
i = 1; 10 <= c; c /= 10, | |
i++) | |
; | |
h = (s = (o %= d) - d + i) < 0 ? 0 : f / g[i - s - 1] % 10 | 0 | |
} | |
if (n = n || e < 0 || null != y[l + 1] || (s < 0 ? f : f % g[i - s - 1]), | |
n = r < 4 ? (h || n) && (0 == r || r == (t.s < 0 ? 3 : 2)) : 5 < h || 5 == h && (4 == r || n || 6 == r && (0 < o ? 0 < s ? f / g[i - s] : 0 : y[l - 1]) % 10 & 1 || r == (t.s < 0 ? 8 : 7)), | |
e < 1 || !y[0]) | |
return y.length = 0, | |
n ? (e -= t.e + 1, | |
y[0] = g[e % d], | |
t.e = -e || 0) : y[0] = t.e = 0, | |
t; | |
if (0 == o ? (y.length = l, | |
c = 1, | |
l--) : (y.length = l + 1, | |
c = g[d - o], | |
y[l] = 0 < s ? u(f / g[i - s] % g[s]) * c : 0), | |
n) | |
for (; ; ) { | |
if (0 == l) { | |
for (o = 1, | |
s = y[0]; 10 <= s; s /= 10, | |
o++) | |
; | |
for (s = y[0] += c, | |
c = 1; 10 <= s; s /= 10, | |
c++) | |
; | |
o != c && (t.e++, | |
y[0] == p && (y[0] = 1)); | |
break | |
} | |
if (y[l] += c, | |
y[l] != p) | |
break; | |
y[l--] = 0, | |
c = 1 | |
} | |
for (o = y.length; 0 === y[--o]; y.pop()) | |
; | |
} | |
t.e > H ? t.c = t.e = null : t.e < q && (t.c = [t.e = 0]) | |
} | |
return t | |
} | |
return X.another = t, | |
X.ROUND_UP = 0, | |
X.ROUND_DOWN = 1, | |
X.ROUND_CEIL = 2, | |
X.ROUND_FLOOR = 3, | |
X.ROUND_HALF_UP = 4, | |
X.ROUND_HALF_DOWN = 5, | |
X.ROUND_HALF_EVEN = 6, | |
X.ROUND_HALF_CEIL = 7, | |
X.ROUND_HALF_FLOOR = 8, | |
X.EUCLID = 9, | |
X.config = function() { | |
var t, e, r = 0, n = {}, o = arguments, s = o[0], a = s && "object" == typeof s ? function() { | |
if (s.hasOwnProperty(e)) | |
return null != (t = s[e]) | |
} | |
: function() { | |
if (o.length > r) | |
return null != (t = o[r++]) | |
} | |
; | |
return a(e = "DECIMAL_PLACES") && W(t, 0, v, 2, e) && (P = 0 | t), | |
n[e] = P, | |
a(e = "ROUNDING_MODE") && W(t, 0, 8, 2, e) && (D = 0 | t), | |
n[e] = D, | |
a(e = "EXPONENTIAL_AT") && (S(t) ? W(t[0], -v, 0, 2, e) && W(t[1], 0, v, 2, e) && (F = 0 | t[0], | |
U = 0 | t[1]) : W(t, -v, v, 2, e) && (F = -(U = 0 | (t < 0 ? -t : t)))), | |
n[e] = [F, U], | |
a(e = "RANGE") && (S(t) ? W(t[0], -v, -1, 2, e) && W(t[1], 1, v, 2, e) && (q = 0 | t[0], | |
H = 0 | t[1]) : W(t, -v, v, 2, e) && (0 | t ? q = -(H = 0 | (t < 0 ? -t : t)) : z && et(2, e + " cannot be zero", t))), | |
n[e] = [q, H], | |
a(e = "ERRORS") && (t === !!t || 1 === t || 0 === t ? (L = 0, | |
W = (z = !!t) ? Q : x) : z && et(2, e + c, t)), | |
n[e] = z, | |
a(e = "CRYPTO") && (t === !!t || 1 === t || 0 === t ? (J = !(!t || !i || "object" != typeof i), | |
t && !J && z && et(2, "crypto unavailable", i)) : z && et(2, e + c, t)), | |
n[e] = J, | |
a(e = "MODULO_MODE") && W(t, 0, 9, 2, e) && (G = 0 | t), | |
n[e] = G, | |
a(e = "POW_PRECISION") && W(t, 0, v, 2, e) && (K = 0 | t), | |
n[e] = K, | |
a(e = "FORMAT") && ("object" == typeof t ? V = t : z && et(2, e + " not an object", t)), | |
n[e] = V, | |
n | |
} | |
, | |
X.max = function() { | |
return Z(arguments, I.lt) | |
} | |
, | |
X.min = function() { | |
return Z(arguments, I.gt) | |
} | |
, | |
X.random = (n = 9007199254740992, | |
T = Math.random() * n & 2097151 ? function() { | |
return u(Math.random() * n) | |
} | |
: function() { | |
return 8388608 * (1073741824 * Math.random() | 0) + (8388608 * Math.random() | 0) | |
} | |
, | |
function(t) { | |
var e, r, n, o, s, c = 0, f = [], l = new X(N); | |
if (t = null != t && W(t, 0, v, 14) ? 0 | t : P, | |
o = a(t / d), | |
J) | |
if (i && i.getRandomValues) { | |
for (e = i.getRandomValues(new Uint32Array(o *= 2)); c < o; ) | |
9e15 <= (s = 131072 * e[c] + (e[c + 1] >>> 11)) ? (r = i.getRandomValues(new Uint32Array(2)), | |
e[c] = r[0], | |
e[c + 1] = r[1]) : (f.push(s % 1e14), | |
c += 2); | |
c = o / 2 | |
} else if (i && i.randomBytes) { | |
for (e = i.randomBytes(o *= 7); c < o; ) | |
9e15 <= (s = 281474976710656 * (31 & e[c]) + 1099511627776 * e[c + 1] + 4294967296 * e[c + 2] + 16777216 * e[c + 3] + (e[c + 4] << 16) + (e[c + 5] << 8) + e[c + 6]) ? i.randomBytes(7).copy(e, c) : (f.push(s % 1e14), | |
c += 7); | |
c = o / 7 | |
} else | |
z && et(14, "crypto unavailable", i); | |
if (!c) | |
for (; c < o; ) | |
(s = T()) < 9e15 && (f[c++] = s % 1e14); | |
for (o = f[--c], | |
t %= d, | |
o && t && (s = m[d - t], | |
f[c] = u(o / s) * s); 0 === f[c]; f.pop(), | |
c--) | |
; | |
if (c < 0) | |
f = [n = 0]; | |
else { | |
for (n = -1; 0 === f[0]; f.shift(), | |
n -= d) | |
; | |
for (c = 1, | |
s = f[0]; 10 <= s; s /= 10, | |
c++) | |
; | |
c < d && (n -= d - c) | |
} | |
return l.e = n, | |
l.c = f, | |
l | |
} | |
), | |
r = function() { | |
function t(t, e, r) { | |
var n, i, o, s, a = 0, u = t.length, c = e % g, f = e / g | 0; | |
for (t = t.slice(); u--; ) | |
a = ((i = c * (o = t[u] % g) + (n = f * o + (s = t[u] / g | 0) * c) % g * g + a) / r | 0) + (n / g | 0) + f * s, | |
t[u] = i % r; | |
return a && t.unshift(a), | |
t | |
} | |
function e(t, e, r, n) { | |
var i, o; | |
if (r != n) | |
o = n < r ? 1 : -1; | |
else | |
for (i = o = 0; i < r; i++) | |
if (t[i] != e[i]) { | |
o = t[i] > e[i] ? 1 : -1; | |
break | |
} | |
return o | |
} | |
function r(t, e, r, n) { | |
for (var i = 0; r--; ) | |
t[r] -= i, | |
i = t[r] < e[r] ? 1 : 0, | |
t[r] = i * n + t[r] - e[r]; | |
for (; !t[0] && 1 < t.length; t.shift()) | |
; | |
} | |
return function(n, i, o, s, a) { | |
var c, f, l, h, y, m, g, v, w, _, x, S, k, E, A, C, T, O = n.s == i.s ? 1 : -1, B = n.c, j = i.c; | |
if (!(B && B[0] && j && j[0])) | |
return new X(n.s && i.s && (B ? !j || B[0] != j[0] : j) ? B && 0 == B[0] || !j ? 0 * O : O / 0 : NaN); | |
for (w = (v = new X(O)).c = [], | |
O = o + (f = n.e - i.e) + 1, | |
a || (a = p, | |
f = b(n.e / d) - b(i.e / d), | |
O = O / d | 0), | |
l = 0; j[l] == (B[l] || 0); l++) | |
; | |
if (j[l] > (B[l] || 0) && f--, | |
O < 0) | |
w.push(1), | |
h = !0; | |
else { | |
for (E = B.length, | |
C = j.length, | |
O += 2, | |
1 < (y = u(a / (j[l = 0] + 1))) && (j = t(j, y, a), | |
B = t(B, y, a), | |
C = j.length, | |
E = B.length), | |
k = C, | |
x = (_ = B.slice(0, C)).length; x < C; _[x++] = 0) | |
; | |
(T = j.slice()).unshift(0), | |
A = j[0], | |
j[1] >= a / 2 && A++; | |
do { | |
if (y = 0, | |
(c = e(j, _, C, x)) < 0) { | |
if (S = _[0], | |
C != x && (S = S * a + (_[1] || 0)), | |
1 < (y = u(S / A))) | |
for (a <= y && (y = a - 1), | |
g = (m = t(j, y, a)).length, | |
x = _.length; 1 == e(m, _, g, x); ) | |
y--, | |
r(m, C < g ? T : j, g, a), | |
g = m.length, | |
c = 1; | |
else | |
0 == y && (c = y = 1), | |
g = (m = j.slice()).length; | |
if (g < x && m.unshift(0), | |
r(_, m, x, a), | |
x = _.length, | |
-1 == c) | |
for (; e(j, _, C, x) < 1; ) | |
y++, | |
r(_, C < x ? T : j, x, a), | |
x = _.length | |
} else | |
0 === c && (y++, | |
_ = [0]); | |
w[l++] = y, | |
_[0] ? _[x++] = B[k] || 0 : (_ = [B[k]], | |
x = 1) | |
} while ((k++ < E || null != _[0]) && O--);h = null != _[0], | |
w[0] || w.shift() | |
} | |
if (a == p) { | |
for (l = 1, | |
O = w[0]; 10 <= O; O /= 10, | |
l++) | |
; | |
rt(v, o + (v.e = l + f * d - 1) + 1, s, h) | |
} else | |
v.e = f, | |
v.r = +h; | |
return v | |
} | |
}(), | |
O = /^(-?)0([xbo])/i, | |
B = /^([^.]+)\.$/, | |
j = /^\.([^.]+)$/, | |
R = /^-?(Infinity|NaN)$/, | |
M = /^\s*\+|^\s+|\s+$/g, | |
o = function(t, e, r, n) { | |
var i, o = r ? e : e.replace(M, ""); | |
if (R.test(o)) | |
t.s = isNaN(o) ? null : o < 0 ? -1 : 1; | |
else { | |
if (!r && (o = o.replace(O, function(t, e, r) { | |
return i = "x" == (r = r.toLowerCase()) ? 16 : "b" == r ? 2 : 8, | |
n && n != i ? t : e | |
}), | |
n && (i = n, | |
o = o.replace(B, "$1").replace(j, "0.$1")), | |
e != o)) | |
return new X(o,i); | |
z && et(L, "not a" + (n ? " base " + n : "") + " number", e), | |
t.s = null | |
} | |
t.c = t.e = null, | |
L = 0 | |
} | |
, | |
I.absoluteValue = I.abs = function() { | |
var t = new X(this); | |
return t.s < 0 && (t.s = 1), | |
t | |
} | |
, | |
I.ceil = function() { | |
return rt(new X(this), this.e + 1, 2) | |
} | |
, | |
I.comparedTo = I.cmp = function(t, e) { | |
return L = 1, | |
_(this, new X(t,e)) | |
} | |
, | |
I.decimalPlaces = I.dp = function() { | |
var t, e, r = this.c; | |
if (!r) | |
return null; | |
if (t = ((e = r.length - 1) - b(this.e / d)) * d, | |
e = r[e]) | |
for (; e % 10 == 0; e /= 10, | |
t--) | |
; | |
return t < 0 && (t = 0), | |
t | |
} | |
, | |
I.dividedBy = I.div = function(t, e) { | |
return L = 3, | |
r(this, new X(t,e), P, D) | |
} | |
, | |
I.dividedToIntegerBy = I.divToInt = function(t, e) { | |
return L = 4, | |
r(this, new X(t,e), 0, 1) | |
} | |
, | |
I.equals = I.eq = function(t, e) { | |
return L = 5, | |
0 === _(this, new X(t,e)) | |
} | |
, | |
I.floor = function() { | |
return rt(new X(this), this.e + 1, 3) | |
} | |
, | |
I.greaterThan = I.gt = function(t, e) { | |
return L = 6, | |
0 < _(this, new X(t,e)) | |
} | |
, | |
I.greaterThanOrEqualTo = I.gte = function(t, e) { | |
return L = 7, | |
1 === (e = _(this, new X(t,e))) || 0 === e | |
} | |
, | |
I.isFinite = function() { | |
return !!this.c | |
} | |
, | |
I.isInteger = I.isInt = function() { | |
return !!this.c && b(this.e / d) > this.c.length - 2 | |
} | |
, | |
I.isNaN = function() { | |
return !this.s | |
} | |
, | |
I.isNegative = I.isNeg = function() { | |
return this.s < 0 | |
} | |
, | |
I.isZero = function() { | |
return !!this.c && 0 == this.c[0] | |
} | |
, | |
I.lessThan = I.lt = function(t, e) { | |
return L = 8, | |
_(this, new X(t,e)) < 0 | |
} | |
, | |
I.lessThanOrEqualTo = I.lte = function(t, e) { | |
return L = 9, | |
-1 === (e = _(this, new X(t,e))) || 0 === e | |
} | |
, | |
I.minus = I.sub = function(t, e) { | |
var r, n, i, o, s = this.s; | |
if (L = 10, | |
e = (t = new X(t,e)).s, | |
!s || !e) | |
return new X(NaN); | |
if (s != e) | |
return t.s = -e, | |
this.plus(t); | |
var a = this.e / d | |
, u = t.e / d | |
, c = this.c | |
, f = t.c; | |
if (!a || !u) { | |
if (!c || !f) | |
return c ? (t.s = -e, | |
t) : new X(f ? this : NaN); | |
if (!c[0] || !f[0]) | |
return f[0] ? (t.s = -e, | |
t) : new X(c[0] ? this : 3 == D ? -0 : 0) | |
} | |
if (a = b(a), | |
u = b(u), | |
c = c.slice(), | |
s = a - u) { | |
for ((o = s < 0) ? (s = -s, | |
i = c) : (u = a, | |
i = f), | |
i.reverse(), | |
e = s; e--; i.push(0)) | |
; | |
i.reverse() | |
} else | |
for (n = (o = (s = c.length) < (e = f.length)) ? s : e, | |
s = e = 0; e < n; e++) | |
if (c[e] != f[e]) { | |
o = c[e] < f[e]; | |
break | |
} | |
if (o && (i = c, | |
c = f, | |
f = i, | |
t.s = -t.s), | |
0 < (e = (n = f.length) - (r = c.length))) | |
for (; e--; c[r++] = 0) | |
; | |
for (e = p - 1; s < n; ) { | |
if (c[--n] < f[n]) { | |
for (r = n; r && !c[--r]; c[r] = e) | |
; | |
--c[r], | |
c[n] += p | |
} | |
c[n] -= f[n] | |
} | |
for (; 0 == c[0]; c.shift(), | |
--u) | |
; | |
return c[0] ? tt(t, c, u) : (t.s = 3 == D ? -1 : 1, | |
t.c = [t.e = 0], | |
t) | |
} | |
, | |
I.modulo = I.mod = function(t, e) { | |
var n, i; | |
return L = 11, | |
t = new X(t,e), | |
!this.c || !t.s || t.c && !t.c[0] ? new X(NaN) : !t.c || this.c && !this.c[0] ? new X(this) : (9 == G ? (i = t.s, | |
t.s = 1, | |
n = r(this, t, 0, 3), | |
t.s = i, | |
n.s *= i) : n = r(this, t, 0, G), | |
this.minus(n.times(t))) | |
} | |
, | |
I.negated = I.neg = function() { | |
var t = new X(this); | |
return t.s = -t.s || null, | |
t | |
} | |
, | |
I.plus = I.add = function(t, e) { | |
var r, n = this.s; | |
if (L = 12, | |
e = (t = new X(t,e)).s, | |
!n || !e) | |
return new X(NaN); | |
if (n != e) | |
return t.s = -e, | |
this.minus(t); | |
var i = this.e / d | |
, o = t.e / d | |
, s = this.c | |
, a = t.c; | |
if (!i || !o) { | |
if (!s || !a) | |
return new X(n / 0); | |
if (!s[0] || !a[0]) | |
return a[0] ? t : new X(s[0] ? this : 0 * n) | |
} | |
if (i = b(i), | |
o = b(o), | |
s = s.slice(), | |
n = i - o) { | |
for (0 < n ? (o = i, | |
r = a) : (n = -n, | |
r = s), | |
r.reverse(); n--; r.push(0)) | |
; | |
r.reverse() | |
} | |
for ((n = s.length) - (e = a.length) < 0 && (r = a, | |
a = s, | |
s = r, | |
e = n), | |
n = 0; e; ) | |
n = (s[--e] = s[e] + a[e] + n) / p | 0, | |
s[e] %= p; | |
return n && (s.unshift(n), | |
++o), | |
tt(t, s, o) | |
} | |
, | |
I.precision = I.sd = function(t) { | |
var e, r, n = this.c; | |
if (null != t && t !== !!t && 1 !== t && 0 !== t && (z && et(13, "argument" + c, t), | |
t != !!t && (t = null)), | |
!n) | |
return null; | |
if (e = (r = n.length - 1) * d + 1, | |
r = n[r]) { | |
for (; r % 10 == 0; r /= 10, | |
e--) | |
; | |
for (r = n[0]; 10 <= r; r /= 10, | |
e++) | |
; | |
} | |
return t && this.e + 1 > e && (e = this.e + 1), | |
e | |
} | |
, | |
I.round = function(t, e) { | |
var r = new X(this); | |
return (null == t || W(t, 0, v, 15)) && rt(r, ~~t + this.e + 1, null != e && W(e, 0, 8, 15, f) ? 0 | e : D), | |
r | |
} | |
, | |
I.shift = function(t) { | |
return W(t, -y, y, 16, "argument") ? this.times("1e" + C(t)) : new X(this.c && this.c[0] && (t < -y || y < t) ? this.s * (t < 0 ? 0 : 1 / 0) : this) | |
} | |
, | |
I.squareRoot = I.sqrt = function() { | |
var t, e, n, i, o, s = this.c, a = this.s, u = this.e, c = P + 4, f = new X("0.5"); | |
if (1 !== a || !s || !s[0]) | |
return new X(!a || a < 0 && (!s || s[0]) ? NaN : s ? this : 1 / 0); | |
if (0 == (a = Math.sqrt(+this)) || a == 1 / 0 ? (((e = w(s)).length + u) % 2 == 0 && (e += "0"), | |
a = Math.sqrt(e), | |
u = b((u + 1) / 2) - (u < 0 || u % 2), | |
n = new X(e = a == 1 / 0 ? "1e" + u : (e = a.toExponential()).slice(0, e.indexOf("e") + 1) + u)) : n = new X(a + ""), | |
n.c[0]) | |
for ((a = (u = n.e) + c) < 3 && (a = 0); ; ) | |
if (o = n, | |
n = f.times(o.plus(r(this, o, c, 1))), | |
w(o.c).slice(0, a) === (e = w(n.c)).slice(0, a)) { | |
if (n.e < u && --a, | |
"9999" != (e = e.slice(a - 3, a + 1)) && (i || "4999" != e)) { | |
+e && (+e.slice(1) || "5" != e.charAt(0)) || (rt(n, n.e + P + 2, 1), | |
t = !n.times(n).eq(this)); | |
break | |
} | |
if (!i && (rt(o, o.e + P + 2, 0), | |
o.times(o).eq(this))) { | |
n = o; | |
break | |
} | |
c += 4, | |
a += 4, | |
i = 1 | |
} | |
return rt(n, n.e + P + 1, D, t) | |
} | |
, | |
I.times = I.mul = function(t, e) { | |
var r, n, i, o, s, a, u, c, f, l, h, y, m, v, w, _ = this.c, x = (L = 17, | |
t = new X(t,e)).c; | |
if (!(_ && x && _[0] && x[0])) | |
return !this.s || !t.s || _ && !_[0] && !x || x && !x[0] && !_ ? t.c = t.e = t.s = null : (t.s *= this.s, | |
_ && x ? (t.c = [0], | |
t.e = 0) : t.c = t.e = null), | |
t; | |
for (n = b(this.e / d) + b(t.e / d), | |
t.s *= this.s, | |
(u = _.length) < (l = x.length) && (m = _, | |
_ = x, | |
x = m, | |
i = u, | |
u = l, | |
l = i), | |
i = u + l, | |
m = []; i--; m.push(0)) | |
; | |
for (v = p, | |
w = g, | |
i = l; 0 <= --i; ) { | |
for (r = 0, | |
h = x[i] % w, | |
y = x[i] / w | 0, | |
o = i + (s = u); i < o; ) | |
r = ((c = h * (c = _[--s] % w) + (a = y * c + (f = _[s] / w | 0) * h) % w * w + m[o] + r) / v | 0) + (a / w | 0) + y * f, | |
m[o--] = c % v; | |
m[o] = r | |
} | |
return r ? ++n : m.shift(), | |
tt(t, m, n) | |
} | |
, | |
I.toDigits = function(t, e) { | |
var r = new X(this); | |
return t = null != t && W(t, 1, v, 18, "precision") ? 0 | t : null, | |
e = null != e && W(e, 0, 8, 18, f) ? 0 | e : D, | |
t ? rt(r, t, e) : r | |
} | |
, | |
I.toExponential = function(t, e) { | |
return Y(this, null != t && W(t, 0, v, 19) ? 1 + ~~t : null, e, 19) | |
} | |
, | |
I.toFixed = function(t, e) { | |
return Y(this, null != t && W(t, 0, v, 20) ? ~~t + this.e + 1 : null, e, 20) | |
} | |
, | |
I.toFormat = function(t, e) { | |
var r = Y(this, null != t && W(t, 0, v, 21) ? ~~t + this.e + 1 : null, e, 21); | |
if (this.c) { | |
var n, i = r.split("."), o = +V.groupSize, s = +V.secondaryGroupSize, a = V.groupSeparator, u = i[0], c = i[1], f = this.s < 0, l = f ? u.slice(1) : u, h = l.length; | |
if (s && (n = o, | |
o = s, | |
h -= s = n), | |
0 < o && 0 < h) { | |
for (n = h % o || o, | |
u = l.substr(0, n); n < h; n += o) | |
u += a + l.substr(n, o); | |
0 < s && (u += a + l.slice(n)), | |
f && (u = "-" + u) | |
} | |
r = c ? u + V.decimalSeparator + ((s = +V.fractionGroupSize) ? c.replace(new RegExp("\\d{" + s + "}\\B","g"), "$&" + V.fractionGroupSeparator) : c) : u | |
} | |
return r | |
} | |
, | |
I.toFraction = function(t) { | |
var e, n, i, o, s, a, u, c, f, l = z, h = this.c, p = new X(N), y = n = new X(N), g = u = new X(N); | |
if (null != t && (z = !1, | |
a = new X(t), | |
z = l, | |
(l = a.isInt()) && !a.lt(N) || (z && et(22, "max denominator " + (l ? "out of range" : "not an integer"), t), | |
t = !l && a.c && rt(a, a.e + 1, 1).gte(N) ? a : null)), | |
!h) | |
return this.toString(); | |
for (f = w(h), | |
o = p.e = f.length - this.e - 1, | |
p.c[0] = m[(s = o % d) < 0 ? d + s : s], | |
t = !t || 0 < a.cmp(p) ? 0 < o ? p : y : a, | |
s = H, | |
H = 1 / 0, | |
a = new X(f), | |
u.c[0] = 0; c = r(a, p, 0, 1), | |
1 != (i = n.plus(c.times(g))).cmp(t); ) | |
n = g, | |
g = i, | |
y = u.plus(c.times(i = y)), | |
u = i, | |
p = a.minus(c.times(i = p)), | |
a = i; | |
return i = r(t.minus(n), g, 0, 1), | |
u = u.plus(i.times(y)), | |
n = n.plus(i.times(g)), | |
u.s = y.s = this.s, | |
e = r(y, g, o *= 2, D).minus(this).abs().cmp(r(u, n, o, D).minus(this).abs()) < 1 ? [y.toString(), g.toString()] : [u.toString(), n.toString()], | |
H = s, | |
e | |
} | |
, | |
I.toNumber = function() { | |
return +this || (this.s ? 0 * this.s : NaN) | |
} | |
, | |
I.toPower = I.pow = function(t) { | |
var e, r, n = u(t < 0 ? -t : +t), i = this; | |
if (!W(t, -y, y, 23, "exponent") && (!isFinite(t) || y < n && (t /= 0) || parseFloat(t) != t && !(t = NaN))) | |
return new X(Math.pow(+i, t)); | |
for (e = K ? a(K / d + 2) : 0, | |
r = new X(N); ; ) { | |
if (n % 2) { | |
if (!(r = r.times(i)).c) | |
break; | |
e && r.c.length > e && (r.c.length = e) | |
} | |
if (!(n = u(n / 2))) | |
break; | |
i = i.times(i), | |
e && i.c && i.c.length > e && (i.c.length = e) | |
} | |
return t < 0 && (r = N.div(r)), | |
e ? rt(r, K, D) : r | |
} | |
, | |
I.toPrecision = function(t, e) { | |
return Y(this, null != t && W(t, 1, v, 24, "precision") ? 0 | t : null, e, 24) | |
} | |
, | |
I.toString = function(t) { | |
var e, r = this.s, n = this.e; | |
return null === n ? r ? (e = "Infinity", | |
r < 0 && (e = "-" + e)) : e = "NaN" : (e = w(this.c), | |
e = null != t && W(t, 2, 64, 25, "base") ? $(A(e, n), 0 | t, 10, r) : n <= F || U <= n ? E(e, n) : A(e, n), | |
r < 0 && this.c[0] && (e = "-" + e)), | |
e | |
} | |
, | |
I.truncated = I.trunc = function() { | |
return rt(new X(this), this.e + 1, 1) | |
} | |
, | |
I.valueOf = I.toJSON = function() { | |
return this.toString() | |
} | |
, | |
null != e && X.config(e), | |
X | |
}(), | |
"function" == typeof define && define.amd) | |
define(function() { | |
return n | |
}); | |
else if (void 0 !== e && e.exports) { | |
if (e.exports = n, | |
!i) | |
try { | |
i = t("crypto") | |
} catch (r) {} | |
} else | |
r.BigNumber = n | |
}(this) | |
} | |
, { | |
crypto: 52 | |
}], | |
web3: [function(t, e, r) { | |
var n = t("./lib/web3"); | |
"undefined" != typeof window && void 0 === window.Web3 && (window.Web3 = n), | |
e.exports = n | |
} | |
, { | |
"./lib/web3": 22 | |
}] | |
}, {}, ["web3"]) | |
} | |
).call(this, "undefined" != typeof global ? global : "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}) | |
} | |
, {}], | |
68: [function(t, e, r) { | |
e.exports = function t(e, r) { | |
if (e && r) | |
return t(e)(r); | |
if ("function" != typeof e) | |
throw new TypeError("need wrapper function"); | |
Object.keys(e).forEach(function(t) { | |
n[t] = e[t] | |
}); | |
return n; | |
function n() { | |
for (var t = new Array(arguments.length), r = 0; r < t.length; r++) | |
t[r] = arguments[r]; | |
var n = e.apply(this, t) | |
, i = t[t.length - 1]; | |
return "function" == typeof n && n !== i && Object.keys(i).forEach(function(t) { | |
n[t] = i[t] | |
}), | |
n | |
} | |
} | |
} | |
, {}], | |
69: [function(t, e, r) { | |
e.exports = function() { | |
for (var t = {}, e = 0; e < arguments.length; e++) { | |
var r = arguments[e]; | |
for (var i in r) | |
n.call(r, i) && (t[i] = r[i]) | |
} | |
return t | |
} | |
; | |
var n = Object.prototype.hasOwnProperty | |
} | |
, {}] | |
}, {}, [2]); | |
//# sourceMappingURL=../sourcemaps/inpage.js.map |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment