{"version":3,"sources":["webpack:///./node_modules/evp_bytestokey/index.js","webpack:///./node_modules/events/events.js"],"names":["Buffer","MD5","EVP_BytesToKey","password","salt","keyBits","ivLen","isBuffer","from","length","RangeError","keyLen","key","alloc","iv","tmp","hash","update","digest","used","keyStart","Math","min","copy","ivStart","fill","module","exports","ReflectOwnKeys","R","Reflect","ReflectApply","apply","target","receiver","args","Function","prototype","call","ProcessEmitWarning","warning","console","warn","ownKeys","Object","getOwnPropertySymbols","getOwnPropertyNames","concat","NumberIsNaN","Number","isNaN","value","EventEmitter","init","this","once","_events","undefined","_eventsCount","_maxListeners","defaultMaxListeners","checkListener","listener","TypeError","_getMaxListeners","that","_addListener","type","prepend","m","events","existing","create","newListener","emit","unshift","push","warned","w","Error","String","name","emitter","count","onceWrapper","fired","removeListener","wrapFn","arguments","_onceWrap","state","wrapped","bind","_listeners","unwrap","evlistener","unwrapListeners","arrayClone","listenerCount","arr","n","Array","i","spliceOne","list","index","pop","ret","Promise","resolve","reject","errorListener","err","resolver","slice","eventTargetAgnosticAddListener","addErrorHandlerIfEventEmitter","handler","flags","on","addEventListener","wrapListener","arg","removeEventListener","defineProperty","enumerable","get","set","getPrototypeOf","setMaxListeners","getMaxListeners","doError","error","er","message","context","len","listeners","addListener","prependListener","prependOnceListener","position","originalListener","shift","off","removeAllListeners","keys","rawListeners","eventNames"],"mappings":"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","file":"js/account~7901f734.33338f45.js","sourcesContent":["var Buffer = require('safe-buffer').Buffer\nvar MD5 = require('md5.js')\n\n/* eslint-disable camelcase */\nfunction EVP_BytesToKey (password, salt, keyBits, ivLen) {\n  if (!Buffer.isBuffer(password)) password = Buffer.from(password, 'binary')\n  if (salt) {\n    if (!Buffer.isBuffer(salt)) salt = Buffer.from(salt, 'binary')\n    if (salt.length !== 8) throw new RangeError('salt should be Buffer with 8 byte length')\n  }\n\n  var keyLen = keyBits / 8\n  var key = Buffer.alloc(keyLen)\n  var iv = Buffer.alloc(ivLen || 0)\n  var tmp = Buffer.alloc(0)\n\n  while (keyLen > 0 || ivLen > 0) {\n    var hash = new MD5()\n    hash.update(tmp)\n    hash.update(password)\n    if (salt) hash.update(salt)\n    tmp = hash.digest()\n\n    var used = 0\n\n    if (keyLen > 0) {\n      var keyStart = key.length - keyLen\n      used = Math.min(keyLen, tmp.length)\n      tmp.copy(key, keyStart, 0, used)\n      keyLen -= used\n    }\n\n    if (used < tmp.length && ivLen > 0) {\n      var ivStart = iv.length - ivLen\n      var length = Math.min(ivLen, tmp.length - used)\n      tmp.copy(iv, ivStart, used, used + length)\n      ivLen -= length\n    }\n  }\n\n  tmp.fill(0)\n  return { key: key, iv: iv }\n}\n\nmodule.exports = EVP_BytesToKey\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar R = typeof Reflect === 'object' ? Reflect : null\nvar ReflectApply = R && typeof R.apply === 'function'\n  ? R.apply\n  : function ReflectApply(target, receiver, args) {\n    return Function.prototype.apply.call(target, receiver, args);\n  }\n\nvar ReflectOwnKeys\nif (R && typeof R.ownKeys === 'function') {\n  ReflectOwnKeys = R.ownKeys\n} else if (Object.getOwnPropertySymbols) {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target)\n      .concat(Object.getOwnPropertySymbols(target));\n  };\n} else {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target);\n  };\n}\n\nfunction ProcessEmitWarning(warning) {\n  if (console && console.warn) console.warn(warning);\n}\n\nvar NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {\n  return value !== value;\n}\n\nfunction EventEmitter() {\n  EventEmitter.init.call(this);\n}\nmodule.exports = EventEmitter;\nmodule.exports.once = once;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._eventsCount = 0;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nvar defaultMaxListeners = 10;\n\nfunction checkListener(listener) {\n  if (typeof listener !== 'function') {\n    throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n  }\n}\n\nObject.defineProperty(EventEmitter, 'defaultMaxListeners', {\n  enumerable: true,\n  get: function() {\n    return defaultMaxListeners;\n  },\n  set: function(arg) {\n    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {\n      throw new RangeError('The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received ' + arg + '.');\n    }\n    defaultMaxListeners = arg;\n  }\n});\n\nEventEmitter.init = function() {\n\n  if (this._events === undefined ||\n      this._events === Object.getPrototypeOf(this)._events) {\n    this._events = Object.create(null);\n    this._eventsCount = 0;\n  }\n\n  this._maxListeners = this._maxListeners || undefined;\n};\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {\n    throw new RangeError('The value of \"n\" is out of range. It must be a non-negative number. Received ' + n + '.');\n  }\n  this._maxListeners = n;\n  return this;\n};\n\nfunction _getMaxListeners(that) {\n  if (that._maxListeners === undefined)\n    return EventEmitter.defaultMaxListeners;\n  return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n  return _getMaxListeners(this);\n};\n\nEventEmitter.prototype.emit = function emit(type) {\n  var args = [];\n  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);\n  var doError = (type === 'error');\n\n  var events = this._events;\n  if (events !== undefined)\n    doError = (doError && events.error === undefined);\n  else if (!doError)\n    return false;\n\n  // If there is no 'error' event listener then throw.\n  if (doError) {\n    var er;\n    if (args.length > 0)\n      er = args[0];\n    if (er instanceof Error) {\n      // Note: The comments on the `throw` lines are intentional, they show\n      // up in Node's output if this results in an unhandled exception.\n      throw er; // Unhandled 'error' event\n    }\n    // At least give some kind of context to the user\n    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));\n    err.context = er;\n    throw err; // Unhandled 'error' event\n  }\n\n  var handler = events[type];\n\n  if (handler === undefined)\n    return false;\n\n  if (typeof handler === 'function') {\n    ReflectApply(handler, this, args);\n  } else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      ReflectApply(listeners[i], this, args);\n  }\n\n  return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n  var m;\n  var events;\n  var existing;\n\n  checkListener(listener);\n\n  events = target._events;\n  if (events === undefined) {\n    events = target._events = Object.create(null);\n    target._eventsCount = 0;\n  } else {\n    // To avoid recursion in the case that type === \"newListener\"! Before\n    // adding it to the listeners, first emit \"newListener\".\n    if (events.newListener !== undefined) {\n      target.emit('newListener', type,\n                  listener.listener ? listener.listener : listener);\n\n      // Re-assign `events` because a newListener handler could have caused the\n      // this._events to be assigned to a new object\n      events = target._events;\n    }\n    existing = events[type];\n  }\n\n  if (existing === undefined) {\n    // Optimize the case of one listener. Don't need the extra array object.\n    existing = events[type] = listener;\n    ++target._eventsCount;\n  } else {\n    if (typeof existing === 'function') {\n      // Adding the second element, need to change to array.\n      existing = events[type] =\n        prepend ? [listener, existing] : [existing, listener];\n      // If we've already got an array, just append.\n    } else if (prepend) {\n      existing.unshift(listener);\n    } else {\n      existing.push(listener);\n    }\n\n    // Check for listener leak\n    m = _getMaxListeners(target);\n    if (m > 0 && existing.length > m && !existing.warned) {\n      existing.warned = true;\n      // No error code for this since it is a Warning\n      // eslint-disable-next-line no-restricted-syntax\n      var w = new Error('Possible EventEmitter memory leak detected. ' +\n                          existing.length + ' ' + String(type) + ' listeners ' +\n                          'added. Use emitter.setMaxListeners() to ' +\n                          'increase limit');\n      w.name = 'MaxListenersExceededWarning';\n      w.emitter = target;\n      w.type = type;\n      w.count = existing.length;\n      ProcessEmitWarning(w);\n    }\n  }\n\n  return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n  return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener =\n    function prependListener(type, listener) {\n      return _addListener(this, type, listener, true);\n    };\n\nfunction onceWrapper() {\n  if (!this.fired) {\n    this.target.removeListener(this.type, this.wrapFn);\n    this.fired = true;\n    if (arguments.length === 0)\n      return this.listener.call(this.target);\n    return this.listener.apply(this.target, arguments);\n  }\n}\n\nfunction _onceWrap(target, type, listener) {\n  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n  var wrapped = onceWrapper.bind(state);\n  wrapped.listener = listener;\n  state.wrapFn = wrapped;\n  return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n  checkListener(listener);\n  this.on(type, _onceWrap(this, type, listener));\n  return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n    function prependOnceListener(type, listener) {\n      checkListener(listener);\n      this.prependListener(type, _onceWrap(this, type, listener));\n      return this;\n    };\n\n// Emits a 'removeListener' event if and only if the listener was removed.\nEventEmitter.prototype.removeListener =\n    function removeListener(type, listener) {\n      var list, events, position, i, originalListener;\n\n      checkListener(listener);\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      list = events[type];\n      if (list === undefined)\n        return this;\n\n      if (list === listener || list.listener === listener) {\n        if (--this._eventsCount === 0)\n          this._events = Object.create(null);\n        else {\n          delete events[type];\n          if (events.removeListener)\n            this.emit('removeListener', type, list.listener || listener);\n        }\n      } else if (typeof list !== 'function') {\n        position = -1;\n\n        for (i = list.length - 1; i >= 0; i--) {\n          if (list[i] === listener || list[i].listener === listener) {\n            originalListener = list[i].listener;\n            position = i;\n            break;\n          }\n        }\n\n        if (position < 0)\n          return this;\n\n        if (position === 0)\n          list.shift();\n        else {\n          spliceOne(list, position);\n        }\n\n        if (list.length === 1)\n          events[type] = list[0];\n\n        if (events.removeListener !== undefined)\n          this.emit('removeListener', type, originalListener || listener);\n      }\n\n      return this;\n    };\n\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\n\nEventEmitter.prototype.removeAllListeners =\n    function removeAllListeners(type) {\n      var listeners, events, i;\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      // not listening for removeListener, no need to emit\n      if (events.removeListener === undefined) {\n        if (arguments.length === 0) {\n          this._events = Object.create(null);\n          this._eventsCount = 0;\n        } else if (events[type] !== undefined) {\n          if (--this._eventsCount === 0)\n            this._events = Object.create(null);\n          else\n            delete events[type];\n        }\n        return this;\n      }\n\n      // emit removeListener for all listeners on all events\n      if (arguments.length === 0) {\n        var keys = Object.keys(events);\n        var key;\n        for (i = 0; i < keys.length; ++i) {\n          key = keys[i];\n          if (key === 'removeListener') continue;\n          this.removeAllListeners(key);\n        }\n        this.removeAllListeners('removeListener');\n        this._events = Object.create(null);\n        this._eventsCount = 0;\n        return this;\n      }\n\n      listeners = events[type];\n\n      if (typeof listeners === 'function') {\n        this.removeListener(type, listeners);\n      } else if (listeners !== undefined) {\n        // LIFO order\n        for (i = listeners.length - 1; i >= 0; i--) {\n          this.removeListener(type, listeners[i]);\n        }\n      }\n\n      return this;\n    };\n\nfunction _listeners(target, type, unwrap) {\n  var events = target._events;\n\n  if (events === undefined)\n    return [];\n\n  var evlistener = events[type];\n  if (evlistener === undefined)\n    return [];\n\n  if (typeof evlistener === 'function')\n    return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n\n  return unwrap ?\n    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n  return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n  return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  if (typeof emitter.listenerCount === 'function') {\n    return emitter.listenerCount(type);\n  } else {\n    return listenerCount.call(emitter, type);\n  }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n  var events = this._events;\n\n  if (events !== undefined) {\n    var evlistener = events[type];\n\n    if (typeof evlistener === 'function') {\n      return 1;\n    } else if (evlistener !== undefined) {\n      return evlistener.length;\n    }\n  }\n\n  return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];\n};\n\nfunction arrayClone(arr, n) {\n  var copy = new Array(n);\n  for (var i = 0; i < n; ++i)\n    copy[i] = arr[i];\n  return copy;\n}\n\nfunction spliceOne(list, index) {\n  for (; index + 1 < list.length; index++)\n    list[index] = list[index + 1];\n  list.pop();\n}\n\nfunction unwrapListeners(arr) {\n  var ret = new Array(arr.length);\n  for (var i = 0; i < ret.length; ++i) {\n    ret[i] = arr[i].listener || arr[i];\n  }\n  return ret;\n}\n\nfunction once(emitter, name) {\n  return new Promise(function (resolve, reject) {\n    function errorListener(err) {\n      emitter.removeListener(name, resolver);\n      reject(err);\n    }\n\n    function resolver() {\n      if (typeof emitter.removeListener === 'function') {\n        emitter.removeListener('error', errorListener);\n      }\n      resolve([].slice.call(arguments));\n    };\n\n    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });\n    if (name !== 'error') {\n      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });\n    }\n  });\n}\n\nfunction addErrorHandlerIfEventEmitter(emitter, handler, flags) {\n  if (typeof emitter.on === 'function') {\n    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);\n  }\n}\n\nfunction eventTargetAgnosticAddListener(emitter, name, listener, flags) {\n  if (typeof emitter.on === 'function') {\n    if (flags.once) {\n      emitter.once(name, listener);\n    } else {\n      emitter.on(name, listener);\n    }\n  } else if (typeof emitter.addEventListener === 'function') {\n    // EventTarget does not have `error` event semantics like Node\n    // EventEmitters, we do not listen for `error` events here.\n    emitter.addEventListener(name, function wrapListener(arg) {\n      // IE does not have builtin `{ once: true }` support so we\n      // have to do it manually.\n      if (flags.once) {\n        emitter.removeEventListener(name, wrapListener);\n      }\n      listener(arg);\n    });\n  } else {\n    throw new TypeError('The \"emitter\" argument must be of type EventEmitter. Received type ' + typeof emitter);\n  }\n}\n"],"sourceRoot":""}