{"version":3,"sources":["webpack:///./node_modules/@metamask/post-message-stream/dist/index.js","webpack:///./src/vendor/MetaMask/MobilePortStream.js","webpack:///./node_modules/wrappy/wrappy.js","webpack:///./node_modules/json-rpc-engine/dist/index.js","webpack:///./node_modules/json-rpc-engine/dist/idRemapMiddleware.js","webpack:///./node_modules/json-rpc-engine/dist/createAsyncMiddleware.js","webpack:///./node_modules/json-rpc-engine/dist/createScaffoldMiddleware.js","webpack:///./node_modules/fast-safe-stringify/index.js","webpack:///./node_modules/eth-rpc-errors/dist/errors.js","webpack:///./node_modules/json-rpc-engine/dist/mergeMiddleware.js","webpack:///./node_modules/json-rpc-middleware-stream/dist/index.js","webpack:///./node_modules/json-rpc-middleware-stream/dist/createEngineStream.js","webpack:///./node_modules/json-rpc-middleware-stream/dist/createStreamMiddleware.js","webpack:///./node_modules/@metamask/object-multiplex/dist/ObjectMultiplex.js","webpack:///./node_modules/@metamask/object-multiplex/dist/Substream.js","webpack:///./node_modules/@metamask/inpage-provider/node_modules/fast-deep-equal/index.js","webpack:///./node_modules/@metamask/inpage-provider/node_modules/is-stream/index.js","webpack:///./node_modules/@metamask/inpage-provider/dist/siteMetadata.js","webpack:///./node_modules/@metamask/inpage-provider/dist/initializeProvider.js","webpack:///./node_modules/@metamask/post-message-stream/dist/WindowPostMessageStream.js","webpack:///./node_modules/@metamask/post-message-stream/node_modules/readable-stream/readable-browser.js","webpack:///./node_modules/@metamask/post-message-stream/node_modules/readable-stream/lib/internal/streams/BufferList.js","webpack:///./node_modules/@metamask/post-message-stream/node_modules/readable-stream/lib/_stream_passthrough.js","webpack:///./node_modules/@metamask/post-message-stream/dist/WorkerPostMessageStream.js","webpack:///./node_modules/@metamask/post-message-stream/dist/WorkerParentPostMessageStream.js","webpack:///./node_modules/@metamask/post-message-stream/node_modules/readable-stream/lib/_stream_duplex.js","webpack:///./src/vendor/inpage-metamask-mobile.js","webpack:///./src/vendor/inpage-metamask.js","webpack:///./node_modules/pump/index.js","webpack:///./node_modules/@metamask/post-message-stream/node_modules/process-nextick-args/index.js","webpack:///./node_modules/@metamask/inpage-provider/dist/index.js","webpack:///./node_modules/@metamask/object-multiplex/dist/index.js","webpack:///./node_modules/once/once.js","webpack:///./node_modules/@metamask/safe-event-emitter/index.js","webpack:///./node_modules/eth-rpc-errors/dist/index.js","webpack:///./node_modules/eth-rpc-errors/dist/classes.js","webpack:///./node_modules/eth-rpc-errors/dist/error-constants.js","webpack:///./node_modules/@metamask/post-message-stream/dist/BasePostMessageStream.js","webpack:///./node_modules/@metamask/post-message-stream/node_modules/safe-buffer/index.js","webpack:///./src/vendor/MetaMask/ReactNativePostMessageStream.js","webpack:///./node_modules/@metamask/inpage-provider/dist/MetaMaskInpageProvider.js","webpack:///./node_modules/end-of-stream/index.js","webpack:///./node_modules/json-rpc-engine/dist/getUniqueId.js","webpack:///./node_modules/json-rpc-engine/dist/JsonRpcEngine.js","webpack:///./node_modules/eth-rpc-errors/dist/utils.js","webpack:///./node_modules/@metamask/inpage-provider/dist/messages.js","webpack:///./node_modules/@metamask/inpage-provider/dist/utils.js","webpack:///./node_modules/@metamask/inpage-provider/dist/shimWeb3.js","webpack:///./node_modules/@metamask/post-message-stream/node_modules/readable-stream/lib/_stream_readable.js","webpack:///./node_modules/@metamask/post-message-stream/node_modules/readable-stream/lib/internal/streams/stream-browser.js","webpack:///./node_modules/@metamask/post-message-stream/node_modules/readable-stream/lib/internal/streams/destroy.js","webpack:///./node_modules/@metamask/post-message-stream/node_modules/readable-stream/lib/_stream_writable.js","webpack:///./node_modules/@metamask/post-message-stream/node_modules/readable-stream/lib/_stream_transform.js","webpack:///./node_modules/@metamask/post-message-stream/dist/enums.js"],"names":["Object","defineProperty","exports","value","WorkerParentPostMessageStream","WorkerPostMessageStream","WindowPostMessageStream","WindowPostMessageStream_1","enumerable","get","WorkerPostMessageStream_1","WorkerParentPostMessageStream_1","Duplex","inherits","MobilePortStream","port","call","this","objectMode","_name","name","_targetWindow","window","_port","_origin","location","origin","addEventListener","_onMessage","bind","module","prototype","event","msg","data","target","toNative","Buffer","isBuffer","_isBuffer","from","push","_onDisconnect","destroy","_read","_write","_encoding","cb","toJSON","ReactNativeWebView","postMessage","JSON","stringify","href","err","Error","wrappy","fn","TypeError","keys","forEach","k","wrapper","args","Array","arguments","length","i","ret","apply","__createBinding","create","o","m","k2","undefined","__exportStar","p","hasOwnProperty","createIdRemapMiddleware","getUniqueId_1","req","res","next","_end","originalId","id","newId","getUniqueId","done","createAsyncMiddleware","asyncMiddleware","async","end","resolveNextPromise","nextPromise","Promise","resolve","returnHandlerCallback","nextWasCalled","asyncNext","runReturnHandlersCallback","error","createScaffoldMiddleware","handlers","handler","method","result","default","stable","deterministicStringify","stableStringify","arr","replacerStack","obj","replacer","spacer","decirc","val","stack","parent","propertyDescriptor","getOwnPropertyDescriptor","configurable","isArray","key","pop","replaceGetterValues","part","compareFunction","a","b","tmp","deterministicDecirc","sort","v","splice","ethErrors","classes_1","utils_1","error_constants_1","getEthJsonRpcError","code","arg","message","parseOpts","EthereumRpcError","getMessageFromCode","getEthProviderError","EthereumProviderError","rpc","parse","errorCodes","invalidRequest","invalidParams","methodNotFound","internal","server","opts","Number","isInteger","invalidInput","resourceNotFound","resourceUnavailable","transactionRejected","methodNotSupported","limitExceeded","provider","userRejectedRequest","unauthorized","unsupportedMethod","disconnected","chainDisconnected","custom","mergeMiddleware","JsonRpcEngine_1","middlewareStack","engine","JsonRpcEngine","middleware","asMiddleware","__importDefault","mod","__esModule","createStreamMiddleware","createEngineStream","createEngineStream_1","createStreamMiddleware_1","readable_stream_1","stream","read","write","handle","_err","on","safe_event_emitter_1","idMap","events","emit","processNotification","context","assign","setTimeout","processResponse","ObjectMultiplex","end_of_stream_1","once_1","Substream_1","IGNORE_SUBSTREAM","Symbol","super","_substreams","destroyed","_readableState","ended","_writableState","substream","Substream","_cb","readable","writable","anyStreamEnd","_error","chunk","callback","console","warn","_parent","keyList","hasProp","equal","arrA","arrB","dateA","Date","dateB","getTime","regexpA","RegExp","regexpB","toString","isStream","pipe","duplex","transform","_transform","_transformState","messages_1","getSiteName","windowObject","document","siteName","querySelector","content","metaTitle","title","hostname","getSiteIcon","icons","querySelectorAll","icon","imgExists","url","reject","img","createElement","onload","onerror","src","e","log","domainMetadata","getSiteMetadata","jsonrpc","params","NOOP","errors","sendSiteMetadata","originalError","setGlobalProvider","initializeProvider","MetaMaskInpageProvider_1","shimWeb3_1","providerInstance","ethereum","dispatchEvent","Event","connectionStream","jsonRpcStreamName","logger","maxEventListeners","shouldSendMetadata","shouldSetOnWindow","shouldShimWeb3","Proxy","deleteProperty","BasePostMessageStream_1","BasePostMessageStream","targetWindow","_target","_targetOrigin","_handshake","source","_onData","removeEventListener","Stream","Readable","Writable","Transform","PassThrough","BufferList","instance","Constructor","_classCallCheck","head","tail","entry","unshift","shift","clear","join","s","concat","n","alloc","offset","allocUnsafe","copy","util","options","encoding","enums_1","DEDICATED_WORKER_NAME","self","onmessage","worker","_worker","processNextTick","objectKeys","allowHalfOpen","once","onend","onEndNT","set","_destroy","INPAGE","injectMobile","metamaskStream","pageStream","appStream","pageMux","setMaxListeners","appMux","logStreamDisconnectWarning","channelName","muxA","muxB","channelA","createStream","channelB","forwardTrafficBetweenMuxes","setupProviderStreams","remoteLabel","warningMsg","web3","navigator","userAgent","includes","eos","fs","noop","ancient","test","process","version","isFn","destroyer","reading","writing","closed","ReadStream","WriteStream","close","isFS","setHeader","abort","isRequest","to","streams","slice","destroys","map","reduce","indexOf","arg1","arg2","arg3","len","nextTick","shimWeb3","MetaMaskInpageProvider","initializeProvider_1","ObjectMultiplex_1","f","called","onceStrict","onceError","strict","proto","Function","events_1","safeApply","Reflect","SafeEventEmitter","EventEmitter","type","doError","_events","er","listeners","arrayClone","serializeError","errors_1","fast_safe_stringify_1","serialized","serialize","stringifyReplacer","_","isValidEthProviderCode","errorValues","standard","_init","_haveSyn","cork","uncork","_postMessage","buffer","copyProps","dst","SafeBuffer","encodingOrOffset","allocUnsafeSlow","size","fill","buf","SlowBuffer","PostMessageStream","top","pump_1","json_rpc_engine_1","json_rpc_middleware_stream_1","object_multiplex_1","fast_deep_equal_1","eth_rpc_errors_1","is_stream_1","siteMetadata_1","invalidDuplexStream","invalidOptions","methodKeys","invalidLoggerMethod","invalidLoggerObject","validateLoggerObject","_log","isMetaMask","_state","sentWarnings","enable","experimentalMethods","send","networkChanged","notification","accounts","isConnected","isUnlocked","initialized","isPermanentlyDisconnected","_metamask","_getExperimentalApi","selectedAddress","networkVersion","chainId","_handleAccountsChanged","_handleConnect","_handleChainChanged","_handleDisconnect","_handleStreamDisconnect","_handleUnlockStateChanged","_sendSync","_rpcRequest","_warnOfDeprecation","request","sendAsync","mux","ignoreStream","jsonRpcConnection","rpcEngine","createErrorMiddleware","_rpcEngine","_initializeState","payload","EMITTED_NOTIFICATIONS","permanentlyDisconnected","readyState","domContentLoadedHandler","invalidRequestArgs","invalidRequestMethod","invalidRequestParams","getRpcPromiseCallback","eventName","listener","addListener","prependListener","prependOnceListener","debug","info","connected","isRecoverable","errorMessage","streamName","startsWith","isEthAccounts","_accounts","account","warnings","requestBatch","requests","prop","enableDeprecation","methodOrPayload","callbackOrArgs","sendDeprecation","unsupportedSync","ws","rs","cancelled","onlegacyfinish","onfinish","onexit","exitCode","onclose","onclosenexttick","onrequest","stdio","isChildProcess","removeListener","idCounter","Math","floor","random","_middleware","_handleBatch","_handle","_promiseHandle","middlewareError","isComplete","returnHandlers","_runAllMiddleware","_runReturnHandlers","handlerCallback","reqs","responses","all","callerReq","_processRequest","_checkForCompletion","_runMiddleware","reverse","returnHandler","jsonify","isValidCode","JSON_RPC_SERVER_ERROR_MESSAGE","FALLBACK_ERROR_CODE","FALLBACK_ERROR","fallbackMessage","codeString","hasKey","isJsonRpcServerError","assignOriginalError","fallbackError","shouldIncludeStack","_a","_b","messages","unwrapResult","response","emitter","listenerCount","loggedCurrentProvider","loggedMissingProperty","SHIM_IDENTIFIER","web3Shim","currentProvider","property","catch","ReadableState","EElistenerCount","OurUint8Array","global","Uint8Array","debugUtil","debuglog","StringDecoder","destroyImpl","kProxyEvents","readableObjectMode","hwm","highWaterMark","defaultHwm","pipes","pipesCount","flowing","endEmitted","sync","needReadable","emittedReadable","readableListening","resumeScheduled","defaultEncoding","awaitDrain","readingMore","decoder","readableAddChunk","addToFront","skipChunkCheck","state","emitReadable","onEofChunk","chunkInvalid","getPrototypeOf","_uint8ArrayToBuffer","addChunk","maybeReadMore","needMoreData","_undestroy","undestroy","isPaused","setEncoding","enc","howMuchToRead","computeNewHighWaterMark","emitReadable_","flow","maybeReadMore_","nReadingNextTick","resume_","fromList","list","hasStrings","c","str","nb","copyFromBufferString","copyFromBuffer","fromListPartial","endReadable","endReadableNT","xs","x","l","parseInt","nOrig","doRead","dest","pipeOpts","endFn","stdout","stderr","unpipe","onunpipe","unpipeInfo","hasUnpiped","ondrain","ondata","cleanedUp","needDrain","pipeOnDrain","increasedAwaitDrain","pause","resume","dests","index","ev","wrap","paused","_fromList","emitErrorNT","_this","readableDestroyed","writableDestroyed","errorEmitted","ending","finished","CorkedRequest","finish","corkReq","pendingcb","corkedRequestsFree","onCorkedFinish","asyncWrite","browser","setImmediate","WritableState","internalUtil","deprecate","realHasInstance","nop","writableObjectMode","finalCalled","noDecode","decodeStrings","corked","bufferProcessing","onwrite","writecb","writelen","onwriteStateUpdate","finishMaybe","onwriteError","needFinish","bufferedRequest","clearBuffer","afterWrite","lastBufferedRequest","prefinished","bufferedRequestCount","writev","_writev","final","_final","doWrite","onwriteDrain","holder","count","allBuffers","isBuf","callFinal","need","prefinish","getBuffer","current","out","hasInstance","object","writeAfterEnd","valid","validChunk","newChunk","decodeChunk","last","writeOrBuffer","setDefaultEncoding","toLowerCase","endWritable","TransformState","afterTransform","ts","transforming","writechunk","needTransform","writeencoding","flush","_flush","err2"],"mappings":"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","file":"metaMaskFirefox.6670aac9e9324e4851cb.js","sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.WorkerParentPostMessageStream = exports.WorkerPostMessageStream = exports.WindowPostMessageStream = void 0;\nvar WindowPostMessageStream_1 = require(\"./WindowPostMessageStream\");\nObject.defineProperty(exports, \"WindowPostMessageStream\", { enumerable: true, get: function () { return WindowPostMessageStream_1.WindowPostMessageStream; } });\nvar WorkerPostMessageStream_1 = require(\"./WorkerPostMessageStream\");\nObject.defineProperty(exports, \"WorkerPostMessageStream\", { enumerable: true, get: function () { return WorkerPostMessageStream_1.WorkerPostMessageStream; } });\nvar WorkerParentPostMessageStream_1 = require(\"./WorkerParentPostMessageStream\");\nObject.defineProperty(exports, \"WorkerParentPostMessageStream\", { enumerable: true, get: function () { return WorkerParentPostMessageStream_1.WorkerParentPostMessageStream; } });\n//# sourceMappingURL=index.js.map","const { Duplex } = require('readable-stream');\nconst { inherits } = require('util');\n\nconst noop = () => undefined;\n\nmodule.exports = MobilePortStream;\n\ninherits(MobilePortStream, Duplex);\n\n/**\n * Creates a stream that's both readable and writable.\n * The stream supports arbitrary objects.\n *\n * @class\n * @param {Object} port Remote Port object\n */\nfunction MobilePortStream(port) {\n  Duplex.call(this, {\n    objectMode: true\n  });\n  this._name = port.name;\n  this._targetWindow = window;\n  this._port = port;\n  this._origin = location.origin;\n  window.addEventListener('message', this._onMessage.bind(this), false);\n}\n\n/**\n * Callback triggered when a message is received from\n * the remote Port associated with this Stream.\n *\n * @private\n * @param {Object} msg - Payload from the onMessage listener of Port\n */\nMobilePortStream.prototype._onMessage = function (event) {\n  const msg = event.data;\n\n  // validate message\n  if (this._origin !== '*' && event.origin !== this._origin) {\n    return;\n  }\n  if (!msg || typeof msg !== 'object') {\n    return;\n  }\n  if (!msg.data || typeof msg.data !== 'object') {\n    return;\n  }\n  if (msg.target && msg.target !== this._name) {\n    return;\n  }\n  // Filter outgoing messages\n  if (msg.data.data && msg.data.data.toNative) {\n    return;\n  }\n\n  if (Buffer.isBuffer(msg)) {\n    delete msg._isBuffer;\n    const data = Buffer.from(msg);\n    this.push(data);\n  } else {\n    this.push(msg);\n  }\n};\n\n/**\n * Callback triggered when the remote Port\n * associated with this Stream disconnects.\n *\n * @private\n */\nMobilePortStream.prototype._onDisconnect = function () {\n  this.destroy();\n};\n\n/**\n * Explicitly sets read operations to a no-op\n */\nMobilePortStream.prototype._read = noop;\n\n/**\n * Called internally when data should be written to\n * this writable stream.\n *\n * @private\n * @param {*} msg Arbitrary object to write\n * @param {string} encoding Encoding to use when writing payload\n * @param {Function} cb Called when writing is complete or an error occurs\n */\nMobilePortStream.prototype._write = function (msg, _encoding, cb) {\n  try {\n    if (Buffer.isBuffer(msg)) {\n      const data = msg.toJSON();\n      data._isBuffer = true;\n      window.ReactNativeWebView.postMessage(\n        JSON.stringify({ ...data, origin: window.location.href })\n      );\n    } else {\n      if (msg.data) {\n        msg.data.toNative = true;\n      }\n      window.ReactNativeWebView.postMessage(\n        JSON.stringify({ ...msg, origin: window.location.href })\n      );\n    }\n  } catch (err) {\n    return cb(new Error('MobilePortStream - disconnected'));\n  }\n  return cb();\n};\n","// Returns a wrapper function that returns a wrapped callback\n// The wrapper function should do some stuff, and return a\n// presumably different callback function.\n// This makes sure that own properties are retained, so that\n// decorations and such are not lost along the way.\nmodule.exports = wrappy\nfunction wrappy (fn, cb) {\n  if (fn && cb) return wrappy(fn)(cb)\n\n  if (typeof fn !== 'function')\n    throw new TypeError('need wrapper function')\n\n  Object.keys(fn).forEach(function (k) {\n    wrapper[k] = fn[k]\n  })\n\n  return wrapper\n\n  function wrapper() {\n    var args = new Array(arguments.length)\n    for (var i = 0; i < args.length; i++) {\n      args[i] = arguments[i]\n    }\n    var ret = fn.apply(this, args)\n    var cb = args[args.length-1]\n    if (typeof ret === 'function' && ret !== cb) {\n      Object.keys(cb).forEach(function (k) {\n        ret[k] = cb[k]\n      })\n    }\n    return ret\n  }\n}\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\n__exportStar(require(\"./idRemapMiddleware\"), exports);\n__exportStar(require(\"./createAsyncMiddleware\"), exports);\n__exportStar(require(\"./createScaffoldMiddleware\"), exports);\n__exportStar(require(\"./getUniqueId\"), exports);\n__exportStar(require(\"./JsonRpcEngine\"), exports);\n__exportStar(require(\"./mergeMiddleware\"), exports);\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7O0FBQUEsc0RBQW9DO0FBQ3BDLDBEQUF3QztBQUN4Qyw2REFBMkM7QUFDM0MsZ0RBQThCO0FBQzlCLGtEQUFnQztBQUNoQyxvREFBa0MifQ==","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createIdRemapMiddleware = void 0;\nconst getUniqueId_1 = require(\"./getUniqueId\");\nfunction createIdRemapMiddleware() {\n    return (req, res, next, _end) => {\n        const originalId = req.id;\n        const newId = getUniqueId_1.getUniqueId();\n        req.id = newId;\n        res.id = newId;\n        next((done) => {\n            req.id = originalId;\n            res.id = originalId;\n            done();\n        });\n    };\n}\nexports.createIdRemapMiddleware = createIdRemapMiddleware;\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaWRSZW1hcE1pZGRsZXdhcmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaWRSZW1hcE1pZGRsZXdhcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsK0NBQTRDO0FBRzVDLFNBQWdCLHVCQUF1QjtJQUNyQyxPQUFPLENBQUMsR0FBRyxFQUFFLEdBQUcsRUFBRSxJQUFJLEVBQUUsSUFBSSxFQUFFLEVBQUU7UUFDOUIsTUFBTSxVQUFVLEdBQUcsR0FBRyxDQUFDLEVBQUUsQ0FBQztRQUMxQixNQUFNLEtBQUssR0FBRyx5QkFBVyxFQUFFLENBQUM7UUFDNUIsR0FBRyxDQUFDLEVBQUUsR0FBRyxLQUFLLENBQUM7UUFDZixHQUFHLENBQUMsRUFBRSxHQUFHLEtBQUssQ0FBQztRQUNmLElBQUksQ0FBQyxDQUFDLElBQUksRUFBRSxFQUFFO1lBQ1osR0FBRyxDQUFDLEVBQUUsR0FBRyxVQUFVLENBQUM7WUFDcEIsR0FBRyxDQUFDLEVBQUUsR0FBRyxVQUFVLENBQUM7WUFDcEIsSUFBSSxFQUFFLENBQUM7UUFDVCxDQUFDLENBQUMsQ0FBQztJQUNMLENBQUMsQ0FBQztBQUNKLENBQUM7QUFaRCwwREFZQyJ9","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createAsyncMiddleware = void 0;\n/**\n * JsonRpcEngine only accepts callback-based middleware directly.\n * createAsyncMiddleware exists to enable consumers to pass in async middleware\n * functions.\n *\n * Async middleware have no \"end\" function. Instead, they \"end\" if they return\n * without calling \"next\". Rather than passing in explicit return handlers,\n * async middleware can simply await \"next\", and perform operations on the\n * response object when execution resumes.\n *\n * To accomplish this, createAsyncMiddleware passes the async middleware a\n * wrapped \"next\" function. That function calls the internal JsonRpcEngine\n * \"next\" function with a return handler that resolves a promise when called.\n *\n * The return handler will always be called. Its resolution of the promise\n * enables the control flow described above.\n */\nfunction createAsyncMiddleware(asyncMiddleware) {\n    return async (req, res, next, end) => {\n        // nextPromise is the key to the implementation\n        // it is resolved by the return handler passed to the\n        // \"next\" function\n        let resolveNextPromise;\n        const nextPromise = new Promise((resolve) => {\n            resolveNextPromise = resolve;\n        });\n        let returnHandlerCallback = null;\n        let nextWasCalled = false;\n        // This will be called by the consumer's async middleware.\n        const asyncNext = async () => {\n            nextWasCalled = true;\n            // We pass a return handler to next(). When it is called by the engine,\n            // the consumer's async middleware will resume executing.\n            // eslint-disable-next-line node/callback-return\n            next((runReturnHandlersCallback) => {\n                // This callback comes from JsonRpcEngine._runReturnHandlers\n                returnHandlerCallback = runReturnHandlersCallback;\n                resolveNextPromise();\n            });\n            await nextPromise;\n        };\n        try {\n            await asyncMiddleware(req, res, asyncNext);\n            if (nextWasCalled) {\n                await nextPromise; // we must wait until the return handler is called\n                returnHandlerCallback(null);\n            }\n            else {\n                end(null);\n            }\n        }\n        catch (error) {\n            if (returnHandlerCallback) {\n                returnHandlerCallback(error);\n            }\n            else {\n                end(error);\n            }\n        }\n    };\n}\nexports.createAsyncMiddleware = createAsyncMiddleware;\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlQXN5bmNNaWRkbGV3YXJlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2NyZWF0ZUFzeW5jTWlkZGxld2FyZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFnQkE7Ozs7Ozs7Ozs7Ozs7Ozs7R0FnQkc7QUFDSCxTQUFnQixxQkFBcUIsQ0FDbkMsZUFBNkM7SUFFN0MsT0FBTyxLQUFLLEVBQUUsR0FBRyxFQUFFLEdBQUcsRUFBRSxJQUFJLEVBQUUsR0FBRyxFQUFFLEVBQUU7UUFDbkMsK0NBQStDO1FBQy9DLHFEQUFxRDtRQUNyRCxrQkFBa0I7UUFDbEIsSUFBSSxrQkFBOEIsQ0FBQztRQUNuQyxNQUFNLFdBQVcsR0FBRyxJQUFJLE9BQU8sQ0FBQyxDQUFDLE9BQU8sRUFBRSxFQUFFO1lBQzFDLGtCQUFrQixHQUFHLE9BQU8sQ0FBQztRQUMvQixDQUFDLENBQUMsQ0FBQztRQUVILElBQUkscUJBQXFCLEdBQVksSUFBSSxDQUFDO1FBQzFDLElBQUksYUFBYSxHQUFHLEtBQUssQ0FBQztRQUUxQiwwREFBMEQ7UUFDMUQsTUFBTSxTQUFTLEdBQUcsS0FBSyxJQUFJLEVBQUU7WUFDM0IsYUFBYSxHQUFHLElBQUksQ0FBQztZQUVyQix1RUFBdUU7WUFDdkUseURBQXlEO1lBQ3pELGdEQUFnRDtZQUNoRCxJQUFJLENBQUMsQ0FBQyx5QkFBeUIsRUFBRSxFQUFFO2dCQUNqQyw0REFBNEQ7Z0JBQzVELHFCQUFxQixHQUFHLHlCQUF5QixDQUFDO2dCQUNsRCxrQkFBa0IsRUFBRSxDQUFDO1lBQ3ZCLENBQUMsQ0FBQyxDQUFDO1lBQ0gsTUFBTSxXQUFXLENBQUM7UUFDcEIsQ0FBQyxDQUFDO1FBRUYsSUFBSTtZQUNGLE1BQU0sZUFBZSxDQUFDLEdBQUcsRUFBRSxHQUFHLEVBQUUsU0FBUyxDQUFDLENBQUM7WUFFM0MsSUFBSSxhQUFhLEVBQUU7Z0JBQ2pCLE1BQU0sV0FBVyxDQUFDLENBQUMsa0RBQWtEO2dCQUNwRSxxQkFBK0MsQ0FBQyxJQUFJLENBQUMsQ0FBQzthQUN4RDtpQkFBTTtnQkFDTCxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUM7YUFDWDtTQUNGO1FBQUMsT0FBTyxLQUFLLEVBQUU7WUFDZCxJQUFJLHFCQUFxQixFQUFFO2dCQUN4QixxQkFBK0MsQ0FBQyxLQUFLLENBQUMsQ0FBQzthQUN6RDtpQkFBTTtnQkFDTCxHQUFHLENBQUMsS0FBSyxDQUFDLENBQUM7YUFDWjtTQUNGO0lBQ0gsQ0FBQyxDQUFDO0FBQ0osQ0FBQztBQS9DRCxzREErQ0MifQ==","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createScaffoldMiddleware = void 0;\nfunction createScaffoldMiddleware(handlers) {\n    return (req, res, next, end) => {\n        const handler = handlers[req.method];\n        // if no handler, return\n        if (handler === undefined) {\n            return next();\n        }\n        // if handler is fn, call as middleware\n        if (typeof handler === 'function') {\n            return handler(req, res, next, end);\n        }\n        // if handler is some other value, use as result\n        res.result = handler;\n        return end();\n    };\n}\nexports.createScaffoldMiddleware = createScaffoldMiddleware;\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlU2NhZmZvbGRNaWRkbGV3YXJlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2NyZWF0ZVNjYWZmb2xkTWlkZGxld2FyZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFJQSxTQUFnQix3QkFBd0IsQ0FBQyxRQUV4QztJQUNDLE9BQU8sQ0FBQyxHQUFHLEVBQUUsR0FBRyxFQUFFLElBQUksRUFBRSxHQUFHLEVBQUUsRUFBRTtRQUM3QixNQUFNLE9BQU8sR0FBRyxRQUFRLENBQUMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBQ3JDLHdCQUF3QjtRQUN4QixJQUFJLE9BQU8sS0FBSyxTQUFTLEVBQUU7WUFDekIsT0FBTyxJQUFJLEVBQUUsQ0FBQztTQUNmO1FBQ0QsdUNBQXVDO1FBQ3ZDLElBQUksT0FBTyxPQUFPLEtBQUssVUFBVSxFQUFFO1lBQ2pDLE9BQU8sT0FBTyxDQUFDLEdBQUcsRUFBRSxHQUFHLEVBQUUsSUFBSSxFQUFFLEdBQUcsQ0FBQyxDQUFDO1NBQ3JDO1FBQ0QsZ0RBQWdEO1FBQy9DLEdBQStCLENBQUMsTUFBTSxHQUFHLE9BQU8sQ0FBQztRQUNsRCxPQUFPLEdBQUcsRUFBRSxDQUFDO0lBQ2YsQ0FBQyxDQUFDO0FBQ0osQ0FBQztBQWpCRCw0REFpQkMifQ==","module.exports = stringify\nstringify.default = stringify\nstringify.stable = deterministicStringify\nstringify.stableStringify = deterministicStringify\n\nvar arr = []\nvar replacerStack = []\n\n// Regular stringify\nfunction stringify (obj, replacer, spacer) {\n  decirc(obj, '', [], undefined)\n  var res\n  if (replacerStack.length === 0) {\n    res = JSON.stringify(obj, replacer, spacer)\n  } else {\n    res = JSON.stringify(obj, replaceGetterValues(replacer), spacer)\n  }\n  while (arr.length !== 0) {\n    var part = arr.pop()\n    if (part.length === 4) {\n      Object.defineProperty(part[0], part[1], part[3])\n    } else {\n      part[0][part[1]] = part[2]\n    }\n  }\n  return res\n}\nfunction decirc (val, k, stack, parent) {\n  var i\n  if (typeof val === 'object' && val !== null) {\n    for (i = 0; i < stack.length; i++) {\n      if (stack[i] === val) {\n        var propertyDescriptor = Object.getOwnPropertyDescriptor(parent, k)\n        if (propertyDescriptor.get !== undefined) {\n          if (propertyDescriptor.configurable) {\n            Object.defineProperty(parent, k, { value: '[Circular]' })\n            arr.push([parent, k, val, propertyDescriptor])\n          } else {\n            replacerStack.push([val, k])\n          }\n        } else {\n          parent[k] = '[Circular]'\n          arr.push([parent, k, val])\n        }\n        return\n      }\n    }\n    stack.push(val)\n    // Optimize for Arrays. Big arrays could kill the performance otherwise!\n    if (Array.isArray(val)) {\n      for (i = 0; i < val.length; i++) {\n        decirc(val[i], i, stack, val)\n      }\n    } else {\n      var keys = Object.keys(val)\n      for (i = 0; i < keys.length; i++) {\n        var key = keys[i]\n        decirc(val[key], key, stack, val)\n      }\n    }\n    stack.pop()\n  }\n}\n\n// Stable-stringify\nfunction compareFunction (a, b) {\n  if (a < b) {\n    return -1\n  }\n  if (a > b) {\n    return 1\n  }\n  return 0\n}\n\nfunction deterministicStringify (obj, replacer, spacer) {\n  var tmp = deterministicDecirc(obj, '', [], undefined) || obj\n  var res\n  if (replacerStack.length === 0) {\n    res = JSON.stringify(tmp, replacer, spacer)\n  } else {\n    res = JSON.stringify(tmp, replaceGetterValues(replacer), spacer)\n  }\n  while (arr.length !== 0) {\n    var part = arr.pop()\n    if (part.length === 4) {\n      Object.defineProperty(part[0], part[1], part[3])\n    } else {\n      part[0][part[1]] = part[2]\n    }\n  }\n  return res\n}\n\nfunction deterministicDecirc (val, k, stack, parent) {\n  var i\n  if (typeof val === 'object' && val !== null) {\n    for (i = 0; i < stack.length; i++) {\n      if (stack[i] === val) {\n        var propertyDescriptor = Object.getOwnPropertyDescriptor(parent, k)\n        if (propertyDescriptor.get !== undefined) {\n          if (propertyDescriptor.configurable) {\n            Object.defineProperty(parent, k, { value: '[Circular]' })\n            arr.push([parent, k, val, propertyDescriptor])\n          } else {\n            replacerStack.push([val, k])\n          }\n        } else {\n          parent[k] = '[Circular]'\n          arr.push([parent, k, val])\n        }\n        return\n      }\n    }\n    if (typeof val.toJSON === 'function') {\n      return\n    }\n    stack.push(val)\n    // Optimize for Arrays. Big arrays could kill the performance otherwise!\n    if (Array.isArray(val)) {\n      for (i = 0; i < val.length; i++) {\n        deterministicDecirc(val[i], i, stack, val)\n      }\n    } else {\n      // Create a temporary object in the required way\n      var tmp = {}\n      var keys = Object.keys(val).sort(compareFunction)\n      for (i = 0; i < keys.length; i++) {\n        var key = keys[i]\n        deterministicDecirc(val[key], key, stack, val)\n        tmp[key] = val[key]\n      }\n      if (parent !== undefined) {\n        arr.push([parent, k, val])\n        parent[k] = tmp\n      } else {\n        return tmp\n      }\n    }\n    stack.pop()\n  }\n}\n\n// wraps replacer function to handle values we couldn't replace\n// and mark them as [Circular]\nfunction replaceGetterValues (replacer) {\n  replacer = replacer !== undefined ? replacer : function (k, v) { return v }\n  return function (key, val) {\n    if (replacerStack.length > 0) {\n      for (var i = 0; i < replacerStack.length; i++) {\n        var part = replacerStack[i]\n        if (part[1] === key && part[0] === val) {\n          val = '[Circular]'\n          replacerStack.splice(i, 1)\n          break\n        }\n      }\n    }\n    return replacer.call(this, key, val)\n  }\n}\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ethErrors = void 0;\nconst classes_1 = require(\"./classes\");\nconst utils_1 = require(\"./utils\");\nconst error_constants_1 = require(\"./error-constants\");\nexports.ethErrors = {\n    rpc: {\n        /**\n         * Get a JSON RPC 2.0 Parse (-32700) error.\n         */\n        parse: (arg) => getEthJsonRpcError(error_constants_1.errorCodes.rpc.parse, arg),\n        /**\n         * Get a JSON RPC 2.0 Invalid Request (-32600) error.\n         */\n        invalidRequest: (arg) => getEthJsonRpcError(error_constants_1.errorCodes.rpc.invalidRequest, arg),\n        /**\n         * Get a JSON RPC 2.0 Invalid Params (-32602) error.\n         */\n        invalidParams: (arg) => getEthJsonRpcError(error_constants_1.errorCodes.rpc.invalidParams, arg),\n        /**\n         * Get a JSON RPC 2.0 Method Not Found (-32601) error.\n         */\n        methodNotFound: (arg) => getEthJsonRpcError(error_constants_1.errorCodes.rpc.methodNotFound, arg),\n        /**\n         * Get a JSON RPC 2.0 Internal (-32603) error.\n         */\n        internal: (arg) => getEthJsonRpcError(error_constants_1.errorCodes.rpc.internal, arg),\n        /**\n         * Get a JSON RPC 2.0 Server error.\n         * Permits integer error codes in the [ -32099 <= -32005 ] range.\n         * Codes -32000 through -32004 are reserved by EIP-1474.\n         */\n        server: (opts) => {\n            if (!opts || typeof opts !== 'object' || Array.isArray(opts)) {\n                throw new Error('Ethereum RPC Server errors must provide single object argument.');\n            }\n            const { code } = opts;\n            if (!Number.isInteger(code) || code > -32005 || code < -32099) {\n                throw new Error('\"code\" must be an integer such that: -32099 <= code <= -32005');\n            }\n            return getEthJsonRpcError(code, opts);\n        },\n        /**\n         * Get an Ethereum JSON RPC Invalid Input (-32000) error.\n         */\n        invalidInput: (arg) => getEthJsonRpcError(error_constants_1.errorCodes.rpc.invalidInput, arg),\n        /**\n         * Get an Ethereum JSON RPC Resource Not Found (-32001) error.\n         */\n        resourceNotFound: (arg) => getEthJsonRpcError(error_constants_1.errorCodes.rpc.resourceNotFound, arg),\n        /**\n         * Get an Ethereum JSON RPC Resource Unavailable (-32002) error.\n         */\n        resourceUnavailable: (arg) => getEthJsonRpcError(error_constants_1.errorCodes.rpc.resourceUnavailable, arg),\n        /**\n         * Get an Ethereum JSON RPC Transaction Rejected (-32003) error.\n         */\n        transactionRejected: (arg) => getEthJsonRpcError(error_constants_1.errorCodes.rpc.transactionRejected, arg),\n        /**\n         * Get an Ethereum JSON RPC Method Not Supported (-32004) error.\n         */\n        methodNotSupported: (arg) => getEthJsonRpcError(error_constants_1.errorCodes.rpc.methodNotSupported, arg),\n        /**\n         * Get an Ethereum JSON RPC Limit Exceeded (-32005) error.\n         */\n        limitExceeded: (arg) => getEthJsonRpcError(error_constants_1.errorCodes.rpc.limitExceeded, arg),\n    },\n    provider: {\n        /**\n         * Get an Ethereum Provider User Rejected Request (4001) error.\n         */\n        userRejectedRequest: (arg) => {\n            return getEthProviderError(error_constants_1.errorCodes.provider.userRejectedRequest, arg);\n        },\n        /**\n         * Get an Ethereum Provider Unauthorized (4100) error.\n         */\n        unauthorized: (arg) => {\n            return getEthProviderError(error_constants_1.errorCodes.provider.unauthorized, arg);\n        },\n        /**\n         * Get an Ethereum Provider Unsupported Method (4200) error.\n         */\n        unsupportedMethod: (arg) => {\n            return getEthProviderError(error_constants_1.errorCodes.provider.unsupportedMethod, arg);\n        },\n        /**\n         * Get an Ethereum Provider Not Connected (4900) error.\n         */\n        disconnected: (arg) => {\n            return getEthProviderError(error_constants_1.errorCodes.provider.disconnected, arg);\n        },\n        /**\n         * Get an Ethereum Provider Chain Not Connected (4901) error.\n         */\n        chainDisconnected: (arg) => {\n            return getEthProviderError(error_constants_1.errorCodes.provider.chainDisconnected, arg);\n        },\n        /**\n         * Get a custom Ethereum Provider error.\n         */\n        custom: (opts) => {\n            if (!opts || typeof opts !== 'object' || Array.isArray(opts)) {\n                throw new Error('Ethereum Provider custom errors must provide single object argument.');\n            }\n            const { code, message, data } = opts;\n            if (!message || typeof message !== 'string') {\n                throw new Error('\"message\" must be a nonempty string');\n            }\n            return new classes_1.EthereumProviderError(code, message, data);\n        },\n    },\n};\n// Internal\nfunction getEthJsonRpcError(code, arg) {\n    const [message, data] = parseOpts(arg);\n    return new classes_1.EthereumRpcError(code, message || utils_1.getMessageFromCode(code), data);\n}\nfunction getEthProviderError(code, arg) {\n    const [message, data] = parseOpts(arg);\n    return new classes_1.EthereumProviderError(code, message || utils_1.getMessageFromCode(code), data);\n}\nfunction parseOpts(arg) {\n    if (arg) {\n        if (typeof arg === 'string') {\n            return [arg];\n        }\n        else if (typeof arg === 'object' && !Array.isArray(arg)) {\n            const { message, data } = arg;\n            if (message && typeof message !== 'string') {\n                throw new Error('Must specify string message.');\n            }\n            return [message || undefined, data];\n        }\n    }\n    return [];\n}\n//# sourceMappingURL=data:application/json;base64,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","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.mergeMiddleware = void 0;\nconst JsonRpcEngine_1 = require(\"./JsonRpcEngine\");\nfunction mergeMiddleware(middlewareStack) {\n    const engine = new JsonRpcEngine_1.JsonRpcEngine();\n    middlewareStack.forEach((middleware) => engine.push(middleware));\n    return engine.asMiddleware();\n}\nexports.mergeMiddleware = mergeMiddleware;\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVyZ2VNaWRkbGV3YXJlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL21lcmdlTWlkZGxld2FyZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxtREFBbUU7QUFFbkUsU0FBZ0IsZUFBZSxDQUFDLGVBQXNEO0lBQ3BGLE1BQU0sTUFBTSxHQUFHLElBQUksNkJBQWEsRUFBRSxDQUFDO0lBQ25DLGVBQWUsQ0FBQyxPQUFPLENBQUMsQ0FBQyxVQUFVLEVBQUUsRUFBRSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLENBQUMsQ0FBQztJQUNqRSxPQUFPLE1BQU0sQ0FBQyxZQUFZLEVBQUUsQ0FBQztBQUMvQixDQUFDO0FBSkQsMENBSUMifQ==","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createStreamMiddleware = exports.createEngineStream = void 0;\nconst createEngineStream_1 = __importDefault(require(\"./createEngineStream\"));\nexports.createEngineStream = createEngineStream_1.default;\nconst createStreamMiddleware_1 = __importDefault(require(\"./createStreamMiddleware\"));\nexports.createStreamMiddleware = createStreamMiddleware_1.default;\n//# sourceMappingURL=index.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst readable_stream_1 = require(\"readable-stream\");\n/**\n * Takes a JsonRpcEngine and returns a Duplex stream wrapping it.\n *\n * @param opts - Options bag.\n * @param opts.engine - The JsonRpcEngine to wrap in a stream.\n * @returns The stream wrapping the engine.\n */\nfunction createEngineStream(opts) {\n    if (!opts || !opts.engine) {\n        throw new Error('Missing engine parameter!');\n    }\n    const { engine } = opts;\n    const stream = new readable_stream_1.Duplex({ objectMode: true, read, write });\n    // forward notifications\n    if (engine.on) {\n        engine.on('notification', (message) => {\n            stream.push(message);\n        });\n    }\n    return stream;\n    function read() {\n        return undefined;\n    }\n    function write(req, _encoding, cb) {\n        engine.handle(req, (_err, res) => {\n            stream.push(res);\n        });\n        cb();\n    }\n}\nexports.default = createEngineStream;\n//# sourceMappingURL=createEngineStream.js.map","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst safe_event_emitter_1 = __importDefault(require(\"@metamask/safe-event-emitter\"));\nconst readable_stream_1 = require(\"readable-stream\");\n/**\n * Creates a JsonRpcEngine middleware with an associated Duplex stream and\n * EventEmitter. The middleware, and by extension stream, assume that middleware\n * parameters are properly formatted. No runtime type checking or validation is\n * performed.\n *\n * @returns The event emitter, middleware, and stream.\n */\nfunction createStreamMiddleware() {\n    const idMap = {};\n    const stream = new readable_stream_1.Duplex({\n        objectMode: true,\n        read: readNoop,\n        write: processMessage,\n    });\n    const events = new safe_event_emitter_1.default();\n    const middleware = (req, res, next, end) => {\n        // write req to stream\n        stream.push(req);\n        // register request on id map\n        idMap[req.id] = { req, res, next, end };\n    };\n    return { events, middleware, stream };\n    function readNoop() {\n        return false;\n    }\n    function processMessage(res, _encoding, cb) {\n        let err;\n        try {\n            const isNotification = !res.id;\n            if (isNotification) {\n                processNotification(res);\n            }\n            else {\n                processResponse(res);\n            }\n        }\n        catch (_err) {\n            err = _err;\n        }\n        // continue processing stream\n        cb(err);\n    }\n    function processResponse(res) {\n        const context = idMap[res.id];\n        if (!context) {\n            throw new Error(`StreamMiddleware - Unknown response id \"${res.id}\"`);\n        }\n        delete idMap[res.id];\n        // copy whole res onto original res\n        Object.assign(context.res, res);\n        // run callback on empty stack,\n        // prevent internal stream-handler from catching errors\n        setTimeout(context.end);\n    }\n    function processNotification(res) {\n        events.emit('notification', res);\n    }\n}\nexports.default = createStreamMiddleware;\n//# sourceMappingURL=createStreamMiddleware.js.map","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ObjectMultiplex = void 0;\nconst readable_stream_1 = require(\"readable-stream\");\nconst end_of_stream_1 = __importDefault(require(\"end-of-stream\"));\nconst once_1 = __importDefault(require(\"once\"));\nconst Substream_1 = require(\"./Substream\");\nconst IGNORE_SUBSTREAM = Symbol('IGNORE_SUBSTREAM');\nclass ObjectMultiplex extends readable_stream_1.Duplex {\n    constructor(opts = {}) {\n        super(Object.assign(Object.assign({}, opts), { objectMode: true }));\n        this._substreams = {};\n    }\n    createStream(name) {\n        // guard stream against destroyed already\n        if (this.destroyed) {\n            throw new Error(`ObjectMultiplex - parent stream for name \"${name}\" already destroyed`);\n        }\n        // guard stream against ended already\n        if (this._readableState.ended || this._writableState.ended) {\n            throw new Error(`ObjectMultiplex - parent stream for name \"${name}\" already ended`);\n        }\n        // validate name\n        if (!name) {\n            throw new Error('ObjectMultiplex - name must not be empty');\n        }\n        if (this._substreams[name]) {\n            throw new Error(`ObjectMultiplex - Substream for name \"${name}\" already exists`);\n        }\n        // create substream\n        const substream = new Substream_1.Substream({ parent: this, name });\n        this._substreams[name] = substream;\n        // listen for parent stream to end\n        anyStreamEnd(this, (_error) => {\n            return substream.destroy(_error || undefined);\n        });\n        return substream;\n    }\n    // ignore streams (dont display orphaned data warning)\n    ignoreStream(name) {\n        // validate name\n        if (!name) {\n            throw new Error('ObjectMultiplex - name must not be empty');\n        }\n        if (this._substreams[name]) {\n            throw new Error(`ObjectMultiplex - Substream for name \"${name}\" already exists`);\n        }\n        // set\n        this._substreams[name] = IGNORE_SUBSTREAM;\n    }\n    _read() {\n        return undefined;\n    }\n    _write(chunk, _encoding, callback) {\n        const { name, data } = chunk;\n        if (!name) {\n            console.warn(`ObjectMultiplex - malformed chunk without name \"${chunk}\"`);\n            return callback();\n        }\n        // get corresponding substream\n        const substream = this._substreams[name];\n        if (!substream) {\n            console.warn(`ObjectMultiplex - orphaned data for stream \"${name}\"`);\n            return callback();\n        }\n        // push data into substream\n        if (substream !== IGNORE_SUBSTREAM) {\n            substream.push(data);\n        }\n        return callback();\n    }\n}\nexports.ObjectMultiplex = ObjectMultiplex;\n// util\nfunction anyStreamEnd(stream, _cb) {\n    const cb = once_1.default(_cb);\n    end_of_stream_1.default(stream, { readable: false }, cb);\n    end_of_stream_1.default(stream, { writable: false }, cb);\n}\n//# sourceMappingURL=ObjectMultiplex.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Substream = void 0;\nconst readable_stream_1 = require(\"readable-stream\");\nclass Substream extends readable_stream_1.Duplex {\n    constructor({ parent, name }) {\n        super({ objectMode: true });\n        this._parent = parent;\n        this._name = name;\n    }\n    /**\n     * Explicitly sets read operations to a no-op.\n     */\n    _read() {\n        return undefined;\n    }\n    /**\n     * Called when data should be written to this writable stream.\n     *\n     * @param chunk - Arbitrary object to write\n     * @param encoding - Encoding to use when writing payload\n     * @param callback - Called when writing is complete or an error occurs\n     */\n    _write(chunk, _encoding, callback) {\n        this._parent.push({\n            name: this._name,\n            data: chunk,\n        });\n        callback();\n    }\n}\nexports.Substream = Substream;\n//# sourceMappingURL=Substream.js.map","'use strict';\n\nvar isArray = Array.isArray;\nvar keyList = Object.keys;\nvar hasProp = Object.prototype.hasOwnProperty;\n\nmodule.exports = function equal(a, b) {\n  if (a === b) return true;\n\n  if (a && b && typeof a == 'object' && typeof b == 'object') {\n    var arrA = isArray(a)\n      , arrB = isArray(b)\n      , i\n      , length\n      , key;\n\n    if (arrA && arrB) {\n      length = a.length;\n      if (length != b.length) return false;\n      for (i = length; i-- !== 0;)\n        if (!equal(a[i], b[i])) return false;\n      return true;\n    }\n\n    if (arrA != arrB) return false;\n\n    var dateA = a instanceof Date\n      , dateB = b instanceof Date;\n    if (dateA != dateB) return false;\n    if (dateA && dateB) return a.getTime() == b.getTime();\n\n    var regexpA = a instanceof RegExp\n      , regexpB = b instanceof RegExp;\n    if (regexpA != regexpB) return false;\n    if (regexpA && regexpB) return a.toString() == b.toString();\n\n    var keys = keyList(a);\n    length = keys.length;\n\n    if (length !== keyList(b).length)\n      return false;\n\n    for (i = length; i-- !== 0;)\n      if (!hasProp.call(b, keys[i])) return false;\n\n    for (i = length; i-- !== 0;) {\n      key = keys[i];\n      if (!equal(a[key], b[key])) return false;\n    }\n\n    return true;\n  }\n\n  return a!==a && b!==b;\n};\n","'use strict';\n\nconst isStream = stream =>\n\tstream !== null &&\n\ttypeof stream === 'object' &&\n\ttypeof stream.pipe === 'function';\n\nisStream.writable = stream =>\n\tisStream(stream) &&\n\tstream.writable !== false &&\n\ttypeof stream._write === 'function' &&\n\ttypeof stream._writableState === 'object';\n\nisStream.readable = stream =>\n\tisStream(stream) &&\n\tstream.readable !== false &&\n\ttypeof stream._read === 'function' &&\n\ttypeof stream._readableState === 'object';\n\nisStream.duplex = stream =>\n\tisStream.writable(stream) &&\n\tisStream.readable(stream);\n\nisStream.transform = stream =>\n\tisStream.duplex(stream) &&\n\ttypeof stream._transform === 'function' &&\n\ttypeof stream._transformState === 'object';\n\nmodule.exports = isStream;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst messages_1 = __importDefault(require(\"./messages\"));\nconst utils_1 = require(\"./utils\");\n/**\n * Sends site metadata over an RPC request.\n *\n * @param engine - The JSON RPC Engine to send metadata over.\n * @param log - The logging API to use.\n */\nasync function sendSiteMetadata(engine, log) {\n    try {\n        const domainMetadata = await getSiteMetadata();\n        // call engine.handle directly to avoid normal RPC request handling\n        engine.handle({\n            jsonrpc: '2.0',\n            id: 1,\n            method: 'metamask_sendDomainMetadata',\n            params: domainMetadata,\n        }, utils_1.NOOP);\n    }\n    catch (error) {\n        log.error({\n            message: messages_1.default.errors.sendSiteMetadata(),\n            originalError: error,\n        });\n    }\n}\nexports.default = sendSiteMetadata;\n/**\n * Gets site metadata and returns it\n *\n */\nasync function getSiteMetadata() {\n    return {\n        name: getSiteName(window),\n        icon: await getSiteIcon(window),\n    };\n}\n/**\n * Extracts a name for the site from the DOM\n */\nfunction getSiteName(windowObject) {\n    const { document } = windowObject;\n    const siteName = document.querySelector('head > meta[property=\"og:site_name\"]');\n    if (siteName) {\n        return siteName.content;\n    }\n    const metaTitle = document.querySelector('head > meta[name=\"title\"]');\n    if (metaTitle) {\n        return metaTitle.content;\n    }\n    if (document.title && document.title.length > 0) {\n        return document.title;\n    }\n    return window.location.hostname;\n}\n/**\n * Extracts an icon for the site from the DOM\n * @returns an icon URL\n */\nasync function getSiteIcon(windowObject) {\n    const { document } = windowObject;\n    const icons = document.querySelectorAll('head > link[rel~=\"icon\"]');\n    for (const icon of icons) {\n        if (icon && await imgExists(icon.href)) {\n            return icon.href;\n        }\n    }\n    return null;\n}\n/**\n * Returns whether the given image URL exists\n * @param url - the url of the image\n * @returns Whether the image exists.\n */\nfunction imgExists(url) {\n    return new Promise((resolve, reject) => {\n        try {\n            const img = document.createElement('img');\n            img.onload = () => resolve(true);\n            img.onerror = () => resolve(false);\n            img.src = url;\n        }\n        catch (e) {\n            reject(e);\n        }\n    });\n}\n//# sourceMappingURL=siteMetadata.js.map","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.setGlobalProvider = exports.initializeProvider = void 0;\nconst MetaMaskInpageProvider_1 = __importDefault(require(\"./MetaMaskInpageProvider\"));\nconst shimWeb3_1 = __importDefault(require(\"./shimWeb3\"));\n/**\n * Initializes a MetaMaskInpageProvider and (optionally) assigns it as window.ethereum.\n *\n * @param options - An options bag.\n * @param options.connectionStream - A Node.js stream.\n * @param options.jsonRpcStreamName - The name of the internal JSON-RPC stream.\n * @param options.maxEventListeners - The maximum number of event listeners.\n * @param options.shouldSendMetadata - Whether the provider should send page metadata.\n * @param options.shouldSetOnWindow - Whether the provider should be set as window.ethereum.\n * @param options.shouldShimWeb3 - Whether a window.web3 shim should be injected.\n * @returns The initialized provider (whether set or not).\n */\nfunction initializeProvider({ connectionStream, jsonRpcStreamName, logger = console, maxEventListeners = 100, shouldSendMetadata = true, shouldSetOnWindow = true, shouldShimWeb3 = false, }) {\n    let provider = new MetaMaskInpageProvider_1.default(connectionStream, {\n        jsonRpcStreamName,\n        logger,\n        maxEventListeners,\n        shouldSendMetadata,\n    });\n    provider = new Proxy(provider, {\n        // some common libraries, e.g. web3@1.x, mess with our API\n        deleteProperty: () => true,\n    });\n    if (shouldSetOnWindow) {\n        setGlobalProvider(provider);\n    }\n    if (shouldShimWeb3) {\n        shimWeb3_1.default(provider, logger);\n    }\n    return provider;\n}\nexports.initializeProvider = initializeProvider;\n/**\n * Sets the given provider instance as window.ethereum and dispatches the\n * 'ethereum#initialized' event on window.\n *\n * @param providerInstance - The provider instance.\n */\nfunction setGlobalProvider(providerInstance) {\n    window.ethereum = providerInstance;\n    window.dispatchEvent(new Event('ethereum#initialized'));\n}\nexports.setGlobalProvider = setGlobalProvider;\n//# sourceMappingURL=initializeProvider.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.WindowPostMessageStream = void 0;\nconst BasePostMessageStream_1 = require(\"./BasePostMessageStream\");\n/**\n * Window.postMessage stream.\n */\nclass WindowPostMessageStream extends BasePostMessageStream_1.BasePostMessageStream {\n    /**\n     * Creates a stream for communicating with other streams across the same or\n     * different window objects.\n     *\n     * @param args.name - The name of the stream. Used to differentiate between\n     * multiple streams sharing the same window object.\n     * @param args.target - The name of the stream to exchange messages with.\n     * @param args.targetWindow - The window object of the target stream. Defaults\n     * to `window`.\n     */\n    constructor({ name, target, targetWindow }) {\n        if (!name || !target) {\n            throw new Error('Invalid input.');\n        }\n        super();\n        this._name = name;\n        this._target = target;\n        this._targetOrigin = targetWindow ? '*' : location.origin;\n        this._targetWindow = targetWindow || window;\n        this._onMessage = this._onMessage.bind(this);\n        window.addEventListener('message', this._onMessage, false);\n        this._handshake();\n    }\n    _postMessage(data) {\n        this._targetWindow.postMessage({\n            target: this._target,\n            data,\n        }, this._targetOrigin);\n    }\n    _onMessage(event) {\n        const message = event.data;\n        // validate message\n        if ((this._targetOrigin !== '*' && event.origin !== this._targetOrigin) ||\n            event.source !== this._targetWindow ||\n            typeof message !== 'object' ||\n            message.target !== this._name ||\n            !message.data) {\n            return;\n        }\n        this._onData(message.data);\n    }\n    _destroy() {\n        window.removeEventListener('message', this._onMessage, false);\n    }\n}\nexports.WindowPostMessageStream = WindowPostMessageStream;\n//# sourceMappingURL=WindowPostMessageStream.js.map","exports = module.exports = require('./lib/_stream_readable.js');\nexports.Stream = exports;\nexports.Readable = exports;\nexports.Writable = require('./lib/_stream_writable.js');\nexports.Duplex = require('./lib/_stream_duplex.js');\nexports.Transform = require('./lib/_stream_transform.js');\nexports.PassThrough = require('./lib/_stream_passthrough.js');\n","'use strict';\n\n/*<replacement>*/\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar Buffer = require('safe-buffer').Buffer;\n/*</replacement>*/\n\nfunction copyBuffer(src, target, offset) {\n  src.copy(target, offset);\n}\n\nmodule.exports = function () {\n  function BufferList() {\n    _classCallCheck(this, BufferList);\n\n    this.head = null;\n    this.tail = null;\n    this.length = 0;\n  }\n\n  BufferList.prototype.push = function push(v) {\n    var entry = { data: v, next: null };\n    if (this.length > 0) this.tail.next = entry;else this.head = entry;\n    this.tail = entry;\n    ++this.length;\n  };\n\n  BufferList.prototype.unshift = function unshift(v) {\n    var entry = { data: v, next: this.head };\n    if (this.length === 0) this.tail = entry;\n    this.head = entry;\n    ++this.length;\n  };\n\n  BufferList.prototype.shift = function shift() {\n    if (this.length === 0) return;\n    var ret = this.head.data;\n    if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;\n    --this.length;\n    return ret;\n  };\n\n  BufferList.prototype.clear = function clear() {\n    this.head = this.tail = null;\n    this.length = 0;\n  };\n\n  BufferList.prototype.join = function join(s) {\n    if (this.length === 0) return '';\n    var p = this.head;\n    var ret = '' + p.data;\n    while (p = p.next) {\n      ret += s + p.data;\n    }return ret;\n  };\n\n  BufferList.prototype.concat = function concat(n) {\n    if (this.length === 0) return Buffer.alloc(0);\n    if (this.length === 1) return this.head.data;\n    var ret = Buffer.allocUnsafe(n >>> 0);\n    var p = this.head;\n    var i = 0;\n    while (p) {\n      copyBuffer(p.data, ret, i);\n      i += p.data.length;\n      p = p.next;\n    }\n    return ret;\n  };\n\n  return BufferList;\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// a passthrough stream.\n// basically just the most minimal sort of Transform stream.\n// Every written chunk gets output as-is.\n\n'use strict';\n\nmodule.exports = PassThrough;\n\nvar Transform = require('./_stream_transform');\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nutil.inherits(PassThrough, Transform);\n\nfunction PassThrough(options) {\n  if (!(this instanceof PassThrough)) return new PassThrough(options);\n\n  Transform.call(this, options);\n}\n\nPassThrough.prototype._transform = function (chunk, encoding, cb) {\n  cb(null, chunk);\n};","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.WorkerPostMessageStream = void 0;\n/* istanbul ignore file */\n// We ignore coverage for the entire file due to limits on our instrumentation,\n// but it is in fact covered by our tests.\nconst BasePostMessageStream_1 = require(\"./BasePostMessageStream\");\nconst enums_1 = require(\"./enums\");\n/**\n * Worker-side dedicated web worker `postMessage` stream.\n */\nclass WorkerPostMessageStream extends BasePostMessageStream_1.BasePostMessageStream {\n    /**\n     * Note: Designed for use in web workers only.\n     *\n     * Creates a stream for communicating with the window that created this web\n     * worker.\n     */\n    constructor() {\n        super();\n        this._name = enums_1.DEDICATED_WORKER_NAME;\n        self.onmessage = this._onMessage.bind(this);\n        this._handshake();\n    }\n    _postMessage(data) {\n        // Cast of self.postMessage due to usage of DOM lib\n        self.postMessage({ data });\n    }\n    _onMessage(event) {\n        const message = event.data;\n        // validate message\n        if (typeof message !== 'object' ||\n            message.target !== this._name ||\n            !message.data) {\n            return;\n        }\n        this._onData(message.data);\n    }\n    // worker stream lifecycle assumed to be coterminous with global scope\n    _destroy() {\n        return undefined;\n    }\n}\nexports.WorkerPostMessageStream = WorkerPostMessageStream;\n//# sourceMappingURL=WorkerPostMessageStream.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.WorkerParentPostMessageStream = void 0;\nconst BasePostMessageStream_1 = require(\"./BasePostMessageStream\");\nconst enums_1 = require(\"./enums\");\n/**\n * Parent-side dedicated web worker `postMessage` stream.\n */\nclass WorkerParentPostMessageStream extends BasePostMessageStream_1.BasePostMessageStream {\n    /**\n     * Creates a stream for communicating with a dedicated web worker.\n     *\n     * @param args.worker - The Web Worker to exchange messages with. The worker\n     * must instantiate a WorkerPostMessageStream.\n     */\n    constructor({ worker }) {\n        if (!worker) {\n            throw new Error('Invalid input.');\n        }\n        super();\n        this._target = enums_1.DEDICATED_WORKER_NAME;\n        this._worker = worker;\n        this._worker.onmessage = this._onMessage.bind(this);\n        this._handshake();\n    }\n    _postMessage(data) {\n        this._worker.postMessage({\n            target: this._target,\n            data,\n        });\n    }\n    _onMessage(event) {\n        const message = event.data;\n        // validate message\n        if (typeof message !== 'object' || !message.data) {\n            return;\n        }\n        this._onData(message.data);\n    }\n    _destroy() {\n        this._worker.onmessage = null;\n        this._worker = null;\n    }\n}\nexports.WorkerParentPostMessageStream = WorkerParentPostMessageStream;\n//# sourceMappingURL=WorkerParentPostMessageStream.js.map","// 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// a duplex stream is just a stream that is both readable and writable.\n// Since JS doesn't have multiple prototypal inheritance, this class\n// prototypally inherits from Readable, and then parasitically from\n// Writable.\n\n'use strict';\n\n/*<replacement>*/\n\nvar processNextTick = require('process-nextick-args');\n/*</replacement>*/\n\n/*<replacement>*/\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n  for (var key in obj) {\n    keys.push(key);\n  }return keys;\n};\n/*</replacement>*/\n\nmodule.exports = Duplex;\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nvar Readable = require('./_stream_readable');\nvar Writable = require('./_stream_writable');\n\nutil.inherits(Duplex, Readable);\n\nvar keys = objectKeys(Writable.prototype);\nfor (var v = 0; v < keys.length; v++) {\n  var method = keys[v];\n  if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];\n}\n\nfunction Duplex(options) {\n  if (!(this instanceof Duplex)) return new Duplex(options);\n\n  Readable.call(this, options);\n  Writable.call(this, options);\n\n  if (options && options.readable === false) this.readable = false;\n\n  if (options && options.writable === false) this.writable = false;\n\n  this.allowHalfOpen = true;\n  if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;\n\n  this.once('end', onend);\n}\n\n// the no-half-open enforcer\nfunction onend() {\n  // if we allow half-open state, or if the writable side ended,\n  // then we're ok.\n  if (this.allowHalfOpen || this._writableState.ended) return;\n\n  // no more data can be written.\n  // But allow more writes to happen in this tick.\n  processNextTick(onEndNT, this);\n}\n\nfunction onEndNT(self) {\n  self.end();\n}\n\nObject.defineProperty(Duplex.prototype, 'destroyed', {\n  get: function () {\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed && this._writableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._readableState.destroyed = value;\n    this._writableState.destroyed = value;\n  }\n});\n\nDuplex.prototype._destroy = function (err, cb) {\n  this.push(null);\n  this.end();\n\n  processNextTick(cb, err);\n};\n\nfunction forEach(xs, f) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    f(xs[i], i);\n  }\n}","// Based of: https://github.com/MetaMask/mobile-provider/blob/main/src/inpage/index.js\n\nimport { initializeProvider } from '@metamask/inpage-provider';\nimport ObjectMultiplex from '@metamask/object-multiplex';\nimport pump from 'pump';\n\nimport MobilePortStream from './MetaMask/MobilePortStream';\nimport ReactNativePostMessageStream from './MetaMask/ReactNativePostMessageStream';\n\nconst INPAGE = 'metamask-inpage';\nconst CONTENT_SCRIPT = 'metamask-contentscript';\nconst PROVIDER = 'metamask-provider';\n\nexport const injectMobile = () => {\n  // Setup stream for content script communication\n  const metamaskStream = new ReactNativePostMessageStream({\n    name: INPAGE,\n    target: CONTENT_SCRIPT\n  });\n\n  // Initialize provider object (window.ethereum)\n  initializeProvider({\n    connectionStream: metamaskStream,\n    shouldSendMetadata: false\n  });\n\n  setupProviderStreams();\n};\n\n// Functions\n\n/**\n * Setup function called from content script after the DOM is ready.\n */\nfunction setupProviderStreams() {\n  // the transport-specific streams for communication between inpage and background\n  const pageStream = new ReactNativePostMessageStream({\n    name: CONTENT_SCRIPT,\n    target: INPAGE\n  });\n\n  const appStream = new MobilePortStream({\n    name: CONTENT_SCRIPT\n  });\n\n  // create and connect channel muxes\n  // so we can handle the channels individually\n  const pageMux = new ObjectMultiplex();\n  pageMux.setMaxListeners(25);\n  const appMux = new ObjectMultiplex();\n  appMux.setMaxListeners(25);\n\n  pump(pageMux, pageStream, pageMux, (err) =>\n    logStreamDisconnectWarning('MetaMask Inpage Multiplex', err)\n  );\n  pump(appMux, appStream, appMux, (err) => {\n    logStreamDisconnectWarning('MetaMask Background Multiplex', err);\n    notifyProviderOfStreamFailure();\n  });\n\n  // forward communication across inpage-background for these channels only\n  forwardTrafficBetweenMuxes(PROVIDER, pageMux, appMux);\n}\n\n/**\n * Set up two-way communication between muxes for a single, named channel.\n *\n * @param {string} channelName - The name of the channel.\n * @param {ObjectMultiplex} muxA - The first mux.\n * @param {ObjectMultiplex} muxB - The second mux.\n */\nfunction forwardTrafficBetweenMuxes(channelName, muxA, muxB) {\n  const channelA = muxA.createStream(channelName);\n  const channelB = muxB.createStream(channelName);\n  pump(channelA, channelB, channelA, (err) =>\n    logStreamDisconnectWarning(`MetaMask muxed traffic for channel \"${channelName}\" failed.`, err)\n  );\n}\n\n/**\n * Error handler for page to extension stream disconnections\n *\n * @param {string} remoteLabel - Remote stream name\n * @param {Error} err - Stream connection error\n */\nfunction logStreamDisconnectWarning(remoteLabel, err) {\n  let warningMsg = `MetamaskContentscript - lost connection to ${remoteLabel}`;\n  if (err) {\n    warningMsg += `\\n${err.stack}`;\n  }\n  console.warn(warningMsg);\n  console.error(err);\n}\n\n/**\n * This function must ONLY be called in pump destruction/close callbacks.\n * Notifies the inpage context that streams have failed, via window.postMessage.\n * Relies on @metamask/object-multiplex and post-message-stream implementation details.\n */\nfunction notifyProviderOfStreamFailure() {\n  window.postMessage(\n    {\n      target: INPAGE, // the post-message-stream \"target\"\n      data: {\n        // this object gets passed to object-multiplex\n        name: PROVIDER, // the object-multiplex channel name\n        data: {\n          jsonrpc: '2.0',\n          method: 'METAMASK_STREAM_FAILURE'\n        }\n      }\n    },\n    window.location.origin\n  );\n}\n","import { initializeProvider } from '@metamask/inpage-provider';\nimport { WindowPostMessageStream } from '@metamask/post-message-stream';\n\nimport { injectMobile } from './inpage-metamask-mobile';\n\n// MetaMask injection hack\n// Due to https://github.com/MetaMask/metamask-extension/issues/3133\n\n(() => {\n  if (window.ethereum || window.web3) {\n    return;\n  }\n  if (navigator.userAgent.includes('Firefox')) {\n    // setup background connection\n    const metamaskStream = new WindowPostMessageStream({\n      name: 'metamask-inpage',\n      target: 'metamask-contentscript'\n    });\n\n    // this will initialize the provider and set it as window.ethereum\n    initializeProvider({\n      connectionStream: metamaskStream,\n      shouldShimWeb3: true\n    });\n  } else if (navigator.userAgent.includes('iPhone')) {\n    injectMobile();\n  }\n})();\n","var once = require('once')\nvar eos = require('end-of-stream')\nvar fs = require('fs') // we only need fs to get the ReadStream and WriteStream prototypes\n\nvar noop = function () {}\nvar ancient = /^v?\\.0/.test(process.version)\n\nvar isFn = function (fn) {\n  return typeof fn === 'function'\n}\n\nvar isFS = function (stream) {\n  if (!ancient) return false // newer node version do not need to care about fs is a special way\n  if (!fs) return false // browser\n  return (stream instanceof (fs.ReadStream || noop) || stream instanceof (fs.WriteStream || noop)) && isFn(stream.close)\n}\n\nvar isRequest = function (stream) {\n  return stream.setHeader && isFn(stream.abort)\n}\n\nvar destroyer = function (stream, reading, writing, callback) {\n  callback = once(callback)\n\n  var closed = false\n  stream.on('close', function () {\n    closed = true\n  })\n\n  eos(stream, {readable: reading, writable: writing}, function (err) {\n    if (err) return callback(err)\n    closed = true\n    callback()\n  })\n\n  var destroyed = false\n  return function (err) {\n    if (closed) return\n    if (destroyed) return\n    destroyed = true\n\n    if (isFS(stream)) return stream.close(noop) // use close for fs streams to avoid fd leaks\n    if (isRequest(stream)) return stream.abort() // request.destroy just do .end - .abort is what we want\n\n    if (isFn(stream.destroy)) return stream.destroy()\n\n    callback(err || new Error('stream was destroyed'))\n  }\n}\n\nvar call = function (fn) {\n  fn()\n}\n\nvar pipe = function (from, to) {\n  return from.pipe(to)\n}\n\nvar pump = function () {\n  var streams = Array.prototype.slice.call(arguments)\n  var callback = isFn(streams[streams.length - 1] || noop) && streams.pop() || noop\n\n  if (Array.isArray(streams[0])) streams = streams[0]\n  if (streams.length < 2) throw new Error('pump requires two streams per minimum')\n\n  var error\n  var destroys = streams.map(function (stream, i) {\n    var reading = i < streams.length - 1\n    var writing = i > 0\n    return destroyer(stream, reading, writing, function (err) {\n      if (!error) error = err\n      if (err) destroys.forEach(call)\n      if (reading) return\n      destroys.forEach(call)\n      callback(error)\n    })\n  })\n\n  return streams.reduce(pipe)\n}\n\nmodule.exports = pump\n","'use strict';\n\nif (!process.version ||\n    process.version.indexOf('v0.') === 0 ||\n    process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {\n  module.exports = nextTick;\n} else {\n  module.exports = process.nextTick;\n}\n\nfunction nextTick(fn, arg1, arg2, arg3) {\n  if (typeof fn !== 'function') {\n    throw new TypeError('\"callback\" argument must be a function');\n  }\n  var len = arguments.length;\n  var args, i;\n  switch (len) {\n  case 0:\n  case 1:\n    return process.nextTick(fn);\n  case 2:\n    return process.nextTick(function afterTickOne() {\n      fn.call(null, arg1);\n    });\n  case 3:\n    return process.nextTick(function afterTickTwo() {\n      fn.call(null, arg1, arg2);\n    });\n  case 4:\n    return process.nextTick(function afterTickThree() {\n      fn.call(null, arg1, arg2, arg3);\n    });\n  default:\n    args = new Array(len - 1);\n    i = 0;\n    while (i < args.length) {\n      args[i++] = arguments[i];\n    }\n    return process.nextTick(function afterTick() {\n      fn.apply(null, args);\n    });\n  }\n}\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.shimWeb3 = exports.setGlobalProvider = exports.MetaMaskInpageProvider = exports.initializeProvider = void 0;\nconst MetaMaskInpageProvider_1 = __importDefault(require(\"./MetaMaskInpageProvider\"));\nexports.MetaMaskInpageProvider = MetaMaskInpageProvider_1.default;\nconst initializeProvider_1 = require(\"./initializeProvider\");\nObject.defineProperty(exports, \"initializeProvider\", { enumerable: true, get: function () { return initializeProvider_1.initializeProvider; } });\nObject.defineProperty(exports, \"setGlobalProvider\", { enumerable: true, get: function () { return initializeProvider_1.setGlobalProvider; } });\nconst shimWeb3_1 = __importDefault(require(\"./shimWeb3\"));\nexports.shimWeb3 = shimWeb3_1.default;\n//# sourceMappingURL=index.js.map","\"use strict\";\nconst ObjectMultiplex_1 = require(\"./ObjectMultiplex\");\nmodule.exports = ObjectMultiplex_1.ObjectMultiplex;\n//# sourceMappingURL=index.js.map","var wrappy = require('wrappy')\nmodule.exports = wrappy(once)\nmodule.exports.strict = wrappy(onceStrict)\n\nonce.proto = once(function () {\n  Object.defineProperty(Function.prototype, 'once', {\n    value: function () {\n      return once(this)\n    },\n    configurable: true\n  })\n\n  Object.defineProperty(Function.prototype, 'onceStrict', {\n    value: function () {\n      return onceStrict(this)\n    },\n    configurable: true\n  })\n})\n\nfunction once (fn) {\n  var f = function () {\n    if (f.called) return f.value\n    f.called = true\n    return f.value = fn.apply(this, arguments)\n  }\n  f.called = false\n  return f\n}\n\nfunction onceStrict (fn) {\n  var f = function () {\n    if (f.called)\n      throw new Error(f.onceError)\n    f.called = true\n    return f.value = fn.apply(this, arguments)\n  }\n  var name = fn.name || 'Function wrapped with `once`'\n  f.onceError = name + \" shouldn't be called more than once\"\n  f.called = false\n  return f\n}\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst events_1 = require(\"events\");\nfunction safeApply(handler, context, args) {\n    try {\n        Reflect.apply(handler, context, args);\n    }\n    catch (err) {\n        // Throw error after timeout so as not to interrupt the stack\n        setTimeout(() => {\n            throw err;\n        });\n    }\n}\nfunction arrayClone(arr) {\n    const n = arr.length;\n    const copy = new Array(n);\n    for (let i = 0; i < n; i += 1) {\n        copy[i] = arr[i];\n    }\n    return copy;\n}\nclass SafeEventEmitter extends events_1.EventEmitter {\n    emit(type, ...args) {\n        let doError = type === 'error';\n        const events = this._events;\n        if (events !== undefined) {\n            doError = doError && events.error === undefined;\n        }\n        else if (!doError) {\n            return false;\n        }\n        // If there is no 'error' event listener then throw.\n        if (doError) {\n            let er;\n            if (args.length > 0) {\n                [er] = args;\n            }\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            const err = new Error(`Unhandled error.${er ? ` (${er.message})` : ''}`);\n            err.context = er;\n            throw err; // Unhandled 'error' event\n        }\n        const handler = events[type];\n        if (handler === undefined) {\n            return false;\n        }\n        if (typeof handler === 'function') {\n            safeApply(handler, this, args);\n        }\n        else {\n            const len = handler.length;\n            const listeners = arrayClone(handler);\n            for (let i = 0; i < len; i += 1) {\n                safeApply(listeners[i], this, args);\n            }\n        }\n        return true;\n    }\n}\nexports.default = SafeEventEmitter;\n//# sourceMappingURL=index.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.getMessageFromCode = exports.serializeError = exports.EthereumProviderError = exports.EthereumRpcError = exports.ethErrors = exports.errorCodes = void 0;\nconst classes_1 = require(\"./classes\");\nObject.defineProperty(exports, \"EthereumRpcError\", { enumerable: true, get: function () { return classes_1.EthereumRpcError; } });\nObject.defineProperty(exports, \"EthereumProviderError\", { enumerable: true, get: function () { return classes_1.EthereumProviderError; } });\nconst utils_1 = require(\"./utils\");\nObject.defineProperty(exports, \"serializeError\", { enumerable: true, get: function () { return utils_1.serializeError; } });\nObject.defineProperty(exports, \"getMessageFromCode\", { enumerable: true, get: function () { return utils_1.getMessageFromCode; } });\nconst errors_1 = require(\"./errors\");\nObject.defineProperty(exports, \"ethErrors\", { enumerable: true, get: function () { return errors_1.ethErrors; } });\nconst error_constants_1 = require(\"./error-constants\");\nObject.defineProperty(exports, \"errorCodes\", { enumerable: true, get: function () { return error_constants_1.errorCodes; } });\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsdUNBQW9FO0FBVWxFLGlHQVZPLDBCQUFnQixPQVVQO0FBQ2hCLHNHQVh5QiwrQkFBcUIsT0FXekI7QUFWdkIsbUNBRWlCO0FBU2YsK0ZBVkEsc0JBQWMsT0FVQTtBQUNkLG1HQVhnQiwwQkFBa0IsT0FXaEI7QUFUcEIscUNBQXFDO0FBS25DLDBGQUxPLGtCQUFTLE9BS1A7QUFKWCx1REFBK0M7QUFHN0MsMkZBSE8sNEJBQVUsT0FHUCJ9","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.EthereumProviderError = exports.EthereumRpcError = void 0;\nconst fast_safe_stringify_1 = require(\"fast-safe-stringify\");\n/**\n * Error subclass implementing JSON RPC 2.0 errors and Ethereum RPC errors\n * per EIP-1474.\n * Permits any integer error code.\n */\nclass EthereumRpcError extends Error {\n    constructor(code, message, data) {\n        if (!Number.isInteger(code)) {\n            throw new Error('\"code\" must be an integer.');\n        }\n        if (!message || typeof message !== 'string') {\n            throw new Error('\"message\" must be a nonempty string.');\n        }\n        super(message);\n        this.code = code;\n        if (data !== undefined) {\n            this.data = data;\n        }\n    }\n    /**\n     * Returns a plain object with all public class properties.\n     */\n    serialize() {\n        const serialized = {\n            code: this.code,\n            message: this.message,\n        };\n        if (this.data !== undefined) {\n            serialized.data = this.data;\n        }\n        if (this.stack) {\n            serialized.stack = this.stack;\n        }\n        return serialized;\n    }\n    /**\n     * Return a string representation of the serialized error, omitting\n     * any circular references.\n     */\n    toString() {\n        return fast_safe_stringify_1.default(this.serialize(), stringifyReplacer, 2);\n    }\n}\nexports.EthereumRpcError = EthereumRpcError;\n/**\n * Error subclass implementing Ethereum Provider errors per EIP-1193.\n * Permits integer error codes in the [ 1000 <= 4999 ] range.\n */\nclass EthereumProviderError extends EthereumRpcError {\n    /**\n     * Create an Ethereum Provider JSON-RPC error.\n     * `code` must be an integer in the 1000 <= 4999 range.\n     */\n    constructor(code, message, data) {\n        if (!isValidEthProviderCode(code)) {\n            throw new Error('\"code\" must be an integer such that: 1000 <= code <= 4999');\n        }\n        super(code, message, data);\n    }\n}\nexports.EthereumProviderError = EthereumProviderError;\n// Internal\nfunction isValidEthProviderCode(code) {\n    return Number.isInteger(code) && code >= 1000 && code <= 4999;\n}\nfunction stringifyReplacer(_, value) {\n    if (value === '[Circular]') {\n        return undefined;\n    }\n    return value;\n}\n//# sourceMappingURL=data:application/json;base64,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","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.errorValues = exports.errorCodes = void 0;\nexports.errorCodes = {\n    rpc: {\n        invalidInput: -32000,\n        resourceNotFound: -32001,\n        resourceUnavailable: -32002,\n        transactionRejected: -32003,\n        methodNotSupported: -32004,\n        limitExceeded: -32005,\n        parse: -32700,\n        invalidRequest: -32600,\n        methodNotFound: -32601,\n        invalidParams: -32602,\n        internal: -32603,\n    },\n    provider: {\n        userRejectedRequest: 4001,\n        unauthorized: 4100,\n        unsupportedMethod: 4200,\n        disconnected: 4900,\n        chainDisconnected: 4901,\n    },\n};\nexports.errorValues = {\n    '-32700': {\n        standard: 'JSON RPC 2.0',\n        message: 'Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text.',\n    },\n    '-32600': {\n        standard: 'JSON RPC 2.0',\n        message: 'The JSON sent is not a valid Request object.',\n    },\n    '-32601': {\n        standard: 'JSON RPC 2.0',\n        message: 'The method does not exist / is not available.',\n    },\n    '-32602': {\n        standard: 'JSON RPC 2.0',\n        message: 'Invalid method parameter(s).',\n    },\n    '-32603': {\n        standard: 'JSON RPC 2.0',\n        message: 'Internal JSON-RPC error.',\n    },\n    '-32000': {\n        standard: 'EIP-1474',\n        message: 'Invalid input.',\n    },\n    '-32001': {\n        standard: 'EIP-1474',\n        message: 'Resource not found.',\n    },\n    '-32002': {\n        standard: 'EIP-1474',\n        message: 'Resource unavailable.',\n    },\n    '-32003': {\n        standard: 'EIP-1474',\n        message: 'Transaction rejected.',\n    },\n    '-32004': {\n        standard: 'EIP-1474',\n        message: 'Method not supported.',\n    },\n    '-32005': {\n        standard: 'EIP-1474',\n        message: 'Request limit exceeded.',\n    },\n    '4001': {\n        standard: 'EIP-1193',\n        message: 'User rejected the request.',\n    },\n    '4100': {\n        standard: 'EIP-1193',\n        message: 'The requested account and/or method has not been authorized by the user.',\n    },\n    '4200': {\n        standard: 'EIP-1193',\n        message: 'The requested method is not supported by this Ethereum provider.',\n    },\n    '4900': {\n        standard: 'EIP-1193',\n        message: 'The provider is disconnected from all chains.',\n    },\n    '4901': {\n        standard: 'EIP-1193',\n        message: 'The provider is disconnected from the specified chain.',\n    },\n};\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3ItY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2Vycm9yLWNvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUF1QmEsUUFBQSxVQUFVLEdBQWU7SUFDcEMsR0FBRyxFQUFFO1FBQ0gsWUFBWSxFQUFFLENBQUMsS0FBSztRQUNwQixnQkFBZ0IsRUFBRSxDQUFDLEtBQUs7UUFDeEIsbUJBQW1CLEVBQUUsQ0FBQyxLQUFLO1FBQzNCLG1CQUFtQixFQUFFLENBQUMsS0FBSztRQUMzQixrQkFBa0IsRUFBRSxDQUFDLEtBQUs7UUFDMUIsYUFBYSxFQUFFLENBQUMsS0FBSztRQUNyQixLQUFLLEVBQUUsQ0FBQyxLQUFLO1FBQ2IsY0FBYyxFQUFFLENBQUMsS0FBSztRQUN0QixjQUFjLEVBQUUsQ0FBQyxLQUFLO1FBQ3RCLGFBQWEsRUFBRSxDQUFDLEtBQUs7UUFDckIsUUFBUSxFQUFFLENBQUMsS0FBSztLQUNqQjtJQUNELFFBQVEsRUFBRTtRQUNSLG1CQUFtQixFQUFFLElBQUk7UUFDekIsWUFBWSxFQUFFLElBQUk7UUFDbEIsaUJBQWlCLEVBQUUsSUFBSTtRQUN2QixZQUFZLEVBQUUsSUFBSTtRQUNsQixpQkFBaUIsRUFBRSxJQUFJO0tBQ3hCO0NBQ0YsQ0FBQztBQUVXLFFBQUEsV0FBVyxHQUFHO0lBQ3pCLFFBQVEsRUFBRTtRQUNSLFFBQVEsRUFBRSxjQUFjO1FBQ3hCLE9BQU8sRUFBRSx1R0FBdUc7S0FDakg7SUFDRCxRQUFRLEVBQUU7UUFDUixRQUFRLEVBQUUsY0FBYztRQUN4QixPQUFPLEVBQUUsOENBQThDO0tBQ3hEO0lBQ0QsUUFBUSxFQUFFO1FBQ1IsUUFBUSxFQUFFLGNBQWM7UUFDeEIsT0FBTyxFQUFFLCtDQUErQztLQUN6RDtJQUNELFFBQVEsRUFBRTtRQUNSLFFBQVEsRUFBRSxjQUFjO1FBQ3hCLE9BQU8sRUFBRSw4QkFBOEI7S0FDeEM7SUFDRCxRQUFRLEVBQUU7UUFDUixRQUFRLEVBQUUsY0FBYztRQUN4QixPQUFPLEVBQUUsMEJBQTBCO0tBQ3BDO0lBQ0QsUUFBUSxFQUFFO1FBQ1IsUUFBUSxFQUFFLFVBQVU7UUFDcEIsT0FBTyxFQUFFLGdCQUFnQjtLQUMxQjtJQUNELFFBQVEsRUFBRTtRQUNSLFFBQVEsRUFBRSxVQUFVO1FBQ3BCLE9BQU8sRUFBRSxxQkFBcUI7S0FDL0I7SUFDRCxRQUFRLEVBQUU7UUFDUixRQUFRLEVBQUUsVUFBVTtRQUNwQixPQUFPLEVBQUUsdUJBQXVCO0tBQ2pDO0lBQ0QsUUFBUSxFQUFFO1FBQ1IsUUFBUSxFQUFFLFVBQVU7UUFDcEIsT0FBTyxFQUFFLHVCQUF1QjtLQUNqQztJQUNELFFBQVEsRUFBRTtRQUNSLFFBQVEsRUFBRSxVQUFVO1FBQ3BCLE9BQU8sRUFBRSx1QkFBdUI7S0FDakM7SUFDRCxRQUFRLEVBQUU7UUFDUixRQUFRLEVBQUUsVUFBVTtRQUNwQixPQUFPLEVBQUUseUJBQXlCO0tBQ25DO0lBQ0QsTUFBTSxFQUFFO1FBQ04sUUFBUSxFQUFFLFVBQVU7UUFDcEIsT0FBTyxFQUFFLDRCQUE0QjtLQUN0QztJQUNELE1BQU0sRUFBRTtRQUNOLFFBQVEsRUFBRSxVQUFVO1FBQ3BCLE9BQU8sRUFBRSwwRUFBMEU7S0FDcEY7SUFDRCxNQUFNLEVBQUU7UUFDTixRQUFRLEVBQUUsVUFBVTtRQUNwQixPQUFPLEVBQUUsa0VBQWtFO0tBQzVFO0lBQ0QsTUFBTSxFQUFFO1FBQ04sUUFBUSxFQUFFLFVBQVU7UUFDcEIsT0FBTyxFQUFFLCtDQUErQztLQUN6RDtJQUNELE1BQU0sRUFBRTtRQUNOLFFBQVEsRUFBRSxVQUFVO1FBQ3BCLE9BQU8sRUFBRSx3REFBd0Q7S0FDbEU7Q0FDRixDQUFDIn0=","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.BasePostMessageStream = void 0;\nconst readable_stream_1 = require(\"readable-stream\");\nfunction noop() {\n    return undefined;\n}\nconst SYN = 'SYN';\nconst ACK = 'ACK';\n/**\n * Abstract base class for postMessage streams.\n */\nclass BasePostMessageStream extends readable_stream_1.Duplex {\n    constructor() {\n        super({\n            objectMode: true,\n        });\n        // Initialization flags\n        this._init = false;\n        this._haveSyn = false;\n    }\n    /**\n     * Must be called at end of child constructor to initiate\n     * communication with other end.\n     */\n    _handshake() {\n        // Send synchronization message\n        this._write(SYN, null, noop);\n        this.cork();\n    }\n    _onData(data) {\n        if (this._init) {\n            // Forward message\n            try {\n                this.push(data);\n            }\n            catch (err) {\n                this.emit('error', err);\n            }\n        }\n        else if (data === SYN) {\n            // Listen for handshake\n            this._haveSyn = true;\n            this._write(ACK, null, noop);\n        }\n        else if (data === ACK) {\n            this._init = true;\n            if (!this._haveSyn) {\n                this._write(ACK, null, noop);\n            }\n            this.uncork();\n        }\n    }\n    _read() {\n        return undefined;\n    }\n    _write(data, _encoding, cb) {\n        this._postMessage(data);\n        cb();\n    }\n}\nexports.BasePostMessageStream = BasePostMessageStream;\n//# sourceMappingURL=BasePostMessageStream.js.map","/* eslint-disable node/no-deprecated-api */\nvar buffer = require('buffer')\nvar Buffer = buffer.Buffer\n\n// alternative to using Object.keys for old browsers\nfunction copyProps (src, dst) {\n  for (var key in src) {\n    dst[key] = src[key]\n  }\n}\nif (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {\n  module.exports = buffer\n} else {\n  // Copy properties from require('buffer')\n  copyProps(buffer, exports)\n  exports.Buffer = SafeBuffer\n}\n\nfunction SafeBuffer (arg, encodingOrOffset, length) {\n  return Buffer(arg, encodingOrOffset, length)\n}\n\n// Copy static methods from Buffer\ncopyProps(Buffer, SafeBuffer)\n\nSafeBuffer.from = function (arg, encodingOrOffset, length) {\n  if (typeof arg === 'number') {\n    throw new TypeError('Argument must not be a number')\n  }\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.alloc = function (size, fill, encoding) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  var buf = Buffer(size)\n  if (fill !== undefined) {\n    if (typeof encoding === 'string') {\n      buf.fill(fill, encoding)\n    } else {\n      buf.fill(fill)\n    }\n  } else {\n    buf.fill(0)\n  }\n  return buf\n}\n\nSafeBuffer.allocUnsafe = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return Buffer(size)\n}\n\nSafeBuffer.allocUnsafeSlow = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return buffer.SlowBuffer(size)\n}\n","const { Duplex } = require('readable-stream');\nconst { inherits } = require('util');\n\nconst noop = () => undefined;\n\nmodule.exports = PostMessageStream;\n\ninherits(PostMessageStream, Duplex);\n\nfunction PostMessageStream(opts) {\n  Duplex.call(this, {\n    objectMode: true\n  });\n\n  this._name = opts.name;\n  this._target = opts.target;\n  this._targetWindow = opts.targetWindow || window;\n  this._origin = opts.targetWindow ? '*' : location.origin;\n\n  // initialization flags\n  this._init = false;\n  this._haveSyn = false;\n\n  window.addEventListener('message', this._onMessage.bind(this), false);\n  // send syncorization message\n  this._write('SYN', null, noop);\n  this.cork();\n}\n\n// private\nPostMessageStream.prototype._onMessage = function (event) {\n  const msg = event.data;\n\n  // validate message\n  if (this._origin !== '*' && event.origin !== this._origin) {\n    return;\n  }\n  if (event.source !== this._targetWindow && window === top) {\n    return;\n  }\n  if (!msg || typeof msg !== 'object') {\n    return;\n  }\n  if (msg.target !== this._name) {\n    return;\n  }\n  if (!msg.data) {\n    return;\n  }\n\n  if (this._init) {\n    // forward message\n    try {\n      this.push(msg.data);\n    } catch (err) {\n      this.emit('error', err);\n    }\n  } else if (msg.data === 'SYN') {\n    this._haveSyn = true;\n    this._write('ACK', null, noop);\n  } else if (msg.data === 'ACK') {\n    this._init = true;\n    if (!this._haveSyn) {\n      this._write('ACK', null, noop);\n    }\n    this.uncork();\n  }\n};\n\n// stream plumbing\nPostMessageStream.prototype._read = noop;\n\nPostMessageStream.prototype._write = function (data, _encoding, cb) {\n  const message = {\n    target: this._target,\n    data\n  };\n  this._targetWindow.postMessage(message, this._origin);\n  cb();\n};\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst pump_1 = __importDefault(require(\"pump\"));\nconst json_rpc_engine_1 = require(\"json-rpc-engine\");\nconst json_rpc_middleware_stream_1 = require(\"json-rpc-middleware-stream\");\nconst object_multiplex_1 = __importDefault(require(\"@metamask/object-multiplex\"));\nconst safe_event_emitter_1 = __importDefault(require(\"@metamask/safe-event-emitter\"));\nconst fast_deep_equal_1 = __importDefault(require(\"fast-deep-equal\"));\nconst eth_rpc_errors_1 = require(\"eth-rpc-errors\");\nconst is_stream_1 = require(\"is-stream\");\nconst messages_1 = __importDefault(require(\"./messages\"));\nconst siteMetadata_1 = __importDefault(require(\"./siteMetadata\"));\nconst utils_1 = require(\"./utils\");\nclass MetaMaskInpageProvider extends safe_event_emitter_1.default {\n    /**\n     * @param connectionStream - A Node.js duplex stream\n     * @param options - An options bag\n     * @param options.jsonRpcStreamName - The name of the internal JSON-RPC stream.\n     * Default: metamask-provider\n     * @param options.logger - The logging API to use. Default: console\n     * @param options.maxEventListeners - The maximum number of event\n     * listeners. Default: 100\n     * @param options.shouldSendMetadata - Whether the provider should\n     * send page metadata. Default: true\n     */\n    constructor(connectionStream, { jsonRpcStreamName = 'metamask-provider', logger = console, maxEventListeners = 100, shouldSendMetadata = true, } = {}) {\n        if (!is_stream_1.duplex(connectionStream)) {\n            throw new Error(messages_1.default.errors.invalidDuplexStream());\n        }\n        if (typeof maxEventListeners !== 'number' ||\n            typeof shouldSendMetadata !== 'boolean') {\n            throw new Error(messages_1.default.errors.invalidOptions(maxEventListeners, shouldSendMetadata));\n        }\n        validateLoggerObject(logger);\n        super();\n        this._log = logger;\n        this.isMetaMask = true;\n        this.setMaxListeners(maxEventListeners);\n        // private state\n        this._state = {\n            sentWarnings: {\n                // methods\n                enable: false,\n                experimentalMethods: false,\n                send: false,\n                // events\n                events: {\n                    close: false,\n                    data: false,\n                    networkChanged: false,\n                    notification: false,\n                },\n            },\n            accounts: null,\n            isConnected: false,\n            isUnlocked: false,\n            initialized: false,\n            isPermanentlyDisconnected: false,\n        };\n        this._metamask = this._getExperimentalApi();\n        // public state\n        this.selectedAddress = null;\n        this.networkVersion = null;\n        this.chainId = null;\n        // bind functions (to prevent consumers from making unbound calls)\n        this._handleAccountsChanged = this._handleAccountsChanged.bind(this);\n        this._handleConnect = this._handleConnect.bind(this);\n        this._handleChainChanged = this._handleChainChanged.bind(this);\n        this._handleDisconnect = this._handleDisconnect.bind(this);\n        this._handleStreamDisconnect = this._handleStreamDisconnect.bind(this);\n        this._handleUnlockStateChanged = this._handleUnlockStateChanged.bind(this);\n        this._sendSync = this._sendSync.bind(this);\n        this._rpcRequest = this._rpcRequest.bind(this);\n        this._warnOfDeprecation = this._warnOfDeprecation.bind(this);\n        this.enable = this.enable.bind(this);\n        this.request = this.request.bind(this);\n        this.send = this.send.bind(this);\n        this.sendAsync = this.sendAsync.bind(this);\n        // setup connectionStream multiplexing\n        const mux = new object_multiplex_1.default();\n        pump_1.default(connectionStream, mux, connectionStream, this._handleStreamDisconnect.bind(this, 'MetaMask'));\n        // ignore phishing warning message (handled elsewhere)\n        mux.ignoreStream('phishing');\n        // setup own event listeners\n        // EIP-1193 connect\n        this.on('connect', () => {\n            this._state.isConnected = true;\n        });\n        // setup RPC connection\n        const jsonRpcConnection = json_rpc_middleware_stream_1.createStreamMiddleware();\n        pump_1.default(jsonRpcConnection.stream, mux.createStream(jsonRpcStreamName), jsonRpcConnection.stream, this._handleStreamDisconnect.bind(this, 'MetaMask RpcProvider'));\n        // handle RPC requests via dapp-side rpc engine\n        const rpcEngine = new json_rpc_engine_1.JsonRpcEngine();\n        rpcEngine.push(json_rpc_engine_1.createIdRemapMiddleware());\n        rpcEngine.push(utils_1.createErrorMiddleware(this._log));\n        rpcEngine.push(jsonRpcConnection.middleware);\n        this._rpcEngine = rpcEngine;\n        this._initializeState();\n        // handle JSON-RPC notifications\n        jsonRpcConnection.events.on('notification', (payload) => {\n            const { method, params } = payload;\n            if (method === 'metamask_accountsChanged') {\n                this._handleAccountsChanged(params);\n            }\n            else if (method === 'metamask_unlockStateChanged') {\n                this._handleUnlockStateChanged(params);\n            }\n            else if (method === 'metamask_chainChanged') {\n                this._handleChainChanged(params);\n            }\n            else if (utils_1.EMITTED_NOTIFICATIONS.includes(method)) {\n                // deprecated\n                // emitted here because that was the original order\n                this.emit('data', payload);\n                this.emit('message', {\n                    type: method,\n                    data: params,\n                });\n                // deprecated\n                this.emit('notification', payload.params.result);\n            }\n            else if (method === 'METAMASK_STREAM_FAILURE') {\n                connectionStream.destroy(new Error(messages_1.default.errors.permanentlyDisconnected()));\n            }\n        });\n        // miscellanea\n        // send website metadata\n        if (shouldSendMetadata) {\n            if (document.readyState === 'complete') {\n                siteMetadata_1.default(this._rpcEngine, this._log);\n            }\n            else {\n                const domContentLoadedHandler = () => {\n                    siteMetadata_1.default(this._rpcEngine, this._log);\n                    window.removeEventListener('DOMContentLoaded', domContentLoadedHandler);\n                };\n                window.addEventListener('DOMContentLoaded', domContentLoadedHandler);\n            }\n        }\n    }\n    //====================\n    // Public Methods\n    //====================\n    /**\n     * Returns whether the provider can process RPC requests.\n     */\n    isConnected() {\n        return this._state.isConnected;\n    }\n    /**\n     * Submits an RPC request for the given method, with the given params.\n     * Resolves with the result of the method call, or rejects on error.\n     *\n     * @param args - The RPC request arguments.\n     * @param args.method - The RPC method name.\n     * @param args.params - The parameters for the RPC method.\n     * @returns A Promise that resolves with the result of the RPC method,\n     * or rejects if an error is encountered.\n     */\n    async request(args) {\n        if (!args || typeof args !== 'object' || Array.isArray(args)) {\n            throw eth_rpc_errors_1.ethErrors.rpc.invalidRequest({\n                message: messages_1.default.errors.invalidRequestArgs(),\n                data: args,\n            });\n        }\n        const { method, params } = args;\n        if (typeof method !== 'string' || method.length === 0) {\n            throw eth_rpc_errors_1.ethErrors.rpc.invalidRequest({\n                message: messages_1.default.errors.invalidRequestMethod(),\n                data: args,\n            });\n        }\n        if (params !== undefined && !Array.isArray(params) &&\n            (typeof params !== 'object' || params === null)) {\n            throw eth_rpc_errors_1.ethErrors.rpc.invalidRequest({\n                message: messages_1.default.errors.invalidRequestParams(),\n                data: args,\n            });\n        }\n        return new Promise((resolve, reject) => {\n            this._rpcRequest({ method, params }, utils_1.getRpcPromiseCallback(resolve, reject));\n        });\n    }\n    /**\n     * Submits an RPC request per the given JSON-RPC request object.\n     *\n     * @param payload - The RPC request object.\n     * @param cb - The callback function.\n     */\n    sendAsync(payload, callback) {\n        this._rpcRequest(payload, callback);\n    }\n    /**\n     * We override the following event methods so that we can warn consumers\n     * about deprecated events:\n     *   addListener, on, once, prependListener, prependOnceListener\n     */\n    addListener(eventName, listener) {\n        this._warnOfDeprecation(eventName);\n        return super.addListener(eventName, listener);\n    }\n    on(eventName, listener) {\n        this._warnOfDeprecation(eventName);\n        return super.on(eventName, listener);\n    }\n    once(eventName, listener) {\n        this._warnOfDeprecation(eventName);\n        return super.once(eventName, listener);\n    }\n    prependListener(eventName, listener) {\n        this._warnOfDeprecation(eventName);\n        return super.prependListener(eventName, listener);\n    }\n    prependOnceListener(eventName, listener) {\n        this._warnOfDeprecation(eventName);\n        return super.prependOnceListener(eventName, listener);\n    }\n    //====================\n    // Private Methods\n    //====================\n    /**\n     * Constructor helper.\n     * Populates initial state by calling 'metamask_getProviderState' and emits\n     * necessary events.\n     */\n    async _initializeState() {\n        try {\n            const { accounts, chainId, isUnlocked, networkVersion, } = await this.request({\n                method: 'metamask_getProviderState',\n            });\n            // indicate that we've connected, for EIP-1193 compliance\n            this.emit('connect', { chainId });\n            this._handleChainChanged({ chainId, networkVersion });\n            this._handleUnlockStateChanged({ accounts, isUnlocked });\n            this._handleAccountsChanged(accounts);\n        }\n        catch (error) {\n            this._log.error('MetaMask: Failed to get initial state. Please report this bug.', error);\n        }\n        finally {\n            this._state.initialized = true;\n            this.emit('_initialized');\n        }\n    }\n    /**\n     * Internal RPC method. Forwards requests to background via the RPC engine.\n     * Also remap ids inbound and outbound.\n     *\n     * @param payload - The RPC request object.\n     * @param callback - The consumer's callback.\n     */\n    _rpcRequest(payload, callback) {\n        let cb = callback;\n        if (!Array.isArray(payload)) {\n            if (!payload.jsonrpc) {\n                payload.jsonrpc = '2.0';\n            }\n            if (payload.method === 'eth_accounts' ||\n                payload.method === 'eth_requestAccounts') {\n                // handle accounts changing\n                cb = (err, res) => {\n                    this._handleAccountsChanged(res.result || [], payload.method === 'eth_accounts');\n                    callback(err, res);\n                };\n            }\n            return this._rpcEngine.handle(payload, cb);\n        }\n        return this._rpcEngine.handle(payload, cb);\n    }\n    /**\n     * When the provider becomes connected, updates internal state and emits\n     * required events. Idempotent.\n     *\n     * @param chainId - The ID of the newly connected chain.\n     * @emits MetaMaskInpageProvider#connect\n     */\n    _handleConnect(chainId) {\n        if (!this._state.isConnected) {\n            this._state.isConnected = true;\n            this.emit('connect', { chainId });\n            this._log.debug(messages_1.default.info.connected(chainId));\n        }\n    }\n    /**\n     * When the provider becomes disconnected, updates internal state and emits\n     * required events. Idempotent with respect to the isRecoverable parameter.\n     *\n     * Error codes per the CloseEvent status codes as required by EIP-1193:\n     * https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes\n     *\n     * @param isRecoverable - Whether the disconnection is recoverable.\n     * @param errorMessage - A custom error message.\n     * @emits MetaMaskInpageProvider#disconnect\n     */\n    _handleDisconnect(isRecoverable, errorMessage) {\n        if (this._state.isConnected ||\n            (!this._state.isPermanentlyDisconnected && !isRecoverable)) {\n            this._state.isConnected = false;\n            let error;\n            if (isRecoverable) {\n                error = new eth_rpc_errors_1.EthereumRpcError(1013, // Try again later\n                errorMessage || messages_1.default.errors.disconnected());\n                this._log.debug(error);\n            }\n            else {\n                error = new eth_rpc_errors_1.EthereumRpcError(1011, // Internal error\n                errorMessage || messages_1.default.errors.permanentlyDisconnected());\n                this._log.error(error);\n                this.chainId = null;\n                this.networkVersion = null;\n                this._state.accounts = null;\n                this.selectedAddress = null;\n                this._state.isUnlocked = false;\n                this._state.isPermanentlyDisconnected = true;\n            }\n            this.emit('disconnect', error);\n            this.emit('close', error); // deprecated\n        }\n    }\n    /**\n     * Called when connection is lost to critical streams.\n     *\n     * @emits MetamaskInpageProvider#disconnect\n     */\n    _handleStreamDisconnect(streamName, error) {\n        utils_1.logStreamDisconnectWarning(this._log, streamName, error, this);\n        this._handleDisconnect(false, error ? error.message : undefined);\n    }\n    /**\n     * Upon receipt of a new chainId and networkVersion, emits corresponding\n     * events and sets relevant public state.\n     * Does nothing if neither the chainId nor the networkVersion are different\n     * from existing values.\n     *\n     * @emits MetamaskInpageProvider#chainChanged\n     * @param networkInfo - An object with network info.\n     * @param networkInfo.chainId - The latest chain ID.\n     * @param networkInfo.networkVersion - The latest network ID.\n     */\n    _handleChainChanged({ chainId, networkVersion, } = {}) {\n        if (!chainId || typeof chainId !== 'string' || !chainId.startsWith('0x') ||\n            !networkVersion || typeof networkVersion !== 'string') {\n            this._log.error('MetaMask: Received invalid network parameters. Please report this bug.', { chainId, networkVersion });\n            return;\n        }\n        if (networkVersion === 'loading') {\n            this._handleDisconnect(true);\n        }\n        else {\n            this._handleConnect(chainId);\n            if (chainId !== this.chainId) {\n                this.chainId = chainId;\n                if (this._state.initialized) {\n                    this.emit('chainChanged', this.chainId);\n                }\n            }\n            if (networkVersion !== this.networkVersion) {\n                this.networkVersion = networkVersion;\n                if (this._state.initialized) {\n                    this.emit('networkChanged', this.networkVersion);\n                }\n            }\n        }\n    }\n    /**\n     * Called when accounts may have changed. Diffs the new accounts value with\n     * the current one, updates all state as necessary, and emits the\n     * accountsChanged event.\n     *\n     * @param accounts - The new accounts value.\n     * @param isEthAccounts - Whether the accounts value was returned by\n     * a call to eth_accounts.\n     */\n    _handleAccountsChanged(accounts, isEthAccounts = false) {\n        let _accounts = accounts;\n        if (!Array.isArray(accounts)) {\n            this._log.error('MetaMask: Received invalid accounts parameter. Please report this bug.', accounts);\n            _accounts = [];\n        }\n        for (const account of accounts) {\n            if (typeof account !== 'string') {\n                this._log.error('MetaMask: Received non-string account. Please report this bug.', accounts);\n                _accounts = [];\n                break;\n            }\n        }\n        // emit accountsChanged if anything about the accounts array has changed\n        if (!fast_deep_equal_1.default(this._state.accounts, _accounts)) {\n            // we should always have the correct accounts even before eth_accounts\n            // returns\n            if (isEthAccounts && this._state.accounts !== null) {\n                this._log.error(`MetaMask: 'eth_accounts' unexpectedly updated accounts. Please report this bug.`, _accounts);\n            }\n            this._state.accounts = _accounts;\n            // handle selectedAddress\n            if (this.selectedAddress !== _accounts[0]) {\n                this.selectedAddress = _accounts[0] || null;\n            }\n            // finally, after all state has been updated, emit the event\n            if (this._state.initialized) {\n                this.emit('accountsChanged', _accounts);\n            }\n        }\n    }\n    /**\n     * Upon receipt of a new isUnlocked state, sets relevant public state.\n     * Calls the accounts changed handler with the received accounts, or an empty\n     * array.\n     *\n     * Does nothing if the received value is equal to the existing value.\n     * There are no lock/unlock events.\n     *\n     * @param opts - Options bag.\n     * @param opts.accounts - The exposed accounts, if any.\n     * @param opts.isUnlocked - The latest isUnlocked value.\n     */\n    _handleUnlockStateChanged({ accounts, isUnlocked, } = {}) {\n        if (typeof isUnlocked !== 'boolean') {\n            this._log.error('MetaMask: Received invalid isUnlocked parameter. Please report this bug.');\n            return;\n        }\n        if (isUnlocked !== this._state.isUnlocked) {\n            this._state.isUnlocked = isUnlocked;\n            this._handleAccountsChanged(accounts || []);\n        }\n    }\n    /**\n     * Warns of deprecation for the given event, if applicable.\n     */\n    _warnOfDeprecation(eventName) {\n        if (this._state.sentWarnings.events[eventName] === false) {\n            this._log.warn(messages_1.default.warnings.events[eventName]);\n            this._state.sentWarnings.events[eventName] = true;\n        }\n    }\n    /**\n     * Constructor helper.\n     * Gets experimental _metamask API as Proxy, so that we can warn consumers\n     * about its experiment nature.\n     */\n    _getExperimentalApi() {\n        return new Proxy({\n            /**\n             * Determines if MetaMask is unlocked by the user.\n             *\n             * @returns Promise resolving to true if MetaMask is currently unlocked\n             */\n            isUnlocked: async () => {\n                if (!this._state.initialized) {\n                    await new Promise((resolve) => {\n                        this.on('_initialized', () => resolve());\n                    });\n                }\n                return this._state.isUnlocked;\n            },\n            /**\n             * Make a batch RPC request.\n             */\n            requestBatch: async (requests) => {\n                if (!Array.isArray(requests)) {\n                    throw eth_rpc_errors_1.ethErrors.rpc.invalidRequest({\n                        message: 'Batch requests must be made with an array of request objects.',\n                        data: requests,\n                    });\n                }\n                return new Promise((resolve, reject) => {\n                    this._rpcRequest(requests, utils_1.getRpcPromiseCallback(resolve, reject));\n                });\n            },\n        }, {\n            get: (obj, prop, ...args) => {\n                if (!this._state.sentWarnings.experimentalMethods) {\n                    this._log.warn(messages_1.default.warnings.experimentalMethods);\n                    this._state.sentWarnings.experimentalMethods = true;\n                }\n                return Reflect.get(obj, prop, ...args);\n            },\n        });\n    }\n    //====================\n    // Deprecated Methods\n    //====================\n    /**\n     * Equivalent to: ethereum.request('eth_requestAccounts')\n     *\n     * @deprecated Use request({ method: 'eth_requestAccounts' }) instead.\n     * @returns A promise that resolves to an array of addresses.\n     */\n    enable() {\n        if (!this._state.sentWarnings.enable) {\n            this._log.warn(messages_1.default.warnings.enableDeprecation);\n            this._state.sentWarnings.enable = true;\n        }\n        return new Promise((resolve, reject) => {\n            try {\n                this._rpcRequest({ method: 'eth_requestAccounts', params: [] }, utils_1.getRpcPromiseCallback(resolve, reject));\n            }\n            catch (error) {\n                reject(error);\n            }\n        });\n    }\n    send(methodOrPayload, callbackOrArgs) {\n        if (!this._state.sentWarnings.send) {\n            this._log.warn(messages_1.default.warnings.sendDeprecation);\n            this._state.sentWarnings.send = true;\n        }\n        if (typeof methodOrPayload === 'string' &&\n            (!callbackOrArgs || Array.isArray(callbackOrArgs))) {\n            return new Promise((resolve, reject) => {\n                try {\n                    this._rpcRequest({ method: methodOrPayload, params: callbackOrArgs }, utils_1.getRpcPromiseCallback(resolve, reject, false));\n                }\n                catch (error) {\n                    reject(error);\n                }\n            });\n        }\n        else if (methodOrPayload &&\n            typeof methodOrPayload === 'object' &&\n            typeof callbackOrArgs === 'function') {\n            return this._rpcRequest(methodOrPayload, callbackOrArgs);\n        }\n        return this._sendSync(methodOrPayload);\n    }\n    /**\n     * Internal backwards compatibility method, used in send.\n     *\n     * @deprecated\n     */\n    _sendSync(payload) {\n        let result;\n        switch (payload.method) {\n            case 'eth_accounts':\n                result = this.selectedAddress ? [this.selectedAddress] : [];\n                break;\n            case 'eth_coinbase':\n                result = this.selectedAddress || null;\n                break;\n            case 'eth_uninstallFilter':\n                this._rpcRequest(payload, utils_1.NOOP);\n                result = true;\n                break;\n            case 'net_version':\n                result = this.networkVersion || null;\n                break;\n            default:\n                throw new Error(messages_1.default.errors.unsupportedSync(payload.method));\n        }\n        return {\n            id: payload.id,\n            jsonrpc: payload.jsonrpc,\n            result,\n        };\n    }\n}\nexports.default = MetaMaskInpageProvider;\nfunction validateLoggerObject(logger) {\n    if (logger !== console) {\n        if (typeof logger === 'object') {\n            const methodKeys = ['log', 'warn', 'error', 'debug', 'info', 'trace'];\n            for (const key of methodKeys) {\n                if (typeof logger[key] !== 'function') {\n                    throw new Error(messages_1.default.errors.invalidLoggerMethod(key));\n                }\n            }\n            return;\n        }\n        throw new Error(messages_1.default.errors.invalidLoggerObject());\n    }\n}\n//# sourceMappingURL=MetaMaskInpageProvider.js.map","var once = require('once');\n\nvar noop = function() {};\n\nvar isRequest = function(stream) {\n\treturn stream.setHeader && typeof stream.abort === 'function';\n};\n\nvar isChildProcess = function(stream) {\n\treturn stream.stdio && Array.isArray(stream.stdio) && stream.stdio.length === 3\n};\n\nvar eos = function(stream, opts, callback) {\n\tif (typeof opts === 'function') return eos(stream, null, opts);\n\tif (!opts) opts = {};\n\n\tcallback = once(callback || noop);\n\n\tvar ws = stream._writableState;\n\tvar rs = stream._readableState;\n\tvar readable = opts.readable || (opts.readable !== false && stream.readable);\n\tvar writable = opts.writable || (opts.writable !== false && stream.writable);\n\tvar cancelled = false;\n\n\tvar onlegacyfinish = function() {\n\t\tif (!stream.writable) onfinish();\n\t};\n\n\tvar onfinish = function() {\n\t\twritable = false;\n\t\tif (!readable) callback.call(stream);\n\t};\n\n\tvar onend = function() {\n\t\treadable = false;\n\t\tif (!writable) callback.call(stream);\n\t};\n\n\tvar onexit = function(exitCode) {\n\t\tcallback.call(stream, exitCode ? new Error('exited with error code: ' + exitCode) : null);\n\t};\n\n\tvar onerror = function(err) {\n\t\tcallback.call(stream, err);\n\t};\n\n\tvar onclose = function() {\n\t\tprocess.nextTick(onclosenexttick);\n\t};\n\n\tvar onclosenexttick = function() {\n\t\tif (cancelled) return;\n\t\tif (readable && !(rs && (rs.ended && !rs.destroyed))) return callback.call(stream, new Error('premature close'));\n\t\tif (writable && !(ws && (ws.ended && !ws.destroyed))) return callback.call(stream, new Error('premature close'));\n\t};\n\n\tvar onrequest = function() {\n\t\tstream.req.on('finish', onfinish);\n\t};\n\n\tif (isRequest(stream)) {\n\t\tstream.on('complete', onfinish);\n\t\tstream.on('abort', onclose);\n\t\tif (stream.req) onrequest();\n\t\telse stream.on('request', onrequest);\n\t} else if (writable && !ws) { // legacy streams\n\t\tstream.on('end', onlegacyfinish);\n\t\tstream.on('close', onlegacyfinish);\n\t}\n\n\tif (isChildProcess(stream)) stream.on('exit', onexit);\n\n\tstream.on('end', onend);\n\tstream.on('finish', onfinish);\n\tif (opts.error !== false) stream.on('error', onerror);\n\tstream.on('close', onclose);\n\n\treturn function() {\n\t\tcancelled = true;\n\t\tstream.removeListener('complete', onfinish);\n\t\tstream.removeListener('abort', onclose);\n\t\tstream.removeListener('request', onrequest);\n\t\tif (stream.req) stream.req.removeListener('finish', onfinish);\n\t\tstream.removeListener('end', onlegacyfinish);\n\t\tstream.removeListener('close', onlegacyfinish);\n\t\tstream.removeListener('finish', onfinish);\n\t\tstream.removeListener('exit', onexit);\n\t\tstream.removeListener('end', onend);\n\t\tstream.removeListener('error', onerror);\n\t\tstream.removeListener('close', onclose);\n\t};\n};\n\nmodule.exports = eos;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.getUniqueId = void 0;\n// uint32 (two's complement) max\n// more conservative than Number.MAX_SAFE_INTEGER\nconst MAX = 4294967295;\nlet idCounter = Math.floor(Math.random() * MAX);\nfunction getUniqueId() {\n    idCounter = (idCounter + 1) % MAX;\n    return idCounter;\n}\nexports.getUniqueId = getUniqueId;\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0VW5pcXVlSWQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvZ2V0VW5pcXVlSWQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsZ0NBQWdDO0FBQ2hDLGlEQUFpRDtBQUNqRCxNQUFNLEdBQUcsR0FBRyxVQUFVLENBQUM7QUFDdkIsSUFBSSxTQUFTLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFLEdBQUcsR0FBRyxDQUFDLENBQUM7QUFFaEQsU0FBZ0IsV0FBVztJQUN6QixTQUFTLEdBQUcsQ0FBQyxTQUFTLEdBQUcsQ0FBQyxDQUFDLEdBQUcsR0FBRyxDQUFDO0lBQ2xDLE9BQU8sU0FBUyxDQUFDO0FBQ25CLENBQUM7QUFIRCxrQ0FHQyJ9","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.JsonRpcEngine = void 0;\nconst safe_event_emitter_1 = __importDefault(require(\"@metamask/safe-event-emitter\"));\nconst eth_rpc_errors_1 = require(\"eth-rpc-errors\");\n/**\n * A JSON-RPC request and response processor.\n * Give it a stack of middleware, pass it requests, and get back responses.\n */\nclass JsonRpcEngine extends safe_event_emitter_1.default {\n    constructor() {\n        super();\n        this._middleware = [];\n    }\n    /**\n     * Add a middleware function to the engine's middleware stack.\n     *\n     * @param middleware - The middleware function to add.\n     */\n    push(middleware) {\n        this._middleware.push(middleware);\n    }\n    handle(req, cb) {\n        if (cb && typeof cb !== 'function') {\n            throw new Error('\"callback\" must be a function if provided.');\n        }\n        if (Array.isArray(req)) {\n            if (cb) {\n                return this._handleBatch(req, cb);\n            }\n            return this._handleBatch(req);\n        }\n        if (cb) {\n            return this._handle(req, cb);\n        }\n        return this._promiseHandle(req);\n    }\n    /**\n     * Returns this engine as a middleware function that can be pushed to other\n     * engines.\n     *\n     * @returns This engine as a middleware function.\n     */\n    asMiddleware() {\n        return async (req, res, next, end) => {\n            try {\n                const [middlewareError, isComplete, returnHandlers,] = await JsonRpcEngine._runAllMiddleware(req, res, this._middleware);\n                if (isComplete) {\n                    await JsonRpcEngine._runReturnHandlers(returnHandlers);\n                    return end(middlewareError);\n                }\n                return next(async (handlerCallback) => {\n                    try {\n                        await JsonRpcEngine._runReturnHandlers(returnHandlers);\n                    }\n                    catch (error) {\n                        return handlerCallback(error);\n                    }\n                    return handlerCallback();\n                });\n            }\n            catch (error) {\n                return end(error);\n            }\n        };\n    }\n    async _handleBatch(reqs, cb) {\n        // The order here is important\n        try {\n            // 2. Wait for all requests to finish, or throw on some kind of fatal\n            // error\n            const responses = await Promise.all(\n            // 1. Begin executing each request in the order received\n            reqs.map(this._promiseHandle.bind(this)));\n            // 3. Return batch response\n            if (cb) {\n                return cb(null, responses);\n            }\n            return responses;\n        }\n        catch (error) {\n            if (cb) {\n                return cb(error);\n            }\n            throw error;\n        }\n    }\n    /**\n     * A promise-wrapped _handle.\n     */\n    _promiseHandle(req) {\n        return new Promise((resolve) => {\n            this._handle(req, (_err, res) => {\n                // There will always be a response, and it will always have any error\n                // that is caught and propagated.\n                resolve(res);\n            });\n        });\n    }\n    /**\n     * Ensures that the request object is valid, processes it, and passes any\n     * error and the response object to the given callback.\n     *\n     * Does not reject.\n     */\n    async _handle(callerReq, cb) {\n        if (!callerReq ||\n            Array.isArray(callerReq) ||\n            typeof callerReq !== 'object') {\n            const error = new eth_rpc_errors_1.EthereumRpcError(eth_rpc_errors_1.errorCodes.rpc.invalidRequest, `Requests must be plain objects. Received: ${typeof callerReq}`, { request: callerReq });\n            return cb(error, { id: undefined, jsonrpc: '2.0', error });\n        }\n        if (typeof callerReq.method !== 'string') {\n            const error = new eth_rpc_errors_1.EthereumRpcError(eth_rpc_errors_1.errorCodes.rpc.invalidRequest, `Must specify a string method. Received: ${typeof callerReq.method}`, { request: callerReq });\n            return cb(error, { id: callerReq.id, jsonrpc: '2.0', error });\n        }\n        const req = Object.assign({}, callerReq);\n        const res = {\n            id: req.id,\n            jsonrpc: req.jsonrpc,\n        };\n        let error = null;\n        try {\n            await this._processRequest(req, res);\n        }\n        catch (_error) {\n            // A request handler error, a re-thrown middleware error, or something\n            // unexpected.\n            error = _error;\n        }\n        if (error) {\n            // Ensure no result is present on an errored response\n            delete res.result;\n            if (!res.error) {\n                res.error = eth_rpc_errors_1.serializeError(error);\n            }\n        }\n        return cb(error, res);\n    }\n    /**\n     * For the given request and response, runs all middleware and their return\n     * handlers, if any, and ensures that internal request processing semantics\n     * are satisfied.\n     */\n    async _processRequest(req, res) {\n        const [error, isComplete, returnHandlers,] = await JsonRpcEngine._runAllMiddleware(req, res, this._middleware);\n        // Throw if \"end\" was not called, or if the response has neither a result\n        // nor an error.\n        JsonRpcEngine._checkForCompletion(req, res, isComplete);\n        // The return handlers should run even if an error was encountered during\n        // middleware processing.\n        await JsonRpcEngine._runReturnHandlers(returnHandlers);\n        // Now we re-throw the middleware processing error, if any, to catch it\n        // further up the call chain.\n        if (error) {\n            throw error;\n        }\n    }\n    /**\n     * Serially executes the given stack of middleware.\n     *\n     * @returns An array of any error encountered during middleware execution,\n     * a boolean indicating whether the request was completed, and an array of\n     * middleware-defined return handlers.\n     */\n    static async _runAllMiddleware(req, res, middlewareStack) {\n        const returnHandlers = [];\n        let error = null;\n        let isComplete = false;\n        // Go down stack of middleware, call and collect optional returnHandlers\n        for (const middleware of middlewareStack) {\n            [error, isComplete] = await JsonRpcEngine._runMiddleware(req, res, middleware, returnHandlers);\n            if (isComplete) {\n                break;\n            }\n        }\n        return [error, isComplete, returnHandlers.reverse()];\n    }\n    /**\n     * Runs an individual middleware.\n     *\n     * @returns An array of any error encountered during middleware exection,\n     * and a boolean indicating whether the request should end.\n     */\n    static _runMiddleware(req, res, middleware, returnHandlers) {\n        return new Promise((resolve) => {\n            const end = (err) => {\n                const error = err || res.error;\n                if (error) {\n                    res.error = eth_rpc_errors_1.serializeError(error);\n                }\n                // True indicates that the request should end\n                resolve([error, true]);\n            };\n            const next = (returnHandler) => {\n                if (res.error) {\n                    end(res.error);\n                }\n                else {\n                    if (returnHandler) {\n                        if (typeof returnHandler !== 'function') {\n                            end(new eth_rpc_errors_1.EthereumRpcError(eth_rpc_errors_1.errorCodes.rpc.internal, `JsonRpcEngine: \"next\" return handlers must be functions. ` +\n                                `Received \"${typeof returnHandler}\" for request:\\n${jsonify(req)}`, { request: req }));\n                        }\n                        returnHandlers.push(returnHandler);\n                    }\n                    // False indicates that the request should not end\n                    resolve([null, false]);\n                }\n            };\n            try {\n                middleware(req, res, next, end);\n            }\n            catch (error) {\n                end(error);\n            }\n        });\n    }\n    /**\n     * Serially executes array of return handlers. The request and response are\n     * assumed to be in their scope.\n     */\n    static async _runReturnHandlers(handlers) {\n        for (const handler of handlers) {\n            await new Promise((resolve, reject) => {\n                handler((err) => (err ? reject(err) : resolve()));\n            });\n        }\n    }\n    /**\n     * Throws an error if the response has neither a result nor an error, or if\n     * the \"isComplete\" flag is falsy.\n     */\n    static _checkForCompletion(req, res, isComplete) {\n        if (!('result' in res) && !('error' in res)) {\n            throw new eth_rpc_errors_1.EthereumRpcError(eth_rpc_errors_1.errorCodes.rpc.internal, `JsonRpcEngine: Response has no error or result for request:\\n${jsonify(req)}`, { request: req });\n        }\n        if (!isComplete) {\n            throw new eth_rpc_errors_1.EthereumRpcError(eth_rpc_errors_1.errorCodes.rpc.internal, `JsonRpcEngine: Nothing ended request:\\n${jsonify(req)}`, { request: req });\n        }\n    }\n}\nexports.JsonRpcEngine = JsonRpcEngine;\nfunction jsonify(request) {\n    return JSON.stringify(request, null, 2);\n}\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"JsonRpcEngine.js","sourceRoot":"","sources":["../src/JsonRpcEngine.ts"],"names":[],"mappings":"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"}","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.serializeError = exports.isValidCode = exports.getMessageFromCode = exports.JSON_RPC_SERVER_ERROR_MESSAGE = void 0;\nconst error_constants_1 = require(\"./error-constants\");\nconst classes_1 = require(\"./classes\");\nconst FALLBACK_ERROR_CODE = error_constants_1.errorCodes.rpc.internal;\nconst FALLBACK_MESSAGE = 'Unspecified error message. This is a bug, please report it.';\nconst FALLBACK_ERROR = {\n    code: FALLBACK_ERROR_CODE,\n    message: getMessageFromCode(FALLBACK_ERROR_CODE),\n};\nexports.JSON_RPC_SERVER_ERROR_MESSAGE = 'Unspecified server error.';\n/**\n * Gets the message for a given code, or a fallback message if the code has\n * no corresponding message.\n */\nfunction getMessageFromCode(code, fallbackMessage = FALLBACK_MESSAGE) {\n    if (Number.isInteger(code)) {\n        const codeString = code.toString();\n        if (hasKey(error_constants_1.errorValues, codeString)) {\n            return error_constants_1.errorValues[codeString].message;\n        }\n        if (isJsonRpcServerError(code)) {\n            return exports.JSON_RPC_SERVER_ERROR_MESSAGE;\n        }\n    }\n    return fallbackMessage;\n}\nexports.getMessageFromCode = getMessageFromCode;\n/**\n * Returns whether the given code is valid.\n * A code is only valid if it has a message.\n */\nfunction isValidCode(code) {\n    if (!Number.isInteger(code)) {\n        return false;\n    }\n    const codeString = code.toString();\n    if (error_constants_1.errorValues[codeString]) {\n        return true;\n    }\n    if (isJsonRpcServerError(code)) {\n        return true;\n    }\n    return false;\n}\nexports.isValidCode = isValidCode;\n/**\n * Serializes the given error to an Ethereum JSON RPC-compatible error object.\n * Merely copies the given error's values if it is already compatible.\n * If the given error is not fully compatible, it will be preserved on the\n * returned object's data.originalError property.\n */\nfunction serializeError(error, { fallbackError = FALLBACK_ERROR, shouldIncludeStack = false, } = {}) {\n    var _a, _b;\n    if (!fallbackError ||\n        !Number.isInteger(fallbackError.code) ||\n        typeof fallbackError.message !== 'string') {\n        throw new Error('Must provide fallback error with integer number code and string message.');\n    }\n    if (error instanceof classes_1.EthereumRpcError) {\n        return error.serialize();\n    }\n    const serialized = {};\n    if (error &&\n        typeof error === 'object' &&\n        !Array.isArray(error) &&\n        hasKey(error, 'code') &&\n        isValidCode(error.code)) {\n        const _error = error;\n        serialized.code = _error.code;\n        if (_error.message && typeof _error.message === 'string') {\n            serialized.message = _error.message;\n            if (hasKey(_error, 'data')) {\n                serialized.data = _error.data;\n            }\n        }\n        else {\n            serialized.message = getMessageFromCode(serialized.code);\n            serialized.data = { originalError: assignOriginalError(error) };\n        }\n    }\n    else {\n        serialized.code = fallbackError.code;\n        const message = (_a = error) === null || _a === void 0 ? void 0 : _a.message;\n        serialized.message = (message && typeof message === 'string'\n            ? message\n            : fallbackError.message);\n        serialized.data = { originalError: assignOriginalError(error) };\n    }\n    const stack = (_b = error) === null || _b === void 0 ? void 0 : _b.stack;\n    if (shouldIncludeStack && error && stack && typeof stack === 'string') {\n        serialized.stack = stack;\n    }\n    return serialized;\n}\nexports.serializeError = serializeError;\n// Internal\nfunction isJsonRpcServerError(code) {\n    return code >= -32099 && code <= -32000;\n}\nfunction assignOriginalError(error) {\n    if (error && typeof error === 'object' && !Array.isArray(error)) {\n        return Object.assign({}, error);\n    }\n    return error;\n}\nfunction hasKey(obj, key) {\n    return Object.prototype.hasOwnProperty.call(obj, key);\n}\n//# sourceMappingURL=data:application/json;base64,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","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst messages = {\n    errors: {\n        disconnected: () => 'MetaMask: Disconnected from chain. Attempting to connect.',\n        permanentlyDisconnected: () => 'MetaMask: Disconnected from MetaMask background. Page reload required.',\n        sendSiteMetadata: () => `MetaMask: Failed to send site metadata. This is an internal error, please report this bug.`,\n        unsupportedSync: (method) => `MetaMask: The MetaMask Ethereum provider does not support synchronous methods like ${method} without a callback parameter.`,\n        invalidDuplexStream: () => 'Must provide a Node.js-style duplex stream.',\n        invalidOptions: (maxEventListeners, shouldSendMetadata) => `Invalid options. Received: { maxEventListeners: ${maxEventListeners}, shouldSendMetadata: ${shouldSendMetadata} }`,\n        invalidRequestArgs: () => `Expected a single, non-array, object argument.`,\n        invalidRequestMethod: () => `'args.method' must be a non-empty string.`,\n        invalidRequestParams: () => `'args.params' must be an object or array if provided.`,\n        invalidLoggerObject: () => `'args.logger' must be an object if provided.`,\n        invalidLoggerMethod: (method) => `'args.logger' must include required method '${method}'.`,\n    },\n    info: {\n        connected: (chainId) => `MetaMask: Connected to chain with ID \"${chainId}\".`,\n    },\n    warnings: {\n        // deprecated methods\n        enableDeprecation: `MetaMask: 'ethereum.enable()' is deprecated and may be removed in the future. Please use the 'eth_requestAccounts' RPC method instead.\\nFor more information, see: https://eips.ethereum.org/EIPS/eip-1102`,\n        sendDeprecation: `MetaMask: 'ethereum.send(...)' is deprecated and may be removed in the future. Please use 'ethereum.sendAsync(...)' or 'ethereum.request(...)' instead.\\nFor more information, see: https://eips.ethereum.org/EIPS/eip-1193`,\n        // deprecated events\n        events: {\n            close: `MetaMask: The event 'close' is deprecated and may be removed in the future. Please use 'disconnect' instead.\\nFor more information, see: https://eips.ethereum.org/EIPS/eip-1193#disconnect`,\n            data: `MetaMask: The event 'data' is deprecated and will be removed in the future. Use 'message' instead.\\nFor more information, see: https://eips.ethereum.org/EIPS/eip-1193#message`,\n            networkChanged: `MetaMask: The event 'networkChanged' is deprecated and may be removed in the future. Use 'chainChanged' instead.\\nFor more information, see: https://eips.ethereum.org/EIPS/eip-1193#chainchanged`,\n            notification: `MetaMask: The event 'notification' is deprecated and may be removed in the future. Use 'message' instead.\\nFor more information, see: https://eips.ethereum.org/EIPS/eip-1193#message`,\n        },\n        // misc\n        experimentalMethods: `MetaMask: 'ethereum._metamask' exposes non-standard, experimental methods. They may be removed or changed without warning.`,\n    },\n};\nexports.default = messages;\n//# sourceMappingURL=messages.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.EMITTED_NOTIFICATIONS = exports.NOOP = exports.logStreamDisconnectWarning = exports.getRpcPromiseCallback = exports.createErrorMiddleware = void 0;\nconst eth_rpc_errors_1 = require(\"eth-rpc-errors\");\n// utility functions\n/**\n * json-rpc-engine middleware that logs RPC errors and and validates req.method.\n *\n * @param log - The logging API to use.\n * @returns  json-rpc-engine middleware function\n */\nfunction createErrorMiddleware(log) {\n    return (req, res, next) => {\n        // json-rpc-engine will terminate the request when it notices this error\n        if (typeof req.method !== 'string' || !req.method) {\n            res.error = eth_rpc_errors_1.ethErrors.rpc.invalidRequest({\n                message: `The request 'method' must be a non-empty string.`,\n                data: req,\n            });\n        }\n        next((done) => {\n            const { error } = res;\n            if (!error) {\n                return done();\n            }\n            log.error(`MetaMask - RPC Error: ${error.message}`, error);\n            return done();\n        });\n    };\n}\nexports.createErrorMiddleware = createErrorMiddleware;\n// resolve response.result or response, reject errors\nconst getRpcPromiseCallback = (resolve, reject, unwrapResult = true) => (error, response) => {\n    if (error || response.error) {\n        reject(error || response.error);\n    }\n    else {\n        !unwrapResult || Array.isArray(response)\n            ? resolve(response)\n            : resolve(response.result);\n    }\n};\nexports.getRpcPromiseCallback = getRpcPromiseCallback;\n/**\n * Logs a stream disconnection error. Emits an 'error' if given an\n * EventEmitter that has listeners for the 'error' event.\n *\n * @param log - The logging API to use.\n * @param remoteLabel - The label of the disconnected stream.\n * @param error - The associated error to log.\n * @param emitter - The logging API to use.\n */\nfunction logStreamDisconnectWarning(log, remoteLabel, error, emitter) {\n    let warningMsg = `MetaMask: Lost connection to \"${remoteLabel}\".`;\n    if (error === null || error === void 0 ? void 0 : error.stack) {\n        warningMsg += `\\n${error.stack}`;\n    }\n    log.warn(warningMsg);\n    if (emitter && emitter.listenerCount('error') > 0) {\n        emitter.emit('error', warningMsg);\n    }\n}\nexports.logStreamDisconnectWarning = logStreamDisconnectWarning;\nconst NOOP = () => undefined;\nexports.NOOP = NOOP;\n// constants\nexports.EMITTED_NOTIFICATIONS = [\n    'eth_subscription',\n];\n//# sourceMappingURL=utils.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * If no existing window.web3 is found, this function injects a web3 \"shim\" to\n * not break dapps that rely on window.web3.currentProvider.\n *\n * @param provider - The provider to set as window.web3.currentProvider.\n * @param log - The logging API to use.\n */\nfunction shimWeb3(provider, log = console) {\n    let loggedCurrentProvider = false;\n    let loggedMissingProperty = false;\n    if (!window.web3) {\n        const SHIM_IDENTIFIER = '__isMetaMaskShim__';\n        let web3Shim = { currentProvider: provider };\n        Object.defineProperty(web3Shim, SHIM_IDENTIFIER, {\n            value: true,\n            enumerable: true,\n            configurable: false,\n            writable: false,\n        });\n        web3Shim = new Proxy(web3Shim, {\n            get: (target, property, ...args) => {\n                if (property === 'currentProvider' && !loggedCurrentProvider) {\n                    loggedCurrentProvider = true;\n                    log.warn('You are accessing the MetaMask window.web3.currentProvider shim. This property is deprecated; use window.ethereum instead. For details, see: https://docs.metamask.io/guide/provider-migration.html#replacing-window-web3');\n                }\n                else if (property !== SHIM_IDENTIFIER && !loggedMissingProperty) {\n                    loggedMissingProperty = true;\n                    log.error(`MetaMask no longer injects web3. For details, see: https://docs.metamask.io/guide/provider-migration.html#replacing-window-web3`);\n                    provider.request({ method: 'metamask_logWeb3ShimUsage' })\n                        .catch((error) => {\n                        log.debug('MetaMask: Failed to log web3 shim usage.', error);\n                    });\n                }\n                return Reflect.get(target, property, ...args);\n            },\n            set: (...args) => {\n                log.warn('You are accessing the MetaMask window.web3 shim. This object is deprecated; use window.ethereum instead. For details, see: https://docs.metamask.io/guide/provider-migration.html#replacing-window-web3');\n                return Reflect.set(...args);\n            },\n        });\n        Object.defineProperty(window, 'web3', {\n            value: web3Shim,\n            enumerable: false,\n            configurable: true,\n            writable: true,\n        });\n    }\n}\nexports.default = shimWeb3;\n//# sourceMappingURL=shimWeb3.js.map","// 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\n/*<replacement>*/\n\nvar processNextTick = require('process-nextick-args');\n/*</replacement>*/\n\nmodule.exports = Readable;\n\n/*<replacement>*/\nvar isArray = require('isarray');\n/*</replacement>*/\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nReadable.ReadableState = ReadableState;\n\n/*<replacement>*/\nvar EE = require('events').EventEmitter;\n\nvar EElistenerCount = function (emitter, type) {\n  return emitter.listeners(type).length;\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n// TODO(bmeurer): Change this back to const once hole checks are\n// properly optimized away early in Ignition+TurboFan.\n/*<replacement>*/\nvar Buffer = require('safe-buffer').Buffer;\nvar OurUint8Array = global.Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n/*</replacement>*/\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\n/*<replacement>*/\nvar debugUtil = require('util');\nvar debug = void 0;\nif (debugUtil && debugUtil.debuglog) {\n  debug = debugUtil.debuglog('stream');\n} else {\n  debug = function () {};\n}\n/*</replacement>*/\n\nvar BufferList = require('./internal/streams/BufferList');\nvar destroyImpl = require('./internal/streams/destroy');\nvar StringDecoder;\n\nutil.inherits(Readable, Stream);\n\nvar kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];\n\nfunction prependListener(emitter, event, fn) {\n  // Sadly this is not cacheable as some libraries bundle their own\n  // event emitter implementation with them.\n  if (typeof emitter.prependListener === 'function') {\n    return emitter.prependListener(event, fn);\n  } else {\n    // This is a hack to make sure that our error handler is attached before any\n    // userland ones.  NEVER DO THIS. This is here only because this code needs\n    // to continue to work with older versions of Node.js that do not include\n    // the prependListener() method. The goal is to eventually remove this hack.\n    if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];\n  }\n}\n\nfunction ReadableState(options, stream) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  options = options || {};\n\n  // object stream flag. Used to make read(n) ignore n and to\n  // make all the buffer merging and length checks go away\n  this.objectMode = !!options.objectMode;\n\n  if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.readableObjectMode;\n\n  // the point at which it stops calling _read() to fill the buffer\n  // Note: 0 is a valid value, means \"don't call _read preemptively ever\"\n  var hwm = options.highWaterMark;\n  var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n  this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;\n\n  // cast to ints.\n  this.highWaterMark = Math.floor(this.highWaterMark);\n\n  // A linked list is used to store data chunks instead of an array because the\n  // linked list can remove elements from the beginning faster than\n  // array.shift()\n  this.buffer = new BufferList();\n  this.length = 0;\n  this.pipes = null;\n  this.pipesCount = 0;\n  this.flowing = null;\n  this.ended = false;\n  this.endEmitted = false;\n  this.reading = false;\n\n  // a flag to be able to tell if the event 'readable'/'data' is emitted\n  // immediately, or on a later tick.  We set this to true at first, because\n  // any actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first read call.\n  this.sync = true;\n\n  // whenever we return null, then we set a flag to say\n  // that we're awaiting a 'readable' event emission.\n  this.needReadable = false;\n  this.emittedReadable = false;\n  this.readableListening = false;\n  this.resumeScheduled = false;\n\n  // has it been destroyed\n  this.destroyed = false;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // the number of writers that are awaiting a drain event in .pipe()s\n  this.awaitDrain = 0;\n\n  // if true, a maybeReadMore has been scheduled\n  this.readingMore = false;\n\n  this.decoder = null;\n  this.encoding = null;\n  if (options.encoding) {\n    if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n    this.decoder = new StringDecoder(options.encoding);\n    this.encoding = options.encoding;\n  }\n}\n\nfunction Readable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  if (!(this instanceof Readable)) return new Readable(options);\n\n  this._readableState = new ReadableState(options, this);\n\n  // legacy\n  this.readable = true;\n\n  if (options) {\n    if (typeof options.read === 'function') this._read = options.read;\n\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n  }\n\n  Stream.call(this);\n}\n\nObject.defineProperty(Readable.prototype, 'destroyed', {\n  get: function () {\n    if (this._readableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._readableState) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._readableState.destroyed = value;\n  }\n});\n\nReadable.prototype.destroy = destroyImpl.destroy;\nReadable.prototype._undestroy = destroyImpl.undestroy;\nReadable.prototype._destroy = function (err, cb) {\n  this.push(null);\n  cb(err);\n};\n\n// Manually shove something into the read() buffer.\n// This returns true if the highWaterMark has not been hit yet,\n// similar to how Writable.write() returns true if you should\n// write() some more.\nReadable.prototype.push = function (chunk, encoding) {\n  var state = this._readableState;\n  var skipChunkCheck;\n\n  if (!state.objectMode) {\n    if (typeof chunk === 'string') {\n      encoding = encoding || state.defaultEncoding;\n      if (encoding !== state.encoding) {\n        chunk = Buffer.from(chunk, encoding);\n        encoding = '';\n      }\n      skipChunkCheck = true;\n    }\n  } else {\n    skipChunkCheck = true;\n  }\n\n  return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);\n};\n\n// Unshift should *always* be something directly out of read()\nReadable.prototype.unshift = function (chunk) {\n  return readableAddChunk(this, chunk, null, true, false);\n};\n\nfunction readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {\n  var state = stream._readableState;\n  if (chunk === null) {\n    state.reading = false;\n    onEofChunk(stream, state);\n  } else {\n    var er;\n    if (!skipChunkCheck) er = chunkInvalid(state, chunk);\n    if (er) {\n      stream.emit('error', er);\n    } else if (state.objectMode || chunk && chunk.length > 0) {\n      if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {\n        chunk = _uint8ArrayToBuffer(chunk);\n      }\n\n      if (addToFront) {\n        if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true);\n      } else if (state.ended) {\n        stream.emit('error', new Error('stream.push() after EOF'));\n      } else {\n        state.reading = false;\n        if (state.decoder && !encoding) {\n          chunk = state.decoder.write(chunk);\n          if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);\n        } else {\n          addChunk(stream, state, chunk, false);\n        }\n      }\n    } else if (!addToFront) {\n      state.reading = false;\n    }\n  }\n\n  return needMoreData(state);\n}\n\nfunction addChunk(stream, state, chunk, addToFront) {\n  if (state.flowing && state.length === 0 && !state.sync) {\n    stream.emit('data', chunk);\n    stream.read(0);\n  } else {\n    // update the buffer info.\n    state.length += state.objectMode ? 1 : chunk.length;\n    if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);\n\n    if (state.needReadable) emitReadable(stream);\n  }\n  maybeReadMore(stream, state);\n}\n\nfunction chunkInvalid(state, chunk) {\n  var er;\n  if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new TypeError('Invalid non-string/buffer chunk');\n  }\n  return er;\n}\n\n// if it's past the high water mark, we can push in some more.\n// Also, if we have no data yet, we can stand some\n// more bytes.  This is to work around cases where hwm=0,\n// such as the repl.  Also, if the push() triggered a\n// readable event, and the user called read(largeNumber) such that\n// needReadable was set, then we ought to push more, so that another\n// 'readable' event will be triggered.\nfunction needMoreData(state) {\n  return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);\n}\n\nReadable.prototype.isPaused = function () {\n  return this._readableState.flowing === false;\n};\n\n// backwards compatibility.\nReadable.prototype.setEncoding = function (enc) {\n  if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n  this._readableState.decoder = new StringDecoder(enc);\n  this._readableState.encoding = enc;\n  return this;\n};\n\n// Don't raise the hwm > 8MB\nvar MAX_HWM = 0x800000;\nfunction computeNewHighWaterMark(n) {\n  if (n >= MAX_HWM) {\n    n = MAX_HWM;\n  } else {\n    // Get the next highest power of 2 to prevent increasing hwm excessively in\n    // tiny amounts\n    n--;\n    n |= n >>> 1;\n    n |= n >>> 2;\n    n |= n >>> 4;\n    n |= n >>> 8;\n    n |= n >>> 16;\n    n++;\n  }\n  return n;\n}\n\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction howMuchToRead(n, state) {\n  if (n <= 0 || state.length === 0 && state.ended) return 0;\n  if (state.objectMode) return 1;\n  if (n !== n) {\n    // Only flow one buffer at a time\n    if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;\n  }\n  // If we're asking for more than the current hwm, then raise the hwm.\n  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);\n  if (n <= state.length) return n;\n  // Don't have enough\n  if (!state.ended) {\n    state.needReadable = true;\n    return 0;\n  }\n  return state.length;\n}\n\n// you can override either this method, or the async _read(n) below.\nReadable.prototype.read = function (n) {\n  debug('read', n);\n  n = parseInt(n, 10);\n  var state = this._readableState;\n  var nOrig = n;\n\n  if (n !== 0) state.emittedReadable = false;\n\n  // if we're doing read(0) to trigger a readable event, but we\n  // already have a bunch of data in the buffer, then just trigger\n  // the 'readable' event and move on.\n  if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {\n    debug('read: emitReadable', state.length, state.ended);\n    if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);\n    return null;\n  }\n\n  n = howMuchToRead(n, state);\n\n  // if we've ended, and we're now clear, then finish it up.\n  if (n === 0 && state.ended) {\n    if (state.length === 0) endReadable(this);\n    return null;\n  }\n\n  // All the actual chunk generation logic needs to be\n  // *below* the call to _read.  The reason is that in certain\n  // synthetic stream cases, such as passthrough streams, _read\n  // may be a completely synchronous operation which may change\n  // the state of the read buffer, providing enough data when\n  // before there was *not* enough.\n  //\n  // So, the steps are:\n  // 1. Figure out what the state of things will be after we do\n  // a read from the buffer.\n  //\n  // 2. If that resulting state will trigger a _read, then call _read.\n  // Note that this may be asynchronous, or synchronous.  Yes, it is\n  // deeply ugly to write APIs this way, but that still doesn't mean\n  // that the Readable class should behave improperly, as streams are\n  // designed to be sync/async agnostic.\n  // Take note if the _read call is sync or async (ie, if the read call\n  // has returned yet), so that we know whether or not it's safe to emit\n  // 'readable' etc.\n  //\n  // 3. Actually pull the requested chunks out of the buffer and return.\n\n  // if we need a readable event, then we need to do some reading.\n  var doRead = state.needReadable;\n  debug('need readable', doRead);\n\n  // if we currently have less than the highWaterMark, then also read some\n  if (state.length === 0 || state.length - n < state.highWaterMark) {\n    doRead = true;\n    debug('length less than watermark', doRead);\n  }\n\n  // however, if we've ended, then there's no point, and if we're already\n  // reading, then it's unnecessary.\n  if (state.ended || state.reading) {\n    doRead = false;\n    debug('reading or ended', doRead);\n  } else if (doRead) {\n    debug('do read');\n    state.reading = true;\n    state.sync = true;\n    // if the length is currently zero, then we *need* a readable event.\n    if (state.length === 0) state.needReadable = true;\n    // call internal read method\n    this._read(state.highWaterMark);\n    state.sync = false;\n    // If _read pushed data synchronously, then `reading` will be false,\n    // and we need to re-evaluate how much data we can return to the user.\n    if (!state.reading) n = howMuchToRead(nOrig, state);\n  }\n\n  var ret;\n  if (n > 0) ret = fromList(n, state);else ret = null;\n\n  if (ret === null) {\n    state.needReadable = true;\n    n = 0;\n  } else {\n    state.length -= n;\n  }\n\n  if (state.length === 0) {\n    // If we have nothing in the buffer, then we want to know\n    // as soon as we *do* get something into the buffer.\n    if (!state.ended) state.needReadable = true;\n\n    // If we tried to read() past the EOF, then emit end on the next tick.\n    if (nOrig !== n && state.ended) endReadable(this);\n  }\n\n  if (ret !== null) this.emit('data', ret);\n\n  return ret;\n};\n\nfunction onEofChunk(stream, state) {\n  if (state.ended) return;\n  if (state.decoder) {\n    var chunk = state.decoder.end();\n    if (chunk && chunk.length) {\n      state.buffer.push(chunk);\n      state.length += state.objectMode ? 1 : chunk.length;\n    }\n  }\n  state.ended = true;\n\n  // emit 'readable' now to make sure it gets picked up.\n  emitReadable(stream);\n}\n\n// Don't emit readable right away in sync mode, because this can trigger\n// another read() call => stack overflow.  This way, it might trigger\n// a nextTick recursion warning, but that's not so bad.\nfunction emitReadable(stream) {\n  var state = stream._readableState;\n  state.needReadable = false;\n  if (!state.emittedReadable) {\n    debug('emitReadable', state.flowing);\n    state.emittedReadable = true;\n    if (state.sync) processNextTick(emitReadable_, stream);else emitReadable_(stream);\n  }\n}\n\nfunction emitReadable_(stream) {\n  debug('emit readable');\n  stream.emit('readable');\n  flow(stream);\n}\n\n// at this point, the user has presumably seen the 'readable' event,\n// and called read() to consume some data.  that may have triggered\n// in turn another _read(n) call, in which case reading = true if\n// it's in progress.\n// However, if we're not ended, or reading, and the length < hwm,\n// then go ahead and try to read some more preemptively.\nfunction maybeReadMore(stream, state) {\n  if (!state.readingMore) {\n    state.readingMore = true;\n    processNextTick(maybeReadMore_, stream, state);\n  }\n}\n\nfunction maybeReadMore_(stream, state) {\n  var len = state.length;\n  while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {\n    debug('maybeReadMore read 0');\n    stream.read(0);\n    if (len === state.length)\n      // didn't get any data, stop spinning.\n      break;else len = state.length;\n  }\n  state.readingMore = false;\n}\n\n// abstract method.  to be overridden in specific implementation classes.\n// call cb(er, data) where data is <= n in length.\n// for virtual (non-string, non-buffer) streams, \"length\" is somewhat\n// arbitrary, and perhaps not very meaningful.\nReadable.prototype._read = function (n) {\n  this.emit('error', new Error('_read() is not implemented'));\n};\n\nReadable.prototype.pipe = function (dest, pipeOpts) {\n  var src = this;\n  var state = this._readableState;\n\n  switch (state.pipesCount) {\n    case 0:\n      state.pipes = dest;\n      break;\n    case 1:\n      state.pipes = [state.pipes, dest];\n      break;\n    default:\n      state.pipes.push(dest);\n      break;\n  }\n  state.pipesCount += 1;\n  debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);\n\n  var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;\n\n  var endFn = doEnd ? onend : unpipe;\n  if (state.endEmitted) processNextTick(endFn);else src.once('end', endFn);\n\n  dest.on('unpipe', onunpipe);\n  function onunpipe(readable, unpipeInfo) {\n    debug('onunpipe');\n    if (readable === src) {\n      if (unpipeInfo && unpipeInfo.hasUnpiped === false) {\n        unpipeInfo.hasUnpiped = true;\n        cleanup();\n      }\n    }\n  }\n\n  function onend() {\n    debug('onend');\n    dest.end();\n  }\n\n  // when the dest drains, it reduces the awaitDrain counter\n  // on the source.  This would be more elegant with a .once()\n  // handler in flow(), but adding and removing repeatedly is\n  // too slow.\n  var ondrain = pipeOnDrain(src);\n  dest.on('drain', ondrain);\n\n  var cleanedUp = false;\n  function cleanup() {\n    debug('cleanup');\n    // cleanup event handlers once the pipe is broken\n    dest.removeListener('close', onclose);\n    dest.removeListener('finish', onfinish);\n    dest.removeListener('drain', ondrain);\n    dest.removeListener('error', onerror);\n    dest.removeListener('unpipe', onunpipe);\n    src.removeListener('end', onend);\n    src.removeListener('end', unpipe);\n    src.removeListener('data', ondata);\n\n    cleanedUp = true;\n\n    // if the reader is waiting for a drain event from this\n    // specific writer, then it would cause it to never start\n    // flowing again.\n    // So, if this is awaiting a drain, then we just call it now.\n    // If we don't know, then assume that we are waiting for one.\n    if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();\n  }\n\n  // If the user pushes more data while we're writing to dest then we'll end up\n  // in ondata again. However, we only want to increase awaitDrain once because\n  // dest will only emit one 'drain' event for the multiple writes.\n  // => Introduce a guard on increasing awaitDrain.\n  var increasedAwaitDrain = false;\n  src.on('data', ondata);\n  function ondata(chunk) {\n    debug('ondata');\n    increasedAwaitDrain = false;\n    var ret = dest.write(chunk);\n    if (false === ret && !increasedAwaitDrain) {\n      // If the user unpiped during `dest.write()`, it is possible\n      // to get stuck in a permanently paused state if that write\n      // also returned false.\n      // => Check whether `dest` is still a piping destination.\n      if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {\n        debug('false write response, pause', src._readableState.awaitDrain);\n        src._readableState.awaitDrain++;\n        increasedAwaitDrain = true;\n      }\n      src.pause();\n    }\n  }\n\n  // if the dest has an error, then stop piping into it.\n  // however, don't suppress the throwing behavior for this.\n  function onerror(er) {\n    debug('onerror', er);\n    unpipe();\n    dest.removeListener('error', onerror);\n    if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);\n  }\n\n  // Make sure our error handler is attached before userland ones.\n  prependListener(dest, 'error', onerror);\n\n  // Both close and finish should trigger unpipe, but only once.\n  function onclose() {\n    dest.removeListener('finish', onfinish);\n    unpipe();\n  }\n  dest.once('close', onclose);\n  function onfinish() {\n    debug('onfinish');\n    dest.removeListener('close', onclose);\n    unpipe();\n  }\n  dest.once('finish', onfinish);\n\n  function unpipe() {\n    debug('unpipe');\n    src.unpipe(dest);\n  }\n\n  // tell the dest that it's being piped to\n  dest.emit('pipe', src);\n\n  // start the flow if it hasn't been started already.\n  if (!state.flowing) {\n    debug('pipe resume');\n    src.resume();\n  }\n\n  return dest;\n};\n\nfunction pipeOnDrain(src) {\n  return function () {\n    var state = src._readableState;\n    debug('pipeOnDrain', state.awaitDrain);\n    if (state.awaitDrain) state.awaitDrain--;\n    if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {\n      state.flowing = true;\n      flow(src);\n    }\n  };\n}\n\nReadable.prototype.unpipe = function (dest) {\n  var state = this._readableState;\n  var unpipeInfo = { hasUnpiped: false };\n\n  // if we're not piping anywhere, then do nothing.\n  if (state.pipesCount === 0) return this;\n\n  // just one destination.  most common case.\n  if (state.pipesCount === 1) {\n    // passed in one, but it's not the right one.\n    if (dest && dest !== state.pipes) return this;\n\n    if (!dest) dest = state.pipes;\n\n    // got a match.\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n    if (dest) dest.emit('unpipe', this, unpipeInfo);\n    return this;\n  }\n\n  // slow case. multiple pipe destinations.\n\n  if (!dest) {\n    // remove all.\n    var dests = state.pipes;\n    var len = state.pipesCount;\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n\n    for (var i = 0; i < len; i++) {\n      dests[i].emit('unpipe', this, unpipeInfo);\n    }return this;\n  }\n\n  // try to find the right one.\n  var index = indexOf(state.pipes, dest);\n  if (index === -1) return this;\n\n  state.pipes.splice(index, 1);\n  state.pipesCount -= 1;\n  if (state.pipesCount === 1) state.pipes = state.pipes[0];\n\n  dest.emit('unpipe', this, unpipeInfo);\n\n  return this;\n};\n\n// set up data events if they are asked for\n// Ensure readable listeners eventually get something\nReadable.prototype.on = function (ev, fn) {\n  var res = Stream.prototype.on.call(this, ev, fn);\n\n  if (ev === 'data') {\n    // Start flowing on next tick if stream isn't explicitly paused\n    if (this._readableState.flowing !== false) this.resume();\n  } else if (ev === 'readable') {\n    var state = this._readableState;\n    if (!state.endEmitted && !state.readableListening) {\n      state.readableListening = state.needReadable = true;\n      state.emittedReadable = false;\n      if (!state.reading) {\n        processNextTick(nReadingNextTick, this);\n      } else if (state.length) {\n        emitReadable(this);\n      }\n    }\n  }\n\n  return res;\n};\nReadable.prototype.addListener = Readable.prototype.on;\n\nfunction nReadingNextTick(self) {\n  debug('readable nexttick read 0');\n  self.read(0);\n}\n\n// pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\nReadable.prototype.resume = function () {\n  var state = this._readableState;\n  if (!state.flowing) {\n    debug('resume');\n    state.flowing = true;\n    resume(this, state);\n  }\n  return this;\n};\n\nfunction resume(stream, state) {\n  if (!state.resumeScheduled) {\n    state.resumeScheduled = true;\n    processNextTick(resume_, stream, state);\n  }\n}\n\nfunction resume_(stream, state) {\n  if (!state.reading) {\n    debug('resume read 0');\n    stream.read(0);\n  }\n\n  state.resumeScheduled = false;\n  state.awaitDrain = 0;\n  stream.emit('resume');\n  flow(stream);\n  if (state.flowing && !state.reading) stream.read(0);\n}\n\nReadable.prototype.pause = function () {\n  debug('call pause flowing=%j', this._readableState.flowing);\n  if (false !== this._readableState.flowing) {\n    debug('pause');\n    this._readableState.flowing = false;\n    this.emit('pause');\n  }\n  return this;\n};\n\nfunction flow(stream) {\n  var state = stream._readableState;\n  debug('flow', state.flowing);\n  while (state.flowing && stream.read() !== null) {}\n}\n\n// wrap an old-style stream as the async data source.\n// This is *not* part of the readable stream interface.\n// It is an ugly unfortunate mess of history.\nReadable.prototype.wrap = function (stream) {\n  var state = this._readableState;\n  var paused = false;\n\n  var self = this;\n  stream.on('end', function () {\n    debug('wrapped end');\n    if (state.decoder && !state.ended) {\n      var chunk = state.decoder.end();\n      if (chunk && chunk.length) self.push(chunk);\n    }\n\n    self.push(null);\n  });\n\n  stream.on('data', function (chunk) {\n    debug('wrapped data');\n    if (state.decoder) chunk = state.decoder.write(chunk);\n\n    // don't skip over falsy values in objectMode\n    if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;\n\n    var ret = self.push(chunk);\n    if (!ret) {\n      paused = true;\n      stream.pause();\n    }\n  });\n\n  // proxy all the other methods.\n  // important when wrapping filters and duplexes.\n  for (var i in stream) {\n    if (this[i] === undefined && typeof stream[i] === 'function') {\n      this[i] = function (method) {\n        return function () {\n          return stream[method].apply(stream, arguments);\n        };\n      }(i);\n    }\n  }\n\n  // proxy certain important events.\n  for (var n = 0; n < kProxyEvents.length; n++) {\n    stream.on(kProxyEvents[n], self.emit.bind(self, kProxyEvents[n]));\n  }\n\n  // when we try to consume some more bytes, simply unpause the\n  // underlying stream.\n  self._read = function (n) {\n    debug('wrapped _read', n);\n    if (paused) {\n      paused = false;\n      stream.resume();\n    }\n  };\n\n  return self;\n};\n\n// exposed for testing purposes only.\nReadable._fromList = fromList;\n\n// Pluck off n bytes from an array of buffers.\n// Length is the combined lengths of all the buffers in the list.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromList(n, state) {\n  // nothing buffered\n  if (state.length === 0) return null;\n\n  var ret;\n  if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {\n    // read it all, truncate the list\n    if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length);\n    state.buffer.clear();\n  } else {\n    // read part of list\n    ret = fromListPartial(n, state.buffer, state.decoder);\n  }\n\n  return ret;\n}\n\n// Extracts only enough buffered data to satisfy the amount requested.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromListPartial(n, list, hasStrings) {\n  var ret;\n  if (n < list.head.data.length) {\n    // slice is the same for buffers and strings\n    ret = list.head.data.slice(0, n);\n    list.head.data = list.head.data.slice(n);\n  } else if (n === list.head.data.length) {\n    // first chunk is a perfect match\n    ret = list.shift();\n  } else {\n    // result spans more than one buffer\n    ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);\n  }\n  return ret;\n}\n\n// Copies a specified amount of characters from the list of buffered data\n// chunks.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction copyFromBufferString(n, list) {\n  var p = list.head;\n  var c = 1;\n  var ret = p.data;\n  n -= ret.length;\n  while (p = p.next) {\n    var str = p.data;\n    var nb = n > str.length ? str.length : n;\n    if (nb === str.length) ret += str;else ret += str.slice(0, n);\n    n -= nb;\n    if (n === 0) {\n      if (nb === str.length) {\n        ++c;\n        if (p.next) list.head = p.next;else list.head = list.tail = null;\n      } else {\n        list.head = p;\n        p.data = str.slice(nb);\n      }\n      break;\n    }\n    ++c;\n  }\n  list.length -= c;\n  return ret;\n}\n\n// Copies a specified amount of bytes from the list of buffered data chunks.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction copyFromBuffer(n, list) {\n  var ret = Buffer.allocUnsafe(n);\n  var p = list.head;\n  var c = 1;\n  p.data.copy(ret);\n  n -= p.data.length;\n  while (p = p.next) {\n    var buf = p.data;\n    var nb = n > buf.length ? buf.length : n;\n    buf.copy(ret, ret.length - n, 0, nb);\n    n -= nb;\n    if (n === 0) {\n      if (nb === buf.length) {\n        ++c;\n        if (p.next) list.head = p.next;else list.head = list.tail = null;\n      } else {\n        list.head = p;\n        p.data = buf.slice(nb);\n      }\n      break;\n    }\n    ++c;\n  }\n  list.length -= c;\n  return ret;\n}\n\nfunction endReadable(stream) {\n  var state = stream._readableState;\n\n  // If we get here before consuming all the bytes, then that is a\n  // bug in node.  Should never happen.\n  if (state.length > 0) throw new Error('\"endReadable()\" called on non-empty stream');\n\n  if (!state.endEmitted) {\n    state.ended = true;\n    processNextTick(endReadableNT, state, stream);\n  }\n}\n\nfunction endReadableNT(state, stream) {\n  // Check that we didn't get one last unshift.\n  if (!state.endEmitted && state.length === 0) {\n    state.endEmitted = true;\n    stream.readable = false;\n    stream.emit('end');\n  }\n}\n\nfunction forEach(xs, f) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    f(xs[i], i);\n  }\n}\n\nfunction indexOf(xs, x) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    if (xs[i] === x) return i;\n  }\n  return -1;\n}","module.exports = require('events').EventEmitter;\n","'use strict';\n\n/*<replacement>*/\n\nvar processNextTick = require('process-nextick-args');\n/*</replacement>*/\n\n// undocumented cb() API, needed for core, not for public API\nfunction destroy(err, cb) {\n  var _this = this;\n\n  var readableDestroyed = this._readableState && this._readableState.destroyed;\n  var writableDestroyed = this._writableState && this._writableState.destroyed;\n\n  if (readableDestroyed || writableDestroyed) {\n    if (cb) {\n      cb(err);\n    } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {\n      processNextTick(emitErrorNT, this, err);\n    }\n    return;\n  }\n\n  // we set destroyed to true before firing error callbacks in order\n  // to make it re-entrance safe in case destroy() is called within callbacks\n\n  if (this._readableState) {\n    this._readableState.destroyed = true;\n  }\n\n  // if this is a duplex stream mark the writable part as destroyed as well\n  if (this._writableState) {\n    this._writableState.destroyed = true;\n  }\n\n  this._destroy(err || null, function (err) {\n    if (!cb && err) {\n      processNextTick(emitErrorNT, _this, err);\n      if (_this._writableState) {\n        _this._writableState.errorEmitted = true;\n      }\n    } else if (cb) {\n      cb(err);\n    }\n  });\n}\n\nfunction undestroy() {\n  if (this._readableState) {\n    this._readableState.destroyed = false;\n    this._readableState.reading = false;\n    this._readableState.ended = false;\n    this._readableState.endEmitted = false;\n  }\n\n  if (this._writableState) {\n    this._writableState.destroyed = false;\n    this._writableState.ended = false;\n    this._writableState.ending = false;\n    this._writableState.finished = false;\n    this._writableState.errorEmitted = false;\n  }\n}\n\nfunction emitErrorNT(self, err) {\n  self.emit('error', err);\n}\n\nmodule.exports = {\n  destroy: destroy,\n  undestroy: undestroy\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// A bit simpler than readable streams.\n// Implement an async ._write(chunk, encoding, cb), and it'll handle all\n// the drain event emission and buffering.\n\n'use strict';\n\n/*<replacement>*/\n\nvar processNextTick = require('process-nextick-args');\n/*</replacement>*/\n\nmodule.exports = Writable;\n\n/* <replacement> */\nfunction WriteReq(chunk, encoding, cb) {\n  this.chunk = chunk;\n  this.encoding = encoding;\n  this.callback = cb;\n  this.next = null;\n}\n\n// It seems a linked list but it is not\n// there will be only 2 of these for each stream\nfunction CorkedRequest(state) {\n  var _this = this;\n\n  this.next = null;\n  this.entry = null;\n  this.finish = function () {\n    onCorkedFinish(_this, state);\n  };\n}\n/* </replacement> */\n\n/*<replacement>*/\nvar asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : processNextTick;\n/*</replacement>*/\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nWritable.WritableState = WritableState;\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\n/*<replacement>*/\nvar internalUtil = {\n  deprecate: require('util-deprecate')\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n/*<replacement>*/\nvar Buffer = require('safe-buffer').Buffer;\nvar OurUint8Array = global.Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n/*</replacement>*/\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nutil.inherits(Writable, Stream);\n\nfunction nop() {}\n\nfunction WritableState(options, stream) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  options = options || {};\n\n  // object stream flag to indicate whether or not this stream\n  // contains buffers or objects.\n  this.objectMode = !!options.objectMode;\n\n  if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.writableObjectMode;\n\n  // the point at which write() starts returning false\n  // Note: 0 is a valid value, means that we always return false if\n  // the entire buffer is not flushed immediately on write()\n  var hwm = options.highWaterMark;\n  var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n  this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;\n\n  // cast to ints.\n  this.highWaterMark = Math.floor(this.highWaterMark);\n\n  // if _final has been called\n  this.finalCalled = false;\n\n  // drain event flag.\n  this.needDrain = false;\n  // at the start of calling end()\n  this.ending = false;\n  // when end() has been called, and returned\n  this.ended = false;\n  // when 'finish' is emitted\n  this.finished = false;\n\n  // has it been destroyed\n  this.destroyed = false;\n\n  // should we decode strings into buffers before passing to _write?\n  // this is here so that some node-core streams can optimize string\n  // handling at a lower level.\n  var noDecode = options.decodeStrings === false;\n  this.decodeStrings = !noDecode;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // not an actual buffer we keep track of, but a measurement\n  // of how much we're waiting to get pushed to some underlying\n  // socket or file.\n  this.length = 0;\n\n  // a flag to see when we're in the middle of a write.\n  this.writing = false;\n\n  // when true all writes will be buffered until .uncork() call\n  this.corked = 0;\n\n  // a flag to be able to tell if the onwrite cb is called immediately,\n  // or on a later tick.  We set this to true at first, because any\n  // actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first write call.\n  this.sync = true;\n\n  // a flag to know if we're processing previously buffered items, which\n  // may call the _write() callback in the same tick, so that we don't\n  // end up in an overlapped onwrite situation.\n  this.bufferProcessing = false;\n\n  // the callback that's passed to _write(chunk,cb)\n  this.onwrite = function (er) {\n    onwrite(stream, er);\n  };\n\n  // the callback that the user supplies to write(chunk,encoding,cb)\n  this.writecb = null;\n\n  // the amount that is being written when _write is called.\n  this.writelen = 0;\n\n  this.bufferedRequest = null;\n  this.lastBufferedRequest = null;\n\n  // number of pending user-supplied write callbacks\n  // this must be 0 before 'finish' can be emitted\n  this.pendingcb = 0;\n\n  // emit prefinish if the only thing we're waiting for is _write cbs\n  // This is relevant for synchronous Transform streams\n  this.prefinished = false;\n\n  // True if the error was already emitted and should not be thrown again\n  this.errorEmitted = false;\n\n  // count buffered requests\n  this.bufferedRequestCount = 0;\n\n  // allocate the first CorkedRequest, there is always\n  // one allocated and free to use, and we maintain at most two\n  this.corkedRequestsFree = new CorkedRequest(this);\n}\n\nWritableState.prototype.getBuffer = function getBuffer() {\n  var current = this.bufferedRequest;\n  var out = [];\n  while (current) {\n    out.push(current);\n    current = current.next;\n  }\n  return out;\n};\n\n(function () {\n  try {\n    Object.defineProperty(WritableState.prototype, 'buffer', {\n      get: internalUtil.deprecate(function () {\n        return this.getBuffer();\n      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')\n    });\n  } catch (_) {}\n})();\n\n// Test _writableState for inheritance to account for Duplex streams,\n// whose prototype chain only points to Readable.\nvar realHasInstance;\nif (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {\n  realHasInstance = Function.prototype[Symbol.hasInstance];\n  Object.defineProperty(Writable, Symbol.hasInstance, {\n    value: function (object) {\n      if (realHasInstance.call(this, object)) return true;\n\n      return object && object._writableState instanceof WritableState;\n    }\n  });\n} else {\n  realHasInstance = function (object) {\n    return object instanceof this;\n  };\n}\n\nfunction Writable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  // Writable ctor is applied to Duplexes, too.\n  // `realHasInstance` is necessary because using plain `instanceof`\n  // would return false, as no `_writableState` property is attached.\n\n  // Trying to use the custom `instanceof` for Writable here will also break the\n  // Node.js LazyTransform implementation, which has a non-trivial getter for\n  // `_writableState` that would lead to infinite recursion.\n  if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {\n    return new Writable(options);\n  }\n\n  this._writableState = new WritableState(options, this);\n\n  // legacy.\n  this.writable = true;\n\n  if (options) {\n    if (typeof options.write === 'function') this._write = options.write;\n\n    if (typeof options.writev === 'function') this._writev = options.writev;\n\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n\n    if (typeof options.final === 'function') this._final = options.final;\n  }\n\n  Stream.call(this);\n}\n\n// Otherwise people can pipe Writable streams, which is just wrong.\nWritable.prototype.pipe = function () {\n  this.emit('error', new Error('Cannot pipe, not readable'));\n};\n\nfunction writeAfterEnd(stream, cb) {\n  var er = new Error('write after end');\n  // TODO: defer error events consistently everywhere, not just the cb\n  stream.emit('error', er);\n  processNextTick(cb, er);\n}\n\n// Checks that a user-supplied chunk is valid, especially for the particular\n// mode the stream is in. Currently this means that `null` is never accepted\n// and undefined/non-string values are only allowed in object mode.\nfunction validChunk(stream, state, chunk, cb) {\n  var valid = true;\n  var er = false;\n\n  if (chunk === null) {\n    er = new TypeError('May not write null values to stream');\n  } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new TypeError('Invalid non-string/buffer chunk');\n  }\n  if (er) {\n    stream.emit('error', er);\n    processNextTick(cb, er);\n    valid = false;\n  }\n  return valid;\n}\n\nWritable.prototype.write = function (chunk, encoding, cb) {\n  var state = this._writableState;\n  var ret = false;\n  var isBuf = _isUint8Array(chunk) && !state.objectMode;\n\n  if (isBuf && !Buffer.isBuffer(chunk)) {\n    chunk = _uint8ArrayToBuffer(chunk);\n  }\n\n  if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;\n\n  if (typeof cb !== 'function') cb = nop;\n\n  if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {\n    state.pendingcb++;\n    ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);\n  }\n\n  return ret;\n};\n\nWritable.prototype.cork = function () {\n  var state = this._writableState;\n\n  state.corked++;\n};\n\nWritable.prototype.uncork = function () {\n  var state = this._writableState;\n\n  if (state.corked) {\n    state.corked--;\n\n    if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);\n  }\n};\n\nWritable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n  // node::ParseEncoding() requires lower case.\n  if (typeof encoding === 'string') encoding = encoding.toLowerCase();\n  if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding);\n  this._writableState.defaultEncoding = encoding;\n  return this;\n};\n\nfunction decodeChunk(state, chunk, encoding) {\n  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\n    chunk = Buffer.from(chunk, encoding);\n  }\n  return chunk;\n}\n\n// if we're already writing something, then just put this\n// in the queue, and wait our turn.  Otherwise, call _write\n// If we return false, then we need a drain event, so set that flag.\nfunction writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {\n  if (!isBuf) {\n    var newChunk = decodeChunk(state, chunk, encoding);\n    if (chunk !== newChunk) {\n      isBuf = true;\n      encoding = 'buffer';\n      chunk = newChunk;\n    }\n  }\n  var len = state.objectMode ? 1 : chunk.length;\n\n  state.length += len;\n\n  var ret = state.length < state.highWaterMark;\n  // we must ensure that previous needDrain will not be reset to false.\n  if (!ret) state.needDrain = true;\n\n  if (state.writing || state.corked) {\n    var last = state.lastBufferedRequest;\n    state.lastBufferedRequest = {\n      chunk: chunk,\n      encoding: encoding,\n      isBuf: isBuf,\n      callback: cb,\n      next: null\n    };\n    if (last) {\n      last.next = state.lastBufferedRequest;\n    } else {\n      state.bufferedRequest = state.lastBufferedRequest;\n    }\n    state.bufferedRequestCount += 1;\n  } else {\n    doWrite(stream, state, false, len, chunk, encoding, cb);\n  }\n\n  return ret;\n}\n\nfunction doWrite(stream, state, writev, len, chunk, encoding, cb) {\n  state.writelen = len;\n  state.writecb = cb;\n  state.writing = true;\n  state.sync = true;\n  if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);\n  state.sync = false;\n}\n\nfunction onwriteError(stream, state, sync, er, cb) {\n  --state.pendingcb;\n\n  if (sync) {\n    // defer the callback if we are being called synchronously\n    // to avoid piling up things on the stack\n    processNextTick(cb, er);\n    // this can emit finish, and it will always happen\n    // after error\n    processNextTick(finishMaybe, stream, state);\n    stream._writableState.errorEmitted = true;\n    stream.emit('error', er);\n  } else {\n    // the caller expect this to happen before if\n    // it is async\n    cb(er);\n    stream._writableState.errorEmitted = true;\n    stream.emit('error', er);\n    // this can emit finish, but finish must\n    // always follow error\n    finishMaybe(stream, state);\n  }\n}\n\nfunction onwriteStateUpdate(state) {\n  state.writing = false;\n  state.writecb = null;\n  state.length -= state.writelen;\n  state.writelen = 0;\n}\n\nfunction onwrite(stream, er) {\n  var state = stream._writableState;\n  var sync = state.sync;\n  var cb = state.writecb;\n\n  onwriteStateUpdate(state);\n\n  if (er) onwriteError(stream, state, sync, er, cb);else {\n    // Check if we're actually ready to finish, but don't emit yet\n    var finished = needFinish(state);\n\n    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n      clearBuffer(stream, state);\n    }\n\n    if (sync) {\n      /*<replacement>*/\n      asyncWrite(afterWrite, stream, state, finished, cb);\n      /*</replacement>*/\n    } else {\n      afterWrite(stream, state, finished, cb);\n    }\n  }\n}\n\nfunction afterWrite(stream, state, finished, cb) {\n  if (!finished) onwriteDrain(stream, state);\n  state.pendingcb--;\n  cb();\n  finishMaybe(stream, state);\n}\n\n// Must force callback to be called on nextTick, so that we don't\n// emit 'drain' before the write() consumer gets the 'false' return\n// value, and has a chance to attach a 'drain' listener.\nfunction onwriteDrain(stream, state) {\n  if (state.length === 0 && state.needDrain) {\n    state.needDrain = false;\n    stream.emit('drain');\n  }\n}\n\n// if there's something in the buffer waiting, then process it\nfunction clearBuffer(stream, state) {\n  state.bufferProcessing = true;\n  var entry = state.bufferedRequest;\n\n  if (stream._writev && entry && entry.next) {\n    // Fast case, write everything using _writev()\n    var l = state.bufferedRequestCount;\n    var buffer = new Array(l);\n    var holder = state.corkedRequestsFree;\n    holder.entry = entry;\n\n    var count = 0;\n    var allBuffers = true;\n    while (entry) {\n      buffer[count] = entry;\n      if (!entry.isBuf) allBuffers = false;\n      entry = entry.next;\n      count += 1;\n    }\n    buffer.allBuffers = allBuffers;\n\n    doWrite(stream, state, true, state.length, buffer, '', holder.finish);\n\n    // doWrite is almost always async, defer these to save a bit of time\n    // as the hot path ends with doWrite\n    state.pendingcb++;\n    state.lastBufferedRequest = null;\n    if (holder.next) {\n      state.corkedRequestsFree = holder.next;\n      holder.next = null;\n    } else {\n      state.corkedRequestsFree = new CorkedRequest(state);\n    }\n  } else {\n    // Slow case, write chunks one-by-one\n    while (entry) {\n      var chunk = entry.chunk;\n      var encoding = entry.encoding;\n      var cb = entry.callback;\n      var len = state.objectMode ? 1 : chunk.length;\n\n      doWrite(stream, state, false, len, chunk, encoding, cb);\n      entry = entry.next;\n      // if we didn't call the onwrite immediately, then\n      // it means that we need to wait until it does.\n      // also, that means that the chunk and cb are currently\n      // being processed, so move the buffer counter past them.\n      if (state.writing) {\n        break;\n      }\n    }\n\n    if (entry === null) state.lastBufferedRequest = null;\n  }\n\n  state.bufferedRequestCount = 0;\n  state.bufferedRequest = entry;\n  state.bufferProcessing = false;\n}\n\nWritable.prototype._write = function (chunk, encoding, cb) {\n  cb(new Error('_write() is not implemented'));\n};\n\nWritable.prototype._writev = null;\n\nWritable.prototype.end = function (chunk, encoding, cb) {\n  var state = this._writableState;\n\n  if (typeof chunk === 'function') {\n    cb = chunk;\n    chunk = null;\n    encoding = null;\n  } else if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);\n\n  // .end() fully uncorks\n  if (state.corked) {\n    state.corked = 1;\n    this.uncork();\n  }\n\n  // ignore unnecessary end() calls.\n  if (!state.ending && !state.finished) endWritable(this, state, cb);\n};\n\nfunction needFinish(state) {\n  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n}\nfunction callFinal(stream, state) {\n  stream._final(function (err) {\n    state.pendingcb--;\n    if (err) {\n      stream.emit('error', err);\n    }\n    state.prefinished = true;\n    stream.emit('prefinish');\n    finishMaybe(stream, state);\n  });\n}\nfunction prefinish(stream, state) {\n  if (!state.prefinished && !state.finalCalled) {\n    if (typeof stream._final === 'function') {\n      state.pendingcb++;\n      state.finalCalled = true;\n      processNextTick(callFinal, stream, state);\n    } else {\n      state.prefinished = true;\n      stream.emit('prefinish');\n    }\n  }\n}\n\nfunction finishMaybe(stream, state) {\n  var need = needFinish(state);\n  if (need) {\n    prefinish(stream, state);\n    if (state.pendingcb === 0) {\n      state.finished = true;\n      stream.emit('finish');\n    }\n  }\n  return need;\n}\n\nfunction endWritable(stream, state, cb) {\n  state.ending = true;\n  finishMaybe(stream, state);\n  if (cb) {\n    if (state.finished) processNextTick(cb);else stream.once('finish', cb);\n  }\n  state.ended = true;\n  stream.writable = false;\n}\n\nfunction onCorkedFinish(corkReq, state, err) {\n  var entry = corkReq.entry;\n  corkReq.entry = null;\n  while (entry) {\n    var cb = entry.callback;\n    state.pendingcb--;\n    cb(err);\n    entry = entry.next;\n  }\n  if (state.corkedRequestsFree) {\n    state.corkedRequestsFree.next = corkReq;\n  } else {\n    state.corkedRequestsFree = corkReq;\n  }\n}\n\nObject.defineProperty(Writable.prototype, 'destroyed', {\n  get: function () {\n    if (this._writableState === undefined) {\n      return false;\n    }\n    return this._writableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._writableState) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._writableState.destroyed = value;\n  }\n});\n\nWritable.prototype.destroy = destroyImpl.destroy;\nWritable.prototype._undestroy = destroyImpl.undestroy;\nWritable.prototype._destroy = function (err, cb) {\n  this.end();\n  cb(err);\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// a transform stream is a readable/writable stream where you do\n// something with the data.  Sometimes it's called a \"filter\",\n// but that's not a great name for it, since that implies a thing where\n// some bits pass through, and others are simply ignored.  (That would\n// be a valid example of a transform, of course.)\n//\n// While the output is causally related to the input, it's not a\n// necessarily symmetric or synchronous transformation.  For example,\n// a zlib stream might take multiple plain-text writes(), and then\n// emit a single compressed chunk some time in the future.\n//\n// Here's how this works:\n//\n// The Transform stream has all the aspects of the readable and writable\n// stream classes.  When you write(chunk), that calls _write(chunk,cb)\n// internally, and returns false if there's a lot of pending writes\n// buffered up.  When you call read(), that calls _read(n) until\n// there's enough pending readable data buffered up.\n//\n// In a transform stream, the written data is placed in a buffer.  When\n// _read(n) is called, it transforms the queued up data, calling the\n// buffered _write cb's as it consumes chunks.  If consuming a single\n// written chunk would result in multiple output chunks, then the first\n// outputted bit calls the readcb, and subsequent chunks just go into\n// the read buffer, and will cause it to emit 'readable' if necessary.\n//\n// This way, back-pressure is actually determined by the reading side,\n// since _read has to be called to start processing a new chunk.  However,\n// a pathological inflate type of transform can cause excessive buffering\n// here.  For example, imagine a stream where every byte of input is\n// interpreted as an integer from 0-255, and then results in that many\n// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in\n// 1kb of data being output.  In this case, you could write a very small\n// amount of input, and end up with a very large amount of output.  In\n// such a pathological inflating mechanism, there'd be no way to tell\n// the system to stop doing the transform.  A single 4MB write could\n// cause the system to run out of memory.\n//\n// However, even in such a pathological case, only a single written chunk\n// would be consumed, and then the rest would wait (un-transformed) until\n// the results of the previous transformed chunk were consumed.\n\n'use strict';\n\nmodule.exports = Transform;\n\nvar Duplex = require('./_stream_duplex');\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nutil.inherits(Transform, Duplex);\n\nfunction TransformState(stream) {\n  this.afterTransform = function (er, data) {\n    return afterTransform(stream, er, data);\n  };\n\n  this.needTransform = false;\n  this.transforming = false;\n  this.writecb = null;\n  this.writechunk = null;\n  this.writeencoding = null;\n}\n\nfunction afterTransform(stream, er, data) {\n  var ts = stream._transformState;\n  ts.transforming = false;\n\n  var cb = ts.writecb;\n\n  if (!cb) {\n    return stream.emit('error', new Error('write callback called multiple times'));\n  }\n\n  ts.writechunk = null;\n  ts.writecb = null;\n\n  if (data !== null && data !== undefined) stream.push(data);\n\n  cb(er);\n\n  var rs = stream._readableState;\n  rs.reading = false;\n  if (rs.needReadable || rs.length < rs.highWaterMark) {\n    stream._read(rs.highWaterMark);\n  }\n}\n\nfunction Transform(options) {\n  if (!(this instanceof Transform)) return new Transform(options);\n\n  Duplex.call(this, options);\n\n  this._transformState = new TransformState(this);\n\n  var stream = this;\n\n  // start out asking for a readable event once data is transformed.\n  this._readableState.needReadable = true;\n\n  // we have implemented the _read method, and done the other things\n  // that Readable wants before the first _read call, so unset the\n  // sync guard flag.\n  this._readableState.sync = false;\n\n  if (options) {\n    if (typeof options.transform === 'function') this._transform = options.transform;\n\n    if (typeof options.flush === 'function') this._flush = options.flush;\n  }\n\n  // When the writable side finishes, then flush out anything remaining.\n  this.once('prefinish', function () {\n    if (typeof this._flush === 'function') this._flush(function (er, data) {\n      done(stream, er, data);\n    });else done(stream);\n  });\n}\n\nTransform.prototype.push = function (chunk, encoding) {\n  this._transformState.needTransform = false;\n  return Duplex.prototype.push.call(this, chunk, encoding);\n};\n\n// This is the part where you do stuff!\n// override this function in implementation classes.\n// 'chunk' is an input chunk.\n//\n// Call `push(newChunk)` to pass along transformed output\n// to the readable side.  You may call 'push' zero or more times.\n//\n// Call `cb(err)` when you are done with this chunk.  If you pass\n// an error, then that'll put the hurt on the whole operation.  If you\n// never call cb(), then you'll never get another chunk.\nTransform.prototype._transform = function (chunk, encoding, cb) {\n  throw new Error('_transform() is not implemented');\n};\n\nTransform.prototype._write = function (chunk, encoding, cb) {\n  var ts = this._transformState;\n  ts.writecb = cb;\n  ts.writechunk = chunk;\n  ts.writeencoding = encoding;\n  if (!ts.transforming) {\n    var rs = this._readableState;\n    if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);\n  }\n};\n\n// Doesn't matter what the args are here.\n// _transform does all the work.\n// That we got here means that the readable side wants more data.\nTransform.prototype._read = function (n) {\n  var ts = this._transformState;\n\n  if (ts.writechunk !== null && ts.writecb && !ts.transforming) {\n    ts.transforming = true;\n    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\n  } else {\n    // mark that we need a transform, so that any data that comes in\n    // will get processed, now that we've asked for it.\n    ts.needTransform = true;\n  }\n};\n\nTransform.prototype._destroy = function (err, cb) {\n  var _this = this;\n\n  Duplex.prototype._destroy.call(this, err, function (err2) {\n    cb(err2);\n    _this.emit('close');\n  });\n};\n\nfunction done(stream, er, data) {\n  if (er) return stream.emit('error', er);\n\n  if (data !== null && data !== undefined) stream.push(data);\n\n  // if there's nothing in the write buffer, then that means\n  // that nothing more will ever be provided\n  var ws = stream._writableState;\n  var ts = stream._transformState;\n\n  if (ws.length) throw new Error('Calling transform done when ws.length != 0');\n\n  if (ts.transforming) throw new Error('Calling transform done when still transforming');\n\n  return stream.push(null);\n}","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.DEDICATED_WORKER_NAME = void 0;\nexports.DEDICATED_WORKER_NAME = 'dedicatedWorker';\n//# sourceMappingURL=enums.js.map"],"sourceRoot":""}