Created
December 14, 2019 23:03
-
-
Save alex0112/39ebb3b76ab356f06f796b58fe339142 to your computer and use it in GitHub Desktop.
This file contains hidden or 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