{"version":3,"sources":["jsdelivr-header.js","/npm/@texture-finance/solana-flash-loan-sdk@0.0.6/build/index.js"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA,CCEA,SAA2C,EAAM,GAC1B,iBAAZ,SAA0C,iBAAX,OACxC,OAAO,QAAU,IACQ,mBAAX,QAAyB,OAAO,IAC9C,OAAO,wBAAyB,GAAI,GACV,iBAAZ,QACd,QAAQ,yBAA2B,IAEnC,EAAK,yBAA2B,GACjC,CATD,CASG,MAAM,IACO,MACN,IAAI,oBAAsB,CAE9B;;;8DAIA,CAAE,wBAAyB,QAAS,uBAE1C,aACA,KAAK,8u0FAEE,EAED;;;mEAIA,CAAE,wBAAyB,oBAAqB,uBAEtD,aACA,KAAK,ix0VAEE,EAED;;;uEAIA,CAAE,wBAAyB,QAAS,uBAE1C,aACA,KAAK,8y2DAEE,EAED;;;8CAIA,CAAE,OAAQ,yBAA0B,uBAE1C,aACA,KAAK,2tIAEE,EAED;;;6CAIA,CAAE,wBAAyB,WAEjC,aACA,KAAK,6jIAEE,EAED;;;wDAIA,CAAE,wBAAyB,QAAS,uBAE1C,aACA,KAAK,q4EAEE,EAED;;;0CAIA,SAAU,OAAQ,yBAA0B,qBAElD,KAAK,u73FAEE,EAED;;;6CAIA,SAAU,wBAAyB,QAAS,qBAElD,aACA,KAAK,khhBAEE,EAED;;;wCAIA,CAAE,OAAQ,yBAA0B,uBAE1C,KAAK,0RAEE,EAED;;;0CAIA,CAAE,wBAAyB,QAAS,uBAE1C,aACA,KAAK,ix2DAEE,EAED;;;iDAIE,SAER,aACA,KAAK,0zSAEE,EAED;;;2CAIA,CAAE,wBAAyB,WAEjC,KAAK,oxEAEE,EAED;;;6DAIA,CAAE,OAAQ,yBAA0B,uBAE1C,aACA,KAAK,w2KAEE,EAED;;;wDAIA,CAAE,OAAQ,yBAA0B,uBAE1C,aACA,KAAK,m4EAEE,EAED;;;+DAIA,CAAE,wBAAyB,QAAS,uBAE1C,aACA,KAAK,irHAEE,EAED;;;4DAIA,CAAE,wBAAyB,QAAS,uBAE1C,aACA,KAAK,uoiBAEE,EAED;;;8EAIA,CAAE,wBAAyB,QAAS,uBAE1C,aACA,KAAK,85JAEE,EAED;;;+CAIA,CAAE,OAAQ,QAAS,uBAEzB,KAAK,o1DAEE,EAED;;;kEAIA,CAAE,wBAAyB,WAEjC,aACA,KAAK,41kBAEE,EAED;;;wCAIA,CAAE,wBAAyB,oBAAqB,uBAEtD,aACA,KAAK,o1BAEE,EAED;;;wCAIA,CAAE,wBAAyB,oBAAqB,uBAEtD,aACA,KAAK,swCAEE,EAED;;;yCAIA,CAAE,wBAAyB,oBAAqB,uBAEtD,aACA,KAAK,udAEE,EAED;;;2CAIA,CAAE,wBAAyB,oBAAqB,uBAEtD,aACA,KAAK,85KAEE,EAED;;;0BAIA,CAAE,wBAAyB,oBAAqB,uBAEtD,aACA,KAAK,2jCAEE,EAED;;;yDAIA,CAAE,wBAAyB,oBAAqB,uBAEtD,aACA,KAAK,ymBAEE,EAED;;;wDAIA,CAAE,wBAAyB,oBAAqB,uBAEtD,aACA,KAAK,6qEAEE,EAED;;;uEAIA,CAAE,wBAAyB,oBAAqB,uBAEtD,aACA,KAAK,+hBAEE,EAED;;;yEAIA,CAAE,wBAAyB,oBAAqB,uBAEtD,aACA,KAAK,ogEAEE,EAED;;;+EAIA,CAAE,wBAAyB,oBAAqB,uBAEtD,aACA,KAAK,07CAEE,EAED;;;6EAIA,CAAE,wBAAyB,oBAAqB,uBAEtD,aACA,KAAK,olCAEE,EAED;;;kFAIA,CAAE,wBAAyB,oBAAqB,uBAEtD,aACA,KAAK,ktCAEE,EAED;;;iFAIA,CAAE,wBAAyB,oBAAqB,uBAEtD,aACA,KAAK,4nCAEE,EAED;;;gCAIA,CAAE,wBAAyB,oBAAqB,uBAEtD,aACA,KAAK,w/BAEE,EAED;;;yDAIA,CAAE,wBAAyB,oBAAqB,uBAEtD,aACA,KAAK,skFAEE,EAED;;;uDAIA,CAAE,wBAAyB,oBAAqB,uBAEtD,aACA,KAAK,gwOAEE,EAED;;;uDAIA,CAAE,wBAAyB,oBAAqB,uBAEtD,aACA,KAAK,4ZAEE,EAED;;;yDAIA,CAAE,wBAAyB,oBAAqB,uBAEtD,aACA,KAAK,yoDAEE,EAED;;;yDAIA,CAAE,wBAAyB,oBAAqB,uBAEtD,aACA,KAAK,2eAEE,EAED;;;uDAIA,CAAE,wBAAyB,oBAAqB,uBAEtD,aACA,KAAK,+zCAEE,EAED;;;wDAIA,CAAE,wBAAyB,oBAAqB,uBAEtD,aACA,KAAK,83FAEE,EAED;;;6DAIA,CAAE,wBAAyB,oBAAqB,uBAEtD,aACA,KAAK,q/DAEE,EAED;;;sDAIA,CAAE,wBAAyB,oBAAqB,uBAEtD,aACA,KAAK,ggIAEE,EAED;;;sDAIA,CAAE,wBAAyB,oBAAqB,uBAEtD,aACA,KAAK,iyBAEE,EAED;;;uDAIA,CAAE,wBAAyB,oBAAqB,uBAEtD,aACA,KAAK,0/EAEE,EAED;;;sDAIA,CAAE,wBAAyB,oBAAqB,uBAEtD,aACA,KAAK,gvCAEE,EAED;;;sDAIA,CAAE,wBAAyB,oBAAqB,uBAEtD,aACA,KAAK,qyBAEE,EAED;;;4DAIA,CAAE,wBAAyB,oBAAqB,uBAEtD,aACA,KAAK,sqBAEE,EAED;;;2DAIA,CAAE,wBAAyB,oBAAqB,uBAEtD,aACA,KAAK,2uBAEE,EAED;;;4BAIA,KAEN,KAAK,qFAEE,EAED;;;4BAIA,KAEN,KAAK,qFAEE,EAED;;;4BAIA,KAEN,KAAK,qFAEE,EAED;;;0EAIE,SAER,KAAK,maAEE,EAED;;;qEAIE,SAER,KAAK,4/BAEE,EAED;;;mEAIE,SAER,KAAK,mYAEE,EAED;;;gEAIA,CAAE,OAAQ,yBAA0B,uBAE1C,KAAK,s/BAEE,EAED;;;mEAIE,SAER,KAAK,giBAEE,EAED;;;6DAIA,CAAE,OAAQ,yBAA0B,uBAE1C,KAAK,q1BAEE,EAED;;;0EAIE,SAER,KAAK,yVAEE,EAED;;;8EAIA,CAAE,OAAQ,yBAA0B,uBAE1C,KAAK,uzBAEE,EAED;;;uEAIA,CAAE,OAAQ,yBAA0B,uBAE1C,KAAK,yxcAEE,EAED;;;mEAIE,SAER,KAAK,yhBAEE,EAED;;;gEAIA,CAAE,OAAQ,yBAA0B,uBAE1C,KAAK,2uBAEE,EAED;;;kEAIA,CAAE,OAAQ,yBAA0B,uBAE1C,KAAK,8kBAEE,EAED;;;2DAIE,SAER,KAAK,wpBAEE,EAED;;;8DAIA,CAAE,OAAQ,yBAA0B,uBAE1C,KAAK,soBAEE,EAED;;;0DAIA,CAAE,oCAAqC,oBAAqB,uBAElE,aACA,KAAK,wj+BAEE,EAED;;;uDAIA,CAAE,oCAAqC,oBAAqB,uBAElE,aACA,KAAK,ijEAEE,EAED;;;qDAIA,CAAE,oCAAqC,oBAAqB,uBAElE,aACA,KAAK,qlKAEE,EAED;;;oDAIA,CAAE,oCAAqC,oBAAqB,uBAElE,aACA,KAAK,i1GAEE,EAED;;;6DAIA,CAAE,oCAAqC,oBAAqB,uBAElE,aACA,KAAK,gbAEE,EAED;;;oDAIA,CAAE,oCAAqC,oBAAqB,uBAElE,aACA,KAAK,m+GAEE,EAED;;;sDAIA,CAAE,oCAAqC,oBAAqB,uBAElE,aACA,KAAK,ywKAEE,EAED;;;oDAIA,CAAE,oCAAqC,oBAAqB,uBAElE,aACA,KAAK,gxSAEE,EAED;;;sDAIA,CAAE,oCAAqC,oBAAqB,uBAElE,aACA,KAAK,osZAEE,EAED;;;qDAIA,CAAE,oCAAqC,oBAAqB,uBAElE,aACA,KAAK,8oOAEE,EAED;;;4DAIA,CAAE,oCAAqC,oBAAqB,uBAElE,aACA,KAAK,o6xCAEE,EAED;;;uEAIA,CAAE,oCAAqC,oBAAqB,uBAElE,aACA,KAAK,8gBAEE,EAED;;;yEAIA,CAAE,oCAAqC,oBAAqB,uBAElE,aACA,KAAK,4mGAEE,EAED;;;0EAIA,CAAE,oCAAqC,oBAAqB,uBAElE,aACA,KAAK,koDAEE,EAED;;;wEAIA,CAAE,oCAAqC,oBAAqB,uBAElE,aACA,KAAK,iwFAEE,EAED;;;yEAIA,CAAE,oCAAqC,oBAAqB,uBAElE,aACA,KAAK,0tCAEE,EAED;;;uEAIA,CAAE,oCAAqC,oBAAqB,uBAElE,aACA,KAAK,w/CAEE,EAED;;;iEAIA,CAAE,oCAAqC,oBAAqB,uBAElE,aACA,KAAK,0sEAEE,EAED;;;qDAIA,CAAE,oCAAqC,oBAAqB,uBAElE,aACA,KAAK,knxFAEE,EAED;;;sDAIA,CAAE,oCAAqC,oBAAqB,uBAElE,aACA,KAAK,y06BAEE,GAKO,yBAA2B,CAAC,EA0C3B,eADA,SAtCL,SAAS,oBAAoB,GAE5B,IAAI,EAAe,yBAAyB,GAC5C,QAAqB,IAAjB,EACH,OAAO,EAAa,QAGrB,IAAI,EAAS,yBAAyB,GAAY,CACjD,GAAI,EACJ,QAAQ,EACR,QAAS,CAAC,GAUX,OANA,oBAAoB,GAAU,KAAK,EAAO,QAAS,EAAQ,EAAO,QAAS,qBAG3E,EAAO,QAAS,EAGT,EAAO,OACf,CAMC,oBAAoB,EAAK,IACxB,IAAI,EAAS,GAAU,EAAO,WAC7B,IAAO,EAAiB,QACxB,IAAM,EAEP,OADA,oBAAoB,EAAE,EAAQ,CAAE,EAAG,IAC5B,CAAM,EAMV,SAAW,OAAO,eAAkB,GAAS,OAAO,eAAe,GAAS,GAAS,EAAa,UAQtG,oBAAoB,EAAI,SAAS,EAAO,GAEvC,GADU,EAAP,IAAU,EAAQ,KAAK,IAChB,EAAP,EAAU,OAAO,EACpB,GAAoB,iBAAV,GAAsB,EAAO,CACtC,GAAW,EAAP,GAAa,EAAM,WAAY,OAAO,EAC1C,GAAW,GAAP,GAAoC,mBAAf,EAAM,KAAqB,OAAO,CAC5D,CACA,IAAI,EAAK,OAAO,OAAO,MACvB,oBAAoB,EAAE,GACtB,IAAI,EAAM,CAAC,EACX,eAAiB,gBAAkB,CAAC,KAAM,SAAS,CAAC,GAAI,SAAS,IAAK,SAAS,WAC/E,IAAI,IAAI,EAAiB,EAAP,GAAY,EAAyB,iBAAX,KAAyB,eAAe,QAAQ,GAAU,EAAU,SAAS,GACxH,OAAO,oBAAoB,GAAS,SAAS,GAAS,EAAI,GAAO,IAAO,EAAM,KAI/E,OAFA,EAAa,QAAI,IAAM,EACvB,oBAAoB,EAAE,EAAI,GACnB,CACR,EAMA,oBAAoB,EAAI,CAAC,EAAS,KACjC,IAAI,IAAI,KAAO,EACX,oBAAoB,EAAE,EAAY,KAAS,oBAAoB,EAAE,EAAS,IAC5E,OAAO,eAAe,EAAS,EAAK,CAAE,YAAY,EAAM,IAAK,EAAW,IAE1E,EAMD,oBAAoB,EAAI,CAAC,EAAK,IAAU,OAAO,UAAU,eAAe,KAAK,EAAK,GAMlF,oBAAoB,EAAK,IACH,oBAAX,QAA0B,OAAO,aAC1C,OAAO,eAAe,EAAS,OAAO,YAAa,CAAE,MAAO,WAE7D,OAAO,eAAe,EAAS,aAAc,CAAE,OAAO,GAAO,EAM9D,oBAAoB,IAAO,IAC1B,EAAO,MAAQ,GACV,EAAO,WAAU,EAAO,SAAW,IACjC,GAST,IAAI,oBAAsB,oBAAoB,kBAE9C,OAAO,mBACP,EA1gCM","file":"/npm/@texture-finance/solana-flash-loan-sdk@0.0.6/build/index.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.37.0.\n * Original file: /npm/@texture-finance/solana-flash-loan-sdk@0.0.6/build/index.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","/*\n * ATTENTION: The \"eval\" devtool has been used (maybe by default in mode: \"development\").\n * This devtool is neither made for production nor for readable output files.\n * It uses \"eval()\" calls to create a separate source file in the browser devtools.\n * If you are trying to read the output file, select a different devtool (https://webpack.js.org/configuration/devtool/)\n * or disable the default devtool with \"devtool: false\".\n * If you are looking for production-ready output files, see mode: \"production\" (https://webpack.js.org/configuration/mode/).\n */\n(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine(\"solana-flash-loan-sdk\", [], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"solana-flash-loan-sdk\"] = factory();\n\telse\n\t\troot[\"solana-flash-loan-sdk\"] = factory();\n})(self, () => {\nreturn /******/ (() => { // webpackBootstrap\n/******/ \tvar __webpack_modules__ = ({\n\n/***/ \"./node_modules/@solana/buffer-layout/lib/Layout.js\":\n/*!**********************************************************!*\\\n  !*** ./node_modules/@solana/buffer-layout/lib/Layout.js ***!\n  \\**********************************************************/\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\neval(\"/* The MIT License (MIT)\\n *\\n * Copyright 2015-2018 Peter A. Bigot\\n *\\n * Permission is hereby granted, free of charge, to any person obtaining a copy\\n * of this software and associated documentation files (the \\\"Software\\\"), to deal\\n * in the Software without restriction, including without limitation the rights\\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\\n * copies of the Software, and to permit persons to whom the Software is\\n * furnished to do so, subject to the following conditions:\\n *\\n * The above copyright notice and this permission notice shall be included in\\n * all copies or substantial portions of the Software.\\n *\\n * THE SOFTWARE IS PROVIDED \\\"AS IS\\\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\\n * THE SOFTWARE.\\n */\\n/**\\n * Support for translating between Uint8Array instances and JavaScript\\n * native types.\\n *\\n * {@link module:Layout~Layout|Layout} is the basis of a class\\n * hierarchy that associates property names with sequences of encoded\\n * bytes.\\n *\\n * Layouts are supported for these scalar (numeric) types:\\n * * {@link module:Layout~UInt|Unsigned integers in little-endian\\n *   format} with {@link module:Layout.u8|8-bit}, {@link\\n *   module:Layout.u16|16-bit}, {@link module:Layout.u24|24-bit},\\n *   {@link module:Layout.u32|32-bit}, {@link\\n *   module:Layout.u40|40-bit}, and {@link module:Layout.u48|48-bit}\\n *   representation ranges;\\n * * {@link module:Layout~UIntBE|Unsigned integers in big-endian\\n *   format} with {@link module:Layout.u16be|16-bit}, {@link\\n *   module:Layout.u24be|24-bit}, {@link module:Layout.u32be|32-bit},\\n *   {@link module:Layout.u40be|40-bit}, and {@link\\n *   module:Layout.u48be|48-bit} representation ranges;\\n * * {@link module:Layout~Int|Signed integers in little-endian\\n *   format} with {@link module:Layout.s8|8-bit}, {@link\\n *   module:Layout.s16|16-bit}, {@link module:Layout.s24|24-bit},\\n *   {@link module:Layout.s32|32-bit}, {@link\\n *   module:Layout.s40|40-bit}, and {@link module:Layout.s48|48-bit}\\n *   representation ranges;\\n * * {@link module:Layout~IntBE|Signed integers in big-endian format}\\n *   with {@link module:Layout.s16be|16-bit}, {@link\\n *   module:Layout.s24be|24-bit}, {@link module:Layout.s32be|32-bit},\\n *   {@link module:Layout.s40be|40-bit}, and {@link\\n *   module:Layout.s48be|48-bit} representation ranges;\\n * * 64-bit integral values that decode to an exact (if magnitude is\\n *   less than 2^53) or nearby integral Number in {@link\\n *   module:Layout.nu64|unsigned little-endian}, {@link\\n *   module:Layout.nu64be|unsigned big-endian}, {@link\\n *   module:Layout.ns64|signed little-endian}, and {@link\\n *   module:Layout.ns64be|unsigned big-endian} encodings;\\n * * 32-bit floating point values with {@link\\n *   module:Layout.f32|little-endian} and {@link\\n *   module:Layout.f32be|big-endian} representations;\\n * * 64-bit floating point values with {@link\\n *   module:Layout.f64|little-endian} and {@link\\n *   module:Layout.f64be|big-endian} representations;\\n * * {@link module:Layout.const|Constants} that take no space in the\\n *   encoded expression.\\n *\\n * and for these aggregate types:\\n * * {@link module:Layout.seq|Sequence}s of instances of a {@link\\n *   module:Layout~Layout|Layout}, with JavaScript representation as\\n *   an Array and constant or data-dependent {@link\\n *   module:Layout~Sequence#count|length};\\n * * {@link module:Layout.struct|Structure}s that aggregate a\\n *   heterogeneous sequence of {@link module:Layout~Layout|Layout}\\n *   instances, with JavaScript representation as an Object;\\n * * {@link module:Layout.union|Union}s that support multiple {@link\\n *   module:Layout~VariantLayout|variant layouts} over a fixed\\n *   (padded) or variable (not padded) span of bytes, using an\\n *   unsigned integer at the start of the data or a separate {@link\\n *   module:Layout.unionLayoutDiscriminator|layout element} to\\n *   determine which layout to use when interpreting the buffer\\n *   contents;\\n * * {@link module:Layout.bits|BitStructure}s that contain a sequence\\n *   of individual {@link\\n *   module:Layout~BitStructure#addField|BitField}s packed into an 8,\\n *   16, 24, or 32-bit unsigned integer starting at the least- or\\n *   most-significant bit;\\n * * {@link module:Layout.cstr|C strings} of varying length;\\n * * {@link module:Layout.blob|Blobs} of fixed- or variable-{@link\\n *   module:Layout~Blob#length|length} raw data.\\n *\\n * All {@link module:Layout~Layout|Layout} instances are immutable\\n * after construction, to prevent internal state from becoming\\n * inconsistent.\\n *\\n * @local Layout\\n * @local ExternalLayout\\n * @local GreedyCount\\n * @local OffsetLayout\\n * @local UInt\\n * @local UIntBE\\n * @local Int\\n * @local IntBE\\n * @local NearUInt64\\n * @local NearUInt64BE\\n * @local NearInt64\\n * @local NearInt64BE\\n * @local Float\\n * @local FloatBE\\n * @local Double\\n * @local DoubleBE\\n * @local Sequence\\n * @local Structure\\n * @local UnionDiscriminator\\n * @local UnionLayoutDiscriminator\\n * @local Union\\n * @local VariantLayout\\n * @local BitStructure\\n * @local BitField\\n * @local Boolean\\n * @local Blob\\n * @local CString\\n * @local Constant\\n * @local bindConstructorLayout\\n * @module Layout\\n * @license MIT\\n * @author Peter A. Bigot\\n * @see {@link https://github.com/pabigot/buffer-layout|buffer-layout on GitHub}\\n */\\n\\nObject.defineProperty(exports, \\\"__esModule\\\", ({ value: true }));\\nexports.s16 = exports.s8 = exports.nu64be = exports.u48be = exports.u40be = exports.u32be = exports.u24be = exports.u16be = exports.nu64 = exports.u48 = exports.u40 = exports.u32 = exports.u24 = exports.u16 = exports.u8 = exports.offset = exports.greedy = exports.Constant = exports.UTF8 = exports.CString = exports.Blob = exports.Boolean = exports.BitField = exports.BitStructure = exports.VariantLayout = exports.Union = exports.UnionLayoutDiscriminator = exports.UnionDiscriminator = exports.Structure = exports.Sequence = exports.DoubleBE = exports.Double = exports.FloatBE = exports.Float = exports.NearInt64BE = exports.NearInt64 = exports.NearUInt64BE = exports.NearUInt64 = exports.IntBE = exports.Int = exports.UIntBE = exports.UInt = exports.OffsetLayout = exports.GreedyCount = exports.ExternalLayout = exports.bindConstructorLayout = exports.nameWithProperty = exports.Layout = exports.uint8ArrayToBuffer = exports.checkUint8Array = void 0;\\nexports.constant = exports.utf8 = exports.cstr = exports.blob = exports.unionLayoutDiscriminator = exports.union = exports.seq = exports.bits = exports.struct = exports.f64be = exports.f64 = exports.f32be = exports.f32 = exports.ns64be = exports.s48be = exports.s40be = exports.s32be = exports.s24be = exports.s16be = exports.ns64 = exports.s48 = exports.s40 = exports.s32 = exports.s24 = void 0;\\nconst buffer_1 = __webpack_require__(/*! buffer */ \\\"./node_modules/buffer/index.js\\\");\\n/* Check if a value is a Uint8Array.\\n *\\n * @ignore */\\nfunction checkUint8Array(b) {\\n    if (!(b instanceof Uint8Array)) {\\n        throw new TypeError('b must be a Uint8Array');\\n    }\\n}\\nexports.checkUint8Array = checkUint8Array;\\n/* Create a Buffer instance from a Uint8Array.\\n *\\n * @ignore */\\nfunction uint8ArrayToBuffer(b) {\\n    checkUint8Array(b);\\n    return buffer_1.Buffer.from(b.buffer, b.byteOffset, b.length);\\n}\\nexports.uint8ArrayToBuffer = uint8ArrayToBuffer;\\n/**\\n * Base class for layout objects.\\n *\\n * **NOTE** This is an abstract base class; you can create instances\\n * if it amuses you, but they won't support the {@link\\n * Layout#encode|encode} or {@link Layout#decode|decode} functions.\\n *\\n * @param {Number} span - Initializer for {@link Layout#span|span}.  The\\n * parameter must be an integer; a negative value signifies that the\\n * span is {@link Layout#getSpan|value-specific}.\\n *\\n * @param {string} [property] - Initializer for {@link\\n * Layout#property|property}.\\n *\\n * @abstract\\n */\\nclass Layout {\\n    constructor(span, property) {\\n        if (!Number.isInteger(span)) {\\n            throw new TypeError('span must be an integer');\\n        }\\n        /** The span of the layout in bytes.\\n         *\\n         * Positive values are generally expected.\\n         *\\n         * Zero will only appear in {@link Constant}s and in {@link\\n         * Sequence}s where the {@link Sequence#count|count} is zero.\\n         *\\n         * A negative value indicates that the span is value-specific, and\\n         * must be obtained using {@link Layout#getSpan|getSpan}. */\\n        this.span = span;\\n        /** The property name used when this layout is represented in an\\n         * Object.\\n         *\\n         * Used only for layouts that {@link Layout#decode|decode} to Object\\n         * instances.  If left undefined the span of the unnamed layout will\\n         * be treated as padding: it will not be mutated by {@link\\n         * Layout#encode|encode} nor represented as a property in the\\n         * decoded Object. */\\n        this.property = property;\\n    }\\n    /** Function to create an Object into which decoded properties will\\n     * be written.\\n     *\\n     * Used only for layouts that {@link Layout#decode|decode} to Object\\n     * instances, which means:\\n     * * {@link Structure}\\n     * * {@link Union}\\n     * * {@link VariantLayout}\\n     * * {@link BitStructure}\\n     *\\n     * If left undefined the JavaScript representation of these layouts\\n     * will be Object instances.\\n     *\\n     * See {@link bindConstructorLayout}.\\n     */\\n    makeDestinationObject() {\\n        return {};\\n    }\\n    /**\\n     * Calculate the span of a specific instance of a layout.\\n     *\\n     * @param {Uint8Array} b - the buffer that contains an encoded instance.\\n     *\\n     * @param {Number} [offset] - the offset at which the encoded instance\\n     * starts.  If absent a zero offset is inferred.\\n     *\\n     * @return {Number} - the number of bytes covered by the layout\\n     * instance.  If this method is not overridden in a subclass the\\n     * definition-time constant {@link Layout#span|span} will be\\n     * returned.\\n     *\\n     * @throws {RangeError} - if the length of the value cannot be\\n     * determined.\\n     */\\n    getSpan(b, offset) {\\n        if (0 > this.span) {\\n            throw new RangeError('indeterminate span');\\n        }\\n        return this.span;\\n    }\\n    /**\\n     * Replicate the layout using a new property.\\n     *\\n     * This function must be used to get a structurally-equivalent layout\\n     * with a different name since all {@link Layout} instances are\\n     * immutable.\\n     *\\n     * **NOTE** This is a shallow copy.  All fields except {@link\\n     * Layout#property|property} are strictly equal to the origin layout.\\n     *\\n     * @param {String} property - the value for {@link\\n     * Layout#property|property} in the replica.\\n     *\\n     * @returns {Layout} - the copy with {@link Layout#property|property}\\n     * set to `property`.\\n     */\\n    replicate(property) {\\n        const rv = Object.create(this.constructor.prototype);\\n        Object.assign(rv, this);\\n        rv.property = property;\\n        return rv;\\n    }\\n    /**\\n     * Create an object from layout properties and an array of values.\\n     *\\n     * **NOTE** This function returns `undefined` if invoked on a layout\\n     * that does not return its value as an Object.  Objects are\\n     * returned for things that are a {@link Structure}, which includes\\n     * {@link VariantLayout|variant layouts} if they are structures, and\\n     * excludes {@link Union}s.  If you want this feature for a union\\n     * you must use {@link Union.getVariant|getVariant} to select the\\n     * desired layout.\\n     *\\n     * @param {Array} values - an array of values that correspond to the\\n     * default order for properties.  As with {@link Layout#decode|decode}\\n     * layout elements that have no property name are skipped when\\n     * iterating over the array values.  Only the top-level properties are\\n     * assigned; arguments are not assigned to properties of contained\\n     * layouts.  Any unused values are ignored.\\n     *\\n     * @return {(Object|undefined)}\\n     */\\n    fromArray(values) {\\n        return undefined;\\n    }\\n}\\nexports.Layout = Layout;\\n/* Provide text that carries a name (such as for a function that will\\n * be throwing an error) annotated with the property of a given layout\\n * (such as one for which the value was unacceptable).\\n *\\n * @ignore */\\nfunction nameWithProperty(name, lo) {\\n    if (lo.property) {\\n        return name + '[' + lo.property + ']';\\n    }\\n    return name;\\n}\\nexports.nameWithProperty = nameWithProperty;\\n/**\\n * Augment a class so that instances can be encoded/decoded using a\\n * given layout.\\n *\\n * Calling this function couples `Class` with `layout` in several ways:\\n *\\n * * `Class.layout_` becomes a static member property equal to `layout`;\\n * * `layout.boundConstructor_` becomes a static member property equal\\n *    to `Class`;\\n * * The {@link Layout#makeDestinationObject|makeDestinationObject()}\\n *   property of `layout` is set to a function that returns a `new\\n *   Class()`;\\n * * `Class.decode(b, offset)` becomes a static member function that\\n *   delegates to {@link Layout#decode|layout.decode}.  The\\n *   synthesized function may be captured and extended.\\n * * `Class.prototype.encode(b, offset)` provides an instance member\\n *   function that delegates to {@link Layout#encode|layout.encode}\\n *   with `src` set to `this`.  The synthesized function may be\\n *   captured and extended, but when the extension is invoked `this`\\n *   must be explicitly bound to the instance.\\n *\\n * @param {class} Class - a JavaScript class with a nullary\\n * constructor.\\n *\\n * @param {Layout} layout - the {@link Layout} instance used to encode\\n * instances of `Class`.\\n */\\n// `Class` must be a constructor Function, but the assignment of a `layout_` property to it makes it difficult to type\\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\\nfunction bindConstructorLayout(Class, layout) {\\n    if ('function' !== typeof Class) {\\n        throw new TypeError('Class must be constructor');\\n    }\\n    if (Object.prototype.hasOwnProperty.call(Class, 'layout_')) {\\n        throw new Error('Class is already bound to a layout');\\n    }\\n    if (!(layout && (layout instanceof Layout))) {\\n        throw new TypeError('layout must be a Layout');\\n    }\\n    if (Object.prototype.hasOwnProperty.call(layout, 'boundConstructor_')) {\\n        throw new Error('layout is already bound to a constructor');\\n    }\\n    Class.layout_ = layout;\\n    layout.boundConstructor_ = Class;\\n    layout.makeDestinationObject = (() => new Class());\\n    Object.defineProperty(Class.prototype, 'encode', {\\n        value(b, offset) {\\n            return layout.encode(this, b, offset);\\n        },\\n        writable: true,\\n    });\\n    Object.defineProperty(Class, 'decode', {\\n        value(b, offset) {\\n            return layout.decode(b, offset);\\n        },\\n        writable: true,\\n    });\\n}\\nexports.bindConstructorLayout = bindConstructorLayout;\\n/**\\n * An object that behaves like a layout but does not consume space\\n * within its containing layout.\\n *\\n * This is primarily used to obtain metadata about a member, such as a\\n * {@link OffsetLayout} that can provide data about a {@link\\n * Layout#getSpan|value-specific span}.\\n *\\n * **NOTE** This is an abstract base class; you can create instances\\n * if it amuses you, but they won't support {@link\\n * ExternalLayout#isCount|isCount} or other {@link Layout} functions.\\n *\\n * @param {Number} span - initializer for {@link Layout#span|span}.\\n * The parameter can range from 1 through 6.\\n *\\n * @param {string} [property] - initializer for {@link\\n * Layout#property|property}.\\n *\\n * @abstract\\n * @augments {Layout}\\n */\\nclass ExternalLayout extends Layout {\\n    /**\\n     * Return `true` iff the external layout decodes to an unsigned\\n     * integer layout.\\n     *\\n     * In that case it can be used as the source of {@link\\n     * Sequence#count|Sequence counts}, {@link Blob#length|Blob lengths},\\n     * or as {@link UnionLayoutDiscriminator#layout|external union\\n     * discriminators}.\\n     *\\n     * @abstract\\n     */\\n    isCount() {\\n        throw new Error('ExternalLayout is abstract');\\n    }\\n}\\nexports.ExternalLayout = ExternalLayout;\\n/**\\n * An {@link ExternalLayout} that determines its {@link\\n * Layout#decode|value} based on offset into and length of the buffer\\n * on which it is invoked.\\n *\\n * *Factory*: {@link module:Layout.greedy|greedy}\\n *\\n * @param {Number} [elementSpan] - initializer for {@link\\n * GreedyCount#elementSpan|elementSpan}.\\n *\\n * @param {string} [property] - initializer for {@link\\n * Layout#property|property}.\\n *\\n * @augments {ExternalLayout}\\n */\\nclass GreedyCount extends ExternalLayout {\\n    constructor(elementSpan = 1, property) {\\n        if ((!Number.isInteger(elementSpan)) || (0 >= elementSpan)) {\\n            throw new TypeError('elementSpan must be a (positive) integer');\\n        }\\n        super(-1, property);\\n        /** The layout for individual elements of the sequence.  The value\\n         * must be a positive integer.  If not provided, the value will be\\n         * 1. */\\n        this.elementSpan = elementSpan;\\n    }\\n    /** @override */\\n    isCount() {\\n        return true;\\n    }\\n    /** @override */\\n    decode(b, offset = 0) {\\n        checkUint8Array(b);\\n        const rem = b.length - offset;\\n        return Math.floor(rem / this.elementSpan);\\n    }\\n    /** @override */\\n    encode(src, b, offset) {\\n        return 0;\\n    }\\n}\\nexports.GreedyCount = GreedyCount;\\n/**\\n * An {@link ExternalLayout} that supports accessing a {@link Layout}\\n * at a fixed offset from the start of another Layout.  The offset may\\n * be before, within, or after the base layout.\\n *\\n * *Factory*: {@link module:Layout.offset|offset}\\n *\\n * @param {Layout} layout - initializer for {@link\\n * OffsetLayout#layout|layout}, modulo `property`.\\n *\\n * @param {Number} [offset] - Initializes {@link\\n * OffsetLayout#offset|offset}.  Defaults to zero.\\n *\\n * @param {string} [property] - Optional new property name for a\\n * {@link Layout#replicate| replica} of `layout` to be used as {@link\\n * OffsetLayout#layout|layout}.  If not provided the `layout` is used\\n * unchanged.\\n *\\n * @augments {Layout}\\n */\\nclass OffsetLayout extends ExternalLayout {\\n    constructor(layout, offset = 0, property) {\\n        if (!(layout instanceof Layout)) {\\n            throw new TypeError('layout must be a Layout');\\n        }\\n        if (!Number.isInteger(offset)) {\\n            throw new TypeError('offset must be integer or undefined');\\n        }\\n        super(layout.span, property || layout.property);\\n        /** The subordinated layout. */\\n        this.layout = layout;\\n        /** The location of {@link OffsetLayout#layout} relative to the\\n         * start of another layout.\\n         *\\n         * The value may be positive or negative, but an error will thrown\\n         * if at the point of use it goes outside the span of the Uint8Array\\n         * being accessed.  */\\n        this.offset = offset;\\n    }\\n    /** @override */\\n    isCount() {\\n        return ((this.layout instanceof UInt)\\n            || (this.layout instanceof UIntBE));\\n    }\\n    /** @override */\\n    decode(b, offset = 0) {\\n        return this.layout.decode(b, offset + this.offset);\\n    }\\n    /** @override */\\n    encode(src, b, offset = 0) {\\n        return this.layout.encode(src, b, offset + this.offset);\\n    }\\n}\\nexports.OffsetLayout = OffsetLayout;\\n/**\\n * Represent an unsigned integer in little-endian format.\\n *\\n * *Factory*: {@link module:Layout.u8|u8}, {@link\\n *  module:Layout.u16|u16}, {@link module:Layout.u24|u24}, {@link\\n *  module:Layout.u32|u32}, {@link module:Layout.u40|u40}, {@link\\n *  module:Layout.u48|u48}\\n *\\n * @param {Number} span - initializer for {@link Layout#span|span}.\\n * The parameter can range from 1 through 6.\\n *\\n * @param {string} [property] - initializer for {@link\\n * Layout#property|property}.\\n *\\n * @augments {Layout}\\n */\\nclass UInt extends Layout {\\n    constructor(span, property) {\\n        super(span, property);\\n        if (6 < this.span) {\\n            throw new RangeError('span must not exceed 6 bytes');\\n        }\\n    }\\n    /** @override */\\n    decode(b, offset = 0) {\\n        return uint8ArrayToBuffer(b).readUIntLE(offset, this.span);\\n    }\\n    /** @override */\\n    encode(src, b, offset = 0) {\\n        uint8ArrayToBuffer(b).writeUIntLE(src, offset, this.span);\\n        return this.span;\\n    }\\n}\\nexports.UInt = UInt;\\n/**\\n * Represent an unsigned integer in big-endian format.\\n *\\n * *Factory*: {@link module:Layout.u8be|u8be}, {@link\\n * module:Layout.u16be|u16be}, {@link module:Layout.u24be|u24be},\\n * {@link module:Layout.u32be|u32be}, {@link\\n * module:Layout.u40be|u40be}, {@link module:Layout.u48be|u48be}\\n *\\n * @param {Number} span - initializer for {@link Layout#span|span}.\\n * The parameter can range from 1 through 6.\\n *\\n * @param {string} [property] - initializer for {@link\\n * Layout#property|property}.\\n *\\n * @augments {Layout}\\n */\\nclass UIntBE extends Layout {\\n    constructor(span, property) {\\n        super(span, property);\\n        if (6 < this.span) {\\n            throw new RangeError('span must not exceed 6 bytes');\\n        }\\n    }\\n    /** @override */\\n    decode(b, offset = 0) {\\n        return uint8ArrayToBuffer(b).readUIntBE(offset, this.span);\\n    }\\n    /** @override */\\n    encode(src, b, offset = 0) {\\n        uint8ArrayToBuffer(b).writeUIntBE(src, offset, this.span);\\n        return this.span;\\n    }\\n}\\nexports.UIntBE = UIntBE;\\n/**\\n * Represent a signed integer in little-endian format.\\n *\\n * *Factory*: {@link module:Layout.s8|s8}, {@link\\n *  module:Layout.s16|s16}, {@link module:Layout.s24|s24}, {@link\\n *  module:Layout.s32|s32}, {@link module:Layout.s40|s40}, {@link\\n *  module:Layout.s48|s48}\\n *\\n * @param {Number} span - initializer for {@link Layout#span|span}.\\n * The parameter can range from 1 through 6.\\n *\\n * @param {string} [property] - initializer for {@link\\n * Layout#property|property}.\\n *\\n * @augments {Layout}\\n */\\nclass Int extends Layout {\\n    constructor(span, property) {\\n        super(span, property);\\n        if (6 < this.span) {\\n            throw new RangeError('span must not exceed 6 bytes');\\n        }\\n    }\\n    /** @override */\\n    decode(b, offset = 0) {\\n        return uint8ArrayToBuffer(b).readIntLE(offset, this.span);\\n    }\\n    /** @override */\\n    encode(src, b, offset = 0) {\\n        uint8ArrayToBuffer(b).writeIntLE(src, offset, this.span);\\n        return this.span;\\n    }\\n}\\nexports.Int = Int;\\n/**\\n * Represent a signed integer in big-endian format.\\n *\\n * *Factory*: {@link module:Layout.s8be|s8be}, {@link\\n * module:Layout.s16be|s16be}, {@link module:Layout.s24be|s24be},\\n * {@link module:Layout.s32be|s32be}, {@link\\n * module:Layout.s40be|s40be}, {@link module:Layout.s48be|s48be}\\n *\\n * @param {Number} span - initializer for {@link Layout#span|span}.\\n * The parameter can range from 1 through 6.\\n *\\n * @param {string} [property] - initializer for {@link\\n * Layout#property|property}.\\n *\\n * @augments {Layout}\\n */\\nclass IntBE extends Layout {\\n    constructor(span, property) {\\n        super(span, property);\\n        if (6 < this.span) {\\n            throw new RangeError('span must not exceed 6 bytes');\\n        }\\n    }\\n    /** @override */\\n    decode(b, offset = 0) {\\n        return uint8ArrayToBuffer(b).readIntBE(offset, this.span);\\n    }\\n    /** @override */\\n    encode(src, b, offset = 0) {\\n        uint8ArrayToBuffer(b).writeIntBE(src, offset, this.span);\\n        return this.span;\\n    }\\n}\\nexports.IntBE = IntBE;\\nconst V2E32 = Math.pow(2, 32);\\n/* True modulus high and low 32-bit words, where low word is always\\n * non-negative. */\\nfunction divmodInt64(src) {\\n    const hi32 = Math.floor(src / V2E32);\\n    const lo32 = src - (hi32 * V2E32);\\n    return { hi32, lo32 };\\n}\\n/* Reconstruct Number from quotient and non-negative remainder */\\nfunction roundedInt64(hi32, lo32) {\\n    return hi32 * V2E32 + lo32;\\n}\\n/**\\n * Represent an unsigned 64-bit integer in little-endian format when\\n * encoded and as a near integral JavaScript Number when decoded.\\n *\\n * *Factory*: {@link module:Layout.nu64|nu64}\\n *\\n * **NOTE** Values with magnitude greater than 2^52 may not decode to\\n * the exact value of the encoded representation.\\n *\\n * @augments {Layout}\\n */\\nclass NearUInt64 extends Layout {\\n    constructor(property) {\\n        super(8, property);\\n    }\\n    /** @override */\\n    decode(b, offset = 0) {\\n        const buffer = uint8ArrayToBuffer(b);\\n        const lo32 = buffer.readUInt32LE(offset);\\n        const hi32 = buffer.readUInt32LE(offset + 4);\\n        return roundedInt64(hi32, lo32);\\n    }\\n    /** @override */\\n    encode(src, b, offset = 0) {\\n        const split = divmodInt64(src);\\n        const buffer = uint8ArrayToBuffer(b);\\n        buffer.writeUInt32LE(split.lo32, offset);\\n        buffer.writeUInt32LE(split.hi32, offset + 4);\\n        return 8;\\n    }\\n}\\nexports.NearUInt64 = NearUInt64;\\n/**\\n * Represent an unsigned 64-bit integer in big-endian format when\\n * encoded and as a near integral JavaScript Number when decoded.\\n *\\n * *Factory*: {@link module:Layout.nu64be|nu64be}\\n *\\n * **NOTE** Values with magnitude greater than 2^52 may not decode to\\n * the exact value of the encoded representation.\\n *\\n * @augments {Layout}\\n */\\nclass NearUInt64BE extends Layout {\\n    constructor(property) {\\n        super(8, property);\\n    }\\n    /** @override */\\n    decode(b, offset = 0) {\\n        const buffer = uint8ArrayToBuffer(b);\\n        const hi32 = buffer.readUInt32BE(offset);\\n        const lo32 = buffer.readUInt32BE(offset + 4);\\n        return roundedInt64(hi32, lo32);\\n    }\\n    /** @override */\\n    encode(src, b, offset = 0) {\\n        const split = divmodInt64(src);\\n        const buffer = uint8ArrayToBuffer(b);\\n        buffer.writeUInt32BE(split.hi32, offset);\\n        buffer.writeUInt32BE(split.lo32, offset + 4);\\n        return 8;\\n    }\\n}\\nexports.NearUInt64BE = NearUInt64BE;\\n/**\\n * Represent a signed 64-bit integer in little-endian format when\\n * encoded and as a near integral JavaScript Number when decoded.\\n *\\n * *Factory*: {@link module:Layout.ns64|ns64}\\n *\\n * **NOTE** Values with magnitude greater than 2^52 may not decode to\\n * the exact value of the encoded representation.\\n *\\n * @augments {Layout}\\n */\\nclass NearInt64 extends Layout {\\n    constructor(property) {\\n        super(8, property);\\n    }\\n    /** @override */\\n    decode(b, offset = 0) {\\n        const buffer = uint8ArrayToBuffer(b);\\n        const lo32 = buffer.readUInt32LE(offset);\\n        const hi32 = buffer.readInt32LE(offset + 4);\\n        return roundedInt64(hi32, lo32);\\n    }\\n    /** @override */\\n    encode(src, b, offset = 0) {\\n        const split = divmodInt64(src);\\n        const buffer = uint8ArrayToBuffer(b);\\n        buffer.writeUInt32LE(split.lo32, offset);\\n        buffer.writeInt32LE(split.hi32, offset + 4);\\n        return 8;\\n    }\\n}\\nexports.NearInt64 = NearInt64;\\n/**\\n * Represent a signed 64-bit integer in big-endian format when\\n * encoded and as a near integral JavaScript Number when decoded.\\n *\\n * *Factory*: {@link module:Layout.ns64be|ns64be}\\n *\\n * **NOTE** Values with magnitude greater than 2^52 may not decode to\\n * the exact value of the encoded representation.\\n *\\n * @augments {Layout}\\n */\\nclass NearInt64BE extends Layout {\\n    constructor(property) {\\n        super(8, property);\\n    }\\n    /** @override */\\n    decode(b, offset = 0) {\\n        const buffer = uint8ArrayToBuffer(b);\\n        const hi32 = buffer.readInt32BE(offset);\\n        const lo32 = buffer.readUInt32BE(offset + 4);\\n        return roundedInt64(hi32, lo32);\\n    }\\n    /** @override */\\n    encode(src, b, offset = 0) {\\n        const split = divmodInt64(src);\\n        const buffer = uint8ArrayToBuffer(b);\\n        buffer.writeInt32BE(split.hi32, offset);\\n        buffer.writeUInt32BE(split.lo32, offset + 4);\\n        return 8;\\n    }\\n}\\nexports.NearInt64BE = NearInt64BE;\\n/**\\n * Represent a 32-bit floating point number in little-endian format.\\n *\\n * *Factory*: {@link module:Layout.f32|f32}\\n *\\n * @param {string} [property] - initializer for {@link\\n * Layout#property|property}.\\n *\\n * @augments {Layout}\\n */\\nclass Float extends Layout {\\n    constructor(property) {\\n        super(4, property);\\n    }\\n    /** @override */\\n    decode(b, offset = 0) {\\n        return uint8ArrayToBuffer(b).readFloatLE(offset);\\n    }\\n    /** @override */\\n    encode(src, b, offset = 0) {\\n        uint8ArrayToBuffer(b).writeFloatLE(src, offset);\\n        return 4;\\n    }\\n}\\nexports.Float = Float;\\n/**\\n * Represent a 32-bit floating point number in big-endian format.\\n *\\n * *Factory*: {@link module:Layout.f32be|f32be}\\n *\\n * @param {string} [property] - initializer for {@link\\n * Layout#property|property}.\\n *\\n * @augments {Layout}\\n */\\nclass FloatBE extends Layout {\\n    constructor(property) {\\n        super(4, property);\\n    }\\n    /** @override */\\n    decode(b, offset = 0) {\\n        return uint8ArrayToBuffer(b).readFloatBE(offset);\\n    }\\n    /** @override */\\n    encode(src, b, offset = 0) {\\n        uint8ArrayToBuffer(b).writeFloatBE(src, offset);\\n        return 4;\\n    }\\n}\\nexports.FloatBE = FloatBE;\\n/**\\n * Represent a 64-bit floating point number in little-endian format.\\n *\\n * *Factory*: {@link module:Layout.f64|f64}\\n *\\n * @param {string} [property] - initializer for {@link\\n * Layout#property|property}.\\n *\\n * @augments {Layout}\\n */\\nclass Double extends Layout {\\n    constructor(property) {\\n        super(8, property);\\n    }\\n    /** @override */\\n    decode(b, offset = 0) {\\n        return uint8ArrayToBuffer(b).readDoubleLE(offset);\\n    }\\n    /** @override */\\n    encode(src, b, offset = 0) {\\n        uint8ArrayToBuffer(b).writeDoubleLE(src, offset);\\n        return 8;\\n    }\\n}\\nexports.Double = Double;\\n/**\\n * Represent a 64-bit floating point number in big-endian format.\\n *\\n * *Factory*: {@link module:Layout.f64be|f64be}\\n *\\n * @param {string} [property] - initializer for {@link\\n * Layout#property|property}.\\n *\\n * @augments {Layout}\\n */\\nclass DoubleBE extends Layout {\\n    constructor(property) {\\n        super(8, property);\\n    }\\n    /** @override */\\n    decode(b, offset = 0) {\\n        return uint8ArrayToBuffer(b).readDoubleBE(offset);\\n    }\\n    /** @override */\\n    encode(src, b, offset = 0) {\\n        uint8ArrayToBuffer(b).writeDoubleBE(src, offset);\\n        return 8;\\n    }\\n}\\nexports.DoubleBE = DoubleBE;\\n/**\\n * Represent a contiguous sequence of a specific layout as an Array.\\n *\\n * *Factory*: {@link module:Layout.seq|seq}\\n *\\n * @param {Layout} elementLayout - initializer for {@link\\n * Sequence#elementLayout|elementLayout}.\\n *\\n * @param {(Number|ExternalLayout)} count - initializer for {@link\\n * Sequence#count|count}.  The parameter must be either a positive\\n * integer or an instance of {@link ExternalLayout}.\\n *\\n * @param {string} [property] - initializer for {@link\\n * Layout#property|property}.\\n *\\n * @augments {Layout}\\n */\\nclass Sequence extends Layout {\\n    constructor(elementLayout, count, property) {\\n        if (!(elementLayout instanceof Layout)) {\\n            throw new TypeError('elementLayout must be a Layout');\\n        }\\n        if (!(((count instanceof ExternalLayout) && count.isCount())\\n            || (Number.isInteger(count) && (0 <= count)))) {\\n            throw new TypeError('count must be non-negative integer '\\n                + 'or an unsigned integer ExternalLayout');\\n        }\\n        let span = -1;\\n        if ((!(count instanceof ExternalLayout))\\n            && (0 < elementLayout.span)) {\\n            span = count * elementLayout.span;\\n        }\\n        super(span, property);\\n        /** The layout for individual elements of the sequence. */\\n        this.elementLayout = elementLayout;\\n        /** The number of elements in the sequence.\\n         *\\n         * This will be either a non-negative integer or an instance of\\n         * {@link ExternalLayout} for which {@link\\n         * ExternalLayout#isCount|isCount()} is `true`. */\\n        this.count = count;\\n    }\\n    /** @override */\\n    getSpan(b, offset = 0) {\\n        if (0 <= this.span) {\\n            return this.span;\\n        }\\n        let span = 0;\\n        let count = this.count;\\n        if (count instanceof ExternalLayout) {\\n            count = count.decode(b, offset);\\n        }\\n        if (0 < this.elementLayout.span) {\\n            span = count * this.elementLayout.span;\\n        }\\n        else {\\n            let idx = 0;\\n            while (idx < count) {\\n                span += this.elementLayout.getSpan(b, offset + span);\\n                ++idx;\\n            }\\n        }\\n        return span;\\n    }\\n    /** @override */\\n    decode(b, offset = 0) {\\n        const rv = [];\\n        let i = 0;\\n        let count = this.count;\\n        if (count instanceof ExternalLayout) {\\n            count = count.decode(b, offset);\\n        }\\n        while (i < count) {\\n            rv.push(this.elementLayout.decode(b, offset));\\n            offset += this.elementLayout.getSpan(b, offset);\\n            i += 1;\\n        }\\n        return rv;\\n    }\\n    /** Implement {@link Layout#encode|encode} for {@link Sequence}.\\n     *\\n     * **NOTE** If `src` is shorter than {@link Sequence#count|count} then\\n     * the unused space in the buffer is left unchanged.  If `src` is\\n     * longer than {@link Sequence#count|count} the unneeded elements are\\n     * ignored.\\n     *\\n     * **NOTE** If {@link Layout#count|count} is an instance of {@link\\n     * ExternalLayout} then the length of `src` will be encoded as the\\n     * count after `src` is encoded. */\\n    encode(src, b, offset = 0) {\\n        const elo = this.elementLayout;\\n        const span = src.reduce((span, v) => {\\n            return span + elo.encode(v, b, offset + span);\\n        }, 0);\\n        if (this.count instanceof ExternalLayout) {\\n            this.count.encode(src.length, b, offset);\\n        }\\n        return span;\\n    }\\n}\\nexports.Sequence = Sequence;\\n/**\\n * Represent a contiguous sequence of arbitrary layout elements as an\\n * Object.\\n *\\n * *Factory*: {@link module:Layout.struct|struct}\\n *\\n * **NOTE** The {@link Layout#span|span} of the structure is variable\\n * if any layout in {@link Structure#fields|fields} has a variable\\n * span.  When {@link Layout#encode|encoding} we must have a value for\\n * all variable-length fields, or we wouldn't be able to figure out\\n * how much space to use for storage.  We can only identify the value\\n * for a field when it has a {@link Layout#property|property}.  As\\n * such, although a structure may contain both unnamed fields and\\n * variable-length fields, it cannot contain an unnamed\\n * variable-length field.\\n *\\n * @param {Layout[]} fields - initializer for {@link\\n * Structure#fields|fields}.  An error is raised if this contains a\\n * variable-length field for which a {@link Layout#property|property}\\n * is not defined.\\n *\\n * @param {string} [property] - initializer for {@link\\n * Layout#property|property}.\\n *\\n * @param {Boolean} [decodePrefixes] - initializer for {@link\\n * Structure#decodePrefixes|property}.\\n *\\n * @throws {Error} - if `fields` contains an unnamed variable-length\\n * layout.\\n *\\n * @augments {Layout}\\n */\\nclass Structure extends Layout {\\n    constructor(fields, property, decodePrefixes) {\\n        if (!(Array.isArray(fields)\\n            && fields.reduce((acc, v) => acc && (v instanceof Layout), true))) {\\n            throw new TypeError('fields must be array of Layout instances');\\n        }\\n        if (('boolean' === typeof property)\\n            && (undefined === decodePrefixes)) {\\n            decodePrefixes = property;\\n            property = undefined;\\n        }\\n        /* Verify absence of unnamed variable-length fields. */\\n        for (const fd of fields) {\\n            if ((0 > fd.span)\\n                && (undefined === fd.property)) {\\n                throw new Error('fields cannot contain unnamed variable-length layout');\\n            }\\n        }\\n        let span = -1;\\n        try {\\n            span = fields.reduce((span, fd) => span + fd.getSpan(), 0);\\n        }\\n        catch (e) {\\n            // ignore error\\n        }\\n        super(span, property);\\n        /** The sequence of {@link Layout} values that comprise the\\n         * structure.\\n         *\\n         * The individual elements need not be the same type, and may be\\n         * either scalar or aggregate layouts.  If a member layout leaves\\n         * its {@link Layout#property|property} undefined the\\n         * corresponding region of the buffer associated with the element\\n         * will not be mutated.\\n         *\\n         * @type {Layout[]} */\\n        this.fields = fields;\\n        /** Control behavior of {@link Layout#decode|decode()} given short\\n         * buffers.\\n         *\\n         * In some situations a structure many be extended with additional\\n         * fields over time, with older installations providing only a\\n         * prefix of the full structure.  If this property is `true`\\n         * decoding will accept those buffers and leave subsequent fields\\n         * undefined, as long as the buffer ends at a field boundary.\\n         * Defaults to `false`. */\\n        this.decodePrefixes = !!decodePrefixes;\\n    }\\n    /** @override */\\n    getSpan(b, offset = 0) {\\n        if (0 <= this.span) {\\n            return this.span;\\n        }\\n        let span = 0;\\n        try {\\n            span = this.fields.reduce((span, fd) => {\\n                const fsp = fd.getSpan(b, offset);\\n                offset += fsp;\\n                return span + fsp;\\n            }, 0);\\n        }\\n        catch (e) {\\n            throw new RangeError('indeterminate span');\\n        }\\n        return span;\\n    }\\n    /** @override */\\n    decode(b, offset = 0) {\\n        checkUint8Array(b);\\n        const dest = this.makeDestinationObject();\\n        for (const fd of this.fields) {\\n            if (undefined !== fd.property) {\\n                dest[fd.property] = fd.decode(b, offset);\\n            }\\n            offset += fd.getSpan(b, offset);\\n            if (this.decodePrefixes\\n                && (b.length === offset)) {\\n                break;\\n            }\\n        }\\n        return dest;\\n    }\\n    /** Implement {@link Layout#encode|encode} for {@link Structure}.\\n     *\\n     * If `src` is missing a property for a member with a defined {@link\\n     * Layout#property|property} the corresponding region of the buffer is\\n     * left unmodified. */\\n    encode(src, b, offset = 0) {\\n        const firstOffset = offset;\\n        let lastOffset = 0;\\n        let lastWrote = 0;\\n        for (const fd of this.fields) {\\n            let span = fd.span;\\n            lastWrote = (0 < span) ? span : 0;\\n            if (undefined !== fd.property) {\\n                const fv = src[fd.property];\\n                if (undefined !== fv) {\\n                    lastWrote = fd.encode(fv, b, offset);\\n                    if (0 > span) {\\n                        /* Read the as-encoded span, which is not necessarily the\\n                         * same as what we wrote. */\\n                        span = fd.getSpan(b, offset);\\n                    }\\n                }\\n            }\\n            lastOffset = offset;\\n            offset += span;\\n        }\\n        /* Use (lastOffset + lastWrote) instead of offset because the last\\n         * item may have had a dynamic length and we don't want to include\\n         * the padding between it and the end of the space reserved for\\n         * it. */\\n        return (lastOffset + lastWrote) - firstOffset;\\n    }\\n    /** @override */\\n    fromArray(values) {\\n        const dest = this.makeDestinationObject();\\n        for (const fd of this.fields) {\\n            if ((undefined !== fd.property)\\n                && (0 < values.length)) {\\n                dest[fd.property] = values.shift();\\n            }\\n        }\\n        return dest;\\n    }\\n    /**\\n     * Get access to the layout of a given property.\\n     *\\n     * @param {String} property - the structure member of interest.\\n     *\\n     * @return {Layout} - the layout associated with `property`, or\\n     * undefined if there is no such property.\\n     */\\n    layoutFor(property) {\\n        if ('string' !== typeof property) {\\n            throw new TypeError('property must be string');\\n        }\\n        for (const fd of this.fields) {\\n            if (fd.property === property) {\\n                return fd;\\n            }\\n        }\\n        return undefined;\\n    }\\n    /**\\n     * Get the offset of a structure member.\\n     *\\n     * @param {String} property - the structure member of interest.\\n     *\\n     * @return {Number} - the offset in bytes to the start of `property`\\n     * within the structure, or undefined if `property` is not a field\\n     * within the structure.  If the property is a member but follows a\\n     * variable-length structure member a negative number will be\\n     * returned.\\n     */\\n    offsetOf(property) {\\n        if ('string' !== typeof property) {\\n            throw new TypeError('property must be string');\\n        }\\n        let offset = 0;\\n        for (const fd of this.fields) {\\n            if (fd.property === property) {\\n                return offset;\\n            }\\n            if (0 > fd.span) {\\n                offset = -1;\\n            }\\n            else if (0 <= offset) {\\n                offset += fd.span;\\n            }\\n        }\\n        return undefined;\\n    }\\n}\\nexports.Structure = Structure;\\n/**\\n * An object that can provide a {@link\\n * Union#discriminator|discriminator} API for {@link Union}.\\n *\\n * **NOTE** This is an abstract base class; you can create instances\\n * if it amuses you, but they won't support the {@link\\n * UnionDiscriminator#encode|encode} or {@link\\n * UnionDiscriminator#decode|decode} functions.\\n *\\n * @param {string} [property] - Default for {@link\\n * UnionDiscriminator#property|property}.\\n *\\n * @abstract\\n */\\nclass UnionDiscriminator {\\n    constructor(property) {\\n        /** The {@link Layout#property|property} to be used when the\\n         * discriminator is referenced in isolation (generally when {@link\\n         * Union#decode|Union decode} cannot delegate to a specific\\n         * variant). */\\n        this.property = property;\\n    }\\n    /** Analog to {@link Layout#decode|Layout decode} for union discriminators.\\n     *\\n     * The implementation of this method need not reference the buffer if\\n     * variant information is available through other means. */\\n    decode(b, offset) {\\n        throw new Error('UnionDiscriminator is abstract');\\n    }\\n    /** Analog to {@link Layout#decode|Layout encode} for union discriminators.\\n     *\\n     * The implementation of this method need not store the value if\\n     * variant information is maintained through other means. */\\n    encode(src, b, offset) {\\n        throw new Error('UnionDiscriminator is abstract');\\n    }\\n}\\nexports.UnionDiscriminator = UnionDiscriminator;\\n/**\\n * An object that can provide a {@link\\n * UnionDiscriminator|discriminator API} for {@link Union} using an\\n * unsigned integral {@link Layout} instance located either inside or\\n * outside the union.\\n *\\n * @param {ExternalLayout} layout - initializes {@link\\n * UnionLayoutDiscriminator#layout|layout}.  Must satisfy {@link\\n * ExternalLayout#isCount|isCount()}.\\n *\\n * @param {string} [property] - Default for {@link\\n * UnionDiscriminator#property|property}, superseding the property\\n * from `layout`, but defaulting to `variant` if neither `property`\\n * nor layout provide a property name.\\n *\\n * @augments {UnionDiscriminator}\\n */\\nclass UnionLayoutDiscriminator extends UnionDiscriminator {\\n    constructor(layout, property) {\\n        if (!((layout instanceof ExternalLayout)\\n            && layout.isCount())) {\\n            throw new TypeError('layout must be an unsigned integer ExternalLayout');\\n        }\\n        super(property || layout.property || 'variant');\\n        /** The {@link ExternalLayout} used to access the discriminator\\n         * value. */\\n        this.layout = layout;\\n    }\\n    /** Delegate decoding to {@link UnionLayoutDiscriminator#layout|layout}. */\\n    decode(b, offset) {\\n        return this.layout.decode(b, offset);\\n    }\\n    /** Delegate encoding to {@link UnionLayoutDiscriminator#layout|layout}. */\\n    encode(src, b, offset) {\\n        return this.layout.encode(src, b, offset);\\n    }\\n}\\nexports.UnionLayoutDiscriminator = UnionLayoutDiscriminator;\\n/**\\n * Represent any number of span-compatible layouts.\\n *\\n * *Factory*: {@link module:Layout.union|union}\\n *\\n * If the union has a {@link Union#defaultLayout|default layout} that\\n * layout must have a non-negative {@link Layout#span|span}.  The span\\n * of a fixed-span union includes its {@link\\n * Union#discriminator|discriminator} if the variant is a {@link\\n * Union#usesPrefixDiscriminator|prefix of the union}, plus the span\\n * of its {@link Union#defaultLayout|default layout}.\\n *\\n * If the union does not have a default layout then the encoded span\\n * of the union depends on the encoded span of its variant (which may\\n * be fixed or variable).\\n *\\n * {@link VariantLayout#layout|Variant layout}s are added through\\n * {@link Union#addVariant|addVariant}.  If the union has a default\\n * layout, the span of the {@link VariantLayout#layout|layout\\n * contained by the variant} must not exceed the span of the {@link\\n * Union#defaultLayout|default layout} (minus the span of a {@link\\n * Union#usesPrefixDiscriminator|prefix disriminator}, if used).  The\\n * span of the variant will equal the span of the union itself.\\n *\\n * The variant for a buffer can only be identified from the {@link\\n * Union#discriminator|discriminator} {@link\\n * UnionDiscriminator#property|property} (in the case of the {@link\\n * Union#defaultLayout|default layout}), or by using {@link\\n * Union#getVariant|getVariant} and examining the resulting {@link\\n * VariantLayout} instance.\\n *\\n * A variant compatible with a JavaScript object can be identified\\n * using {@link Union#getSourceVariant|getSourceVariant}.\\n *\\n * @param {(UnionDiscriminator|ExternalLayout|Layout)} discr - How to\\n * identify the layout used to interpret the union contents.  The\\n * parameter must be an instance of {@link UnionDiscriminator}, an\\n * {@link ExternalLayout} that satisfies {@link\\n * ExternalLayout#isCount|isCount()}, or {@link UInt} (or {@link\\n * UIntBE}).  When a non-external layout element is passed the layout\\n * appears at the start of the union.  In all cases the (synthesized)\\n * {@link UnionDiscriminator} instance is recorded as {@link\\n * Union#discriminator|discriminator}.\\n *\\n * @param {(Layout|null)} defaultLayout - initializer for {@link\\n * Union#defaultLayout|defaultLayout}.  If absent defaults to `null`.\\n * If `null` there is no default layout: the union has data-dependent\\n * length and attempts to decode or encode unrecognized variants will\\n * throw an exception.  A {@link Layout} instance must have a\\n * non-negative {@link Layout#span|span}, and if it lacks a {@link\\n * Layout#property|property} the {@link\\n * Union#defaultLayout|defaultLayout} will be a {@link\\n * Layout#replicate|replica} with property `content`.\\n *\\n * @param {string} [property] - initializer for {@link\\n * Layout#property|property}.\\n *\\n * @augments {Layout}\\n */\\nclass Union extends Layout {\\n    constructor(discr, defaultLayout, property) {\\n        let discriminator;\\n        if ((discr instanceof UInt)\\n            || (discr instanceof UIntBE)) {\\n            discriminator = new UnionLayoutDiscriminator(new OffsetLayout(discr));\\n        }\\n        else if ((discr instanceof ExternalLayout)\\n            && discr.isCount()) {\\n            discriminator = new UnionLayoutDiscriminator(discr);\\n        }\\n        else if (!(discr instanceof UnionDiscriminator)) {\\n            throw new TypeError('discr must be a UnionDiscriminator '\\n                + 'or an unsigned integer layout');\\n        }\\n        else {\\n            discriminator = discr;\\n        }\\n        if (undefined === defaultLayout) {\\n            defaultLayout = null;\\n        }\\n        if (!((null === defaultLayout)\\n            || (defaultLayout instanceof Layout))) {\\n            throw new TypeError('defaultLayout must be null or a Layout');\\n        }\\n        if (null !== defaultLayout) {\\n            if (0 > defaultLayout.span) {\\n                throw new Error('defaultLayout must have constant span');\\n            }\\n            if (undefined === defaultLayout.property) {\\n                defaultLayout = defaultLayout.replicate('content');\\n            }\\n        }\\n        /* The union span can be estimated only if there's a default\\n         * layout.  The union spans its default layout, plus any prefix\\n         * variant layout.  By construction both layouts, if present, have\\n         * non-negative span. */\\n        let span = -1;\\n        if (defaultLayout) {\\n            span = defaultLayout.span;\\n            if ((0 <= span) && ((discr instanceof UInt)\\n                || (discr instanceof UIntBE))) {\\n                span += discriminator.layout.span;\\n            }\\n        }\\n        super(span, property);\\n        /** The interface for the discriminator value in isolation.\\n         *\\n         * This a {@link UnionDiscriminator} either passed to the\\n         * constructor or synthesized from the `discr` constructor\\n         * argument.  {@link\\n         * Union#usesPrefixDiscriminator|usesPrefixDiscriminator} will be\\n         * `true` iff the `discr` parameter was a non-offset {@link\\n         * Layout} instance. */\\n        this.discriminator = discriminator;\\n        /** `true` if the {@link Union#discriminator|discriminator} is the\\n         * first field in the union.\\n         *\\n         * If `false` the discriminator is obtained from somewhere\\n         * else. */\\n        this.usesPrefixDiscriminator = (discr instanceof UInt)\\n            || (discr instanceof UIntBE);\\n        /** The layout for non-discriminator content when the value of the\\n         * discriminator is not recognized.\\n         *\\n         * This is the value passed to the constructor.  It is\\n         * structurally equivalent to the second component of {@link\\n         * Union#layout|layout} but may have a different property\\n         * name. */\\n        this.defaultLayout = defaultLayout;\\n        /** A registry of allowed variants.\\n         *\\n         * The keys are unsigned integers which should be compatible with\\n         * {@link Union.discriminator|discriminator}.  The property value\\n         * is the corresponding {@link VariantLayout} instances assigned\\n         * to this union by {@link Union#addVariant|addVariant}.\\n         *\\n         * **NOTE** The registry remains mutable so that variants can be\\n         * {@link Union#addVariant|added} at any time.  Users should not\\n         * manipulate the content of this property. */\\n        this.registry = {};\\n        /* Private variable used when invoking getSourceVariant */\\n        let boundGetSourceVariant = this.defaultGetSourceVariant.bind(this);\\n        /** Function to infer the variant selected by a source object.\\n         *\\n         * Defaults to {@link\\n         * Union#defaultGetSourceVariant|defaultGetSourceVariant} but may\\n         * be overridden using {@link\\n         * Union#configGetSourceVariant|configGetSourceVariant}.\\n         *\\n         * @param {Object} src - as with {@link\\n         * Union#defaultGetSourceVariant|defaultGetSourceVariant}.\\n         *\\n         * @returns {(undefined|VariantLayout)} The default variant\\n         * (`undefined`) or first registered variant that uses a property\\n         * available in `src`. */\\n        this.getSourceVariant = function (src) {\\n            return boundGetSourceVariant(src);\\n        };\\n        /** Function to override the implementation of {@link\\n         * Union#getSourceVariant|getSourceVariant}.\\n         *\\n         * Use this if the desired variant cannot be identified using the\\n         * algorithm of {@link\\n         * Union#defaultGetSourceVariant|defaultGetSourceVariant}.\\n         *\\n         * **NOTE** The provided function will be invoked bound to this\\n         * Union instance, providing local access to {@link\\n         * Union#registry|registry}.\\n         *\\n         * @param {Function} gsv - a function that follows the API of\\n         * {@link Union#defaultGetSourceVariant|defaultGetSourceVariant}. */\\n        this.configGetSourceVariant = function (gsv) {\\n            boundGetSourceVariant = gsv.bind(this);\\n        };\\n    }\\n    /** @override */\\n    getSpan(b, offset = 0) {\\n        if (0 <= this.span) {\\n            return this.span;\\n        }\\n        /* Default layouts always have non-negative span, so we don't have\\n         * one and we have to recognize the variant which will in turn\\n         * determine the span. */\\n        const vlo = this.getVariant(b, offset);\\n        if (!vlo) {\\n            throw new Error('unable to determine span for unrecognized variant');\\n        }\\n        return vlo.getSpan(b, offset);\\n    }\\n    /**\\n     * Method to infer a registered Union variant compatible with `src`.\\n     *\\n     * The first satisfied rule in the following sequence defines the\\n     * return value:\\n     * * If `src` has properties matching the Union discriminator and\\n     *   the default layout, `undefined` is returned regardless of the\\n     *   value of the discriminator property (this ensures the default\\n     *   layout will be used);\\n     * * If `src` has a property matching the Union discriminator, the\\n     *   value of the discriminator identifies a registered variant, and\\n     *   either (a) the variant has no layout, or (b) `src` has the\\n     *   variant's property, then the variant is returned (because the\\n     *   source satisfies the constraints of the variant it identifies);\\n     * * If `src` does not have a property matching the Union\\n     *   discriminator, but does have a property matching a registered\\n     *   variant, then the variant is returned (because the source\\n     *   matches a variant without an explicit conflict);\\n     * * An error is thrown (because we either can't identify a variant,\\n     *   or we were explicitly told the variant but can't satisfy it).\\n     *\\n     * @param {Object} src - an object presumed to be compatible with\\n     * the content of the Union.\\n     *\\n     * @return {(undefined|VariantLayout)} - as described above.\\n     *\\n     * @throws {Error} - if `src` cannot be associated with a default or\\n     * registered variant.\\n     */\\n    defaultGetSourceVariant(src) {\\n        if (Object.prototype.hasOwnProperty.call(src, this.discriminator.property)) {\\n            if (this.defaultLayout && this.defaultLayout.property\\n                && Object.prototype.hasOwnProperty.call(src, this.defaultLayout.property)) {\\n                return undefined;\\n            }\\n            const vlo = this.registry[src[this.discriminator.property]];\\n            if (vlo\\n                && ((!vlo.layout)\\n                    || (vlo.property && Object.prototype.hasOwnProperty.call(src, vlo.property)))) {\\n                return vlo;\\n            }\\n        }\\n        else {\\n            for (const tag in this.registry) {\\n                const vlo = this.registry[tag];\\n                if (vlo.property && Object.prototype.hasOwnProperty.call(src, vlo.property)) {\\n                    return vlo;\\n                }\\n            }\\n        }\\n        throw new Error('unable to infer src variant');\\n    }\\n    /** Implement {@link Layout#decode|decode} for {@link Union}.\\n     *\\n     * If the variant is {@link Union#addVariant|registered} the return\\n     * value is an instance of that variant, with no explicit\\n     * discriminator.  Otherwise the {@link Union#defaultLayout|default\\n     * layout} is used to decode the content. */\\n    decode(b, offset = 0) {\\n        let dest;\\n        const dlo = this.discriminator;\\n        const discr = dlo.decode(b, offset);\\n        const clo = this.registry[discr];\\n        if (undefined === clo) {\\n            const defaultLayout = this.defaultLayout;\\n            let contentOffset = 0;\\n            if (this.usesPrefixDiscriminator) {\\n                contentOffset = dlo.layout.span;\\n            }\\n            dest = this.makeDestinationObject();\\n            dest[dlo.property] = discr;\\n            // defaultLayout.property can be undefined, but this is allowed by buffer-layout\\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\\n            dest[defaultLayout.property] = defaultLayout.decode(b, offset + contentOffset);\\n        }\\n        else {\\n            dest = clo.decode(b, offset);\\n        }\\n        return dest;\\n    }\\n    /** Implement {@link Layout#encode|encode} for {@link Union}.\\n     *\\n     * This API assumes the `src` object is consistent with the union's\\n     * {@link Union#defaultLayout|default layout}.  To encode variants\\n     * use the appropriate variant-specific {@link VariantLayout#encode}\\n     * method. */\\n    encode(src, b, offset = 0) {\\n        const vlo = this.getSourceVariant(src);\\n        if (undefined === vlo) {\\n            const dlo = this.discriminator;\\n            // this.defaultLayout is not undefined when vlo is undefined\\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\\n            const clo = this.defaultLayout;\\n            let contentOffset = 0;\\n            if (this.usesPrefixDiscriminator) {\\n                contentOffset = dlo.layout.span;\\n            }\\n            dlo.encode(src[dlo.property], b, offset);\\n            // clo.property is not undefined when vlo is undefined\\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\\n            return contentOffset + clo.encode(src[clo.property], b, offset + contentOffset);\\n        }\\n        return vlo.encode(src, b, offset);\\n    }\\n    /** Register a new variant structure within a union.  The newly\\n     * created variant is returned.\\n     *\\n     * @param {Number} variant - initializer for {@link\\n     * VariantLayout#variant|variant}.\\n     *\\n     * @param {Layout} layout - initializer for {@link\\n     * VariantLayout#layout|layout}.\\n     *\\n     * @param {String} property - initializer for {@link\\n     * Layout#property|property}.\\n     *\\n     * @return {VariantLayout} */\\n    addVariant(variant, layout, property) {\\n        const rv = new VariantLayout(this, variant, layout, property);\\n        this.registry[variant] = rv;\\n        return rv;\\n    }\\n    /**\\n     * Get the layout associated with a registered variant.\\n     *\\n     * If `vb` does not produce a registered variant the function returns\\n     * `undefined`.\\n     *\\n     * @param {(Number|Uint8Array)} vb - either the variant number, or a\\n     * buffer from which the discriminator is to be read.\\n     *\\n     * @param {Number} offset - offset into `vb` for the start of the\\n     * union.  Used only when `vb` is an instance of {Uint8Array}.\\n     *\\n     * @return {({VariantLayout}|undefined)}\\n     */\\n    getVariant(vb, offset = 0) {\\n        let variant;\\n        if (vb instanceof Uint8Array) {\\n            variant = this.discriminator.decode(vb, offset);\\n        }\\n        else {\\n            variant = vb;\\n        }\\n        return this.registry[variant];\\n    }\\n}\\nexports.Union = Union;\\n/**\\n * Represent a specific variant within a containing union.\\n *\\n * **NOTE** The {@link Layout#span|span} of the variant may include\\n * the span of the {@link Union#discriminator|discriminator} used to\\n * identify it, but values read and written using the variant strictly\\n * conform to the content of {@link VariantLayout#layout|layout}.\\n *\\n * **NOTE** User code should not invoke this constructor directly.  Use\\n * the union {@link Union#addVariant|addVariant} helper method.\\n *\\n * @param {Union} union - initializer for {@link\\n * VariantLayout#union|union}.\\n *\\n * @param {Number} variant - initializer for {@link\\n * VariantLayout#variant|variant}.\\n *\\n * @param {Layout} [layout] - initializer for {@link\\n * VariantLayout#layout|layout}.  If absent the variant carries no\\n * data.\\n *\\n * @param {String} [property] - initializer for {@link\\n * Layout#property|property}.  Unlike many other layouts, variant\\n * layouts normally include a property name so they can be identified\\n * within their containing {@link Union}.  The property identifier may\\n * be absent only if `layout` is is absent.\\n *\\n * @augments {Layout}\\n */\\nclass VariantLayout extends Layout {\\n    constructor(union, variant, layout, property) {\\n        if (!(union instanceof Union)) {\\n            throw new TypeError('union must be a Union');\\n        }\\n        if ((!Number.isInteger(variant)) || (0 > variant)) {\\n            throw new TypeError('variant must be a (non-negative) integer');\\n        }\\n        if (('string' === typeof layout)\\n            && (undefined === property)) {\\n            property = layout;\\n            layout = null;\\n        }\\n        if (layout) {\\n            if (!(layout instanceof Layout)) {\\n                throw new TypeError('layout must be a Layout');\\n            }\\n            if ((null !== union.defaultLayout)\\n                && (0 <= layout.span)\\n                && (layout.span > union.defaultLayout.span)) {\\n                throw new Error('variant span exceeds span of containing union');\\n            }\\n            if ('string' !== typeof property) {\\n                throw new TypeError('variant must have a String property');\\n            }\\n        }\\n        let span = union.span;\\n        if (0 > union.span) {\\n            span = layout ? layout.span : 0;\\n            if ((0 <= span) && union.usesPrefixDiscriminator) {\\n                span += union.discriminator.layout.span;\\n            }\\n        }\\n        super(span, property);\\n        /** The {@link Union} to which this variant belongs. */\\n        this.union = union;\\n        /** The unsigned integral value identifying this variant within\\n         * the {@link Union#discriminator|discriminator} of the containing\\n         * union. */\\n        this.variant = variant;\\n        /** The {@link Layout} to be used when reading/writing the\\n         * non-discriminator part of the {@link\\n         * VariantLayout#union|union}.  If `null` the variant carries no\\n         * data. */\\n        this.layout = layout || null;\\n    }\\n    /** @override */\\n    getSpan(b, offset = 0) {\\n        if (0 <= this.span) {\\n            /* Will be equal to the containing union span if that is not\\n             * variable. */\\n            return this.span;\\n        }\\n        let contentOffset = 0;\\n        if (this.union.usesPrefixDiscriminator) {\\n            contentOffset = this.union.discriminator.layout.span;\\n        }\\n        /* Span is defined solely by the variant (and prefix discriminator) */\\n        let span = 0;\\n        if (this.layout) {\\n            span = this.layout.getSpan(b, offset + contentOffset);\\n        }\\n        return contentOffset + span;\\n    }\\n    /** @override */\\n    decode(b, offset = 0) {\\n        const dest = this.makeDestinationObject();\\n        if (this !== this.union.getVariant(b, offset)) {\\n            throw new Error('variant mismatch');\\n        }\\n        let contentOffset = 0;\\n        if (this.union.usesPrefixDiscriminator) {\\n            contentOffset = this.union.discriminator.layout.span;\\n        }\\n        if (this.layout) {\\n            dest[this.property] = this.layout.decode(b, offset + contentOffset);\\n        }\\n        else if (this.property) {\\n            dest[this.property] = true;\\n        }\\n        else if (this.union.usesPrefixDiscriminator) {\\n            dest[this.union.discriminator.property] = this.variant;\\n        }\\n        return dest;\\n    }\\n    /** @override */\\n    encode(src, b, offset = 0) {\\n        let contentOffset = 0;\\n        if (this.union.usesPrefixDiscriminator) {\\n            contentOffset = this.union.discriminator.layout.span;\\n        }\\n        if (this.layout\\n            && (!Object.prototype.hasOwnProperty.call(src, this.property))) {\\n            throw new TypeError('variant lacks property ' + this.property);\\n        }\\n        this.union.discriminator.encode(this.variant, b, offset);\\n        let span = contentOffset;\\n        if (this.layout) {\\n            this.layout.encode(src[this.property], b, offset + contentOffset);\\n            span += this.layout.getSpan(b, offset + contentOffset);\\n            if ((0 <= this.union.span)\\n                && (span > this.union.span)) {\\n                throw new Error('encoded variant overruns containing union');\\n            }\\n        }\\n        return span;\\n    }\\n    /** Delegate {@link Layout#fromArray|fromArray} to {@link\\n     * VariantLayout#layout|layout}. */\\n    fromArray(values) {\\n        if (this.layout) {\\n            return this.layout.fromArray(values);\\n        }\\n        return undefined;\\n    }\\n}\\nexports.VariantLayout = VariantLayout;\\n/** JavaScript chose to define bitwise operations as operating on\\n * signed 32-bit values in 2's complement form, meaning any integer\\n * with bit 31 set is going to look negative.  For right shifts that's\\n * not a problem, because `>>>` is a logical shift, but for every\\n * other bitwise operator we have to compensate for possible negative\\n * results. */\\nfunction fixBitwiseResult(v) {\\n    if (0 > v) {\\n        v += 0x100000000;\\n    }\\n    return v;\\n}\\n/**\\n * Contain a sequence of bit fields as an unsigned integer.\\n *\\n * *Factory*: {@link module:Layout.bits|bits}\\n *\\n * This is a container element; within it there are {@link BitField}\\n * instances that provide the extracted properties.  The container\\n * simply defines the aggregate representation and its bit ordering.\\n * The representation is an object containing properties with numeric\\n * or {@link Boolean} values.\\n *\\n * {@link BitField}s are added with the {@link\\n * BitStructure#addField|addField} and {@link\\n * BitStructure#addBoolean|addBoolean} methods.\\n\\n * @param {Layout} word - initializer for {@link\\n * BitStructure#word|word}.  The parameter must be an instance of\\n * {@link UInt} (or {@link UIntBE}) that is no more than 4 bytes wide.\\n *\\n * @param {bool} [msb] - `true` if the bit numbering starts at the\\n * most significant bit of the containing word; `false` (default) if\\n * it starts at the least significant bit of the containing word.  If\\n * the parameter at this position is a string and `property` is\\n * `undefined` the value of this argument will instead be used as the\\n * value of `property`.\\n *\\n * @param {string} [property] - initializer for {@link\\n * Layout#property|property}.\\n *\\n * @augments {Layout}\\n */\\nclass BitStructure extends Layout {\\n    constructor(word, msb, property) {\\n        if (!((word instanceof UInt)\\n            || (word instanceof UIntBE))) {\\n            throw new TypeError('word must be a UInt or UIntBE layout');\\n        }\\n        if (('string' === typeof msb)\\n            && (undefined === property)) {\\n            property = msb;\\n            msb = false;\\n        }\\n        if (4 < word.span) {\\n            throw new RangeError('word cannot exceed 32 bits');\\n        }\\n        super(word.span, property);\\n        /** The layout used for the packed value.  {@link BitField}\\n         * instances are packed sequentially depending on {@link\\n         * BitStructure#msb|msb}. */\\n        this.word = word;\\n        /** Whether the bit sequences are packed starting at the most\\n         * significant bit growing down (`true`), or the least significant\\n         * bit growing up (`false`).\\n         *\\n         * **NOTE** Regardless of this value, the least significant bit of\\n         * any {@link BitField} value is the least significant bit of the\\n         * corresponding section of the packed value. */\\n        this.msb = !!msb;\\n        /** The sequence of {@link BitField} layouts that comprise the\\n         * packed structure.\\n         *\\n         * **NOTE** The array remains mutable to allow fields to be {@link\\n         * BitStructure#addField|added} after construction.  Users should\\n         * not manipulate the content of this property.*/\\n        this.fields = [];\\n        /* Storage for the value.  Capture a variable instead of using an\\n         * instance property because we don't want anything to change the\\n         * value without going through the mutator. */\\n        let value = 0;\\n        this._packedSetValue = function (v) {\\n            value = fixBitwiseResult(v);\\n            return this;\\n        };\\n        this._packedGetValue = function () {\\n            return value;\\n        };\\n    }\\n    /** @override */\\n    decode(b, offset = 0) {\\n        const dest = this.makeDestinationObject();\\n        const value = this.word.decode(b, offset);\\n        this._packedSetValue(value);\\n        for (const fd of this.fields) {\\n            if (undefined !== fd.property) {\\n                dest[fd.property] = fd.decode(b);\\n            }\\n        }\\n        return dest;\\n    }\\n    /** Implement {@link Layout#encode|encode} for {@link BitStructure}.\\n     *\\n     * If `src` is missing a property for a member with a defined {@link\\n     * Layout#property|property} the corresponding region of the packed\\n     * value is left unmodified.  Unused bits are also left unmodified. */\\n    encode(src, b, offset = 0) {\\n        const value = this.word.decode(b, offset);\\n        this._packedSetValue(value);\\n        for (const fd of this.fields) {\\n            if (undefined !== fd.property) {\\n                const fv = src[fd.property];\\n                if (undefined !== fv) {\\n                    fd.encode(fv);\\n                }\\n            }\\n        }\\n        return this.word.encode(this._packedGetValue(), b, offset);\\n    }\\n    /** Register a new bitfield with a containing bit structure.  The\\n     * resulting bitfield is returned.\\n     *\\n     * @param {Number} bits - initializer for {@link BitField#bits|bits}.\\n     *\\n     * @param {string} property - initializer for {@link\\n     * Layout#property|property}.\\n     *\\n     * @return {BitField} */\\n    addField(bits, property) {\\n        const bf = new BitField(this, bits, property);\\n        this.fields.push(bf);\\n        return bf;\\n    }\\n    /** As with {@link BitStructure#addField|addField} for single-bit\\n     * fields with `boolean` value representation.\\n     *\\n     * @param {string} property - initializer for {@link\\n     * Layout#property|property}.\\n     *\\n     * @return {Boolean} */\\n    // `Boolean` conflicts with the native primitive type\\n    // eslint-disable-next-line @typescript-eslint/ban-types\\n    addBoolean(property) {\\n        // This is my Boolean, not the Javascript one.\\n        const bf = new Boolean(this, property);\\n        this.fields.push(bf);\\n        return bf;\\n    }\\n    /**\\n     * Get access to the bit field for a given property.\\n     *\\n     * @param {String} property - the bit field of interest.\\n     *\\n     * @return {BitField} - the field associated with `property`, or\\n     * undefined if there is no such property.\\n     */\\n    fieldFor(property) {\\n        if ('string' !== typeof property) {\\n            throw new TypeError('property must be string');\\n        }\\n        for (const fd of this.fields) {\\n            if (fd.property === property) {\\n                return fd;\\n            }\\n        }\\n        return undefined;\\n    }\\n}\\nexports.BitStructure = BitStructure;\\n/**\\n * Represent a sequence of bits within a {@link BitStructure}.\\n *\\n * All bit field values are represented as unsigned integers.\\n *\\n * **NOTE** User code should not invoke this constructor directly.\\n * Use the container {@link BitStructure#addField|addField} helper\\n * method.\\n *\\n * **NOTE** BitField instances are not instances of {@link Layout}\\n * since {@link Layout#span|span} measures 8-bit units.\\n *\\n * @param {BitStructure} container - initializer for {@link\\n * BitField#container|container}.\\n *\\n * @param {Number} bits - initializer for {@link BitField#bits|bits}.\\n *\\n * @param {string} [property] - initializer for {@link\\n * Layout#property|property}.\\n */\\nclass BitField {\\n    constructor(container, bits, property) {\\n        if (!(container instanceof BitStructure)) {\\n            throw new TypeError('container must be a BitStructure');\\n        }\\n        if ((!Number.isInteger(bits)) || (0 >= bits)) {\\n            throw new TypeError('bits must be positive integer');\\n        }\\n        const totalBits = 8 * container.span;\\n        const usedBits = container.fields.reduce((sum, fd) => sum + fd.bits, 0);\\n        if ((bits + usedBits) > totalBits) {\\n            throw new Error('bits too long for span remainder ('\\n                + (totalBits - usedBits) + ' of '\\n                + totalBits + ' remain)');\\n        }\\n        /** The {@link BitStructure} instance to which this bit field\\n         * belongs. */\\n        this.container = container;\\n        /** The span of this value in bits. */\\n        this.bits = bits;\\n        /** A mask of {@link BitField#bits|bits} bits isolating value bits\\n         * that fit within the field.\\n         *\\n         * That is, it masks a value that has not yet been shifted into\\n         * position within its containing packed integer. */\\n        this.valueMask = (1 << bits) - 1;\\n        if (32 === bits) { // shifted value out of range\\n            this.valueMask = 0xFFFFFFFF;\\n        }\\n        /** The offset of the value within the containing packed unsigned\\n         * integer.  The least significant bit of the packed value is at\\n         * offset zero, regardless of bit ordering used. */\\n        this.start = usedBits;\\n        if (this.container.msb) {\\n            this.start = totalBits - usedBits - bits;\\n        }\\n        /** A mask of {@link BitField#bits|bits} isolating the field value\\n         * within the containing packed unsigned integer. */\\n        this.wordMask = fixBitwiseResult(this.valueMask << this.start);\\n        /** The property name used when this bitfield is represented in an\\n         * Object.\\n         *\\n         * Intended to be functionally equivalent to {@link\\n         * Layout#property}.\\n         *\\n         * If left undefined the corresponding span of bits will be\\n         * treated as padding: it will not be mutated by {@link\\n         * Layout#encode|encode} nor represented as a property in the\\n         * decoded Object. */\\n        this.property = property;\\n    }\\n    /** Store a value into the corresponding subsequence of the containing\\n     * bit field. */\\n    decode(b, offset) {\\n        const word = this.container._packedGetValue();\\n        const wordValue = fixBitwiseResult(word & this.wordMask);\\n        const value = wordValue >>> this.start;\\n        return value;\\n    }\\n    /** Store a value into the corresponding subsequence of the containing\\n     * bit field.\\n     *\\n     * **NOTE** This is not a specialization of {@link\\n     * Layout#encode|Layout.encode} and there is no return value. */\\n    encode(value) {\\n        if ('number' !== typeof value\\n            || !Number.isInteger(value)\\n            || (value !== fixBitwiseResult(value & this.valueMask))) {\\n            throw new TypeError(nameWithProperty('BitField.encode', this)\\n                + ' value must be integer not exceeding ' + this.valueMask);\\n        }\\n        const word = this.container._packedGetValue();\\n        const wordValue = fixBitwiseResult(value << this.start);\\n        this.container._packedSetValue(fixBitwiseResult(word & ~this.wordMask)\\n            | wordValue);\\n    }\\n}\\nexports.BitField = BitField;\\n/**\\n * Represent a single bit within a {@link BitStructure} as a\\n * JavaScript boolean.\\n *\\n * **NOTE** User code should not invoke this constructor directly.\\n * Use the container {@link BitStructure#addBoolean|addBoolean} helper\\n * method.\\n *\\n * @param {BitStructure} container - initializer for {@link\\n * BitField#container|container}.\\n *\\n * @param {string} [property] - initializer for {@link\\n * Layout#property|property}.\\n *\\n * @augments {BitField}\\n */\\n/* eslint-disable no-extend-native */\\nclass Boolean extends BitField {\\n    constructor(container, property) {\\n        super(container, 1, property);\\n    }\\n    /** Override {@link BitField#decode|decode} for {@link Boolean|Boolean}.\\n     *\\n     * @returns {boolean} */\\n    decode(b, offset) {\\n        return !!super.decode(b, offset);\\n    }\\n    /** @override */\\n    encode(value) {\\n        if ('boolean' === typeof value) {\\n            // BitField requires integer values\\n            value = +value;\\n        }\\n        super.encode(value);\\n    }\\n}\\nexports.Boolean = Boolean;\\n/* eslint-enable no-extend-native */\\n/**\\n * Contain a fixed-length block of arbitrary data, represented as a\\n * Uint8Array.\\n *\\n * *Factory*: {@link module:Layout.blob|blob}\\n *\\n * @param {(Number|ExternalLayout)} length - initializes {@link\\n * Blob#length|length}.\\n *\\n * @param {String} [property] - initializer for {@link\\n * Layout#property|property}.\\n *\\n * @augments {Layout}\\n */\\nclass Blob extends Layout {\\n    constructor(length, property) {\\n        if (!(((length instanceof ExternalLayout) && length.isCount())\\n            || (Number.isInteger(length) && (0 <= length)))) {\\n            throw new TypeError('length must be positive integer '\\n                + 'or an unsigned integer ExternalLayout');\\n        }\\n        let span = -1;\\n        if (!(length instanceof ExternalLayout)) {\\n            span = length;\\n        }\\n        super(span, property);\\n        /** The number of bytes in the blob.\\n         *\\n         * This may be a non-negative integer, or an instance of {@link\\n         * ExternalLayout} that satisfies {@link\\n         * ExternalLayout#isCount|isCount()}. */\\n        this.length = length;\\n    }\\n    /** @override */\\n    getSpan(b, offset) {\\n        let span = this.span;\\n        if (0 > span) {\\n            span = this.length.decode(b, offset);\\n        }\\n        return span;\\n    }\\n    /** @override */\\n    decode(b, offset = 0) {\\n        let span = this.span;\\n        if (0 > span) {\\n            span = this.length.decode(b, offset);\\n        }\\n        return uint8ArrayToBuffer(b).slice(offset, offset + span);\\n    }\\n    /** Implement {@link Layout#encode|encode} for {@link Blob}.\\n     *\\n     * **NOTE** If {@link Layout#count|count} is an instance of {@link\\n     * ExternalLayout} then the length of `src` will be encoded as the\\n     * count after `src` is encoded. */\\n    encode(src, b, offset) {\\n        let span = this.length;\\n        if (this.length instanceof ExternalLayout) {\\n            span = src.length;\\n        }\\n        if (!(src instanceof Uint8Array && span === src.length)) {\\n            throw new TypeError(nameWithProperty('Blob.encode', this)\\n                + ' requires (length ' + span + ') Uint8Array as src');\\n        }\\n        if ((offset + span) > b.length) {\\n            throw new RangeError('encoding overruns Uint8Array');\\n        }\\n        const srcBuffer = uint8ArrayToBuffer(src);\\n        uint8ArrayToBuffer(b).write(srcBuffer.toString('hex'), offset, span, 'hex');\\n        if (this.length instanceof ExternalLayout) {\\n            this.length.encode(span, b, offset);\\n        }\\n        return span;\\n    }\\n}\\nexports.Blob = Blob;\\n/**\\n * Contain a `NUL`-terminated UTF8 string.\\n *\\n * *Factory*: {@link module:Layout.cstr|cstr}\\n *\\n * **NOTE** Any UTF8 string that incorporates a zero-valued byte will\\n * not be correctly decoded by this layout.\\n *\\n * @param {String} [property] - initializer for {@link\\n * Layout#property|property}.\\n *\\n * @augments {Layout}\\n */\\nclass CString extends Layout {\\n    constructor(property) {\\n        super(-1, property);\\n    }\\n    /** @override */\\n    getSpan(b, offset = 0) {\\n        checkUint8Array(b);\\n        let idx = offset;\\n        while ((idx < b.length) && (0 !== b[idx])) {\\n            idx += 1;\\n        }\\n        return 1 + idx - offset;\\n    }\\n    /** @override */\\n    decode(b, offset = 0) {\\n        const span = this.getSpan(b, offset);\\n        return uint8ArrayToBuffer(b).slice(offset, offset + span - 1).toString('utf-8');\\n    }\\n    /** @override */\\n    encode(src, b, offset = 0) {\\n        /* Must force this to a string, lest it be a number and the\\n         * \\\"utf8-encoding\\\" below actually allocate a buffer of length\\n         * src */\\n        if ('string' !== typeof src) {\\n            src = String(src);\\n        }\\n        const srcb = buffer_1.Buffer.from(src, 'utf8');\\n        const span = srcb.length;\\n        if ((offset + span) > b.length) {\\n            throw new RangeError('encoding overruns Buffer');\\n        }\\n        const buffer = uint8ArrayToBuffer(b);\\n        srcb.copy(buffer, offset);\\n        buffer[offset + span] = 0;\\n        return span + 1;\\n    }\\n}\\nexports.CString = CString;\\n/**\\n * Contain a UTF8 string with implicit length.\\n *\\n * *Factory*: {@link module:Layout.utf8|utf8}\\n *\\n * **NOTE** Because the length is implicit in the size of the buffer\\n * this layout should be used only in isolation, or in a situation\\n * where the length can be expressed by operating on a slice of the\\n * containing buffer.\\n *\\n * @param {Number} [maxSpan] - the maximum length allowed for encoded\\n * string content.  If not provided there is no bound on the allowed\\n * content.\\n *\\n * @param {String} [property] - initializer for {@link\\n * Layout#property|property}.\\n *\\n * @augments {Layout}\\n */\\nclass UTF8 extends Layout {\\n    constructor(maxSpan, property) {\\n        if (('string' === typeof maxSpan) && (undefined === property)) {\\n            property = maxSpan;\\n            maxSpan = undefined;\\n        }\\n        if (undefined === maxSpan) {\\n            maxSpan = -1;\\n        }\\n        else if (!Number.isInteger(maxSpan)) {\\n            throw new TypeError('maxSpan must be an integer');\\n        }\\n        super(-1, property);\\n        /** The maximum span of the layout in bytes.\\n         *\\n         * Positive values are generally expected.  Zero is abnormal.\\n         * Attempts to encode or decode a value that exceeds this length\\n         * will throw a `RangeError`.\\n         *\\n         * A negative value indicates that there is no bound on the length\\n         * of the content. */\\n        this.maxSpan = maxSpan;\\n    }\\n    /** @override */\\n    getSpan(b, offset = 0) {\\n        checkUint8Array(b);\\n        return b.length - offset;\\n    }\\n    /** @override */\\n    decode(b, offset = 0) {\\n        const span = this.getSpan(b, offset);\\n        if ((0 <= this.maxSpan)\\n            && (this.maxSpan < span)) {\\n            throw new RangeError('text length exceeds maxSpan');\\n        }\\n        return uint8ArrayToBuffer(b).slice(offset, offset + span).toString('utf-8');\\n    }\\n    /** @override */\\n    encode(src, b, offset = 0) {\\n        /* Must force this to a string, lest it be a number and the\\n         * \\\"utf8-encoding\\\" below actually allocate a buffer of length\\n         * src */\\n        if ('string' !== typeof src) {\\n            src = String(src);\\n        }\\n        const srcb = buffer_1.Buffer.from(src, 'utf8');\\n        const span = srcb.length;\\n        if ((0 <= this.maxSpan)\\n            && (this.maxSpan < span)) {\\n            throw new RangeError('text length exceeds maxSpan');\\n        }\\n        if ((offset + span) > b.length) {\\n            throw new RangeError('encoding overruns Buffer');\\n        }\\n        srcb.copy(uint8ArrayToBuffer(b), offset);\\n        return span;\\n    }\\n}\\nexports.UTF8 = UTF8;\\n/**\\n * Contain a constant value.\\n *\\n * This layout may be used in cases where a JavaScript value can be\\n * inferred without an expression in the binary encoding.  An example\\n * would be a {@link VariantLayout|variant layout} where the content\\n * is implied by the union {@link Union#discriminator|discriminator}.\\n *\\n * @param {Object|Number|String} value - initializer for {@link\\n * Constant#value|value}.  If the value is an object (or array) and\\n * the application intends the object to remain unchanged regardless\\n * of what is done to values decoded by this layout, the value should\\n * be frozen prior passing it to this constructor.\\n *\\n * @param {String} [property] - initializer for {@link\\n * Layout#property|property}.\\n *\\n * @augments {Layout}\\n */\\nclass Constant extends Layout {\\n    constructor(value, property) {\\n        super(0, property);\\n        /** The value produced by this constant when the layout is {@link\\n         * Constant#decode|decoded}.\\n         *\\n         * Any JavaScript value including `null` and `undefined` is\\n         * permitted.\\n         *\\n         * **WARNING** If `value` passed in the constructor was not\\n         * frozen, it is possible for users of decoded values to change\\n         * the content of the value. */\\n        this.value = value;\\n    }\\n    /** @override */\\n    decode(b, offset) {\\n        return this.value;\\n    }\\n    /** @override */\\n    encode(src, b, offset) {\\n        /* Constants take no space */\\n        return 0;\\n    }\\n}\\nexports.Constant = Constant;\\n/** Factory for {@link GreedyCount}. */\\nexports.greedy = ((elementSpan, property) => new GreedyCount(elementSpan, property));\\n/** Factory for {@link OffsetLayout}. */\\nexports.offset = ((layout, offset, property) => new OffsetLayout(layout, offset, property));\\n/** Factory for {@link UInt|unsigned int layouts} spanning one\\n * byte. */\\nexports.u8 = ((property) => new UInt(1, property));\\n/** Factory for {@link UInt|little-endian unsigned int layouts}\\n * spanning two bytes. */\\nexports.u16 = ((property) => new UInt(2, property));\\n/** Factory for {@link UInt|little-endian unsigned int layouts}\\n * spanning three bytes. */\\nexports.u24 = ((property) => new UInt(3, property));\\n/** Factory for {@link UInt|little-endian unsigned int layouts}\\n * spanning four bytes. */\\nexports.u32 = ((property) => new UInt(4, property));\\n/** Factory for {@link UInt|little-endian unsigned int layouts}\\n * spanning five bytes. */\\nexports.u40 = ((property) => new UInt(5, property));\\n/** Factory for {@link UInt|little-endian unsigned int layouts}\\n * spanning six bytes. */\\nexports.u48 = ((property) => new UInt(6, property));\\n/** Factory for {@link NearUInt64|little-endian unsigned int\\n * layouts} interpreted as Numbers. */\\nexports.nu64 = ((property) => new NearUInt64(property));\\n/** Factory for {@link UInt|big-endian unsigned int layouts}\\n * spanning two bytes. */\\nexports.u16be = ((property) => new UIntBE(2, property));\\n/** Factory for {@link UInt|big-endian unsigned int layouts}\\n * spanning three bytes. */\\nexports.u24be = ((property) => new UIntBE(3, property));\\n/** Factory for {@link UInt|big-endian unsigned int layouts}\\n * spanning four bytes. */\\nexports.u32be = ((property) => new UIntBE(4, property));\\n/** Factory for {@link UInt|big-endian unsigned int layouts}\\n * spanning five bytes. */\\nexports.u40be = ((property) => new UIntBE(5, property));\\n/** Factory for {@link UInt|big-endian unsigned int layouts}\\n * spanning six bytes. */\\nexports.u48be = ((property) => new UIntBE(6, property));\\n/** Factory for {@link NearUInt64BE|big-endian unsigned int\\n * layouts} interpreted as Numbers. */\\nexports.nu64be = ((property) => new NearUInt64BE(property));\\n/** Factory for {@link Int|signed int layouts} spanning one\\n * byte. */\\nexports.s8 = ((property) => new Int(1, property));\\n/** Factory for {@link Int|little-endian signed int layouts}\\n * spanning two bytes. */\\nexports.s16 = ((property) => new Int(2, property));\\n/** Factory for {@link Int|little-endian signed int layouts}\\n * spanning three bytes. */\\nexports.s24 = ((property) => new Int(3, property));\\n/** Factory for {@link Int|little-endian signed int layouts}\\n * spanning four bytes. */\\nexports.s32 = ((property) => new Int(4, property));\\n/** Factory for {@link Int|little-endian signed int layouts}\\n * spanning five bytes. */\\nexports.s40 = ((property) => new Int(5, property));\\n/** Factory for {@link Int|little-endian signed int layouts}\\n * spanning six bytes. */\\nexports.s48 = ((property) => new Int(6, property));\\n/** Factory for {@link NearInt64|little-endian signed int layouts}\\n * interpreted as Numbers. */\\nexports.ns64 = ((property) => new NearInt64(property));\\n/** Factory for {@link Int|big-endian signed int layouts}\\n * spanning two bytes. */\\nexports.s16be = ((property) => new IntBE(2, property));\\n/** Factory for {@link Int|big-endian signed int layouts}\\n * spanning three bytes. */\\nexports.s24be = ((property) => new IntBE(3, property));\\n/** Factory for {@link Int|big-endian signed int layouts}\\n * spanning four bytes. */\\nexports.s32be = ((property) => new IntBE(4, property));\\n/** Factory for {@link Int|big-endian signed int layouts}\\n * spanning five bytes. */\\nexports.s40be = ((property) => new IntBE(5, property));\\n/** Factory for {@link Int|big-endian signed int layouts}\\n * spanning six bytes. */\\nexports.s48be = ((property) => new IntBE(6, property));\\n/** Factory for {@link NearInt64BE|big-endian signed int layouts}\\n * interpreted as Numbers. */\\nexports.ns64be = ((property) => new NearInt64BE(property));\\n/** Factory for {@link Float|little-endian 32-bit floating point} values. */\\nexports.f32 = ((property) => new Float(property));\\n/** Factory for {@link FloatBE|big-endian 32-bit floating point} values. */\\nexports.f32be = ((property) => new FloatBE(property));\\n/** Factory for {@link Double|little-endian 64-bit floating point} values. */\\nexports.f64 = ((property) => new Double(property));\\n/** Factory for {@link DoubleBE|big-endian 64-bit floating point} values. */\\nexports.f64be = ((property) => new DoubleBE(property));\\n/** Factory for {@link Structure} values. */\\nexports.struct = ((fields, property, decodePrefixes) => new Structure(fields, property, decodePrefixes));\\n/** Factory for {@link BitStructure} values. */\\nexports.bits = ((word, msb, property) => new BitStructure(word, msb, property));\\n/** Factory for {@link Sequence} values. */\\nexports.seq = ((elementLayout, count, property) => new Sequence(elementLayout, count, property));\\n/** Factory for {@link Union} values. */\\nexports.union = ((discr, defaultLayout, property) => new Union(discr, defaultLayout, property));\\n/** Factory for {@link UnionLayoutDiscriminator} values. */\\nexports.unionLayoutDiscriminator = ((layout, property) => new UnionLayoutDiscriminator(layout, property));\\n/** Factory for {@link Blob} values. */\\nexports.blob = ((length, property) => new Blob(length, property));\\n/** Factory for {@link CString} values. */\\nexports.cstr = ((property) => new CString(property));\\n/** Factory for {@link UTF8} values. */\\nexports.utf8 = ((maxSpan, property) => new UTF8(maxSpan, property));\\n/** Factory for {@link Constant} values. */\\nexports.constant = ((value, property) => new Constant(value, property));\\n//# sourceMappingURL=Layout.js.map\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@solana/buffer-layout/lib/Layout.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/@solana/web3.js/lib/index.browser.esm.js\":\n/*!***************************************************************!*\\\n  !*** ./node_modules/@solana/web3.js/lib/index.browser.esm.js ***!\n  \\***************************************************************/\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"Account\\\": () => (/* binding */ Account),\\n/* harmony export */   \\\"AddressLookupTableAccount\\\": () => (/* binding */ AddressLookupTableAccount),\\n/* harmony export */   \\\"AddressLookupTableInstruction\\\": () => (/* binding */ AddressLookupTableInstruction),\\n/* harmony export */   \\\"AddressLookupTableProgram\\\": () => (/* binding */ AddressLookupTableProgram),\\n/* harmony export */   \\\"Authorized\\\": () => (/* binding */ Authorized),\\n/* harmony export */   \\\"BLOCKHASH_CACHE_TIMEOUT_MS\\\": () => (/* binding */ BLOCKHASH_CACHE_TIMEOUT_MS),\\n/* harmony export */   \\\"BPF_LOADER_DEPRECATED_PROGRAM_ID\\\": () => (/* binding */ BPF_LOADER_DEPRECATED_PROGRAM_ID),\\n/* harmony export */   \\\"BPF_LOADER_PROGRAM_ID\\\": () => (/* binding */ BPF_LOADER_PROGRAM_ID),\\n/* harmony export */   \\\"BpfLoader\\\": () => (/* binding */ BpfLoader),\\n/* harmony export */   \\\"COMPUTE_BUDGET_INSTRUCTION_LAYOUTS\\\": () => (/* binding */ COMPUTE_BUDGET_INSTRUCTION_LAYOUTS),\\n/* harmony export */   \\\"ComputeBudgetInstruction\\\": () => (/* binding */ ComputeBudgetInstruction),\\n/* harmony export */   \\\"ComputeBudgetProgram\\\": () => (/* binding */ ComputeBudgetProgram),\\n/* harmony export */   \\\"Connection\\\": () => (/* binding */ Connection),\\n/* harmony export */   \\\"Ed25519Program\\\": () => (/* binding */ Ed25519Program),\\n/* harmony export */   \\\"Enum\\\": () => (/* binding */ Enum),\\n/* harmony export */   \\\"EpochSchedule\\\": () => (/* binding */ EpochSchedule),\\n/* harmony export */   \\\"FeeCalculatorLayout\\\": () => (/* binding */ FeeCalculatorLayout),\\n/* harmony export */   \\\"Keypair\\\": () => (/* binding */ Keypair),\\n/* harmony export */   \\\"LAMPORTS_PER_SOL\\\": () => (/* binding */ LAMPORTS_PER_SOL),\\n/* harmony export */   \\\"LOOKUP_TABLE_INSTRUCTION_LAYOUTS\\\": () => (/* binding */ LOOKUP_TABLE_INSTRUCTION_LAYOUTS),\\n/* harmony export */   \\\"Loader\\\": () => (/* binding */ Loader),\\n/* harmony export */   \\\"Lockup\\\": () => (/* binding */ Lockup),\\n/* harmony export */   \\\"MAX_SEED_LENGTH\\\": () => (/* binding */ MAX_SEED_LENGTH),\\n/* harmony export */   \\\"Message\\\": () => (/* binding */ Message),\\n/* harmony export */   \\\"MessageAccountKeys\\\": () => (/* binding */ MessageAccountKeys),\\n/* harmony export */   \\\"MessageV0\\\": () => (/* binding */ MessageV0),\\n/* harmony export */   \\\"NONCE_ACCOUNT_LENGTH\\\": () => (/* binding */ NONCE_ACCOUNT_LENGTH),\\n/* harmony export */   \\\"NonceAccount\\\": () => (/* binding */ NonceAccount),\\n/* harmony export */   \\\"PACKET_DATA_SIZE\\\": () => (/* binding */ PACKET_DATA_SIZE),\\n/* harmony export */   \\\"PUBLIC_KEY_LENGTH\\\": () => (/* binding */ PUBLIC_KEY_LENGTH),\\n/* harmony export */   \\\"PublicKey\\\": () => (/* binding */ PublicKey),\\n/* harmony export */   \\\"SIGNATURE_LENGTH_IN_BYTES\\\": () => (/* binding */ SIGNATURE_LENGTH_IN_BYTES),\\n/* harmony export */   \\\"SOLANA_SCHEMA\\\": () => (/* binding */ SOLANA_SCHEMA),\\n/* harmony export */   \\\"STAKE_CONFIG_ID\\\": () => (/* binding */ STAKE_CONFIG_ID),\\n/* harmony export */   \\\"STAKE_INSTRUCTION_LAYOUTS\\\": () => (/* binding */ STAKE_INSTRUCTION_LAYOUTS),\\n/* harmony export */   \\\"SYSTEM_INSTRUCTION_LAYOUTS\\\": () => (/* binding */ SYSTEM_INSTRUCTION_LAYOUTS),\\n/* harmony export */   \\\"SYSVAR_CLOCK_PUBKEY\\\": () => (/* binding */ SYSVAR_CLOCK_PUBKEY),\\n/* harmony export */   \\\"SYSVAR_EPOCH_SCHEDULE_PUBKEY\\\": () => (/* binding */ SYSVAR_EPOCH_SCHEDULE_PUBKEY),\\n/* harmony export */   \\\"SYSVAR_INSTRUCTIONS_PUBKEY\\\": () => (/* binding */ SYSVAR_INSTRUCTIONS_PUBKEY),\\n/* harmony export */   \\\"SYSVAR_RECENT_BLOCKHASHES_PUBKEY\\\": () => (/* binding */ SYSVAR_RECENT_BLOCKHASHES_PUBKEY),\\n/* harmony export */   \\\"SYSVAR_RENT_PUBKEY\\\": () => (/* binding */ SYSVAR_RENT_PUBKEY),\\n/* harmony export */   \\\"SYSVAR_REWARDS_PUBKEY\\\": () => (/* binding */ SYSVAR_REWARDS_PUBKEY),\\n/* harmony export */   \\\"SYSVAR_SLOT_HASHES_PUBKEY\\\": () => (/* binding */ SYSVAR_SLOT_HASHES_PUBKEY),\\n/* harmony export */   \\\"SYSVAR_SLOT_HISTORY_PUBKEY\\\": () => (/* binding */ SYSVAR_SLOT_HISTORY_PUBKEY),\\n/* harmony export */   \\\"SYSVAR_STAKE_HISTORY_PUBKEY\\\": () => (/* binding */ SYSVAR_STAKE_HISTORY_PUBKEY),\\n/* harmony export */   \\\"Secp256k1Program\\\": () => (/* binding */ Secp256k1Program),\\n/* harmony export */   \\\"SendTransactionError\\\": () => (/* binding */ SendTransactionError),\\n/* harmony export */   \\\"SolanaJSONRPCError\\\": () => (/* binding */ SolanaJSONRPCError),\\n/* harmony export */   \\\"SolanaJSONRPCErrorCode\\\": () => (/* binding */ SolanaJSONRPCErrorCode),\\n/* harmony export */   \\\"StakeAuthorizationLayout\\\": () => (/* binding */ StakeAuthorizationLayout),\\n/* harmony export */   \\\"StakeInstruction\\\": () => (/* binding */ StakeInstruction),\\n/* harmony export */   \\\"StakeProgram\\\": () => (/* binding */ StakeProgram),\\n/* harmony export */   \\\"Struct\\\": () => (/* binding */ Struct),\\n/* harmony export */   \\\"SystemInstruction\\\": () => (/* binding */ SystemInstruction),\\n/* harmony export */   \\\"SystemProgram\\\": () => (/* binding */ SystemProgram),\\n/* harmony export */   \\\"Transaction\\\": () => (/* binding */ Transaction),\\n/* harmony export */   \\\"TransactionExpiredBlockheightExceededError\\\": () => (/* binding */ TransactionExpiredBlockheightExceededError),\\n/* harmony export */   \\\"TransactionExpiredNonceInvalidError\\\": () => (/* binding */ TransactionExpiredNonceInvalidError),\\n/* harmony export */   \\\"TransactionExpiredTimeoutError\\\": () => (/* binding */ TransactionExpiredTimeoutError),\\n/* harmony export */   \\\"TransactionInstruction\\\": () => (/* binding */ TransactionInstruction),\\n/* harmony export */   \\\"TransactionMessage\\\": () => (/* binding */ TransactionMessage),\\n/* harmony export */   \\\"TransactionStatus\\\": () => (/* binding */ TransactionStatus),\\n/* harmony export */   \\\"VALIDATOR_INFO_KEY\\\": () => (/* binding */ VALIDATOR_INFO_KEY),\\n/* harmony export */   \\\"VERSION_PREFIX_MASK\\\": () => (/* binding */ VERSION_PREFIX_MASK),\\n/* harmony export */   \\\"VOTE_PROGRAM_ID\\\": () => (/* binding */ VOTE_PROGRAM_ID),\\n/* harmony export */   \\\"ValidatorInfo\\\": () => (/* binding */ ValidatorInfo),\\n/* harmony export */   \\\"VersionedMessage\\\": () => (/* binding */ VersionedMessage),\\n/* harmony export */   \\\"VersionedTransaction\\\": () => (/* binding */ VersionedTransaction),\\n/* harmony export */   \\\"VoteAccount\\\": () => (/* binding */ VoteAccount),\\n/* harmony export */   \\\"VoteAuthorizationLayout\\\": () => (/* binding */ VoteAuthorizationLayout),\\n/* harmony export */   \\\"VoteInit\\\": () => (/* binding */ VoteInit),\\n/* harmony export */   \\\"VoteInstruction\\\": () => (/* binding */ VoteInstruction),\\n/* harmony export */   \\\"VoteProgram\\\": () => (/* binding */ VoteProgram),\\n/* harmony export */   \\\"clusterApiUrl\\\": () => (/* binding */ clusterApiUrl),\\n/* harmony export */   \\\"sendAndConfirmRawTransaction\\\": () => (/* binding */ sendAndConfirmRawTransaction),\\n/* harmony export */   \\\"sendAndConfirmTransaction\\\": () => (/* binding */ sendAndConfirmTransaction)\\n/* harmony export */ });\\n/* harmony import */ var buffer__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! buffer */ \\\"./node_modules/@solana/web3.js/node_modules/buffer/index.js\\\");\\n/* harmony import */ var _noble_hashes_sha512__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @noble/hashes/sha512 */ \\\"./node_modules/@noble/hashes/esm/sha512.js\\\");\\n/* harmony import */ var _noble_ed25519__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @noble/ed25519 */ \\\"./node_modules/@noble/ed25519/lib/esm/index.js\\\");\\n/* harmony import */ var bn_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! bn.js */ \\\"./node_modules/bn.js/lib/bn.js\\\");\\n/* harmony import */ var bn_js__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(bn_js__WEBPACK_IMPORTED_MODULE_3__);\\n/* harmony import */ var bs58__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! bs58 */ \\\"./node_modules/bs58/index.js\\\");\\n/* harmony import */ var bs58__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(bs58__WEBPACK_IMPORTED_MODULE_4__);\\n/* harmony import */ var _noble_hashes_sha256__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! @noble/hashes/sha256 */ \\\"./node_modules/@noble/hashes/esm/sha256.js\\\");\\n/* harmony import */ var borsh__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! borsh */ \\\"./node_modules/borsh/lib/index.js\\\");\\n/* harmony import */ var borsh__WEBPACK_IMPORTED_MODULE_6___default = /*#__PURE__*/__webpack_require__.n(borsh__WEBPACK_IMPORTED_MODULE_6__);\\n/* harmony import */ var _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! @solana/buffer-layout */ \\\"./node_modules/@solana/buffer-layout/lib/Layout.js\\\");\\n/* harmony import */ var bigint_buffer__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! bigint-buffer */ \\\"./node_modules/bigint-buffer/dist/browser.js\\\");\\n/* harmony import */ var superstruct__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! superstruct */ \\\"./node_modules/superstruct/lib/index.es.js\\\");\\n/* harmony import */ var rpc_websockets__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! rpc-websockets */ \\\"./node_modules/rpc-websockets/dist/index.browser.js\\\");\\n/* harmony import */ var jayson_lib_client_browser__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! jayson/lib/client/browser */ \\\"./node_modules/jayson/lib/client/browser/index.js\\\");\\n/* harmony import */ var jayson_lib_client_browser__WEBPACK_IMPORTED_MODULE_10___default = /*#__PURE__*/__webpack_require__.n(jayson_lib_client_browser__WEBPACK_IMPORTED_MODULE_10__);\\n/* harmony import */ var _noble_hashes_sha3__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! @noble/hashes/sha3 */ \\\"./node_modules/@noble/hashes/esm/sha3.js\\\");\\n/* harmony import */ var _noble_hashes_hmac__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! @noble/hashes/hmac */ \\\"./node_modules/@noble/hashes/esm/hmac.js\\\");\\n/* harmony import */ var _noble_secp256k1__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! @noble/secp256k1 */ \\\"./node_modules/@noble/secp256k1/lib/esm/index.js\\\");\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n/**\\n * A 64 byte secret key, the first 32 bytes of which is the\\n * private scalar and the last 32 bytes is the public key.\\n * Read more: https://blog.mozilla.org/warner/2011/11/29/ed25519-keys/\\n */\\n\\n_noble_ed25519__WEBPACK_IMPORTED_MODULE_2__.utils.sha512Sync = (...m) => (0,_noble_hashes_sha512__WEBPACK_IMPORTED_MODULE_1__.sha512)(_noble_ed25519__WEBPACK_IMPORTED_MODULE_2__.utils.concatBytes(...m));\\n\\nconst generatePrivateKey = _noble_ed25519__WEBPACK_IMPORTED_MODULE_2__.utils.randomPrivateKey;\\nconst generateKeypair = () => {\\n  const privateScalar = _noble_ed25519__WEBPACK_IMPORTED_MODULE_2__.utils.randomPrivateKey();\\n  const publicKey = getPublicKey(privateScalar);\\n  const secretKey = new Uint8Array(64);\\n  secretKey.set(privateScalar);\\n  secretKey.set(publicKey, 32);\\n  return {\\n    publicKey,\\n    secretKey\\n  };\\n};\\nconst getPublicKey = _noble_ed25519__WEBPACK_IMPORTED_MODULE_2__.sync.getPublicKey;\\nfunction isOnCurve(publicKey) {\\n  try {\\n    _noble_ed25519__WEBPACK_IMPORTED_MODULE_2__.Point.fromHex(publicKey, true\\n    /* strict */\\n    );\\n    return true;\\n  } catch {\\n    return false;\\n  }\\n}\\nconst sign = (message, secretKey) => _noble_ed25519__WEBPACK_IMPORTED_MODULE_2__.sync.sign(message, secretKey.slice(0, 32));\\nconst verify = _noble_ed25519__WEBPACK_IMPORTED_MODULE_2__.sync.verify;\\n\\nconst toBuffer = arr => {\\n  if (buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.isBuffer(arr)) {\\n    return arr;\\n  } else if (arr instanceof Uint8Array) {\\n    return buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.from(arr.buffer, arr.byteOffset, arr.byteLength);\\n  } else {\\n    return buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.from(arr);\\n  }\\n};\\n\\nclass Struct {\\n  constructor(properties) {\\n    Object.assign(this, properties);\\n  }\\n\\n  encode() {\\n    return buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.from((0,borsh__WEBPACK_IMPORTED_MODULE_6__.serialize)(SOLANA_SCHEMA, this));\\n  }\\n\\n  static decode(data) {\\n    return (0,borsh__WEBPACK_IMPORTED_MODULE_6__.deserialize)(SOLANA_SCHEMA, this, data);\\n  }\\n\\n  static decodeUnchecked(data) {\\n    return (0,borsh__WEBPACK_IMPORTED_MODULE_6__.deserializeUnchecked)(SOLANA_SCHEMA, this, data);\\n  }\\n\\n} // Class representing a Rust-compatible enum, since enums are only strings or\\n// numbers in pure JS\\n\\nclass Enum extends Struct {\\n  constructor(properties) {\\n    super(properties);\\n    this.enum = '';\\n\\n    if (Object.keys(properties).length !== 1) {\\n      throw new Error('Enum can only take single value');\\n    }\\n\\n    Object.keys(properties).map(key => {\\n      this.enum = key;\\n    });\\n  }\\n\\n}\\nconst SOLANA_SCHEMA = new Map();\\n\\n/**\\n * Maximum length of derived pubkey seed\\n */\\n\\nconst MAX_SEED_LENGTH = 32;\\n/**\\n * Size of public key in bytes\\n */\\n\\nconst PUBLIC_KEY_LENGTH = 32;\\n/**\\n * Value to be converted into public key\\n */\\n\\nfunction isPublicKeyData(value) {\\n  return value._bn !== undefined;\\n} // local counter used by PublicKey.unique()\\n\\n\\nlet uniquePublicKeyCounter = 1;\\n/**\\n * A public key\\n */\\n\\nclass PublicKey extends Struct {\\n  /** @internal */\\n\\n  /**\\n   * Create a new PublicKey object\\n   * @param value ed25519 public key as buffer or base-58 encoded string\\n   */\\n  constructor(value) {\\n    super({});\\n    this._bn = void 0;\\n\\n    if (isPublicKeyData(value)) {\\n      this._bn = value._bn;\\n    } else {\\n      if (typeof value === 'string') {\\n        // assume base 58 encoding by default\\n        const decoded = bs58__WEBPACK_IMPORTED_MODULE_4___default().decode(value);\\n\\n        if (decoded.length != PUBLIC_KEY_LENGTH) {\\n          throw new Error(`Invalid public key input`);\\n        }\\n\\n        this._bn = new (bn_js__WEBPACK_IMPORTED_MODULE_3___default())(decoded);\\n      } else {\\n        this._bn = new (bn_js__WEBPACK_IMPORTED_MODULE_3___default())(value);\\n      }\\n\\n      if (this._bn.byteLength() > PUBLIC_KEY_LENGTH) {\\n        throw new Error(`Invalid public key input`);\\n      }\\n    }\\n  }\\n  /**\\n   * Returns a unique PublicKey for tests and benchmarks using a counter\\n   */\\n\\n\\n  static unique() {\\n    const key = new PublicKey(uniquePublicKeyCounter);\\n    uniquePublicKeyCounter += 1;\\n    return new PublicKey(key.toBuffer());\\n  }\\n  /**\\n   * Default public key value. The base58-encoded string representation is all ones (as seen below)\\n   * The underlying BN number is 32 bytes that are all zeros\\n   */\\n\\n\\n  /**\\n   * Checks if two publicKeys are equal\\n   */\\n  equals(publicKey) {\\n    return this._bn.eq(publicKey._bn);\\n  }\\n  /**\\n   * Return the base-58 representation of the public key\\n   */\\n\\n\\n  toBase58() {\\n    return bs58__WEBPACK_IMPORTED_MODULE_4___default().encode(this.toBytes());\\n  }\\n\\n  toJSON() {\\n    return this.toBase58();\\n  }\\n  /**\\n   * Return the byte array representation of the public key\\n   */\\n\\n\\n  toBytes() {\\n    return this.toBuffer();\\n  }\\n  /**\\n   * Return the Buffer representation of the public key\\n   */\\n\\n\\n  toBuffer() {\\n    const b = this._bn.toArrayLike(buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer);\\n\\n    if (b.length === PUBLIC_KEY_LENGTH) {\\n      return b;\\n    }\\n\\n    const zeroPad = buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.alloc(32);\\n    b.copy(zeroPad, 32 - b.length);\\n    return zeroPad;\\n  }\\n  /**\\n   * Return the base-58 representation of the public key\\n   */\\n\\n\\n  toString() {\\n    return this.toBase58();\\n  }\\n  /**\\n   * Derive a public key from another key, a seed, and a program ID.\\n   * The program ID will also serve as the owner of the public key, giving\\n   * it permission to write data to the account.\\n   */\\n\\n  /* eslint-disable require-await */\\n\\n\\n  static async createWithSeed(fromPublicKey, seed, programId) {\\n    const buffer = buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.concat([fromPublicKey.toBuffer(), buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.from(seed), programId.toBuffer()]);\\n    const publicKeyBytes = (0,_noble_hashes_sha256__WEBPACK_IMPORTED_MODULE_5__.sha256)(buffer);\\n    return new PublicKey(publicKeyBytes);\\n  }\\n  /**\\n   * Derive a program address from seeds and a program ID.\\n   */\\n\\n  /* eslint-disable require-await */\\n\\n\\n  static createProgramAddressSync(seeds, programId) {\\n    let buffer = buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.alloc(0);\\n    seeds.forEach(function (seed) {\\n      if (seed.length > MAX_SEED_LENGTH) {\\n        throw new TypeError(`Max seed length exceeded`);\\n      }\\n\\n      buffer = buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.concat([buffer, toBuffer(seed)]);\\n    });\\n    buffer = buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.concat([buffer, programId.toBuffer(), buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.from('ProgramDerivedAddress')]);\\n    const publicKeyBytes = (0,_noble_hashes_sha256__WEBPACK_IMPORTED_MODULE_5__.sha256)(buffer);\\n\\n    if (isOnCurve(publicKeyBytes)) {\\n      throw new Error(`Invalid seeds, address must fall off the curve`);\\n    }\\n\\n    return new PublicKey(publicKeyBytes);\\n  }\\n  /**\\n   * Async version of createProgramAddressSync\\n   * For backwards compatibility\\n   *\\n   * @deprecated Use {@link createProgramAddressSync} instead\\n   */\\n\\n  /* eslint-disable require-await */\\n\\n\\n  static async createProgramAddress(seeds, programId) {\\n    return this.createProgramAddressSync(seeds, programId);\\n  }\\n  /**\\n   * Find a valid program address\\n   *\\n   * Valid program addresses must fall off the ed25519 curve.  This function\\n   * iterates a nonce until it finds one that when combined with the seeds\\n   * results in a valid program address.\\n   */\\n\\n\\n  static findProgramAddressSync(seeds, programId) {\\n    let nonce = 255;\\n    let address;\\n\\n    while (nonce != 0) {\\n      try {\\n        const seedsWithNonce = seeds.concat(buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.from([nonce]));\\n        address = this.createProgramAddressSync(seedsWithNonce, programId);\\n      } catch (err) {\\n        if (err instanceof TypeError) {\\n          throw err;\\n        }\\n\\n        nonce--;\\n        continue;\\n      }\\n\\n      return [address, nonce];\\n    }\\n\\n    throw new Error(`Unable to find a viable program address nonce`);\\n  }\\n  /**\\n   * Async version of findProgramAddressSync\\n   * For backwards compatibility\\n   *\\n   * @deprecated Use {@link findProgramAddressSync} instead\\n   */\\n\\n\\n  static async findProgramAddress(seeds, programId) {\\n    return this.findProgramAddressSync(seeds, programId);\\n  }\\n  /**\\n   * Check that a pubkey is on the ed25519 curve.\\n   */\\n\\n\\n  static isOnCurve(pubkeyData) {\\n    const pubkey = new PublicKey(pubkeyData);\\n    return isOnCurve(pubkey.toBytes());\\n  }\\n\\n}\\nPublicKey.default = new PublicKey('11111111111111111111111111111111');\\nSOLANA_SCHEMA.set(PublicKey, {\\n  kind: 'struct',\\n  fields: [['_bn', 'u256']]\\n});\\n\\n/**\\n * An account key pair (public and secret keys).\\n *\\n * @deprecated since v1.10.0, please use {@link Keypair} instead.\\n */\\n\\nclass Account {\\n  /** @internal */\\n\\n  /** @internal */\\n\\n  /**\\n   * Create a new Account object\\n   *\\n   * If the secretKey parameter is not provided a new key pair is randomly\\n   * created for the account\\n   *\\n   * @param secretKey Secret key for the account\\n   */\\n  constructor(secretKey) {\\n    this._publicKey = void 0;\\n    this._secretKey = void 0;\\n\\n    if (secretKey) {\\n      const secretKeyBuffer = toBuffer(secretKey);\\n\\n      if (secretKey.length !== 64) {\\n        throw new Error('bad secret key size');\\n      }\\n\\n      this._publicKey = secretKeyBuffer.slice(32, 64);\\n      this._secretKey = secretKeyBuffer.slice(0, 32);\\n    } else {\\n      this._secretKey = toBuffer(generatePrivateKey());\\n      this._publicKey = toBuffer(getPublicKey(this._secretKey));\\n    }\\n  }\\n  /**\\n   * The public key for this account\\n   */\\n\\n\\n  get publicKey() {\\n    return new PublicKey(this._publicKey);\\n  }\\n  /**\\n   * The **unencrypted** secret key for this account. The first 32 bytes\\n   * is the private scalar and the last 32 bytes is the public key.\\n   * Read more: https://blog.mozilla.org/warner/2011/11/29/ed25519-keys/\\n   */\\n\\n\\n  get secretKey() {\\n    return buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.concat([this._secretKey, this._publicKey], 64);\\n  }\\n\\n}\\n\\nconst BPF_LOADER_DEPRECATED_PROGRAM_ID = new PublicKey('BPFLoader1111111111111111111111111111111111');\\n\\n/**\\n * Maximum over-the-wire size of a Transaction\\n *\\n * 1280 is IPv6 minimum MTU\\n * 40 bytes is the size of the IPv6 header\\n * 8 bytes is the size of the fragment header\\n */\\nconst PACKET_DATA_SIZE = 1280 - 40 - 8;\\nconst VERSION_PREFIX_MASK = 0x7f;\\nconst SIGNATURE_LENGTH_IN_BYTES = 64;\\n\\nclass TransactionExpiredBlockheightExceededError extends Error {\\n  constructor(signature) {\\n    super(`Signature ${signature} has expired: block height exceeded.`);\\n    this.signature = void 0;\\n    this.signature = signature;\\n  }\\n\\n}\\nObject.defineProperty(TransactionExpiredBlockheightExceededError.prototype, 'name', {\\n  value: 'TransactionExpiredBlockheightExceededError'\\n});\\nclass TransactionExpiredTimeoutError extends Error {\\n  constructor(signature, timeoutSeconds) {\\n    super(`Transaction was not confirmed in ${timeoutSeconds.toFixed(2)} seconds. It is ` + 'unknown if it succeeded or failed. Check signature ' + `${signature} using the Solana Explorer or CLI tools.`);\\n    this.signature = void 0;\\n    this.signature = signature;\\n  }\\n\\n}\\nObject.defineProperty(TransactionExpiredTimeoutError.prototype, 'name', {\\n  value: 'TransactionExpiredTimeoutError'\\n});\\nclass TransactionExpiredNonceInvalidError extends Error {\\n  constructor(signature) {\\n    super(`Signature ${signature} has expired: the nonce is no longer valid.`);\\n    this.signature = void 0;\\n    this.signature = signature;\\n  }\\n\\n}\\nObject.defineProperty(TransactionExpiredNonceInvalidError.prototype, 'name', {\\n  value: 'TransactionExpiredNonceInvalidError'\\n});\\n\\nclass MessageAccountKeys {\\n  constructor(staticAccountKeys, accountKeysFromLookups) {\\n    this.staticAccountKeys = void 0;\\n    this.accountKeysFromLookups = void 0;\\n    this.staticAccountKeys = staticAccountKeys;\\n    this.accountKeysFromLookups = accountKeysFromLookups;\\n  }\\n\\n  keySegments() {\\n    const keySegments = [this.staticAccountKeys];\\n\\n    if (this.accountKeysFromLookups) {\\n      keySegments.push(this.accountKeysFromLookups.writable);\\n      keySegments.push(this.accountKeysFromLookups.readonly);\\n    }\\n\\n    return keySegments;\\n  }\\n\\n  get(index) {\\n    for (const keySegment of this.keySegments()) {\\n      if (index < keySegment.length) {\\n        return keySegment[index];\\n      } else {\\n        index -= keySegment.length;\\n      }\\n    }\\n\\n    return;\\n  }\\n\\n  get length() {\\n    return this.keySegments().flat().length;\\n  }\\n\\n  compileInstructions(instructions) {\\n    // Bail early if any account indexes would overflow a u8\\n    const U8_MAX = 255;\\n\\n    if (this.length > U8_MAX + 1) {\\n      throw new Error('Account index overflow encountered during compilation');\\n    }\\n\\n    const keyIndexMap = new Map();\\n    this.keySegments().flat().forEach((key, index) => {\\n      keyIndexMap.set(key.toBase58(), index);\\n    });\\n\\n    const findKeyIndex = key => {\\n      const keyIndex = keyIndexMap.get(key.toBase58());\\n      if (keyIndex === undefined) throw new Error('Encountered an unknown instruction account key during compilation');\\n      return keyIndex;\\n    };\\n\\n    return instructions.map(instruction => {\\n      return {\\n        programIdIndex: findKeyIndex(instruction.programId),\\n        accountKeyIndexes: instruction.keys.map(meta => findKeyIndex(meta.pubkey)),\\n        data: instruction.data\\n      };\\n    });\\n  }\\n\\n}\\n\\n/**\\n * Layout for a public key\\n */\\nconst publicKey = (property = 'publicKey') => {\\n  return _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.blob(32, property);\\n};\\n/**\\n * Layout for a signature\\n */\\n\\nconst signature = (property = 'signature') => {\\n  return _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.blob(64, property);\\n};\\n\\n/**\\n * Layout for a Rust String type\\n */\\nconst rustString = (property = 'string') => {\\n  const rsl = _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('length'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('lengthPadding'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.blob(_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.offset(_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32(), -8), 'chars')], property);\\n\\n  const _decode = rsl.decode.bind(rsl);\\n\\n  const _encode = rsl.encode.bind(rsl);\\n\\n  const rslShim = rsl;\\n\\n  rslShim.decode = (b, offset) => {\\n    const data = _decode(b, offset);\\n\\n    return data['chars'].toString();\\n  };\\n\\n  rslShim.encode = (str, b, offset) => {\\n    const data = {\\n      chars: buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.from(str, 'utf8')\\n    };\\n    return _encode(data, b, offset);\\n  };\\n\\n  rslShim.alloc = str => {\\n    return _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32().span + _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32().span + buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.from(str, 'utf8').length;\\n  };\\n\\n  return rslShim;\\n};\\n/**\\n * Layout for an Authorized object\\n */\\n\\nconst authorized = (property = 'authorized') => {\\n  return _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([publicKey('staker'), publicKey('withdrawer')], property);\\n};\\n/**\\n * Layout for a Lockup object\\n */\\n\\nconst lockup = (property = 'lockup') => {\\n  return _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.ns64('unixTimestamp'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.ns64('epoch'), publicKey('custodian')], property);\\n};\\n/**\\n *  Layout for a VoteInit object\\n */\\n\\nconst voteInit = (property = 'voteInit') => {\\n  return _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([publicKey('nodePubkey'), publicKey('authorizedVoter'), publicKey('authorizedWithdrawer'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u8('commission')], property);\\n};\\n/**\\n *  Layout for a VoteAuthorizeWithSeedArgs object\\n */\\n\\nconst voteAuthorizeWithSeedArgs = (property = 'voteAuthorizeWithSeedArgs') => {\\n  return _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('voteAuthorizationType'), publicKey('currentAuthorityDerivedKeyOwnerPubkey'), rustString('currentAuthorityDerivedKeySeed'), publicKey('newAuthorized')], property);\\n};\\nfunction getAlloc(type, fields) {\\n  const getItemAlloc = item => {\\n    if (item.span >= 0) {\\n      return item.span;\\n    } else if (typeof item.alloc === 'function') {\\n      return item.alloc(fields[item.property]);\\n    } else if ('count' in item && 'elementLayout' in item) {\\n      const field = fields[item.property];\\n\\n      if (Array.isArray(field)) {\\n        return field.length * getItemAlloc(item.elementLayout);\\n      }\\n    } else if ('fields' in item) {\\n      // This is a `Structure` whose size needs to be recursively measured.\\n      return getAlloc({\\n        layout: item\\n      }, fields[item.property]);\\n    } // Couldn't determine allocated size of layout\\n\\n\\n    return 0;\\n  };\\n\\n  let alloc = 0;\\n  type.layout.fields.forEach(item => {\\n    alloc += getItemAlloc(item);\\n  });\\n  return alloc;\\n}\\n\\nfunction decodeLength(bytes) {\\n  let len = 0;\\n  let size = 0;\\n\\n  for (;;) {\\n    let elem = bytes.shift();\\n    len |= (elem & 0x7f) << size * 7;\\n    size += 1;\\n\\n    if ((elem & 0x80) === 0) {\\n      break;\\n    }\\n  }\\n\\n  return len;\\n}\\nfunction encodeLength(bytes, len) {\\n  let rem_len = len;\\n\\n  for (;;) {\\n    let elem = rem_len & 0x7f;\\n    rem_len >>= 7;\\n\\n    if (rem_len == 0) {\\n      bytes.push(elem);\\n      break;\\n    } else {\\n      elem |= 0x80;\\n      bytes.push(elem);\\n    }\\n  }\\n}\\n\\nfunction assert (condition, message) {\\n  if (!condition) {\\n    throw new Error(message || 'Assertion failed');\\n  }\\n}\\n\\nclass CompiledKeys {\\n  constructor(payer, keyMetaMap) {\\n    this.payer = void 0;\\n    this.keyMetaMap = void 0;\\n    this.payer = payer;\\n    this.keyMetaMap = keyMetaMap;\\n  }\\n\\n  static compile(instructions, payer) {\\n    const keyMetaMap = new Map();\\n\\n    const getOrInsertDefault = pubkey => {\\n      const address = pubkey.toBase58();\\n      let keyMeta = keyMetaMap.get(address);\\n\\n      if (keyMeta === undefined) {\\n        keyMeta = {\\n          isSigner: false,\\n          isWritable: false,\\n          isInvoked: false\\n        };\\n        keyMetaMap.set(address, keyMeta);\\n      }\\n\\n      return keyMeta;\\n    };\\n\\n    const payerKeyMeta = getOrInsertDefault(payer);\\n    payerKeyMeta.isSigner = true;\\n    payerKeyMeta.isWritable = true;\\n\\n    for (const ix of instructions) {\\n      getOrInsertDefault(ix.programId).isInvoked = true;\\n\\n      for (const accountMeta of ix.keys) {\\n        const keyMeta = getOrInsertDefault(accountMeta.pubkey);\\n        keyMeta.isSigner || (keyMeta.isSigner = accountMeta.isSigner);\\n        keyMeta.isWritable || (keyMeta.isWritable = accountMeta.isWritable);\\n      }\\n    }\\n\\n    return new CompiledKeys(payer, keyMetaMap);\\n  }\\n\\n  getMessageComponents() {\\n    const mapEntries = [...this.keyMetaMap.entries()];\\n    assert(mapEntries.length <= 256, 'Max static account keys length exceeded');\\n    const writableSigners = mapEntries.filter(([, meta]) => meta.isSigner && meta.isWritable);\\n    const readonlySigners = mapEntries.filter(([, meta]) => meta.isSigner && !meta.isWritable);\\n    const writableNonSigners = mapEntries.filter(([, meta]) => !meta.isSigner && meta.isWritable);\\n    const readonlyNonSigners = mapEntries.filter(([, meta]) => !meta.isSigner && !meta.isWritable);\\n    const header = {\\n      numRequiredSignatures: writableSigners.length + readonlySigners.length,\\n      numReadonlySignedAccounts: readonlySigners.length,\\n      numReadonlyUnsignedAccounts: readonlyNonSigners.length\\n    }; // sanity checks\\n\\n    {\\n      assert(writableSigners.length > 0, 'Expected at least one writable signer key');\\n      const [payerAddress] = writableSigners[0];\\n      assert(payerAddress === this.payer.toBase58(), 'Expected first writable signer key to be the fee payer');\\n    }\\n    const staticAccountKeys = [...writableSigners.map(([address]) => new PublicKey(address)), ...readonlySigners.map(([address]) => new PublicKey(address)), ...writableNonSigners.map(([address]) => new PublicKey(address)), ...readonlyNonSigners.map(([address]) => new PublicKey(address))];\\n    return [header, staticAccountKeys];\\n  }\\n\\n  extractTableLookup(lookupTable) {\\n    const [writableIndexes, drainedWritableKeys] = this.drainKeysFoundInLookupTable(lookupTable.state.addresses, keyMeta => !keyMeta.isSigner && !keyMeta.isInvoked && keyMeta.isWritable);\\n    const [readonlyIndexes, drainedReadonlyKeys] = this.drainKeysFoundInLookupTable(lookupTable.state.addresses, keyMeta => !keyMeta.isSigner && !keyMeta.isInvoked && !keyMeta.isWritable); // Don't extract lookup if no keys were found\\n\\n    if (writableIndexes.length === 0 && readonlyIndexes.length === 0) {\\n      return;\\n    }\\n\\n    return [{\\n      accountKey: lookupTable.key,\\n      writableIndexes,\\n      readonlyIndexes\\n    }, {\\n      writable: drainedWritableKeys,\\n      readonly: drainedReadonlyKeys\\n    }];\\n  }\\n  /** @internal */\\n\\n\\n  drainKeysFoundInLookupTable(lookupTableEntries, keyMetaFilter) {\\n    const lookupTableIndexes = new Array();\\n    const drainedKeys = new Array();\\n\\n    for (const [address, keyMeta] of this.keyMetaMap.entries()) {\\n      if (keyMetaFilter(keyMeta)) {\\n        const key = new PublicKey(address);\\n        const lookupTableIndex = lookupTableEntries.findIndex(entry => entry.equals(key));\\n\\n        if (lookupTableIndex >= 0) {\\n          assert(lookupTableIndex < 256, 'Max lookup table index exceeded');\\n          lookupTableIndexes.push(lookupTableIndex);\\n          drainedKeys.push(key);\\n          this.keyMetaMap.delete(address);\\n        }\\n      }\\n    }\\n\\n    return [lookupTableIndexes, drainedKeys];\\n  }\\n\\n}\\n\\n/**\\n * An instruction to execute by a program\\n *\\n * @property {number} programIdIndex\\n * @property {number[]} accounts\\n * @property {string} data\\n */\\n\\n/**\\n * List of instructions to be processed atomically\\n */\\nclass Message {\\n  constructor(args) {\\n    this.header = void 0;\\n    this.accountKeys = void 0;\\n    this.recentBlockhash = void 0;\\n    this.instructions = void 0;\\n    this.indexToProgramIds = new Map();\\n    this.header = args.header;\\n    this.accountKeys = args.accountKeys.map(account => new PublicKey(account));\\n    this.recentBlockhash = args.recentBlockhash;\\n    this.instructions = args.instructions;\\n    this.instructions.forEach(ix => this.indexToProgramIds.set(ix.programIdIndex, this.accountKeys[ix.programIdIndex]));\\n  }\\n\\n  get version() {\\n    return 'legacy';\\n  }\\n\\n  get staticAccountKeys() {\\n    return this.accountKeys;\\n  }\\n\\n  get compiledInstructions() {\\n    return this.instructions.map(ix => ({\\n      programIdIndex: ix.programIdIndex,\\n      accountKeyIndexes: ix.accounts,\\n      data: bs58__WEBPACK_IMPORTED_MODULE_4___default().decode(ix.data)\\n    }));\\n  }\\n\\n  get addressTableLookups() {\\n    return [];\\n  }\\n\\n  getAccountKeys() {\\n    return new MessageAccountKeys(this.staticAccountKeys);\\n  }\\n\\n  static compile(args) {\\n    const compiledKeys = CompiledKeys.compile(args.instructions, args.payerKey);\\n    const [header, staticAccountKeys] = compiledKeys.getMessageComponents();\\n    const accountKeys = new MessageAccountKeys(staticAccountKeys);\\n    const instructions = accountKeys.compileInstructions(args.instructions).map(ix => ({\\n      programIdIndex: ix.programIdIndex,\\n      accounts: ix.accountKeyIndexes,\\n      data: bs58__WEBPACK_IMPORTED_MODULE_4___default().encode(ix.data)\\n    }));\\n    return new Message({\\n      header,\\n      accountKeys: staticAccountKeys,\\n      recentBlockhash: args.recentBlockhash,\\n      instructions\\n    });\\n  }\\n\\n  isAccountSigner(index) {\\n    return index < this.header.numRequiredSignatures;\\n  }\\n\\n  isAccountWritable(index) {\\n    const numSignedAccounts = this.header.numRequiredSignatures;\\n\\n    if (index >= this.header.numRequiredSignatures) {\\n      const unsignedAccountIndex = index - numSignedAccounts;\\n      const numUnsignedAccounts = this.accountKeys.length - numSignedAccounts;\\n      const numWritableUnsignedAccounts = numUnsignedAccounts - this.header.numReadonlyUnsignedAccounts;\\n      return unsignedAccountIndex < numWritableUnsignedAccounts;\\n    } else {\\n      const numWritableSignedAccounts = numSignedAccounts - this.header.numReadonlySignedAccounts;\\n      return index < numWritableSignedAccounts;\\n    }\\n  }\\n\\n  isProgramId(index) {\\n    return this.indexToProgramIds.has(index);\\n  }\\n\\n  programIds() {\\n    return [...this.indexToProgramIds.values()];\\n  }\\n\\n  nonProgramIds() {\\n    return this.accountKeys.filter((_, index) => !this.isProgramId(index));\\n  }\\n\\n  serialize() {\\n    const numKeys = this.accountKeys.length;\\n    let keyCount = [];\\n    encodeLength(keyCount, numKeys);\\n    const instructions = this.instructions.map(instruction => {\\n      const {\\n        accounts,\\n        programIdIndex\\n      } = instruction;\\n      const data = Array.from(bs58__WEBPACK_IMPORTED_MODULE_4___default().decode(instruction.data));\\n      let keyIndicesCount = [];\\n      encodeLength(keyIndicesCount, accounts.length);\\n      let dataCount = [];\\n      encodeLength(dataCount, data.length);\\n      return {\\n        programIdIndex,\\n        keyIndicesCount: buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.from(keyIndicesCount),\\n        keyIndices: accounts,\\n        dataLength: buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.from(dataCount),\\n        data\\n      };\\n    });\\n    let instructionCount = [];\\n    encodeLength(instructionCount, instructions.length);\\n    let instructionBuffer = buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.alloc(PACKET_DATA_SIZE);\\n    buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.from(instructionCount).copy(instructionBuffer);\\n    let instructionBufferLength = instructionCount.length;\\n    instructions.forEach(instruction => {\\n      const instructionLayout = _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u8('programIdIndex'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.blob(instruction.keyIndicesCount.length, 'keyIndicesCount'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.seq(_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u8('keyIndex'), instruction.keyIndices.length, 'keyIndices'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.blob(instruction.dataLength.length, 'dataLength'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.seq(_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u8('userdatum'), instruction.data.length, 'data')]);\\n      const length = instructionLayout.encode(instruction, instructionBuffer, instructionBufferLength);\\n      instructionBufferLength += length;\\n    });\\n    instructionBuffer = instructionBuffer.slice(0, instructionBufferLength);\\n    const signDataLayout = _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.blob(1, 'numRequiredSignatures'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.blob(1, 'numReadonlySignedAccounts'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.blob(1, 'numReadonlyUnsignedAccounts'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.blob(keyCount.length, 'keyCount'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.seq(publicKey('key'), numKeys, 'keys'), publicKey('recentBlockhash')]);\\n    const transaction = {\\n      numRequiredSignatures: buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.from([this.header.numRequiredSignatures]),\\n      numReadonlySignedAccounts: buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.from([this.header.numReadonlySignedAccounts]),\\n      numReadonlyUnsignedAccounts: buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.from([this.header.numReadonlyUnsignedAccounts]),\\n      keyCount: buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.from(keyCount),\\n      keys: this.accountKeys.map(key => toBuffer(key.toBytes())),\\n      recentBlockhash: bs58__WEBPACK_IMPORTED_MODULE_4___default().decode(this.recentBlockhash)\\n    };\\n    let signData = buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.alloc(2048);\\n    const length = signDataLayout.encode(transaction, signData);\\n    instructionBuffer.copy(signData, length);\\n    return signData.slice(0, length + instructionBuffer.length);\\n  }\\n  /**\\n   * Decode a compiled message into a Message object.\\n   */\\n\\n\\n  static from(buffer) {\\n    // Slice up wire data\\n    let byteArray = [...buffer];\\n    const numRequiredSignatures = byteArray.shift();\\n\\n    if (numRequiredSignatures !== (numRequiredSignatures & VERSION_PREFIX_MASK)) {\\n      throw new Error('Versioned messages must be deserialized with VersionedMessage.deserialize()');\\n    }\\n\\n    const numReadonlySignedAccounts = byteArray.shift();\\n    const numReadonlyUnsignedAccounts = byteArray.shift();\\n    const accountCount = decodeLength(byteArray);\\n    let accountKeys = [];\\n\\n    for (let i = 0; i < accountCount; i++) {\\n      const account = byteArray.slice(0, PUBLIC_KEY_LENGTH);\\n      byteArray = byteArray.slice(PUBLIC_KEY_LENGTH);\\n      accountKeys.push(new PublicKey(buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.from(account)));\\n    }\\n\\n    const recentBlockhash = byteArray.slice(0, PUBLIC_KEY_LENGTH);\\n    byteArray = byteArray.slice(PUBLIC_KEY_LENGTH);\\n    const instructionCount = decodeLength(byteArray);\\n    let instructions = [];\\n\\n    for (let i = 0; i < instructionCount; i++) {\\n      const programIdIndex = byteArray.shift();\\n      const accountCount = decodeLength(byteArray);\\n      const accounts = byteArray.slice(0, accountCount);\\n      byteArray = byteArray.slice(accountCount);\\n      const dataLength = decodeLength(byteArray);\\n      const dataSlice = byteArray.slice(0, dataLength);\\n      const data = bs58__WEBPACK_IMPORTED_MODULE_4___default().encode(buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.from(dataSlice));\\n      byteArray = byteArray.slice(dataLength);\\n      instructions.push({\\n        programIdIndex,\\n        accounts,\\n        data\\n      });\\n    }\\n\\n    const messageArgs = {\\n      header: {\\n        numRequiredSignatures,\\n        numReadonlySignedAccounts,\\n        numReadonlyUnsignedAccounts\\n      },\\n      recentBlockhash: bs58__WEBPACK_IMPORTED_MODULE_4___default().encode(buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.from(recentBlockhash)),\\n      accountKeys,\\n      instructions\\n    };\\n    return new Message(messageArgs);\\n  }\\n\\n}\\n\\n/**\\n * Message constructor arguments\\n */\\n\\nclass MessageV0 {\\n  constructor(args) {\\n    this.header = void 0;\\n    this.staticAccountKeys = void 0;\\n    this.recentBlockhash = void 0;\\n    this.compiledInstructions = void 0;\\n    this.addressTableLookups = void 0;\\n    this.header = args.header;\\n    this.staticAccountKeys = args.staticAccountKeys;\\n    this.recentBlockhash = args.recentBlockhash;\\n    this.compiledInstructions = args.compiledInstructions;\\n    this.addressTableLookups = args.addressTableLookups;\\n  }\\n\\n  get version() {\\n    return 0;\\n  }\\n\\n  get numAccountKeysFromLookups() {\\n    let count = 0;\\n\\n    for (const lookup of this.addressTableLookups) {\\n      count += lookup.readonlyIndexes.length + lookup.writableIndexes.length;\\n    }\\n\\n    return count;\\n  }\\n\\n  getAccountKeys(args) {\\n    let accountKeysFromLookups;\\n\\n    if (args && 'accountKeysFromLookups' in args && args.accountKeysFromLookups) {\\n      if (this.numAccountKeysFromLookups != args.accountKeysFromLookups.writable.length + args.accountKeysFromLookups.readonly.length) {\\n        throw new Error('Failed to get account keys because of a mismatch in the number of account keys from lookups');\\n      }\\n\\n      accountKeysFromLookups = args.accountKeysFromLookups;\\n    } else if (args && 'addressLookupTableAccounts' in args && args.addressLookupTableAccounts) {\\n      accountKeysFromLookups = this.resolveAddressTableLookups(args.addressLookupTableAccounts);\\n    } else if (this.addressTableLookups.length > 0) {\\n      throw new Error('Failed to get account keys because address table lookups were not resolved');\\n    }\\n\\n    return new MessageAccountKeys(this.staticAccountKeys, accountKeysFromLookups);\\n  }\\n\\n  isAccountSigner(index) {\\n    return index < this.header.numRequiredSignatures;\\n  }\\n\\n  isAccountWritable(index) {\\n    const numSignedAccounts = this.header.numRequiredSignatures;\\n    const numStaticAccountKeys = this.staticAccountKeys.length;\\n\\n    if (index >= numStaticAccountKeys) {\\n      const lookupAccountKeysIndex = index - numStaticAccountKeys;\\n      const numWritableLookupAccountKeys = this.addressTableLookups.reduce((count, lookup) => count + lookup.writableIndexes.length, 0);\\n      return lookupAccountKeysIndex < numWritableLookupAccountKeys;\\n    } else if (index >= this.header.numRequiredSignatures) {\\n      const unsignedAccountIndex = index - numSignedAccounts;\\n      const numUnsignedAccounts = numStaticAccountKeys - numSignedAccounts;\\n      const numWritableUnsignedAccounts = numUnsignedAccounts - this.header.numReadonlyUnsignedAccounts;\\n      return unsignedAccountIndex < numWritableUnsignedAccounts;\\n    } else {\\n      const numWritableSignedAccounts = numSignedAccounts - this.header.numReadonlySignedAccounts;\\n      return index < numWritableSignedAccounts;\\n    }\\n  }\\n\\n  resolveAddressTableLookups(addressLookupTableAccounts) {\\n    const accountKeysFromLookups = {\\n      writable: [],\\n      readonly: []\\n    };\\n\\n    for (const tableLookup of this.addressTableLookups) {\\n      const tableAccount = addressLookupTableAccounts.find(account => account.key.equals(tableLookup.accountKey));\\n\\n      if (!tableAccount) {\\n        throw new Error(`Failed to find address lookup table account for table key ${tableLookup.accountKey.toBase58()}`);\\n      }\\n\\n      for (const index of tableLookup.writableIndexes) {\\n        if (index < tableAccount.state.addresses.length) {\\n          accountKeysFromLookups.writable.push(tableAccount.state.addresses[index]);\\n        } else {\\n          throw new Error(`Failed to find address for index ${index} in address lookup table ${tableLookup.accountKey.toBase58()}`);\\n        }\\n      }\\n\\n      for (const index of tableLookup.readonlyIndexes) {\\n        if (index < tableAccount.state.addresses.length) {\\n          accountKeysFromLookups.readonly.push(tableAccount.state.addresses[index]);\\n        } else {\\n          throw new Error(`Failed to find address for index ${index} in address lookup table ${tableLookup.accountKey.toBase58()}`);\\n        }\\n      }\\n    }\\n\\n    return accountKeysFromLookups;\\n  }\\n\\n  static compile(args) {\\n    const compiledKeys = CompiledKeys.compile(args.instructions, args.payerKey);\\n    const addressTableLookups = new Array();\\n    const accountKeysFromLookups = {\\n      writable: new Array(),\\n      readonly: new Array()\\n    };\\n    const lookupTableAccounts = args.addressLookupTableAccounts || [];\\n\\n    for (const lookupTable of lookupTableAccounts) {\\n      const extractResult = compiledKeys.extractTableLookup(lookupTable);\\n\\n      if (extractResult !== undefined) {\\n        const [addressTableLookup, {\\n          writable,\\n          readonly\\n        }] = extractResult;\\n        addressTableLookups.push(addressTableLookup);\\n        accountKeysFromLookups.writable.push(...writable);\\n        accountKeysFromLookups.readonly.push(...readonly);\\n      }\\n    }\\n\\n    const [header, staticAccountKeys] = compiledKeys.getMessageComponents();\\n    const accountKeys = new MessageAccountKeys(staticAccountKeys, accountKeysFromLookups);\\n    const compiledInstructions = accountKeys.compileInstructions(args.instructions);\\n    return new MessageV0({\\n      header,\\n      staticAccountKeys,\\n      recentBlockhash: args.recentBlockhash,\\n      compiledInstructions,\\n      addressTableLookups\\n    });\\n  }\\n\\n  serialize() {\\n    const encodedStaticAccountKeysLength = Array();\\n    encodeLength(encodedStaticAccountKeysLength, this.staticAccountKeys.length);\\n    const serializedInstructions = this.serializeInstructions();\\n    const encodedInstructionsLength = Array();\\n    encodeLength(encodedInstructionsLength, this.compiledInstructions.length);\\n    const serializedAddressTableLookups = this.serializeAddressTableLookups();\\n    const encodedAddressTableLookupsLength = Array();\\n    encodeLength(encodedAddressTableLookupsLength, this.addressTableLookups.length);\\n    const messageLayout = _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u8('prefix'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u8('numRequiredSignatures'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u8('numReadonlySignedAccounts'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u8('numReadonlyUnsignedAccounts')], 'header'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.blob(encodedStaticAccountKeysLength.length, 'staticAccountKeysLength'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.seq(publicKey(), this.staticAccountKeys.length, 'staticAccountKeys'), publicKey('recentBlockhash'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.blob(encodedInstructionsLength.length, 'instructionsLength'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.blob(serializedInstructions.length, 'serializedInstructions'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.blob(encodedAddressTableLookupsLength.length, 'addressTableLookupsLength'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.blob(serializedAddressTableLookups.length, 'serializedAddressTableLookups')]);\\n    const serializedMessage = new Uint8Array(PACKET_DATA_SIZE);\\n    const MESSAGE_VERSION_0_PREFIX = 1 << 7;\\n    const serializedMessageLength = messageLayout.encode({\\n      prefix: MESSAGE_VERSION_0_PREFIX,\\n      header: this.header,\\n      staticAccountKeysLength: new Uint8Array(encodedStaticAccountKeysLength),\\n      staticAccountKeys: this.staticAccountKeys.map(key => key.toBytes()),\\n      recentBlockhash: bs58__WEBPACK_IMPORTED_MODULE_4___default().decode(this.recentBlockhash),\\n      instructionsLength: new Uint8Array(encodedInstructionsLength),\\n      serializedInstructions,\\n      addressTableLookupsLength: new Uint8Array(encodedAddressTableLookupsLength),\\n      serializedAddressTableLookups\\n    }, serializedMessage);\\n    return serializedMessage.slice(0, serializedMessageLength);\\n  }\\n\\n  serializeInstructions() {\\n    let serializedLength = 0;\\n    const serializedInstructions = new Uint8Array(PACKET_DATA_SIZE);\\n\\n    for (const instruction of this.compiledInstructions) {\\n      const encodedAccountKeyIndexesLength = Array();\\n      encodeLength(encodedAccountKeyIndexesLength, instruction.accountKeyIndexes.length);\\n      const encodedDataLength = Array();\\n      encodeLength(encodedDataLength, instruction.data.length);\\n      const instructionLayout = _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u8('programIdIndex'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.blob(encodedAccountKeyIndexesLength.length, 'encodedAccountKeyIndexesLength'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.seq(_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u8(), instruction.accountKeyIndexes.length, 'accountKeyIndexes'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.blob(encodedDataLength.length, 'encodedDataLength'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.blob(instruction.data.length, 'data')]);\\n      serializedLength += instructionLayout.encode({\\n        programIdIndex: instruction.programIdIndex,\\n        encodedAccountKeyIndexesLength: new Uint8Array(encodedAccountKeyIndexesLength),\\n        accountKeyIndexes: instruction.accountKeyIndexes,\\n        encodedDataLength: new Uint8Array(encodedDataLength),\\n        data: instruction.data\\n      }, serializedInstructions, serializedLength);\\n    }\\n\\n    return serializedInstructions.slice(0, serializedLength);\\n  }\\n\\n  serializeAddressTableLookups() {\\n    let serializedLength = 0;\\n    const serializedAddressTableLookups = new Uint8Array(PACKET_DATA_SIZE);\\n\\n    for (const lookup of this.addressTableLookups) {\\n      const encodedWritableIndexesLength = Array();\\n      encodeLength(encodedWritableIndexesLength, lookup.writableIndexes.length);\\n      const encodedReadonlyIndexesLength = Array();\\n      encodeLength(encodedReadonlyIndexesLength, lookup.readonlyIndexes.length);\\n      const addressTableLookupLayout = _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([publicKey('accountKey'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.blob(encodedWritableIndexesLength.length, 'encodedWritableIndexesLength'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.seq(_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u8(), lookup.writableIndexes.length, 'writableIndexes'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.blob(encodedReadonlyIndexesLength.length, 'encodedReadonlyIndexesLength'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.seq(_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u8(), lookup.readonlyIndexes.length, 'readonlyIndexes')]);\\n      serializedLength += addressTableLookupLayout.encode({\\n        accountKey: lookup.accountKey.toBytes(),\\n        encodedWritableIndexesLength: new Uint8Array(encodedWritableIndexesLength),\\n        writableIndexes: lookup.writableIndexes,\\n        encodedReadonlyIndexesLength: new Uint8Array(encodedReadonlyIndexesLength),\\n        readonlyIndexes: lookup.readonlyIndexes\\n      }, serializedAddressTableLookups, serializedLength);\\n    }\\n\\n    return serializedAddressTableLookups.slice(0, serializedLength);\\n  }\\n\\n  static deserialize(serializedMessage) {\\n    let byteArray = [...serializedMessage];\\n    const prefix = byteArray.shift();\\n    const maskedPrefix = prefix & VERSION_PREFIX_MASK;\\n    assert(prefix !== maskedPrefix, `Expected versioned message but received legacy message`);\\n    const version = maskedPrefix;\\n    assert(version === 0, `Expected versioned message with version 0 but found version ${version}`);\\n    const header = {\\n      numRequiredSignatures: byteArray.shift(),\\n      numReadonlySignedAccounts: byteArray.shift(),\\n      numReadonlyUnsignedAccounts: byteArray.shift()\\n    };\\n    const staticAccountKeys = [];\\n    const staticAccountKeysLength = decodeLength(byteArray);\\n\\n    for (let i = 0; i < staticAccountKeysLength; i++) {\\n      staticAccountKeys.push(new PublicKey(byteArray.splice(0, PUBLIC_KEY_LENGTH)));\\n    }\\n\\n    const recentBlockhash = bs58__WEBPACK_IMPORTED_MODULE_4___default().encode(byteArray.splice(0, PUBLIC_KEY_LENGTH));\\n    const instructionCount = decodeLength(byteArray);\\n    const compiledInstructions = [];\\n\\n    for (let i = 0; i < instructionCount; i++) {\\n      const programIdIndex = byteArray.shift();\\n      const accountKeyIndexesLength = decodeLength(byteArray);\\n      const accountKeyIndexes = byteArray.splice(0, accountKeyIndexesLength);\\n      const dataLength = decodeLength(byteArray);\\n      const data = new Uint8Array(byteArray.splice(0, dataLength));\\n      compiledInstructions.push({\\n        programIdIndex,\\n        accountKeyIndexes,\\n        data\\n      });\\n    }\\n\\n    const addressTableLookupsCount = decodeLength(byteArray);\\n    const addressTableLookups = [];\\n\\n    for (let i = 0; i < addressTableLookupsCount; i++) {\\n      const accountKey = new PublicKey(byteArray.splice(0, PUBLIC_KEY_LENGTH));\\n      const writableIndexesLength = decodeLength(byteArray);\\n      const writableIndexes = byteArray.splice(0, writableIndexesLength);\\n      const readonlyIndexesLength = decodeLength(byteArray);\\n      const readonlyIndexes = byteArray.splice(0, readonlyIndexesLength);\\n      addressTableLookups.push({\\n        accountKey,\\n        writableIndexes,\\n        readonlyIndexes\\n      });\\n    }\\n\\n    return new MessageV0({\\n      header,\\n      staticAccountKeys,\\n      recentBlockhash,\\n      compiledInstructions,\\n      addressTableLookups\\n    });\\n  }\\n\\n}\\n\\n// eslint-disable-next-line no-redeclare\\nconst VersionedMessage = {\\n  deserializeMessageVersion(serializedMessage) {\\n    const prefix = serializedMessage[0];\\n    const maskedPrefix = prefix & VERSION_PREFIX_MASK; // if the highest bit of the prefix is not set, the message is not versioned\\n\\n    if (maskedPrefix === prefix) {\\n      return 'legacy';\\n    } // the lower 7 bits of the prefix indicate the message version\\n\\n\\n    return maskedPrefix;\\n  },\\n\\n  deserialize: serializedMessage => {\\n    const version = VersionedMessage.deserializeMessageVersion(serializedMessage);\\n\\n    if (version === 'legacy') {\\n      return Message.from(serializedMessage);\\n    }\\n\\n    if (version === 0) {\\n      return MessageV0.deserialize(serializedMessage);\\n    } else {\\n      throw new Error(`Transaction message version ${version} deserialization is not supported`);\\n    }\\n  }\\n};\\n\\n/**\\n * Transaction signature as base-58 encoded string\\n */\\n\\nlet TransactionStatus;\\n/**\\n * Default (empty) signature\\n */\\n\\n(function (TransactionStatus) {\\n  TransactionStatus[TransactionStatus[\\\"BLOCKHEIGHT_EXCEEDED\\\"] = 0] = \\\"BLOCKHEIGHT_EXCEEDED\\\";\\n  TransactionStatus[TransactionStatus[\\\"PROCESSED\\\"] = 1] = \\\"PROCESSED\\\";\\n  TransactionStatus[TransactionStatus[\\\"TIMED_OUT\\\"] = 2] = \\\"TIMED_OUT\\\";\\n  TransactionStatus[TransactionStatus[\\\"NONCE_INVALID\\\"] = 3] = \\\"NONCE_INVALID\\\";\\n})(TransactionStatus || (TransactionStatus = {}));\\n\\nconst DEFAULT_SIGNATURE = buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.alloc(SIGNATURE_LENGTH_IN_BYTES).fill(0);\\n/**\\n * Account metadata used to define instructions\\n */\\n\\n/**\\n * Transaction Instruction class\\n */\\nclass TransactionInstruction {\\n  /**\\n   * Public keys to include in this transaction\\n   * Boolean represents whether this pubkey needs to sign the transaction\\n   */\\n\\n  /**\\n   * Program Id to execute\\n   */\\n\\n  /**\\n   * Program input\\n   */\\n  constructor(opts) {\\n    this.keys = void 0;\\n    this.programId = void 0;\\n    this.data = buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.alloc(0);\\n    this.programId = opts.programId;\\n    this.keys = opts.keys;\\n\\n    if (opts.data) {\\n      this.data = opts.data;\\n    }\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  toJSON() {\\n    return {\\n      keys: this.keys.map(({\\n        pubkey,\\n        isSigner,\\n        isWritable\\n      }) => ({\\n        pubkey: pubkey.toJSON(),\\n        isSigner,\\n        isWritable\\n      })),\\n      programId: this.programId.toJSON(),\\n      data: [...this.data]\\n    };\\n  }\\n\\n}\\n/**\\n * Pair of signature and corresponding public key\\n */\\n\\n/**\\n * Transaction class\\n */\\nclass Transaction {\\n  /**\\n   * Signatures for the transaction.  Typically created by invoking the\\n   * `sign()` method\\n   */\\n\\n  /**\\n   * The first (payer) Transaction signature\\n   */\\n  get signature() {\\n    if (this.signatures.length > 0) {\\n      return this.signatures[0].signature;\\n    }\\n\\n    return null;\\n  }\\n  /**\\n   * The transaction fee payer\\n   */\\n\\n\\n  /**\\n   * Construct an empty Transaction\\n   */\\n  constructor(opts) {\\n    this.signatures = [];\\n    this.feePayer = void 0;\\n    this.instructions = [];\\n    this.recentBlockhash = void 0;\\n    this.lastValidBlockHeight = void 0;\\n    this.nonceInfo = void 0;\\n    this.minNonceContextSlot = void 0;\\n    this._message = void 0;\\n    this._json = void 0;\\n\\n    if (!opts) {\\n      return;\\n    }\\n\\n    if (opts.feePayer) {\\n      this.feePayer = opts.feePayer;\\n    }\\n\\n    if (opts.signatures) {\\n      this.signatures = opts.signatures;\\n    }\\n\\n    if (Object.prototype.hasOwnProperty.call(opts, 'nonceInfo')) {\\n      const {\\n        minContextSlot,\\n        nonceInfo\\n      } = opts;\\n      this.minNonceContextSlot = minContextSlot;\\n      this.nonceInfo = nonceInfo;\\n    } else if (Object.prototype.hasOwnProperty.call(opts, 'lastValidBlockHeight')) {\\n      const {\\n        blockhash,\\n        lastValidBlockHeight\\n      } = opts;\\n      this.recentBlockhash = blockhash;\\n      this.lastValidBlockHeight = lastValidBlockHeight;\\n    } else {\\n      const {\\n        recentBlockhash,\\n        nonceInfo\\n      } = opts;\\n\\n      if (nonceInfo) {\\n        this.nonceInfo = nonceInfo;\\n      }\\n\\n      this.recentBlockhash = recentBlockhash;\\n    }\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  toJSON() {\\n    return {\\n      recentBlockhash: this.recentBlockhash || null,\\n      feePayer: this.feePayer ? this.feePayer.toJSON() : null,\\n      nonceInfo: this.nonceInfo ? {\\n        nonce: this.nonceInfo.nonce,\\n        nonceInstruction: this.nonceInfo.nonceInstruction.toJSON()\\n      } : null,\\n      instructions: this.instructions.map(instruction => instruction.toJSON()),\\n      signers: this.signatures.map(({\\n        publicKey\\n      }) => {\\n        return publicKey.toJSON();\\n      })\\n    };\\n  }\\n  /**\\n   * Add one or more instructions to this Transaction\\n   */\\n\\n\\n  add(...items) {\\n    if (items.length === 0) {\\n      throw new Error('No instructions');\\n    }\\n\\n    items.forEach(item => {\\n      if ('instructions' in item) {\\n        this.instructions = this.instructions.concat(item.instructions);\\n      } else if ('data' in item && 'programId' in item && 'keys' in item) {\\n        this.instructions.push(item);\\n      } else {\\n        this.instructions.push(new TransactionInstruction(item));\\n      }\\n    });\\n    return this;\\n  }\\n  /**\\n   * Compile transaction data\\n   */\\n\\n\\n  compileMessage() {\\n    if (this._message && JSON.stringify(this.toJSON()) === JSON.stringify(this._json)) {\\n      return this._message;\\n    }\\n\\n    let recentBlockhash;\\n    let instructions;\\n\\n    if (this.nonceInfo) {\\n      recentBlockhash = this.nonceInfo.nonce;\\n\\n      if (this.instructions[0] != this.nonceInfo.nonceInstruction) {\\n        instructions = [this.nonceInfo.nonceInstruction, ...this.instructions];\\n      } else {\\n        instructions = this.instructions;\\n      }\\n    } else {\\n      recentBlockhash = this.recentBlockhash;\\n      instructions = this.instructions;\\n    }\\n\\n    if (!recentBlockhash) {\\n      throw new Error('Transaction recentBlockhash required');\\n    }\\n\\n    if (instructions.length < 1) {\\n      console.warn('No instructions provided');\\n    }\\n\\n    let feePayer;\\n\\n    if (this.feePayer) {\\n      feePayer = this.feePayer;\\n    } else if (this.signatures.length > 0 && this.signatures[0].publicKey) {\\n      // Use implicit fee payer\\n      feePayer = this.signatures[0].publicKey;\\n    } else {\\n      throw new Error('Transaction fee payer required');\\n    }\\n\\n    for (let i = 0; i < instructions.length; i++) {\\n      if (instructions[i].programId === undefined) {\\n        throw new Error(`Transaction instruction index ${i} has undefined program id`);\\n      }\\n    }\\n\\n    const programIds = [];\\n    const accountMetas = [];\\n    instructions.forEach(instruction => {\\n      instruction.keys.forEach(accountMeta => {\\n        accountMetas.push({ ...accountMeta\\n        });\\n      });\\n      const programId = instruction.programId.toString();\\n\\n      if (!programIds.includes(programId)) {\\n        programIds.push(programId);\\n      }\\n    }); // Append programID account metas\\n\\n    programIds.forEach(programId => {\\n      accountMetas.push({\\n        pubkey: new PublicKey(programId),\\n        isSigner: false,\\n        isWritable: false\\n      });\\n    }); // Cull duplicate account metas\\n\\n    const uniqueMetas = [];\\n    accountMetas.forEach(accountMeta => {\\n      const pubkeyString = accountMeta.pubkey.toString();\\n      const uniqueIndex = uniqueMetas.findIndex(x => {\\n        return x.pubkey.toString() === pubkeyString;\\n      });\\n\\n      if (uniqueIndex > -1) {\\n        uniqueMetas[uniqueIndex].isWritable = uniqueMetas[uniqueIndex].isWritable || accountMeta.isWritable;\\n        uniqueMetas[uniqueIndex].isSigner = uniqueMetas[uniqueIndex].isSigner || accountMeta.isSigner;\\n      } else {\\n        uniqueMetas.push(accountMeta);\\n      }\\n    }); // Sort. Prioritizing first by signer, then by writable\\n\\n    uniqueMetas.sort(function (x, y) {\\n      if (x.isSigner !== y.isSigner) {\\n        // Signers always come before non-signers\\n        return x.isSigner ? -1 : 1;\\n      }\\n\\n      if (x.isWritable !== y.isWritable) {\\n        // Writable accounts always come before read-only accounts\\n        return x.isWritable ? -1 : 1;\\n      } // Otherwise, sort by pubkey, stringwise.\\n\\n\\n      return x.pubkey.toBase58().localeCompare(y.pubkey.toBase58());\\n    }); // Move fee payer to the front\\n\\n    const feePayerIndex = uniqueMetas.findIndex(x => {\\n      return x.pubkey.equals(feePayer);\\n    });\\n\\n    if (feePayerIndex > -1) {\\n      const [payerMeta] = uniqueMetas.splice(feePayerIndex, 1);\\n      payerMeta.isSigner = true;\\n      payerMeta.isWritable = true;\\n      uniqueMetas.unshift(payerMeta);\\n    } else {\\n      uniqueMetas.unshift({\\n        pubkey: feePayer,\\n        isSigner: true,\\n        isWritable: true\\n      });\\n    } // Disallow unknown signers\\n\\n\\n    for (const signature of this.signatures) {\\n      const uniqueIndex = uniqueMetas.findIndex(x => {\\n        return x.pubkey.equals(signature.publicKey);\\n      });\\n\\n      if (uniqueIndex > -1) {\\n        if (!uniqueMetas[uniqueIndex].isSigner) {\\n          uniqueMetas[uniqueIndex].isSigner = true;\\n          console.warn('Transaction references a signature that is unnecessary, ' + 'only the fee payer and instruction signer accounts should sign a transaction. ' + 'This behavior is deprecated and will throw an error in the next major version release.');\\n        }\\n      } else {\\n        throw new Error(`unknown signer: ${signature.publicKey.toString()}`);\\n      }\\n    }\\n\\n    let numRequiredSignatures = 0;\\n    let numReadonlySignedAccounts = 0;\\n    let numReadonlyUnsignedAccounts = 0; // Split out signing from non-signing keys and count header values\\n\\n    const signedKeys = [];\\n    const unsignedKeys = [];\\n    uniqueMetas.forEach(({\\n      pubkey,\\n      isSigner,\\n      isWritable\\n    }) => {\\n      if (isSigner) {\\n        signedKeys.push(pubkey.toString());\\n        numRequiredSignatures += 1;\\n\\n        if (!isWritable) {\\n          numReadonlySignedAccounts += 1;\\n        }\\n      } else {\\n        unsignedKeys.push(pubkey.toString());\\n\\n        if (!isWritable) {\\n          numReadonlyUnsignedAccounts += 1;\\n        }\\n      }\\n    });\\n    const accountKeys = signedKeys.concat(unsignedKeys);\\n    const compiledInstructions = instructions.map(instruction => {\\n      const {\\n        data,\\n        programId\\n      } = instruction;\\n      return {\\n        programIdIndex: accountKeys.indexOf(programId.toString()),\\n        accounts: instruction.keys.map(meta => accountKeys.indexOf(meta.pubkey.toString())),\\n        data: bs58__WEBPACK_IMPORTED_MODULE_4___default().encode(data)\\n      };\\n    });\\n    compiledInstructions.forEach(instruction => {\\n      assert(instruction.programIdIndex >= 0);\\n      instruction.accounts.forEach(keyIndex => assert(keyIndex >= 0));\\n    });\\n    return new Message({\\n      header: {\\n        numRequiredSignatures,\\n        numReadonlySignedAccounts,\\n        numReadonlyUnsignedAccounts\\n      },\\n      accountKeys,\\n      recentBlockhash,\\n      instructions: compiledInstructions\\n    });\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  _compile() {\\n    const message = this.compileMessage();\\n    const signedKeys = message.accountKeys.slice(0, message.header.numRequiredSignatures);\\n\\n    if (this.signatures.length === signedKeys.length) {\\n      const valid = this.signatures.every((pair, index) => {\\n        return signedKeys[index].equals(pair.publicKey);\\n      });\\n      if (valid) return message;\\n    }\\n\\n    this.signatures = signedKeys.map(publicKey => ({\\n      signature: null,\\n      publicKey\\n    }));\\n    return message;\\n  }\\n  /**\\n   * Get a buffer of the Transaction data that need to be covered by signatures\\n   */\\n\\n\\n  serializeMessage() {\\n    return this._compile().serialize();\\n  }\\n  /**\\n   * Get the estimated fee associated with a transaction\\n   */\\n\\n\\n  async getEstimatedFee(connection) {\\n    return (await connection.getFeeForMessage(this.compileMessage())).value;\\n  }\\n  /**\\n   * Specify the public keys which will be used to sign the Transaction.\\n   * The first signer will be used as the transaction fee payer account.\\n   *\\n   * Signatures can be added with either `partialSign` or `addSignature`\\n   *\\n   * @deprecated Deprecated since v0.84.0. Only the fee payer needs to be\\n   * specified and it can be set in the Transaction constructor or with the\\n   * `feePayer` property.\\n   */\\n\\n\\n  setSigners(...signers) {\\n    if (signers.length === 0) {\\n      throw new Error('No signers');\\n    }\\n\\n    const seen = new Set();\\n    this.signatures = signers.filter(publicKey => {\\n      const key = publicKey.toString();\\n\\n      if (seen.has(key)) {\\n        return false;\\n      } else {\\n        seen.add(key);\\n        return true;\\n      }\\n    }).map(publicKey => ({\\n      signature: null,\\n      publicKey\\n    }));\\n  }\\n  /**\\n   * Sign the Transaction with the specified signers. Multiple signatures may\\n   * be applied to a Transaction. The first signature is considered \\\"primary\\\"\\n   * and is used identify and confirm transactions.\\n   *\\n   * If the Transaction `feePayer` is not set, the first signer will be used\\n   * as the transaction fee payer account.\\n   *\\n   * Transaction fields should not be modified after the first call to `sign`,\\n   * as doing so may invalidate the signature and cause the Transaction to be\\n   * rejected.\\n   *\\n   * The Transaction must be assigned a valid `recentBlockhash` before invoking this method\\n   */\\n\\n\\n  sign(...signers) {\\n    if (signers.length === 0) {\\n      throw new Error('No signers');\\n    } // Dedupe signers\\n\\n\\n    const seen = new Set();\\n    const uniqueSigners = [];\\n\\n    for (const signer of signers) {\\n      const key = signer.publicKey.toString();\\n\\n      if (seen.has(key)) {\\n        continue;\\n      } else {\\n        seen.add(key);\\n        uniqueSigners.push(signer);\\n      }\\n    }\\n\\n    this.signatures = uniqueSigners.map(signer => ({\\n      signature: null,\\n      publicKey: signer.publicKey\\n    }));\\n\\n    const message = this._compile();\\n\\n    this._partialSign(message, ...uniqueSigners);\\n  }\\n  /**\\n   * Partially sign a transaction with the specified accounts. All accounts must\\n   * correspond to either the fee payer or a signer account in the transaction\\n   * instructions.\\n   *\\n   * All the caveats from the `sign` method apply to `partialSign`\\n   */\\n\\n\\n  partialSign(...signers) {\\n    if (signers.length === 0) {\\n      throw new Error('No signers');\\n    } // Dedupe signers\\n\\n\\n    const seen = new Set();\\n    const uniqueSigners = [];\\n\\n    for (const signer of signers) {\\n      const key = signer.publicKey.toString();\\n\\n      if (seen.has(key)) {\\n        continue;\\n      } else {\\n        seen.add(key);\\n        uniqueSigners.push(signer);\\n      }\\n    }\\n\\n    const message = this._compile();\\n\\n    this._partialSign(message, ...uniqueSigners);\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  _partialSign(message, ...signers) {\\n    const signData = message.serialize();\\n    signers.forEach(signer => {\\n      const signature = sign(signData, signer.secretKey);\\n\\n      this._addSignature(signer.publicKey, toBuffer(signature));\\n    });\\n  }\\n  /**\\n   * Add an externally created signature to a transaction. The public key\\n   * must correspond to either the fee payer or a signer account in the transaction\\n   * instructions.\\n   */\\n\\n\\n  addSignature(pubkey, signature) {\\n    this._compile(); // Ensure signatures array is populated\\n\\n\\n    this._addSignature(pubkey, signature);\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  _addSignature(pubkey, signature) {\\n    assert(signature.length === 64);\\n    const index = this.signatures.findIndex(sigpair => pubkey.equals(sigpair.publicKey));\\n\\n    if (index < 0) {\\n      throw new Error(`unknown signer: ${pubkey.toString()}`);\\n    }\\n\\n    this.signatures[index].signature = buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.from(signature);\\n  }\\n  /**\\n   * Verify signatures of a complete, signed Transaction\\n   */\\n\\n\\n  verifySignatures() {\\n    return this._verifySignatures(this.serializeMessage(), true);\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  _verifySignatures(signData, requireAllSignatures) {\\n    for (const {\\n      signature,\\n      publicKey\\n    } of this.signatures) {\\n      if (signature === null) {\\n        if (requireAllSignatures) {\\n          return false;\\n        }\\n      } else {\\n        if (!verify(signature, signData, publicKey.toBytes())) {\\n          return false;\\n        }\\n      }\\n    }\\n\\n    return true;\\n  }\\n  /**\\n   * Serialize the Transaction in the wire format.\\n   */\\n\\n\\n  serialize(config) {\\n    const {\\n      requireAllSignatures,\\n      verifySignatures\\n    } = Object.assign({\\n      requireAllSignatures: true,\\n      verifySignatures: true\\n    }, config);\\n    const signData = this.serializeMessage();\\n\\n    if (verifySignatures && !this._verifySignatures(signData, requireAllSignatures)) {\\n      throw new Error('Signature verification failed');\\n    }\\n\\n    return this._serialize(signData);\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  _serialize(signData) {\\n    const {\\n      signatures\\n    } = this;\\n    const signatureCount = [];\\n    encodeLength(signatureCount, signatures.length);\\n    const transactionLength = signatureCount.length + signatures.length * 64 + signData.length;\\n    const wireTransaction = buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.alloc(transactionLength);\\n    assert(signatures.length < 256);\\n    buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.from(signatureCount).copy(wireTransaction, 0);\\n    signatures.forEach(({\\n      signature\\n    }, index) => {\\n      if (signature !== null) {\\n        assert(signature.length === 64, `signature has invalid length`);\\n        buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.from(signature).copy(wireTransaction, signatureCount.length + index * 64);\\n      }\\n    });\\n    signData.copy(wireTransaction, signatureCount.length + signatures.length * 64);\\n    assert(wireTransaction.length <= PACKET_DATA_SIZE, `Transaction too large: ${wireTransaction.length} > ${PACKET_DATA_SIZE}`);\\n    return wireTransaction;\\n  }\\n  /**\\n   * Deprecated method\\n   * @internal\\n   */\\n\\n\\n  get keys() {\\n    assert(this.instructions.length === 1);\\n    return this.instructions[0].keys.map(keyObj => keyObj.pubkey);\\n  }\\n  /**\\n   * Deprecated method\\n   * @internal\\n   */\\n\\n\\n  get programId() {\\n    assert(this.instructions.length === 1);\\n    return this.instructions[0].programId;\\n  }\\n  /**\\n   * Deprecated method\\n   * @internal\\n   */\\n\\n\\n  get data() {\\n    assert(this.instructions.length === 1);\\n    return this.instructions[0].data;\\n  }\\n  /**\\n   * Parse a wire transaction into a Transaction object.\\n   */\\n\\n\\n  static from(buffer) {\\n    // Slice up wire data\\n    let byteArray = [...buffer];\\n    const signatureCount = decodeLength(byteArray);\\n    let signatures = [];\\n\\n    for (let i = 0; i < signatureCount; i++) {\\n      const signature = byteArray.slice(0, SIGNATURE_LENGTH_IN_BYTES);\\n      byteArray = byteArray.slice(SIGNATURE_LENGTH_IN_BYTES);\\n      signatures.push(bs58__WEBPACK_IMPORTED_MODULE_4___default().encode(buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.from(signature)));\\n    }\\n\\n    return Transaction.populate(Message.from(byteArray), signatures);\\n  }\\n  /**\\n   * Populate Transaction object from message and signatures\\n   */\\n\\n\\n  static populate(message, signatures = []) {\\n    const transaction = new Transaction();\\n    transaction.recentBlockhash = message.recentBlockhash;\\n\\n    if (message.header.numRequiredSignatures > 0) {\\n      transaction.feePayer = message.accountKeys[0];\\n    }\\n\\n    signatures.forEach((signature, index) => {\\n      const sigPubkeyPair = {\\n        signature: signature == bs58__WEBPACK_IMPORTED_MODULE_4___default().encode(DEFAULT_SIGNATURE) ? null : bs58__WEBPACK_IMPORTED_MODULE_4___default().decode(signature),\\n        publicKey: message.accountKeys[index]\\n      };\\n      transaction.signatures.push(sigPubkeyPair);\\n    });\\n    message.instructions.forEach(instruction => {\\n      const keys = instruction.accounts.map(account => {\\n        const pubkey = message.accountKeys[account];\\n        return {\\n          pubkey,\\n          isSigner: transaction.signatures.some(keyObj => keyObj.publicKey.toString() === pubkey.toString()) || message.isAccountSigner(account),\\n          isWritable: message.isAccountWritable(account)\\n        };\\n      });\\n      transaction.instructions.push(new TransactionInstruction({\\n        keys,\\n        programId: message.accountKeys[instruction.programIdIndex],\\n        data: bs58__WEBPACK_IMPORTED_MODULE_4___default().decode(instruction.data)\\n      }));\\n    });\\n    transaction._message = message;\\n    transaction._json = transaction.toJSON();\\n    return transaction;\\n  }\\n\\n}\\n\\nclass TransactionMessage {\\n  constructor(args) {\\n    this.payerKey = void 0;\\n    this.instructions = void 0;\\n    this.recentBlockhash = void 0;\\n    this.payerKey = args.payerKey;\\n    this.instructions = args.instructions;\\n    this.recentBlockhash = args.recentBlockhash;\\n  }\\n\\n  static decompile(message, args) {\\n    const {\\n      header,\\n      compiledInstructions,\\n      recentBlockhash\\n    } = message;\\n    const {\\n      numRequiredSignatures,\\n      numReadonlySignedAccounts,\\n      numReadonlyUnsignedAccounts\\n    } = header;\\n    const numWritableSignedAccounts = numRequiredSignatures - numReadonlySignedAccounts;\\n    assert(numWritableSignedAccounts > 0, 'Message header is invalid');\\n    const numWritableUnsignedAccounts = message.staticAccountKeys.length - numRequiredSignatures - numReadonlyUnsignedAccounts;\\n    assert(numWritableUnsignedAccounts >= 0, 'Message header is invalid');\\n    const accountKeys = message.getAccountKeys(args);\\n    const payerKey = accountKeys.get(0);\\n\\n    if (payerKey === undefined) {\\n      throw new Error('Failed to decompile message because no account keys were found');\\n    }\\n\\n    const instructions = [];\\n\\n    for (const compiledIx of compiledInstructions) {\\n      const keys = [];\\n\\n      for (const keyIndex of compiledIx.accountKeyIndexes) {\\n        const pubkey = accountKeys.get(keyIndex);\\n\\n        if (pubkey === undefined) {\\n          throw new Error(`Failed to find key for account key index ${keyIndex}`);\\n        }\\n\\n        const isSigner = keyIndex < numRequiredSignatures;\\n        let isWritable;\\n\\n        if (isSigner) {\\n          isWritable = keyIndex < numWritableSignedAccounts;\\n        } else if (keyIndex < accountKeys.staticAccountKeys.length) {\\n          isWritable = keyIndex - numRequiredSignatures < numWritableUnsignedAccounts;\\n        } else {\\n          isWritable = keyIndex - accountKeys.staticAccountKeys.length < // accountKeysFromLookups cannot be undefined because we already found a pubkey for this index above\\n          accountKeys.accountKeysFromLookups.writable.length;\\n        }\\n\\n        keys.push({\\n          pubkey,\\n          isSigner: keyIndex < header.numRequiredSignatures,\\n          isWritable\\n        });\\n      }\\n\\n      const programId = accountKeys.get(compiledIx.programIdIndex);\\n\\n      if (programId === undefined) {\\n        throw new Error(`Failed to find program id for program id index ${compiledIx.programIdIndex}`);\\n      }\\n\\n      instructions.push(new TransactionInstruction({\\n        programId,\\n        data: toBuffer(compiledIx.data),\\n        keys\\n      }));\\n    }\\n\\n    return new TransactionMessage({\\n      payerKey,\\n      instructions,\\n      recentBlockhash\\n    });\\n  }\\n\\n  compileToLegacyMessage() {\\n    return Message.compile({\\n      payerKey: this.payerKey,\\n      recentBlockhash: this.recentBlockhash,\\n      instructions: this.instructions\\n    });\\n  }\\n\\n  compileToV0Message(addressLookupTableAccounts) {\\n    return MessageV0.compile({\\n      payerKey: this.payerKey,\\n      recentBlockhash: this.recentBlockhash,\\n      instructions: this.instructions,\\n      addressLookupTableAccounts\\n    });\\n  }\\n\\n}\\n\\n/**\\n * Versioned transaction class\\n */\\nclass VersionedTransaction {\\n  get version() {\\n    return this.message.version;\\n  }\\n\\n  constructor(message, signatures) {\\n    this.signatures = void 0;\\n    this.message = void 0;\\n\\n    if (signatures !== undefined) {\\n      assert(signatures.length === message.header.numRequiredSignatures, 'Expected signatures length to be equal to the number of required signatures');\\n      this.signatures = signatures;\\n    } else {\\n      const defaultSignatures = [];\\n\\n      for (let i = 0; i < message.header.numRequiredSignatures; i++) {\\n        defaultSignatures.push(new Uint8Array(SIGNATURE_LENGTH_IN_BYTES));\\n      }\\n\\n      this.signatures = defaultSignatures;\\n    }\\n\\n    this.message = message;\\n  }\\n\\n  serialize() {\\n    const serializedMessage = this.message.serialize();\\n    const encodedSignaturesLength = Array();\\n    encodeLength(encodedSignaturesLength, this.signatures.length);\\n    const transactionLayout = _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.blob(encodedSignaturesLength.length, 'encodedSignaturesLength'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.seq(signature(), this.signatures.length, 'signatures'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.blob(serializedMessage.length, 'serializedMessage')]);\\n    const serializedTransaction = new Uint8Array(2048);\\n    const serializedTransactionLength = transactionLayout.encode({\\n      encodedSignaturesLength: new Uint8Array(encodedSignaturesLength),\\n      signatures: this.signatures,\\n      serializedMessage\\n    }, serializedTransaction);\\n    return serializedTransaction.slice(0, serializedTransactionLength);\\n  }\\n\\n  static deserialize(serializedTransaction) {\\n    let byteArray = [...serializedTransaction];\\n    const signatures = [];\\n    const signaturesLength = decodeLength(byteArray);\\n\\n    for (let i = 0; i < signaturesLength; i++) {\\n      signatures.push(new Uint8Array(byteArray.splice(0, SIGNATURE_LENGTH_IN_BYTES)));\\n    }\\n\\n    const message = VersionedMessage.deserialize(new Uint8Array(byteArray));\\n    return new VersionedTransaction(message, signatures);\\n  }\\n\\n  sign(signers) {\\n    const messageData = this.message.serialize();\\n    const signerPubkeys = this.message.staticAccountKeys.slice(0, this.message.header.numRequiredSignatures);\\n\\n    for (const signer of signers) {\\n      const signerIndex = signerPubkeys.findIndex(pubkey => pubkey.equals(signer.publicKey));\\n      assert(signerIndex >= 0, `Cannot sign with non signer key ${signer.publicKey.toBase58()}`);\\n      this.signatures[signerIndex] = sign(messageData, signer.secretKey);\\n    }\\n  }\\n\\n  addSignature(publicKey, signature) {\\n    assert(signature.byteLength === 64, 'Signature must be 64 bytes long');\\n    const signerPubkeys = this.message.staticAccountKeys.slice(0, this.message.header.numRequiredSignatures);\\n    const signerIndex = signerPubkeys.findIndex(pubkey => pubkey.equals(publicKey));\\n    assert(signerIndex >= 0, `Can not add signature; \\\\`${publicKey.toBase58()}\\\\` is not required to sign this transaction`);\\n    this.signatures[signerIndex] = signature;\\n  }\\n\\n}\\n\\nconst SYSVAR_CLOCK_PUBKEY = new PublicKey('SysvarC1ock11111111111111111111111111111111');\\nconst SYSVAR_EPOCH_SCHEDULE_PUBKEY = new PublicKey('SysvarEpochSchedu1e111111111111111111111111');\\nconst SYSVAR_INSTRUCTIONS_PUBKEY = new PublicKey('Sysvar1nstructions1111111111111111111111111');\\nconst SYSVAR_RECENT_BLOCKHASHES_PUBKEY = new PublicKey('SysvarRecentB1ockHashes11111111111111111111');\\nconst SYSVAR_RENT_PUBKEY = new PublicKey('SysvarRent111111111111111111111111111111111');\\nconst SYSVAR_REWARDS_PUBKEY = new PublicKey('SysvarRewards111111111111111111111111111111');\\nconst SYSVAR_SLOT_HASHES_PUBKEY = new PublicKey('SysvarS1otHashes111111111111111111111111111');\\nconst SYSVAR_SLOT_HISTORY_PUBKEY = new PublicKey('SysvarS1otHistory11111111111111111111111111');\\nconst SYSVAR_STAKE_HISTORY_PUBKEY = new PublicKey('SysvarStakeHistory1111111111111111111111111');\\n\\n/**\\n * Sign, send and confirm a transaction.\\n *\\n * If `commitment` option is not specified, defaults to 'max' commitment.\\n *\\n * @param {Connection} connection\\n * @param {Transaction} transaction\\n * @param {Array<Signer>} signers\\n * @param {ConfirmOptions} [options]\\n * @returns {Promise<TransactionSignature>}\\n */\\nasync function sendAndConfirmTransaction(connection, transaction, signers, options) {\\n  const sendOptions = options && {\\n    skipPreflight: options.skipPreflight,\\n    preflightCommitment: options.preflightCommitment || options.commitment,\\n    maxRetries: options.maxRetries,\\n    minContextSlot: options.minContextSlot\\n  };\\n  const signature = await connection.sendTransaction(transaction, signers, sendOptions);\\n  let status;\\n\\n  if (transaction.recentBlockhash != null && transaction.lastValidBlockHeight != null) {\\n    status = (await connection.confirmTransaction({\\n      abortSignal: options === null || options === void 0 ? void 0 : options.abortSignal,\\n      signature: signature,\\n      blockhash: transaction.recentBlockhash,\\n      lastValidBlockHeight: transaction.lastValidBlockHeight\\n    }, options && options.commitment)).value;\\n  } else if (transaction.minNonceContextSlot != null && transaction.nonceInfo != null) {\\n    const {\\n      nonceInstruction\\n    } = transaction.nonceInfo;\\n    const nonceAccountPubkey = nonceInstruction.keys[0].pubkey;\\n    status = (await connection.confirmTransaction({\\n      abortSignal: options === null || options === void 0 ? void 0 : options.abortSignal,\\n      minContextSlot: transaction.minNonceContextSlot,\\n      nonceAccountPubkey,\\n      nonceValue: transaction.nonceInfo.nonce,\\n      signature\\n    }, options && options.commitment)).value;\\n  } else {\\n    if ((options === null || options === void 0 ? void 0 : options.abortSignal) != null) {\\n      console.warn('sendAndConfirmTransaction(): A transaction with a deprecated confirmation strategy was ' + 'supplied along with an `abortSignal`. Only transactions having `lastValidBlockHeight` ' + 'or a combination of `nonceInfo` and `minNonceContextSlot` are abortable.');\\n    }\\n\\n    status = (await connection.confirmTransaction(signature, options && options.commitment)).value;\\n  }\\n\\n  if (status.err) {\\n    throw new Error(`Transaction ${signature} failed (${JSON.stringify(status)})`);\\n  }\\n\\n  return signature;\\n}\\n\\n// zzz\\nfunction sleep(ms) {\\n  return new Promise(resolve => setTimeout(resolve, ms));\\n}\\n\\n/**\\n * Populate a buffer of instruction data using an InstructionType\\n * @internal\\n */\\nfunction encodeData(type, fields) {\\n  const allocLength = type.layout.span >= 0 ? type.layout.span : getAlloc(type, fields);\\n  const data = buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.alloc(allocLength);\\n  const layoutFields = Object.assign({\\n    instruction: type.index\\n  }, fields);\\n  type.layout.encode(layoutFields, data);\\n  return data;\\n}\\n/**\\n * Decode instruction data buffer using an InstructionType\\n * @internal\\n */\\n\\nfunction decodeData$1(type, buffer) {\\n  let data;\\n\\n  try {\\n    data = type.layout.decode(buffer);\\n  } catch (err) {\\n    throw new Error('invalid instruction; ' + err);\\n  }\\n\\n  if (data.instruction !== type.index) {\\n    throw new Error(`invalid instruction; instruction index mismatch ${data.instruction} != ${type.index}`);\\n  }\\n\\n  return data;\\n}\\n\\n/**\\n * https://github.com/solana-labs/solana/blob/90bedd7e067b5b8f3ddbb45da00a4e9cabb22c62/sdk/src/fee_calculator.rs#L7-L11\\n *\\n * @internal\\n */\\n\\nconst FeeCalculatorLayout = _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.nu64('lamportsPerSignature');\\n/**\\n * Calculator for transaction fees.\\n *\\n * @deprecated Deprecated since Solana v1.8.0.\\n */\\n\\n/**\\n * See https://github.com/solana-labs/solana/blob/0ea2843ec9cdc517572b8e62c959f41b55cf4453/sdk/src/nonce_state.rs#L29-L32\\n *\\n * @internal\\n */\\n\\nconst NonceAccountLayout = _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('version'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('state'), publicKey('authorizedPubkey'), publicKey('nonce'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([FeeCalculatorLayout], 'feeCalculator')]);\\nconst NONCE_ACCOUNT_LENGTH = NonceAccountLayout.span;\\n/**\\n * A durable nonce is a 32 byte value encoded as a base58 string.\\n */\\n\\n/**\\n * NonceAccount class\\n */\\nclass NonceAccount {\\n  /**\\n   * @internal\\n   */\\n  constructor(args) {\\n    this.authorizedPubkey = void 0;\\n    this.nonce = void 0;\\n    this.feeCalculator = void 0;\\n    this.authorizedPubkey = args.authorizedPubkey;\\n    this.nonce = args.nonce;\\n    this.feeCalculator = args.feeCalculator;\\n  }\\n  /**\\n   * Deserialize NonceAccount from the account data.\\n   *\\n   * @param buffer account data\\n   * @return NonceAccount\\n   */\\n\\n\\n  static fromAccountData(buffer) {\\n    const nonceAccount = NonceAccountLayout.decode(toBuffer(buffer), 0);\\n    return new NonceAccount({\\n      authorizedPubkey: new PublicKey(nonceAccount.authorizedPubkey),\\n      nonce: new PublicKey(nonceAccount.nonce).toString(),\\n      feeCalculator: nonceAccount.feeCalculator\\n    });\\n  }\\n\\n}\\n\\nconst encodeDecode = layout => {\\n  const decode = layout.decode.bind(layout);\\n  const encode = layout.encode.bind(layout);\\n  return {\\n    decode,\\n    encode\\n  };\\n};\\n\\nconst bigInt = length => property => {\\n  const layout = (0,_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.blob)(length, property);\\n  const {\\n    encode,\\n    decode\\n  } = encodeDecode(layout);\\n  const bigIntLayout = layout;\\n\\n  bigIntLayout.decode = (buffer, offset) => {\\n    const src = decode(buffer, offset);\\n    return (0,bigint_buffer__WEBPACK_IMPORTED_MODULE_8__.toBigIntLE)(buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.from(src));\\n  };\\n\\n  bigIntLayout.encode = (bigInt, buffer, offset) => {\\n    const src = (0,bigint_buffer__WEBPACK_IMPORTED_MODULE_8__.toBufferLE)(bigInt, length);\\n    return encode(src, buffer, offset);\\n  };\\n\\n  return bigIntLayout;\\n};\\n\\nconst u64 = bigInt(8);\\n\\n/**\\n * Create account system transaction params\\n */\\n\\n/**\\n * System Instruction class\\n */\\nclass SystemInstruction {\\n  /**\\n   * @internal\\n   */\\n  constructor() {}\\n  /**\\n   * Decode a system instruction and retrieve the instruction type.\\n   */\\n\\n\\n  static decodeInstructionType(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    const instructionTypeLayout = _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction');\\n    const typeIndex = instructionTypeLayout.decode(instruction.data);\\n    let type;\\n\\n    for (const [ixType, layout] of Object.entries(SYSTEM_INSTRUCTION_LAYOUTS)) {\\n      if (layout.index == typeIndex) {\\n        type = ixType;\\n        break;\\n      }\\n    }\\n\\n    if (!type) {\\n      throw new Error('Instruction type incorrect; not a SystemInstruction');\\n    }\\n\\n    return type;\\n  }\\n  /**\\n   * Decode a create account system instruction and retrieve the instruction params.\\n   */\\n\\n\\n  static decodeCreateAccount(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    this.checkKeyLength(instruction.keys, 2);\\n    const {\\n      lamports,\\n      space,\\n      programId\\n    } = decodeData$1(SYSTEM_INSTRUCTION_LAYOUTS.Create, instruction.data);\\n    return {\\n      fromPubkey: instruction.keys[0].pubkey,\\n      newAccountPubkey: instruction.keys[1].pubkey,\\n      lamports,\\n      space,\\n      programId: new PublicKey(programId)\\n    };\\n  }\\n  /**\\n   * Decode a transfer system instruction and retrieve the instruction params.\\n   */\\n\\n\\n  static decodeTransfer(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    this.checkKeyLength(instruction.keys, 2);\\n    const {\\n      lamports\\n    } = decodeData$1(SYSTEM_INSTRUCTION_LAYOUTS.Transfer, instruction.data);\\n    return {\\n      fromPubkey: instruction.keys[0].pubkey,\\n      toPubkey: instruction.keys[1].pubkey,\\n      lamports\\n    };\\n  }\\n  /**\\n   * Decode a transfer with seed system instruction and retrieve the instruction params.\\n   */\\n\\n\\n  static decodeTransferWithSeed(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    this.checkKeyLength(instruction.keys, 3);\\n    const {\\n      lamports,\\n      seed,\\n      programId\\n    } = decodeData$1(SYSTEM_INSTRUCTION_LAYOUTS.TransferWithSeed, instruction.data);\\n    return {\\n      fromPubkey: instruction.keys[0].pubkey,\\n      basePubkey: instruction.keys[1].pubkey,\\n      toPubkey: instruction.keys[2].pubkey,\\n      lamports,\\n      seed,\\n      programId: new PublicKey(programId)\\n    };\\n  }\\n  /**\\n   * Decode an allocate system instruction and retrieve the instruction params.\\n   */\\n\\n\\n  static decodeAllocate(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    this.checkKeyLength(instruction.keys, 1);\\n    const {\\n      space\\n    } = decodeData$1(SYSTEM_INSTRUCTION_LAYOUTS.Allocate, instruction.data);\\n    return {\\n      accountPubkey: instruction.keys[0].pubkey,\\n      space\\n    };\\n  }\\n  /**\\n   * Decode an allocate with seed system instruction and retrieve the instruction params.\\n   */\\n\\n\\n  static decodeAllocateWithSeed(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    this.checkKeyLength(instruction.keys, 1);\\n    const {\\n      base,\\n      seed,\\n      space,\\n      programId\\n    } = decodeData$1(SYSTEM_INSTRUCTION_LAYOUTS.AllocateWithSeed, instruction.data);\\n    return {\\n      accountPubkey: instruction.keys[0].pubkey,\\n      basePubkey: new PublicKey(base),\\n      seed,\\n      space,\\n      programId: new PublicKey(programId)\\n    };\\n  }\\n  /**\\n   * Decode an assign system instruction and retrieve the instruction params.\\n   */\\n\\n\\n  static decodeAssign(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    this.checkKeyLength(instruction.keys, 1);\\n    const {\\n      programId\\n    } = decodeData$1(SYSTEM_INSTRUCTION_LAYOUTS.Assign, instruction.data);\\n    return {\\n      accountPubkey: instruction.keys[0].pubkey,\\n      programId: new PublicKey(programId)\\n    };\\n  }\\n  /**\\n   * Decode an assign with seed system instruction and retrieve the instruction params.\\n   */\\n\\n\\n  static decodeAssignWithSeed(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    this.checkKeyLength(instruction.keys, 1);\\n    const {\\n      base,\\n      seed,\\n      programId\\n    } = decodeData$1(SYSTEM_INSTRUCTION_LAYOUTS.AssignWithSeed, instruction.data);\\n    return {\\n      accountPubkey: instruction.keys[0].pubkey,\\n      basePubkey: new PublicKey(base),\\n      seed,\\n      programId: new PublicKey(programId)\\n    };\\n  }\\n  /**\\n   * Decode a create account with seed system instruction and retrieve the instruction params.\\n   */\\n\\n\\n  static decodeCreateWithSeed(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    this.checkKeyLength(instruction.keys, 2);\\n    const {\\n      base,\\n      seed,\\n      lamports,\\n      space,\\n      programId\\n    } = decodeData$1(SYSTEM_INSTRUCTION_LAYOUTS.CreateWithSeed, instruction.data);\\n    return {\\n      fromPubkey: instruction.keys[0].pubkey,\\n      newAccountPubkey: instruction.keys[1].pubkey,\\n      basePubkey: new PublicKey(base),\\n      seed,\\n      lamports,\\n      space,\\n      programId: new PublicKey(programId)\\n    };\\n  }\\n  /**\\n   * Decode a nonce initialize system instruction and retrieve the instruction params.\\n   */\\n\\n\\n  static decodeNonceInitialize(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    this.checkKeyLength(instruction.keys, 3);\\n    const {\\n      authorized\\n    } = decodeData$1(SYSTEM_INSTRUCTION_LAYOUTS.InitializeNonceAccount, instruction.data);\\n    return {\\n      noncePubkey: instruction.keys[0].pubkey,\\n      authorizedPubkey: new PublicKey(authorized)\\n    };\\n  }\\n  /**\\n   * Decode a nonce advance system instruction and retrieve the instruction params.\\n   */\\n\\n\\n  static decodeNonceAdvance(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    this.checkKeyLength(instruction.keys, 3);\\n    decodeData$1(SYSTEM_INSTRUCTION_LAYOUTS.AdvanceNonceAccount, instruction.data);\\n    return {\\n      noncePubkey: instruction.keys[0].pubkey,\\n      authorizedPubkey: instruction.keys[2].pubkey\\n    };\\n  }\\n  /**\\n   * Decode a nonce withdraw system instruction and retrieve the instruction params.\\n   */\\n\\n\\n  static decodeNonceWithdraw(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    this.checkKeyLength(instruction.keys, 5);\\n    const {\\n      lamports\\n    } = decodeData$1(SYSTEM_INSTRUCTION_LAYOUTS.WithdrawNonceAccount, instruction.data);\\n    return {\\n      noncePubkey: instruction.keys[0].pubkey,\\n      toPubkey: instruction.keys[1].pubkey,\\n      authorizedPubkey: instruction.keys[4].pubkey,\\n      lamports\\n    };\\n  }\\n  /**\\n   * Decode a nonce authorize system instruction and retrieve the instruction params.\\n   */\\n\\n\\n  static decodeNonceAuthorize(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    this.checkKeyLength(instruction.keys, 2);\\n    const {\\n      authorized\\n    } = decodeData$1(SYSTEM_INSTRUCTION_LAYOUTS.AuthorizeNonceAccount, instruction.data);\\n    return {\\n      noncePubkey: instruction.keys[0].pubkey,\\n      authorizedPubkey: instruction.keys[1].pubkey,\\n      newAuthorizedPubkey: new PublicKey(authorized)\\n    };\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  static checkProgramId(programId) {\\n    if (!programId.equals(SystemProgram.programId)) {\\n      throw new Error('invalid instruction; programId is not SystemProgram');\\n    }\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  static checkKeyLength(keys, expectedLength) {\\n    if (keys.length < expectedLength) {\\n      throw new Error(`invalid instruction; found ${keys.length} keys, expected at least ${expectedLength}`);\\n    }\\n  }\\n\\n}\\n/**\\n * An enumeration of valid SystemInstructionType's\\n */\\n\\n/**\\n * An enumeration of valid system InstructionType's\\n * @internal\\n */\\nconst SYSTEM_INSTRUCTION_LAYOUTS = Object.freeze({\\n  Create: {\\n    index: 0,\\n    layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.ns64('lamports'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.ns64('space'), publicKey('programId')])\\n  },\\n  Assign: {\\n    index: 1,\\n    layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction'), publicKey('programId')])\\n  },\\n  Transfer: {\\n    index: 2,\\n    layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction'), u64('lamports')])\\n  },\\n  CreateWithSeed: {\\n    index: 3,\\n    layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction'), publicKey('base'), rustString('seed'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.ns64('lamports'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.ns64('space'), publicKey('programId')])\\n  },\\n  AdvanceNonceAccount: {\\n    index: 4,\\n    layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction')])\\n  },\\n  WithdrawNonceAccount: {\\n    index: 5,\\n    layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.ns64('lamports')])\\n  },\\n  InitializeNonceAccount: {\\n    index: 6,\\n    layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction'), publicKey('authorized')])\\n  },\\n  AuthorizeNonceAccount: {\\n    index: 7,\\n    layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction'), publicKey('authorized')])\\n  },\\n  Allocate: {\\n    index: 8,\\n    layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.ns64('space')])\\n  },\\n  AllocateWithSeed: {\\n    index: 9,\\n    layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction'), publicKey('base'), rustString('seed'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.ns64('space'), publicKey('programId')])\\n  },\\n  AssignWithSeed: {\\n    index: 10,\\n    layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction'), publicKey('base'), rustString('seed'), publicKey('programId')])\\n  },\\n  TransferWithSeed: {\\n    index: 11,\\n    layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction'), u64('lamports'), rustString('seed'), publicKey('programId')])\\n  },\\n  UpgradeNonceAccount: {\\n    index: 12,\\n    layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction')])\\n  }\\n});\\n/**\\n * Factory class for transactions to interact with the System program\\n */\\n\\nclass SystemProgram {\\n  /**\\n   * @internal\\n   */\\n  constructor() {}\\n  /**\\n   * Public key that identifies the System program\\n   */\\n\\n\\n  /**\\n   * Generate a transaction instruction that creates a new account\\n   */\\n  static createAccount(params) {\\n    const type = SYSTEM_INSTRUCTION_LAYOUTS.Create;\\n    const data = encodeData(type, {\\n      lamports: params.lamports,\\n      space: params.space,\\n      programId: toBuffer(params.programId.toBuffer())\\n    });\\n    return new TransactionInstruction({\\n      keys: [{\\n        pubkey: params.fromPubkey,\\n        isSigner: true,\\n        isWritable: true\\n      }, {\\n        pubkey: params.newAccountPubkey,\\n        isSigner: true,\\n        isWritable: true\\n      }],\\n      programId: this.programId,\\n      data\\n    });\\n  }\\n  /**\\n   * Generate a transaction instruction that transfers lamports from one account to another\\n   */\\n\\n\\n  static transfer(params) {\\n    let data;\\n    let keys;\\n\\n    if ('basePubkey' in params) {\\n      const type = SYSTEM_INSTRUCTION_LAYOUTS.TransferWithSeed;\\n      data = encodeData(type, {\\n        lamports: BigInt(params.lamports),\\n        seed: params.seed,\\n        programId: toBuffer(params.programId.toBuffer())\\n      });\\n      keys = [{\\n        pubkey: params.fromPubkey,\\n        isSigner: false,\\n        isWritable: true\\n      }, {\\n        pubkey: params.basePubkey,\\n        isSigner: true,\\n        isWritable: false\\n      }, {\\n        pubkey: params.toPubkey,\\n        isSigner: false,\\n        isWritable: true\\n      }];\\n    } else {\\n      const type = SYSTEM_INSTRUCTION_LAYOUTS.Transfer;\\n      data = encodeData(type, {\\n        lamports: BigInt(params.lamports)\\n      });\\n      keys = [{\\n        pubkey: params.fromPubkey,\\n        isSigner: true,\\n        isWritable: true\\n      }, {\\n        pubkey: params.toPubkey,\\n        isSigner: false,\\n        isWritable: true\\n      }];\\n    }\\n\\n    return new TransactionInstruction({\\n      keys,\\n      programId: this.programId,\\n      data\\n    });\\n  }\\n  /**\\n   * Generate a transaction instruction that assigns an account to a program\\n   */\\n\\n\\n  static assign(params) {\\n    let data;\\n    let keys;\\n\\n    if ('basePubkey' in params) {\\n      const type = SYSTEM_INSTRUCTION_LAYOUTS.AssignWithSeed;\\n      data = encodeData(type, {\\n        base: toBuffer(params.basePubkey.toBuffer()),\\n        seed: params.seed,\\n        programId: toBuffer(params.programId.toBuffer())\\n      });\\n      keys = [{\\n        pubkey: params.accountPubkey,\\n        isSigner: false,\\n        isWritable: true\\n      }, {\\n        pubkey: params.basePubkey,\\n        isSigner: true,\\n        isWritable: false\\n      }];\\n    } else {\\n      const type = SYSTEM_INSTRUCTION_LAYOUTS.Assign;\\n      data = encodeData(type, {\\n        programId: toBuffer(params.programId.toBuffer())\\n      });\\n      keys = [{\\n        pubkey: params.accountPubkey,\\n        isSigner: true,\\n        isWritable: true\\n      }];\\n    }\\n\\n    return new TransactionInstruction({\\n      keys,\\n      programId: this.programId,\\n      data\\n    });\\n  }\\n  /**\\n   * Generate a transaction instruction that creates a new account at\\n   *   an address generated with `from`, a seed, and programId\\n   */\\n\\n\\n  static createAccountWithSeed(params) {\\n    const type = SYSTEM_INSTRUCTION_LAYOUTS.CreateWithSeed;\\n    const data = encodeData(type, {\\n      base: toBuffer(params.basePubkey.toBuffer()),\\n      seed: params.seed,\\n      lamports: params.lamports,\\n      space: params.space,\\n      programId: toBuffer(params.programId.toBuffer())\\n    });\\n    let keys = [{\\n      pubkey: params.fromPubkey,\\n      isSigner: true,\\n      isWritable: true\\n    }, {\\n      pubkey: params.newAccountPubkey,\\n      isSigner: false,\\n      isWritable: true\\n    }];\\n\\n    if (params.basePubkey != params.fromPubkey) {\\n      keys.push({\\n        pubkey: params.basePubkey,\\n        isSigner: true,\\n        isWritable: false\\n      });\\n    }\\n\\n    return new TransactionInstruction({\\n      keys,\\n      programId: this.programId,\\n      data\\n    });\\n  }\\n  /**\\n   * Generate a transaction that creates a new Nonce account\\n   */\\n\\n\\n  static createNonceAccount(params) {\\n    const transaction = new Transaction();\\n\\n    if ('basePubkey' in params && 'seed' in params) {\\n      transaction.add(SystemProgram.createAccountWithSeed({\\n        fromPubkey: params.fromPubkey,\\n        newAccountPubkey: params.noncePubkey,\\n        basePubkey: params.basePubkey,\\n        seed: params.seed,\\n        lamports: params.lamports,\\n        space: NONCE_ACCOUNT_LENGTH,\\n        programId: this.programId\\n      }));\\n    } else {\\n      transaction.add(SystemProgram.createAccount({\\n        fromPubkey: params.fromPubkey,\\n        newAccountPubkey: params.noncePubkey,\\n        lamports: params.lamports,\\n        space: NONCE_ACCOUNT_LENGTH,\\n        programId: this.programId\\n      }));\\n    }\\n\\n    const initParams = {\\n      noncePubkey: params.noncePubkey,\\n      authorizedPubkey: params.authorizedPubkey\\n    };\\n    transaction.add(this.nonceInitialize(initParams));\\n    return transaction;\\n  }\\n  /**\\n   * Generate an instruction to initialize a Nonce account\\n   */\\n\\n\\n  static nonceInitialize(params) {\\n    const type = SYSTEM_INSTRUCTION_LAYOUTS.InitializeNonceAccount;\\n    const data = encodeData(type, {\\n      authorized: toBuffer(params.authorizedPubkey.toBuffer())\\n    });\\n    const instructionData = {\\n      keys: [{\\n        pubkey: params.noncePubkey,\\n        isSigner: false,\\n        isWritable: true\\n      }, {\\n        pubkey: SYSVAR_RECENT_BLOCKHASHES_PUBKEY,\\n        isSigner: false,\\n        isWritable: false\\n      }, {\\n        pubkey: SYSVAR_RENT_PUBKEY,\\n        isSigner: false,\\n        isWritable: false\\n      }],\\n      programId: this.programId,\\n      data\\n    };\\n    return new TransactionInstruction(instructionData);\\n  }\\n  /**\\n   * Generate an instruction to advance the nonce in a Nonce account\\n   */\\n\\n\\n  static nonceAdvance(params) {\\n    const type = SYSTEM_INSTRUCTION_LAYOUTS.AdvanceNonceAccount;\\n    const data = encodeData(type);\\n    const instructionData = {\\n      keys: [{\\n        pubkey: params.noncePubkey,\\n        isSigner: false,\\n        isWritable: true\\n      }, {\\n        pubkey: SYSVAR_RECENT_BLOCKHASHES_PUBKEY,\\n        isSigner: false,\\n        isWritable: false\\n      }, {\\n        pubkey: params.authorizedPubkey,\\n        isSigner: true,\\n        isWritable: false\\n      }],\\n      programId: this.programId,\\n      data\\n    };\\n    return new TransactionInstruction(instructionData);\\n  }\\n  /**\\n   * Generate a transaction instruction that withdraws lamports from a Nonce account\\n   */\\n\\n\\n  static nonceWithdraw(params) {\\n    const type = SYSTEM_INSTRUCTION_LAYOUTS.WithdrawNonceAccount;\\n    const data = encodeData(type, {\\n      lamports: params.lamports\\n    });\\n    return new TransactionInstruction({\\n      keys: [{\\n        pubkey: params.noncePubkey,\\n        isSigner: false,\\n        isWritable: true\\n      }, {\\n        pubkey: params.toPubkey,\\n        isSigner: false,\\n        isWritable: true\\n      }, {\\n        pubkey: SYSVAR_RECENT_BLOCKHASHES_PUBKEY,\\n        isSigner: false,\\n        isWritable: false\\n      }, {\\n        pubkey: SYSVAR_RENT_PUBKEY,\\n        isSigner: false,\\n        isWritable: false\\n      }, {\\n        pubkey: params.authorizedPubkey,\\n        isSigner: true,\\n        isWritable: false\\n      }],\\n      programId: this.programId,\\n      data\\n    });\\n  }\\n  /**\\n   * Generate a transaction instruction that authorizes a new PublicKey as the authority\\n   * on a Nonce account.\\n   */\\n\\n\\n  static nonceAuthorize(params) {\\n    const type = SYSTEM_INSTRUCTION_LAYOUTS.AuthorizeNonceAccount;\\n    const data = encodeData(type, {\\n      authorized: toBuffer(params.newAuthorizedPubkey.toBuffer())\\n    });\\n    return new TransactionInstruction({\\n      keys: [{\\n        pubkey: params.noncePubkey,\\n        isSigner: false,\\n        isWritable: true\\n      }, {\\n        pubkey: params.authorizedPubkey,\\n        isSigner: true,\\n        isWritable: false\\n      }],\\n      programId: this.programId,\\n      data\\n    });\\n  }\\n  /**\\n   * Generate a transaction instruction that allocates space in an account without funding\\n   */\\n\\n\\n  static allocate(params) {\\n    let data;\\n    let keys;\\n\\n    if ('basePubkey' in params) {\\n      const type = SYSTEM_INSTRUCTION_LAYOUTS.AllocateWithSeed;\\n      data = encodeData(type, {\\n        base: toBuffer(params.basePubkey.toBuffer()),\\n        seed: params.seed,\\n        space: params.space,\\n        programId: toBuffer(params.programId.toBuffer())\\n      });\\n      keys = [{\\n        pubkey: params.accountPubkey,\\n        isSigner: false,\\n        isWritable: true\\n      }, {\\n        pubkey: params.basePubkey,\\n        isSigner: true,\\n        isWritable: false\\n      }];\\n    } else {\\n      const type = SYSTEM_INSTRUCTION_LAYOUTS.Allocate;\\n      data = encodeData(type, {\\n        space: params.space\\n      });\\n      keys = [{\\n        pubkey: params.accountPubkey,\\n        isSigner: true,\\n        isWritable: true\\n      }];\\n    }\\n\\n    return new TransactionInstruction({\\n      keys,\\n      programId: this.programId,\\n      data\\n    });\\n  }\\n\\n}\\nSystemProgram.programId = new PublicKey('11111111111111111111111111111111');\\n\\n// Keep program chunks under PACKET_DATA_SIZE, leaving enough room for the\\n// rest of the Transaction fields\\n//\\n// TODO: replace 300 with a proper constant for the size of the other\\n// Transaction fields\\nconst CHUNK_SIZE = PACKET_DATA_SIZE - 300;\\n/**\\n * Program loader interface\\n */\\n\\nclass Loader {\\n  /**\\n   * @internal\\n   */\\n  constructor() {}\\n  /**\\n   * Amount of program data placed in each load Transaction\\n   */\\n\\n\\n  /**\\n   * Minimum number of signatures required to load a program not including\\n   * retries\\n   *\\n   * Can be used to calculate transaction fees\\n   */\\n  static getMinNumSignatures(dataLength) {\\n    return 2 * ( // Every transaction requires two signatures (payer + program)\\n    Math.ceil(dataLength / Loader.chunkSize) + 1 + // Add one for Create transaction\\n    1) // Add one for Finalize transaction\\n    ;\\n  }\\n  /**\\n   * Loads a generic program\\n   *\\n   * @param connection The connection to use\\n   * @param payer System account that pays to load the program\\n   * @param program Account to load the program into\\n   * @param programId Public key that identifies the loader\\n   * @param data Program octets\\n   * @return true if program was loaded successfully, false if program was already loaded\\n   */\\n\\n\\n  static async load(connection, payer, program, programId, data) {\\n    {\\n      const balanceNeeded = await connection.getMinimumBalanceForRentExemption(data.length); // Fetch program account info to check if it has already been created\\n\\n      const programInfo = await connection.getAccountInfo(program.publicKey, 'confirmed');\\n      let transaction = null;\\n\\n      if (programInfo !== null) {\\n        if (programInfo.executable) {\\n          console.error('Program load failed, account is already executable');\\n          return false;\\n        }\\n\\n        if (programInfo.data.length !== data.length) {\\n          transaction = transaction || new Transaction();\\n          transaction.add(SystemProgram.allocate({\\n            accountPubkey: program.publicKey,\\n            space: data.length\\n          }));\\n        }\\n\\n        if (!programInfo.owner.equals(programId)) {\\n          transaction = transaction || new Transaction();\\n          transaction.add(SystemProgram.assign({\\n            accountPubkey: program.publicKey,\\n            programId\\n          }));\\n        }\\n\\n        if (programInfo.lamports < balanceNeeded) {\\n          transaction = transaction || new Transaction();\\n          transaction.add(SystemProgram.transfer({\\n            fromPubkey: payer.publicKey,\\n            toPubkey: program.publicKey,\\n            lamports: balanceNeeded - programInfo.lamports\\n          }));\\n        }\\n      } else {\\n        transaction = new Transaction().add(SystemProgram.createAccount({\\n          fromPubkey: payer.publicKey,\\n          newAccountPubkey: program.publicKey,\\n          lamports: balanceNeeded > 0 ? balanceNeeded : 1,\\n          space: data.length,\\n          programId\\n        }));\\n      } // If the account is already created correctly, skip this step\\n      // and proceed directly to loading instructions\\n\\n\\n      if (transaction !== null) {\\n        await sendAndConfirmTransaction(connection, transaction, [payer, program], {\\n          commitment: 'confirmed'\\n        });\\n      }\\n    }\\n    const dataLayout = _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('offset'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('bytesLength'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('bytesLengthPadding'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.seq(_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u8('byte'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.offset(_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32(), -8), 'bytes')]);\\n    const chunkSize = Loader.chunkSize;\\n    let offset = 0;\\n    let array = data;\\n    let transactions = [];\\n\\n    while (array.length > 0) {\\n      const bytes = array.slice(0, chunkSize);\\n      const data = buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.alloc(chunkSize + 16);\\n      dataLayout.encode({\\n        instruction: 0,\\n        // Load instruction\\n        offset,\\n        bytes: bytes,\\n        bytesLength: 0,\\n        bytesLengthPadding: 0\\n      }, data);\\n      const transaction = new Transaction().add({\\n        keys: [{\\n          pubkey: program.publicKey,\\n          isSigner: true,\\n          isWritable: true\\n        }],\\n        programId,\\n        data\\n      });\\n      transactions.push(sendAndConfirmTransaction(connection, transaction, [payer, program], {\\n        commitment: 'confirmed'\\n      })); // Delay between sends in an attempt to reduce rate limit errors\\n\\n      if (connection._rpcEndpoint.includes('solana.com')) {\\n        const REQUESTS_PER_SECOND = 4;\\n        await sleep(1000 / REQUESTS_PER_SECOND);\\n      }\\n\\n      offset += chunkSize;\\n      array = array.slice(chunkSize);\\n    }\\n\\n    await Promise.all(transactions); // Finalize the account loaded with program data for execution\\n\\n    {\\n      const dataLayout = _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction')]);\\n      const data = buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.alloc(dataLayout.span);\\n      dataLayout.encode({\\n        instruction: 1 // Finalize instruction\\n\\n      }, data);\\n      const transaction = new Transaction().add({\\n        keys: [{\\n          pubkey: program.publicKey,\\n          isSigner: true,\\n          isWritable: true\\n        }, {\\n          pubkey: SYSVAR_RENT_PUBKEY,\\n          isSigner: false,\\n          isWritable: false\\n        }],\\n        programId,\\n        data\\n      });\\n      await sendAndConfirmTransaction(connection, transaction, [payer, program], {\\n        commitment: 'confirmed'\\n      });\\n    } // success\\n\\n    return true;\\n  }\\n\\n}\\nLoader.chunkSize = CHUNK_SIZE;\\n\\nconst BPF_LOADER_PROGRAM_ID = new PublicKey('BPFLoader2111111111111111111111111111111111');\\n/**\\n * Factory class for transactions to interact with a program loader\\n */\\n\\nclass BpfLoader {\\n  /**\\n   * Minimum number of signatures required to load a program not including\\n   * retries\\n   *\\n   * Can be used to calculate transaction fees\\n   */\\n  static getMinNumSignatures(dataLength) {\\n    return Loader.getMinNumSignatures(dataLength);\\n  }\\n  /**\\n   * Load a SBF program\\n   *\\n   * @param connection The connection to use\\n   * @param payer Account that will pay program loading fees\\n   * @param program Account to load the program into\\n   * @param elf The entire ELF containing the SBF program\\n   * @param loaderProgramId The program id of the BPF loader to use\\n   * @return true if program was loaded successfully, false if program was already loaded\\n   */\\n\\n\\n  static load(connection, payer, program, elf, loaderProgramId) {\\n    return Loader.load(connection, payer, program, loaderProgramId, elf);\\n  }\\n\\n}\\n\\nvar objToString = Object.prototype.toString;\\nvar objKeys = Object.keys || function(obj) {\\n\\t\\tvar keys = [];\\n\\t\\tfor (var name in obj) {\\n\\t\\t\\tkeys.push(name);\\n\\t\\t}\\n\\t\\treturn keys;\\n\\t};\\n\\nfunction stringify(val, isArrayProp) {\\n\\tvar i, max, str, keys, key, propVal, toStr;\\n\\tif (val === true) {\\n\\t\\treturn \\\"true\\\";\\n\\t}\\n\\tif (val === false) {\\n\\t\\treturn \\\"false\\\";\\n\\t}\\n\\tswitch (typeof val) {\\n\\t\\tcase \\\"object\\\":\\n\\t\\t\\tif (val === null) {\\n\\t\\t\\t\\treturn null;\\n\\t\\t\\t} else if (val.toJSON && typeof val.toJSON === \\\"function\\\") {\\n\\t\\t\\t\\treturn stringify(val.toJSON(), isArrayProp);\\n\\t\\t\\t} else {\\n\\t\\t\\t\\ttoStr = objToString.call(val);\\n\\t\\t\\t\\tif (toStr === \\\"[object Array]\\\") {\\n\\t\\t\\t\\t\\tstr = '[';\\n\\t\\t\\t\\t\\tmax = val.length - 1;\\n\\t\\t\\t\\t\\tfor(i = 0; i < max; i++) {\\n\\t\\t\\t\\t\\t\\tstr += stringify(val[i], true) + ',';\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\tif (max > -1) {\\n\\t\\t\\t\\t\\t\\tstr += stringify(val[i], true);\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\treturn str + ']';\\n\\t\\t\\t\\t} else if (toStr === \\\"[object Object]\\\") {\\n\\t\\t\\t\\t\\t// only object is left\\n\\t\\t\\t\\t\\tkeys = objKeys(val).sort();\\n\\t\\t\\t\\t\\tmax = keys.length;\\n\\t\\t\\t\\t\\tstr = \\\"\\\";\\n\\t\\t\\t\\t\\ti = 0;\\n\\t\\t\\t\\t\\twhile (i < max) {\\n\\t\\t\\t\\t\\t\\tkey = keys[i];\\n\\t\\t\\t\\t\\t\\tpropVal = stringify(val[key], false);\\n\\t\\t\\t\\t\\t\\tif (propVal !== undefined) {\\n\\t\\t\\t\\t\\t\\t\\tif (str) {\\n\\t\\t\\t\\t\\t\\t\\t\\tstr += ',';\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t\\t\\tstr += JSON.stringify(key) + ':' + propVal;\\n\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t\\ti++;\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\treturn '{' + str + '}';\\n\\t\\t\\t\\t} else {\\n\\t\\t\\t\\t\\treturn JSON.stringify(val);\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\tcase \\\"function\\\":\\n\\t\\tcase \\\"undefined\\\":\\n\\t\\t\\treturn isArrayProp ? null : undefined;\\n\\t\\tcase \\\"string\\\":\\n\\t\\t\\treturn JSON.stringify(val);\\n\\t\\tdefault:\\n\\t\\t\\treturn isFinite(val) ? val : null;\\n\\t}\\n}\\n\\nvar fastStableStringify = function(val) {\\n\\tvar returnVal = stringify(val, false);\\n\\tif (returnVal !== undefined) {\\n\\t\\treturn ''+ returnVal;\\n\\t}\\n};\\n\\nvar fastStableStringify$1 = fastStableStringify;\\n\\nconst MINIMUM_SLOT_PER_EPOCH = 32; // Returns the number of trailing zeros in the binary representation of self.\\n\\nfunction trailingZeros(n) {\\n  let trailingZeros = 0;\\n\\n  while (n > 1) {\\n    n /= 2;\\n    trailingZeros++;\\n  }\\n\\n  return trailingZeros;\\n} // Returns the smallest power of two greater than or equal to n\\n\\n\\nfunction nextPowerOfTwo(n) {\\n  if (n === 0) return 1;\\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 >> 32;\\n  return n + 1;\\n}\\n/**\\n * Epoch schedule\\n * (see https://docs.solana.com/terminology#epoch)\\n * Can be retrieved with the {@link Connection.getEpochSchedule} method\\n */\\n\\n\\nclass EpochSchedule {\\n  /** The maximum number of slots in each epoch */\\n\\n  /** The number of slots before beginning of an epoch to calculate a leader schedule for that epoch */\\n\\n  /** Indicates whether epochs start short and grow */\\n\\n  /** The first epoch with `slotsPerEpoch` slots */\\n\\n  /** The first slot of `firstNormalEpoch` */\\n  constructor(slotsPerEpoch, leaderScheduleSlotOffset, warmup, firstNormalEpoch, firstNormalSlot) {\\n    this.slotsPerEpoch = void 0;\\n    this.leaderScheduleSlotOffset = void 0;\\n    this.warmup = void 0;\\n    this.firstNormalEpoch = void 0;\\n    this.firstNormalSlot = void 0;\\n    this.slotsPerEpoch = slotsPerEpoch;\\n    this.leaderScheduleSlotOffset = leaderScheduleSlotOffset;\\n    this.warmup = warmup;\\n    this.firstNormalEpoch = firstNormalEpoch;\\n    this.firstNormalSlot = firstNormalSlot;\\n  }\\n\\n  getEpoch(slot) {\\n    return this.getEpochAndSlotIndex(slot)[0];\\n  }\\n\\n  getEpochAndSlotIndex(slot) {\\n    if (slot < this.firstNormalSlot) {\\n      const epoch = trailingZeros(nextPowerOfTwo(slot + MINIMUM_SLOT_PER_EPOCH + 1)) - trailingZeros(MINIMUM_SLOT_PER_EPOCH) - 1;\\n      const epochLen = this.getSlotsInEpoch(epoch);\\n      const slotIndex = slot - (epochLen - MINIMUM_SLOT_PER_EPOCH);\\n      return [epoch, slotIndex];\\n    } else {\\n      const normalSlotIndex = slot - this.firstNormalSlot;\\n      const normalEpochIndex = Math.floor(normalSlotIndex / this.slotsPerEpoch);\\n      const epoch = this.firstNormalEpoch + normalEpochIndex;\\n      const slotIndex = normalSlotIndex % this.slotsPerEpoch;\\n      return [epoch, slotIndex];\\n    }\\n  }\\n\\n  getFirstSlotInEpoch(epoch) {\\n    if (epoch <= this.firstNormalEpoch) {\\n      return (Math.pow(2, epoch) - 1) * MINIMUM_SLOT_PER_EPOCH;\\n    } else {\\n      return (epoch - this.firstNormalEpoch) * this.slotsPerEpoch + this.firstNormalSlot;\\n    }\\n  }\\n\\n  getLastSlotInEpoch(epoch) {\\n    return this.getFirstSlotInEpoch(epoch) + this.getSlotsInEpoch(epoch) - 1;\\n  }\\n\\n  getSlotsInEpoch(epoch) {\\n    if (epoch < this.firstNormalEpoch) {\\n      return Math.pow(2, epoch + trailingZeros(MINIMUM_SLOT_PER_EPOCH));\\n    } else {\\n      return this.slotsPerEpoch;\\n    }\\n  }\\n\\n}\\n\\nclass SendTransactionError extends Error {\\n  constructor(message, logs) {\\n    super(message);\\n    this.logs = void 0;\\n    this.logs = logs;\\n  }\\n\\n} // Keep in sync with client/src/rpc_custom_errors.rs\\n// Typescript `enums` thwart tree-shaking. See https://bargsten.org/jsts/enums/\\n\\nconst SolanaJSONRPCErrorCode = {\\n  JSON_RPC_SERVER_ERROR_BLOCK_CLEANED_UP: -32001,\\n  JSON_RPC_SERVER_ERROR_SEND_TRANSACTION_PREFLIGHT_FAILURE: -32002,\\n  JSON_RPC_SERVER_ERROR_TRANSACTION_SIGNATURE_VERIFICATION_FAILURE: -32003,\\n  JSON_RPC_SERVER_ERROR_BLOCK_NOT_AVAILABLE: -32004,\\n  JSON_RPC_SERVER_ERROR_NODE_UNHEALTHY: -32005,\\n  JSON_RPC_SERVER_ERROR_TRANSACTION_PRECOMPILE_VERIFICATION_FAILURE: -32006,\\n  JSON_RPC_SERVER_ERROR_SLOT_SKIPPED: -32007,\\n  JSON_RPC_SERVER_ERROR_NO_SNAPSHOT: -32008,\\n  JSON_RPC_SERVER_ERROR_LONG_TERM_STORAGE_SLOT_SKIPPED: -32009,\\n  JSON_RPC_SERVER_ERROR_KEY_EXCLUDED_FROM_SECONDARY_INDEX: -32010,\\n  JSON_RPC_SERVER_ERROR_TRANSACTION_HISTORY_NOT_AVAILABLE: -32011,\\n  JSON_RPC_SCAN_ERROR: -32012,\\n  JSON_RPC_SERVER_ERROR_TRANSACTION_SIGNATURE_LEN_MISMATCH: -32013,\\n  JSON_RPC_SERVER_ERROR_BLOCK_STATUS_NOT_AVAILABLE_YET: -32014,\\n  JSON_RPC_SERVER_ERROR_UNSUPPORTED_TRANSACTION_VERSION: -32015,\\n  JSON_RPC_SERVER_ERROR_MIN_CONTEXT_SLOT_NOT_REACHED: -32016\\n};\\nclass SolanaJSONRPCError extends Error {\\n  constructor({\\n    code,\\n    message,\\n    data\\n  }, customMessage) {\\n    super(customMessage != null ? `${customMessage}: ${message}` : message);\\n    this.code = void 0;\\n    this.data = void 0;\\n    this.code = code;\\n    this.data = data;\\n    this.name = 'SolanaJSONRPCError';\\n  }\\n\\n}\\n\\nvar fetchImpl = globalThis.fetch;\\n\\n// TODO: These constants should be removed in favor of reading them out of a\\n// Syscall account\\n\\n/**\\n * @internal\\n */\\nconst NUM_TICKS_PER_SECOND = 160;\\n/**\\n * @internal\\n */\\n\\nconst DEFAULT_TICKS_PER_SLOT = 64;\\n/**\\n * @internal\\n */\\n\\nconst NUM_SLOTS_PER_SECOND = NUM_TICKS_PER_SECOND / DEFAULT_TICKS_PER_SLOT;\\n/**\\n * @internal\\n */\\n\\nconst MS_PER_SLOT = 1000 / NUM_SLOTS_PER_SECOND;\\n\\n/**\\n * @internal\\n */\\n\\n/**\\n * Decode account data buffer using an AccountType\\n * @internal\\n */\\nfunction decodeData(type, data) {\\n  let decoded;\\n\\n  try {\\n    decoded = type.layout.decode(data);\\n  } catch (err) {\\n    throw new Error('invalid instruction; ' + err);\\n  }\\n\\n  if (decoded.typeIndex !== type.index) {\\n    throw new Error(`invalid account data; account type mismatch ${decoded.typeIndex} != ${type.index}`);\\n  }\\n\\n  return decoded;\\n}\\n\\n/// The serialized size of lookup table metadata\\nconst LOOKUP_TABLE_META_SIZE = 56;\\nclass AddressLookupTableAccount {\\n  constructor(args) {\\n    this.key = void 0;\\n    this.state = void 0;\\n    this.key = args.key;\\n    this.state = args.state;\\n  }\\n\\n  isActive() {\\n    const U64_MAX = BigInt('0xffffffffffffffff');\\n    return this.state.deactivationSlot === U64_MAX;\\n  }\\n\\n  static deserialize(accountData) {\\n    const meta = decodeData(LookupTableMetaLayout, accountData);\\n    const serializedAddressesLen = accountData.length - LOOKUP_TABLE_META_SIZE;\\n    assert(serializedAddressesLen >= 0, 'lookup table is invalid');\\n    assert(serializedAddressesLen % 32 === 0, 'lookup table is invalid');\\n    const numSerializedAddresses = serializedAddressesLen / 32;\\n    const {\\n      addresses\\n    } = _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.seq(publicKey(), numSerializedAddresses, 'addresses')]).decode(accountData.slice(LOOKUP_TABLE_META_SIZE));\\n    return {\\n      deactivationSlot: meta.deactivationSlot,\\n      lastExtendedSlot: meta.lastExtendedSlot,\\n      lastExtendedSlotStartIndex: meta.lastExtendedStartIndex,\\n      authority: meta.authority.length !== 0 ? new PublicKey(meta.authority[0]) : undefined,\\n      addresses: addresses.map(address => new PublicKey(address))\\n    };\\n  }\\n\\n}\\nconst LookupTableMetaLayout = {\\n  index: 1,\\n  layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('typeIndex'), u64('deactivationSlot'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.nu64('lastExtendedSlot'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u8('lastExtendedStartIndex'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u8(), // option\\n  _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.seq(publicKey(), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.offset(_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u8(), -1), 'authority')])\\n};\\n\\nconst URL_RE = /^[^:]+:\\\\/\\\\/([^:[]+|\\\\[[^\\\\]]+\\\\])(:\\\\d+)?(.*)/i;\\nfunction makeWebsocketUrl(endpoint) {\\n  const matches = endpoint.match(URL_RE);\\n\\n  if (matches == null) {\\n    throw TypeError(`Failed to validate endpoint URL \\\\`${endpoint}\\\\``);\\n  }\\n\\n  const [_, // eslint-disable-line @typescript-eslint/no-unused-vars\\n  hostish, portWithColon, rest] = matches;\\n  const protocol = endpoint.startsWith('https:') ? 'wss:' : 'ws:';\\n  const startPort = portWithColon == null ? null : parseInt(portWithColon.slice(1), 10);\\n  const websocketPort = // Only shift the port by +1 as a convention for ws(s) only if given endpoint\\n  // is explictly specifying the endpoint port (HTTP-based RPC), assuming\\n  // we're directly trying to connect to solana-validator's ws listening port.\\n  // When the endpoint omits the port, we're connecting to the protocol\\n  // default ports: http(80) or https(443) and it's assumed we're behind a reverse\\n  // proxy which manages WebSocket upgrade and backend port redirection.\\n  startPort == null ? '' : `:${startPort + 1}`;\\n  return `${protocol}//${hostish}${websocketPort}${rest}`;\\n}\\n\\nvar _process$env$npm_pack;\\nconst PublicKeyFromString = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.coerce)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.instance)(PublicKey), (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(), value => new PublicKey(value));\\nconst RawAccountDataResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.tuple)([(0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(), (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.literal)('base64')]);\\nconst BufferFromRawAccountData = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.coerce)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.instance)(buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer), RawAccountDataResult, value => buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.from(value[0], 'base64'));\\n/**\\n * Attempt to use a recent blockhash for up to 30 seconds\\n * @internal\\n */\\n\\nconst BLOCKHASH_CACHE_TIMEOUT_MS = 30 * 1000;\\n/**\\n * HACK.\\n * Copied from rpc-websockets/dist/lib/client.\\n * Otherwise, `yarn build` fails with:\\n * https://gist.github.com/steveluscher/c057eca81d479ef705cdb53162f9971d\\n */\\n\\n/* @internal */\\nfunction assertEndpointUrl(putativeUrl) {\\n  if (/^https?:/.test(putativeUrl) === false) {\\n    throw new TypeError('Endpoint URL must start with `http:` or `https:`.');\\n  }\\n\\n  return putativeUrl;\\n}\\n/** @internal */\\n\\n\\nfunction extractCommitmentFromConfig(commitmentOrConfig) {\\n  let commitment;\\n  let config;\\n\\n  if (typeof commitmentOrConfig === 'string') {\\n    commitment = commitmentOrConfig;\\n  } else if (commitmentOrConfig) {\\n    const {\\n      commitment: specifiedCommitment,\\n      ...specifiedConfig\\n    } = commitmentOrConfig;\\n    commitment = specifiedCommitment;\\n    config = specifiedConfig;\\n  }\\n\\n  return {\\n    commitment,\\n    config\\n  };\\n}\\n/**\\n * @internal\\n */\\n\\n\\nfunction createRpcResult(result) {\\n  return (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.union)([(0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n    jsonrpc: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.literal)('2.0'),\\n    id: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n    result\\n  }), (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n    jsonrpc: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.literal)('2.0'),\\n    id: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n    error: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n      code: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.unknown)(),\\n      message: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n      data: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.any)())\\n    })\\n  })]);\\n}\\n\\nconst UnknownRpcResult = createRpcResult((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.unknown)());\\n/**\\n * @internal\\n */\\n\\nfunction jsonRpcResult(schema) {\\n  return (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.coerce)(createRpcResult(schema), UnknownRpcResult, value => {\\n    if ('error' in value) {\\n      return value;\\n    } else {\\n      return { ...value,\\n        result: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(value.result, schema)\\n      };\\n    }\\n  });\\n}\\n/**\\n * @internal\\n */\\n\\n\\nfunction jsonRpcResultAndContext(value) {\\n  return jsonRpcResult((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n    context: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n      slot: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()\\n    }),\\n    value\\n  }));\\n}\\n/**\\n * @internal\\n */\\n\\n\\nfunction notificationResultAndContext(value) {\\n  return (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n    context: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n      slot: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()\\n    }),\\n    value\\n  });\\n}\\n/**\\n * @internal\\n */\\n\\n\\nfunction versionedMessageFromResponse(version, response) {\\n  if (version === 0) {\\n    return new MessageV0({\\n      header: response.header,\\n      staticAccountKeys: response.accountKeys.map(accountKey => new PublicKey(accountKey)),\\n      recentBlockhash: response.recentBlockhash,\\n      compiledInstructions: response.instructions.map(ix => ({\\n        programIdIndex: ix.programIdIndex,\\n        accountKeyIndexes: ix.accounts,\\n        data: bs58__WEBPACK_IMPORTED_MODULE_4___default().decode(ix.data)\\n      })),\\n      addressTableLookups: response.addressTableLookups\\n    });\\n  } else {\\n    return new Message(response);\\n  }\\n}\\n/**\\n * The level of commitment desired when querying state\\n * <pre>\\n *   'processed': Query the most recent block which has reached 1 confirmation by the connected node\\n *   'confirmed': Query the most recent block which has reached 1 confirmation by the cluster\\n *   'finalized': Query the most recent block which has been finalized by the cluster\\n * </pre>\\n */\\n\\n\\nconst GetInflationGovernorResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  foundation: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  foundationTerm: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  initial: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  taper: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  terminal: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()\\n});\\n/**\\n * The inflation reward for an epoch\\n */\\n\\n/**\\n * Expected JSON RPC response for the \\\"getInflationReward\\\" message\\n */\\nconst GetInflationRewardResult = jsonRpcResult((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  epoch: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  effectiveSlot: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  amount: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  postBalance: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()\\n}))));\\n/**\\n * Information about the current epoch\\n */\\n\\nconst GetEpochInfoResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  epoch: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  slotIndex: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  slotsInEpoch: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  absoluteSlot: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  blockHeight: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()),\\n  transactionCount: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)())\\n});\\nconst GetEpochScheduleResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  slotsPerEpoch: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  leaderScheduleSlotOffset: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  warmup: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.boolean)(),\\n  firstNormalEpoch: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  firstNormalSlot: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()\\n});\\n/**\\n * Leader schedule\\n * (see https://docs.solana.com/terminology#leader-schedule)\\n */\\n\\nconst GetLeaderScheduleResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.record)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(), (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()));\\n/**\\n * Transaction error or null\\n */\\n\\nconst TransactionErrorResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.union)([(0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({}), (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)()]));\\n/**\\n * Signature status for a transaction\\n */\\n\\nconst SignatureStatusResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  err: TransactionErrorResult\\n});\\n/**\\n * Transaction signature received notification\\n */\\n\\nconst SignatureReceivedResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.literal)('receivedSignature');\\n/**\\n * Version info for a node\\n */\\n\\nconst VersionResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  'solana-core': (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n  'feature-set': (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)())\\n});\\nconst SimulatedTransactionResponseStruct = jsonRpcResultAndContext((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  err: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.union)([(0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({}), (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)()])),\\n  logs: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)())),\\n  accounts: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n    executable: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.boolean)(),\\n    owner: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n    lamports: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n    data: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)()),\\n    rentEpoch: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)())\\n  }))))),\\n  unitsConsumed: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()),\\n  returnData: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n    programId: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n    data: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.tuple)([(0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(), (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.literal)('base64')])\\n  })))\\n}));\\n\\n/**\\n * Expected JSON RPC response for the \\\"getBlockProduction\\\" message\\n */\\nconst BlockProductionResponseStruct = jsonRpcResultAndContext((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  byIdentity: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.record)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(), (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)())),\\n  range: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n    firstSlot: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n    lastSlot: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()\\n  })\\n}));\\n/**\\n * A performance sample\\n */\\n\\nfunction createRpcClient(url, httpHeaders, customFetch, fetchMiddleware, disableRetryOnRateLimit, httpAgent) {\\n  const fetch = customFetch ? customFetch : fetchImpl;\\n\\n  {\\n    if (httpAgent != null) {\\n      console.warn('You have supplied an `httpAgent` when creating a `Connection` in a browser environment.' + 'It has been ignored; `httpAgent` is only used in Node environments.');\\n    }\\n  }\\n\\n  let fetchWithMiddleware;\\n\\n  if (fetchMiddleware) {\\n    fetchWithMiddleware = async (info, init) => {\\n      const modifiedFetchArgs = await new Promise((resolve, reject) => {\\n        try {\\n          fetchMiddleware(info, init, (modifiedInfo, modifiedInit) => resolve([modifiedInfo, modifiedInit]));\\n        } catch (error) {\\n          reject(error);\\n        }\\n      });\\n      return await fetch(...modifiedFetchArgs);\\n    };\\n  }\\n\\n  const clientBrowser = new (jayson_lib_client_browser__WEBPACK_IMPORTED_MODULE_10___default())(async (request, callback) => {\\n    const agent = undefined;\\n    const options = {\\n      method: 'POST',\\n      body: request,\\n      agent,\\n      headers: Object.assign({\\n        'Content-Type': 'application/json'\\n      }, httpHeaders || {}, COMMON_HTTP_HEADERS)\\n    };\\n\\n    try {\\n      let too_many_requests_retries = 5;\\n      let res;\\n      let waitTime = 500;\\n\\n      for (;;) {\\n        if (fetchWithMiddleware) {\\n          res = await fetchWithMiddleware(url, options);\\n        } else {\\n          res = await fetch(url, options);\\n        }\\n\\n        if (res.status !== 429\\n        /* Too many requests */\\n        ) {\\n          break;\\n        }\\n\\n        if (disableRetryOnRateLimit === true) {\\n          break;\\n        }\\n\\n        too_many_requests_retries -= 1;\\n\\n        if (too_many_requests_retries === 0) {\\n          break;\\n        }\\n\\n        console.log(`Server responded with ${res.status} ${res.statusText}.  Retrying after ${waitTime}ms delay...`);\\n        await sleep(waitTime);\\n        waitTime *= 2;\\n      }\\n\\n      const text = await res.text();\\n\\n      if (res.ok) {\\n        callback(null, text);\\n      } else {\\n        callback(new Error(`${res.status} ${res.statusText}: ${text}`));\\n      }\\n    } catch (err) {\\n      if (err instanceof Error) callback(err);\\n    } finally {\\n    }\\n  }, {});\\n  return clientBrowser;\\n}\\n\\nfunction createRpcRequest(client) {\\n  return (method, args) => {\\n    return new Promise((resolve, reject) => {\\n      client.request(method, args, (err, response) => {\\n        if (err) {\\n          reject(err);\\n          return;\\n        }\\n\\n        resolve(response);\\n      });\\n    });\\n  };\\n}\\n\\nfunction createRpcBatchRequest(client) {\\n  return requests => {\\n    return new Promise((resolve, reject) => {\\n      // Do nothing if requests is empty\\n      if (requests.length === 0) resolve([]);\\n      const batch = requests.map(params => {\\n        return client.request(params.methodName, params.args);\\n      });\\n      client.request(batch, (err, response) => {\\n        if (err) {\\n          reject(err);\\n          return;\\n        }\\n\\n        resolve(response);\\n      });\\n    });\\n  };\\n}\\n/**\\n * Expected JSON RPC response for the \\\"getInflationGovernor\\\" message\\n */\\n\\n\\nconst GetInflationGovernorRpcResult = jsonRpcResult(GetInflationGovernorResult);\\n/**\\n * Expected JSON RPC response for the \\\"getEpochInfo\\\" message\\n */\\n\\nconst GetEpochInfoRpcResult = jsonRpcResult(GetEpochInfoResult);\\n/**\\n * Expected JSON RPC response for the \\\"getEpochSchedule\\\" message\\n */\\n\\nconst GetEpochScheduleRpcResult = jsonRpcResult(GetEpochScheduleResult);\\n/**\\n * Expected JSON RPC response for the \\\"getLeaderSchedule\\\" message\\n */\\n\\nconst GetLeaderScheduleRpcResult = jsonRpcResult(GetLeaderScheduleResult);\\n/**\\n * Expected JSON RPC response for the \\\"minimumLedgerSlot\\\" and \\\"getFirstAvailableBlock\\\" messages\\n */\\n\\nconst SlotRpcResult = jsonRpcResult((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)());\\n/**\\n * Supply\\n */\\n\\n/**\\n * Expected JSON RPC response for the \\\"getSupply\\\" message\\n */\\nconst GetSupplyRpcResult = jsonRpcResultAndContext((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  total: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  circulating: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  nonCirculating: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  nonCirculatingAccounts: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)(PublicKeyFromString)\\n}));\\n/**\\n * Token amount object which returns a token amount in different formats\\n * for various client use cases.\\n */\\n\\n/**\\n * Expected JSON RPC structure for token amounts\\n */\\nconst TokenAmountResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  amount: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n  uiAmount: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()),\\n  decimals: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  uiAmountString: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)())\\n});\\n/**\\n * Token address and balance.\\n */\\n\\n/**\\n * Expected JSON RPC response for the \\\"getTokenLargestAccounts\\\" message\\n */\\nconst GetTokenLargestAccountsResult = jsonRpcResultAndContext((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  address: PublicKeyFromString,\\n  amount: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n  uiAmount: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()),\\n  decimals: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  uiAmountString: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)())\\n})));\\n/**\\n * Expected JSON RPC response for the \\\"getTokenAccountsByOwner\\\" message\\n */\\n\\nconst GetTokenAccountsByOwner = jsonRpcResultAndContext((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  pubkey: PublicKeyFromString,\\n  account: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n    executable: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.boolean)(),\\n    owner: PublicKeyFromString,\\n    lamports: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n    data: BufferFromRawAccountData,\\n    rentEpoch: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()\\n  })\\n})));\\nconst ParsedAccountDataResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  program: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n  parsed: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.unknown)(),\\n  space: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()\\n});\\n/**\\n * Expected JSON RPC response for the \\\"getTokenAccountsByOwner\\\" message with parsed data\\n */\\n\\nconst GetParsedTokenAccountsByOwner = jsonRpcResultAndContext((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  pubkey: PublicKeyFromString,\\n  account: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n    executable: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.boolean)(),\\n    owner: PublicKeyFromString,\\n    lamports: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n    data: ParsedAccountDataResult,\\n    rentEpoch: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()\\n  })\\n})));\\n/**\\n * Pair of an account address and its balance\\n */\\n\\n/**\\n * Expected JSON RPC response for the \\\"getLargestAccounts\\\" message\\n */\\nconst GetLargestAccountsRpcResult = jsonRpcResultAndContext((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  lamports: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  address: PublicKeyFromString\\n})));\\n/**\\n * @internal\\n */\\n\\nconst AccountInfoResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  executable: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.boolean)(),\\n  owner: PublicKeyFromString,\\n  lamports: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  data: BufferFromRawAccountData,\\n  rentEpoch: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()\\n});\\n/**\\n * @internal\\n */\\n\\nconst KeyedAccountInfoResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  pubkey: PublicKeyFromString,\\n  account: AccountInfoResult\\n});\\nconst ParsedOrRawAccountData = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.coerce)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.union)([(0,superstruct__WEBPACK_IMPORTED_MODULE_14__.instance)(buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer), ParsedAccountDataResult]), (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.union)([RawAccountDataResult, ParsedAccountDataResult]), value => {\\n  if (Array.isArray(value)) {\\n    return (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(value, BufferFromRawAccountData);\\n  } else {\\n    return value;\\n  }\\n});\\n/**\\n * @internal\\n */\\n\\nconst ParsedAccountInfoResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  executable: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.boolean)(),\\n  owner: PublicKeyFromString,\\n  lamports: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  data: ParsedOrRawAccountData,\\n  rentEpoch: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()\\n});\\nconst KeyedParsedAccountInfoResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  pubkey: PublicKeyFromString,\\n  account: ParsedAccountInfoResult\\n});\\n/**\\n * @internal\\n */\\n\\nconst StakeActivationResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  state: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.union)([(0,superstruct__WEBPACK_IMPORTED_MODULE_14__.literal)('active'), (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.literal)('inactive'), (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.literal)('activating'), (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.literal)('deactivating')]),\\n  active: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  inactive: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()\\n});\\n/**\\n * Expected JSON RPC response for the \\\"getConfirmedSignaturesForAddress2\\\" message\\n */\\n\\nconst GetConfirmedSignaturesForAddress2RpcResult = jsonRpcResult((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  signature: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n  slot: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  err: TransactionErrorResult,\\n  memo: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)()),\\n  blockTime: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()))\\n})));\\n/**\\n * Expected JSON RPC response for the \\\"getSignaturesForAddress\\\" message\\n */\\n\\nconst GetSignaturesForAddressRpcResult = jsonRpcResult((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  signature: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n  slot: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  err: TransactionErrorResult,\\n  memo: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)()),\\n  blockTime: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()))\\n})));\\n/***\\n * Expected JSON RPC response for the \\\"accountNotification\\\" message\\n */\\n\\nconst AccountNotificationResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  subscription: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  result: notificationResultAndContext(AccountInfoResult)\\n});\\n/**\\n * @internal\\n */\\n\\nconst ProgramAccountInfoResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  pubkey: PublicKeyFromString,\\n  account: AccountInfoResult\\n});\\n/***\\n * Expected JSON RPC response for the \\\"programNotification\\\" message\\n */\\n\\nconst ProgramAccountNotificationResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  subscription: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  result: notificationResultAndContext(ProgramAccountInfoResult)\\n});\\n/**\\n * @internal\\n */\\n\\nconst SlotInfoResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  parent: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  slot: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  root: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()\\n});\\n/**\\n * Expected JSON RPC response for the \\\"slotNotification\\\" message\\n */\\n\\nconst SlotNotificationResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  subscription: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  result: SlotInfoResult\\n});\\n/**\\n * Slot updates which can be used for tracking the live progress of a cluster.\\n * - `\\\"firstShredReceived\\\"`: connected node received the first shred of a block.\\n * Indicates that a new block that is being produced.\\n * - `\\\"completed\\\"`: connected node has received all shreds of a block. Indicates\\n * a block was recently produced.\\n * - `\\\"optimisticConfirmation\\\"`: block was optimistically confirmed by the\\n * cluster. It is not guaranteed that an optimistic confirmation notification\\n * will be sent for every finalized blocks.\\n * - `\\\"root\\\"`: the connected node rooted this block.\\n * - `\\\"createdBank\\\"`: the connected node has started validating this block.\\n * - `\\\"frozen\\\"`: the connected node has validated this block.\\n * - `\\\"dead\\\"`: the connected node failed to validate this block.\\n */\\n\\n/**\\n * @internal\\n */\\nconst SlotUpdateResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.union)([(0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  type: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.union)([(0,superstruct__WEBPACK_IMPORTED_MODULE_14__.literal)('firstShredReceived'), (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.literal)('completed'), (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.literal)('optimisticConfirmation'), (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.literal)('root')]),\\n  slot: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  timestamp: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()\\n}), (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  type: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.literal)('createdBank'),\\n  parent: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  slot: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  timestamp: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()\\n}), (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  type: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.literal)('frozen'),\\n  slot: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  timestamp: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  stats: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n    numTransactionEntries: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n    numSuccessfulTransactions: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n    numFailedTransactions: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n    maxTransactionsPerEntry: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()\\n  })\\n}), (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  type: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.literal)('dead'),\\n  slot: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  timestamp: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  err: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)()\\n})]);\\n/**\\n * Expected JSON RPC response for the \\\"slotsUpdatesNotification\\\" message\\n */\\n\\nconst SlotUpdateNotificationResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  subscription: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  result: SlotUpdateResult\\n});\\n/**\\n * Expected JSON RPC response for the \\\"signatureNotification\\\" message\\n */\\n\\nconst SignatureNotificationResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  subscription: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  result: notificationResultAndContext((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.union)([SignatureStatusResult, SignatureReceivedResult]))\\n});\\n/**\\n * Expected JSON RPC response for the \\\"rootNotification\\\" message\\n */\\n\\nconst RootNotificationResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  subscription: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  result: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()\\n});\\nconst ContactInfoResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  pubkey: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n  gossip: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)()),\\n  tpu: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)()),\\n  rpc: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)()),\\n  version: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)())\\n});\\nconst VoteAccountInfoResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  votePubkey: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n  nodePubkey: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n  activatedStake: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  epochVoteAccount: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.boolean)(),\\n  epochCredits: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.tuple)([(0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(), (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(), (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()])),\\n  commission: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  lastVote: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  rootSlot: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)())\\n});\\n/**\\n * Expected JSON RPC response for the \\\"getVoteAccounts\\\" message\\n */\\n\\nconst GetVoteAccounts = jsonRpcResult((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  current: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)(VoteAccountInfoResult),\\n  delinquent: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)(VoteAccountInfoResult)\\n}));\\nconst ConfirmationStatus = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.union)([(0,superstruct__WEBPACK_IMPORTED_MODULE_14__.literal)('processed'), (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.literal)('confirmed'), (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.literal)('finalized')]);\\nconst SignatureStatusResponse = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  slot: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  confirmations: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()),\\n  err: TransactionErrorResult,\\n  confirmationStatus: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)(ConfirmationStatus)\\n});\\n/**\\n * Expected JSON RPC response for the \\\"getSignatureStatuses\\\" message\\n */\\n\\nconst GetSignatureStatusesRpcResult = jsonRpcResultAndContext((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)(SignatureStatusResponse)));\\n/**\\n * Expected JSON RPC response for the \\\"getMinimumBalanceForRentExemption\\\" message\\n */\\n\\nconst GetMinimumBalanceForRentExemptionRpcResult = jsonRpcResult((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)());\\nconst AddressTableLookupStruct = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  accountKey: PublicKeyFromString,\\n  writableIndexes: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()),\\n  readonlyIndexes: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)())\\n});\\nconst ConfirmedTransactionResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  signatures: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)()),\\n  message: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n    accountKeys: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)()),\\n    header: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n      numRequiredSignatures: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n      numReadonlySignedAccounts: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n      numReadonlyUnsignedAccounts: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()\\n    }),\\n    instructions: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n      accounts: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()),\\n      data: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n      programIdIndex: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()\\n    })),\\n    recentBlockhash: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n    addressTableLookups: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)(AddressTableLookupStruct))\\n  })\\n});\\nconst AnnotatedAccountKey = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  pubkey: PublicKeyFromString,\\n  signer: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.boolean)(),\\n  writable: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.boolean)(),\\n  source: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.union)([(0,superstruct__WEBPACK_IMPORTED_MODULE_14__.literal)('transaction'), (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.literal)('lookupTable')]))\\n});\\nconst ConfirmedTransactionAccountsModeResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  accountKeys: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)(AnnotatedAccountKey),\\n  signatures: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)())\\n});\\nconst ParsedInstructionResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  parsed: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.unknown)(),\\n  program: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n  programId: PublicKeyFromString\\n});\\nconst RawInstructionResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  accounts: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)(PublicKeyFromString),\\n  data: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n  programId: PublicKeyFromString\\n});\\nconst InstructionResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.union)([RawInstructionResult, ParsedInstructionResult]);\\nconst UnknownInstructionResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.union)([(0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  parsed: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.unknown)(),\\n  program: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n  programId: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)()\\n}), (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  accounts: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)()),\\n  data: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n  programId: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)()\\n})]);\\nconst ParsedOrRawInstruction = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.coerce)(InstructionResult, UnknownInstructionResult, value => {\\n  if ('accounts' in value) {\\n    return (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(value, RawInstructionResult);\\n  } else {\\n    return (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(value, ParsedInstructionResult);\\n  }\\n});\\n/**\\n * @internal\\n */\\n\\nconst ParsedConfirmedTransactionResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  signatures: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)()),\\n  message: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n    accountKeys: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)(AnnotatedAccountKey),\\n    instructions: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)(ParsedOrRawInstruction),\\n    recentBlockhash: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n    addressTableLookups: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)(AddressTableLookupStruct)))\\n  })\\n});\\nconst TokenBalanceResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  accountIndex: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  mint: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n  owner: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)()),\\n  uiTokenAmount: TokenAmountResult\\n});\\nconst LoadedAddressesResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  writable: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)(PublicKeyFromString),\\n  readonly: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)(PublicKeyFromString)\\n});\\n/**\\n * @internal\\n */\\n\\nconst ConfirmedTransactionMetaResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  err: TransactionErrorResult,\\n  fee: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  innerInstructions: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n    index: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n    instructions: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n      accounts: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()),\\n      data: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n      programIdIndex: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()\\n    }))\\n  })))),\\n  preBalances: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()),\\n  postBalances: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()),\\n  logMessages: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)()))),\\n  preTokenBalances: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)(TokenBalanceResult))),\\n  postTokenBalances: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)(TokenBalanceResult))),\\n  loadedAddresses: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)(LoadedAddressesResult),\\n  computeUnitsConsumed: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)())\\n});\\n/**\\n * @internal\\n */\\n\\nconst ParsedConfirmedTransactionMetaResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  err: TransactionErrorResult,\\n  fee: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  innerInstructions: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n    index: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n    instructions: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)(ParsedOrRawInstruction)\\n  })))),\\n  preBalances: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()),\\n  postBalances: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()),\\n  logMessages: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)()))),\\n  preTokenBalances: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)(TokenBalanceResult))),\\n  postTokenBalances: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)(TokenBalanceResult))),\\n  loadedAddresses: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)(LoadedAddressesResult),\\n  computeUnitsConsumed: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)())\\n});\\nconst TransactionVersionStruct = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.union)([(0,superstruct__WEBPACK_IMPORTED_MODULE_14__.literal)(0), (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.literal)('legacy')]);\\n/** @internal */\\n\\nconst RewardsResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  pubkey: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n  lamports: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  postBalance: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()),\\n  rewardType: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)())\\n});\\n/**\\n * Expected JSON RPC response for the \\\"getBlock\\\" message\\n */\\n\\nconst GetBlockRpcResult = jsonRpcResult((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  blockhash: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n  previousBlockhash: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n  parentSlot: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  transactions: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n    transaction: ConfirmedTransactionResult,\\n    meta: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)(ConfirmedTransactionMetaResult),\\n    version: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)(TransactionVersionStruct)\\n  })),\\n  rewards: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)(RewardsResult)),\\n  blockTime: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()),\\n  blockHeight: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)())\\n})));\\n/**\\n * Expected JSON RPC response for the \\\"getBlock\\\" message when `transactionDetails` is `none`\\n */\\n\\nconst GetNoneModeBlockRpcResult = jsonRpcResult((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  blockhash: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n  previousBlockhash: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n  parentSlot: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  rewards: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)(RewardsResult)),\\n  blockTime: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()),\\n  blockHeight: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)())\\n})));\\n/**\\n * Expected JSON RPC response for the \\\"getBlock\\\" message when `transactionDetails` is `accounts`\\n */\\n\\nconst GetAccountsModeBlockRpcResult = jsonRpcResult((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  blockhash: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n  previousBlockhash: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n  parentSlot: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  transactions: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n    transaction: ConfirmedTransactionAccountsModeResult,\\n    meta: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)(ConfirmedTransactionMetaResult),\\n    version: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)(TransactionVersionStruct)\\n  })),\\n  rewards: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)(RewardsResult)),\\n  blockTime: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()),\\n  blockHeight: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)())\\n})));\\n/**\\n * Expected parsed JSON RPC response for the \\\"getBlock\\\" message\\n */\\n\\nconst GetParsedBlockRpcResult = jsonRpcResult((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  blockhash: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n  previousBlockhash: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n  parentSlot: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  transactions: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n    transaction: ParsedConfirmedTransactionResult,\\n    meta: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)(ParsedConfirmedTransactionMetaResult),\\n    version: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)(TransactionVersionStruct)\\n  })),\\n  rewards: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)(RewardsResult)),\\n  blockTime: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()),\\n  blockHeight: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)())\\n})));\\n/**\\n * Expected parsed JSON RPC response for the \\\"getBlock\\\" message  when `transactionDetails` is `accounts`\\n */\\n\\nconst GetParsedAccountsModeBlockRpcResult = jsonRpcResult((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  blockhash: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n  previousBlockhash: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n  parentSlot: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  transactions: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n    transaction: ConfirmedTransactionAccountsModeResult,\\n    meta: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)(ParsedConfirmedTransactionMetaResult),\\n    version: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)(TransactionVersionStruct)\\n  })),\\n  rewards: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)(RewardsResult)),\\n  blockTime: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()),\\n  blockHeight: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)())\\n})));\\n/**\\n * Expected parsed JSON RPC response for the \\\"getBlock\\\" message  when `transactionDetails` is `none`\\n */\\n\\nconst GetParsedNoneModeBlockRpcResult = jsonRpcResult((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  blockhash: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n  previousBlockhash: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n  parentSlot: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  rewards: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)(RewardsResult)),\\n  blockTime: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()),\\n  blockHeight: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)())\\n})));\\n/**\\n * Expected JSON RPC response for the \\\"getConfirmedBlock\\\" message\\n *\\n * @deprecated Deprecated since Solana v1.8.0. Please use {@link GetBlockRpcResult} instead.\\n */\\n\\nconst GetConfirmedBlockRpcResult = jsonRpcResult((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  blockhash: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n  previousBlockhash: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n  parentSlot: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  transactions: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n    transaction: ConfirmedTransactionResult,\\n    meta: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)(ConfirmedTransactionMetaResult)\\n  })),\\n  rewards: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)(RewardsResult)),\\n  blockTime: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)())\\n})));\\n/**\\n * Expected JSON RPC response for the \\\"getBlock\\\" message\\n */\\n\\nconst GetBlockSignaturesRpcResult = jsonRpcResult((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  blockhash: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n  previousBlockhash: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n  parentSlot: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  signatures: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)()),\\n  blockTime: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)())\\n})));\\n/**\\n * Expected JSON RPC response for the \\\"getTransaction\\\" message\\n */\\n\\nconst GetTransactionRpcResult = jsonRpcResult((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  slot: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  meta: ConfirmedTransactionMetaResult,\\n  blockTime: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)())),\\n  transaction: ConfirmedTransactionResult,\\n  version: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)(TransactionVersionStruct)\\n})));\\n/**\\n * Expected parsed JSON RPC response for the \\\"getTransaction\\\" message\\n */\\n\\nconst GetParsedTransactionRpcResult = jsonRpcResult((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  slot: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  transaction: ParsedConfirmedTransactionResult,\\n  meta: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)(ParsedConfirmedTransactionMetaResult),\\n  blockTime: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)())),\\n  version: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)(TransactionVersionStruct)\\n})));\\n/**\\n * Expected JSON RPC response for the \\\"getRecentBlockhash\\\" message\\n *\\n * @deprecated Deprecated since Solana v1.8.0. Please use {@link GetLatestBlockhashRpcResult} instead.\\n */\\n\\nconst GetRecentBlockhashAndContextRpcResult = jsonRpcResultAndContext((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  blockhash: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n  feeCalculator: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n    lamportsPerSignature: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()\\n  })\\n}));\\n/**\\n * Expected JSON RPC response for the \\\"getLatestBlockhash\\\" message\\n */\\n\\nconst GetLatestBlockhashRpcResult = jsonRpcResultAndContext((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  blockhash: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n  lastValidBlockHeight: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()\\n}));\\nconst PerfSampleResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  slot: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  numTransactions: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  numSlots: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)(),\\n  samplePeriodSecs: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()\\n});\\n/*\\n * Expected JSON RPC response for \\\"getRecentPerformanceSamples\\\" message\\n */\\n\\nconst GetRecentPerformanceSamplesRpcResult = jsonRpcResult((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)(PerfSampleResult));\\n/**\\n * Expected JSON RPC response for the \\\"getFeeCalculatorForBlockhash\\\" message\\n */\\n\\nconst GetFeeCalculatorRpcResult = jsonRpcResultAndContext((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  feeCalculator: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n    lamportsPerSignature: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()\\n  })\\n})));\\n/**\\n * Expected JSON RPC response for the \\\"requestAirdrop\\\" message\\n */\\n\\nconst RequestAirdropRpcResult = jsonRpcResult((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)());\\n/**\\n * Expected JSON RPC response for the \\\"sendTransaction\\\" message\\n */\\n\\nconst SendTransactionRpcResult = jsonRpcResult((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)());\\n/**\\n * Information about the latest slot being processed by a node\\n */\\n\\n/**\\n * @internal\\n */\\nconst LogsResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  err: TransactionErrorResult,\\n  logs: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)()),\\n  signature: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)()\\n});\\n/**\\n * Logs result.\\n */\\n\\n/**\\n * Expected JSON RPC response for the \\\"logsNotification\\\" message.\\n */\\nconst LogsNotificationResult = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  result: notificationResultAndContext(LogsResult),\\n  subscription: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()\\n});\\n/**\\n * Filter for log subscriptions.\\n */\\n\\n/** @internal */\\nconst COMMON_HTTP_HEADERS = {\\n  'solana-client': `js/${(_process$env$npm_pack = \\\"0.0.0-development\\\") !== null && _process$env$npm_pack !== void 0 ? _process$env$npm_pack : 'UNKNOWN'}`\\n};\\n/**\\n * A connection to a fullnode JSON RPC endpoint\\n */\\n\\nclass Connection {\\n  /** @internal */\\n\\n  /** @internal */\\n\\n  /** @internal */\\n\\n  /** @internal */\\n\\n  /** @internal */\\n\\n  /** @internal */\\n\\n  /** @internal */\\n\\n  /** @internal */\\n\\n  /** @internal */\\n\\n  /** @internal */\\n\\n  /** @internal */\\n\\n  /** @internal\\n   * A number that we increment every time an active connection closes.\\n   * Used to determine whether the same socket connection that was open\\n   * when an async operation started is the same one that's active when\\n   * its continuation fires.\\n   *\\n   */\\n\\n  /** @internal */\\n\\n  /** @internal */\\n\\n  /** @internal */\\n\\n  /** @internal */\\n\\n  /** @internal */\\n\\n  /** @internal */\\n\\n  /** @internal */\\n\\n  /** @internal */\\n\\n  /** @internal */\\n\\n  /**\\n   * Special case.\\n   * After a signature is processed, RPCs automatically dispose of the\\n   * subscription on the server side. We need to track which of these\\n   * subscriptions have been disposed in such a way, so that we know\\n   * whether the client is dealing with a not-yet-processed signature\\n   * (in which case we must tear down the server subscription) or an\\n   * already-processed signature (in which case the client can simply\\n   * clear out the subscription locally without telling the server).\\n   *\\n   * NOTE: There is a proposal to eliminate this special case, here:\\n   * https://github.com/solana-labs/solana/issues/18892\\n   */\\n\\n  /** @internal */\\n\\n  /**\\n   * Establish a JSON RPC connection\\n   *\\n   * @param endpoint URL to the fullnode JSON RPC endpoint\\n   * @param commitmentOrConfig optional default commitment level or optional ConnectionConfig configuration object\\n   */\\n  constructor(endpoint, commitmentOrConfig) {\\n    this._commitment = void 0;\\n    this._confirmTransactionInitialTimeout = void 0;\\n    this._rpcEndpoint = void 0;\\n    this._rpcWsEndpoint = void 0;\\n    this._rpcClient = void 0;\\n    this._rpcRequest = void 0;\\n    this._rpcBatchRequest = void 0;\\n    this._rpcWebSocket = void 0;\\n    this._rpcWebSocketConnected = false;\\n    this._rpcWebSocketHeartbeat = null;\\n    this._rpcWebSocketIdleTimeout = null;\\n    this._rpcWebSocketGeneration = 0;\\n    this._disableBlockhashCaching = false;\\n    this._pollingBlockhash = false;\\n    this._blockhashInfo = {\\n      latestBlockhash: null,\\n      lastFetch: 0,\\n      transactionSignatures: [],\\n      simulatedSignatures: []\\n    };\\n    this._nextClientSubscriptionId = 0;\\n    this._subscriptionDisposeFunctionsByClientSubscriptionId = {};\\n    this._subscriptionHashByClientSubscriptionId = {};\\n    this._subscriptionStateChangeCallbacksByHash = {};\\n    this._subscriptionCallbacksByServerSubscriptionId = {};\\n    this._subscriptionsByHash = {};\\n    this._subscriptionsAutoDisposedByRpc = new Set();\\n    let wsEndpoint;\\n    let httpHeaders;\\n    let fetch;\\n    let fetchMiddleware;\\n    let disableRetryOnRateLimit;\\n    let httpAgent;\\n\\n    if (commitmentOrConfig && typeof commitmentOrConfig === 'string') {\\n      this._commitment = commitmentOrConfig;\\n    } else if (commitmentOrConfig) {\\n      this._commitment = commitmentOrConfig.commitment;\\n      this._confirmTransactionInitialTimeout = commitmentOrConfig.confirmTransactionInitialTimeout;\\n      wsEndpoint = commitmentOrConfig.wsEndpoint;\\n      httpHeaders = commitmentOrConfig.httpHeaders;\\n      fetch = commitmentOrConfig.fetch;\\n      fetchMiddleware = commitmentOrConfig.fetchMiddleware;\\n      disableRetryOnRateLimit = commitmentOrConfig.disableRetryOnRateLimit;\\n      httpAgent = commitmentOrConfig.httpAgent;\\n    }\\n\\n    this._rpcEndpoint = assertEndpointUrl(endpoint);\\n    this._rpcWsEndpoint = wsEndpoint || makeWebsocketUrl(endpoint);\\n    this._rpcClient = createRpcClient(endpoint, httpHeaders, fetch, fetchMiddleware, disableRetryOnRateLimit, httpAgent);\\n    this._rpcRequest = createRpcRequest(this._rpcClient);\\n    this._rpcBatchRequest = createRpcBatchRequest(this._rpcClient);\\n    this._rpcWebSocket = new rpc_websockets__WEBPACK_IMPORTED_MODULE_9__.Client(this._rpcWsEndpoint, {\\n      autoconnect: false,\\n      max_reconnects: Infinity\\n    });\\n\\n    this._rpcWebSocket.on('open', this._wsOnOpen.bind(this));\\n\\n    this._rpcWebSocket.on('error', this._wsOnError.bind(this));\\n\\n    this._rpcWebSocket.on('close', this._wsOnClose.bind(this));\\n\\n    this._rpcWebSocket.on('accountNotification', this._wsOnAccountNotification.bind(this));\\n\\n    this._rpcWebSocket.on('programNotification', this._wsOnProgramAccountNotification.bind(this));\\n\\n    this._rpcWebSocket.on('slotNotification', this._wsOnSlotNotification.bind(this));\\n\\n    this._rpcWebSocket.on('slotsUpdatesNotification', this._wsOnSlotUpdatesNotification.bind(this));\\n\\n    this._rpcWebSocket.on('signatureNotification', this._wsOnSignatureNotification.bind(this));\\n\\n    this._rpcWebSocket.on('rootNotification', this._wsOnRootNotification.bind(this));\\n\\n    this._rpcWebSocket.on('logsNotification', this._wsOnLogsNotification.bind(this));\\n  }\\n  /**\\n   * The default commitment used for requests\\n   */\\n\\n\\n  get commitment() {\\n    return this._commitment;\\n  }\\n  /**\\n   * The RPC endpoint\\n   */\\n\\n\\n  get rpcEndpoint() {\\n    return this._rpcEndpoint;\\n  }\\n  /**\\n   * Fetch the balance for the specified public key, return with context\\n   */\\n\\n\\n  async getBalanceAndContext(publicKey, commitmentOrConfig) {\\n    /** @internal */\\n    const {\\n      commitment,\\n      config\\n    } = extractCommitmentFromConfig(commitmentOrConfig);\\n\\n    const args = this._buildArgs([publicKey.toBase58()], commitment, undefined\\n    /* encoding */\\n    , config);\\n\\n    const unsafeRes = await this._rpcRequest('getBalance', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, jsonRpcResultAndContext((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()));\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, `failed to get balance for ${publicKey.toBase58()}`);\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch the balance for the specified public key\\n   */\\n\\n\\n  async getBalance(publicKey, commitmentOrConfig) {\\n    return await this.getBalanceAndContext(publicKey, commitmentOrConfig).then(x => x.value).catch(e => {\\n      throw new Error('failed to get balance of account ' + publicKey.toBase58() + ': ' + e);\\n    });\\n  }\\n  /**\\n   * Fetch the estimated production time of a block\\n   */\\n\\n\\n  async getBlockTime(slot) {\\n    const unsafeRes = await this._rpcRequest('getBlockTime', [slot]);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, jsonRpcResult((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)())));\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, `failed to get block time for slot ${slot}`);\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch the lowest slot that the node has information about in its ledger.\\n   * This value may increase over time if the node is configured to purge older ledger data\\n   */\\n\\n\\n  async getMinimumLedgerSlot() {\\n    const unsafeRes = await this._rpcRequest('minimumLedgerSlot', []);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, jsonRpcResult((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()));\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get minimum ledger slot');\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch the slot of the lowest confirmed block that has not been purged from the ledger\\n   */\\n\\n\\n  async getFirstAvailableBlock() {\\n    const unsafeRes = await this._rpcRequest('getFirstAvailableBlock', []);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, SlotRpcResult);\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get first available block');\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch information about the current supply\\n   */\\n\\n\\n  async getSupply(config) {\\n    let configArg = {};\\n\\n    if (typeof config === 'string') {\\n      configArg = {\\n        commitment: config\\n      };\\n    } else if (config) {\\n      configArg = { ...config,\\n        commitment: config && config.commitment || this.commitment\\n      };\\n    } else {\\n      configArg = {\\n        commitment: this.commitment\\n      };\\n    }\\n\\n    const unsafeRes = await this._rpcRequest('getSupply', [configArg]);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetSupplyRpcResult);\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get supply');\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch the current supply of a token mint\\n   */\\n\\n\\n  async getTokenSupply(tokenMintAddress, commitment) {\\n    const args = this._buildArgs([tokenMintAddress.toBase58()], commitment);\\n\\n    const unsafeRes = await this._rpcRequest('getTokenSupply', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, jsonRpcResultAndContext(TokenAmountResult));\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get token supply');\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch the current balance of a token account\\n   */\\n\\n\\n  async getTokenAccountBalance(tokenAddress, commitment) {\\n    const args = this._buildArgs([tokenAddress.toBase58()], commitment);\\n\\n    const unsafeRes = await this._rpcRequest('getTokenAccountBalance', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, jsonRpcResultAndContext(TokenAmountResult));\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get token account balance');\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch all the token accounts owned by the specified account\\n   *\\n   * @return {Promise<RpcResponseAndContext<Array<{pubkey: PublicKey, account: AccountInfo<Buffer>}>>>}\\n   */\\n\\n\\n  async getTokenAccountsByOwner(ownerAddress, filter, commitmentOrConfig) {\\n    const {\\n      commitment,\\n      config\\n    } = extractCommitmentFromConfig(commitmentOrConfig);\\n    let _args = [ownerAddress.toBase58()];\\n\\n    if ('mint' in filter) {\\n      _args.push({\\n        mint: filter.mint.toBase58()\\n      });\\n    } else {\\n      _args.push({\\n        programId: filter.programId.toBase58()\\n      });\\n    }\\n\\n    const args = this._buildArgs(_args, commitment, 'base64', config);\\n\\n    const unsafeRes = await this._rpcRequest('getTokenAccountsByOwner', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetTokenAccountsByOwner);\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, `failed to get token accounts owned by account ${ownerAddress.toBase58()}`);\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch parsed token accounts owned by the specified account\\n   *\\n   * @return {Promise<RpcResponseAndContext<Array<{pubkey: PublicKey, account: AccountInfo<ParsedAccountData>}>>>}\\n   */\\n\\n\\n  async getParsedTokenAccountsByOwner(ownerAddress, filter, commitment) {\\n    let _args = [ownerAddress.toBase58()];\\n\\n    if ('mint' in filter) {\\n      _args.push({\\n        mint: filter.mint.toBase58()\\n      });\\n    } else {\\n      _args.push({\\n        programId: filter.programId.toBase58()\\n      });\\n    }\\n\\n    const args = this._buildArgs(_args, commitment, 'jsonParsed');\\n\\n    const unsafeRes = await this._rpcRequest('getTokenAccountsByOwner', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetParsedTokenAccountsByOwner);\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, `failed to get token accounts owned by account ${ownerAddress.toBase58()}`);\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch the 20 largest accounts with their current balances\\n   */\\n\\n\\n  async getLargestAccounts(config) {\\n    const arg = { ...config,\\n      commitment: config && config.commitment || this.commitment\\n    };\\n    const args = arg.filter || arg.commitment ? [arg] : [];\\n    const unsafeRes = await this._rpcRequest('getLargestAccounts', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetLargestAccountsRpcResult);\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get largest accounts');\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch the 20 largest token accounts with their current balances\\n   * for a given mint.\\n   */\\n\\n\\n  async getTokenLargestAccounts(mintAddress, commitment) {\\n    const args = this._buildArgs([mintAddress.toBase58()], commitment);\\n\\n    const unsafeRes = await this._rpcRequest('getTokenLargestAccounts', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetTokenLargestAccountsResult);\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get token largest accounts');\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch all the account info for the specified public key, return with context\\n   */\\n\\n\\n  async getAccountInfoAndContext(publicKey, commitmentOrConfig) {\\n    const {\\n      commitment,\\n      config\\n    } = extractCommitmentFromConfig(commitmentOrConfig);\\n\\n    const args = this._buildArgs([publicKey.toBase58()], commitment, 'base64', config);\\n\\n    const unsafeRes = await this._rpcRequest('getAccountInfo', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, jsonRpcResultAndContext((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)(AccountInfoResult)));\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, `failed to get info about account ${publicKey.toBase58()}`);\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch parsed account info for the specified public key\\n   */\\n\\n\\n  async getParsedAccountInfo(publicKey, commitmentOrConfig) {\\n    const {\\n      commitment,\\n      config\\n    } = extractCommitmentFromConfig(commitmentOrConfig);\\n\\n    const args = this._buildArgs([publicKey.toBase58()], commitment, 'jsonParsed', config);\\n\\n    const unsafeRes = await this._rpcRequest('getAccountInfo', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, jsonRpcResultAndContext((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)(ParsedAccountInfoResult)));\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, `failed to get info about account ${publicKey.toBase58()}`);\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch all the account info for the specified public key\\n   */\\n\\n\\n  async getAccountInfo(publicKey, commitmentOrConfig) {\\n    try {\\n      const res = await this.getAccountInfoAndContext(publicKey, commitmentOrConfig);\\n      return res.value;\\n    } catch (e) {\\n      throw new Error('failed to get info about account ' + publicKey.toBase58() + ': ' + e);\\n    }\\n  }\\n  /**\\n   * Fetch all the account info for multiple accounts specified by an array of public keys, return with context\\n   */\\n\\n\\n  async getMultipleParsedAccounts(publicKeys, rawConfig) {\\n    const {\\n      commitment,\\n      config\\n    } = extractCommitmentFromConfig(rawConfig);\\n    const keys = publicKeys.map(key => key.toBase58());\\n\\n    const args = this._buildArgs([keys], commitment, 'jsonParsed', config);\\n\\n    const unsafeRes = await this._rpcRequest('getMultipleAccounts', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, jsonRpcResultAndContext((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)(ParsedAccountInfoResult))));\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, `failed to get info for accounts ${keys}`);\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch all the account info for multiple accounts specified by an array of public keys, return with context\\n   */\\n\\n\\n  async getMultipleAccountsInfoAndContext(publicKeys, commitmentOrConfig) {\\n    const {\\n      commitment,\\n      config\\n    } = extractCommitmentFromConfig(commitmentOrConfig);\\n    const keys = publicKeys.map(key => key.toBase58());\\n\\n    const args = this._buildArgs([keys], commitment, 'base64', config);\\n\\n    const unsafeRes = await this._rpcRequest('getMultipleAccounts', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, jsonRpcResultAndContext((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)(AccountInfoResult))));\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, `failed to get info for accounts ${keys}`);\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch all the account info for multiple accounts specified by an array of public keys\\n   */\\n\\n\\n  async getMultipleAccountsInfo(publicKeys, commitmentOrConfig) {\\n    const res = await this.getMultipleAccountsInfoAndContext(publicKeys, commitmentOrConfig);\\n    return res.value;\\n  }\\n  /**\\n   * Returns epoch activation information for a stake account that has been delegated\\n   */\\n\\n\\n  async getStakeActivation(publicKey, commitmentOrConfig, epoch) {\\n    const {\\n      commitment,\\n      config\\n    } = extractCommitmentFromConfig(commitmentOrConfig);\\n\\n    const args = this._buildArgs([publicKey.toBase58()], commitment, undefined\\n    /* encoding */\\n    , { ...config,\\n      epoch: epoch != null ? epoch : config === null || config === void 0 ? void 0 : config.epoch\\n    });\\n\\n    const unsafeRes = await this._rpcRequest('getStakeActivation', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, jsonRpcResult(StakeActivationResult));\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, `failed to get Stake Activation ${publicKey.toBase58()}`);\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch all the accounts owned by the specified program id\\n   *\\n   * @return {Promise<Array<{pubkey: PublicKey, account: AccountInfo<Buffer>}>>}\\n   */\\n\\n\\n  async getProgramAccounts(programId, configOrCommitment) {\\n    const {\\n      commitment,\\n      config\\n    } = extractCommitmentFromConfig(configOrCommitment);\\n    const {\\n      encoding,\\n      ...configWithoutEncoding\\n    } = config || {};\\n\\n    const args = this._buildArgs([programId.toBase58()], commitment, encoding || 'base64', configWithoutEncoding);\\n\\n    const unsafeRes = await this._rpcRequest('getProgramAccounts', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, jsonRpcResult((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)(KeyedAccountInfoResult)));\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, `failed to get accounts owned by program ${programId.toBase58()}`);\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch and parse all the accounts owned by the specified program id\\n   *\\n   * @return {Promise<Array<{pubkey: PublicKey, account: AccountInfo<Buffer | ParsedAccountData>}>>}\\n   */\\n\\n\\n  async getParsedProgramAccounts(programId, configOrCommitment) {\\n    const {\\n      commitment,\\n      config\\n    } = extractCommitmentFromConfig(configOrCommitment);\\n\\n    const args = this._buildArgs([programId.toBase58()], commitment, 'jsonParsed', config);\\n\\n    const unsafeRes = await this._rpcRequest('getProgramAccounts', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, jsonRpcResult((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)(KeyedParsedAccountInfoResult)));\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, `failed to get accounts owned by program ${programId.toBase58()}`);\\n    }\\n\\n    return res.result;\\n  }\\n\\n  // eslint-disable-next-line no-dupe-class-members\\n  async confirmTransaction(strategy, commitment) {\\n    let rawSignature;\\n\\n    if (typeof strategy == 'string') {\\n      rawSignature = strategy;\\n    } else {\\n      var _config$abortSignal;\\n\\n      const config = strategy;\\n\\n      if ((_config$abortSignal = config.abortSignal) !== null && _config$abortSignal !== void 0 && _config$abortSignal.aborted) {\\n        return Promise.reject(config.abortSignal.reason);\\n      }\\n\\n      rawSignature = config.signature;\\n    }\\n\\n    let decodedSignature;\\n\\n    try {\\n      decodedSignature = bs58__WEBPACK_IMPORTED_MODULE_4___default().decode(rawSignature);\\n    } catch (err) {\\n      throw new Error('signature must be base58 encoded: ' + rawSignature);\\n    }\\n\\n    assert(decodedSignature.length === 64, 'signature has invalid length');\\n\\n    if (typeof strategy === 'string') {\\n      return await this.confirmTransactionUsingLegacyTimeoutStrategy({\\n        commitment: commitment || this.commitment,\\n        signature: rawSignature\\n      });\\n    } else if ('lastValidBlockHeight' in strategy) {\\n      return await this.confirmTransactionUsingBlockHeightExceedanceStrategy({\\n        commitment: commitment || this.commitment,\\n        strategy\\n      });\\n    } else {\\n      return await this.confirmTransactionUsingDurableNonceStrategy({\\n        commitment: commitment || this.commitment,\\n        strategy\\n      });\\n    }\\n  }\\n\\n  getCancellationPromise(signal) {\\n    return new Promise((_, reject) => {\\n      if (signal == null) {\\n        return;\\n      }\\n\\n      if (signal.aborted) {\\n        reject(signal.reason);\\n      } else {\\n        signal.addEventListener('abort', () => {\\n          reject(signal.reason);\\n        });\\n      }\\n    });\\n  }\\n\\n  getTransactionConfirmationPromise({\\n    commitment,\\n    signature\\n  }) {\\n    let signatureSubscriptionId;\\n    let disposeSignatureSubscriptionStateChangeObserver;\\n    let done = false;\\n    const confirmationPromise = new Promise((resolve, reject) => {\\n      try {\\n        signatureSubscriptionId = this.onSignature(signature, (result, context) => {\\n          signatureSubscriptionId = undefined;\\n          const response = {\\n            context,\\n            value: result\\n          };\\n          resolve({\\n            __type: TransactionStatus.PROCESSED,\\n            response\\n          });\\n        }, commitment);\\n        const subscriptionSetupPromise = new Promise(resolveSubscriptionSetup => {\\n          if (signatureSubscriptionId == null) {\\n            resolveSubscriptionSetup();\\n          } else {\\n            disposeSignatureSubscriptionStateChangeObserver = this._onSubscriptionStateChange(signatureSubscriptionId, nextState => {\\n              if (nextState === 'subscribed') {\\n                resolveSubscriptionSetup();\\n              }\\n            });\\n          }\\n        });\\n\\n        (async () => {\\n          await subscriptionSetupPromise;\\n          if (done) return;\\n          const response = await this.getSignatureStatus(signature);\\n          if (done) return;\\n\\n          if (response == null) {\\n            return;\\n          }\\n\\n          const {\\n            context,\\n            value\\n          } = response;\\n\\n          if (value == null) {\\n            return;\\n          }\\n\\n          if (value !== null && value !== void 0 && value.err) {\\n            reject(value.err);\\n          } else {\\n            switch (commitment) {\\n              case 'confirmed':\\n              case 'single':\\n              case 'singleGossip':\\n                {\\n                  if (value.confirmationStatus === 'processed') {\\n                    return;\\n                  }\\n\\n                  break;\\n                }\\n\\n              case 'finalized':\\n              case 'max':\\n              case 'root':\\n                {\\n                  if (value.confirmationStatus === 'processed' || value.confirmationStatus === 'confirmed') {\\n                    return;\\n                  }\\n\\n                  break;\\n                }\\n              // exhaust enums to ensure full coverage\\n\\n              case 'processed':\\n              case 'recent':\\n            }\\n\\n            done = true;\\n            resolve({\\n              __type: TransactionStatus.PROCESSED,\\n              response: {\\n                context,\\n                value\\n              }\\n            });\\n          }\\n        })();\\n      } catch (err) {\\n        reject(err);\\n      }\\n    });\\n\\n    const abortConfirmation = () => {\\n      if (disposeSignatureSubscriptionStateChangeObserver) {\\n        disposeSignatureSubscriptionStateChangeObserver();\\n        disposeSignatureSubscriptionStateChangeObserver = undefined;\\n      }\\n\\n      if (signatureSubscriptionId != null) {\\n        this.removeSignatureListener(signatureSubscriptionId);\\n        signatureSubscriptionId = undefined;\\n      }\\n    };\\n\\n    return {\\n      abortConfirmation,\\n      confirmationPromise\\n    };\\n  }\\n\\n  async confirmTransactionUsingBlockHeightExceedanceStrategy({\\n    commitment,\\n    strategy: {\\n      abortSignal,\\n      lastValidBlockHeight,\\n      signature\\n    }\\n  }) {\\n    let done = false;\\n    const expiryPromise = new Promise(resolve => {\\n      const checkBlockHeight = async () => {\\n        try {\\n          const blockHeight = await this.getBlockHeight(commitment);\\n          return blockHeight;\\n        } catch (_e) {\\n          return -1;\\n        }\\n      };\\n\\n      (async () => {\\n        let currentBlockHeight = await checkBlockHeight();\\n        if (done) return;\\n\\n        while (currentBlockHeight <= lastValidBlockHeight) {\\n          await sleep(1000);\\n          if (done) return;\\n          currentBlockHeight = await checkBlockHeight();\\n          if (done) return;\\n        }\\n\\n        resolve({\\n          __type: TransactionStatus.BLOCKHEIGHT_EXCEEDED\\n        });\\n      })();\\n    });\\n    const {\\n      abortConfirmation,\\n      confirmationPromise\\n    } = this.getTransactionConfirmationPromise({\\n      commitment,\\n      signature\\n    });\\n    const cancellationPromise = this.getCancellationPromise(abortSignal);\\n    let result;\\n\\n    try {\\n      const outcome = await Promise.race([cancellationPromise, confirmationPromise, expiryPromise]);\\n\\n      if (outcome.__type === TransactionStatus.PROCESSED) {\\n        result = outcome.response;\\n      } else {\\n        throw new TransactionExpiredBlockheightExceededError(signature);\\n      }\\n    } finally {\\n      done = true;\\n      abortConfirmation();\\n    }\\n\\n    return result;\\n  }\\n\\n  async confirmTransactionUsingDurableNonceStrategy({\\n    commitment,\\n    strategy: {\\n      abortSignal,\\n      minContextSlot,\\n      nonceAccountPubkey,\\n      nonceValue,\\n      signature\\n    }\\n  }) {\\n    let done = false;\\n    const expiryPromise = new Promise(resolve => {\\n      let currentNonceValue = nonceValue;\\n      let lastCheckedSlot = null;\\n\\n      const getCurrentNonceValue = async () => {\\n        try {\\n          const {\\n            context,\\n            value: nonceAccount\\n          } = await this.getNonceAndContext(nonceAccountPubkey, {\\n            commitment,\\n            minContextSlot\\n          });\\n          lastCheckedSlot = context.slot;\\n          return nonceAccount === null || nonceAccount === void 0 ? void 0 : nonceAccount.nonce;\\n        } catch (e) {\\n          // If for whatever reason we can't reach/read the nonce\\n          // account, just keep using the last-known value.\\n          return currentNonceValue;\\n        }\\n      };\\n\\n      (async () => {\\n        currentNonceValue = await getCurrentNonceValue();\\n        if (done) return;\\n\\n        while (true // eslint-disable-line no-constant-condition\\n        ) {\\n          if (nonceValue !== currentNonceValue) {\\n            resolve({\\n              __type: TransactionStatus.NONCE_INVALID,\\n              slotInWhichNonceDidAdvance: lastCheckedSlot\\n            });\\n            return;\\n          }\\n\\n          await sleep(2000);\\n          if (done) return;\\n          currentNonceValue = await getCurrentNonceValue();\\n          if (done) return;\\n        }\\n      })();\\n    });\\n    const {\\n      abortConfirmation,\\n      confirmationPromise\\n    } = this.getTransactionConfirmationPromise({\\n      commitment,\\n      signature\\n    });\\n    const cancellationPromise = this.getCancellationPromise(abortSignal);\\n    let result;\\n\\n    try {\\n      const outcome = await Promise.race([cancellationPromise, confirmationPromise, expiryPromise]);\\n\\n      if (outcome.__type === TransactionStatus.PROCESSED) {\\n        result = outcome.response;\\n      } else {\\n        var _signatureStatus;\\n\\n        // Double check that the transaction is indeed unconfirmed.\\n        let signatureStatus;\\n\\n        while (true // eslint-disable-line no-constant-condition\\n        ) {\\n          var _outcome$slotInWhichN;\\n\\n          const status = await this.getSignatureStatus(signature);\\n\\n          if (status == null) {\\n            break;\\n          }\\n\\n          if (status.context.slot < ((_outcome$slotInWhichN = outcome.slotInWhichNonceDidAdvance) !== null && _outcome$slotInWhichN !== void 0 ? _outcome$slotInWhichN : minContextSlot)) {\\n            await sleep(400);\\n            continue;\\n          }\\n\\n          signatureStatus = status;\\n          break;\\n        }\\n\\n        if ((_signatureStatus = signatureStatus) !== null && _signatureStatus !== void 0 && _signatureStatus.value) {\\n          const commitmentForStatus = commitment || 'finalized';\\n          const {\\n            confirmationStatus\\n          } = signatureStatus.value;\\n\\n          switch (commitmentForStatus) {\\n            case 'processed':\\n            case 'recent':\\n              if (confirmationStatus !== 'processed' && confirmationStatus !== 'confirmed' && confirmationStatus !== 'finalized') {\\n                throw new TransactionExpiredNonceInvalidError(signature);\\n              }\\n\\n              break;\\n\\n            case 'confirmed':\\n            case 'single':\\n            case 'singleGossip':\\n              if (confirmationStatus !== 'confirmed' && confirmationStatus !== 'finalized') {\\n                throw new TransactionExpiredNonceInvalidError(signature);\\n              }\\n\\n              break;\\n\\n            case 'finalized':\\n            case 'max':\\n            case 'root':\\n              if (confirmationStatus !== 'finalized') {\\n                throw new TransactionExpiredNonceInvalidError(signature);\\n              }\\n\\n              break;\\n\\n            default:\\n              // Exhaustive switch.\\n              // eslint-disable-next-line @typescript-eslint/no-unused-vars\\n              (_ => {})(commitmentForStatus);\\n\\n          }\\n\\n          result = {\\n            context: signatureStatus.context,\\n            value: {\\n              err: signatureStatus.value.err\\n            }\\n          };\\n        } else {\\n          throw new TransactionExpiredNonceInvalidError(signature);\\n        }\\n      }\\n    } finally {\\n      done = true;\\n      abortConfirmation();\\n    }\\n\\n    return result;\\n  }\\n\\n  async confirmTransactionUsingLegacyTimeoutStrategy({\\n    commitment,\\n    signature\\n  }) {\\n    let timeoutId;\\n    const expiryPromise = new Promise(resolve => {\\n      let timeoutMs = this._confirmTransactionInitialTimeout || 60 * 1000;\\n\\n      switch (commitment) {\\n        case 'processed':\\n        case 'recent':\\n        case 'single':\\n        case 'confirmed':\\n        case 'singleGossip':\\n          {\\n            timeoutMs = this._confirmTransactionInitialTimeout || 30 * 1000;\\n            break;\\n          }\\n      }\\n\\n      timeoutId = setTimeout(() => resolve({\\n        __type: TransactionStatus.TIMED_OUT,\\n        timeoutMs\\n      }), timeoutMs);\\n    });\\n    const {\\n      abortConfirmation,\\n      confirmationPromise\\n    } = this.getTransactionConfirmationPromise({\\n      commitment,\\n      signature\\n    });\\n    let result;\\n\\n    try {\\n      const outcome = await Promise.race([confirmationPromise, expiryPromise]);\\n\\n      if (outcome.__type === TransactionStatus.PROCESSED) {\\n        result = outcome.response;\\n      } else {\\n        throw new TransactionExpiredTimeoutError(signature, outcome.timeoutMs / 1000);\\n      }\\n    } finally {\\n      clearTimeout(timeoutId);\\n      abortConfirmation();\\n    }\\n\\n    return result;\\n  }\\n  /**\\n   * Return the list of nodes that are currently participating in the cluster\\n   */\\n\\n\\n  async getClusterNodes() {\\n    const unsafeRes = await this._rpcRequest('getClusterNodes', []);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, jsonRpcResult((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)(ContactInfoResult)));\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get cluster nodes');\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Return the list of nodes that are currently participating in the cluster\\n   */\\n\\n\\n  async getVoteAccounts(commitment) {\\n    const args = this._buildArgs([], commitment);\\n\\n    const unsafeRes = await this._rpcRequest('getVoteAccounts', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetVoteAccounts);\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get vote accounts');\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch the current slot that the node is processing\\n   */\\n\\n\\n  async getSlot(commitmentOrConfig) {\\n    const {\\n      commitment,\\n      config\\n    } = extractCommitmentFromConfig(commitmentOrConfig);\\n\\n    const args = this._buildArgs([], commitment, undefined\\n    /* encoding */\\n    , config);\\n\\n    const unsafeRes = await this._rpcRequest('getSlot', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, jsonRpcResult((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()));\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get slot');\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch the current slot leader of the cluster\\n   */\\n\\n\\n  async getSlotLeader(commitmentOrConfig) {\\n    const {\\n      commitment,\\n      config\\n    } = extractCommitmentFromConfig(commitmentOrConfig);\\n\\n    const args = this._buildArgs([], commitment, undefined\\n    /* encoding */\\n    , config);\\n\\n    const unsafeRes = await this._rpcRequest('getSlotLeader', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, jsonRpcResult((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)()));\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get slot leader');\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch `limit` number of slot leaders starting from `startSlot`\\n   *\\n   * @param startSlot fetch slot leaders starting from this slot\\n   * @param limit number of slot leaders to return\\n   */\\n\\n\\n  async getSlotLeaders(startSlot, limit) {\\n    const args = [startSlot, limit];\\n    const unsafeRes = await this._rpcRequest('getSlotLeaders', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, jsonRpcResult((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)(PublicKeyFromString)));\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get slot leaders');\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch the current status of a signature\\n   */\\n\\n\\n  async getSignatureStatus(signature, config) {\\n    const {\\n      context,\\n      value: values\\n    } = await this.getSignatureStatuses([signature], config);\\n    assert(values.length === 1);\\n    const value = values[0];\\n    return {\\n      context,\\n      value\\n    };\\n  }\\n  /**\\n   * Fetch the current statuses of a batch of signatures\\n   */\\n\\n\\n  async getSignatureStatuses(signatures, config) {\\n    const params = [signatures];\\n\\n    if (config) {\\n      params.push(config);\\n    }\\n\\n    const unsafeRes = await this._rpcRequest('getSignatureStatuses', params);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetSignatureStatusesRpcResult);\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get signature status');\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch the current transaction count of the cluster\\n   */\\n\\n\\n  async getTransactionCount(commitmentOrConfig) {\\n    const {\\n      commitment,\\n      config\\n    } = extractCommitmentFromConfig(commitmentOrConfig);\\n\\n    const args = this._buildArgs([], commitment, undefined\\n    /* encoding */\\n    , config);\\n\\n    const unsafeRes = await this._rpcRequest('getTransactionCount', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, jsonRpcResult((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()));\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get transaction count');\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch the current total currency supply of the cluster in lamports\\n   *\\n   * @deprecated Deprecated since v1.2.8. Please use {@link getSupply} instead.\\n   */\\n\\n\\n  async getTotalSupply(commitment) {\\n    const result = await this.getSupply({\\n      commitment,\\n      excludeNonCirculatingAccountsList: true\\n    });\\n    return result.value.total;\\n  }\\n  /**\\n   * Fetch the cluster InflationGovernor parameters\\n   */\\n\\n\\n  async getInflationGovernor(commitment) {\\n    const args = this._buildArgs([], commitment);\\n\\n    const unsafeRes = await this._rpcRequest('getInflationGovernor', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetInflationGovernorRpcResult);\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get inflation');\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch the inflation reward for a list of addresses for an epoch\\n   */\\n\\n\\n  async getInflationReward(addresses, epoch, commitmentOrConfig) {\\n    const {\\n      commitment,\\n      config\\n    } = extractCommitmentFromConfig(commitmentOrConfig);\\n\\n    const args = this._buildArgs([addresses.map(pubkey => pubkey.toBase58())], commitment, undefined\\n    /* encoding */\\n    , { ...config,\\n      epoch: epoch != null ? epoch : config === null || config === void 0 ? void 0 : config.epoch\\n    });\\n\\n    const unsafeRes = await this._rpcRequest('getInflationReward', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetInflationRewardResult);\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get inflation reward');\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch the Epoch Info parameters\\n   */\\n\\n\\n  async getEpochInfo(commitmentOrConfig) {\\n    const {\\n      commitment,\\n      config\\n    } = extractCommitmentFromConfig(commitmentOrConfig);\\n\\n    const args = this._buildArgs([], commitment, undefined\\n    /* encoding */\\n    , config);\\n\\n    const unsafeRes = await this._rpcRequest('getEpochInfo', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetEpochInfoRpcResult);\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get epoch info');\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch the Epoch Schedule parameters\\n   */\\n\\n\\n  async getEpochSchedule() {\\n    const unsafeRes = await this._rpcRequest('getEpochSchedule', []);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetEpochScheduleRpcResult);\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get epoch schedule');\\n    }\\n\\n    const epochSchedule = res.result;\\n    return new EpochSchedule(epochSchedule.slotsPerEpoch, epochSchedule.leaderScheduleSlotOffset, epochSchedule.warmup, epochSchedule.firstNormalEpoch, epochSchedule.firstNormalSlot);\\n  }\\n  /**\\n   * Fetch the leader schedule for the current epoch\\n   * @return {Promise<RpcResponseAndContext<LeaderSchedule>>}\\n   */\\n\\n\\n  async getLeaderSchedule() {\\n    const unsafeRes = await this._rpcRequest('getLeaderSchedule', []);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetLeaderScheduleRpcResult);\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get leader schedule');\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch the minimum balance needed to exempt an account of `dataLength`\\n   * size from rent\\n   */\\n\\n\\n  async getMinimumBalanceForRentExemption(dataLength, commitment) {\\n    const args = this._buildArgs([dataLength], commitment);\\n\\n    const unsafeRes = await this._rpcRequest('getMinimumBalanceForRentExemption', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetMinimumBalanceForRentExemptionRpcResult);\\n\\n    if ('error' in res) {\\n      console.warn('Unable to fetch minimum balance for rent exemption');\\n      return 0;\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch a recent blockhash from the cluster, return with context\\n   * @return {Promise<RpcResponseAndContext<{blockhash: Blockhash, feeCalculator: FeeCalculator}>>}\\n   *\\n   * @deprecated Deprecated since Solana v1.8.0. Please use {@link getLatestBlockhash} instead.\\n   */\\n\\n\\n  async getRecentBlockhashAndContext(commitment) {\\n    const args = this._buildArgs([], commitment);\\n\\n    const unsafeRes = await this._rpcRequest('getRecentBlockhash', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetRecentBlockhashAndContextRpcResult);\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get recent blockhash');\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch recent performance samples\\n   * @return {Promise<Array<PerfSample>>}\\n   */\\n\\n\\n  async getRecentPerformanceSamples(limit) {\\n    const unsafeRes = await this._rpcRequest('getRecentPerformanceSamples', limit ? [limit] : []);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetRecentPerformanceSamplesRpcResult);\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get recent performance samples');\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch the fee calculator for a recent blockhash from the cluster, return with context\\n   *\\n   * @deprecated Deprecated since Solana v1.8.0. Please use {@link getFeeForMessage} instead.\\n   */\\n\\n\\n  async getFeeCalculatorForBlockhash(blockhash, commitment) {\\n    const args = this._buildArgs([blockhash], commitment);\\n\\n    const unsafeRes = await this._rpcRequest('getFeeCalculatorForBlockhash', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetFeeCalculatorRpcResult);\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get fee calculator');\\n    }\\n\\n    const {\\n      context,\\n      value\\n    } = res.result;\\n    return {\\n      context,\\n      value: value !== null ? value.feeCalculator : null\\n    };\\n  }\\n  /**\\n   * Fetch the fee for a message from the cluster, return with context\\n   */\\n\\n\\n  async getFeeForMessage(message, commitment) {\\n    const wireMessage = toBuffer(message.serialize()).toString('base64');\\n\\n    const args = this._buildArgs([wireMessage], commitment);\\n\\n    const unsafeRes = await this._rpcRequest('getFeeForMessage', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, jsonRpcResultAndContext((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.nullable)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)())));\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get fee for message');\\n    }\\n\\n    if (res.result === null) {\\n      throw new Error('invalid blockhash');\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch a recent blockhash from the cluster\\n   * @return {Promise<{blockhash: Blockhash, feeCalculator: FeeCalculator}>}\\n   *\\n   * @deprecated Deprecated since Solana v1.8.0. Please use {@link getLatestBlockhash} instead.\\n   */\\n\\n\\n  async getRecentBlockhash(commitment) {\\n    try {\\n      const res = await this.getRecentBlockhashAndContext(commitment);\\n      return res.value;\\n    } catch (e) {\\n      throw new Error('failed to get recent blockhash: ' + e);\\n    }\\n  }\\n  /**\\n   * Fetch the latest blockhash from the cluster\\n   * @return {Promise<BlockhashWithExpiryBlockHeight>}\\n   */\\n\\n\\n  async getLatestBlockhash(commitmentOrConfig) {\\n    try {\\n      const res = await this.getLatestBlockhashAndContext(commitmentOrConfig);\\n      return res.value;\\n    } catch (e) {\\n      throw new Error('failed to get recent blockhash: ' + e);\\n    }\\n  }\\n  /**\\n   * Fetch the latest blockhash from the cluster\\n   * @return {Promise<BlockhashWithExpiryBlockHeight>}\\n   */\\n\\n\\n  async getLatestBlockhashAndContext(commitmentOrConfig) {\\n    const {\\n      commitment,\\n      config\\n    } = extractCommitmentFromConfig(commitmentOrConfig);\\n\\n    const args = this._buildArgs([], commitment, undefined\\n    /* encoding */\\n    , config);\\n\\n    const unsafeRes = await this._rpcRequest('getLatestBlockhash', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetLatestBlockhashRpcResult);\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get latest blockhash');\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch the node version\\n   */\\n\\n\\n  async getVersion() {\\n    const unsafeRes = await this._rpcRequest('getVersion', []);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, jsonRpcResult(VersionResult));\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get version');\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch the genesis hash\\n   */\\n\\n\\n  async getGenesisHash() {\\n    const unsafeRes = await this._rpcRequest('getGenesisHash', []);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, jsonRpcResult((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)()));\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get genesis hash');\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch a processed block from the cluster.\\n   *\\n   * @deprecated Instead, call `getBlock` using a `GetVersionedBlockConfig` by\\n   * setting the `maxSupportedTransactionVersion` property.\\n   */\\n\\n\\n  /**\\n   * Fetch a processed block from the cluster.\\n   */\\n  // eslint-disable-next-line no-dupe-class-members\\n  async getBlock(slot, rawConfig) {\\n    const {\\n      commitment,\\n      config\\n    } = extractCommitmentFromConfig(rawConfig);\\n\\n    const args = this._buildArgsAtLeastConfirmed([slot], commitment, undefined\\n    /* encoding */\\n    , config);\\n\\n    const unsafeRes = await this._rpcRequest('getBlock', args);\\n\\n    try {\\n      switch (config === null || config === void 0 ? void 0 : config.transactionDetails) {\\n        case 'accounts':\\n          {\\n            const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetAccountsModeBlockRpcResult);\\n\\n            if ('error' in res) {\\n              throw res.error;\\n            }\\n\\n            return res.result;\\n          }\\n\\n        case 'none':\\n          {\\n            const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetNoneModeBlockRpcResult);\\n\\n            if ('error' in res) {\\n              throw res.error;\\n            }\\n\\n            return res.result;\\n          }\\n\\n        default:\\n          {\\n            const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetBlockRpcResult);\\n\\n            if ('error' in res) {\\n              throw res.error;\\n            }\\n\\n            const {\\n              result\\n            } = res;\\n            return result ? { ...result,\\n              transactions: result.transactions.map(({\\n                transaction,\\n                meta,\\n                version\\n              }) => ({\\n                meta,\\n                transaction: { ...transaction,\\n                  message: versionedMessageFromResponse(version, transaction.message)\\n                },\\n                version\\n              }))\\n            } : null;\\n          }\\n      }\\n    } catch (e) {\\n      throw new SolanaJSONRPCError(e, 'failed to get confirmed block');\\n    }\\n  }\\n  /**\\n   * Fetch parsed transaction details for a confirmed or finalized block\\n   */\\n\\n\\n  // eslint-disable-next-line no-dupe-class-members\\n  async getParsedBlock(slot, rawConfig) {\\n    const {\\n      commitment,\\n      config\\n    } = extractCommitmentFromConfig(rawConfig);\\n\\n    const args = this._buildArgsAtLeastConfirmed([slot], commitment, 'jsonParsed', config);\\n\\n    const unsafeRes = await this._rpcRequest('getBlock', args);\\n\\n    try {\\n      switch (config === null || config === void 0 ? void 0 : config.transactionDetails) {\\n        case 'accounts':\\n          {\\n            const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetParsedAccountsModeBlockRpcResult);\\n\\n            if ('error' in res) {\\n              throw res.error;\\n            }\\n\\n            return res.result;\\n          }\\n\\n        case 'none':\\n          {\\n            const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetParsedNoneModeBlockRpcResult);\\n\\n            if ('error' in res) {\\n              throw res.error;\\n            }\\n\\n            return res.result;\\n          }\\n\\n        default:\\n          {\\n            const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetParsedBlockRpcResult);\\n\\n            if ('error' in res) {\\n              throw res.error;\\n            }\\n\\n            return res.result;\\n          }\\n      }\\n    } catch (e) {\\n      throw new SolanaJSONRPCError(e, 'failed to get block');\\n    }\\n  }\\n  /*\\n   * Returns the current block height of the node\\n   */\\n\\n\\n  async getBlockHeight(commitmentOrConfig) {\\n    const {\\n      commitment,\\n      config\\n    } = extractCommitmentFromConfig(commitmentOrConfig);\\n\\n    const args = this._buildArgs([], commitment, undefined\\n    /* encoding */\\n    , config);\\n\\n    const unsafeRes = await this._rpcRequest('getBlockHeight', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, jsonRpcResult((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()));\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get block height information');\\n    }\\n\\n    return res.result;\\n  }\\n  /*\\n   * Returns recent block production information from the current or previous epoch\\n   */\\n\\n\\n  async getBlockProduction(configOrCommitment) {\\n    let extra;\\n    let commitment;\\n\\n    if (typeof configOrCommitment === 'string') {\\n      commitment = configOrCommitment;\\n    } else if (configOrCommitment) {\\n      const {\\n        commitment: c,\\n        ...rest\\n      } = configOrCommitment;\\n      commitment = c;\\n      extra = rest;\\n    }\\n\\n    const args = this._buildArgs([], commitment, 'base64', extra);\\n\\n    const unsafeRes = await this._rpcRequest('getBlockProduction', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, BlockProductionResponseStruct);\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get block production information');\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch a confirmed or finalized transaction from the cluster.\\n   *\\n   * @deprecated Instead, call `getTransaction` using a\\n   * `GetVersionedTransactionConfig` by setting the\\n   * `maxSupportedTransactionVersion` property.\\n   */\\n\\n\\n  /**\\n   * Fetch a confirmed or finalized transaction from the cluster.\\n   */\\n  // eslint-disable-next-line no-dupe-class-members\\n  async getTransaction(signature, rawConfig) {\\n    const {\\n      commitment,\\n      config\\n    } = extractCommitmentFromConfig(rawConfig);\\n\\n    const args = this._buildArgsAtLeastConfirmed([signature], commitment, undefined\\n    /* encoding */\\n    , config);\\n\\n    const unsafeRes = await this._rpcRequest('getTransaction', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetTransactionRpcResult);\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get transaction');\\n    }\\n\\n    const result = res.result;\\n    if (!result) return result;\\n    return { ...result,\\n      transaction: { ...result.transaction,\\n        message: versionedMessageFromResponse(result.version, result.transaction.message)\\n      }\\n    };\\n  }\\n  /**\\n   * Fetch parsed transaction details for a confirmed or finalized transaction\\n   */\\n\\n\\n  async getParsedTransaction(signature, commitmentOrConfig) {\\n    const {\\n      commitment,\\n      config\\n    } = extractCommitmentFromConfig(commitmentOrConfig);\\n\\n    const args = this._buildArgsAtLeastConfirmed([signature], commitment, 'jsonParsed', config);\\n\\n    const unsafeRes = await this._rpcRequest('getTransaction', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetParsedTransactionRpcResult);\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get transaction');\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch parsed transaction details for a batch of confirmed transactions\\n   */\\n\\n\\n  async getParsedTransactions(signatures, commitmentOrConfig) {\\n    const {\\n      commitment,\\n      config\\n    } = extractCommitmentFromConfig(commitmentOrConfig);\\n    const batch = signatures.map(signature => {\\n      const args = this._buildArgsAtLeastConfirmed([signature], commitment, 'jsonParsed', config);\\n\\n      return {\\n        methodName: 'getTransaction',\\n        args\\n      };\\n    });\\n    const unsafeRes = await this._rpcBatchRequest(batch);\\n    const res = unsafeRes.map(unsafeRes => {\\n      const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetParsedTransactionRpcResult);\\n\\n      if ('error' in res) {\\n        throw new SolanaJSONRPCError(res.error, 'failed to get transactions');\\n      }\\n\\n      return res.result;\\n    });\\n    return res;\\n  }\\n  /**\\n   * Fetch transaction details for a batch of confirmed transactions.\\n   * Similar to {@link getParsedTransactions} but returns a {@link TransactionResponse}.\\n   *\\n   * @deprecated Instead, call `getTransactions` using a\\n   * `GetVersionedTransactionConfig` by setting the\\n   * `maxSupportedTransactionVersion` property.\\n   */\\n\\n\\n  /**\\n   * Fetch transaction details for a batch of confirmed transactions.\\n   * Similar to {@link getParsedTransactions} but returns a {@link\\n   * VersionedTransactionResponse}.\\n   */\\n  // eslint-disable-next-line no-dupe-class-members\\n  async getTransactions(signatures, commitmentOrConfig) {\\n    const {\\n      commitment,\\n      config\\n    } = extractCommitmentFromConfig(commitmentOrConfig);\\n    const batch = signatures.map(signature => {\\n      const args = this._buildArgsAtLeastConfirmed([signature], commitment, undefined\\n      /* encoding */\\n      , config);\\n\\n      return {\\n        methodName: 'getTransaction',\\n        args\\n      };\\n    });\\n    const unsafeRes = await this._rpcBatchRequest(batch);\\n    const res = unsafeRes.map(unsafeRes => {\\n      const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetTransactionRpcResult);\\n\\n      if ('error' in res) {\\n        throw new SolanaJSONRPCError(res.error, 'failed to get transactions');\\n      }\\n\\n      const result = res.result;\\n      if (!result) return result;\\n      return { ...result,\\n        transaction: { ...result.transaction,\\n          message: versionedMessageFromResponse(result.version, result.transaction.message)\\n        }\\n      };\\n    });\\n    return res;\\n  }\\n  /**\\n   * Fetch a list of Transactions and transaction statuses from the cluster\\n   * for a confirmed block.\\n   *\\n   * @deprecated Deprecated since v1.13.0. Please use {@link getBlock} instead.\\n   */\\n\\n\\n  async getConfirmedBlock(slot, commitment) {\\n    const args = this._buildArgsAtLeastConfirmed([slot], commitment);\\n\\n    const unsafeRes = await this._rpcRequest('getConfirmedBlock', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetConfirmedBlockRpcResult);\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get confirmed block');\\n    }\\n\\n    const result = res.result;\\n\\n    if (!result) {\\n      throw new Error('Confirmed block ' + slot + ' not found');\\n    }\\n\\n    const block = { ...result,\\n      transactions: result.transactions.map(({\\n        transaction,\\n        meta\\n      }) => {\\n        const message = new Message(transaction.message);\\n        return {\\n          meta,\\n          transaction: { ...transaction,\\n            message\\n          }\\n        };\\n      })\\n    };\\n    return { ...block,\\n      transactions: block.transactions.map(({\\n        transaction,\\n        meta\\n      }) => {\\n        return {\\n          meta,\\n          transaction: Transaction.populate(transaction.message, transaction.signatures)\\n        };\\n      })\\n    };\\n  }\\n  /**\\n   * Fetch confirmed blocks between two slots\\n   */\\n\\n\\n  async getBlocks(startSlot, endSlot, commitment) {\\n    const args = this._buildArgsAtLeastConfirmed(endSlot !== undefined ? [startSlot, endSlot] : [startSlot], commitment);\\n\\n    const unsafeRes = await this._rpcRequest('getBlocks', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, jsonRpcResult((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.array)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)())));\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get blocks');\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch a list of Signatures from the cluster for a block, excluding rewards\\n   */\\n\\n\\n  async getBlockSignatures(slot, commitment) {\\n    const args = this._buildArgsAtLeastConfirmed([slot], commitment, undefined, {\\n      transactionDetails: 'signatures',\\n      rewards: false\\n    });\\n\\n    const unsafeRes = await this._rpcRequest('getBlock', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetBlockSignaturesRpcResult);\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get block');\\n    }\\n\\n    const result = res.result;\\n\\n    if (!result) {\\n      throw new Error('Block ' + slot + ' not found');\\n    }\\n\\n    return result;\\n  }\\n  /**\\n   * Fetch a list of Signatures from the cluster for a confirmed block, excluding rewards\\n   *\\n   * @deprecated Deprecated since Solana v1.8.0. Please use {@link getBlockSignatures} instead.\\n   */\\n\\n\\n  async getConfirmedBlockSignatures(slot, commitment) {\\n    const args = this._buildArgsAtLeastConfirmed([slot], commitment, undefined, {\\n      transactionDetails: 'signatures',\\n      rewards: false\\n    });\\n\\n    const unsafeRes = await this._rpcRequest('getConfirmedBlock', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetBlockSignaturesRpcResult);\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get confirmed block');\\n    }\\n\\n    const result = res.result;\\n\\n    if (!result) {\\n      throw new Error('Confirmed block ' + slot + ' not found');\\n    }\\n\\n    return result;\\n  }\\n  /**\\n   * Fetch a transaction details for a confirmed transaction\\n   *\\n   * @deprecated Deprecated since Solana v1.8.0. Please use {@link getTransaction} instead.\\n   */\\n\\n\\n  async getConfirmedTransaction(signature, commitment) {\\n    const args = this._buildArgsAtLeastConfirmed([signature], commitment);\\n\\n    const unsafeRes = await this._rpcRequest('getConfirmedTransaction', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetTransactionRpcResult);\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get transaction');\\n    }\\n\\n    const result = res.result;\\n    if (!result) return result;\\n    const message = new Message(result.transaction.message);\\n    const signatures = result.transaction.signatures;\\n    return { ...result,\\n      transaction: Transaction.populate(message, signatures)\\n    };\\n  }\\n  /**\\n   * Fetch parsed transaction details for a confirmed transaction\\n   *\\n   * @deprecated Deprecated since Solana v1.8.0. Please use {@link getParsedTransaction} instead.\\n   */\\n\\n\\n  async getParsedConfirmedTransaction(signature, commitment) {\\n    const args = this._buildArgsAtLeastConfirmed([signature], commitment, 'jsonParsed');\\n\\n    const unsafeRes = await this._rpcRequest('getConfirmedTransaction', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetParsedTransactionRpcResult);\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get confirmed transaction');\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Fetch parsed transaction details for a batch of confirmed transactions\\n   *\\n   * @deprecated Deprecated since Solana v1.8.0. Please use {@link getParsedTransactions} instead.\\n   */\\n\\n\\n  async getParsedConfirmedTransactions(signatures, commitment) {\\n    const batch = signatures.map(signature => {\\n      const args = this._buildArgsAtLeastConfirmed([signature], commitment, 'jsonParsed');\\n\\n      return {\\n        methodName: 'getConfirmedTransaction',\\n        args\\n      };\\n    });\\n    const unsafeRes = await this._rpcBatchRequest(batch);\\n    const res = unsafeRes.map(unsafeRes => {\\n      const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetParsedTransactionRpcResult);\\n\\n      if ('error' in res) {\\n        throw new SolanaJSONRPCError(res.error, 'failed to get confirmed transactions');\\n      }\\n\\n      return res.result;\\n    });\\n    return res;\\n  }\\n  /**\\n   * Fetch a list of all the confirmed signatures for transactions involving an address\\n   * within a specified slot range. Max range allowed is 10,000 slots.\\n   *\\n   * @deprecated Deprecated since v1.3. Please use {@link getConfirmedSignaturesForAddress2} instead.\\n   *\\n   * @param address queried address\\n   * @param startSlot start slot, inclusive\\n   * @param endSlot end slot, inclusive\\n   */\\n\\n\\n  async getConfirmedSignaturesForAddress(address, startSlot, endSlot) {\\n    let options = {};\\n    let firstAvailableBlock = await this.getFirstAvailableBlock();\\n\\n    while (!('until' in options)) {\\n      startSlot--;\\n\\n      if (startSlot <= 0 || startSlot < firstAvailableBlock) {\\n        break;\\n      }\\n\\n      try {\\n        const block = await this.getConfirmedBlockSignatures(startSlot, 'finalized');\\n\\n        if (block.signatures.length > 0) {\\n          options.until = block.signatures[block.signatures.length - 1].toString();\\n        }\\n      } catch (err) {\\n        if (err instanceof Error && err.message.includes('skipped')) {\\n          continue;\\n        } else {\\n          throw err;\\n        }\\n      }\\n    }\\n\\n    let highestConfirmedRoot = await this.getSlot('finalized');\\n\\n    while (!('before' in options)) {\\n      endSlot++;\\n\\n      if (endSlot > highestConfirmedRoot) {\\n        break;\\n      }\\n\\n      try {\\n        const block = await this.getConfirmedBlockSignatures(endSlot);\\n\\n        if (block.signatures.length > 0) {\\n          options.before = block.signatures[block.signatures.length - 1].toString();\\n        }\\n      } catch (err) {\\n        if (err instanceof Error && err.message.includes('skipped')) {\\n          continue;\\n        } else {\\n          throw err;\\n        }\\n      }\\n    }\\n\\n    const confirmedSignatureInfo = await this.getConfirmedSignaturesForAddress2(address, options);\\n    return confirmedSignatureInfo.map(info => info.signature);\\n  }\\n  /**\\n   * Returns confirmed signatures for transactions involving an\\n   * address backwards in time from the provided signature or most recent confirmed block\\n   *\\n   *\\n   * @param address queried address\\n   * @param options\\n   */\\n\\n\\n  async getConfirmedSignaturesForAddress2(address, options, commitment) {\\n    const args = this._buildArgsAtLeastConfirmed([address.toBase58()], commitment, undefined, options);\\n\\n    const unsafeRes = await this._rpcRequest('getConfirmedSignaturesForAddress2', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetConfirmedSignaturesForAddress2RpcResult);\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get confirmed signatures for address');\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Returns confirmed signatures for transactions involving an\\n   * address backwards in time from the provided signature or most recent confirmed block\\n   *\\n   *\\n   * @param address queried address\\n   * @param options\\n   */\\n\\n\\n  async getSignaturesForAddress(address, options, commitment) {\\n    const args = this._buildArgsAtLeastConfirmed([address.toBase58()], commitment, undefined, options);\\n\\n    const unsafeRes = await this._rpcRequest('getSignaturesForAddress', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, GetSignaturesForAddressRpcResult);\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, 'failed to get signatures for address');\\n    }\\n\\n    return res.result;\\n  }\\n\\n  async getAddressLookupTable(accountKey, config) {\\n    const {\\n      context,\\n      value: accountInfo\\n    } = await this.getAccountInfoAndContext(accountKey, config);\\n    let value = null;\\n\\n    if (accountInfo !== null) {\\n      value = new AddressLookupTableAccount({\\n        key: accountKey,\\n        state: AddressLookupTableAccount.deserialize(accountInfo.data)\\n      });\\n    }\\n\\n    return {\\n      context,\\n      value\\n    };\\n  }\\n  /**\\n   * Fetch the contents of a Nonce account from the cluster, return with context\\n   */\\n\\n\\n  async getNonceAndContext(nonceAccount, commitmentOrConfig) {\\n    const {\\n      context,\\n      value: accountInfo\\n    } = await this.getAccountInfoAndContext(nonceAccount, commitmentOrConfig);\\n    let value = null;\\n\\n    if (accountInfo !== null) {\\n      value = NonceAccount.fromAccountData(accountInfo.data);\\n    }\\n\\n    return {\\n      context,\\n      value\\n    };\\n  }\\n  /**\\n   * Fetch the contents of a Nonce account from the cluster\\n   */\\n\\n\\n  async getNonce(nonceAccount, commitmentOrConfig) {\\n    return await this.getNonceAndContext(nonceAccount, commitmentOrConfig).then(x => x.value).catch(e => {\\n      throw new Error('failed to get nonce for account ' + nonceAccount.toBase58() + ': ' + e);\\n    });\\n  }\\n  /**\\n   * Request an allocation of lamports to the specified address\\n   *\\n   * ```typescript\\n   * import { Connection, PublicKey, LAMPORTS_PER_SOL } from \\\"@solana/web3.js\\\";\\n   *\\n   * (async () => {\\n   *   const connection = new Connection(\\\"https://api.testnet.solana.com\\\", \\\"confirmed\\\");\\n   *   const myAddress = new PublicKey(\\\"2nr1bHFT86W9tGnyvmYW4vcHKsQB3sVQfnddasz4kExM\\\");\\n   *   const signature = await connection.requestAirdrop(myAddress, LAMPORTS_PER_SOL);\\n   *   await connection.confirmTransaction(signature);\\n   * })();\\n   * ```\\n   */\\n\\n\\n  async requestAirdrop(to, lamports) {\\n    const unsafeRes = await this._rpcRequest('requestAirdrop', [to.toBase58(), lamports]);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, RequestAirdropRpcResult);\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, `airdrop to ${to.toBase58()} failed`);\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  async _blockhashWithExpiryBlockHeight(disableCache) {\\n    if (!disableCache) {\\n      // Wait for polling to finish\\n      while (this._pollingBlockhash) {\\n        await sleep(100);\\n      }\\n\\n      const timeSinceFetch = Date.now() - this._blockhashInfo.lastFetch;\\n\\n      const expired = timeSinceFetch >= BLOCKHASH_CACHE_TIMEOUT_MS;\\n\\n      if (this._blockhashInfo.latestBlockhash !== null && !expired) {\\n        return this._blockhashInfo.latestBlockhash;\\n      }\\n    }\\n\\n    return await this._pollNewBlockhash();\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  async _pollNewBlockhash() {\\n    this._pollingBlockhash = true;\\n\\n    try {\\n      const startTime = Date.now();\\n      const cachedLatestBlockhash = this._blockhashInfo.latestBlockhash;\\n      const cachedBlockhash = cachedLatestBlockhash ? cachedLatestBlockhash.blockhash : null;\\n\\n      for (let i = 0; i < 50; i++) {\\n        const latestBlockhash = await this.getLatestBlockhash('finalized');\\n\\n        if (cachedBlockhash !== latestBlockhash.blockhash) {\\n          this._blockhashInfo = {\\n            latestBlockhash,\\n            lastFetch: Date.now(),\\n            transactionSignatures: [],\\n            simulatedSignatures: []\\n          };\\n          return latestBlockhash;\\n        } // Sleep for approximately half a slot\\n\\n\\n        await sleep(MS_PER_SLOT / 2);\\n      }\\n\\n      throw new Error(`Unable to obtain a new blockhash after ${Date.now() - startTime}ms`);\\n    } finally {\\n      this._pollingBlockhash = false;\\n    }\\n  }\\n  /**\\n   * get the stake minimum delegation\\n   */\\n\\n\\n  async getStakeMinimumDelegation(config) {\\n    const {\\n      commitment,\\n      config: configArg\\n    } = extractCommitmentFromConfig(config);\\n\\n    const args = this._buildArgs([], commitment, 'base64', configArg);\\n\\n    const unsafeRes = await this._rpcRequest('getStakeMinimumDelegation', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, jsonRpcResultAndContext((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.number)()));\\n\\n    if ('error' in res) {\\n      throw new SolanaJSONRPCError(res.error, `failed to get stake minimum delegation`);\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Simulate a transaction\\n   *\\n   * @deprecated Instead, call {@link simulateTransaction} with {@link\\n   * VersionedTransaction} and {@link SimulateTransactionConfig} parameters\\n   */\\n\\n\\n  /**\\n   * Simulate a transaction\\n   */\\n  // eslint-disable-next-line no-dupe-class-members\\n  async simulateTransaction(transactionOrMessage, configOrSigners, includeAccounts) {\\n    if ('message' in transactionOrMessage) {\\n      const versionedTx = transactionOrMessage;\\n      const wireTransaction = versionedTx.serialize();\\n      const encodedTransaction = buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.from(wireTransaction).toString('base64');\\n\\n      if (Array.isArray(configOrSigners) || includeAccounts !== undefined) {\\n        throw new Error('Invalid arguments');\\n      }\\n\\n      const config = configOrSigners || {};\\n      config.encoding = 'base64';\\n\\n      if (!('commitment' in config)) {\\n        config.commitment = this.commitment;\\n      }\\n\\n      const args = [encodedTransaction, config];\\n      const unsafeRes = await this._rpcRequest('simulateTransaction', args);\\n      const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, SimulatedTransactionResponseStruct);\\n\\n      if ('error' in res) {\\n        throw new Error('failed to simulate transaction: ' + res.error.message);\\n      }\\n\\n      return res.result;\\n    }\\n\\n    let transaction;\\n\\n    if (transactionOrMessage instanceof Transaction) {\\n      let originalTx = transactionOrMessage;\\n      transaction = new Transaction();\\n      transaction.feePayer = originalTx.feePayer;\\n      transaction.instructions = transactionOrMessage.instructions;\\n      transaction.nonceInfo = originalTx.nonceInfo;\\n      transaction.signatures = originalTx.signatures;\\n    } else {\\n      transaction = Transaction.populate(transactionOrMessage); // HACK: this function relies on mutating the populated transaction\\n\\n      transaction._message = transaction._json = undefined;\\n    }\\n\\n    if (configOrSigners !== undefined && !Array.isArray(configOrSigners)) {\\n      throw new Error('Invalid arguments');\\n    }\\n\\n    const signers = configOrSigners;\\n\\n    if (transaction.nonceInfo && signers) {\\n      transaction.sign(...signers);\\n    } else {\\n      let disableCache = this._disableBlockhashCaching;\\n\\n      for (;;) {\\n        const latestBlockhash = await this._blockhashWithExpiryBlockHeight(disableCache);\\n        transaction.lastValidBlockHeight = latestBlockhash.lastValidBlockHeight;\\n        transaction.recentBlockhash = latestBlockhash.blockhash;\\n        if (!signers) break;\\n        transaction.sign(...signers);\\n\\n        if (!transaction.signature) {\\n          throw new Error('!signature'); // should never happen\\n        }\\n\\n        const signature = transaction.signature.toString('base64');\\n\\n        if (!this._blockhashInfo.simulatedSignatures.includes(signature) && !this._blockhashInfo.transactionSignatures.includes(signature)) {\\n          // The signature of this transaction has not been seen before with the\\n          // current recentBlockhash, all done. Let's break\\n          this._blockhashInfo.simulatedSignatures.push(signature);\\n\\n          break;\\n        } else {\\n          // This transaction would be treated as duplicate (its derived signature\\n          // matched to one of already recorded signatures).\\n          // So, we must fetch a new blockhash for a different signature by disabling\\n          // our cache not to wait for the cache expiration (BLOCKHASH_CACHE_TIMEOUT_MS).\\n          disableCache = true;\\n        }\\n      }\\n    }\\n\\n    const message = transaction._compile();\\n\\n    const signData = message.serialize();\\n\\n    const wireTransaction = transaction._serialize(signData);\\n\\n    const encodedTransaction = wireTransaction.toString('base64');\\n    const config = {\\n      encoding: 'base64',\\n      commitment: this.commitment\\n    };\\n\\n    if (includeAccounts) {\\n      const addresses = (Array.isArray(includeAccounts) ? includeAccounts : message.nonProgramIds()).map(key => key.toBase58());\\n      config['accounts'] = {\\n        encoding: 'base64',\\n        addresses\\n      };\\n    }\\n\\n    if (signers) {\\n      config.sigVerify = true;\\n    }\\n\\n    const args = [encodedTransaction, config];\\n    const unsafeRes = await this._rpcRequest('simulateTransaction', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, SimulatedTransactionResponseStruct);\\n\\n    if ('error' in res) {\\n      let logs;\\n\\n      if ('data' in res.error) {\\n        logs = res.error.data.logs;\\n\\n        if (logs && Array.isArray(logs)) {\\n          const traceIndent = '\\\\n    ';\\n          const logTrace = traceIndent + logs.join(traceIndent);\\n          console.error(res.error.message, logTrace);\\n        }\\n      }\\n\\n      throw new SendTransactionError('failed to simulate transaction: ' + res.error.message, logs);\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * Sign and send a transaction\\n   *\\n   * @deprecated Instead, call {@link sendTransaction} with a {@link\\n   * VersionedTransaction}\\n   */\\n\\n\\n  /**\\n   * Sign and send a transaction\\n   */\\n  // eslint-disable-next-line no-dupe-class-members\\n  async sendTransaction(transaction, signersOrOptions, options) {\\n    if ('version' in transaction) {\\n      if (signersOrOptions && Array.isArray(signersOrOptions)) {\\n        throw new Error('Invalid arguments');\\n      }\\n\\n      const wireTransaction = transaction.serialize();\\n      return await this.sendRawTransaction(wireTransaction, options);\\n    }\\n\\n    if (signersOrOptions === undefined || !Array.isArray(signersOrOptions)) {\\n      throw new Error('Invalid arguments');\\n    }\\n\\n    const signers = signersOrOptions;\\n\\n    if (transaction.nonceInfo) {\\n      transaction.sign(...signers);\\n    } else {\\n      let disableCache = this._disableBlockhashCaching;\\n\\n      for (;;) {\\n        const latestBlockhash = await this._blockhashWithExpiryBlockHeight(disableCache);\\n        transaction.lastValidBlockHeight = latestBlockhash.lastValidBlockHeight;\\n        transaction.recentBlockhash = latestBlockhash.blockhash;\\n        transaction.sign(...signers);\\n\\n        if (!transaction.signature) {\\n          throw new Error('!signature'); // should never happen\\n        }\\n\\n        const signature = transaction.signature.toString('base64');\\n\\n        if (!this._blockhashInfo.transactionSignatures.includes(signature)) {\\n          // The signature of this transaction has not been seen before with the\\n          // current recentBlockhash, all done. Let's break\\n          this._blockhashInfo.transactionSignatures.push(signature);\\n\\n          break;\\n        } else {\\n          // This transaction would be treated as duplicate (its derived signature\\n          // matched to one of already recorded signatures).\\n          // So, we must fetch a new blockhash for a different signature by disabling\\n          // our cache not to wait for the cache expiration (BLOCKHASH_CACHE_TIMEOUT_MS).\\n          disableCache = true;\\n        }\\n      }\\n    }\\n\\n    const wireTransaction = transaction.serialize();\\n    return await this.sendRawTransaction(wireTransaction, options);\\n  }\\n  /**\\n   * Send a transaction that has already been signed and serialized into the\\n   * wire format\\n   */\\n\\n\\n  async sendRawTransaction(rawTransaction, options) {\\n    const encodedTransaction = toBuffer(rawTransaction).toString('base64');\\n    const result = await this.sendEncodedTransaction(encodedTransaction, options);\\n    return result;\\n  }\\n  /**\\n   * Send a transaction that has already been signed, serialized into the\\n   * wire format, and encoded as a base64 string\\n   */\\n\\n\\n  async sendEncodedTransaction(encodedTransaction, options) {\\n    const config = {\\n      encoding: 'base64'\\n    };\\n    const skipPreflight = options && options.skipPreflight;\\n    const preflightCommitment = options && options.preflightCommitment || this.commitment;\\n\\n    if (options && options.maxRetries != null) {\\n      config.maxRetries = options.maxRetries;\\n    }\\n\\n    if (options && options.minContextSlot != null) {\\n      config.minContextSlot = options.minContextSlot;\\n    }\\n\\n    if (skipPreflight) {\\n      config.skipPreflight = skipPreflight;\\n    }\\n\\n    if (preflightCommitment) {\\n      config.preflightCommitment = preflightCommitment;\\n    }\\n\\n    const args = [encodedTransaction, config];\\n    const unsafeRes = await this._rpcRequest('sendTransaction', args);\\n    const res = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(unsafeRes, SendTransactionRpcResult);\\n\\n    if ('error' in res) {\\n      let logs;\\n\\n      if ('data' in res.error) {\\n        logs = res.error.data.logs;\\n      }\\n\\n      throw new SendTransactionError('failed to send transaction: ' + res.error.message, logs);\\n    }\\n\\n    return res.result;\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  _wsOnOpen() {\\n    this._rpcWebSocketConnected = true;\\n    this._rpcWebSocketHeartbeat = setInterval(() => {\\n      // Ping server every 5s to prevent idle timeouts\\n      this._rpcWebSocket.notify('ping').catch(() => {});\\n    }, 5000);\\n\\n    this._updateSubscriptions();\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  _wsOnError(err) {\\n    this._rpcWebSocketConnected = false;\\n    console.error('ws error:', err.message);\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  _wsOnClose(code) {\\n    this._rpcWebSocketConnected = false;\\n    this._rpcWebSocketGeneration = (this._rpcWebSocketGeneration + 1) % Number.MAX_SAFE_INTEGER;\\n\\n    if (this._rpcWebSocketIdleTimeout) {\\n      clearTimeout(this._rpcWebSocketIdleTimeout);\\n      this._rpcWebSocketIdleTimeout = null;\\n    }\\n\\n    if (this._rpcWebSocketHeartbeat) {\\n      clearInterval(this._rpcWebSocketHeartbeat);\\n      this._rpcWebSocketHeartbeat = null;\\n    }\\n\\n    if (code === 1000) {\\n      // explicit close, check if any subscriptions have been made since close\\n      this._updateSubscriptions();\\n\\n      return;\\n    } // implicit close, prepare subscriptions for auto-reconnect\\n\\n\\n    this._subscriptionCallbacksByServerSubscriptionId = {};\\n    Object.entries(this._subscriptionsByHash).forEach(([hash, subscription]) => {\\n      this._setSubscription(hash, { ...subscription,\\n        state: 'pending'\\n      });\\n    });\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  _setSubscription(hash, nextSubscription) {\\n    var _this$_subscriptionsB;\\n\\n    const prevState = (_this$_subscriptionsB = this._subscriptionsByHash[hash]) === null || _this$_subscriptionsB === void 0 ? void 0 : _this$_subscriptionsB.state;\\n    this._subscriptionsByHash[hash] = nextSubscription;\\n\\n    if (prevState !== nextSubscription.state) {\\n      const stateChangeCallbacks = this._subscriptionStateChangeCallbacksByHash[hash];\\n\\n      if (stateChangeCallbacks) {\\n        stateChangeCallbacks.forEach(cb => {\\n          try {\\n            cb(nextSubscription.state); // eslint-disable-next-line no-empty\\n          } catch {}\\n        });\\n      }\\n    }\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  _onSubscriptionStateChange(clientSubscriptionId, callback) {\\n    var _this$_subscriptionSt;\\n\\n    const hash = this._subscriptionHashByClientSubscriptionId[clientSubscriptionId];\\n\\n    if (hash == null) {\\n      return () => {};\\n    }\\n\\n    const stateChangeCallbacks = (_this$_subscriptionSt = this._subscriptionStateChangeCallbacksByHash)[hash] || (_this$_subscriptionSt[hash] = new Set());\\n    stateChangeCallbacks.add(callback);\\n    return () => {\\n      stateChangeCallbacks.delete(callback);\\n\\n      if (stateChangeCallbacks.size === 0) {\\n        delete this._subscriptionStateChangeCallbacksByHash[hash];\\n      }\\n    };\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  async _updateSubscriptions() {\\n    if (Object.keys(this._subscriptionsByHash).length === 0) {\\n      if (this._rpcWebSocketConnected) {\\n        this._rpcWebSocketConnected = false;\\n        this._rpcWebSocketIdleTimeout = setTimeout(() => {\\n          this._rpcWebSocketIdleTimeout = null;\\n\\n          try {\\n            this._rpcWebSocket.close();\\n          } catch (err) {\\n            // swallow error if socket has already been closed.\\n            if (err instanceof Error) {\\n              console.log(`Error when closing socket connection: ${err.message}`);\\n            }\\n          }\\n        }, 500);\\n      }\\n\\n      return;\\n    }\\n\\n    if (this._rpcWebSocketIdleTimeout !== null) {\\n      clearTimeout(this._rpcWebSocketIdleTimeout);\\n      this._rpcWebSocketIdleTimeout = null;\\n      this._rpcWebSocketConnected = true;\\n    }\\n\\n    if (!this._rpcWebSocketConnected) {\\n      this._rpcWebSocket.connect();\\n\\n      return;\\n    }\\n\\n    const activeWebSocketGeneration = this._rpcWebSocketGeneration;\\n\\n    const isCurrentConnectionStillActive = () => {\\n      return activeWebSocketGeneration === this._rpcWebSocketGeneration;\\n    };\\n\\n    await Promise.all( // Don't be tempted to change this to `Object.entries`. We call\\n    // `_updateSubscriptions` recursively when processing the state,\\n    // so it's important that we look up the *current* version of\\n    // each subscription, every time we process a hash.\\n    Object.keys(this._subscriptionsByHash).map(async hash => {\\n      const subscription = this._subscriptionsByHash[hash];\\n\\n      if (subscription === undefined) {\\n        // This entry has since been deleted. Skip.\\n        return;\\n      }\\n\\n      switch (subscription.state) {\\n        case 'pending':\\n        case 'unsubscribed':\\n          if (subscription.callbacks.size === 0) {\\n            /**\\n             * You can end up here when:\\n             *\\n             * - a subscription has recently unsubscribed\\n             *   without having new callbacks added to it\\n             *   while the unsubscribe was in flight, or\\n             * - when a pending subscription has its\\n             *   listeners removed before a request was\\n             *   sent to the server.\\n             *\\n             * Being that nobody is interested in this\\n             * subscription any longer, delete it.\\n             */\\n            delete this._subscriptionsByHash[hash];\\n\\n            if (subscription.state === 'unsubscribed') {\\n              delete this._subscriptionCallbacksByServerSubscriptionId[subscription.serverSubscriptionId];\\n            }\\n\\n            await this._updateSubscriptions();\\n            return;\\n          }\\n\\n          await (async () => {\\n            const {\\n              args,\\n              method\\n            } = subscription;\\n\\n            try {\\n              this._setSubscription(hash, { ...subscription,\\n                state: 'subscribing'\\n              });\\n\\n              const serverSubscriptionId = await this._rpcWebSocket.call(method, args);\\n\\n              this._setSubscription(hash, { ...subscription,\\n                serverSubscriptionId,\\n                state: 'subscribed'\\n              });\\n\\n              this._subscriptionCallbacksByServerSubscriptionId[serverSubscriptionId] = subscription.callbacks;\\n              await this._updateSubscriptions();\\n            } catch (e) {\\n              if (e instanceof Error) {\\n                console.error(`${method} error for argument`, args, e.message);\\n              }\\n\\n              if (!isCurrentConnectionStillActive()) {\\n                return;\\n              } // TODO: Maybe add an 'errored' state or a retry limit?\\n\\n\\n              this._setSubscription(hash, { ...subscription,\\n                state: 'pending'\\n              });\\n\\n              await this._updateSubscriptions();\\n            }\\n          })();\\n          break;\\n\\n        case 'subscribed':\\n          if (subscription.callbacks.size === 0) {\\n            // By the time we successfully set up a subscription\\n            // with the server, the client stopped caring about it.\\n            // Tear it down now.\\n            await (async () => {\\n              const {\\n                serverSubscriptionId,\\n                unsubscribeMethod\\n              } = subscription;\\n\\n              if (this._subscriptionsAutoDisposedByRpc.has(serverSubscriptionId)) {\\n                /**\\n                 * Special case.\\n                 * If we're dealing with a subscription that has been auto-\\n                 * disposed by the RPC, then we can skip the RPC call to\\n                 * tear down the subscription here.\\n                 *\\n                 * NOTE: There is a proposal to eliminate this special case, here:\\n                 * https://github.com/solana-labs/solana/issues/18892\\n                 */\\n                this._subscriptionsAutoDisposedByRpc.delete(serverSubscriptionId);\\n              } else {\\n                this._setSubscription(hash, { ...subscription,\\n                  state: 'unsubscribing'\\n                });\\n\\n                this._setSubscription(hash, { ...subscription,\\n                  state: 'unsubscribing'\\n                });\\n\\n                try {\\n                  await this._rpcWebSocket.call(unsubscribeMethod, [serverSubscriptionId]);\\n                } catch (e) {\\n                  if (e instanceof Error) {\\n                    console.error(`${unsubscribeMethod} error:`, e.message);\\n                  }\\n\\n                  if (!isCurrentConnectionStillActive()) {\\n                    return;\\n                  } // TODO: Maybe add an 'errored' state or a retry limit?\\n\\n\\n                  this._setSubscription(hash, { ...subscription,\\n                    state: 'subscribed'\\n                  });\\n\\n                  await this._updateSubscriptions();\\n                  return;\\n                }\\n              }\\n\\n              this._setSubscription(hash, { ...subscription,\\n                state: 'unsubscribed'\\n              });\\n\\n              await this._updateSubscriptions();\\n            })();\\n          }\\n\\n          break;\\n      }\\n    }));\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  _handleServerNotification(serverSubscriptionId, callbackArgs) {\\n    const callbacks = this._subscriptionCallbacksByServerSubscriptionId[serverSubscriptionId];\\n\\n    if (callbacks === undefined) {\\n      return;\\n    }\\n\\n    callbacks.forEach(cb => {\\n      try {\\n        cb( // I failed to find a way to convince TypeScript that `cb` is of type\\n        // `TCallback` which is certainly compatible with `Parameters<TCallback>`.\\n        // See https://github.com/microsoft/TypeScript/issues/47615\\n        // @ts-ignore\\n        ...callbackArgs);\\n      } catch (e) {\\n        console.error(e);\\n      }\\n    });\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  _wsOnAccountNotification(notification) {\\n    const {\\n      result,\\n      subscription\\n    } = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(notification, AccountNotificationResult);\\n\\n    this._handleServerNotification(subscription, [result.value, result.context]);\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  _makeSubscription(subscriptionConfig,\\n  /**\\n   * When preparing `args` for a call to `_makeSubscription`, be sure\\n   * to carefully apply a default `commitment` property, if necessary.\\n   *\\n   * - If the user supplied a `commitment` use that.\\n   * - Otherwise, if the `Connection::commitment` is set, use that.\\n   * - Otherwise, set it to the RPC server default: `finalized`.\\n   *\\n   * This is extremely important to ensure that these two fundamentally\\n   * identical subscriptions produce the same identifying hash:\\n   *\\n   * - A subscription made without specifying a commitment.\\n   * - A subscription made where the commitment specified is the same\\n   *   as the default applied to the subscription above.\\n   *\\n   * Example; these two subscriptions must produce the same hash:\\n   *\\n   * - An `accountSubscribe` subscription for `'PUBKEY'`\\n   * - An `accountSubscribe` subscription for `'PUBKEY'` with commitment\\n   *   `'finalized'`.\\n   *\\n   * See the 'making a subscription with defaulted params omitted' test\\n   * in `connection-subscriptions.ts` for more.\\n   */\\n  args) {\\n    const clientSubscriptionId = this._nextClientSubscriptionId++;\\n    const hash = fastStableStringify$1([subscriptionConfig.method, args], true\\n    /* isArrayProp */\\n    );\\n    const existingSubscription = this._subscriptionsByHash[hash];\\n\\n    if (existingSubscription === undefined) {\\n      this._subscriptionsByHash[hash] = { ...subscriptionConfig,\\n        args,\\n        callbacks: new Set([subscriptionConfig.callback]),\\n        state: 'pending'\\n      };\\n    } else {\\n      existingSubscription.callbacks.add(subscriptionConfig.callback);\\n    }\\n\\n    this._subscriptionHashByClientSubscriptionId[clientSubscriptionId] = hash;\\n\\n    this._subscriptionDisposeFunctionsByClientSubscriptionId[clientSubscriptionId] = async () => {\\n      delete this._subscriptionDisposeFunctionsByClientSubscriptionId[clientSubscriptionId];\\n      delete this._subscriptionHashByClientSubscriptionId[clientSubscriptionId];\\n      const subscription = this._subscriptionsByHash[hash];\\n      assert(subscription !== undefined, `Could not find a \\\\`Subscription\\\\` when tearing down client subscription #${clientSubscriptionId}`);\\n      subscription.callbacks.delete(subscriptionConfig.callback);\\n      await this._updateSubscriptions();\\n    };\\n\\n    this._updateSubscriptions();\\n\\n    return clientSubscriptionId;\\n  }\\n  /**\\n   * Register a callback to be invoked whenever the specified account changes\\n   *\\n   * @param publicKey Public key of the account to monitor\\n   * @param callback Function to invoke whenever the account is changed\\n   * @param commitment Specify the commitment level account changes must reach before notification\\n   * @return subscription id\\n   */\\n\\n\\n  onAccountChange(publicKey, callback, commitment) {\\n    const args = this._buildArgs([publicKey.toBase58()], commitment || this._commitment || 'finalized', // Apply connection/server default.\\n    'base64');\\n\\n    return this._makeSubscription({\\n      callback,\\n      method: 'accountSubscribe',\\n      unsubscribeMethod: 'accountUnsubscribe'\\n    }, args);\\n  }\\n  /**\\n   * Deregister an account notification callback\\n   *\\n   * @param id client subscription id to deregister\\n   */\\n\\n\\n  async removeAccountChangeListener(clientSubscriptionId) {\\n    await this._unsubscribeClientSubscription(clientSubscriptionId, 'account change');\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  _wsOnProgramAccountNotification(notification) {\\n    const {\\n      result,\\n      subscription\\n    } = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(notification, ProgramAccountNotificationResult);\\n\\n    this._handleServerNotification(subscription, [{\\n      accountId: result.value.pubkey,\\n      accountInfo: result.value.account\\n    }, result.context]);\\n  }\\n  /**\\n   * Register a callback to be invoked whenever accounts owned by the\\n   * specified program change\\n   *\\n   * @param programId Public key of the program to monitor\\n   * @param callback Function to invoke whenever the account is changed\\n   * @param commitment Specify the commitment level account changes must reach before notification\\n   * @param filters The program account filters to pass into the RPC method\\n   * @return subscription id\\n   */\\n\\n\\n  onProgramAccountChange(programId, callback, commitment, filters) {\\n    const args = this._buildArgs([programId.toBase58()], commitment || this._commitment || 'finalized', // Apply connection/server default.\\n    'base64'\\n    /* encoding */\\n    , filters ? {\\n      filters: filters\\n    } : undefined\\n    /* extra */\\n    );\\n\\n    return this._makeSubscription({\\n      callback,\\n      method: 'programSubscribe',\\n      unsubscribeMethod: 'programUnsubscribe'\\n    }, args);\\n  }\\n  /**\\n   * Deregister an account notification callback\\n   *\\n   * @param id client subscription id to deregister\\n   */\\n\\n\\n  async removeProgramAccountChangeListener(clientSubscriptionId) {\\n    await this._unsubscribeClientSubscription(clientSubscriptionId, 'program account change');\\n  }\\n  /**\\n   * Registers a callback to be invoked whenever logs are emitted.\\n   */\\n\\n\\n  onLogs(filter, callback, commitment) {\\n    const args = this._buildArgs([typeof filter === 'object' ? {\\n      mentions: [filter.toString()]\\n    } : filter], commitment || this._commitment || 'finalized' // Apply connection/server default.\\n    );\\n\\n    return this._makeSubscription({\\n      callback,\\n      method: 'logsSubscribe',\\n      unsubscribeMethod: 'logsUnsubscribe'\\n    }, args);\\n  }\\n  /**\\n   * Deregister a logs callback.\\n   *\\n   * @param id client subscription id to deregister.\\n   */\\n\\n\\n  async removeOnLogsListener(clientSubscriptionId) {\\n    await this._unsubscribeClientSubscription(clientSubscriptionId, 'logs');\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  _wsOnLogsNotification(notification) {\\n    const {\\n      result,\\n      subscription\\n    } = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(notification, LogsNotificationResult);\\n\\n    this._handleServerNotification(subscription, [result.value, result.context]);\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  _wsOnSlotNotification(notification) {\\n    const {\\n      result,\\n      subscription\\n    } = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(notification, SlotNotificationResult);\\n\\n    this._handleServerNotification(subscription, [result]);\\n  }\\n  /**\\n   * Register a callback to be invoked upon slot changes\\n   *\\n   * @param callback Function to invoke whenever the slot changes\\n   * @return subscription id\\n   */\\n\\n\\n  onSlotChange(callback) {\\n    return this._makeSubscription({\\n      callback,\\n      method: 'slotSubscribe',\\n      unsubscribeMethod: 'slotUnsubscribe'\\n    }, []\\n    /* args */\\n    );\\n  }\\n  /**\\n   * Deregister a slot notification callback\\n   *\\n   * @param id client subscription id to deregister\\n   */\\n\\n\\n  async removeSlotChangeListener(clientSubscriptionId) {\\n    await this._unsubscribeClientSubscription(clientSubscriptionId, 'slot change');\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  _wsOnSlotUpdatesNotification(notification) {\\n    const {\\n      result,\\n      subscription\\n    } = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(notification, SlotUpdateNotificationResult);\\n\\n    this._handleServerNotification(subscription, [result]);\\n  }\\n  /**\\n   * Register a callback to be invoked upon slot updates. {@link SlotUpdate}'s\\n   * may be useful to track live progress of a cluster.\\n   *\\n   * @param callback Function to invoke whenever the slot updates\\n   * @return subscription id\\n   */\\n\\n\\n  onSlotUpdate(callback) {\\n    return this._makeSubscription({\\n      callback,\\n      method: 'slotsUpdatesSubscribe',\\n      unsubscribeMethod: 'slotsUpdatesUnsubscribe'\\n    }, []\\n    /* args */\\n    );\\n  }\\n  /**\\n   * Deregister a slot update notification callback\\n   *\\n   * @param id client subscription id to deregister\\n   */\\n\\n\\n  async removeSlotUpdateListener(clientSubscriptionId) {\\n    await this._unsubscribeClientSubscription(clientSubscriptionId, 'slot update');\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  async _unsubscribeClientSubscription(clientSubscriptionId, subscriptionName) {\\n    const dispose = this._subscriptionDisposeFunctionsByClientSubscriptionId[clientSubscriptionId];\\n\\n    if (dispose) {\\n      await dispose();\\n    } else {\\n      console.warn('Ignored unsubscribe request because an active subscription with id ' + `\\\\`${clientSubscriptionId}\\\\` for '${subscriptionName}' events ` + 'could not be found.');\\n    }\\n  }\\n\\n  _buildArgs(args, override, encoding, extra) {\\n    const commitment = override || this._commitment;\\n\\n    if (commitment || encoding || extra) {\\n      let options = {};\\n\\n      if (encoding) {\\n        options.encoding = encoding;\\n      }\\n\\n      if (commitment) {\\n        options.commitment = commitment;\\n      }\\n\\n      if (extra) {\\n        options = Object.assign(options, extra);\\n      }\\n\\n      args.push(options);\\n    }\\n\\n    return args;\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  _buildArgsAtLeastConfirmed(args, override, encoding, extra) {\\n    const commitment = override || this._commitment;\\n\\n    if (commitment && !['confirmed', 'finalized'].includes(commitment)) {\\n      throw new Error('Using Connection with default commitment: `' + this._commitment + '`, but method requires at least `confirmed`');\\n    }\\n\\n    return this._buildArgs(args, override, encoding, extra);\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  _wsOnSignatureNotification(notification) {\\n    const {\\n      result,\\n      subscription\\n    } = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(notification, SignatureNotificationResult);\\n\\n    if (result.value !== 'receivedSignature') {\\n      /**\\n       * Special case.\\n       * After a signature is processed, RPCs automatically dispose of the\\n       * subscription on the server side. We need to track which of these\\n       * subscriptions have been disposed in such a way, so that we know\\n       * whether the client is dealing with a not-yet-processed signature\\n       * (in which case we must tear down the server subscription) or an\\n       * already-processed signature (in which case the client can simply\\n       * clear out the subscription locally without telling the server).\\n       *\\n       * NOTE: There is a proposal to eliminate this special case, here:\\n       * https://github.com/solana-labs/solana/issues/18892\\n       */\\n      this._subscriptionsAutoDisposedByRpc.add(subscription);\\n    }\\n\\n    this._handleServerNotification(subscription, result.value === 'receivedSignature' ? [{\\n      type: 'received'\\n    }, result.context] : [{\\n      type: 'status',\\n      result: result.value\\n    }, result.context]);\\n  }\\n  /**\\n   * Register a callback to be invoked upon signature updates\\n   *\\n   * @param signature Transaction signature string in base 58\\n   * @param callback Function to invoke on signature notifications\\n   * @param commitment Specify the commitment level signature must reach before notification\\n   * @return subscription id\\n   */\\n\\n\\n  onSignature(signature, callback, commitment) {\\n    const args = this._buildArgs([signature], commitment || this._commitment || 'finalized' // Apply connection/server default.\\n    );\\n\\n    const clientSubscriptionId = this._makeSubscription({\\n      callback: (notification, context) => {\\n        if (notification.type === 'status') {\\n          callback(notification.result, context); // Signatures subscriptions are auto-removed by the RPC service\\n          // so no need to explicitly send an unsubscribe message.\\n\\n          try {\\n            this.removeSignatureListener(clientSubscriptionId); // eslint-disable-next-line no-empty\\n          } catch (_err) {// Already removed.\\n          }\\n        }\\n      },\\n      method: 'signatureSubscribe',\\n      unsubscribeMethod: 'signatureUnsubscribe'\\n    }, args);\\n\\n    return clientSubscriptionId;\\n  }\\n  /**\\n   * Register a callback to be invoked when a transaction is\\n   * received and/or processed.\\n   *\\n   * @param signature Transaction signature string in base 58\\n   * @param callback Function to invoke on signature notifications\\n   * @param options Enable received notifications and set the commitment\\n   *   level that signature must reach before notification\\n   * @return subscription id\\n   */\\n\\n\\n  onSignatureWithOptions(signature, callback, options) {\\n    const {\\n      commitment,\\n      ...extra\\n    } = { ...options,\\n      commitment: options && options.commitment || this._commitment || 'finalized' // Apply connection/server default.\\n\\n    };\\n\\n    const args = this._buildArgs([signature], commitment, undefined\\n    /* encoding */\\n    , extra);\\n\\n    const clientSubscriptionId = this._makeSubscription({\\n      callback: (notification, context) => {\\n        callback(notification, context); // Signatures subscriptions are auto-removed by the RPC service\\n        // so no need to explicitly send an unsubscribe message.\\n\\n        try {\\n          this.removeSignatureListener(clientSubscriptionId); // eslint-disable-next-line no-empty\\n        } catch (_err) {// Already removed.\\n        }\\n      },\\n      method: 'signatureSubscribe',\\n      unsubscribeMethod: 'signatureUnsubscribe'\\n    }, args);\\n\\n    return clientSubscriptionId;\\n  }\\n  /**\\n   * Deregister a signature notification callback\\n   *\\n   * @param id client subscription id to deregister\\n   */\\n\\n\\n  async removeSignatureListener(clientSubscriptionId) {\\n    await this._unsubscribeClientSubscription(clientSubscriptionId, 'signature result');\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  _wsOnRootNotification(notification) {\\n    const {\\n      result,\\n      subscription\\n    } = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.create)(notification, RootNotificationResult);\\n\\n    this._handleServerNotification(subscription, [result]);\\n  }\\n  /**\\n   * Register a callback to be invoked upon root changes\\n   *\\n   * @param callback Function to invoke whenever the root changes\\n   * @return subscription id\\n   */\\n\\n\\n  onRootChange(callback) {\\n    return this._makeSubscription({\\n      callback,\\n      method: 'rootSubscribe',\\n      unsubscribeMethod: 'rootUnsubscribe'\\n    }, []\\n    /* args */\\n    );\\n  }\\n  /**\\n   * Deregister a root notification callback\\n   *\\n   * @param id client subscription id to deregister\\n   */\\n\\n\\n  async removeRootChangeListener(clientSubscriptionId) {\\n    await this._unsubscribeClientSubscription(clientSubscriptionId, 'root change');\\n  }\\n\\n}\\n\\n/**\\n * Keypair signer interface\\n */\\n\\n/**\\n * An account keypair used for signing transactions.\\n */\\nclass Keypair {\\n  /**\\n   * Create a new keypair instance.\\n   * Generate random keypair if no {@link Ed25519Keypair} is provided.\\n   *\\n   * @param keypair ed25519 keypair\\n   */\\n  constructor(keypair) {\\n    this._keypair = void 0;\\n    this._keypair = keypair !== null && keypair !== void 0 ? keypair : generateKeypair();\\n  }\\n  /**\\n   * Generate a new random keypair\\n   */\\n\\n\\n  static generate() {\\n    return new Keypair(generateKeypair());\\n  }\\n  /**\\n   * Create a keypair from a raw secret key byte array.\\n   *\\n   * This method should only be used to recreate a keypair from a previously\\n   * generated secret key. Generating keypairs from a random seed should be done\\n   * with the {@link Keypair.fromSeed} method.\\n   *\\n   * @throws error if the provided secret key is invalid and validation is not skipped.\\n   *\\n   * @param secretKey secret key byte array\\n   * @param options: skip secret key validation\\n   */\\n\\n\\n  static fromSecretKey(secretKey, options) {\\n    if (secretKey.byteLength !== 64) {\\n      throw new Error('bad secret key size');\\n    }\\n\\n    const publicKey = secretKey.slice(32, 64);\\n\\n    if (!options || !options.skipValidation) {\\n      const privateScalar = secretKey.slice(0, 32);\\n      const computedPublicKey = getPublicKey(privateScalar);\\n\\n      for (let ii = 0; ii < 32; ii++) {\\n        if (publicKey[ii] !== computedPublicKey[ii]) {\\n          throw new Error('provided secretKey is invalid');\\n        }\\n      }\\n    }\\n\\n    return new Keypair({\\n      publicKey,\\n      secretKey\\n    });\\n  }\\n  /**\\n   * Generate a keypair from a 32 byte seed.\\n   *\\n   * @param seed seed byte array\\n   */\\n\\n\\n  static fromSeed(seed) {\\n    const publicKey = getPublicKey(seed);\\n    const secretKey = new Uint8Array(64);\\n    secretKey.set(seed);\\n    secretKey.set(publicKey, 32);\\n    return new Keypair({\\n      publicKey,\\n      secretKey\\n    });\\n  }\\n  /**\\n   * The public key for this keypair\\n   */\\n\\n\\n  get publicKey() {\\n    return new PublicKey(this._keypair.publicKey);\\n  }\\n  /**\\n   * The raw secret key for this keypair\\n   */\\n\\n\\n  get secretKey() {\\n    return new Uint8Array(this._keypair.secretKey);\\n  }\\n\\n}\\n\\n/**\\n * An enumeration of valid address lookup table InstructionType's\\n * @internal\\n */\\nconst LOOKUP_TABLE_INSTRUCTION_LAYOUTS = Object.freeze({\\n  CreateLookupTable: {\\n    index: 0,\\n    layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction'), u64('recentSlot'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u8('bumpSeed')])\\n  },\\n  FreezeLookupTable: {\\n    index: 1,\\n    layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction')])\\n  },\\n  ExtendLookupTable: {\\n    index: 2,\\n    layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction'), u64(), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.seq(publicKey(), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.offset(_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32(), -8), 'addresses')])\\n  },\\n  DeactivateLookupTable: {\\n    index: 3,\\n    layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction')])\\n  },\\n  CloseLookupTable: {\\n    index: 4,\\n    layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction')])\\n  }\\n});\\nclass AddressLookupTableInstruction {\\n  /**\\n   * @internal\\n   */\\n  constructor() {}\\n\\n  static decodeInstructionType(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    const instructionTypeLayout = _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction');\\n    const index = instructionTypeLayout.decode(instruction.data);\\n    let type;\\n\\n    for (const [layoutType, layout] of Object.entries(LOOKUP_TABLE_INSTRUCTION_LAYOUTS)) {\\n      if (layout.index == index) {\\n        type = layoutType;\\n        break;\\n      }\\n    }\\n\\n    if (!type) {\\n      throw new Error('Invalid Instruction. Should be a LookupTable Instruction');\\n    }\\n\\n    return type;\\n  }\\n\\n  static decodeCreateLookupTable(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    this.checkKeysLength(instruction.keys, 4);\\n    const {\\n      recentSlot\\n    } = decodeData$1(LOOKUP_TABLE_INSTRUCTION_LAYOUTS.CreateLookupTable, instruction.data);\\n    return {\\n      authority: instruction.keys[1].pubkey,\\n      payer: instruction.keys[2].pubkey,\\n      recentSlot: Number(recentSlot)\\n    };\\n  }\\n\\n  static decodeExtendLookupTable(instruction) {\\n    this.checkProgramId(instruction.programId);\\n\\n    if (instruction.keys.length < 2) {\\n      throw new Error(`invalid instruction; found ${instruction.keys.length} keys, expected at least 2`);\\n    }\\n\\n    const {\\n      addresses\\n    } = decodeData$1(LOOKUP_TABLE_INSTRUCTION_LAYOUTS.ExtendLookupTable, instruction.data);\\n    return {\\n      lookupTable: instruction.keys[0].pubkey,\\n      authority: instruction.keys[1].pubkey,\\n      payer: instruction.keys.length > 2 ? instruction.keys[2].pubkey : undefined,\\n      addresses: addresses.map(buffer => new PublicKey(buffer))\\n    };\\n  }\\n\\n  static decodeCloseLookupTable(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    this.checkKeysLength(instruction.keys, 3);\\n    return {\\n      lookupTable: instruction.keys[0].pubkey,\\n      authority: instruction.keys[1].pubkey,\\n      recipient: instruction.keys[2].pubkey\\n    };\\n  }\\n\\n  static decodeFreezeLookupTable(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    this.checkKeysLength(instruction.keys, 2);\\n    return {\\n      lookupTable: instruction.keys[0].pubkey,\\n      authority: instruction.keys[1].pubkey\\n    };\\n  }\\n\\n  static decodeDeactivateLookupTable(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    this.checkKeysLength(instruction.keys, 2);\\n    return {\\n      lookupTable: instruction.keys[0].pubkey,\\n      authority: instruction.keys[1].pubkey\\n    };\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  static checkProgramId(programId) {\\n    if (!programId.equals(AddressLookupTableProgram.programId)) {\\n      throw new Error('invalid instruction; programId is not AddressLookupTable Program');\\n    }\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  static checkKeysLength(keys, expectedLength) {\\n    if (keys.length < expectedLength) {\\n      throw new Error(`invalid instruction; found ${keys.length} keys, expected at least ${expectedLength}`);\\n    }\\n  }\\n\\n}\\nclass AddressLookupTableProgram {\\n  /**\\n   * @internal\\n   */\\n  constructor() {}\\n\\n  static createLookupTable(params) {\\n    const [lookupTableAddress, bumpSeed] = PublicKey.findProgramAddressSync([params.authority.toBuffer(), (0,bigint_buffer__WEBPACK_IMPORTED_MODULE_8__.toBufferLE)(BigInt(params.recentSlot), 8)], this.programId);\\n    const type = LOOKUP_TABLE_INSTRUCTION_LAYOUTS.CreateLookupTable;\\n    const data = encodeData(type, {\\n      recentSlot: BigInt(params.recentSlot),\\n      bumpSeed: bumpSeed\\n    });\\n    const keys = [{\\n      pubkey: lookupTableAddress,\\n      isSigner: false,\\n      isWritable: true\\n    }, {\\n      pubkey: params.authority,\\n      isSigner: true,\\n      isWritable: false\\n    }, {\\n      pubkey: params.payer,\\n      isSigner: true,\\n      isWritable: true\\n    }, {\\n      pubkey: SystemProgram.programId,\\n      isSigner: false,\\n      isWritable: false\\n    }];\\n    return [new TransactionInstruction({\\n      programId: this.programId,\\n      keys: keys,\\n      data: data\\n    }), lookupTableAddress];\\n  }\\n\\n  static freezeLookupTable(params) {\\n    const type = LOOKUP_TABLE_INSTRUCTION_LAYOUTS.FreezeLookupTable;\\n    const data = encodeData(type);\\n    const keys = [{\\n      pubkey: params.lookupTable,\\n      isSigner: false,\\n      isWritable: true\\n    }, {\\n      pubkey: params.authority,\\n      isSigner: true,\\n      isWritable: false\\n    }];\\n    return new TransactionInstruction({\\n      programId: this.programId,\\n      keys: keys,\\n      data: data\\n    });\\n  }\\n\\n  static extendLookupTable(params) {\\n    const type = LOOKUP_TABLE_INSTRUCTION_LAYOUTS.ExtendLookupTable;\\n    const data = encodeData(type, {\\n      addresses: params.addresses.map(addr => addr.toBytes())\\n    });\\n    const keys = [{\\n      pubkey: params.lookupTable,\\n      isSigner: false,\\n      isWritable: true\\n    }, {\\n      pubkey: params.authority,\\n      isSigner: true,\\n      isWritable: false\\n    }];\\n\\n    if (params.payer) {\\n      keys.push({\\n        pubkey: params.payer,\\n        isSigner: true,\\n        isWritable: true\\n      }, {\\n        pubkey: SystemProgram.programId,\\n        isSigner: false,\\n        isWritable: false\\n      });\\n    }\\n\\n    return new TransactionInstruction({\\n      programId: this.programId,\\n      keys: keys,\\n      data: data\\n    });\\n  }\\n\\n  static deactivateLookupTable(params) {\\n    const type = LOOKUP_TABLE_INSTRUCTION_LAYOUTS.DeactivateLookupTable;\\n    const data = encodeData(type);\\n    const keys = [{\\n      pubkey: params.lookupTable,\\n      isSigner: false,\\n      isWritable: true\\n    }, {\\n      pubkey: params.authority,\\n      isSigner: true,\\n      isWritable: false\\n    }];\\n    return new TransactionInstruction({\\n      programId: this.programId,\\n      keys: keys,\\n      data: data\\n    });\\n  }\\n\\n  static closeLookupTable(params) {\\n    const type = LOOKUP_TABLE_INSTRUCTION_LAYOUTS.CloseLookupTable;\\n    const data = encodeData(type);\\n    const keys = [{\\n      pubkey: params.lookupTable,\\n      isSigner: false,\\n      isWritable: true\\n    }, {\\n      pubkey: params.authority,\\n      isSigner: true,\\n      isWritable: false\\n    }, {\\n      pubkey: params.recipient,\\n      isSigner: false,\\n      isWritable: true\\n    }];\\n    return new TransactionInstruction({\\n      programId: this.programId,\\n      keys: keys,\\n      data: data\\n    });\\n  }\\n\\n}\\nAddressLookupTableProgram.programId = new PublicKey('AddressLookupTab1e1111111111111111111111111');\\n\\n/**\\n * Compute Budget Instruction class\\n */\\n\\nclass ComputeBudgetInstruction {\\n  /**\\n   * @internal\\n   */\\n  constructor() {}\\n  /**\\n   * Decode a compute budget instruction and retrieve the instruction type.\\n   */\\n\\n\\n  static decodeInstructionType(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    const instructionTypeLayout = _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u8('instruction');\\n    const typeIndex = instructionTypeLayout.decode(instruction.data);\\n    let type;\\n\\n    for (const [ixType, layout] of Object.entries(COMPUTE_BUDGET_INSTRUCTION_LAYOUTS)) {\\n      if (layout.index == typeIndex) {\\n        type = ixType;\\n        break;\\n      }\\n    }\\n\\n    if (!type) {\\n      throw new Error('Instruction type incorrect; not a ComputeBudgetInstruction');\\n    }\\n\\n    return type;\\n  }\\n  /**\\n   * Decode request units compute budget instruction and retrieve the instruction params.\\n   */\\n\\n\\n  static decodeRequestUnits(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    const {\\n      units,\\n      additionalFee\\n    } = decodeData$1(COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.RequestUnits, instruction.data);\\n    return {\\n      units,\\n      additionalFee\\n    };\\n  }\\n  /**\\n   * Decode request heap frame compute budget instruction and retrieve the instruction params.\\n   */\\n\\n\\n  static decodeRequestHeapFrame(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    const {\\n      bytes\\n    } = decodeData$1(COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.RequestHeapFrame, instruction.data);\\n    return {\\n      bytes\\n    };\\n  }\\n  /**\\n   * Decode set compute unit limit compute budget instruction and retrieve the instruction params.\\n   */\\n\\n\\n  static decodeSetComputeUnitLimit(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    const {\\n      units\\n    } = decodeData$1(COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.SetComputeUnitLimit, instruction.data);\\n    return {\\n      units\\n    };\\n  }\\n  /**\\n   * Decode set compute unit price compute budget instruction and retrieve the instruction params.\\n   */\\n\\n\\n  static decodeSetComputeUnitPrice(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    const {\\n      microLamports\\n    } = decodeData$1(COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.SetComputeUnitPrice, instruction.data);\\n    return {\\n      microLamports\\n    };\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  static checkProgramId(programId) {\\n    if (!programId.equals(ComputeBudgetProgram.programId)) {\\n      throw new Error('invalid instruction; programId is not ComputeBudgetProgram');\\n    }\\n  }\\n\\n}\\n/**\\n * An enumeration of valid ComputeBudgetInstructionType's\\n */\\n\\n/**\\n * An enumeration of valid ComputeBudget InstructionType's\\n * @internal\\n */\\nconst COMPUTE_BUDGET_INSTRUCTION_LAYOUTS = Object.freeze({\\n  RequestUnits: {\\n    index: 0,\\n    layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u8('instruction'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('units'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('additionalFee')])\\n  },\\n  RequestHeapFrame: {\\n    index: 1,\\n    layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u8('instruction'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('bytes')])\\n  },\\n  SetComputeUnitLimit: {\\n    index: 2,\\n    layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u8('instruction'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('units')])\\n  },\\n  SetComputeUnitPrice: {\\n    index: 3,\\n    layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u8('instruction'), u64('microLamports')])\\n  }\\n});\\n/**\\n * Factory class for transaction instructions to interact with the Compute Budget program\\n */\\n\\nclass ComputeBudgetProgram {\\n  /**\\n   * @internal\\n   */\\n  constructor() {}\\n  /**\\n   * Public key that identifies the Compute Budget program\\n   */\\n\\n\\n  /**\\n   * @deprecated Instead, call {@link setComputeUnitLimit} and/or {@link setComputeUnitPrice}\\n   */\\n  static requestUnits(params) {\\n    const type = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.RequestUnits;\\n    const data = encodeData(type, params);\\n    return new TransactionInstruction({\\n      keys: [],\\n      programId: this.programId,\\n      data\\n    });\\n  }\\n\\n  static requestHeapFrame(params) {\\n    const type = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.RequestHeapFrame;\\n    const data = encodeData(type, params);\\n    return new TransactionInstruction({\\n      keys: [],\\n      programId: this.programId,\\n      data\\n    });\\n  }\\n\\n  static setComputeUnitLimit(params) {\\n    const type = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.SetComputeUnitLimit;\\n    const data = encodeData(type, params);\\n    return new TransactionInstruction({\\n      keys: [],\\n      programId: this.programId,\\n      data\\n    });\\n  }\\n\\n  static setComputeUnitPrice(params) {\\n    const type = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.SetComputeUnitPrice;\\n    const data = encodeData(type, {\\n      microLamports: BigInt(params.microLamports)\\n    });\\n    return new TransactionInstruction({\\n      keys: [],\\n      programId: this.programId,\\n      data\\n    });\\n  }\\n\\n}\\nComputeBudgetProgram.programId = new PublicKey('ComputeBudget111111111111111111111111111111');\\n\\nconst PRIVATE_KEY_BYTES$1 = 64;\\nconst PUBLIC_KEY_BYTES$1 = 32;\\nconst SIGNATURE_BYTES = 64;\\n/**\\n * Params for creating an ed25519 instruction using a public key\\n */\\n\\nconst ED25519_INSTRUCTION_LAYOUT = _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u8('numSignatures'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u8('padding'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u16('signatureOffset'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u16('signatureInstructionIndex'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u16('publicKeyOffset'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u16('publicKeyInstructionIndex'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u16('messageDataOffset'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u16('messageDataSize'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u16('messageInstructionIndex')]);\\nclass Ed25519Program {\\n  /**\\n   * @internal\\n   */\\n  constructor() {}\\n  /**\\n   * Public key that identifies the ed25519 program\\n   */\\n\\n\\n  /**\\n   * Create an ed25519 instruction with a public key and signature. The\\n   * public key must be a buffer that is 32 bytes long, and the signature\\n   * must be a buffer of 64 bytes.\\n   */\\n  static createInstructionWithPublicKey(params) {\\n    const {\\n      publicKey,\\n      message,\\n      signature,\\n      instructionIndex\\n    } = params;\\n    assert(publicKey.length === PUBLIC_KEY_BYTES$1, `Public Key must be ${PUBLIC_KEY_BYTES$1} bytes but received ${publicKey.length} bytes`);\\n    assert(signature.length === SIGNATURE_BYTES, `Signature must be ${SIGNATURE_BYTES} bytes but received ${signature.length} bytes`);\\n    const publicKeyOffset = ED25519_INSTRUCTION_LAYOUT.span;\\n    const signatureOffset = publicKeyOffset + publicKey.length;\\n    const messageDataOffset = signatureOffset + signature.length;\\n    const numSignatures = 1;\\n    const instructionData = buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.alloc(messageDataOffset + message.length);\\n    const index = instructionIndex == null ? 0xffff // An index of `u16::MAX` makes it default to the current instruction.\\n    : instructionIndex;\\n    ED25519_INSTRUCTION_LAYOUT.encode({\\n      numSignatures,\\n      padding: 0,\\n      signatureOffset,\\n      signatureInstructionIndex: index,\\n      publicKeyOffset,\\n      publicKeyInstructionIndex: index,\\n      messageDataOffset,\\n      messageDataSize: message.length,\\n      messageInstructionIndex: index\\n    }, instructionData);\\n    instructionData.fill(publicKey, publicKeyOffset);\\n    instructionData.fill(signature, signatureOffset);\\n    instructionData.fill(message, messageDataOffset);\\n    return new TransactionInstruction({\\n      keys: [],\\n      programId: Ed25519Program.programId,\\n      data: instructionData\\n    });\\n  }\\n  /**\\n   * Create an ed25519 instruction with a private key. The private key\\n   * must be a buffer that is 64 bytes long.\\n   */\\n\\n\\n  static createInstructionWithPrivateKey(params) {\\n    const {\\n      privateKey,\\n      message,\\n      instructionIndex\\n    } = params;\\n    assert(privateKey.length === PRIVATE_KEY_BYTES$1, `Private key must be ${PRIVATE_KEY_BYTES$1} bytes but received ${privateKey.length} bytes`);\\n\\n    try {\\n      const keypair = Keypair.fromSecretKey(privateKey);\\n      const publicKey = keypair.publicKey.toBytes();\\n      const signature = sign(message, keypair.secretKey);\\n      return this.createInstructionWithPublicKey({\\n        publicKey,\\n        message,\\n        signature,\\n        instructionIndex\\n      });\\n    } catch (error) {\\n      throw new Error(`Error creating instruction; ${error}`);\\n    }\\n  }\\n\\n}\\nEd25519Program.programId = new PublicKey('Ed25519SigVerify111111111111111111111111111');\\n\\n// library interoperable with the synchronous APIs in web3.js.\\n\\n_noble_secp256k1__WEBPACK_IMPORTED_MODULE_13__.utils.hmacSha256Sync = (key, ...msgs) => {\\n  const h = _noble_hashes_hmac__WEBPACK_IMPORTED_MODULE_12__.hmac.create(_noble_hashes_sha256__WEBPACK_IMPORTED_MODULE_5__.sha256, key);\\n  msgs.forEach(msg => h.update(msg));\\n  return h.digest();\\n};\\n\\nconst ecdsaSign = (msgHash, privKey) => _noble_secp256k1__WEBPACK_IMPORTED_MODULE_13__.signSync(msgHash, privKey, {\\n  der: false,\\n  recovered: true\\n});\\n_noble_secp256k1__WEBPACK_IMPORTED_MODULE_13__.utils.isValidPrivateKey;\\nconst publicKeyCreate = _noble_secp256k1__WEBPACK_IMPORTED_MODULE_13__.getPublicKey;\\n\\nconst PRIVATE_KEY_BYTES = 32;\\nconst ETHEREUM_ADDRESS_BYTES = 20;\\nconst PUBLIC_KEY_BYTES = 64;\\nconst SIGNATURE_OFFSETS_SERIALIZED_SIZE = 11;\\n/**\\n * Params for creating an secp256k1 instruction using a public key\\n */\\n\\nconst SECP256K1_INSTRUCTION_LAYOUT = _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u8('numSignatures'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u16('signatureOffset'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u8('signatureInstructionIndex'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u16('ethAddressOffset'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u8('ethAddressInstructionIndex'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u16('messageDataOffset'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u16('messageDataSize'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u8('messageInstructionIndex'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.blob(20, 'ethAddress'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.blob(64, 'signature'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u8('recoveryId')]);\\nclass Secp256k1Program {\\n  /**\\n   * @internal\\n   */\\n  constructor() {}\\n  /**\\n   * Public key that identifies the secp256k1 program\\n   */\\n\\n\\n  /**\\n   * Construct an Ethereum address from a secp256k1 public key buffer.\\n   * @param {Buffer} publicKey a 64 byte secp256k1 public key buffer\\n   */\\n  static publicKeyToEthAddress(publicKey) {\\n    assert(publicKey.length === PUBLIC_KEY_BYTES, `Public key must be ${PUBLIC_KEY_BYTES} bytes but received ${publicKey.length} bytes`);\\n\\n    try {\\n      return buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.from((0,_noble_hashes_sha3__WEBPACK_IMPORTED_MODULE_11__.keccak_256)(toBuffer(publicKey))).slice(-ETHEREUM_ADDRESS_BYTES);\\n    } catch (error) {\\n      throw new Error(`Error constructing Ethereum address: ${error}`);\\n    }\\n  }\\n  /**\\n   * Create an secp256k1 instruction with a public key. The public key\\n   * must be a buffer that is 64 bytes long.\\n   */\\n\\n\\n  static createInstructionWithPublicKey(params) {\\n    const {\\n      publicKey,\\n      message,\\n      signature,\\n      recoveryId,\\n      instructionIndex\\n    } = params;\\n    return Secp256k1Program.createInstructionWithEthAddress({\\n      ethAddress: Secp256k1Program.publicKeyToEthAddress(publicKey),\\n      message,\\n      signature,\\n      recoveryId,\\n      instructionIndex\\n    });\\n  }\\n  /**\\n   * Create an secp256k1 instruction with an Ethereum address. The address\\n   * must be a hex string or a buffer that is 20 bytes long.\\n   */\\n\\n\\n  static createInstructionWithEthAddress(params) {\\n    const {\\n      ethAddress: rawAddress,\\n      message,\\n      signature,\\n      recoveryId,\\n      instructionIndex = 0\\n    } = params;\\n    let ethAddress;\\n\\n    if (typeof rawAddress === 'string') {\\n      if (rawAddress.startsWith('0x')) {\\n        ethAddress = buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.from(rawAddress.substr(2), 'hex');\\n      } else {\\n        ethAddress = buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.from(rawAddress, 'hex');\\n      }\\n    } else {\\n      ethAddress = rawAddress;\\n    }\\n\\n    assert(ethAddress.length === ETHEREUM_ADDRESS_BYTES, `Address must be ${ETHEREUM_ADDRESS_BYTES} bytes but received ${ethAddress.length} bytes`);\\n    const dataStart = 1 + SIGNATURE_OFFSETS_SERIALIZED_SIZE;\\n    const ethAddressOffset = dataStart;\\n    const signatureOffset = dataStart + ethAddress.length;\\n    const messageDataOffset = signatureOffset + signature.length + 1;\\n    const numSignatures = 1;\\n    const instructionData = buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.alloc(SECP256K1_INSTRUCTION_LAYOUT.span + message.length);\\n    SECP256K1_INSTRUCTION_LAYOUT.encode({\\n      numSignatures,\\n      signatureOffset,\\n      signatureInstructionIndex: instructionIndex,\\n      ethAddressOffset,\\n      ethAddressInstructionIndex: instructionIndex,\\n      messageDataOffset,\\n      messageDataSize: message.length,\\n      messageInstructionIndex: instructionIndex,\\n      signature: toBuffer(signature),\\n      ethAddress: toBuffer(ethAddress),\\n      recoveryId\\n    }, instructionData);\\n    instructionData.fill(toBuffer(message), SECP256K1_INSTRUCTION_LAYOUT.span);\\n    return new TransactionInstruction({\\n      keys: [],\\n      programId: Secp256k1Program.programId,\\n      data: instructionData\\n    });\\n  }\\n  /**\\n   * Create an secp256k1 instruction with a private key. The private key\\n   * must be a buffer that is 32 bytes long.\\n   */\\n\\n\\n  static createInstructionWithPrivateKey(params) {\\n    const {\\n      privateKey: pkey,\\n      message,\\n      instructionIndex\\n    } = params;\\n    assert(pkey.length === PRIVATE_KEY_BYTES, `Private key must be ${PRIVATE_KEY_BYTES} bytes but received ${pkey.length} bytes`);\\n\\n    try {\\n      const privateKey = toBuffer(pkey);\\n      const publicKey = publicKeyCreate(privateKey, false\\n      /* isCompressed */\\n      ).slice(1); // throw away leading byte\\n\\n      const messageHash = buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.from((0,_noble_hashes_sha3__WEBPACK_IMPORTED_MODULE_11__.keccak_256)(toBuffer(message)));\\n      const [signature, recoveryId] = ecdsaSign(messageHash, privateKey);\\n      return this.createInstructionWithPublicKey({\\n        publicKey,\\n        message,\\n        signature,\\n        recoveryId,\\n        instructionIndex\\n      });\\n    } catch (error) {\\n      throw new Error(`Error creating instruction; ${error}`);\\n    }\\n  }\\n\\n}\\nSecp256k1Program.programId = new PublicKey('KeccakSecp256k11111111111111111111111111111');\\n\\n/**\\n * Address of the stake config account which configures the rate\\n * of stake warmup and cooldown as well as the slashing penalty.\\n */\\n\\nconst STAKE_CONFIG_ID = new PublicKey('StakeConfig11111111111111111111111111111111');\\n/**\\n * Stake account authority info\\n */\\n\\nclass Authorized {\\n  /** stake authority */\\n\\n  /** withdraw authority */\\n\\n  /**\\n   * Create a new Authorized object\\n   * @param staker the stake authority\\n   * @param withdrawer the withdraw authority\\n   */\\n  constructor(staker, withdrawer) {\\n    this.staker = void 0;\\n    this.withdrawer = void 0;\\n    this.staker = staker;\\n    this.withdrawer = withdrawer;\\n  }\\n\\n}\\n\\n/**\\n * Stake account lockup info\\n */\\nclass Lockup {\\n  /** Unix timestamp of lockup expiration */\\n\\n  /** Epoch of lockup expiration */\\n\\n  /** Lockup custodian authority */\\n\\n  /**\\n   * Create a new Lockup object\\n   */\\n  constructor(unixTimestamp, epoch, custodian) {\\n    this.unixTimestamp = void 0;\\n    this.epoch = void 0;\\n    this.custodian = void 0;\\n    this.unixTimestamp = unixTimestamp;\\n    this.epoch = epoch;\\n    this.custodian = custodian;\\n  }\\n  /**\\n   * Default, inactive Lockup value\\n   */\\n\\n\\n}\\nLockup.default = new Lockup(0, 0, PublicKey.default);\\n\\n/**\\n * Stake Instruction class\\n */\\nclass StakeInstruction {\\n  /**\\n   * @internal\\n   */\\n  constructor() {}\\n  /**\\n   * Decode a stake instruction and retrieve the instruction type.\\n   */\\n\\n\\n  static decodeInstructionType(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    const instructionTypeLayout = _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction');\\n    const typeIndex = instructionTypeLayout.decode(instruction.data);\\n    let type;\\n\\n    for (const [ixType, layout] of Object.entries(STAKE_INSTRUCTION_LAYOUTS)) {\\n      if (layout.index == typeIndex) {\\n        type = ixType;\\n        break;\\n      }\\n    }\\n\\n    if (!type) {\\n      throw new Error('Instruction type incorrect; not a StakeInstruction');\\n    }\\n\\n    return type;\\n  }\\n  /**\\n   * Decode a initialize stake instruction and retrieve the instruction params.\\n   */\\n\\n\\n  static decodeInitialize(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    this.checkKeyLength(instruction.keys, 2);\\n    const {\\n      authorized,\\n      lockup\\n    } = decodeData$1(STAKE_INSTRUCTION_LAYOUTS.Initialize, instruction.data);\\n    return {\\n      stakePubkey: instruction.keys[0].pubkey,\\n      authorized: new Authorized(new PublicKey(authorized.staker), new PublicKey(authorized.withdrawer)),\\n      lockup: new Lockup(lockup.unixTimestamp, lockup.epoch, new PublicKey(lockup.custodian))\\n    };\\n  }\\n  /**\\n   * Decode a delegate stake instruction and retrieve the instruction params.\\n   */\\n\\n\\n  static decodeDelegate(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    this.checkKeyLength(instruction.keys, 6);\\n    decodeData$1(STAKE_INSTRUCTION_LAYOUTS.Delegate, instruction.data);\\n    return {\\n      stakePubkey: instruction.keys[0].pubkey,\\n      votePubkey: instruction.keys[1].pubkey,\\n      authorizedPubkey: instruction.keys[5].pubkey\\n    };\\n  }\\n  /**\\n   * Decode an authorize stake instruction and retrieve the instruction params.\\n   */\\n\\n\\n  static decodeAuthorize(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    this.checkKeyLength(instruction.keys, 3);\\n    const {\\n      newAuthorized,\\n      stakeAuthorizationType\\n    } = decodeData$1(STAKE_INSTRUCTION_LAYOUTS.Authorize, instruction.data);\\n    const o = {\\n      stakePubkey: instruction.keys[0].pubkey,\\n      authorizedPubkey: instruction.keys[2].pubkey,\\n      newAuthorizedPubkey: new PublicKey(newAuthorized),\\n      stakeAuthorizationType: {\\n        index: stakeAuthorizationType\\n      }\\n    };\\n\\n    if (instruction.keys.length > 3) {\\n      o.custodianPubkey = instruction.keys[3].pubkey;\\n    }\\n\\n    return o;\\n  }\\n  /**\\n   * Decode an authorize-with-seed stake instruction and retrieve the instruction params.\\n   */\\n\\n\\n  static decodeAuthorizeWithSeed(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    this.checkKeyLength(instruction.keys, 2);\\n    const {\\n      newAuthorized,\\n      stakeAuthorizationType,\\n      authoritySeed,\\n      authorityOwner\\n    } = decodeData$1(STAKE_INSTRUCTION_LAYOUTS.AuthorizeWithSeed, instruction.data);\\n    const o = {\\n      stakePubkey: instruction.keys[0].pubkey,\\n      authorityBase: instruction.keys[1].pubkey,\\n      authoritySeed: authoritySeed,\\n      authorityOwner: new PublicKey(authorityOwner),\\n      newAuthorizedPubkey: new PublicKey(newAuthorized),\\n      stakeAuthorizationType: {\\n        index: stakeAuthorizationType\\n      }\\n    };\\n\\n    if (instruction.keys.length > 3) {\\n      o.custodianPubkey = instruction.keys[3].pubkey;\\n    }\\n\\n    return o;\\n  }\\n  /**\\n   * Decode a split stake instruction and retrieve the instruction params.\\n   */\\n\\n\\n  static decodeSplit(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    this.checkKeyLength(instruction.keys, 3);\\n    const {\\n      lamports\\n    } = decodeData$1(STAKE_INSTRUCTION_LAYOUTS.Split, instruction.data);\\n    return {\\n      stakePubkey: instruction.keys[0].pubkey,\\n      splitStakePubkey: instruction.keys[1].pubkey,\\n      authorizedPubkey: instruction.keys[2].pubkey,\\n      lamports\\n    };\\n  }\\n  /**\\n   * Decode a merge stake instruction and retrieve the instruction params.\\n   */\\n\\n\\n  static decodeMerge(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    this.checkKeyLength(instruction.keys, 3);\\n    decodeData$1(STAKE_INSTRUCTION_LAYOUTS.Merge, instruction.data);\\n    return {\\n      stakePubkey: instruction.keys[0].pubkey,\\n      sourceStakePubKey: instruction.keys[1].pubkey,\\n      authorizedPubkey: instruction.keys[4].pubkey\\n    };\\n  }\\n  /**\\n   * Decode a withdraw stake instruction and retrieve the instruction params.\\n   */\\n\\n\\n  static decodeWithdraw(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    this.checkKeyLength(instruction.keys, 5);\\n    const {\\n      lamports\\n    } = decodeData$1(STAKE_INSTRUCTION_LAYOUTS.Withdraw, instruction.data);\\n    const o = {\\n      stakePubkey: instruction.keys[0].pubkey,\\n      toPubkey: instruction.keys[1].pubkey,\\n      authorizedPubkey: instruction.keys[4].pubkey,\\n      lamports\\n    };\\n\\n    if (instruction.keys.length > 5) {\\n      o.custodianPubkey = instruction.keys[5].pubkey;\\n    }\\n\\n    return o;\\n  }\\n  /**\\n   * Decode a deactivate stake instruction and retrieve the instruction params.\\n   */\\n\\n\\n  static decodeDeactivate(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    this.checkKeyLength(instruction.keys, 3);\\n    decodeData$1(STAKE_INSTRUCTION_LAYOUTS.Deactivate, instruction.data);\\n    return {\\n      stakePubkey: instruction.keys[0].pubkey,\\n      authorizedPubkey: instruction.keys[2].pubkey\\n    };\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  static checkProgramId(programId) {\\n    if (!programId.equals(StakeProgram.programId)) {\\n      throw new Error('invalid instruction; programId is not StakeProgram');\\n    }\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  static checkKeyLength(keys, expectedLength) {\\n    if (keys.length < expectedLength) {\\n      throw new Error(`invalid instruction; found ${keys.length} keys, expected at least ${expectedLength}`);\\n    }\\n  }\\n\\n}\\n/**\\n * An enumeration of valid StakeInstructionType's\\n */\\n\\n/**\\n * An enumeration of valid stake InstructionType's\\n * @internal\\n */\\nconst STAKE_INSTRUCTION_LAYOUTS = Object.freeze({\\n  Initialize: {\\n    index: 0,\\n    layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction'), authorized(), lockup()])\\n  },\\n  Authorize: {\\n    index: 1,\\n    layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction'), publicKey('newAuthorized'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('stakeAuthorizationType')])\\n  },\\n  Delegate: {\\n    index: 2,\\n    layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction')])\\n  },\\n  Split: {\\n    index: 3,\\n    layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.ns64('lamports')])\\n  },\\n  Withdraw: {\\n    index: 4,\\n    layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.ns64('lamports')])\\n  },\\n  Deactivate: {\\n    index: 5,\\n    layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction')])\\n  },\\n  Merge: {\\n    index: 7,\\n    layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction')])\\n  },\\n  AuthorizeWithSeed: {\\n    index: 8,\\n    layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction'), publicKey('newAuthorized'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('stakeAuthorizationType'), rustString('authoritySeed'), publicKey('authorityOwner')])\\n  }\\n});\\n/**\\n * Stake authorization type\\n */\\n\\n/**\\n * An enumeration of valid StakeAuthorizationLayout's\\n */\\nconst StakeAuthorizationLayout = Object.freeze({\\n  Staker: {\\n    index: 0\\n  },\\n  Withdrawer: {\\n    index: 1\\n  }\\n});\\n/**\\n * Factory class for transactions to interact with the Stake program\\n */\\n\\nclass StakeProgram {\\n  /**\\n   * @internal\\n   */\\n  constructor() {}\\n  /**\\n   * Public key that identifies the Stake program\\n   */\\n\\n\\n  /**\\n   * Generate an Initialize instruction to add to a Stake Create transaction\\n   */\\n  static initialize(params) {\\n    const {\\n      stakePubkey,\\n      authorized,\\n      lockup: maybeLockup\\n    } = params;\\n    const lockup = maybeLockup || Lockup.default;\\n    const type = STAKE_INSTRUCTION_LAYOUTS.Initialize;\\n    const data = encodeData(type, {\\n      authorized: {\\n        staker: toBuffer(authorized.staker.toBuffer()),\\n        withdrawer: toBuffer(authorized.withdrawer.toBuffer())\\n      },\\n      lockup: {\\n        unixTimestamp: lockup.unixTimestamp,\\n        epoch: lockup.epoch,\\n        custodian: toBuffer(lockup.custodian.toBuffer())\\n      }\\n    });\\n    const instructionData = {\\n      keys: [{\\n        pubkey: stakePubkey,\\n        isSigner: false,\\n        isWritable: true\\n      }, {\\n        pubkey: SYSVAR_RENT_PUBKEY,\\n        isSigner: false,\\n        isWritable: false\\n      }],\\n      programId: this.programId,\\n      data\\n    };\\n    return new TransactionInstruction(instructionData);\\n  }\\n  /**\\n   * Generate a Transaction that creates a new Stake account at\\n   *   an address generated with `from`, a seed, and the Stake programId\\n   */\\n\\n\\n  static createAccountWithSeed(params) {\\n    const transaction = new Transaction();\\n    transaction.add(SystemProgram.createAccountWithSeed({\\n      fromPubkey: params.fromPubkey,\\n      newAccountPubkey: params.stakePubkey,\\n      basePubkey: params.basePubkey,\\n      seed: params.seed,\\n      lamports: params.lamports,\\n      space: this.space,\\n      programId: this.programId\\n    }));\\n    const {\\n      stakePubkey,\\n      authorized,\\n      lockup\\n    } = params;\\n    return transaction.add(this.initialize({\\n      stakePubkey,\\n      authorized,\\n      lockup\\n    }));\\n  }\\n  /**\\n   * Generate a Transaction that creates a new Stake account\\n   */\\n\\n\\n  static createAccount(params) {\\n    const transaction = new Transaction();\\n    transaction.add(SystemProgram.createAccount({\\n      fromPubkey: params.fromPubkey,\\n      newAccountPubkey: params.stakePubkey,\\n      lamports: params.lamports,\\n      space: this.space,\\n      programId: this.programId\\n    }));\\n    const {\\n      stakePubkey,\\n      authorized,\\n      lockup\\n    } = params;\\n    return transaction.add(this.initialize({\\n      stakePubkey,\\n      authorized,\\n      lockup\\n    }));\\n  }\\n  /**\\n   * Generate a Transaction that delegates Stake tokens to a validator\\n   * Vote PublicKey. This transaction can also be used to redelegate Stake\\n   * to a new validator Vote PublicKey.\\n   */\\n\\n\\n  static delegate(params) {\\n    const {\\n      stakePubkey,\\n      authorizedPubkey,\\n      votePubkey\\n    } = params;\\n    const type = STAKE_INSTRUCTION_LAYOUTS.Delegate;\\n    const data = encodeData(type);\\n    return new Transaction().add({\\n      keys: [{\\n        pubkey: stakePubkey,\\n        isSigner: false,\\n        isWritable: true\\n      }, {\\n        pubkey: votePubkey,\\n        isSigner: false,\\n        isWritable: false\\n      }, {\\n        pubkey: SYSVAR_CLOCK_PUBKEY,\\n        isSigner: false,\\n        isWritable: false\\n      }, {\\n        pubkey: SYSVAR_STAKE_HISTORY_PUBKEY,\\n        isSigner: false,\\n        isWritable: false\\n      }, {\\n        pubkey: STAKE_CONFIG_ID,\\n        isSigner: false,\\n        isWritable: false\\n      }, {\\n        pubkey: authorizedPubkey,\\n        isSigner: true,\\n        isWritable: false\\n      }],\\n      programId: this.programId,\\n      data\\n    });\\n  }\\n  /**\\n   * Generate a Transaction that authorizes a new PublicKey as Staker\\n   * or Withdrawer on the Stake account.\\n   */\\n\\n\\n  static authorize(params) {\\n    const {\\n      stakePubkey,\\n      authorizedPubkey,\\n      newAuthorizedPubkey,\\n      stakeAuthorizationType,\\n      custodianPubkey\\n    } = params;\\n    const type = STAKE_INSTRUCTION_LAYOUTS.Authorize;\\n    const data = encodeData(type, {\\n      newAuthorized: toBuffer(newAuthorizedPubkey.toBuffer()),\\n      stakeAuthorizationType: stakeAuthorizationType.index\\n    });\\n    const keys = [{\\n      pubkey: stakePubkey,\\n      isSigner: false,\\n      isWritable: true\\n    }, {\\n      pubkey: SYSVAR_CLOCK_PUBKEY,\\n      isSigner: false,\\n      isWritable: true\\n    }, {\\n      pubkey: authorizedPubkey,\\n      isSigner: true,\\n      isWritable: false\\n    }];\\n\\n    if (custodianPubkey) {\\n      keys.push({\\n        pubkey: custodianPubkey,\\n        isSigner: false,\\n        isWritable: false\\n      });\\n    }\\n\\n    return new Transaction().add({\\n      keys,\\n      programId: this.programId,\\n      data\\n    });\\n  }\\n  /**\\n   * Generate a Transaction that authorizes a new PublicKey as Staker\\n   * or Withdrawer on the Stake account.\\n   */\\n\\n\\n  static authorizeWithSeed(params) {\\n    const {\\n      stakePubkey,\\n      authorityBase,\\n      authoritySeed,\\n      authorityOwner,\\n      newAuthorizedPubkey,\\n      stakeAuthorizationType,\\n      custodianPubkey\\n    } = params;\\n    const type = STAKE_INSTRUCTION_LAYOUTS.AuthorizeWithSeed;\\n    const data = encodeData(type, {\\n      newAuthorized: toBuffer(newAuthorizedPubkey.toBuffer()),\\n      stakeAuthorizationType: stakeAuthorizationType.index,\\n      authoritySeed: authoritySeed,\\n      authorityOwner: toBuffer(authorityOwner.toBuffer())\\n    });\\n    const keys = [{\\n      pubkey: stakePubkey,\\n      isSigner: false,\\n      isWritable: true\\n    }, {\\n      pubkey: authorityBase,\\n      isSigner: true,\\n      isWritable: false\\n    }, {\\n      pubkey: SYSVAR_CLOCK_PUBKEY,\\n      isSigner: false,\\n      isWritable: false\\n    }];\\n\\n    if (custodianPubkey) {\\n      keys.push({\\n        pubkey: custodianPubkey,\\n        isSigner: false,\\n        isWritable: false\\n      });\\n    }\\n\\n    return new Transaction().add({\\n      keys,\\n      programId: this.programId,\\n      data\\n    });\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  static splitInstruction(params) {\\n    const {\\n      stakePubkey,\\n      authorizedPubkey,\\n      splitStakePubkey,\\n      lamports\\n    } = params;\\n    const type = STAKE_INSTRUCTION_LAYOUTS.Split;\\n    const data = encodeData(type, {\\n      lamports\\n    });\\n    return new TransactionInstruction({\\n      keys: [{\\n        pubkey: stakePubkey,\\n        isSigner: false,\\n        isWritable: true\\n      }, {\\n        pubkey: splitStakePubkey,\\n        isSigner: false,\\n        isWritable: true\\n      }, {\\n        pubkey: authorizedPubkey,\\n        isSigner: true,\\n        isWritable: false\\n      }],\\n      programId: this.programId,\\n      data\\n    });\\n  }\\n  /**\\n   * Generate a Transaction that splits Stake tokens into another stake account\\n   */\\n\\n\\n  static split(params) {\\n    const transaction = new Transaction();\\n    transaction.add(SystemProgram.createAccount({\\n      fromPubkey: params.authorizedPubkey,\\n      newAccountPubkey: params.splitStakePubkey,\\n      lamports: 0,\\n      space: this.space,\\n      programId: this.programId\\n    }));\\n    return transaction.add(this.splitInstruction(params));\\n  }\\n  /**\\n   * Generate a Transaction that splits Stake tokens into another account\\n   * derived from a base public key and seed\\n   */\\n\\n\\n  static splitWithSeed(params) {\\n    const {\\n      stakePubkey,\\n      authorizedPubkey,\\n      splitStakePubkey,\\n      basePubkey,\\n      seed,\\n      lamports\\n    } = params;\\n    const transaction = new Transaction();\\n    transaction.add(SystemProgram.allocate({\\n      accountPubkey: splitStakePubkey,\\n      basePubkey,\\n      seed,\\n      space: this.space,\\n      programId: this.programId\\n    }));\\n    return transaction.add(this.splitInstruction({\\n      stakePubkey,\\n      authorizedPubkey,\\n      splitStakePubkey,\\n      lamports\\n    }));\\n  }\\n  /**\\n   * Generate a Transaction that merges Stake accounts.\\n   */\\n\\n\\n  static merge(params) {\\n    const {\\n      stakePubkey,\\n      sourceStakePubKey,\\n      authorizedPubkey\\n    } = params;\\n    const type = STAKE_INSTRUCTION_LAYOUTS.Merge;\\n    const data = encodeData(type);\\n    return new Transaction().add({\\n      keys: [{\\n        pubkey: stakePubkey,\\n        isSigner: false,\\n        isWritable: true\\n      }, {\\n        pubkey: sourceStakePubKey,\\n        isSigner: false,\\n        isWritable: true\\n      }, {\\n        pubkey: SYSVAR_CLOCK_PUBKEY,\\n        isSigner: false,\\n        isWritable: false\\n      }, {\\n        pubkey: SYSVAR_STAKE_HISTORY_PUBKEY,\\n        isSigner: false,\\n        isWritable: false\\n      }, {\\n        pubkey: authorizedPubkey,\\n        isSigner: true,\\n        isWritable: false\\n      }],\\n      programId: this.programId,\\n      data\\n    });\\n  }\\n  /**\\n   * Generate a Transaction that withdraws deactivated Stake tokens.\\n   */\\n\\n\\n  static withdraw(params) {\\n    const {\\n      stakePubkey,\\n      authorizedPubkey,\\n      toPubkey,\\n      lamports,\\n      custodianPubkey\\n    } = params;\\n    const type = STAKE_INSTRUCTION_LAYOUTS.Withdraw;\\n    const data = encodeData(type, {\\n      lamports\\n    });\\n    const keys = [{\\n      pubkey: stakePubkey,\\n      isSigner: false,\\n      isWritable: true\\n    }, {\\n      pubkey: toPubkey,\\n      isSigner: false,\\n      isWritable: true\\n    }, {\\n      pubkey: SYSVAR_CLOCK_PUBKEY,\\n      isSigner: false,\\n      isWritable: false\\n    }, {\\n      pubkey: SYSVAR_STAKE_HISTORY_PUBKEY,\\n      isSigner: false,\\n      isWritable: false\\n    }, {\\n      pubkey: authorizedPubkey,\\n      isSigner: true,\\n      isWritable: false\\n    }];\\n\\n    if (custodianPubkey) {\\n      keys.push({\\n        pubkey: custodianPubkey,\\n        isSigner: false,\\n        isWritable: false\\n      });\\n    }\\n\\n    return new Transaction().add({\\n      keys,\\n      programId: this.programId,\\n      data\\n    });\\n  }\\n  /**\\n   * Generate a Transaction that deactivates Stake tokens.\\n   */\\n\\n\\n  static deactivate(params) {\\n    const {\\n      stakePubkey,\\n      authorizedPubkey\\n    } = params;\\n    const type = STAKE_INSTRUCTION_LAYOUTS.Deactivate;\\n    const data = encodeData(type);\\n    return new Transaction().add({\\n      keys: [{\\n        pubkey: stakePubkey,\\n        isSigner: false,\\n        isWritable: true\\n      }, {\\n        pubkey: SYSVAR_CLOCK_PUBKEY,\\n        isSigner: false,\\n        isWritable: false\\n      }, {\\n        pubkey: authorizedPubkey,\\n        isSigner: true,\\n        isWritable: false\\n      }],\\n      programId: this.programId,\\n      data\\n    });\\n  }\\n\\n}\\nStakeProgram.programId = new PublicKey('Stake11111111111111111111111111111111111111');\\nStakeProgram.space = 200;\\n\\n/**\\n * Vote account info\\n */\\n\\nclass VoteInit {\\n  /** [0, 100] */\\n  constructor(nodePubkey, authorizedVoter, authorizedWithdrawer, commission) {\\n    this.nodePubkey = void 0;\\n    this.authorizedVoter = void 0;\\n    this.authorizedWithdrawer = void 0;\\n    this.commission = void 0;\\n    this.nodePubkey = nodePubkey;\\n    this.authorizedVoter = authorizedVoter;\\n    this.authorizedWithdrawer = authorizedWithdrawer;\\n    this.commission = commission;\\n  }\\n\\n}\\n/**\\n * Create vote account transaction params\\n */\\n\\n/**\\n * Vote Instruction class\\n */\\nclass VoteInstruction {\\n  /**\\n   * @internal\\n   */\\n  constructor() {}\\n  /**\\n   * Decode a vote instruction and retrieve the instruction type.\\n   */\\n\\n\\n  static decodeInstructionType(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    const instructionTypeLayout = _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction');\\n    const typeIndex = instructionTypeLayout.decode(instruction.data);\\n    let type;\\n\\n    for (const [ixType, layout] of Object.entries(VOTE_INSTRUCTION_LAYOUTS)) {\\n      if (layout.index == typeIndex) {\\n        type = ixType;\\n        break;\\n      }\\n    }\\n\\n    if (!type) {\\n      throw new Error('Instruction type incorrect; not a VoteInstruction');\\n    }\\n\\n    return type;\\n  }\\n  /**\\n   * Decode an initialize vote instruction and retrieve the instruction params.\\n   */\\n\\n\\n  static decodeInitializeAccount(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    this.checkKeyLength(instruction.keys, 4);\\n    const {\\n      voteInit\\n    } = decodeData$1(VOTE_INSTRUCTION_LAYOUTS.InitializeAccount, instruction.data);\\n    return {\\n      votePubkey: instruction.keys[0].pubkey,\\n      nodePubkey: instruction.keys[3].pubkey,\\n      voteInit: new VoteInit(new PublicKey(voteInit.nodePubkey), new PublicKey(voteInit.authorizedVoter), new PublicKey(voteInit.authorizedWithdrawer), voteInit.commission)\\n    };\\n  }\\n  /**\\n   * Decode an authorize instruction and retrieve the instruction params.\\n   */\\n\\n\\n  static decodeAuthorize(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    this.checkKeyLength(instruction.keys, 3);\\n    const {\\n      newAuthorized,\\n      voteAuthorizationType\\n    } = decodeData$1(VOTE_INSTRUCTION_LAYOUTS.Authorize, instruction.data);\\n    return {\\n      votePubkey: instruction.keys[0].pubkey,\\n      authorizedPubkey: instruction.keys[2].pubkey,\\n      newAuthorizedPubkey: new PublicKey(newAuthorized),\\n      voteAuthorizationType: {\\n        index: voteAuthorizationType\\n      }\\n    };\\n  }\\n  /**\\n   * Decode an authorize instruction and retrieve the instruction params.\\n   */\\n\\n\\n  static decodeAuthorizeWithSeed(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    this.checkKeyLength(instruction.keys, 3);\\n    const {\\n      voteAuthorizeWithSeedArgs: {\\n        currentAuthorityDerivedKeyOwnerPubkey,\\n        currentAuthorityDerivedKeySeed,\\n        newAuthorized,\\n        voteAuthorizationType\\n      }\\n    } = decodeData$1(VOTE_INSTRUCTION_LAYOUTS.AuthorizeWithSeed, instruction.data);\\n    return {\\n      currentAuthorityDerivedKeyBasePubkey: instruction.keys[2].pubkey,\\n      currentAuthorityDerivedKeyOwnerPubkey: new PublicKey(currentAuthorityDerivedKeyOwnerPubkey),\\n      currentAuthorityDerivedKeySeed: currentAuthorityDerivedKeySeed,\\n      newAuthorizedPubkey: new PublicKey(newAuthorized),\\n      voteAuthorizationType: {\\n        index: voteAuthorizationType\\n      },\\n      votePubkey: instruction.keys[0].pubkey\\n    };\\n  }\\n  /**\\n   * Decode a withdraw instruction and retrieve the instruction params.\\n   */\\n\\n\\n  static decodeWithdraw(instruction) {\\n    this.checkProgramId(instruction.programId);\\n    this.checkKeyLength(instruction.keys, 3);\\n    const {\\n      lamports\\n    } = decodeData$1(VOTE_INSTRUCTION_LAYOUTS.Withdraw, instruction.data);\\n    return {\\n      votePubkey: instruction.keys[0].pubkey,\\n      authorizedWithdrawerPubkey: instruction.keys[2].pubkey,\\n      lamports,\\n      toPubkey: instruction.keys[1].pubkey\\n    };\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  static checkProgramId(programId) {\\n    if (!programId.equals(VoteProgram.programId)) {\\n      throw new Error('invalid instruction; programId is not VoteProgram');\\n    }\\n  }\\n  /**\\n   * @internal\\n   */\\n\\n\\n  static checkKeyLength(keys, expectedLength) {\\n    if (keys.length < expectedLength) {\\n      throw new Error(`invalid instruction; found ${keys.length} keys, expected at least ${expectedLength}`);\\n    }\\n  }\\n\\n}\\n/**\\n * An enumeration of valid VoteInstructionType's\\n */\\n\\nconst VOTE_INSTRUCTION_LAYOUTS = Object.freeze({\\n  InitializeAccount: {\\n    index: 0,\\n    layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction'), voteInit()])\\n  },\\n  Authorize: {\\n    index: 1,\\n    layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction'), publicKey('newAuthorized'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('voteAuthorizationType')])\\n  },\\n  Withdraw: {\\n    index: 3,\\n    layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.ns64('lamports')])\\n  },\\n  AuthorizeWithSeed: {\\n    index: 10,\\n    layout: _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('instruction'), voteAuthorizeWithSeedArgs()])\\n  }\\n});\\n/**\\n * VoteAuthorize type\\n */\\n\\n/**\\n * An enumeration of valid VoteAuthorization layouts.\\n */\\nconst VoteAuthorizationLayout = Object.freeze({\\n  Voter: {\\n    index: 0\\n  },\\n  Withdrawer: {\\n    index: 1\\n  }\\n});\\n/**\\n * Factory class for transactions to interact with the Vote program\\n */\\n\\nclass VoteProgram {\\n  /**\\n   * @internal\\n   */\\n  constructor() {}\\n  /**\\n   * Public key that identifies the Vote program\\n   */\\n\\n\\n  /**\\n   * Generate an Initialize instruction.\\n   */\\n  static initializeAccount(params) {\\n    const {\\n      votePubkey,\\n      nodePubkey,\\n      voteInit\\n    } = params;\\n    const type = VOTE_INSTRUCTION_LAYOUTS.InitializeAccount;\\n    const data = encodeData(type, {\\n      voteInit: {\\n        nodePubkey: toBuffer(voteInit.nodePubkey.toBuffer()),\\n        authorizedVoter: toBuffer(voteInit.authorizedVoter.toBuffer()),\\n        authorizedWithdrawer: toBuffer(voteInit.authorizedWithdrawer.toBuffer()),\\n        commission: voteInit.commission\\n      }\\n    });\\n    const instructionData = {\\n      keys: [{\\n        pubkey: votePubkey,\\n        isSigner: false,\\n        isWritable: true\\n      }, {\\n        pubkey: SYSVAR_RENT_PUBKEY,\\n        isSigner: false,\\n        isWritable: false\\n      }, {\\n        pubkey: SYSVAR_CLOCK_PUBKEY,\\n        isSigner: false,\\n        isWritable: false\\n      }, {\\n        pubkey: nodePubkey,\\n        isSigner: true,\\n        isWritable: false\\n      }],\\n      programId: this.programId,\\n      data\\n    };\\n    return new TransactionInstruction(instructionData);\\n  }\\n  /**\\n   * Generate a transaction that creates a new Vote account.\\n   */\\n\\n\\n  static createAccount(params) {\\n    const transaction = new Transaction();\\n    transaction.add(SystemProgram.createAccount({\\n      fromPubkey: params.fromPubkey,\\n      newAccountPubkey: params.votePubkey,\\n      lamports: params.lamports,\\n      space: this.space,\\n      programId: this.programId\\n    }));\\n    return transaction.add(this.initializeAccount({\\n      votePubkey: params.votePubkey,\\n      nodePubkey: params.voteInit.nodePubkey,\\n      voteInit: params.voteInit\\n    }));\\n  }\\n  /**\\n   * Generate a transaction that authorizes a new Voter or Withdrawer on the Vote account.\\n   */\\n\\n\\n  static authorize(params) {\\n    const {\\n      votePubkey,\\n      authorizedPubkey,\\n      newAuthorizedPubkey,\\n      voteAuthorizationType\\n    } = params;\\n    const type = VOTE_INSTRUCTION_LAYOUTS.Authorize;\\n    const data = encodeData(type, {\\n      newAuthorized: toBuffer(newAuthorizedPubkey.toBuffer()),\\n      voteAuthorizationType: voteAuthorizationType.index\\n    });\\n    const keys = [{\\n      pubkey: votePubkey,\\n      isSigner: false,\\n      isWritable: true\\n    }, {\\n      pubkey: SYSVAR_CLOCK_PUBKEY,\\n      isSigner: false,\\n      isWritable: false\\n    }, {\\n      pubkey: authorizedPubkey,\\n      isSigner: true,\\n      isWritable: false\\n    }];\\n    return new Transaction().add({\\n      keys,\\n      programId: this.programId,\\n      data\\n    });\\n  }\\n  /**\\n   * Generate a transaction that authorizes a new Voter or Withdrawer on the Vote account\\n   * where the current Voter or Withdrawer authority is a derived key.\\n   */\\n\\n\\n  static authorizeWithSeed(params) {\\n    const {\\n      currentAuthorityDerivedKeyBasePubkey,\\n      currentAuthorityDerivedKeyOwnerPubkey,\\n      currentAuthorityDerivedKeySeed,\\n      newAuthorizedPubkey,\\n      voteAuthorizationType,\\n      votePubkey\\n    } = params;\\n    const type = VOTE_INSTRUCTION_LAYOUTS.AuthorizeWithSeed;\\n    const data = encodeData(type, {\\n      voteAuthorizeWithSeedArgs: {\\n        currentAuthorityDerivedKeyOwnerPubkey: toBuffer(currentAuthorityDerivedKeyOwnerPubkey.toBuffer()),\\n        currentAuthorityDerivedKeySeed: currentAuthorityDerivedKeySeed,\\n        newAuthorized: toBuffer(newAuthorizedPubkey.toBuffer()),\\n        voteAuthorizationType: voteAuthorizationType.index\\n      }\\n    });\\n    const keys = [{\\n      pubkey: votePubkey,\\n      isSigner: false,\\n      isWritable: true\\n    }, {\\n      pubkey: SYSVAR_CLOCK_PUBKEY,\\n      isSigner: false,\\n      isWritable: false\\n    }, {\\n      pubkey: currentAuthorityDerivedKeyBasePubkey,\\n      isSigner: true,\\n      isWritable: false\\n    }];\\n    return new Transaction().add({\\n      keys,\\n      programId: this.programId,\\n      data\\n    });\\n  }\\n  /**\\n   * Generate a transaction to withdraw from a Vote account.\\n   */\\n\\n\\n  static withdraw(params) {\\n    const {\\n      votePubkey,\\n      authorizedWithdrawerPubkey,\\n      lamports,\\n      toPubkey\\n    } = params;\\n    const type = VOTE_INSTRUCTION_LAYOUTS.Withdraw;\\n    const data = encodeData(type, {\\n      lamports\\n    });\\n    const keys = [{\\n      pubkey: votePubkey,\\n      isSigner: false,\\n      isWritable: true\\n    }, {\\n      pubkey: toPubkey,\\n      isSigner: false,\\n      isWritable: true\\n    }, {\\n      pubkey: authorizedWithdrawerPubkey,\\n      isSigner: true,\\n      isWritable: false\\n    }];\\n    return new Transaction().add({\\n      keys,\\n      programId: this.programId,\\n      data\\n    });\\n  }\\n  /**\\n   * Generate a transaction to withdraw safely from a Vote account.\\n   *\\n   * This function was created as a safeguard for vote accounts running validators, `safeWithdraw`\\n   * checks that the withdraw amount will not exceed the specified balance while leaving enough left\\n   * to cover rent. If you wish to close the vote account by withdrawing the full amount, call the\\n   * `withdraw` method directly.\\n   */\\n\\n\\n  static safeWithdraw(params, currentVoteAccountBalance, rentExemptMinimum) {\\n    if (params.lamports > currentVoteAccountBalance - rentExemptMinimum) {\\n      throw new Error('Withdraw will leave vote account with insuffcient funds.');\\n    }\\n\\n    return VoteProgram.withdraw(params);\\n  }\\n\\n}\\nVoteProgram.programId = new PublicKey('Vote111111111111111111111111111111111111111');\\nVoteProgram.space = 3731;\\n\\nconst VALIDATOR_INFO_KEY = new PublicKey('Va1idator1nfo111111111111111111111111111111');\\n/**\\n * @internal\\n */\\n\\nconst InfoString = (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.type)({\\n  name: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)(),\\n  website: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)()),\\n  details: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)()),\\n  keybaseUsername: (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.optional)((0,superstruct__WEBPACK_IMPORTED_MODULE_14__.string)())\\n});\\n/**\\n * ValidatorInfo class\\n */\\n\\nclass ValidatorInfo {\\n  /**\\n   * validator public key\\n   */\\n\\n  /**\\n   * validator information\\n   */\\n\\n  /**\\n   * Construct a valid ValidatorInfo\\n   *\\n   * @param key validator public key\\n   * @param info validator information\\n   */\\n  constructor(key, info) {\\n    this.key = void 0;\\n    this.info = void 0;\\n    this.key = key;\\n    this.info = info;\\n  }\\n  /**\\n   * Deserialize ValidatorInfo from the config account data. Exactly two config\\n   * keys are required in the data.\\n   *\\n   * @param buffer config account data\\n   * @return null if info was not found\\n   */\\n\\n\\n  static fromConfigData(buffer) {\\n    let byteArray = [...buffer];\\n    const configKeyCount = decodeLength(byteArray);\\n    if (configKeyCount !== 2) return null;\\n    const configKeys = [];\\n\\n    for (let i = 0; i < 2; i++) {\\n      const publicKey = new PublicKey(byteArray.slice(0, PUBLIC_KEY_LENGTH));\\n      byteArray = byteArray.slice(PUBLIC_KEY_LENGTH);\\n      const isSigner = byteArray.slice(0, 1)[0] === 1;\\n      byteArray = byteArray.slice(1);\\n      configKeys.push({\\n        publicKey,\\n        isSigner\\n      });\\n    }\\n\\n    if (configKeys[0].publicKey.equals(VALIDATOR_INFO_KEY)) {\\n      if (configKeys[1].isSigner) {\\n        const rawInfo = rustString().decode(buffer__WEBPACK_IMPORTED_MODULE_0__.Buffer.from(byteArray));\\n        const info = JSON.parse(rawInfo);\\n        (0,superstruct__WEBPACK_IMPORTED_MODULE_14__.assert)(info, InfoString);\\n        return new ValidatorInfo(configKeys[1].publicKey, info);\\n      }\\n    }\\n\\n    return null;\\n  }\\n\\n}\\n\\nconst VOTE_PROGRAM_ID = new PublicKey('Vote111111111111111111111111111111111111111');\\n\\n/**\\n * See https://github.com/solana-labs/solana/blob/8a12ed029cfa38d4a45400916c2463fb82bbec8c/programs/vote_api/src/vote_state.rs#L68-L88\\n *\\n * @internal\\n */\\nconst VoteAccountLayout = _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([publicKey('nodePubkey'), publicKey('authorizedWithdrawer'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u8('commission'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.nu64(), // votes.length\\n_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.seq(_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.nu64('slot'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32('confirmationCount')]), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.offset(_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32(), -8), 'votes'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u8('rootSlotValid'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.nu64('rootSlot'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.nu64(), // authorizedVoters.length\\n_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.seq(_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.nu64('epoch'), publicKey('authorizedVoter')]), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.offset(_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32(), -8), 'authorizedVoters'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.seq(_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([publicKey('authorizedPubkey'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.nu64('epochOfLastAuthorizedSwitch'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.nu64('targetEpoch')]), 32, 'buf'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.nu64('idx'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u8('isEmpty')], 'priorVoters'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.nu64(), // epochCredits.length\\n_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.seq(_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.nu64('epoch'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.nu64('credits'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.nu64('prevCredits')]), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.offset(_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.u32(), -8), 'epochCredits'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.struct([_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.nu64('slot'), _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_7__.nu64('timestamp')], 'lastTimestamp')]);\\n\\n/**\\n * VoteAccount class\\n */\\nclass VoteAccount {\\n  /**\\n   * @internal\\n   */\\n  constructor(args) {\\n    this.nodePubkey = void 0;\\n    this.authorizedWithdrawer = void 0;\\n    this.commission = void 0;\\n    this.rootSlot = void 0;\\n    this.votes = void 0;\\n    this.authorizedVoters = void 0;\\n    this.priorVoters = void 0;\\n    this.epochCredits = void 0;\\n    this.lastTimestamp = void 0;\\n    this.nodePubkey = args.nodePubkey;\\n    this.authorizedWithdrawer = args.authorizedWithdrawer;\\n    this.commission = args.commission;\\n    this.rootSlot = args.rootSlot;\\n    this.votes = args.votes;\\n    this.authorizedVoters = args.authorizedVoters;\\n    this.priorVoters = args.priorVoters;\\n    this.epochCredits = args.epochCredits;\\n    this.lastTimestamp = args.lastTimestamp;\\n  }\\n  /**\\n   * Deserialize VoteAccount from the account data.\\n   *\\n   * @param buffer account data\\n   * @return VoteAccount\\n   */\\n\\n\\n  static fromAccountData(buffer) {\\n    const versionOffset = 4;\\n    const va = VoteAccountLayout.decode(toBuffer(buffer), versionOffset);\\n    let rootSlot = va.rootSlot;\\n\\n    if (!va.rootSlotValid) {\\n      rootSlot = null;\\n    }\\n\\n    return new VoteAccount({\\n      nodePubkey: new PublicKey(va.nodePubkey),\\n      authorizedWithdrawer: new PublicKey(va.authorizedWithdrawer),\\n      commission: va.commission,\\n      votes: va.votes,\\n      rootSlot,\\n      authorizedVoters: va.authorizedVoters.map(parseAuthorizedVoter),\\n      priorVoters: getPriorVoters(va.priorVoters),\\n      epochCredits: va.epochCredits,\\n      lastTimestamp: va.lastTimestamp\\n    });\\n  }\\n\\n}\\n\\nfunction parseAuthorizedVoter({\\n  authorizedVoter,\\n  epoch\\n}) {\\n  return {\\n    epoch,\\n    authorizedVoter: new PublicKey(authorizedVoter)\\n  };\\n}\\n\\nfunction parsePriorVoters({\\n  authorizedPubkey,\\n  epochOfLastAuthorizedSwitch,\\n  targetEpoch\\n}) {\\n  return {\\n    authorizedPubkey: new PublicKey(authorizedPubkey),\\n    epochOfLastAuthorizedSwitch,\\n    targetEpoch\\n  };\\n}\\n\\nfunction getPriorVoters({\\n  buf,\\n  idx,\\n  isEmpty\\n}) {\\n  if (isEmpty) {\\n    return [];\\n  }\\n\\n  return [...buf.slice(idx + 1).map(parsePriorVoters), ...buf.slice(0, idx).map(parsePriorVoters)];\\n}\\n\\nconst endpoint = {\\n  http: {\\n    devnet: 'http://api.devnet.solana.com',\\n    testnet: 'http://api.testnet.solana.com',\\n    'mainnet-beta': 'http://api.mainnet-beta.solana.com/'\\n  },\\n  https: {\\n    devnet: 'https://api.devnet.solana.com',\\n    testnet: 'https://api.testnet.solana.com',\\n    'mainnet-beta': 'https://api.mainnet-beta.solana.com/'\\n  }\\n};\\n\\n/**\\n * Retrieves the RPC API URL for the specified cluster\\n */\\nfunction clusterApiUrl(cluster, tls) {\\n  const key = tls === false ? 'http' : 'https';\\n\\n  if (!cluster) {\\n    return endpoint[key]['devnet'];\\n  }\\n\\n  const url = endpoint[key][cluster];\\n\\n  if (!url) {\\n    throw new Error(`Unknown ${key} cluster: ${cluster}`);\\n  }\\n\\n  return url;\\n}\\n\\n/**\\n * Send and confirm a raw transaction\\n *\\n * If `commitment` option is not specified, defaults to 'max' commitment.\\n *\\n * @param {Connection} connection\\n * @param {Buffer} rawTransaction\\n * @param {BlockheightBasedTransactionConfirmationStrategy} confirmationStrategy\\n * @param {ConfirmOptions} [options]\\n * @returns {Promise<TransactionSignature>}\\n */\\n\\n/**\\n * @deprecated Calling `sendAndConfirmRawTransaction()` without a `confirmationStrategy`\\n * is no longer supported and will be removed in a future version.\\n */\\n// eslint-disable-next-line no-redeclare\\n// eslint-disable-next-line no-redeclare\\nasync function sendAndConfirmRawTransaction(connection, rawTransaction, confirmationStrategyOrConfirmOptions, maybeConfirmOptions) {\\n  let confirmationStrategy;\\n  let options;\\n\\n  if (confirmationStrategyOrConfirmOptions && Object.prototype.hasOwnProperty.call(confirmationStrategyOrConfirmOptions, 'lastValidBlockHeight')) {\\n    confirmationStrategy = confirmationStrategyOrConfirmOptions;\\n    options = maybeConfirmOptions;\\n  } else if (confirmationStrategyOrConfirmOptions && Object.prototype.hasOwnProperty.call(confirmationStrategyOrConfirmOptions, 'nonceValue')) {\\n    confirmationStrategy = confirmationStrategyOrConfirmOptions;\\n    options = maybeConfirmOptions;\\n  } else {\\n    options = confirmationStrategyOrConfirmOptions;\\n  }\\n\\n  const sendOptions = options && {\\n    skipPreflight: options.skipPreflight,\\n    preflightCommitment: options.preflightCommitment || options.commitment,\\n    minContextSlot: options.minContextSlot\\n  };\\n  const signature = await connection.sendRawTransaction(rawTransaction, sendOptions);\\n  const commitment = options && options.commitment;\\n  const confirmationPromise = confirmationStrategy ? connection.confirmTransaction(confirmationStrategy, commitment) : connection.confirmTransaction(signature, commitment);\\n  const status = (await confirmationPromise).value;\\n\\n  if (status.err) {\\n    throw new Error(`Raw transaction ${signature} failed (${JSON.stringify(status)})`);\\n  }\\n\\n  return signature;\\n}\\n\\n/**\\n * There are 1-billion lamports in one SOL\\n */\\n\\nconst LAMPORTS_PER_SOL = 1000000000;\\n\\n\\n//# sourceMappingURL=index.browser.esm.js.map\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@solana/web3.js/lib/index.browser.esm.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/@solana/web3.js/node_modules/buffer/index.js\":\n/*!*******************************************************************!*\\\n  !*** ./node_modules/@solana/web3.js/node_modules/buffer/index.js ***!\n  \\*******************************************************************/\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\neval(\"/*!\\n * The buffer module from node.js, for the browser.\\n *\\n * @author   Feross Aboukhadijeh <https://feross.org>\\n * @license  MIT\\n */\\n/* eslint-disable no-proto */\\n\\n\\n\\nconst base64 = __webpack_require__(/*! base64-js */ \\\"./node_modules/base64-js/index.js\\\")\\nconst ieee754 = __webpack_require__(/*! ieee754 */ \\\"./node_modules/ieee754/index.js\\\")\\nconst customInspectSymbol =\\n  (typeof Symbol === 'function' && typeof Symbol['for'] === 'function') // eslint-disable-line dot-notation\\n    ? Symbol['for']('nodejs.util.inspect.custom') // eslint-disable-line dot-notation\\n    : null\\n\\nexports.Buffer = Buffer\\nexports.SlowBuffer = SlowBuffer\\nexports.INSPECT_MAX_BYTES = 50\\n\\nconst K_MAX_LENGTH = 0x7fffffff\\nexports.kMaxLength = K_MAX_LENGTH\\n\\n/**\\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\\n *   === true    Use Uint8Array implementation (fastest)\\n *   === false   Print warning and recommend using `buffer` v4.x which has an Object\\n *               implementation (most compatible, even IE6)\\n *\\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\\n * Opera 11.6+, iOS 4.2+.\\n *\\n * We report that the browser does not support typed arrays if the are not subclassable\\n * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`\\n * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support\\n * for __proto__ and has a buggy typed array implementation.\\n */\\nBuffer.TYPED_ARRAY_SUPPORT = typedArraySupport()\\n\\nif (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&\\n    typeof console.error === 'function') {\\n  console.error(\\n    'This browser lacks typed array (Uint8Array) support which is required by ' +\\n    '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'\\n  )\\n}\\n\\nfunction typedArraySupport () {\\n  // Can typed array instances can be augmented?\\n  try {\\n    const arr = new Uint8Array(1)\\n    const proto = { foo: function () { return 42 } }\\n    Object.setPrototypeOf(proto, Uint8Array.prototype)\\n    Object.setPrototypeOf(arr, proto)\\n    return arr.foo() === 42\\n  } catch (e) {\\n    return false\\n  }\\n}\\n\\nObject.defineProperty(Buffer.prototype, 'parent', {\\n  enumerable: true,\\n  get: function () {\\n    if (!Buffer.isBuffer(this)) return undefined\\n    return this.buffer\\n  }\\n})\\n\\nObject.defineProperty(Buffer.prototype, 'offset', {\\n  enumerable: true,\\n  get: function () {\\n    if (!Buffer.isBuffer(this)) return undefined\\n    return this.byteOffset\\n  }\\n})\\n\\nfunction createBuffer (length) {\\n  if (length > K_MAX_LENGTH) {\\n    throw new RangeError('The value \\\"' + length + '\\\" is invalid for option \\\"size\\\"')\\n  }\\n  // Return an augmented `Uint8Array` instance\\n  const buf = new Uint8Array(length)\\n  Object.setPrototypeOf(buf, Buffer.prototype)\\n  return buf\\n}\\n\\n/**\\n * The Buffer constructor returns instances of `Uint8Array` that have their\\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\\n * returns a single octet.\\n *\\n * The `Uint8Array` prototype remains unmodified.\\n */\\n\\nfunction Buffer (arg, encodingOrOffset, length) {\\n  // Common case.\\n  if (typeof arg === 'number') {\\n    if (typeof encodingOrOffset === 'string') {\\n      throw new TypeError(\\n        'The \\\"string\\\" argument must be of type string. Received type number'\\n      )\\n    }\\n    return allocUnsafe(arg)\\n  }\\n  return from(arg, encodingOrOffset, length)\\n}\\n\\nBuffer.poolSize = 8192 // not used by this implementation\\n\\nfunction from (value, encodingOrOffset, length) {\\n  if (typeof value === 'string') {\\n    return fromString(value, encodingOrOffset)\\n  }\\n\\n  if (ArrayBuffer.isView(value)) {\\n    return fromArrayView(value)\\n  }\\n\\n  if (value == null) {\\n    throw new TypeError(\\n      'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\\n      'or Array-like Object. Received type ' + (typeof value)\\n    )\\n  }\\n\\n  if (isInstance(value, ArrayBuffer) ||\\n      (value && isInstance(value.buffer, ArrayBuffer))) {\\n    return fromArrayBuffer(value, encodingOrOffset, length)\\n  }\\n\\n  if (typeof SharedArrayBuffer !== 'undefined' &&\\n      (isInstance(value, SharedArrayBuffer) ||\\n      (value && isInstance(value.buffer, SharedArrayBuffer)))) {\\n    return fromArrayBuffer(value, encodingOrOffset, length)\\n  }\\n\\n  if (typeof value === 'number') {\\n    throw new TypeError(\\n      'The \\\"value\\\" argument must not be of type number. Received type number'\\n    )\\n  }\\n\\n  const valueOf = value.valueOf && value.valueOf()\\n  if (valueOf != null && valueOf !== value) {\\n    return Buffer.from(valueOf, encodingOrOffset, length)\\n  }\\n\\n  const b = fromObject(value)\\n  if (b) return b\\n\\n  if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&\\n      typeof value[Symbol.toPrimitive] === 'function') {\\n    return Buffer.from(value[Symbol.toPrimitive]('string'), encodingOrOffset, length)\\n  }\\n\\n  throw new TypeError(\\n    'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\\n    'or Array-like Object. Received type ' + (typeof value)\\n  )\\n}\\n\\n/**\\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\\n * if value is a number.\\n * Buffer.from(str[, encoding])\\n * Buffer.from(array)\\n * Buffer.from(buffer)\\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\\n **/\\nBuffer.from = function (value, encodingOrOffset, length) {\\n  return from(value, encodingOrOffset, length)\\n}\\n\\n// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:\\n// https://github.com/feross/buffer/pull/148\\nObject.setPrototypeOf(Buffer.prototype, Uint8Array.prototype)\\nObject.setPrototypeOf(Buffer, Uint8Array)\\n\\nfunction assertSize (size) {\\n  if (typeof size !== 'number') {\\n    throw new TypeError('\\\"size\\\" argument must be of type number')\\n  } else if (size < 0) {\\n    throw new RangeError('The value \\\"' + size + '\\\" is invalid for option \\\"size\\\"')\\n  }\\n}\\n\\nfunction alloc (size, fill, encoding) {\\n  assertSize(size)\\n  if (size <= 0) {\\n    return createBuffer(size)\\n  }\\n  if (fill !== undefined) {\\n    // Only pay attention to encoding if it's a string. This\\n    // prevents accidentally sending in a number that would\\n    // be interpreted as a start offset.\\n    return typeof encoding === 'string'\\n      ? createBuffer(size).fill(fill, encoding)\\n      : createBuffer(size).fill(fill)\\n  }\\n  return createBuffer(size)\\n}\\n\\n/**\\n * Creates a new filled Buffer instance.\\n * alloc(size[, fill[, encoding]])\\n **/\\nBuffer.alloc = function (size, fill, encoding) {\\n  return alloc(size, fill, encoding)\\n}\\n\\nfunction allocUnsafe (size) {\\n  assertSize(size)\\n  return createBuffer(size < 0 ? 0 : checked(size) | 0)\\n}\\n\\n/**\\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\\n * */\\nBuffer.allocUnsafe = function (size) {\\n  return allocUnsafe(size)\\n}\\n/**\\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\\n */\\nBuffer.allocUnsafeSlow = function (size) {\\n  return allocUnsafe(size)\\n}\\n\\nfunction fromString (string, encoding) {\\n  if (typeof encoding !== 'string' || encoding === '') {\\n    encoding = 'utf8'\\n  }\\n\\n  if (!Buffer.isEncoding(encoding)) {\\n    throw new TypeError('Unknown encoding: ' + encoding)\\n  }\\n\\n  const length = byteLength(string, encoding) | 0\\n  let buf = createBuffer(length)\\n\\n  const actual = buf.write(string, encoding)\\n\\n  if (actual !== length) {\\n    // Writing a hex string, for example, that contains invalid characters will\\n    // cause everything after the first invalid character to be ignored. (e.g.\\n    // 'abxxcd' will be treated as 'ab')\\n    buf = buf.slice(0, actual)\\n  }\\n\\n  return buf\\n}\\n\\nfunction fromArrayLike (array) {\\n  const length = array.length < 0 ? 0 : checked(array.length) | 0\\n  const buf = createBuffer(length)\\n  for (let i = 0; i < length; i += 1) {\\n    buf[i] = array[i] & 255\\n  }\\n  return buf\\n}\\n\\nfunction fromArrayView (arrayView) {\\n  if (isInstance(arrayView, Uint8Array)) {\\n    const copy = new Uint8Array(arrayView)\\n    return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength)\\n  }\\n  return fromArrayLike(arrayView)\\n}\\n\\nfunction fromArrayBuffer (array, byteOffset, length) {\\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\\n    throw new RangeError('\\\"offset\\\" is outside of buffer bounds')\\n  }\\n\\n  if (array.byteLength < byteOffset + (length || 0)) {\\n    throw new RangeError('\\\"length\\\" is outside of buffer bounds')\\n  }\\n\\n  let buf\\n  if (byteOffset === undefined && length === undefined) {\\n    buf = new Uint8Array(array)\\n  } else if (length === undefined) {\\n    buf = new Uint8Array(array, byteOffset)\\n  } else {\\n    buf = new Uint8Array(array, byteOffset, length)\\n  }\\n\\n  // Return an augmented `Uint8Array` instance\\n  Object.setPrototypeOf(buf, Buffer.prototype)\\n\\n  return buf\\n}\\n\\nfunction fromObject (obj) {\\n  if (Buffer.isBuffer(obj)) {\\n    const len = checked(obj.length) | 0\\n    const buf = createBuffer(len)\\n\\n    if (buf.length === 0) {\\n      return buf\\n    }\\n\\n    obj.copy(buf, 0, 0, len)\\n    return buf\\n  }\\n\\n  if (obj.length !== undefined) {\\n    if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {\\n      return createBuffer(0)\\n    }\\n    return fromArrayLike(obj)\\n  }\\n\\n  if (obj.type === 'Buffer' && Array.isArray(obj.data)) {\\n    return fromArrayLike(obj.data)\\n  }\\n}\\n\\nfunction checked (length) {\\n  // Note: cannot use `length < K_MAX_LENGTH` here because that fails when\\n  // length is NaN (which is otherwise coerced to zero.)\\n  if (length >= K_MAX_LENGTH) {\\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\\n                         'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')\\n  }\\n  return length | 0\\n}\\n\\nfunction SlowBuffer (length) {\\n  if (+length != length) { // eslint-disable-line eqeqeq\\n    length = 0\\n  }\\n  return Buffer.alloc(+length)\\n}\\n\\nBuffer.isBuffer = function isBuffer (b) {\\n  return b != null && b._isBuffer === true &&\\n    b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false\\n}\\n\\nBuffer.compare = function compare (a, b) {\\n  if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)\\n  if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)\\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\\n    throw new TypeError(\\n      'The \\\"buf1\\\", \\\"buf2\\\" arguments must be one of type Buffer or Uint8Array'\\n    )\\n  }\\n\\n  if (a === b) return 0\\n\\n  let x = a.length\\n  let y = b.length\\n\\n  for (let i = 0, len = Math.min(x, y); i < len; ++i) {\\n    if (a[i] !== b[i]) {\\n      x = a[i]\\n      y = b[i]\\n      break\\n    }\\n  }\\n\\n  if (x < y) return -1\\n  if (y < x) return 1\\n  return 0\\n}\\n\\nBuffer.isEncoding = function isEncoding (encoding) {\\n  switch (String(encoding).toLowerCase()) {\\n    case 'hex':\\n    case 'utf8':\\n    case 'utf-8':\\n    case 'ascii':\\n    case 'latin1':\\n    case 'binary':\\n    case 'base64':\\n    case 'ucs2':\\n    case 'ucs-2':\\n    case 'utf16le':\\n    case 'utf-16le':\\n      return true\\n    default:\\n      return false\\n  }\\n}\\n\\nBuffer.concat = function concat (list, length) {\\n  if (!Array.isArray(list)) {\\n    throw new TypeError('\\\"list\\\" argument must be an Array of Buffers')\\n  }\\n\\n  if (list.length === 0) {\\n    return Buffer.alloc(0)\\n  }\\n\\n  let i\\n  if (length === undefined) {\\n    length = 0\\n    for (i = 0; i < list.length; ++i) {\\n      length += list[i].length\\n    }\\n  }\\n\\n  const buffer = Buffer.allocUnsafe(length)\\n  let pos = 0\\n  for (i = 0; i < list.length; ++i) {\\n    let buf = list[i]\\n    if (isInstance(buf, Uint8Array)) {\\n      if (pos + buf.length > buffer.length) {\\n        if (!Buffer.isBuffer(buf)) buf = Buffer.from(buf)\\n        buf.copy(buffer, pos)\\n      } else {\\n        Uint8Array.prototype.set.call(\\n          buffer,\\n          buf,\\n          pos\\n        )\\n      }\\n    } else if (!Buffer.isBuffer(buf)) {\\n      throw new TypeError('\\\"list\\\" argument must be an Array of Buffers')\\n    } else {\\n      buf.copy(buffer, pos)\\n    }\\n    pos += buf.length\\n  }\\n  return buffer\\n}\\n\\nfunction byteLength (string, encoding) {\\n  if (Buffer.isBuffer(string)) {\\n    return string.length\\n  }\\n  if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {\\n    return string.byteLength\\n  }\\n  if (typeof string !== 'string') {\\n    throw new TypeError(\\n      'The \\\"string\\\" argument must be one of type string, Buffer, or ArrayBuffer. ' +\\n      'Received type ' + typeof string\\n    )\\n  }\\n\\n  const len = string.length\\n  const mustMatch = (arguments.length > 2 && arguments[2] === true)\\n  if (!mustMatch && len === 0) return 0\\n\\n  // Use a for loop to avoid recursion\\n  let loweredCase = false\\n  for (;;) {\\n    switch (encoding) {\\n      case 'ascii':\\n      case 'latin1':\\n      case 'binary':\\n        return len\\n      case 'utf8':\\n      case 'utf-8':\\n        return utf8ToBytes(string).length\\n      case 'ucs2':\\n      case 'ucs-2':\\n      case 'utf16le':\\n      case 'utf-16le':\\n        return len * 2\\n      case 'hex':\\n        return len >>> 1\\n      case 'base64':\\n        return base64ToBytes(string).length\\n      default:\\n        if (loweredCase) {\\n          return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8\\n        }\\n        encoding = ('' + encoding).toLowerCase()\\n        loweredCase = true\\n    }\\n  }\\n}\\nBuffer.byteLength = byteLength\\n\\nfunction slowToString (encoding, start, end) {\\n  let loweredCase = false\\n\\n  // No need to verify that \\\"this.length <= MAX_UINT32\\\" since it's a read-only\\n  // property of a typed array.\\n\\n  // This behaves neither like String nor Uint8Array in that we set start/end\\n  // to their upper/lower bounds if the value passed is out of range.\\n  // undefined is handled specially as per ECMA-262 6th Edition,\\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\\n  if (start === undefined || start < 0) {\\n    start = 0\\n  }\\n  // Return early if start > this.length. Done here to prevent potential uint32\\n  // coercion fail below.\\n  if (start > this.length) {\\n    return ''\\n  }\\n\\n  if (end === undefined || end > this.length) {\\n    end = this.length\\n  }\\n\\n  if (end <= 0) {\\n    return ''\\n  }\\n\\n  // Force coercion to uint32. This will also coerce falsey/NaN values to 0.\\n  end >>>= 0\\n  start >>>= 0\\n\\n  if (end <= start) {\\n    return ''\\n  }\\n\\n  if (!encoding) encoding = 'utf8'\\n\\n  while (true) {\\n    switch (encoding) {\\n      case 'hex':\\n        return hexSlice(this, start, end)\\n\\n      case 'utf8':\\n      case 'utf-8':\\n        return utf8Slice(this, start, end)\\n\\n      case 'ascii':\\n        return asciiSlice(this, start, end)\\n\\n      case 'latin1':\\n      case 'binary':\\n        return latin1Slice(this, start, end)\\n\\n      case 'base64':\\n        return base64Slice(this, start, end)\\n\\n      case 'ucs2':\\n      case 'ucs-2':\\n      case 'utf16le':\\n      case 'utf-16le':\\n        return utf16leSlice(this, start, end)\\n\\n      default:\\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\\n        encoding = (encoding + '').toLowerCase()\\n        loweredCase = true\\n    }\\n  }\\n}\\n\\n// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)\\n// to detect a Buffer instance. It's not possible to use `instanceof Buffer`\\n// reliably in a browserify context because there could be multiple different\\n// copies of the 'buffer' package in use. This method works even for Buffer\\n// instances that were created from another copy of the `buffer` package.\\n// See: https://github.com/feross/buffer/issues/154\\nBuffer.prototype._isBuffer = true\\n\\nfunction swap (b, n, m) {\\n  const i = b[n]\\n  b[n] = b[m]\\n  b[m] = i\\n}\\n\\nBuffer.prototype.swap16 = function swap16 () {\\n  const len = this.length\\n  if (len % 2 !== 0) {\\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\\n  }\\n  for (let i = 0; i < len; i += 2) {\\n    swap(this, i, i + 1)\\n  }\\n  return this\\n}\\n\\nBuffer.prototype.swap32 = function swap32 () {\\n  const len = this.length\\n  if (len % 4 !== 0) {\\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\\n  }\\n  for (let i = 0; i < len; i += 4) {\\n    swap(this, i, i + 3)\\n    swap(this, i + 1, i + 2)\\n  }\\n  return this\\n}\\n\\nBuffer.prototype.swap64 = function swap64 () {\\n  const len = this.length\\n  if (len % 8 !== 0) {\\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\\n  }\\n  for (let i = 0; i < len; i += 8) {\\n    swap(this, i, i + 7)\\n    swap(this, i + 1, i + 6)\\n    swap(this, i + 2, i + 5)\\n    swap(this, i + 3, i + 4)\\n  }\\n  return this\\n}\\n\\nBuffer.prototype.toString = function toString () {\\n  const length = this.length\\n  if (length === 0) return ''\\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\\n  return slowToString.apply(this, arguments)\\n}\\n\\nBuffer.prototype.toLocaleString = Buffer.prototype.toString\\n\\nBuffer.prototype.equals = function equals (b) {\\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\\n  if (this === b) return true\\n  return Buffer.compare(this, b) === 0\\n}\\n\\nBuffer.prototype.inspect = function inspect () {\\n  let str = ''\\n  const max = exports.INSPECT_MAX_BYTES\\n  str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()\\n  if (this.length > max) str += ' ... '\\n  return '<Buffer ' + str + '>'\\n}\\nif (customInspectSymbol) {\\n  Buffer.prototype[customInspectSymbol] = Buffer.prototype.inspect\\n}\\n\\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\\n  if (isInstance(target, Uint8Array)) {\\n    target = Buffer.from(target, target.offset, target.byteLength)\\n  }\\n  if (!Buffer.isBuffer(target)) {\\n    throw new TypeError(\\n      'The \\\"target\\\" argument must be one of type Buffer or Uint8Array. ' +\\n      'Received type ' + (typeof target)\\n    )\\n  }\\n\\n  if (start === undefined) {\\n    start = 0\\n  }\\n  if (end === undefined) {\\n    end = target ? target.length : 0\\n  }\\n  if (thisStart === undefined) {\\n    thisStart = 0\\n  }\\n  if (thisEnd === undefined) {\\n    thisEnd = this.length\\n  }\\n\\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\\n    throw new RangeError('out of range index')\\n  }\\n\\n  if (thisStart >= thisEnd && start >= end) {\\n    return 0\\n  }\\n  if (thisStart >= thisEnd) {\\n    return -1\\n  }\\n  if (start >= end) {\\n    return 1\\n  }\\n\\n  start >>>= 0\\n  end >>>= 0\\n  thisStart >>>= 0\\n  thisEnd >>>= 0\\n\\n  if (this === target) return 0\\n\\n  let x = thisEnd - thisStart\\n  let y = end - start\\n  const len = Math.min(x, y)\\n\\n  const thisCopy = this.slice(thisStart, thisEnd)\\n  const targetCopy = target.slice(start, end)\\n\\n  for (let i = 0; i < len; ++i) {\\n    if (thisCopy[i] !== targetCopy[i]) {\\n      x = thisCopy[i]\\n      y = targetCopy[i]\\n      break\\n    }\\n  }\\n\\n  if (x < y) return -1\\n  if (y < x) return 1\\n  return 0\\n}\\n\\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\\n//\\n// Arguments:\\n// - buffer - a Buffer to search\\n// - val - a string, Buffer, or number\\n// - byteOffset - an index into `buffer`; will be clamped to an int32\\n// - encoding - an optional encoding, relevant is val is a string\\n// - dir - true for indexOf, false for lastIndexOf\\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\\n  // Empty buffer means no match\\n  if (buffer.length === 0) return -1\\n\\n  // Normalize byteOffset\\n  if (typeof byteOffset === 'string') {\\n    encoding = byteOffset\\n    byteOffset = 0\\n  } else if (byteOffset > 0x7fffffff) {\\n    byteOffset = 0x7fffffff\\n  } else if (byteOffset < -0x80000000) {\\n    byteOffset = -0x80000000\\n  }\\n  byteOffset = +byteOffset // Coerce to Number.\\n  if (numberIsNaN(byteOffset)) {\\n    // byteOffset: it it's undefined, null, NaN, \\\"foo\\\", etc, search whole buffer\\n    byteOffset = dir ? 0 : (buffer.length - 1)\\n  }\\n\\n  // Normalize byteOffset: negative offsets start from the end of the buffer\\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\\n  if (byteOffset >= buffer.length) {\\n    if (dir) return -1\\n    else byteOffset = buffer.length - 1\\n  } else if (byteOffset < 0) {\\n    if (dir) byteOffset = 0\\n    else return -1\\n  }\\n\\n  // Normalize val\\n  if (typeof val === 'string') {\\n    val = Buffer.from(val, encoding)\\n  }\\n\\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\\n  if (Buffer.isBuffer(val)) {\\n    // Special case: looking for empty string/buffer always fails\\n    if (val.length === 0) {\\n      return -1\\n    }\\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\\n  } else if (typeof val === 'number') {\\n    val = val & 0xFF // Search for a byte value [0-255]\\n    if (typeof Uint8Array.prototype.indexOf === 'function') {\\n      if (dir) {\\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\\n      } else {\\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\\n      }\\n    }\\n    return arrayIndexOf(buffer, [val], byteOffset, encoding, dir)\\n  }\\n\\n  throw new TypeError('val must be string, number or Buffer')\\n}\\n\\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\\n  let indexSize = 1\\n  let arrLength = arr.length\\n  let valLength = val.length\\n\\n  if (encoding !== undefined) {\\n    encoding = String(encoding).toLowerCase()\\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\\n        encoding === 'utf16le' || encoding === 'utf-16le') {\\n      if (arr.length < 2 || val.length < 2) {\\n        return -1\\n      }\\n      indexSize = 2\\n      arrLength /= 2\\n      valLength /= 2\\n      byteOffset /= 2\\n    }\\n  }\\n\\n  function read (buf, i) {\\n    if (indexSize === 1) {\\n      return buf[i]\\n    } else {\\n      return buf.readUInt16BE(i * indexSize)\\n    }\\n  }\\n\\n  let i\\n  if (dir) {\\n    let foundIndex = -1\\n    for (i = byteOffset; i < arrLength; i++) {\\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\\n        if (foundIndex === -1) foundIndex = i\\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\\n      } else {\\n        if (foundIndex !== -1) i -= i - foundIndex\\n        foundIndex = -1\\n      }\\n    }\\n  } else {\\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\\n    for (i = byteOffset; i >= 0; i--) {\\n      let found = true\\n      for (let j = 0; j < valLength; j++) {\\n        if (read(arr, i + j) !== read(val, j)) {\\n          found = false\\n          break\\n        }\\n      }\\n      if (found) return i\\n    }\\n  }\\n\\n  return -1\\n}\\n\\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\\n  return this.indexOf(val, byteOffset, encoding) !== -1\\n}\\n\\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\\n}\\n\\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\\n}\\n\\nfunction hexWrite (buf, string, offset, length) {\\n  offset = Number(offset) || 0\\n  const remaining = buf.length - offset\\n  if (!length) {\\n    length = remaining\\n  } else {\\n    length = Number(length)\\n    if (length > remaining) {\\n      length = remaining\\n    }\\n  }\\n\\n  const strLen = string.length\\n\\n  if (length > strLen / 2) {\\n    length = strLen / 2\\n  }\\n  let i\\n  for (i = 0; i < length; ++i) {\\n    const parsed = parseInt(string.substr(i * 2, 2), 16)\\n    if (numberIsNaN(parsed)) return i\\n    buf[offset + i] = parsed\\n  }\\n  return i\\n}\\n\\nfunction utf8Write (buf, string, offset, length) {\\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\\n}\\n\\nfunction asciiWrite (buf, string, offset, length) {\\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\\n}\\n\\nfunction base64Write (buf, string, offset, length) {\\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\\n}\\n\\nfunction ucs2Write (buf, string, offset, length) {\\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\\n}\\n\\nBuffer.prototype.write = function write (string, offset, length, encoding) {\\n  // Buffer#write(string)\\n  if (offset === undefined) {\\n    encoding = 'utf8'\\n    length = this.length\\n    offset = 0\\n  // Buffer#write(string, encoding)\\n  } else if (length === undefined && typeof offset === 'string') {\\n    encoding = offset\\n    length = this.length\\n    offset = 0\\n  // Buffer#write(string, offset[, length][, encoding])\\n  } else if (isFinite(offset)) {\\n    offset = offset >>> 0\\n    if (isFinite(length)) {\\n      length = length >>> 0\\n      if (encoding === undefined) encoding = 'utf8'\\n    } else {\\n      encoding = length\\n      length = undefined\\n    }\\n  } else {\\n    throw new Error(\\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\\n    )\\n  }\\n\\n  const remaining = this.length - offset\\n  if (length === undefined || length > remaining) length = remaining\\n\\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\\n    throw new RangeError('Attempt to write outside buffer bounds')\\n  }\\n\\n  if (!encoding) encoding = 'utf8'\\n\\n  let loweredCase = false\\n  for (;;) {\\n    switch (encoding) {\\n      case 'hex':\\n        return hexWrite(this, string, offset, length)\\n\\n      case 'utf8':\\n      case 'utf-8':\\n        return utf8Write(this, string, offset, length)\\n\\n      case 'ascii':\\n      case 'latin1':\\n      case 'binary':\\n        return asciiWrite(this, string, offset, length)\\n\\n      case 'base64':\\n        // Warning: maxLength not taken into account in base64Write\\n        return base64Write(this, string, offset, length)\\n\\n      case 'ucs2':\\n      case 'ucs-2':\\n      case 'utf16le':\\n      case 'utf-16le':\\n        return ucs2Write(this, string, offset, length)\\n\\n      default:\\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\\n        encoding = ('' + encoding).toLowerCase()\\n        loweredCase = true\\n    }\\n  }\\n}\\n\\nBuffer.prototype.toJSON = function toJSON () {\\n  return {\\n    type: 'Buffer',\\n    data: Array.prototype.slice.call(this._arr || this, 0)\\n  }\\n}\\n\\nfunction base64Slice (buf, start, end) {\\n  if (start === 0 && end === buf.length) {\\n    return base64.fromByteArray(buf)\\n  } else {\\n    return base64.fromByteArray(buf.slice(start, end))\\n  }\\n}\\n\\nfunction utf8Slice (buf, start, end) {\\n  end = Math.min(buf.length, end)\\n  const res = []\\n\\n  let i = start\\n  while (i < end) {\\n    const firstByte = buf[i]\\n    let codePoint = null\\n    let bytesPerSequence = (firstByte > 0xEF)\\n      ? 4\\n      : (firstByte > 0xDF)\\n          ? 3\\n          : (firstByte > 0xBF)\\n              ? 2\\n              : 1\\n\\n    if (i + bytesPerSequence <= end) {\\n      let secondByte, thirdByte, fourthByte, tempCodePoint\\n\\n      switch (bytesPerSequence) {\\n        case 1:\\n          if (firstByte < 0x80) {\\n            codePoint = firstByte\\n          }\\n          break\\n        case 2:\\n          secondByte = buf[i + 1]\\n          if ((secondByte & 0xC0) === 0x80) {\\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\\n            if (tempCodePoint > 0x7F) {\\n              codePoint = tempCodePoint\\n            }\\n          }\\n          break\\n        case 3:\\n          secondByte = buf[i + 1]\\n          thirdByte = buf[i + 2]\\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\\n              codePoint = tempCodePoint\\n            }\\n          }\\n          break\\n        case 4:\\n          secondByte = buf[i + 1]\\n          thirdByte = buf[i + 2]\\n          fourthByte = buf[i + 3]\\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\\n              codePoint = tempCodePoint\\n            }\\n          }\\n      }\\n    }\\n\\n    if (codePoint === null) {\\n      // we did not generate a valid codePoint so insert a\\n      // replacement char (U+FFFD) and advance only 1 byte\\n      codePoint = 0xFFFD\\n      bytesPerSequence = 1\\n    } else if (codePoint > 0xFFFF) {\\n      // encode to utf16 (surrogate pair dance)\\n      codePoint -= 0x10000\\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\\n      codePoint = 0xDC00 | codePoint & 0x3FF\\n    }\\n\\n    res.push(codePoint)\\n    i += bytesPerSequence\\n  }\\n\\n  return decodeCodePointsArray(res)\\n}\\n\\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\\n// the lowest limit is Chrome, with 0x10000 args.\\n// We go 1 magnitude less, for safety\\nconst MAX_ARGUMENTS_LENGTH = 0x1000\\n\\nfunction decodeCodePointsArray (codePoints) {\\n  const len = codePoints.length\\n  if (len <= MAX_ARGUMENTS_LENGTH) {\\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\\n  }\\n\\n  // Decode in chunks to avoid \\\"call stack size exceeded\\\".\\n  let res = ''\\n  let i = 0\\n  while (i < len) {\\n    res += String.fromCharCode.apply(\\n      String,\\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\\n    )\\n  }\\n  return res\\n}\\n\\nfunction asciiSlice (buf, start, end) {\\n  let ret = ''\\n  end = Math.min(buf.length, end)\\n\\n  for (let i = start; i < end; ++i) {\\n    ret += String.fromCharCode(buf[i] & 0x7F)\\n  }\\n  return ret\\n}\\n\\nfunction latin1Slice (buf, start, end) {\\n  let ret = ''\\n  end = Math.min(buf.length, end)\\n\\n  for (let i = start; i < end; ++i) {\\n    ret += String.fromCharCode(buf[i])\\n  }\\n  return ret\\n}\\n\\nfunction hexSlice (buf, start, end) {\\n  const len = buf.length\\n\\n  if (!start || start < 0) start = 0\\n  if (!end || end < 0 || end > len) end = len\\n\\n  let out = ''\\n  for (let i = start; i < end; ++i) {\\n    out += hexSliceLookupTable[buf[i]]\\n  }\\n  return out\\n}\\n\\nfunction utf16leSlice (buf, start, end) {\\n  const bytes = buf.slice(start, end)\\n  let res = ''\\n  // If bytes.length is odd, the last 8 bits must be ignored (same as node.js)\\n  for (let i = 0; i < bytes.length - 1; i += 2) {\\n    res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256))\\n  }\\n  return res\\n}\\n\\nBuffer.prototype.slice = function slice (start, end) {\\n  const len = this.length\\n  start = ~~start\\n  end = end === undefined ? len : ~~end\\n\\n  if (start < 0) {\\n    start += len\\n    if (start < 0) start = 0\\n  } else if (start > len) {\\n    start = len\\n  }\\n\\n  if (end < 0) {\\n    end += len\\n    if (end < 0) end = 0\\n  } else if (end > len) {\\n    end = len\\n  }\\n\\n  if (end < start) end = start\\n\\n  const newBuf = this.subarray(start, end)\\n  // Return an augmented `Uint8Array` instance\\n  Object.setPrototypeOf(newBuf, Buffer.prototype)\\n\\n  return newBuf\\n}\\n\\n/*\\n * Need to make sure that buffer isn't trying to write out of bounds.\\n */\\nfunction checkOffset (offset, ext, length) {\\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\\n}\\n\\nBuffer.prototype.readUintLE =\\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\\n  offset = offset >>> 0\\n  byteLength = byteLength >>> 0\\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\\n\\n  let val = this[offset]\\n  let mul = 1\\n  let i = 0\\n  while (++i < byteLength && (mul *= 0x100)) {\\n    val += this[offset + i] * mul\\n  }\\n\\n  return val\\n}\\n\\nBuffer.prototype.readUintBE =\\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\\n  offset = offset >>> 0\\n  byteLength = byteLength >>> 0\\n  if (!noAssert) {\\n    checkOffset(offset, byteLength, this.length)\\n  }\\n\\n  let val = this[offset + --byteLength]\\n  let mul = 1\\n  while (byteLength > 0 && (mul *= 0x100)) {\\n    val += this[offset + --byteLength] * mul\\n  }\\n\\n  return val\\n}\\n\\nBuffer.prototype.readUint8 =\\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\\n  offset = offset >>> 0\\n  if (!noAssert) checkOffset(offset, 1, this.length)\\n  return this[offset]\\n}\\n\\nBuffer.prototype.readUint16LE =\\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\\n  offset = offset >>> 0\\n  if (!noAssert) checkOffset(offset, 2, this.length)\\n  return this[offset] | (this[offset + 1] << 8)\\n}\\n\\nBuffer.prototype.readUint16BE =\\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\\n  offset = offset >>> 0\\n  if (!noAssert) checkOffset(offset, 2, this.length)\\n  return (this[offset] << 8) | this[offset + 1]\\n}\\n\\nBuffer.prototype.readUint32LE =\\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\\n  offset = offset >>> 0\\n  if (!noAssert) checkOffset(offset, 4, this.length)\\n\\n  return ((this[offset]) |\\n      (this[offset + 1] << 8) |\\n      (this[offset + 2] << 16)) +\\n      (this[offset + 3] * 0x1000000)\\n}\\n\\nBuffer.prototype.readUint32BE =\\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\\n  offset = offset >>> 0\\n  if (!noAssert) checkOffset(offset, 4, this.length)\\n\\n  return (this[offset] * 0x1000000) +\\n    ((this[offset + 1] << 16) |\\n    (this[offset + 2] << 8) |\\n    this[offset + 3])\\n}\\n\\nBuffer.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE (offset) {\\n  offset = offset >>> 0\\n  validateNumber(offset, 'offset')\\n  const first = this[offset]\\n  const last = this[offset + 7]\\n  if (first === undefined || last === undefined) {\\n    boundsError(offset, this.length - 8)\\n  }\\n\\n  const lo = first +\\n    this[++offset] * 2 ** 8 +\\n    this[++offset] * 2 ** 16 +\\n    this[++offset] * 2 ** 24\\n\\n  const hi = this[++offset] +\\n    this[++offset] * 2 ** 8 +\\n    this[++offset] * 2 ** 16 +\\n    last * 2 ** 24\\n\\n  return BigInt(lo) + (BigInt(hi) << BigInt(32))\\n})\\n\\nBuffer.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE (offset) {\\n  offset = offset >>> 0\\n  validateNumber(offset, 'offset')\\n  const first = this[offset]\\n  const last = this[offset + 7]\\n  if (first === undefined || last === undefined) {\\n    boundsError(offset, this.length - 8)\\n  }\\n\\n  const hi = first * 2 ** 24 +\\n    this[++offset] * 2 ** 16 +\\n    this[++offset] * 2 ** 8 +\\n    this[++offset]\\n\\n  const lo = this[++offset] * 2 ** 24 +\\n    this[++offset] * 2 ** 16 +\\n    this[++offset] * 2 ** 8 +\\n    last\\n\\n  return (BigInt(hi) << BigInt(32)) + BigInt(lo)\\n})\\n\\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\\n  offset = offset >>> 0\\n  byteLength = byteLength >>> 0\\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\\n\\n  let val = this[offset]\\n  let mul = 1\\n  let i = 0\\n  while (++i < byteLength && (mul *= 0x100)) {\\n    val += this[offset + i] * mul\\n  }\\n  mul *= 0x80\\n\\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\\n\\n  return val\\n}\\n\\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\\n  offset = offset >>> 0\\n  byteLength = byteLength >>> 0\\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\\n\\n  let i = byteLength\\n  let mul = 1\\n  let val = this[offset + --i]\\n  while (i > 0 && (mul *= 0x100)) {\\n    val += this[offset + --i] * mul\\n  }\\n  mul *= 0x80\\n\\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\\n\\n  return val\\n}\\n\\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\\n  offset = offset >>> 0\\n  if (!noAssert) checkOffset(offset, 1, this.length)\\n  if (!(this[offset] & 0x80)) return (this[offset])\\n  return ((0xff - this[offset] + 1) * -1)\\n}\\n\\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\\n  offset = offset >>> 0\\n  if (!noAssert) checkOffset(offset, 2, this.length)\\n  const val = this[offset] | (this[offset + 1] << 8)\\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\\n}\\n\\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\\n  offset = offset >>> 0\\n  if (!noAssert) checkOffset(offset, 2, this.length)\\n  const val = this[offset + 1] | (this[offset] << 8)\\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\\n}\\n\\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\\n  offset = offset >>> 0\\n  if (!noAssert) checkOffset(offset, 4, this.length)\\n\\n  return (this[offset]) |\\n    (this[offset + 1] << 8) |\\n    (this[offset + 2] << 16) |\\n    (this[offset + 3] << 24)\\n}\\n\\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\\n  offset = offset >>> 0\\n  if (!noAssert) checkOffset(offset, 4, this.length)\\n\\n  return (this[offset] << 24) |\\n    (this[offset + 1] << 16) |\\n    (this[offset + 2] << 8) |\\n    (this[offset + 3])\\n}\\n\\nBuffer.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE (offset) {\\n  offset = offset >>> 0\\n  validateNumber(offset, 'offset')\\n  const first = this[offset]\\n  const last = this[offset + 7]\\n  if (first === undefined || last === undefined) {\\n    boundsError(offset, this.length - 8)\\n  }\\n\\n  const val = this[offset + 4] +\\n    this[offset + 5] * 2 ** 8 +\\n    this[offset + 6] * 2 ** 16 +\\n    (last << 24) // Overflow\\n\\n  return (BigInt(val) << BigInt(32)) +\\n    BigInt(first +\\n    this[++offset] * 2 ** 8 +\\n    this[++offset] * 2 ** 16 +\\n    this[++offset] * 2 ** 24)\\n})\\n\\nBuffer.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE (offset) {\\n  offset = offset >>> 0\\n  validateNumber(offset, 'offset')\\n  const first = this[offset]\\n  const last = this[offset + 7]\\n  if (first === undefined || last === undefined) {\\n    boundsError(offset, this.length - 8)\\n  }\\n\\n  const val = (first << 24) + // Overflow\\n    this[++offset] * 2 ** 16 +\\n    this[++offset] * 2 ** 8 +\\n    this[++offset]\\n\\n  return (BigInt(val) << BigInt(32)) +\\n    BigInt(this[++offset] * 2 ** 24 +\\n    this[++offset] * 2 ** 16 +\\n    this[++offset] * 2 ** 8 +\\n    last)\\n})\\n\\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\\n  offset = offset >>> 0\\n  if (!noAssert) checkOffset(offset, 4, this.length)\\n  return ieee754.read(this, offset, true, 23, 4)\\n}\\n\\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\\n  offset = offset >>> 0\\n  if (!noAssert) checkOffset(offset, 4, this.length)\\n  return ieee754.read(this, offset, false, 23, 4)\\n}\\n\\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\\n  offset = offset >>> 0\\n  if (!noAssert) checkOffset(offset, 8, this.length)\\n  return ieee754.read(this, offset, true, 52, 8)\\n}\\n\\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\\n  offset = offset >>> 0\\n  if (!noAssert) checkOffset(offset, 8, this.length)\\n  return ieee754.read(this, offset, false, 52, 8)\\n}\\n\\nfunction checkInt (buf, value, offset, ext, max, min) {\\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\\\"buffer\\\" argument must be a Buffer instance')\\n  if (value > max || value < min) throw new RangeError('\\\"value\\\" argument is out of bounds')\\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\\n}\\n\\nBuffer.prototype.writeUintLE =\\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\\n  value = +value\\n  offset = offset >>> 0\\n  byteLength = byteLength >>> 0\\n  if (!noAssert) {\\n    const maxBytes = Math.pow(2, 8 * byteLength) - 1\\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\\n  }\\n\\n  let mul = 1\\n  let i = 0\\n  this[offset] = value & 0xFF\\n  while (++i < byteLength && (mul *= 0x100)) {\\n    this[offset + i] = (value / mul) & 0xFF\\n  }\\n\\n  return offset + byteLength\\n}\\n\\nBuffer.prototype.writeUintBE =\\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\\n  value = +value\\n  offset = offset >>> 0\\n  byteLength = byteLength >>> 0\\n  if (!noAssert) {\\n    const maxBytes = Math.pow(2, 8 * byteLength) - 1\\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\\n  }\\n\\n  let i = byteLength - 1\\n  let mul = 1\\n  this[offset + i] = value & 0xFF\\n  while (--i >= 0 && (mul *= 0x100)) {\\n    this[offset + i] = (value / mul) & 0xFF\\n  }\\n\\n  return offset + byteLength\\n}\\n\\nBuffer.prototype.writeUint8 =\\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\\n  value = +value\\n  offset = offset >>> 0\\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\\n  this[offset] = (value & 0xff)\\n  return offset + 1\\n}\\n\\nBuffer.prototype.writeUint16LE =\\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\\n  value = +value\\n  offset = offset >>> 0\\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\\n  this[offset] = (value & 0xff)\\n  this[offset + 1] = (value >>> 8)\\n  return offset + 2\\n}\\n\\nBuffer.prototype.writeUint16BE =\\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\\n  value = +value\\n  offset = offset >>> 0\\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\\n  this[offset] = (value >>> 8)\\n  this[offset + 1] = (value & 0xff)\\n  return offset + 2\\n}\\n\\nBuffer.prototype.writeUint32LE =\\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\\n  value = +value\\n  offset = offset >>> 0\\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\\n  this[offset + 3] = (value >>> 24)\\n  this[offset + 2] = (value >>> 16)\\n  this[offset + 1] = (value >>> 8)\\n  this[offset] = (value & 0xff)\\n  return offset + 4\\n}\\n\\nBuffer.prototype.writeUint32BE =\\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\\n  value = +value\\n  offset = offset >>> 0\\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\\n  this[offset] = (value >>> 24)\\n  this[offset + 1] = (value >>> 16)\\n  this[offset + 2] = (value >>> 8)\\n  this[offset + 3] = (value & 0xff)\\n  return offset + 4\\n}\\n\\nfunction wrtBigUInt64LE (buf, value, offset, min, max) {\\n  checkIntBI(value, min, max, buf, offset, 7)\\n\\n  let lo = Number(value & BigInt(0xffffffff))\\n  buf[offset++] = lo\\n  lo = lo >> 8\\n  buf[offset++] = lo\\n  lo = lo >> 8\\n  buf[offset++] = lo\\n  lo = lo >> 8\\n  buf[offset++] = lo\\n  let hi = Number(value >> BigInt(32) & BigInt(0xffffffff))\\n  buf[offset++] = hi\\n  hi = hi >> 8\\n  buf[offset++] = hi\\n  hi = hi >> 8\\n  buf[offset++] = hi\\n  hi = hi >> 8\\n  buf[offset++] = hi\\n  return offset\\n}\\n\\nfunction wrtBigUInt64BE (buf, value, offset, min, max) {\\n  checkIntBI(value, min, max, buf, offset, 7)\\n\\n  let lo = Number(value & BigInt(0xffffffff))\\n  buf[offset + 7] = lo\\n  lo = lo >> 8\\n  buf[offset + 6] = lo\\n  lo = lo >> 8\\n  buf[offset + 5] = lo\\n  lo = lo >> 8\\n  buf[offset + 4] = lo\\n  let hi = Number(value >> BigInt(32) & BigInt(0xffffffff))\\n  buf[offset + 3] = hi\\n  hi = hi >> 8\\n  buf[offset + 2] = hi\\n  hi = hi >> 8\\n  buf[offset + 1] = hi\\n  hi = hi >> 8\\n  buf[offset] = hi\\n  return offset + 8\\n}\\n\\nBuffer.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE (value, offset = 0) {\\n  return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt('0xffffffffffffffff'))\\n})\\n\\nBuffer.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE (value, offset = 0) {\\n  return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt('0xffffffffffffffff'))\\n})\\n\\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\\n  value = +value\\n  offset = offset >>> 0\\n  if (!noAssert) {\\n    const limit = Math.pow(2, (8 * byteLength) - 1)\\n\\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\\n  }\\n\\n  let i = 0\\n  let mul = 1\\n  let sub = 0\\n  this[offset] = value & 0xFF\\n  while (++i < byteLength && (mul *= 0x100)) {\\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\\n      sub = 1\\n    }\\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\\n  }\\n\\n  return offset + byteLength\\n}\\n\\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\\n  value = +value\\n  offset = offset >>> 0\\n  if (!noAssert) {\\n    const limit = Math.pow(2, (8 * byteLength) - 1)\\n\\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\\n  }\\n\\n  let i = byteLength - 1\\n  let mul = 1\\n  let sub = 0\\n  this[offset + i] = value & 0xFF\\n  while (--i >= 0 && (mul *= 0x100)) {\\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\\n      sub = 1\\n    }\\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\\n  }\\n\\n  return offset + byteLength\\n}\\n\\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\\n  value = +value\\n  offset = offset >>> 0\\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\\n  if (value < 0) value = 0xff + value + 1\\n  this[offset] = (value & 0xff)\\n  return offset + 1\\n}\\n\\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\\n  value = +value\\n  offset = offset >>> 0\\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\\n  this[offset] = (value & 0xff)\\n  this[offset + 1] = (value >>> 8)\\n  return offset + 2\\n}\\n\\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\\n  value = +value\\n  offset = offset >>> 0\\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\\n  this[offset] = (value >>> 8)\\n  this[offset + 1] = (value & 0xff)\\n  return offset + 2\\n}\\n\\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\\n  value = +value\\n  offset = offset >>> 0\\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\\n  this[offset] = (value & 0xff)\\n  this[offset + 1] = (value >>> 8)\\n  this[offset + 2] = (value >>> 16)\\n  this[offset + 3] = (value >>> 24)\\n  return offset + 4\\n}\\n\\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\\n  value = +value\\n  offset = offset >>> 0\\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\\n  if (value < 0) value = 0xffffffff + value + 1\\n  this[offset] = (value >>> 24)\\n  this[offset + 1] = (value >>> 16)\\n  this[offset + 2] = (value >>> 8)\\n  this[offset + 3] = (value & 0xff)\\n  return offset + 4\\n}\\n\\nBuffer.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE (value, offset = 0) {\\n  return wrtBigUInt64LE(this, value, offset, -BigInt('0x8000000000000000'), BigInt('0x7fffffffffffffff'))\\n})\\n\\nBuffer.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE (value, offset = 0) {\\n  return wrtBigUInt64BE(this, value, offset, -BigInt('0x8000000000000000'), BigInt('0x7fffffffffffffff'))\\n})\\n\\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\\n  if (offset < 0) throw new RangeError('Index out of range')\\n}\\n\\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\\n  value = +value\\n  offset = offset >>> 0\\n  if (!noAssert) {\\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\\n  }\\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\\n  return offset + 4\\n}\\n\\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\\n  return writeFloat(this, value, offset, true, noAssert)\\n}\\n\\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\\n  return writeFloat(this, value, offset, false, noAssert)\\n}\\n\\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\\n  value = +value\\n  offset = offset >>> 0\\n  if (!noAssert) {\\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\\n  }\\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\\n  return offset + 8\\n}\\n\\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\\n  return writeDouble(this, value, offset, true, noAssert)\\n}\\n\\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\\n  return writeDouble(this, value, offset, false, noAssert)\\n}\\n\\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\\n  if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')\\n  if (!start) start = 0\\n  if (!end && end !== 0) end = this.length\\n  if (targetStart >= target.length) targetStart = target.length\\n  if (!targetStart) targetStart = 0\\n  if (end > 0 && end < start) end = start\\n\\n  // Copy 0 bytes; we're done\\n  if (end === start) return 0\\n  if (target.length === 0 || this.length === 0) return 0\\n\\n  // Fatal error conditions\\n  if (targetStart < 0) {\\n    throw new RangeError('targetStart out of bounds')\\n  }\\n  if (start < 0 || start >= this.length) throw new RangeError('Index out of range')\\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\\n\\n  // Are we oob?\\n  if (end > this.length) end = this.length\\n  if (target.length - targetStart < end - start) {\\n    end = target.length - targetStart + start\\n  }\\n\\n  const len = end - start\\n\\n  if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {\\n    // Use built-in when available, missing from IE11\\n    this.copyWithin(targetStart, start, end)\\n  } else {\\n    Uint8Array.prototype.set.call(\\n      target,\\n      this.subarray(start, end),\\n      targetStart\\n    )\\n  }\\n\\n  return len\\n}\\n\\n// Usage:\\n//    buffer.fill(number[, offset[, end]])\\n//    buffer.fill(buffer[, offset[, end]])\\n//    buffer.fill(string[, offset[, end]][, encoding])\\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\\n  // Handle string cases:\\n  if (typeof val === 'string') {\\n    if (typeof start === 'string') {\\n      encoding = start\\n      start = 0\\n      end = this.length\\n    } else if (typeof end === 'string') {\\n      encoding = end\\n      end = this.length\\n    }\\n    if (encoding !== undefined && typeof encoding !== 'string') {\\n      throw new TypeError('encoding must be a string')\\n    }\\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\\n      throw new TypeError('Unknown encoding: ' + encoding)\\n    }\\n    if (val.length === 1) {\\n      const code = val.charCodeAt(0)\\n      if ((encoding === 'utf8' && code < 128) ||\\n          encoding === 'latin1') {\\n        // Fast path: If `val` fits into a single byte, use that numeric value.\\n        val = code\\n      }\\n    }\\n  } else if (typeof val === 'number') {\\n    val = val & 255\\n  } else if (typeof val === 'boolean') {\\n    val = Number(val)\\n  }\\n\\n  // Invalid ranges are not set to a default, so can range check early.\\n  if (start < 0 || this.length < start || this.length < end) {\\n    throw new RangeError('Out of range index')\\n  }\\n\\n  if (end <= start) {\\n    return this\\n  }\\n\\n  start = start >>> 0\\n  end = end === undefined ? this.length : end >>> 0\\n\\n  if (!val) val = 0\\n\\n  let i\\n  if (typeof val === 'number') {\\n    for (i = start; i < end; ++i) {\\n      this[i] = val\\n    }\\n  } else {\\n    const bytes = Buffer.isBuffer(val)\\n      ? val\\n      : Buffer.from(val, encoding)\\n    const len = bytes.length\\n    if (len === 0) {\\n      throw new TypeError('The value \\\"' + val +\\n        '\\\" is invalid for argument \\\"value\\\"')\\n    }\\n    for (i = 0; i < end - start; ++i) {\\n      this[i + start] = bytes[i % len]\\n    }\\n  }\\n\\n  return this\\n}\\n\\n// CUSTOM ERRORS\\n// =============\\n\\n// Simplified versions from Node, changed for Buffer-only usage\\nconst errors = {}\\nfunction E (sym, getMessage, Base) {\\n  errors[sym] = class NodeError extends Base {\\n    constructor () {\\n      super()\\n\\n      Object.defineProperty(this, 'message', {\\n        value: getMessage.apply(this, arguments),\\n        writable: true,\\n        configurable: true\\n      })\\n\\n      // Add the error code to the name to include it in the stack trace.\\n      this.name = `${this.name} [${sym}]`\\n      // Access the stack to generate the error message including the error code\\n      // from the name.\\n      this.stack // eslint-disable-line no-unused-expressions\\n      // Reset the name to the actual name.\\n      delete this.name\\n    }\\n\\n    get code () {\\n      return sym\\n    }\\n\\n    set code (value) {\\n      Object.defineProperty(this, 'code', {\\n        configurable: true,\\n        enumerable: true,\\n        value,\\n        writable: true\\n      })\\n    }\\n\\n    toString () {\\n      return `${this.name} [${sym}]: ${this.message}`\\n    }\\n  }\\n}\\n\\nE('ERR_BUFFER_OUT_OF_BOUNDS',\\n  function (name) {\\n    if (name) {\\n      return `${name} is outside of buffer bounds`\\n    }\\n\\n    return 'Attempt to access memory outside buffer bounds'\\n  }, RangeError)\\nE('ERR_INVALID_ARG_TYPE',\\n  function (name, actual) {\\n    return `The \\\"${name}\\\" argument must be of type number. Received type ${typeof actual}`\\n  }, TypeError)\\nE('ERR_OUT_OF_RANGE',\\n  function (str, range, input) {\\n    let msg = `The value of \\\"${str}\\\" is out of range.`\\n    let received = input\\n    if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {\\n      received = addNumericalSeparator(String(input))\\n    } else if (typeof input === 'bigint') {\\n      received = String(input)\\n      if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) {\\n        received = addNumericalSeparator(received)\\n      }\\n      received += 'n'\\n    }\\n    msg += ` It must be ${range}. Received ${received}`\\n    return msg\\n  }, RangeError)\\n\\nfunction addNumericalSeparator (val) {\\n  let res = ''\\n  let i = val.length\\n  const start = val[0] === '-' ? 1 : 0\\n  for (; i >= start + 4; i -= 3) {\\n    res = `_${val.slice(i - 3, i)}${res}`\\n  }\\n  return `${val.slice(0, i)}${res}`\\n}\\n\\n// CHECK FUNCTIONS\\n// ===============\\n\\nfunction checkBounds (buf, offset, byteLength) {\\n  validateNumber(offset, 'offset')\\n  if (buf[offset] === undefined || buf[offset + byteLength] === undefined) {\\n    boundsError(offset, buf.length - (byteLength + 1))\\n  }\\n}\\n\\nfunction checkIntBI (value, min, max, buf, offset, byteLength) {\\n  if (value > max || value < min) {\\n    const n = typeof min === 'bigint' ? 'n' : ''\\n    let range\\n    if (byteLength > 3) {\\n      if (min === 0 || min === BigInt(0)) {\\n        range = `>= 0${n} and < 2${n} ** ${(byteLength + 1) * 8}${n}`\\n      } else {\\n        range = `>= -(2${n} ** ${(byteLength + 1) * 8 - 1}${n}) and < 2 ** ` +\\n                `${(byteLength + 1) * 8 - 1}${n}`\\n      }\\n    } else {\\n      range = `>= ${min}${n} and <= ${max}${n}`\\n    }\\n    throw new errors.ERR_OUT_OF_RANGE('value', range, value)\\n  }\\n  checkBounds(buf, offset, byteLength)\\n}\\n\\nfunction validateNumber (value, name) {\\n  if (typeof value !== 'number') {\\n    throw new errors.ERR_INVALID_ARG_TYPE(name, 'number', value)\\n  }\\n}\\n\\nfunction boundsError (value, length, type) {\\n  if (Math.floor(value) !== value) {\\n    validateNumber(value, type)\\n    throw new errors.ERR_OUT_OF_RANGE(type || 'offset', 'an integer', value)\\n  }\\n\\n  if (length < 0) {\\n    throw new errors.ERR_BUFFER_OUT_OF_BOUNDS()\\n  }\\n\\n  throw new errors.ERR_OUT_OF_RANGE(type || 'offset',\\n                                    `>= ${type ? 1 : 0} and <= ${length}`,\\n                                    value)\\n}\\n\\n// HELPER FUNCTIONS\\n// ================\\n\\nconst INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g\\n\\nfunction base64clean (str) {\\n  // Node takes equal signs as end of the Base64 encoding\\n  str = str.split('=')[0]\\n  // Node strips out invalid characters like \\\\n and \\\\t from the string, base64-js does not\\n  str = str.trim().replace(INVALID_BASE64_RE, '')\\n  // Node converts strings with length < 2 to ''\\n  if (str.length < 2) return ''\\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\\n  while (str.length % 4 !== 0) {\\n    str = str + '='\\n  }\\n  return str\\n}\\n\\nfunction utf8ToBytes (string, units) {\\n  units = units || Infinity\\n  let codePoint\\n  const length = string.length\\n  let leadSurrogate = null\\n  const bytes = []\\n\\n  for (let i = 0; i < length; ++i) {\\n    codePoint = string.charCodeAt(i)\\n\\n    // is surrogate component\\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\\n      // last char was a lead\\n      if (!leadSurrogate) {\\n        // no lead yet\\n        if (codePoint > 0xDBFF) {\\n          // unexpected trail\\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\\n          continue\\n        } else if (i + 1 === length) {\\n          // unpaired lead\\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\\n          continue\\n        }\\n\\n        // valid lead\\n        leadSurrogate = codePoint\\n\\n        continue\\n      }\\n\\n      // 2 leads in a row\\n      if (codePoint < 0xDC00) {\\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\\n        leadSurrogate = codePoint\\n        continue\\n      }\\n\\n      // valid surrogate pair\\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\\n    } else if (leadSurrogate) {\\n      // valid bmp char, but last char was a lead\\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\\n    }\\n\\n    leadSurrogate = null\\n\\n    // encode utf8\\n    if (codePoint < 0x80) {\\n      if ((units -= 1) < 0) break\\n      bytes.push(codePoint)\\n    } else if (codePoint < 0x800) {\\n      if ((units -= 2) < 0) break\\n      bytes.push(\\n        codePoint >> 0x6 | 0xC0,\\n        codePoint & 0x3F | 0x80\\n      )\\n    } else if (codePoint < 0x10000) {\\n      if ((units -= 3) < 0) break\\n      bytes.push(\\n        codePoint >> 0xC | 0xE0,\\n        codePoint >> 0x6 & 0x3F | 0x80,\\n        codePoint & 0x3F | 0x80\\n      )\\n    } else if (codePoint < 0x110000) {\\n      if ((units -= 4) < 0) break\\n      bytes.push(\\n        codePoint >> 0x12 | 0xF0,\\n        codePoint >> 0xC & 0x3F | 0x80,\\n        codePoint >> 0x6 & 0x3F | 0x80,\\n        codePoint & 0x3F | 0x80\\n      )\\n    } else {\\n      throw new Error('Invalid code point')\\n    }\\n  }\\n\\n  return bytes\\n}\\n\\nfunction asciiToBytes (str) {\\n  const byteArray = []\\n  for (let i = 0; i < str.length; ++i) {\\n    // Node's code seems to be doing this and not & 0x7F..\\n    byteArray.push(str.charCodeAt(i) & 0xFF)\\n  }\\n  return byteArray\\n}\\n\\nfunction utf16leToBytes (str, units) {\\n  let c, hi, lo\\n  const byteArray = []\\n  for (let i = 0; i < str.length; ++i) {\\n    if ((units -= 2) < 0) break\\n\\n    c = str.charCodeAt(i)\\n    hi = c >> 8\\n    lo = c % 256\\n    byteArray.push(lo)\\n    byteArray.push(hi)\\n  }\\n\\n  return byteArray\\n}\\n\\nfunction base64ToBytes (str) {\\n  return base64.toByteArray(base64clean(str))\\n}\\n\\nfunction blitBuffer (src, dst, offset, length) {\\n  let i\\n  for (i = 0; i < length; ++i) {\\n    if ((i + offset >= dst.length) || (i >= src.length)) break\\n    dst[i + offset] = src[i]\\n  }\\n  return i\\n}\\n\\n// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass\\n// the `instanceof` check but they should be treated as of that type.\\n// See: https://github.com/feross/buffer/issues/166\\nfunction isInstance (obj, type) {\\n  return obj instanceof type ||\\n    (obj != null && obj.constructor != null && obj.constructor.name != null &&\\n      obj.constructor.name === type.name)\\n}\\nfunction numberIsNaN (obj) {\\n  // For IE11 support\\n  return obj !== obj // eslint-disable-line no-self-compare\\n}\\n\\n// Create lookup table for `toString('hex')`\\n// See: https://github.com/feross/buffer/issues/219\\nconst hexSliceLookupTable = (function () {\\n  const alphabet = '0123456789abcdef'\\n  const table = new Array(256)\\n  for (let i = 0; i < 16; ++i) {\\n    const i16 = i * 16\\n    for (let j = 0; j < 16; ++j) {\\n      table[i16 + j] = alphabet[i] + alphabet[j]\\n    }\\n  }\\n  return table\\n})()\\n\\n// Return not function with Error if BigInt not supported\\nfunction defineBigIntMethod (fn) {\\n  return typeof BigInt === 'undefined' ? BufferBigIntNotDefined : fn\\n}\\n\\nfunction BufferBigIntNotDefined () {\\n  throw new Error('BigInt not supported')\\n}\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@solana/web3.js/node_modules/buffer/index.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/base-x/src/index.js\":\n/*!******************************************!*\\\n  !*** ./node_modules/base-x/src/index.js ***!\n  \\******************************************/\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\neval(\"\\n// base-x encoding / decoding\\n// Copyright (c) 2018 base-x contributors\\n// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)\\n// Distributed under the MIT software license, see the accompanying\\n// file LICENSE or http://www.opensource.org/licenses/mit-license.php.\\n// @ts-ignore\\nvar _Buffer = (__webpack_require__(/*! safe-buffer */ \\\"./node_modules/safe-buffer/index.js\\\").Buffer)\\nfunction base (ALPHABET) {\\n  if (ALPHABET.length >= 255) { throw new TypeError('Alphabet too long') }\\n  var BASE_MAP = new Uint8Array(256)\\n  for (var j = 0; j < BASE_MAP.length; j++) {\\n    BASE_MAP[j] = 255\\n  }\\n  for (var i = 0; i < ALPHABET.length; i++) {\\n    var x = ALPHABET.charAt(i)\\n    var xc = x.charCodeAt(0)\\n    if (BASE_MAP[xc] !== 255) { throw new TypeError(x + ' is ambiguous') }\\n    BASE_MAP[xc] = i\\n  }\\n  var BASE = ALPHABET.length\\n  var LEADER = ALPHABET.charAt(0)\\n  var FACTOR = Math.log(BASE) / Math.log(256) // log(BASE) / log(256), rounded up\\n  var iFACTOR = Math.log(256) / Math.log(BASE) // log(256) / log(BASE), rounded up\\n  function encode (source) {\\n    if (Array.isArray(source) || source instanceof Uint8Array) { source = _Buffer.from(source) }\\n    if (!_Buffer.isBuffer(source)) { throw new TypeError('Expected Buffer') }\\n    if (source.length === 0) { return '' }\\n        // Skip & count leading zeroes.\\n    var zeroes = 0\\n    var length = 0\\n    var pbegin = 0\\n    var pend = source.length\\n    while (pbegin !== pend && source[pbegin] === 0) {\\n      pbegin++\\n      zeroes++\\n    }\\n        // Allocate enough space in big-endian base58 representation.\\n    var size = ((pend - pbegin) * iFACTOR + 1) >>> 0\\n    var b58 = new Uint8Array(size)\\n        // Process the bytes.\\n    while (pbegin !== pend) {\\n      var carry = source[pbegin]\\n            // Apply \\\"b58 = b58 * 256 + ch\\\".\\n      var i = 0\\n      for (var it1 = size - 1; (carry !== 0 || i < length) && (it1 !== -1); it1--, i++) {\\n        carry += (256 * b58[it1]) >>> 0\\n        b58[it1] = (carry % BASE) >>> 0\\n        carry = (carry / BASE) >>> 0\\n      }\\n      if (carry !== 0) { throw new Error('Non-zero carry') }\\n      length = i\\n      pbegin++\\n    }\\n        // Skip leading zeroes in base58 result.\\n    var it2 = size - length\\n    while (it2 !== size && b58[it2] === 0) {\\n      it2++\\n    }\\n        // Translate the result into a string.\\n    var str = LEADER.repeat(zeroes)\\n    for (; it2 < size; ++it2) { str += ALPHABET.charAt(b58[it2]) }\\n    return str\\n  }\\n  function decodeUnsafe (source) {\\n    if (typeof source !== 'string') { throw new TypeError('Expected String') }\\n    if (source.length === 0) { return _Buffer.alloc(0) }\\n    var psz = 0\\n        // Skip and count leading '1's.\\n    var zeroes = 0\\n    var length = 0\\n    while (source[psz] === LEADER) {\\n      zeroes++\\n      psz++\\n    }\\n        // Allocate enough space in big-endian base256 representation.\\n    var size = (((source.length - psz) * FACTOR) + 1) >>> 0 // log(58) / log(256), rounded up.\\n    var b256 = new Uint8Array(size)\\n        // Process the characters.\\n    while (source[psz]) {\\n            // Decode character\\n      var carry = BASE_MAP[source.charCodeAt(psz)]\\n            // Invalid character\\n      if (carry === 255) { return }\\n      var i = 0\\n      for (var it3 = size - 1; (carry !== 0 || i < length) && (it3 !== -1); it3--, i++) {\\n        carry += (BASE * b256[it3]) >>> 0\\n        b256[it3] = (carry % 256) >>> 0\\n        carry = (carry / 256) >>> 0\\n      }\\n      if (carry !== 0) { throw new Error('Non-zero carry') }\\n      length = i\\n      psz++\\n    }\\n        // Skip leading zeroes in b256.\\n    var it4 = size - length\\n    while (it4 !== size && b256[it4] === 0) {\\n      it4++\\n    }\\n    var vch = _Buffer.allocUnsafe(zeroes + (size - it4))\\n    vch.fill(0x00, 0, zeroes)\\n    var j = zeroes\\n    while (it4 !== size) {\\n      vch[j++] = b256[it4++]\\n    }\\n    return vch\\n  }\\n  function decode (string) {\\n    var buffer = decodeUnsafe(string)\\n    if (buffer) { return buffer }\\n    throw new Error('Non-base' + BASE + ' character')\\n  }\\n  return {\\n    encode: encode,\\n    decodeUnsafe: decodeUnsafe,\\n    decode: decode\\n  }\\n}\\nmodule.exports = base\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/base-x/src/index.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/base64-js/index.js\":\n/*!*****************************************!*\\\n  !*** ./node_modules/base64-js/index.js ***!\n  \\*****************************************/\n/***/ ((__unused_webpack_module, exports) => {\n\n\"use strict\";\neval(\"\\n\\nexports.byteLength = byteLength\\nexports.toByteArray = toByteArray\\nexports.fromByteArray = fromByteArray\\n\\nvar lookup = []\\nvar revLookup = []\\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\\n\\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\\nfor (var i = 0, len = code.length; i < len; ++i) {\\n  lookup[i] = code[i]\\n  revLookup[code.charCodeAt(i)] = i\\n}\\n\\n// Support decoding URL-safe base64 strings, as Node.js does.\\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\\nrevLookup['-'.charCodeAt(0)] = 62\\nrevLookup['_'.charCodeAt(0)] = 63\\n\\nfunction getLens (b64) {\\n  var len = b64.length\\n\\n  if (len % 4 > 0) {\\n    throw new Error('Invalid string. Length must be a multiple of 4')\\n  }\\n\\n  // Trim off extra bytes after placeholder bytes are found\\n  // See: https://github.com/beatgammit/base64-js/issues/42\\n  var validLen = b64.indexOf('=')\\n  if (validLen === -1) validLen = len\\n\\n  var placeHoldersLen = validLen === len\\n    ? 0\\n    : 4 - (validLen % 4)\\n\\n  return [validLen, placeHoldersLen]\\n}\\n\\n// base64 is 4/3 + up to two characters of the original data\\nfunction byteLength (b64) {\\n  var lens = getLens(b64)\\n  var validLen = lens[0]\\n  var placeHoldersLen = lens[1]\\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\\n}\\n\\nfunction _byteLength (b64, validLen, placeHoldersLen) {\\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\\n}\\n\\nfunction toByteArray (b64) {\\n  var tmp\\n  var lens = getLens(b64)\\n  var validLen = lens[0]\\n  var placeHoldersLen = lens[1]\\n\\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\\n\\n  var curByte = 0\\n\\n  // if there are placeholders, only get up to the last complete 4 chars\\n  var len = placeHoldersLen > 0\\n    ? validLen - 4\\n    : validLen\\n\\n  var i\\n  for (i = 0; i < len; i += 4) {\\n    tmp =\\n      (revLookup[b64.charCodeAt(i)] << 18) |\\n      (revLookup[b64.charCodeAt(i + 1)] << 12) |\\n      (revLookup[b64.charCodeAt(i + 2)] << 6) |\\n      revLookup[b64.charCodeAt(i + 3)]\\n    arr[curByte++] = (tmp >> 16) & 0xFF\\n    arr[curByte++] = (tmp >> 8) & 0xFF\\n    arr[curByte++] = tmp & 0xFF\\n  }\\n\\n  if (placeHoldersLen === 2) {\\n    tmp =\\n      (revLookup[b64.charCodeAt(i)] << 2) |\\n      (revLookup[b64.charCodeAt(i + 1)] >> 4)\\n    arr[curByte++] = tmp & 0xFF\\n  }\\n\\n  if (placeHoldersLen === 1) {\\n    tmp =\\n      (revLookup[b64.charCodeAt(i)] << 10) |\\n      (revLookup[b64.charCodeAt(i + 1)] << 4) |\\n      (revLookup[b64.charCodeAt(i + 2)] >> 2)\\n    arr[curByte++] = (tmp >> 8) & 0xFF\\n    arr[curByte++] = tmp & 0xFF\\n  }\\n\\n  return arr\\n}\\n\\nfunction tripletToBase64 (num) {\\n  return lookup[num >> 18 & 0x3F] +\\n    lookup[num >> 12 & 0x3F] +\\n    lookup[num >> 6 & 0x3F] +\\n    lookup[num & 0x3F]\\n}\\n\\nfunction encodeChunk (uint8, start, end) {\\n  var tmp\\n  var output = []\\n  for (var i = start; i < end; i += 3) {\\n    tmp =\\n      ((uint8[i] << 16) & 0xFF0000) +\\n      ((uint8[i + 1] << 8) & 0xFF00) +\\n      (uint8[i + 2] & 0xFF)\\n    output.push(tripletToBase64(tmp))\\n  }\\n  return output.join('')\\n}\\n\\nfunction fromByteArray (uint8) {\\n  var tmp\\n  var len = uint8.length\\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\\n  var parts = []\\n  var maxChunkLength = 16383 // must be multiple of 3\\n\\n  // go through the array every three bytes, we'll deal with trailing stuff later\\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\\n    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\\n  }\\n\\n  // pad the end with zeros, but make sure to not forget the extra bytes\\n  if (extraBytes === 1) {\\n    tmp = uint8[len - 1]\\n    parts.push(\\n      lookup[tmp >> 2] +\\n      lookup[(tmp << 4) & 0x3F] +\\n      '=='\\n    )\\n  } else if (extraBytes === 2) {\\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1]\\n    parts.push(\\n      lookup[tmp >> 10] +\\n      lookup[(tmp >> 4) & 0x3F] +\\n      lookup[(tmp << 2) & 0x3F] +\\n      '='\\n    )\\n  }\\n\\n  return parts.join('')\\n}\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/base64-js/index.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/bigint-buffer/dist/browser.js\":\n/*!****************************************************!*\\\n  !*** ./node_modules/bigint-buffer/dist/browser.js ***!\n  \\****************************************************/\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\neval(\"/* provided dependency */ var Buffer = __webpack_require__(/*! buffer */ \\\"./node_modules/buffer/index.js\\\")[\\\"Buffer\\\"];\\n\\n\\nObject.defineProperty(exports, \\\"__esModule\\\", ({ value: true }));\\nlet converter;\\n/**\\n * Convert a little-endian buffer into a BigInt.\\n * @param buf The little-endian buffer to convert\\n * @returns A BigInt with the little-endian representation of buf.\\n */\\nfunction toBigIntLE(buf) {\\n    {\\n        const reversed = Buffer.from(buf);\\n        reversed.reverse();\\n        const hex = reversed.toString('hex');\\n        if (hex.length === 0) {\\n            return BigInt(0);\\n        }\\n        return BigInt(`0x${hex}`);\\n    }\\n    return converter.toBigInt(buf, false);\\n}\\nexports.toBigIntLE = toBigIntLE;\\n/**\\n * Convert a big-endian buffer into a BigInt\\n * @param buf The big-endian buffer to convert.\\n * @returns A BigInt with the big-endian representation of buf.\\n */\\nfunction toBigIntBE(buf) {\\n    {\\n        const hex = buf.toString('hex');\\n        if (hex.length === 0) {\\n            return BigInt(0);\\n        }\\n        return BigInt(`0x${hex}`);\\n    }\\n    return converter.toBigInt(buf, true);\\n}\\nexports.toBigIntBE = toBigIntBE;\\n/**\\n * Convert a BigInt to a little-endian buffer.\\n * @param num   The BigInt to convert.\\n * @param width The number of bytes that the resulting buffer should be.\\n * @returns A little-endian buffer representation of num.\\n */\\nfunction toBufferLE(num, width) {\\n    {\\n        const hex = num.toString(16);\\n        const buffer = Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');\\n        buffer.reverse();\\n        return buffer;\\n    }\\n    // Allocation is done here, since it is slower using napi in C\\n    return converter.fromBigInt(num, Buffer.allocUnsafe(width), false);\\n}\\nexports.toBufferLE = toBufferLE;\\n/**\\n * Convert a BigInt to a big-endian buffer.\\n * @param num   The BigInt to convert.\\n * @param width The number of bytes that the resulting buffer should be.\\n * @returns A big-endian buffer representation of num.\\n */\\nfunction toBufferBE(num, width) {\\n    {\\n        const hex = num.toString(16);\\n        return Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');\\n    }\\n    return converter.fromBigInt(num, Buffer.allocUnsafe(width), true);\\n}\\nexports.toBufferBE = toBufferBE;\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/bigint-buffer/dist/browser.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/bn.js/lib/bn.js\":\n/*!**************************************!*\\\n  !*** ./node_modules/bn.js/lib/bn.js ***!\n  \\**************************************/\n/***/ (function(module, __unused_webpack_exports, __webpack_require__) {\n\neval(\"/* module decorator */ module = __webpack_require__.nmd(module);\\n(function (module, exports) {\\n  'use strict';\\n\\n  // Utils\\n  function assert (val, msg) {\\n    if (!val) throw new Error(msg || 'Assertion failed');\\n  }\\n\\n  // Could use `inherits` module, but don't want to move from single file\\n  // architecture yet.\\n  function inherits (ctor, superCtor) {\\n    ctor.super_ = superCtor;\\n    var TempCtor = function () {};\\n    TempCtor.prototype = superCtor.prototype;\\n    ctor.prototype = new TempCtor();\\n    ctor.prototype.constructor = ctor;\\n  }\\n\\n  // BN\\n\\n  function BN (number, base, endian) {\\n    if (BN.isBN(number)) {\\n      return number;\\n    }\\n\\n    this.negative = 0;\\n    this.words = null;\\n    this.length = 0;\\n\\n    // Reduction context\\n    this.red = null;\\n\\n    if (number !== null) {\\n      if (base === 'le' || base === 'be') {\\n        endian = base;\\n        base = 10;\\n      }\\n\\n      this._init(number || 0, base || 10, endian || 'be');\\n    }\\n  }\\n  if (typeof module === 'object') {\\n    module.exports = BN;\\n  } else {\\n    exports.BN = BN;\\n  }\\n\\n  BN.BN = BN;\\n  BN.wordSize = 26;\\n\\n  var Buffer;\\n  try {\\n    if (typeof window !== 'undefined' && typeof window.Buffer !== 'undefined') {\\n      Buffer = window.Buffer;\\n    } else {\\n      Buffer = (__webpack_require__(/*! buffer */ \\\"?8131\\\").Buffer);\\n    }\\n  } catch (e) {\\n  }\\n\\n  BN.isBN = function isBN (num) {\\n    if (num instanceof BN) {\\n      return true;\\n    }\\n\\n    return num !== null && typeof num === 'object' &&\\n      num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);\\n  };\\n\\n  BN.max = function max (left, right) {\\n    if (left.cmp(right) > 0) return left;\\n    return right;\\n  };\\n\\n  BN.min = function min (left, right) {\\n    if (left.cmp(right) < 0) return left;\\n    return right;\\n  };\\n\\n  BN.prototype._init = function init (number, base, endian) {\\n    if (typeof number === 'number') {\\n      return this._initNumber(number, base, endian);\\n    }\\n\\n    if (typeof number === 'object') {\\n      return this._initArray(number, base, endian);\\n    }\\n\\n    if (base === 'hex') {\\n      base = 16;\\n    }\\n    assert(base === (base | 0) && base >= 2 && base <= 36);\\n\\n    number = number.toString().replace(/\\\\s+/g, '');\\n    var start = 0;\\n    if (number[0] === '-') {\\n      start++;\\n      this.negative = 1;\\n    }\\n\\n    if (start < number.length) {\\n      if (base === 16) {\\n        this._parseHex(number, start, endian);\\n      } else {\\n        this._parseBase(number, base, start);\\n        if (endian === 'le') {\\n          this._initArray(this.toArray(), base, endian);\\n        }\\n      }\\n    }\\n  };\\n\\n  BN.prototype._initNumber = function _initNumber (number, base, endian) {\\n    if (number < 0) {\\n      this.negative = 1;\\n      number = -number;\\n    }\\n    if (number < 0x4000000) {\\n      this.words = [number & 0x3ffffff];\\n      this.length = 1;\\n    } else if (number < 0x10000000000000) {\\n      this.words = [\\n        number & 0x3ffffff,\\n        (number / 0x4000000) & 0x3ffffff\\n      ];\\n      this.length = 2;\\n    } else {\\n      assert(number < 0x20000000000000); // 2 ^ 53 (unsafe)\\n      this.words = [\\n        number & 0x3ffffff,\\n        (number / 0x4000000) & 0x3ffffff,\\n        1\\n      ];\\n      this.length = 3;\\n    }\\n\\n    if (endian !== 'le') return;\\n\\n    // Reverse the bytes\\n    this._initArray(this.toArray(), base, endian);\\n  };\\n\\n  BN.prototype._initArray = function _initArray (number, base, endian) {\\n    // Perhaps a Uint8Array\\n    assert(typeof number.length === 'number');\\n    if (number.length <= 0) {\\n      this.words = [0];\\n      this.length = 1;\\n      return this;\\n    }\\n\\n    this.length = Math.ceil(number.length / 3);\\n    this.words = new Array(this.length);\\n    for (var i = 0; i < this.length; i++) {\\n      this.words[i] = 0;\\n    }\\n\\n    var j, w;\\n    var off = 0;\\n    if (endian === 'be') {\\n      for (i = number.length - 1, j = 0; i >= 0; i -= 3) {\\n        w = number[i] | (number[i - 1] << 8) | (number[i - 2] << 16);\\n        this.words[j] |= (w << off) & 0x3ffffff;\\n        this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff;\\n        off += 24;\\n        if (off >= 26) {\\n          off -= 26;\\n          j++;\\n        }\\n      }\\n    } else if (endian === 'le') {\\n      for (i = 0, j = 0; i < number.length; i += 3) {\\n        w = number[i] | (number[i + 1] << 8) | (number[i + 2] << 16);\\n        this.words[j] |= (w << off) & 0x3ffffff;\\n        this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff;\\n        off += 24;\\n        if (off >= 26) {\\n          off -= 26;\\n          j++;\\n        }\\n      }\\n    }\\n    return this._strip();\\n  };\\n\\n  function parseHex4Bits (string, index) {\\n    var c = string.charCodeAt(index);\\n    // '0' - '9'\\n    if (c >= 48 && c <= 57) {\\n      return c - 48;\\n    // 'A' - 'F'\\n    } else if (c >= 65 && c <= 70) {\\n      return c - 55;\\n    // 'a' - 'f'\\n    } else if (c >= 97 && c <= 102) {\\n      return c - 87;\\n    } else {\\n      assert(false, 'Invalid character in ' + string);\\n    }\\n  }\\n\\n  function parseHexByte (string, lowerBound, index) {\\n    var r = parseHex4Bits(string, index);\\n    if (index - 1 >= lowerBound) {\\n      r |= parseHex4Bits(string, index - 1) << 4;\\n    }\\n    return r;\\n  }\\n\\n  BN.prototype._parseHex = function _parseHex (number, start, endian) {\\n    // Create possibly bigger array to ensure that it fits the number\\n    this.length = Math.ceil((number.length - start) / 6);\\n    this.words = new Array(this.length);\\n    for (var i = 0; i < this.length; i++) {\\n      this.words[i] = 0;\\n    }\\n\\n    // 24-bits chunks\\n    var off = 0;\\n    var j = 0;\\n\\n    var w;\\n    if (endian === 'be') {\\n      for (i = number.length - 1; i >= start; i -= 2) {\\n        w = parseHexByte(number, start, i) << off;\\n        this.words[j] |= w & 0x3ffffff;\\n        if (off >= 18) {\\n          off -= 18;\\n          j += 1;\\n          this.words[j] |= w >>> 26;\\n        } else {\\n          off += 8;\\n        }\\n      }\\n    } else {\\n      var parseLength = number.length - start;\\n      for (i = parseLength % 2 === 0 ? start + 1 : start; i < number.length; i += 2) {\\n        w = parseHexByte(number, start, i) << off;\\n        this.words[j] |= w & 0x3ffffff;\\n        if (off >= 18) {\\n          off -= 18;\\n          j += 1;\\n          this.words[j] |= w >>> 26;\\n        } else {\\n          off += 8;\\n        }\\n      }\\n    }\\n\\n    this._strip();\\n  };\\n\\n  function parseBase (str, start, end, mul) {\\n    var r = 0;\\n    var b = 0;\\n    var len = Math.min(str.length, end);\\n    for (var i = start; i < len; i++) {\\n      var c = str.charCodeAt(i) - 48;\\n\\n      r *= mul;\\n\\n      // 'a'\\n      if (c >= 49) {\\n        b = c - 49 + 0xa;\\n\\n      // 'A'\\n      } else if (c >= 17) {\\n        b = c - 17 + 0xa;\\n\\n      // '0' - '9'\\n      } else {\\n        b = c;\\n      }\\n      assert(c >= 0 && b < mul, 'Invalid character');\\n      r += b;\\n    }\\n    return r;\\n  }\\n\\n  BN.prototype._parseBase = function _parseBase (number, base, start) {\\n    // Initialize as zero\\n    this.words = [0];\\n    this.length = 1;\\n\\n    // Find length of limb in base\\n    for (var limbLen = 0, limbPow = 1; limbPow <= 0x3ffffff; limbPow *= base) {\\n      limbLen++;\\n    }\\n    limbLen--;\\n    limbPow = (limbPow / base) | 0;\\n\\n    var total = number.length - start;\\n    var mod = total % limbLen;\\n    var end = Math.min(total, total - mod) + start;\\n\\n    var word = 0;\\n    for (var i = start; i < end; i += limbLen) {\\n      word = parseBase(number, i, i + limbLen, base);\\n\\n      this.imuln(limbPow);\\n      if (this.words[0] + word < 0x4000000) {\\n        this.words[0] += word;\\n      } else {\\n        this._iaddn(word);\\n      }\\n    }\\n\\n    if (mod !== 0) {\\n      var pow = 1;\\n      word = parseBase(number, i, number.length, base);\\n\\n      for (i = 0; i < mod; i++) {\\n        pow *= base;\\n      }\\n\\n      this.imuln(pow);\\n      if (this.words[0] + word < 0x4000000) {\\n        this.words[0] += word;\\n      } else {\\n        this._iaddn(word);\\n      }\\n    }\\n\\n    this._strip();\\n  };\\n\\n  BN.prototype.copy = function copy (dest) {\\n    dest.words = new Array(this.length);\\n    for (var i = 0; i < this.length; i++) {\\n      dest.words[i] = this.words[i];\\n    }\\n    dest.length = this.length;\\n    dest.negative = this.negative;\\n    dest.red = this.red;\\n  };\\n\\n  function move (dest, src) {\\n    dest.words = src.words;\\n    dest.length = src.length;\\n    dest.negative = src.negative;\\n    dest.red = src.red;\\n  }\\n\\n  BN.prototype._move = function _move (dest) {\\n    move(dest, this);\\n  };\\n\\n  BN.prototype.clone = function clone () {\\n    var r = new BN(null);\\n    this.copy(r);\\n    return r;\\n  };\\n\\n  BN.prototype._expand = function _expand (size) {\\n    while (this.length < size) {\\n      this.words[this.length++] = 0;\\n    }\\n    return this;\\n  };\\n\\n  // Remove leading `0` from `this`\\n  BN.prototype._strip = function strip () {\\n    while (this.length > 1 && this.words[this.length - 1] === 0) {\\n      this.length--;\\n    }\\n    return this._normSign();\\n  };\\n\\n  BN.prototype._normSign = function _normSign () {\\n    // -0 = 0\\n    if (this.length === 1 && this.words[0] === 0) {\\n      this.negative = 0;\\n    }\\n    return this;\\n  };\\n\\n  // Check Symbol.for because not everywhere where Symbol defined\\n  // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol#Browser_compatibility\\n  if (typeof Symbol !== 'undefined' && typeof Symbol.for === 'function') {\\n    try {\\n      BN.prototype[Symbol.for('nodejs.util.inspect.custom')] = inspect;\\n    } catch (e) {\\n      BN.prototype.inspect = inspect;\\n    }\\n  } else {\\n    BN.prototype.inspect = inspect;\\n  }\\n\\n  function inspect () {\\n    return (this.red ? '<BN-R: ' : '<BN: ') + this.toString(16) + '>';\\n  }\\n\\n  /*\\n\\n  var zeros = [];\\n  var groupSizes = [];\\n  var groupBases = [];\\n\\n  var s = '';\\n  var i = -1;\\n  while (++i < BN.wordSize) {\\n    zeros[i] = s;\\n    s += '0';\\n  }\\n  groupSizes[0] = 0;\\n  groupSizes[1] = 0;\\n  groupBases[0] = 0;\\n  groupBases[1] = 0;\\n  var base = 2 - 1;\\n  while (++base < 36 + 1) {\\n    var groupSize = 0;\\n    var groupBase = 1;\\n    while (groupBase < (1 << BN.wordSize) / base) {\\n      groupBase *= base;\\n      groupSize += 1;\\n    }\\n    groupSizes[base] = groupSize;\\n    groupBases[base] = groupBase;\\n  }\\n\\n  */\\n\\n  var zeros = [\\n    '',\\n    '0',\\n    '00',\\n    '000',\\n    '0000',\\n    '00000',\\n    '000000',\\n    '0000000',\\n    '00000000',\\n    '000000000',\\n    '0000000000',\\n    '00000000000',\\n    '000000000000',\\n    '0000000000000',\\n    '00000000000000',\\n    '000000000000000',\\n    '0000000000000000',\\n    '00000000000000000',\\n    '000000000000000000',\\n    '0000000000000000000',\\n    '00000000000000000000',\\n    '000000000000000000000',\\n    '0000000000000000000000',\\n    '00000000000000000000000',\\n    '000000000000000000000000',\\n    '0000000000000000000000000'\\n  ];\\n\\n  var groupSizes = [\\n    0, 0,\\n    25, 16, 12, 11, 10, 9, 8,\\n    8, 7, 7, 7, 7, 6, 6,\\n    6, 6, 6, 6, 6, 5, 5,\\n    5, 5, 5, 5, 5, 5, 5,\\n    5, 5, 5, 5, 5, 5, 5\\n  ];\\n\\n  var groupBases = [\\n    0, 0,\\n    33554432, 43046721, 16777216, 48828125, 60466176, 40353607, 16777216,\\n    43046721, 10000000, 19487171, 35831808, 62748517, 7529536, 11390625,\\n    16777216, 24137569, 34012224, 47045881, 64000000, 4084101, 5153632,\\n    6436343, 7962624, 9765625, 11881376, 14348907, 17210368, 20511149,\\n    24300000, 28629151, 33554432, 39135393, 45435424, 52521875, 60466176\\n  ];\\n\\n  BN.prototype.toString = function toString (base, padding) {\\n    base = base || 10;\\n    padding = padding | 0 || 1;\\n\\n    var out;\\n    if (base === 16 || base === 'hex') {\\n      out = '';\\n      var off = 0;\\n      var carry = 0;\\n      for (var i = 0; i < this.length; i++) {\\n        var w = this.words[i];\\n        var word = (((w << off) | carry) & 0xffffff).toString(16);\\n        carry = (w >>> (24 - off)) & 0xffffff;\\n        off += 2;\\n        if (off >= 26) {\\n          off -= 26;\\n          i--;\\n        }\\n        if (carry !== 0 || i !== this.length - 1) {\\n          out = zeros[6 - word.length] + word + out;\\n        } else {\\n          out = word + out;\\n        }\\n      }\\n      if (carry !== 0) {\\n        out = carry.toString(16) + out;\\n      }\\n      while (out.length % padding !== 0) {\\n        out = '0' + out;\\n      }\\n      if (this.negative !== 0) {\\n        out = '-' + out;\\n      }\\n      return out;\\n    }\\n\\n    if (base === (base | 0) && base >= 2 && base <= 36) {\\n      // var groupSize = Math.floor(BN.wordSize * Math.LN2 / Math.log(base));\\n      var groupSize = groupSizes[base];\\n      // var groupBase = Math.pow(base, groupSize);\\n      var groupBase = groupBases[base];\\n      out = '';\\n      var c = this.clone();\\n      c.negative = 0;\\n      while (!c.isZero()) {\\n        var r = c.modrn(groupBase).toString(base);\\n        c = c.idivn(groupBase);\\n\\n        if (!c.isZero()) {\\n          out = zeros[groupSize - r.length] + r + out;\\n        } else {\\n          out = r + out;\\n        }\\n      }\\n      if (this.isZero()) {\\n        out = '0' + out;\\n      }\\n      while (out.length % padding !== 0) {\\n        out = '0' + out;\\n      }\\n      if (this.negative !== 0) {\\n        out = '-' + out;\\n      }\\n      return out;\\n    }\\n\\n    assert(false, 'Base should be between 2 and 36');\\n  };\\n\\n  BN.prototype.toNumber = function toNumber () {\\n    var ret = this.words[0];\\n    if (this.length === 2) {\\n      ret += this.words[1] * 0x4000000;\\n    } else if (this.length === 3 && this.words[2] === 0x01) {\\n      // NOTE: at this stage it is known that the top bit is set\\n      ret += 0x10000000000000 + (this.words[1] * 0x4000000);\\n    } else if (this.length > 2) {\\n      assert(false, 'Number can only safely store up to 53 bits');\\n    }\\n    return (this.negative !== 0) ? -ret : ret;\\n  };\\n\\n  BN.prototype.toJSON = function toJSON () {\\n    return this.toString(16, 2);\\n  };\\n\\n  if (Buffer) {\\n    BN.prototype.toBuffer = function toBuffer (endian, length) {\\n      return this.toArrayLike(Buffer, endian, length);\\n    };\\n  }\\n\\n  BN.prototype.toArray = function toArray (endian, length) {\\n    return this.toArrayLike(Array, endian, length);\\n  };\\n\\n  var allocate = function allocate (ArrayType, size) {\\n    if (ArrayType.allocUnsafe) {\\n      return ArrayType.allocUnsafe(size);\\n    }\\n    return new ArrayType(size);\\n  };\\n\\n  BN.prototype.toArrayLike = function toArrayLike (ArrayType, endian, length) {\\n    this._strip();\\n\\n    var byteLength = this.byteLength();\\n    var reqLength = length || Math.max(1, byteLength);\\n    assert(byteLength <= reqLength, 'byte array longer than desired length');\\n    assert(reqLength > 0, 'Requested array length <= 0');\\n\\n    var res = allocate(ArrayType, reqLength);\\n    var postfix = endian === 'le' ? 'LE' : 'BE';\\n    this['_toArrayLike' + postfix](res, byteLength);\\n    return res;\\n  };\\n\\n  BN.prototype._toArrayLikeLE = function _toArrayLikeLE (res, byteLength) {\\n    var position = 0;\\n    var carry = 0;\\n\\n    for (var i = 0, shift = 0; i < this.length; i++) {\\n      var word = (this.words[i] << shift) | carry;\\n\\n      res[position++] = word & 0xff;\\n      if (position < res.length) {\\n        res[position++] = (word >> 8) & 0xff;\\n      }\\n      if (position < res.length) {\\n        res[position++] = (word >> 16) & 0xff;\\n      }\\n\\n      if (shift === 6) {\\n        if (position < res.length) {\\n          res[position++] = (word >> 24) & 0xff;\\n        }\\n        carry = 0;\\n        shift = 0;\\n      } else {\\n        carry = word >>> 24;\\n        shift += 2;\\n      }\\n    }\\n\\n    if (position < res.length) {\\n      res[position++] = carry;\\n\\n      while (position < res.length) {\\n        res[position++] = 0;\\n      }\\n    }\\n  };\\n\\n  BN.prototype._toArrayLikeBE = function _toArrayLikeBE (res, byteLength) {\\n    var position = res.length - 1;\\n    var carry = 0;\\n\\n    for (var i = 0, shift = 0; i < this.length; i++) {\\n      var word = (this.words[i] << shift) | carry;\\n\\n      res[position--] = word & 0xff;\\n      if (position >= 0) {\\n        res[position--] = (word >> 8) & 0xff;\\n      }\\n      if (position >= 0) {\\n        res[position--] = (word >> 16) & 0xff;\\n      }\\n\\n      if (shift === 6) {\\n        if (position >= 0) {\\n          res[position--] = (word >> 24) & 0xff;\\n        }\\n        carry = 0;\\n        shift = 0;\\n      } else {\\n        carry = word >>> 24;\\n        shift += 2;\\n      }\\n    }\\n\\n    if (position >= 0) {\\n      res[position--] = carry;\\n\\n      while (position >= 0) {\\n        res[position--] = 0;\\n      }\\n    }\\n  };\\n\\n  if (Math.clz32) {\\n    BN.prototype._countBits = function _countBits (w) {\\n      return 32 - Math.clz32(w);\\n    };\\n  } else {\\n    BN.prototype._countBits = function _countBits (w) {\\n      var t = w;\\n      var r = 0;\\n      if (t >= 0x1000) {\\n        r += 13;\\n        t >>>= 13;\\n      }\\n      if (t >= 0x40) {\\n        r += 7;\\n        t >>>= 7;\\n      }\\n      if (t >= 0x8) {\\n        r += 4;\\n        t >>>= 4;\\n      }\\n      if (t >= 0x02) {\\n        r += 2;\\n        t >>>= 2;\\n      }\\n      return r + t;\\n    };\\n  }\\n\\n  BN.prototype._zeroBits = function _zeroBits (w) {\\n    // Short-cut\\n    if (w === 0) return 26;\\n\\n    var t = w;\\n    var r = 0;\\n    if ((t & 0x1fff) === 0) {\\n      r += 13;\\n      t >>>= 13;\\n    }\\n    if ((t & 0x7f) === 0) {\\n      r += 7;\\n      t >>>= 7;\\n    }\\n    if ((t & 0xf) === 0) {\\n      r += 4;\\n      t >>>= 4;\\n    }\\n    if ((t & 0x3) === 0) {\\n      r += 2;\\n      t >>>= 2;\\n    }\\n    if ((t & 0x1) === 0) {\\n      r++;\\n    }\\n    return r;\\n  };\\n\\n  // Return number of used bits in a BN\\n  BN.prototype.bitLength = function bitLength () {\\n    var w = this.words[this.length - 1];\\n    var hi = this._countBits(w);\\n    return (this.length - 1) * 26 + hi;\\n  };\\n\\n  function toBitArray (num) {\\n    var w = new Array(num.bitLength());\\n\\n    for (var bit = 0; bit < w.length; bit++) {\\n      var off = (bit / 26) | 0;\\n      var wbit = bit % 26;\\n\\n      w[bit] = (num.words[off] >>> wbit) & 0x01;\\n    }\\n\\n    return w;\\n  }\\n\\n  // Number of trailing zero bits\\n  BN.prototype.zeroBits = function zeroBits () {\\n    if (this.isZero()) return 0;\\n\\n    var r = 0;\\n    for (var i = 0; i < this.length; i++) {\\n      var b = this._zeroBits(this.words[i]);\\n      r += b;\\n      if (b !== 26) break;\\n    }\\n    return r;\\n  };\\n\\n  BN.prototype.byteLength = function byteLength () {\\n    return Math.ceil(this.bitLength() / 8);\\n  };\\n\\n  BN.prototype.toTwos = function toTwos (width) {\\n    if (this.negative !== 0) {\\n      return this.abs().inotn(width).iaddn(1);\\n    }\\n    return this.clone();\\n  };\\n\\n  BN.prototype.fromTwos = function fromTwos (width) {\\n    if (this.testn(width - 1)) {\\n      return this.notn(width).iaddn(1).ineg();\\n    }\\n    return this.clone();\\n  };\\n\\n  BN.prototype.isNeg = function isNeg () {\\n    return this.negative !== 0;\\n  };\\n\\n  // Return negative clone of `this`\\n  BN.prototype.neg = function neg () {\\n    return this.clone().ineg();\\n  };\\n\\n  BN.prototype.ineg = function ineg () {\\n    if (!this.isZero()) {\\n      this.negative ^= 1;\\n    }\\n\\n    return this;\\n  };\\n\\n  // Or `num` with `this` in-place\\n  BN.prototype.iuor = function iuor (num) {\\n    while (this.length < num.length) {\\n      this.words[this.length++] = 0;\\n    }\\n\\n    for (var i = 0; i < num.length; i++) {\\n      this.words[i] = this.words[i] | num.words[i];\\n    }\\n\\n    return this._strip();\\n  };\\n\\n  BN.prototype.ior = function ior (num) {\\n    assert((this.negative | num.negative) === 0);\\n    return this.iuor(num);\\n  };\\n\\n  // Or `num` with `this`\\n  BN.prototype.or = function or (num) {\\n    if (this.length > num.length) return this.clone().ior(num);\\n    return num.clone().ior(this);\\n  };\\n\\n  BN.prototype.uor = function uor (num) {\\n    if (this.length > num.length) return this.clone().iuor(num);\\n    return num.clone().iuor(this);\\n  };\\n\\n  // And `num` with `this` in-place\\n  BN.prototype.iuand = function iuand (num) {\\n    // b = min-length(num, this)\\n    var b;\\n    if (this.length > num.length) {\\n      b = num;\\n    } else {\\n      b = this;\\n    }\\n\\n    for (var i = 0; i < b.length; i++) {\\n      this.words[i] = this.words[i] & num.words[i];\\n    }\\n\\n    this.length = b.length;\\n\\n    return this._strip();\\n  };\\n\\n  BN.prototype.iand = function iand (num) {\\n    assert((this.negative | num.negative) === 0);\\n    return this.iuand(num);\\n  };\\n\\n  // And `num` with `this`\\n  BN.prototype.and = function and (num) {\\n    if (this.length > num.length) return this.clone().iand(num);\\n    return num.clone().iand(this);\\n  };\\n\\n  BN.prototype.uand = function uand (num) {\\n    if (this.length > num.length) return this.clone().iuand(num);\\n    return num.clone().iuand(this);\\n  };\\n\\n  // Xor `num` with `this` in-place\\n  BN.prototype.iuxor = function iuxor (num) {\\n    // a.length > b.length\\n    var a;\\n    var b;\\n    if (this.length > num.length) {\\n      a = this;\\n      b = num;\\n    } else {\\n      a = num;\\n      b = this;\\n    }\\n\\n    for (var i = 0; i < b.length; i++) {\\n      this.words[i] = a.words[i] ^ b.words[i];\\n    }\\n\\n    if (this !== a) {\\n      for (; i < a.length; i++) {\\n        this.words[i] = a.words[i];\\n      }\\n    }\\n\\n    this.length = a.length;\\n\\n    return this._strip();\\n  };\\n\\n  BN.prototype.ixor = function ixor (num) {\\n    assert((this.negative | num.negative) === 0);\\n    return this.iuxor(num);\\n  };\\n\\n  // Xor `num` with `this`\\n  BN.prototype.xor = function xor (num) {\\n    if (this.length > num.length) return this.clone().ixor(num);\\n    return num.clone().ixor(this);\\n  };\\n\\n  BN.prototype.uxor = function uxor (num) {\\n    if (this.length > num.length) return this.clone().iuxor(num);\\n    return num.clone().iuxor(this);\\n  };\\n\\n  // Not ``this`` with ``width`` bitwidth\\n  BN.prototype.inotn = function inotn (width) {\\n    assert(typeof width === 'number' && width >= 0);\\n\\n    var bytesNeeded = Math.ceil(width / 26) | 0;\\n    var bitsLeft = width % 26;\\n\\n    // Extend the buffer with leading zeroes\\n    this._expand(bytesNeeded);\\n\\n    if (bitsLeft > 0) {\\n      bytesNeeded--;\\n    }\\n\\n    // Handle complete words\\n    for (var i = 0; i < bytesNeeded; i++) {\\n      this.words[i] = ~this.words[i] & 0x3ffffff;\\n    }\\n\\n    // Handle the residue\\n    if (bitsLeft > 0) {\\n      this.words[i] = ~this.words[i] & (0x3ffffff >> (26 - bitsLeft));\\n    }\\n\\n    // And remove leading zeroes\\n    return this._strip();\\n  };\\n\\n  BN.prototype.notn = function notn (width) {\\n    return this.clone().inotn(width);\\n  };\\n\\n  // Set `bit` of `this`\\n  BN.prototype.setn = function setn (bit, val) {\\n    assert(typeof bit === 'number' && bit >= 0);\\n\\n    var off = (bit / 26) | 0;\\n    var wbit = bit % 26;\\n\\n    this._expand(off + 1);\\n\\n    if (val) {\\n      this.words[off] = this.words[off] | (1 << wbit);\\n    } else {\\n      this.words[off] = this.words[off] & ~(1 << wbit);\\n    }\\n\\n    return this._strip();\\n  };\\n\\n  // Add `num` to `this` in-place\\n  BN.prototype.iadd = function iadd (num) {\\n    var r;\\n\\n    // negative + positive\\n    if (this.negative !== 0 && num.negative === 0) {\\n      this.negative = 0;\\n      r = this.isub(num);\\n      this.negative ^= 1;\\n      return this._normSign();\\n\\n    // positive + negative\\n    } else if (this.negative === 0 && num.negative !== 0) {\\n      num.negative = 0;\\n      r = this.isub(num);\\n      num.negative = 1;\\n      return r._normSign();\\n    }\\n\\n    // a.length > b.length\\n    var a, b;\\n    if (this.length > num.length) {\\n      a = this;\\n      b = num;\\n    } else {\\n      a = num;\\n      b = this;\\n    }\\n\\n    var carry = 0;\\n    for (var i = 0; i < b.length; i++) {\\n      r = (a.words[i] | 0) + (b.words[i] | 0) + carry;\\n      this.words[i] = r & 0x3ffffff;\\n      carry = r >>> 26;\\n    }\\n    for (; carry !== 0 && i < a.length; i++) {\\n      r = (a.words[i] | 0) + carry;\\n      this.words[i] = r & 0x3ffffff;\\n      carry = r >>> 26;\\n    }\\n\\n    this.length = a.length;\\n    if (carry !== 0) {\\n      this.words[this.length] = carry;\\n      this.length++;\\n    // Copy the rest of the words\\n    } else if (a !== this) {\\n      for (; i < a.length; i++) {\\n        this.words[i] = a.words[i];\\n      }\\n    }\\n\\n    return this;\\n  };\\n\\n  // Add `num` to `this`\\n  BN.prototype.add = function add (num) {\\n    var res;\\n    if (num.negative !== 0 && this.negative === 0) {\\n      num.negative = 0;\\n      res = this.sub(num);\\n      num.negative ^= 1;\\n      return res;\\n    } else if (num.negative === 0 && this.negative !== 0) {\\n      this.negative = 0;\\n      res = num.sub(this);\\n      this.negative = 1;\\n      return res;\\n    }\\n\\n    if (this.length > num.length) return this.clone().iadd(num);\\n\\n    return num.clone().iadd(this);\\n  };\\n\\n  // Subtract `num` from `this` in-place\\n  BN.prototype.isub = function isub (num) {\\n    // this - (-num) = this + num\\n    if (num.negative !== 0) {\\n      num.negative = 0;\\n      var r = this.iadd(num);\\n      num.negative = 1;\\n      return r._normSign();\\n\\n    // -this - num = -(this + num)\\n    } else if (this.negative !== 0) {\\n      this.negative = 0;\\n      this.iadd(num);\\n      this.negative = 1;\\n      return this._normSign();\\n    }\\n\\n    // At this point both numbers are positive\\n    var cmp = this.cmp(num);\\n\\n    // Optimization - zeroify\\n    if (cmp === 0) {\\n      this.negative = 0;\\n      this.length = 1;\\n      this.words[0] = 0;\\n      return this;\\n    }\\n\\n    // a > b\\n    var a, b;\\n    if (cmp > 0) {\\n      a = this;\\n      b = num;\\n    } else {\\n      a = num;\\n      b = this;\\n    }\\n\\n    var carry = 0;\\n    for (var i = 0; i < b.length; i++) {\\n      r = (a.words[i] | 0) - (b.words[i] | 0) + carry;\\n      carry = r >> 26;\\n      this.words[i] = r & 0x3ffffff;\\n    }\\n    for (; carry !== 0 && i < a.length; i++) {\\n      r = (a.words[i] | 0) + carry;\\n      carry = r >> 26;\\n      this.words[i] = r & 0x3ffffff;\\n    }\\n\\n    // Copy rest of the words\\n    if (carry === 0 && i < a.length && a !== this) {\\n      for (; i < a.length; i++) {\\n        this.words[i] = a.words[i];\\n      }\\n    }\\n\\n    this.length = Math.max(this.length, i);\\n\\n    if (a !== this) {\\n      this.negative = 1;\\n    }\\n\\n    return this._strip();\\n  };\\n\\n  // Subtract `num` from `this`\\n  BN.prototype.sub = function sub (num) {\\n    return this.clone().isub(num);\\n  };\\n\\n  function smallMulTo (self, num, out) {\\n    out.negative = num.negative ^ self.negative;\\n    var len = (self.length + num.length) | 0;\\n    out.length = len;\\n    len = (len - 1) | 0;\\n\\n    // Peel one iteration (compiler can't do it, because of code complexity)\\n    var a = self.words[0] | 0;\\n    var b = num.words[0] | 0;\\n    var r = a * b;\\n\\n    var lo = r & 0x3ffffff;\\n    var carry = (r / 0x4000000) | 0;\\n    out.words[0] = lo;\\n\\n    for (var k = 1; k < len; k++) {\\n      // Sum all words with the same `i + j = k` and accumulate `ncarry`,\\n      // note that ncarry could be >= 0x3ffffff\\n      var ncarry = carry >>> 26;\\n      var rword = carry & 0x3ffffff;\\n      var maxJ = Math.min(k, num.length - 1);\\n      for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {\\n        var i = (k - j) | 0;\\n        a = self.words[i] | 0;\\n        b = num.words[j] | 0;\\n        r = a * b + rword;\\n        ncarry += (r / 0x4000000) | 0;\\n        rword = r & 0x3ffffff;\\n      }\\n      out.words[k] = rword | 0;\\n      carry = ncarry | 0;\\n    }\\n    if (carry !== 0) {\\n      out.words[k] = carry | 0;\\n    } else {\\n      out.length--;\\n    }\\n\\n    return out._strip();\\n  }\\n\\n  // TODO(indutny): it may be reasonable to omit it for users who don't need\\n  // to work with 256-bit numbers, otherwise it gives 20% improvement for 256-bit\\n  // multiplication (like elliptic secp256k1).\\n  var comb10MulTo = function comb10MulTo (self, num, out) {\\n    var a = self.words;\\n    var b = num.words;\\n    var o = out.words;\\n    var c = 0;\\n    var lo;\\n    var mid;\\n    var hi;\\n    var a0 = a[0] | 0;\\n    var al0 = a0 & 0x1fff;\\n    var ah0 = a0 >>> 13;\\n    var a1 = a[1] | 0;\\n    var al1 = a1 & 0x1fff;\\n    var ah1 = a1 >>> 13;\\n    var a2 = a[2] | 0;\\n    var al2 = a2 & 0x1fff;\\n    var ah2 = a2 >>> 13;\\n    var a3 = a[3] | 0;\\n    var al3 = a3 & 0x1fff;\\n    var ah3 = a3 >>> 13;\\n    var a4 = a[4] | 0;\\n    var al4 = a4 & 0x1fff;\\n    var ah4 = a4 >>> 13;\\n    var a5 = a[5] | 0;\\n    var al5 = a5 & 0x1fff;\\n    var ah5 = a5 >>> 13;\\n    var a6 = a[6] | 0;\\n    var al6 = a6 & 0x1fff;\\n    var ah6 = a6 >>> 13;\\n    var a7 = a[7] | 0;\\n    var al7 = a7 & 0x1fff;\\n    var ah7 = a7 >>> 13;\\n    var a8 = a[8] | 0;\\n    var al8 = a8 & 0x1fff;\\n    var ah8 = a8 >>> 13;\\n    var a9 = a[9] | 0;\\n    var al9 = a9 & 0x1fff;\\n    var ah9 = a9 >>> 13;\\n    var b0 = b[0] | 0;\\n    var bl0 = b0 & 0x1fff;\\n    var bh0 = b0 >>> 13;\\n    var b1 = b[1] | 0;\\n    var bl1 = b1 & 0x1fff;\\n    var bh1 = b1 >>> 13;\\n    var b2 = b[2] | 0;\\n    var bl2 = b2 & 0x1fff;\\n    var bh2 = b2 >>> 13;\\n    var b3 = b[3] | 0;\\n    var bl3 = b3 & 0x1fff;\\n    var bh3 = b3 >>> 13;\\n    var b4 = b[4] | 0;\\n    var bl4 = b4 & 0x1fff;\\n    var bh4 = b4 >>> 13;\\n    var b5 = b[5] | 0;\\n    var bl5 = b5 & 0x1fff;\\n    var bh5 = b5 >>> 13;\\n    var b6 = b[6] | 0;\\n    var bl6 = b6 & 0x1fff;\\n    var bh6 = b6 >>> 13;\\n    var b7 = b[7] | 0;\\n    var bl7 = b7 & 0x1fff;\\n    var bh7 = b7 >>> 13;\\n    var b8 = b[8] | 0;\\n    var bl8 = b8 & 0x1fff;\\n    var bh8 = b8 >>> 13;\\n    var b9 = b[9] | 0;\\n    var bl9 = b9 & 0x1fff;\\n    var bh9 = b9 >>> 13;\\n\\n    out.negative = self.negative ^ num.negative;\\n    out.length = 19;\\n    /* k = 0 */\\n    lo = Math.imul(al0, bl0);\\n    mid = Math.imul(al0, bh0);\\n    mid = (mid + Math.imul(ah0, bl0)) | 0;\\n    hi = Math.imul(ah0, bh0);\\n    var w0 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\\n    c = (((hi + (mid >>> 13)) | 0) + (w0 >>> 26)) | 0;\\n    w0 &= 0x3ffffff;\\n    /* k = 1 */\\n    lo = Math.imul(al1, bl0);\\n    mid = Math.imul(al1, bh0);\\n    mid = (mid + Math.imul(ah1, bl0)) | 0;\\n    hi = Math.imul(ah1, bh0);\\n    lo = (lo + Math.imul(al0, bl1)) | 0;\\n    mid = (mid + Math.imul(al0, bh1)) | 0;\\n    mid = (mid + Math.imul(ah0, bl1)) | 0;\\n    hi = (hi + Math.imul(ah0, bh1)) | 0;\\n    var w1 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\\n    c = (((hi + (mid >>> 13)) | 0) + (w1 >>> 26)) | 0;\\n    w1 &= 0x3ffffff;\\n    /* k = 2 */\\n    lo = Math.imul(al2, bl0);\\n    mid = Math.imul(al2, bh0);\\n    mid = (mid + Math.imul(ah2, bl0)) | 0;\\n    hi = Math.imul(ah2, bh0);\\n    lo = (lo + Math.imul(al1, bl1)) | 0;\\n    mid = (mid + Math.imul(al1, bh1)) | 0;\\n    mid = (mid + Math.imul(ah1, bl1)) | 0;\\n    hi = (hi + Math.imul(ah1, bh1)) | 0;\\n    lo = (lo + Math.imul(al0, bl2)) | 0;\\n    mid = (mid + Math.imul(al0, bh2)) | 0;\\n    mid = (mid + Math.imul(ah0, bl2)) | 0;\\n    hi = (hi + Math.imul(ah0, bh2)) | 0;\\n    var w2 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\\n    c = (((hi + (mid >>> 13)) | 0) + (w2 >>> 26)) | 0;\\n    w2 &= 0x3ffffff;\\n    /* k = 3 */\\n    lo = Math.imul(al3, bl0);\\n    mid = Math.imul(al3, bh0);\\n    mid = (mid + Math.imul(ah3, bl0)) | 0;\\n    hi = Math.imul(ah3, bh0);\\n    lo = (lo + Math.imul(al2, bl1)) | 0;\\n    mid = (mid + Math.imul(al2, bh1)) | 0;\\n    mid = (mid + Math.imul(ah2, bl1)) | 0;\\n    hi = (hi + Math.imul(ah2, bh1)) | 0;\\n    lo = (lo + Math.imul(al1, bl2)) | 0;\\n    mid = (mid + Math.imul(al1, bh2)) | 0;\\n    mid = (mid + Math.imul(ah1, bl2)) | 0;\\n    hi = (hi + Math.imul(ah1, bh2)) | 0;\\n    lo = (lo + Math.imul(al0, bl3)) | 0;\\n    mid = (mid + Math.imul(al0, bh3)) | 0;\\n    mid = (mid + Math.imul(ah0, bl3)) | 0;\\n    hi = (hi + Math.imul(ah0, bh3)) | 0;\\n    var w3 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\\n    c = (((hi + (mid >>> 13)) | 0) + (w3 >>> 26)) | 0;\\n    w3 &= 0x3ffffff;\\n    /* k = 4 */\\n    lo = Math.imul(al4, bl0);\\n    mid = Math.imul(al4, bh0);\\n    mid = (mid + Math.imul(ah4, bl0)) | 0;\\n    hi = Math.imul(ah4, bh0);\\n    lo = (lo + Math.imul(al3, bl1)) | 0;\\n    mid = (mid + Math.imul(al3, bh1)) | 0;\\n    mid = (mid + Math.imul(ah3, bl1)) | 0;\\n    hi = (hi + Math.imul(ah3, bh1)) | 0;\\n    lo = (lo + Math.imul(al2, bl2)) | 0;\\n    mid = (mid + Math.imul(al2, bh2)) | 0;\\n    mid = (mid + Math.imul(ah2, bl2)) | 0;\\n    hi = (hi + Math.imul(ah2, bh2)) | 0;\\n    lo = (lo + Math.imul(al1, bl3)) | 0;\\n    mid = (mid + Math.imul(al1, bh3)) | 0;\\n    mid = (mid + Math.imul(ah1, bl3)) | 0;\\n    hi = (hi + Math.imul(ah1, bh3)) | 0;\\n    lo = (lo + Math.imul(al0, bl4)) | 0;\\n    mid = (mid + Math.imul(al0, bh4)) | 0;\\n    mid = (mid + Math.imul(ah0, bl4)) | 0;\\n    hi = (hi + Math.imul(ah0, bh4)) | 0;\\n    var w4 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\\n    c = (((hi + (mid >>> 13)) | 0) + (w4 >>> 26)) | 0;\\n    w4 &= 0x3ffffff;\\n    /* k = 5 */\\n    lo = Math.imul(al5, bl0);\\n    mid = Math.imul(al5, bh0);\\n    mid = (mid + Math.imul(ah5, bl0)) | 0;\\n    hi = Math.imul(ah5, bh0);\\n    lo = (lo + Math.imul(al4, bl1)) | 0;\\n    mid = (mid + Math.imul(al4, bh1)) | 0;\\n    mid = (mid + Math.imul(ah4, bl1)) | 0;\\n    hi = (hi + Math.imul(ah4, bh1)) | 0;\\n    lo = (lo + Math.imul(al3, bl2)) | 0;\\n    mid = (mid + Math.imul(al3, bh2)) | 0;\\n    mid = (mid + Math.imul(ah3, bl2)) | 0;\\n    hi = (hi + Math.imul(ah3, bh2)) | 0;\\n    lo = (lo + Math.imul(al2, bl3)) | 0;\\n    mid = (mid + Math.imul(al2, bh3)) | 0;\\n    mid = (mid + Math.imul(ah2, bl3)) | 0;\\n    hi = (hi + Math.imul(ah2, bh3)) | 0;\\n    lo = (lo + Math.imul(al1, bl4)) | 0;\\n    mid = (mid + Math.imul(al1, bh4)) | 0;\\n    mid = (mid + Math.imul(ah1, bl4)) | 0;\\n    hi = (hi + Math.imul(ah1, bh4)) | 0;\\n    lo = (lo + Math.imul(al0, bl5)) | 0;\\n    mid = (mid + Math.imul(al0, bh5)) | 0;\\n    mid = (mid + Math.imul(ah0, bl5)) | 0;\\n    hi = (hi + Math.imul(ah0, bh5)) | 0;\\n    var w5 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\\n    c = (((hi + (mid >>> 13)) | 0) + (w5 >>> 26)) | 0;\\n    w5 &= 0x3ffffff;\\n    /* k = 6 */\\n    lo = Math.imul(al6, bl0);\\n    mid = Math.imul(al6, bh0);\\n    mid = (mid + Math.imul(ah6, bl0)) | 0;\\n    hi = Math.imul(ah6, bh0);\\n    lo = (lo + Math.imul(al5, bl1)) | 0;\\n    mid = (mid + Math.imul(al5, bh1)) | 0;\\n    mid = (mid + Math.imul(ah5, bl1)) | 0;\\n    hi = (hi + Math.imul(ah5, bh1)) | 0;\\n    lo = (lo + Math.imul(al4, bl2)) | 0;\\n    mid = (mid + Math.imul(al4, bh2)) | 0;\\n    mid = (mid + Math.imul(ah4, bl2)) | 0;\\n    hi = (hi + Math.imul(ah4, bh2)) | 0;\\n    lo = (lo + Math.imul(al3, bl3)) | 0;\\n    mid = (mid + Math.imul(al3, bh3)) | 0;\\n    mid = (mid + Math.imul(ah3, bl3)) | 0;\\n    hi = (hi + Math.imul(ah3, bh3)) | 0;\\n    lo = (lo + Math.imul(al2, bl4)) | 0;\\n    mid = (mid + Math.imul(al2, bh4)) | 0;\\n    mid = (mid + Math.imul(ah2, bl4)) | 0;\\n    hi = (hi + Math.imul(ah2, bh4)) | 0;\\n    lo = (lo + Math.imul(al1, bl5)) | 0;\\n    mid = (mid + Math.imul(al1, bh5)) | 0;\\n    mid = (mid + Math.imul(ah1, bl5)) | 0;\\n    hi = (hi + Math.imul(ah1, bh5)) | 0;\\n    lo = (lo + Math.imul(al0, bl6)) | 0;\\n    mid = (mid + Math.imul(al0, bh6)) | 0;\\n    mid = (mid + Math.imul(ah0, bl6)) | 0;\\n    hi = (hi + Math.imul(ah0, bh6)) | 0;\\n    var w6 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\\n    c = (((hi + (mid >>> 13)) | 0) + (w6 >>> 26)) | 0;\\n    w6 &= 0x3ffffff;\\n    /* k = 7 */\\n    lo = Math.imul(al7, bl0);\\n    mid = Math.imul(al7, bh0);\\n    mid = (mid + Math.imul(ah7, bl0)) | 0;\\n    hi = Math.imul(ah7, bh0);\\n    lo = (lo + Math.imul(al6, bl1)) | 0;\\n    mid = (mid + Math.imul(al6, bh1)) | 0;\\n    mid = (mid + Math.imul(ah6, bl1)) | 0;\\n    hi = (hi + Math.imul(ah6, bh1)) | 0;\\n    lo = (lo + Math.imul(al5, bl2)) | 0;\\n    mid = (mid + Math.imul(al5, bh2)) | 0;\\n    mid = (mid + Math.imul(ah5, bl2)) | 0;\\n    hi = (hi + Math.imul(ah5, bh2)) | 0;\\n    lo = (lo + Math.imul(al4, bl3)) | 0;\\n    mid = (mid + Math.imul(al4, bh3)) | 0;\\n    mid = (mid + Math.imul(ah4, bl3)) | 0;\\n    hi = (hi + Math.imul(ah4, bh3)) | 0;\\n    lo = (lo + Math.imul(al3, bl4)) | 0;\\n    mid = (mid + Math.imul(al3, bh4)) | 0;\\n    mid = (mid + Math.imul(ah3, bl4)) | 0;\\n    hi = (hi + Math.imul(ah3, bh4)) | 0;\\n    lo = (lo + Math.imul(al2, bl5)) | 0;\\n    mid = (mid + Math.imul(al2, bh5)) | 0;\\n    mid = (mid + Math.imul(ah2, bl5)) | 0;\\n    hi = (hi + Math.imul(ah2, bh5)) | 0;\\n    lo = (lo + Math.imul(al1, bl6)) | 0;\\n    mid = (mid + Math.imul(al1, bh6)) | 0;\\n    mid = (mid + Math.imul(ah1, bl6)) | 0;\\n    hi = (hi + Math.imul(ah1, bh6)) | 0;\\n    lo = (lo + Math.imul(al0, bl7)) | 0;\\n    mid = (mid + Math.imul(al0, bh7)) | 0;\\n    mid = (mid + Math.imul(ah0, bl7)) | 0;\\n    hi = (hi + Math.imul(ah0, bh7)) | 0;\\n    var w7 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\\n    c = (((hi + (mid >>> 13)) | 0) + (w7 >>> 26)) | 0;\\n    w7 &= 0x3ffffff;\\n    /* k = 8 */\\n    lo = Math.imul(al8, bl0);\\n    mid = Math.imul(al8, bh0);\\n    mid = (mid + Math.imul(ah8, bl0)) | 0;\\n    hi = Math.imul(ah8, bh0);\\n    lo = (lo + Math.imul(al7, bl1)) | 0;\\n    mid = (mid + Math.imul(al7, bh1)) | 0;\\n    mid = (mid + Math.imul(ah7, bl1)) | 0;\\n    hi = (hi + Math.imul(ah7, bh1)) | 0;\\n    lo = (lo + Math.imul(al6, bl2)) | 0;\\n    mid = (mid + Math.imul(al6, bh2)) | 0;\\n    mid = (mid + Math.imul(ah6, bl2)) | 0;\\n    hi = (hi + Math.imul(ah6, bh2)) | 0;\\n    lo = (lo + Math.imul(al5, bl3)) | 0;\\n    mid = (mid + Math.imul(al5, bh3)) | 0;\\n    mid = (mid + Math.imul(ah5, bl3)) | 0;\\n    hi = (hi + Math.imul(ah5, bh3)) | 0;\\n    lo = (lo + Math.imul(al4, bl4)) | 0;\\n    mid = (mid + Math.imul(al4, bh4)) | 0;\\n    mid = (mid + Math.imul(ah4, bl4)) | 0;\\n    hi = (hi + Math.imul(ah4, bh4)) | 0;\\n    lo = (lo + Math.imul(al3, bl5)) | 0;\\n    mid = (mid + Math.imul(al3, bh5)) | 0;\\n    mid = (mid + Math.imul(ah3, bl5)) | 0;\\n    hi = (hi + Math.imul(ah3, bh5)) | 0;\\n    lo = (lo + Math.imul(al2, bl6)) | 0;\\n    mid = (mid + Math.imul(al2, bh6)) | 0;\\n    mid = (mid + Math.imul(ah2, bl6)) | 0;\\n    hi = (hi + Math.imul(ah2, bh6)) | 0;\\n    lo = (lo + Math.imul(al1, bl7)) | 0;\\n    mid = (mid + Math.imul(al1, bh7)) | 0;\\n    mid = (mid + Math.imul(ah1, bl7)) | 0;\\n    hi = (hi + Math.imul(ah1, bh7)) | 0;\\n    lo = (lo + Math.imul(al0, bl8)) | 0;\\n    mid = (mid + Math.imul(al0, bh8)) | 0;\\n    mid = (mid + Math.imul(ah0, bl8)) | 0;\\n    hi = (hi + Math.imul(ah0, bh8)) | 0;\\n    var w8 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\\n    c = (((hi + (mid >>> 13)) | 0) + (w8 >>> 26)) | 0;\\n    w8 &= 0x3ffffff;\\n    /* k = 9 */\\n    lo = Math.imul(al9, bl0);\\n    mid = Math.imul(al9, bh0);\\n    mid = (mid + Math.imul(ah9, bl0)) | 0;\\n    hi = Math.imul(ah9, bh0);\\n    lo = (lo + Math.imul(al8, bl1)) | 0;\\n    mid = (mid + Math.imul(al8, bh1)) | 0;\\n    mid = (mid + Math.imul(ah8, bl1)) | 0;\\n    hi = (hi + Math.imul(ah8, bh1)) | 0;\\n    lo = (lo + Math.imul(al7, bl2)) | 0;\\n    mid = (mid + Math.imul(al7, bh2)) | 0;\\n    mid = (mid + Math.imul(ah7, bl2)) | 0;\\n    hi = (hi + Math.imul(ah7, bh2)) | 0;\\n    lo = (lo + Math.imul(al6, bl3)) | 0;\\n    mid = (mid + Math.imul(al6, bh3)) | 0;\\n    mid = (mid + Math.imul(ah6, bl3)) | 0;\\n    hi = (hi + Math.imul(ah6, bh3)) | 0;\\n    lo = (lo + Math.imul(al5, bl4)) | 0;\\n    mid = (mid + Math.imul(al5, bh4)) | 0;\\n    mid = (mid + Math.imul(ah5, bl4)) | 0;\\n    hi = (hi + Math.imul(ah5, bh4)) | 0;\\n    lo = (lo + Math.imul(al4, bl5)) | 0;\\n    mid = (mid + Math.imul(al4, bh5)) | 0;\\n    mid = (mid + Math.imul(ah4, bl5)) | 0;\\n    hi = (hi + Math.imul(ah4, bh5)) | 0;\\n    lo = (lo + Math.imul(al3, bl6)) | 0;\\n    mid = (mid + Math.imul(al3, bh6)) | 0;\\n    mid = (mid + Math.imul(ah3, bl6)) | 0;\\n    hi = (hi + Math.imul(ah3, bh6)) | 0;\\n    lo = (lo + Math.imul(al2, bl7)) | 0;\\n    mid = (mid + Math.imul(al2, bh7)) | 0;\\n    mid = (mid + Math.imul(ah2, bl7)) | 0;\\n    hi = (hi + Math.imul(ah2, bh7)) | 0;\\n    lo = (lo + Math.imul(al1, bl8)) | 0;\\n    mid = (mid + Math.imul(al1, bh8)) | 0;\\n    mid = (mid + Math.imul(ah1, bl8)) | 0;\\n    hi = (hi + Math.imul(ah1, bh8)) | 0;\\n    lo = (lo + Math.imul(al0, bl9)) | 0;\\n    mid = (mid + Math.imul(al0, bh9)) | 0;\\n    mid = (mid + Math.imul(ah0, bl9)) | 0;\\n    hi = (hi + Math.imul(ah0, bh9)) | 0;\\n    var w9 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\\n    c = (((hi + (mid >>> 13)) | 0) + (w9 >>> 26)) | 0;\\n    w9 &= 0x3ffffff;\\n    /* k = 10 */\\n    lo = Math.imul(al9, bl1);\\n    mid = Math.imul(al9, bh1);\\n    mid = (mid + Math.imul(ah9, bl1)) | 0;\\n    hi = Math.imul(ah9, bh1);\\n    lo = (lo + Math.imul(al8, bl2)) | 0;\\n    mid = (mid + Math.imul(al8, bh2)) | 0;\\n    mid = (mid + Math.imul(ah8, bl2)) | 0;\\n    hi = (hi + Math.imul(ah8, bh2)) | 0;\\n    lo = (lo + Math.imul(al7, bl3)) | 0;\\n    mid = (mid + Math.imul(al7, bh3)) | 0;\\n    mid = (mid + Math.imul(ah7, bl3)) | 0;\\n    hi = (hi + Math.imul(ah7, bh3)) | 0;\\n    lo = (lo + Math.imul(al6, bl4)) | 0;\\n    mid = (mid + Math.imul(al6, bh4)) | 0;\\n    mid = (mid + Math.imul(ah6, bl4)) | 0;\\n    hi = (hi + Math.imul(ah6, bh4)) | 0;\\n    lo = (lo + Math.imul(al5, bl5)) | 0;\\n    mid = (mid + Math.imul(al5, bh5)) | 0;\\n    mid = (mid + Math.imul(ah5, bl5)) | 0;\\n    hi = (hi + Math.imul(ah5, bh5)) | 0;\\n    lo = (lo + Math.imul(al4, bl6)) | 0;\\n    mid = (mid + Math.imul(al4, bh6)) | 0;\\n    mid = (mid + Math.imul(ah4, bl6)) | 0;\\n    hi = (hi + Math.imul(ah4, bh6)) | 0;\\n    lo = (lo + Math.imul(al3, bl7)) | 0;\\n    mid = (mid + Math.imul(al3, bh7)) | 0;\\n    mid = (mid + Math.imul(ah3, bl7)) | 0;\\n    hi = (hi + Math.imul(ah3, bh7)) | 0;\\n    lo = (lo + Math.imul(al2, bl8)) | 0;\\n    mid = (mid + Math.imul(al2, bh8)) | 0;\\n    mid = (mid + Math.imul(ah2, bl8)) | 0;\\n    hi = (hi + Math.imul(ah2, bh8)) | 0;\\n    lo = (lo + Math.imul(al1, bl9)) | 0;\\n    mid = (mid + Math.imul(al1, bh9)) | 0;\\n    mid = (mid + Math.imul(ah1, bl9)) | 0;\\n    hi = (hi + Math.imul(ah1, bh9)) | 0;\\n    var w10 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\\n    c = (((hi + (mid >>> 13)) | 0) + (w10 >>> 26)) | 0;\\n    w10 &= 0x3ffffff;\\n    /* k = 11 */\\n    lo = Math.imul(al9, bl2);\\n    mid = Math.imul(al9, bh2);\\n    mid = (mid + Math.imul(ah9, bl2)) | 0;\\n    hi = Math.imul(ah9, bh2);\\n    lo = (lo + Math.imul(al8, bl3)) | 0;\\n    mid = (mid + Math.imul(al8, bh3)) | 0;\\n    mid = (mid + Math.imul(ah8, bl3)) | 0;\\n    hi = (hi + Math.imul(ah8, bh3)) | 0;\\n    lo = (lo + Math.imul(al7, bl4)) | 0;\\n    mid = (mid + Math.imul(al7, bh4)) | 0;\\n    mid = (mid + Math.imul(ah7, bl4)) | 0;\\n    hi = (hi + Math.imul(ah7, bh4)) | 0;\\n    lo = (lo + Math.imul(al6, bl5)) | 0;\\n    mid = (mid + Math.imul(al6, bh5)) | 0;\\n    mid = (mid + Math.imul(ah6, bl5)) | 0;\\n    hi = (hi + Math.imul(ah6, bh5)) | 0;\\n    lo = (lo + Math.imul(al5, bl6)) | 0;\\n    mid = (mid + Math.imul(al5, bh6)) | 0;\\n    mid = (mid + Math.imul(ah5, bl6)) | 0;\\n    hi = (hi + Math.imul(ah5, bh6)) | 0;\\n    lo = (lo + Math.imul(al4, bl7)) | 0;\\n    mid = (mid + Math.imul(al4, bh7)) | 0;\\n    mid = (mid + Math.imul(ah4, bl7)) | 0;\\n    hi = (hi + Math.imul(ah4, bh7)) | 0;\\n    lo = (lo + Math.imul(al3, bl8)) | 0;\\n    mid = (mid + Math.imul(al3, bh8)) | 0;\\n    mid = (mid + Math.imul(ah3, bl8)) | 0;\\n    hi = (hi + Math.imul(ah3, bh8)) | 0;\\n    lo = (lo + Math.imul(al2, bl9)) | 0;\\n    mid = (mid + Math.imul(al2, bh9)) | 0;\\n    mid = (mid + Math.imul(ah2, bl9)) | 0;\\n    hi = (hi + Math.imul(ah2, bh9)) | 0;\\n    var w11 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\\n    c = (((hi + (mid >>> 13)) | 0) + (w11 >>> 26)) | 0;\\n    w11 &= 0x3ffffff;\\n    /* k = 12 */\\n    lo = Math.imul(al9, bl3);\\n    mid = Math.imul(al9, bh3);\\n    mid = (mid + Math.imul(ah9, bl3)) | 0;\\n    hi = Math.imul(ah9, bh3);\\n    lo = (lo + Math.imul(al8, bl4)) | 0;\\n    mid = (mid + Math.imul(al8, bh4)) | 0;\\n    mid = (mid + Math.imul(ah8, bl4)) | 0;\\n    hi = (hi + Math.imul(ah8, bh4)) | 0;\\n    lo = (lo + Math.imul(al7, bl5)) | 0;\\n    mid = (mid + Math.imul(al7, bh5)) | 0;\\n    mid = (mid + Math.imul(ah7, bl5)) | 0;\\n    hi = (hi + Math.imul(ah7, bh5)) | 0;\\n    lo = (lo + Math.imul(al6, bl6)) | 0;\\n    mid = (mid + Math.imul(al6, bh6)) | 0;\\n    mid = (mid + Math.imul(ah6, bl6)) | 0;\\n    hi = (hi + Math.imul(ah6, bh6)) | 0;\\n    lo = (lo + Math.imul(al5, bl7)) | 0;\\n    mid = (mid + Math.imul(al5, bh7)) | 0;\\n    mid = (mid + Math.imul(ah5, bl7)) | 0;\\n    hi = (hi + Math.imul(ah5, bh7)) | 0;\\n    lo = (lo + Math.imul(al4, bl8)) | 0;\\n    mid = (mid + Math.imul(al4, bh8)) | 0;\\n    mid = (mid + Math.imul(ah4, bl8)) | 0;\\n    hi = (hi + Math.imul(ah4, bh8)) | 0;\\n    lo = (lo + Math.imul(al3, bl9)) | 0;\\n    mid = (mid + Math.imul(al3, bh9)) | 0;\\n    mid = (mid + Math.imul(ah3, bl9)) | 0;\\n    hi = (hi + Math.imul(ah3, bh9)) | 0;\\n    var w12 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\\n    c = (((hi + (mid >>> 13)) | 0) + (w12 >>> 26)) | 0;\\n    w12 &= 0x3ffffff;\\n    /* k = 13 */\\n    lo = Math.imul(al9, bl4);\\n    mid = Math.imul(al9, bh4);\\n    mid = (mid + Math.imul(ah9, bl4)) | 0;\\n    hi = Math.imul(ah9, bh4);\\n    lo = (lo + Math.imul(al8, bl5)) | 0;\\n    mid = (mid + Math.imul(al8, bh5)) | 0;\\n    mid = (mid + Math.imul(ah8, bl5)) | 0;\\n    hi = (hi + Math.imul(ah8, bh5)) | 0;\\n    lo = (lo + Math.imul(al7, bl6)) | 0;\\n    mid = (mid + Math.imul(al7, bh6)) | 0;\\n    mid = (mid + Math.imul(ah7, bl6)) | 0;\\n    hi = (hi + Math.imul(ah7, bh6)) | 0;\\n    lo = (lo + Math.imul(al6, bl7)) | 0;\\n    mid = (mid + Math.imul(al6, bh7)) | 0;\\n    mid = (mid + Math.imul(ah6, bl7)) | 0;\\n    hi = (hi + Math.imul(ah6, bh7)) | 0;\\n    lo = (lo + Math.imul(al5, bl8)) | 0;\\n    mid = (mid + Math.imul(al5, bh8)) | 0;\\n    mid = (mid + Math.imul(ah5, bl8)) | 0;\\n    hi = (hi + Math.imul(ah5, bh8)) | 0;\\n    lo = (lo + Math.imul(al4, bl9)) | 0;\\n    mid = (mid + Math.imul(al4, bh9)) | 0;\\n    mid = (mid + Math.imul(ah4, bl9)) | 0;\\n    hi = (hi + Math.imul(ah4, bh9)) | 0;\\n    var w13 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\\n    c = (((hi + (mid >>> 13)) | 0) + (w13 >>> 26)) | 0;\\n    w13 &= 0x3ffffff;\\n    /* k = 14 */\\n    lo = Math.imul(al9, bl5);\\n    mid = Math.imul(al9, bh5);\\n    mid = (mid + Math.imul(ah9, bl5)) | 0;\\n    hi = Math.imul(ah9, bh5);\\n    lo = (lo + Math.imul(al8, bl6)) | 0;\\n    mid = (mid + Math.imul(al8, bh6)) | 0;\\n    mid = (mid + Math.imul(ah8, bl6)) | 0;\\n    hi = (hi + Math.imul(ah8, bh6)) | 0;\\n    lo = (lo + Math.imul(al7, bl7)) | 0;\\n    mid = (mid + Math.imul(al7, bh7)) | 0;\\n    mid = (mid + Math.imul(ah7, bl7)) | 0;\\n    hi = (hi + Math.imul(ah7, bh7)) | 0;\\n    lo = (lo + Math.imul(al6, bl8)) | 0;\\n    mid = (mid + Math.imul(al6, bh8)) | 0;\\n    mid = (mid + Math.imul(ah6, bl8)) | 0;\\n    hi = (hi + Math.imul(ah6, bh8)) | 0;\\n    lo = (lo + Math.imul(al5, bl9)) | 0;\\n    mid = (mid + Math.imul(al5, bh9)) | 0;\\n    mid = (mid + Math.imul(ah5, bl9)) | 0;\\n    hi = (hi + Math.imul(ah5, bh9)) | 0;\\n    var w14 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\\n    c = (((hi + (mid >>> 13)) | 0) + (w14 >>> 26)) | 0;\\n    w14 &= 0x3ffffff;\\n    /* k = 15 */\\n    lo = Math.imul(al9, bl6);\\n    mid = Math.imul(al9, bh6);\\n    mid = (mid + Math.imul(ah9, bl6)) | 0;\\n    hi = Math.imul(ah9, bh6);\\n    lo = (lo + Math.imul(al8, bl7)) | 0;\\n    mid = (mid + Math.imul(al8, bh7)) | 0;\\n    mid = (mid + Math.imul(ah8, bl7)) | 0;\\n    hi = (hi + Math.imul(ah8, bh7)) | 0;\\n    lo = (lo + Math.imul(al7, bl8)) | 0;\\n    mid = (mid + Math.imul(al7, bh8)) | 0;\\n    mid = (mid + Math.imul(ah7, bl8)) | 0;\\n    hi = (hi + Math.imul(ah7, bh8)) | 0;\\n    lo = (lo + Math.imul(al6, bl9)) | 0;\\n    mid = (mid + Math.imul(al6, bh9)) | 0;\\n    mid = (mid + Math.imul(ah6, bl9)) | 0;\\n    hi = (hi + Math.imul(ah6, bh9)) | 0;\\n    var w15 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\\n    c = (((hi + (mid >>> 13)) | 0) + (w15 >>> 26)) | 0;\\n    w15 &= 0x3ffffff;\\n    /* k = 16 */\\n    lo = Math.imul(al9, bl7);\\n    mid = Math.imul(al9, bh7);\\n    mid = (mid + Math.imul(ah9, bl7)) | 0;\\n    hi = Math.imul(ah9, bh7);\\n    lo = (lo + Math.imul(al8, bl8)) | 0;\\n    mid = (mid + Math.imul(al8, bh8)) | 0;\\n    mid = (mid + Math.imul(ah8, bl8)) | 0;\\n    hi = (hi + Math.imul(ah8, bh8)) | 0;\\n    lo = (lo + Math.imul(al7, bl9)) | 0;\\n    mid = (mid + Math.imul(al7, bh9)) | 0;\\n    mid = (mid + Math.imul(ah7, bl9)) | 0;\\n    hi = (hi + Math.imul(ah7, bh9)) | 0;\\n    var w16 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\\n    c = (((hi + (mid >>> 13)) | 0) + (w16 >>> 26)) | 0;\\n    w16 &= 0x3ffffff;\\n    /* k = 17 */\\n    lo = Math.imul(al9, bl8);\\n    mid = Math.imul(al9, bh8);\\n    mid = (mid + Math.imul(ah9, bl8)) | 0;\\n    hi = Math.imul(ah9, bh8);\\n    lo = (lo + Math.imul(al8, bl9)) | 0;\\n    mid = (mid + Math.imul(al8, bh9)) | 0;\\n    mid = (mid + Math.imul(ah8, bl9)) | 0;\\n    hi = (hi + Math.imul(ah8, bh9)) | 0;\\n    var w17 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\\n    c = (((hi + (mid >>> 13)) | 0) + (w17 >>> 26)) | 0;\\n    w17 &= 0x3ffffff;\\n    /* k = 18 */\\n    lo = Math.imul(al9, bl9);\\n    mid = Math.imul(al9, bh9);\\n    mid = (mid + Math.imul(ah9, bl9)) | 0;\\n    hi = Math.imul(ah9, bh9);\\n    var w18 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\\n    c = (((hi + (mid >>> 13)) | 0) + (w18 >>> 26)) | 0;\\n    w18 &= 0x3ffffff;\\n    o[0] = w0;\\n    o[1] = w1;\\n    o[2] = w2;\\n    o[3] = w3;\\n    o[4] = w4;\\n    o[5] = w5;\\n    o[6] = w6;\\n    o[7] = w7;\\n    o[8] = w8;\\n    o[9] = w9;\\n    o[10] = w10;\\n    o[11] = w11;\\n    o[12] = w12;\\n    o[13] = w13;\\n    o[14] = w14;\\n    o[15] = w15;\\n    o[16] = w16;\\n    o[17] = w17;\\n    o[18] = w18;\\n    if (c !== 0) {\\n      o[19] = c;\\n      out.length++;\\n    }\\n    return out;\\n  };\\n\\n  // Polyfill comb\\n  if (!Math.imul) {\\n    comb10MulTo = smallMulTo;\\n  }\\n\\n  function bigMulTo (self, num, out) {\\n    out.negative = num.negative ^ self.negative;\\n    out.length = self.length + num.length;\\n\\n    var carry = 0;\\n    var hncarry = 0;\\n    for (var k = 0; k < out.length - 1; k++) {\\n      // Sum all words with the same `i + j = k` and accumulate `ncarry`,\\n      // note that ncarry could be >= 0x3ffffff\\n      var ncarry = hncarry;\\n      hncarry = 0;\\n      var rword = carry & 0x3ffffff;\\n      var maxJ = Math.min(k, num.length - 1);\\n      for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {\\n        var i = k - j;\\n        var a = self.words[i] | 0;\\n        var b = num.words[j] | 0;\\n        var r = a * b;\\n\\n        var lo = r & 0x3ffffff;\\n        ncarry = (ncarry + ((r / 0x4000000) | 0)) | 0;\\n        lo = (lo + rword) | 0;\\n        rword = lo & 0x3ffffff;\\n        ncarry = (ncarry + (lo >>> 26)) | 0;\\n\\n        hncarry += ncarry >>> 26;\\n        ncarry &= 0x3ffffff;\\n      }\\n      out.words[k] = rword;\\n      carry = ncarry;\\n      ncarry = hncarry;\\n    }\\n    if (carry !== 0) {\\n      out.words[k] = carry;\\n    } else {\\n      out.length--;\\n    }\\n\\n    return out._strip();\\n  }\\n\\n  function jumboMulTo (self, num, out) {\\n    // Temporary disable, see https://github.com/indutny/bn.js/issues/211\\n    // var fftm = new FFTM();\\n    // return fftm.mulp(self, num, out);\\n    return bigMulTo(self, num, out);\\n  }\\n\\n  BN.prototype.mulTo = function mulTo (num, out) {\\n    var res;\\n    var len = this.length + num.length;\\n    if (this.length === 10 && num.length === 10) {\\n      res = comb10MulTo(this, num, out);\\n    } else if (len < 63) {\\n      res = smallMulTo(this, num, out);\\n    } else if (len < 1024) {\\n      res = bigMulTo(this, num, out);\\n    } else {\\n      res = jumboMulTo(this, num, out);\\n    }\\n\\n    return res;\\n  };\\n\\n  // Cooley-Tukey algorithm for FFT\\n  // slightly revisited to rely on looping instead of recursion\\n\\n  function FFTM (x, y) {\\n    this.x = x;\\n    this.y = y;\\n  }\\n\\n  FFTM.prototype.makeRBT = function makeRBT (N) {\\n    var t = new Array(N);\\n    var l = BN.prototype._countBits(N) - 1;\\n    for (var i = 0; i < N; i++) {\\n      t[i] = this.revBin(i, l, N);\\n    }\\n\\n    return t;\\n  };\\n\\n  // Returns binary-reversed representation of `x`\\n  FFTM.prototype.revBin = function revBin (x, l, N) {\\n    if (x === 0 || x === N - 1) return x;\\n\\n    var rb = 0;\\n    for (var i = 0; i < l; i++) {\\n      rb |= (x & 1) << (l - i - 1);\\n      x >>= 1;\\n    }\\n\\n    return rb;\\n  };\\n\\n  // Performs \\\"tweedling\\\" phase, therefore 'emulating'\\n  // behaviour of the recursive algorithm\\n  FFTM.prototype.permute = function permute (rbt, rws, iws, rtws, itws, N) {\\n    for (var i = 0; i < N; i++) {\\n      rtws[i] = rws[rbt[i]];\\n      itws[i] = iws[rbt[i]];\\n    }\\n  };\\n\\n  FFTM.prototype.transform = function transform (rws, iws, rtws, itws, N, rbt) {\\n    this.permute(rbt, rws, iws, rtws, itws, N);\\n\\n    for (var s = 1; s < N; s <<= 1) {\\n      var l = s << 1;\\n\\n      var rtwdf = Math.cos(2 * Math.PI / l);\\n      var itwdf = Math.sin(2 * Math.PI / l);\\n\\n      for (var p = 0; p < N; p += l) {\\n        var rtwdf_ = rtwdf;\\n        var itwdf_ = itwdf;\\n\\n        for (var j = 0; j < s; j++) {\\n          var re = rtws[p + j];\\n          var ie = itws[p + j];\\n\\n          var ro = rtws[p + j + s];\\n          var io = itws[p + j + s];\\n\\n          var rx = rtwdf_ * ro - itwdf_ * io;\\n\\n          io = rtwdf_ * io + itwdf_ * ro;\\n          ro = rx;\\n\\n          rtws[p + j] = re + ro;\\n          itws[p + j] = ie + io;\\n\\n          rtws[p + j + s] = re - ro;\\n          itws[p + j + s] = ie - io;\\n\\n          /* jshint maxdepth : false */\\n          if (j !== l) {\\n            rx = rtwdf * rtwdf_ - itwdf * itwdf_;\\n\\n            itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;\\n            rtwdf_ = rx;\\n          }\\n        }\\n      }\\n    }\\n  };\\n\\n  FFTM.prototype.guessLen13b = function guessLen13b (n, m) {\\n    var N = Math.max(m, n) | 1;\\n    var odd = N & 1;\\n    var i = 0;\\n    for (N = N / 2 | 0; N; N = N >>> 1) {\\n      i++;\\n    }\\n\\n    return 1 << i + 1 + odd;\\n  };\\n\\n  FFTM.prototype.conjugate = function conjugate (rws, iws, N) {\\n    if (N <= 1) return;\\n\\n    for (var i = 0; i < N / 2; i++) {\\n      var t = rws[i];\\n\\n      rws[i] = rws[N - i - 1];\\n      rws[N - i - 1] = t;\\n\\n      t = iws[i];\\n\\n      iws[i] = -iws[N - i - 1];\\n      iws[N - i - 1] = -t;\\n    }\\n  };\\n\\n  FFTM.prototype.normalize13b = function normalize13b (ws, N) {\\n    var carry = 0;\\n    for (var i = 0; i < N / 2; i++) {\\n      var w = Math.round(ws[2 * i + 1] / N) * 0x2000 +\\n        Math.round(ws[2 * i] / N) +\\n        carry;\\n\\n      ws[i] = w & 0x3ffffff;\\n\\n      if (w < 0x4000000) {\\n        carry = 0;\\n      } else {\\n        carry = w / 0x4000000 | 0;\\n      }\\n    }\\n\\n    return ws;\\n  };\\n\\n  FFTM.prototype.convert13b = function convert13b (ws, len, rws, N) {\\n    var carry = 0;\\n    for (var i = 0; i < len; i++) {\\n      carry = carry + (ws[i] | 0);\\n\\n      rws[2 * i] = carry & 0x1fff; carry = carry >>> 13;\\n      rws[2 * i + 1] = carry & 0x1fff; carry = carry >>> 13;\\n    }\\n\\n    // Pad with zeroes\\n    for (i = 2 * len; i < N; ++i) {\\n      rws[i] = 0;\\n    }\\n\\n    assert(carry === 0);\\n    assert((carry & ~0x1fff) === 0);\\n  };\\n\\n  FFTM.prototype.stub = function stub (N) {\\n    var ph = new Array(N);\\n    for (var i = 0; i < N; i++) {\\n      ph[i] = 0;\\n    }\\n\\n    return ph;\\n  };\\n\\n  FFTM.prototype.mulp = function mulp (x, y, out) {\\n    var N = 2 * this.guessLen13b(x.length, y.length);\\n\\n    var rbt = this.makeRBT(N);\\n\\n    var _ = this.stub(N);\\n\\n    var rws = new Array(N);\\n    var rwst = new Array(N);\\n    var iwst = new Array(N);\\n\\n    var nrws = new Array(N);\\n    var nrwst = new Array(N);\\n    var niwst = new Array(N);\\n\\n    var rmws = out.words;\\n    rmws.length = N;\\n\\n    this.convert13b(x.words, x.length, rws, N);\\n    this.convert13b(y.words, y.length, nrws, N);\\n\\n    this.transform(rws, _, rwst, iwst, N, rbt);\\n    this.transform(nrws, _, nrwst, niwst, N, rbt);\\n\\n    for (var i = 0; i < N; i++) {\\n      var rx = rwst[i] * nrwst[i] - iwst[i] * niwst[i];\\n      iwst[i] = rwst[i] * niwst[i] + iwst[i] * nrwst[i];\\n      rwst[i] = rx;\\n    }\\n\\n    this.conjugate(rwst, iwst, N);\\n    this.transform(rwst, iwst, rmws, _, N, rbt);\\n    this.conjugate(rmws, _, N);\\n    this.normalize13b(rmws, N);\\n\\n    out.negative = x.negative ^ y.negative;\\n    out.length = x.length + y.length;\\n    return out._strip();\\n  };\\n\\n  // Multiply `this` by `num`\\n  BN.prototype.mul = function mul (num) {\\n    var out = new BN(null);\\n    out.words = new Array(this.length + num.length);\\n    return this.mulTo(num, out);\\n  };\\n\\n  // Multiply employing FFT\\n  BN.prototype.mulf = function mulf (num) {\\n    var out = new BN(null);\\n    out.words = new Array(this.length + num.length);\\n    return jumboMulTo(this, num, out);\\n  };\\n\\n  // In-place Multiplication\\n  BN.prototype.imul = function imul (num) {\\n    return this.clone().mulTo(num, this);\\n  };\\n\\n  BN.prototype.imuln = function imuln (num) {\\n    var isNegNum = num < 0;\\n    if (isNegNum) num = -num;\\n\\n    assert(typeof num === 'number');\\n    assert(num < 0x4000000);\\n\\n    // Carry\\n    var carry = 0;\\n    for (var i = 0; i < this.length; i++) {\\n      var w = (this.words[i] | 0) * num;\\n      var lo = (w & 0x3ffffff) + (carry & 0x3ffffff);\\n      carry >>= 26;\\n      carry += (w / 0x4000000) | 0;\\n      // NOTE: lo is 27bit maximum\\n      carry += lo >>> 26;\\n      this.words[i] = lo & 0x3ffffff;\\n    }\\n\\n    if (carry !== 0) {\\n      this.words[i] = carry;\\n      this.length++;\\n    }\\n\\n    return isNegNum ? this.ineg() : this;\\n  };\\n\\n  BN.prototype.muln = function muln (num) {\\n    return this.clone().imuln(num);\\n  };\\n\\n  // `this` * `this`\\n  BN.prototype.sqr = function sqr () {\\n    return this.mul(this);\\n  };\\n\\n  // `this` * `this` in-place\\n  BN.prototype.isqr = function isqr () {\\n    return this.imul(this.clone());\\n  };\\n\\n  // Math.pow(`this`, `num`)\\n  BN.prototype.pow = function pow (num) {\\n    var w = toBitArray(num);\\n    if (w.length === 0) return new BN(1);\\n\\n    // Skip leading zeroes\\n    var res = this;\\n    for (var i = 0; i < w.length; i++, res = res.sqr()) {\\n      if (w[i] !== 0) break;\\n    }\\n\\n    if (++i < w.length) {\\n      for (var q = res.sqr(); i < w.length; i++, q = q.sqr()) {\\n        if (w[i] === 0) continue;\\n\\n        res = res.mul(q);\\n      }\\n    }\\n\\n    return res;\\n  };\\n\\n  // Shift-left in-place\\n  BN.prototype.iushln = function iushln (bits) {\\n    assert(typeof bits === 'number' && bits >= 0);\\n    var r = bits % 26;\\n    var s = (bits - r) / 26;\\n    var carryMask = (0x3ffffff >>> (26 - r)) << (26 - r);\\n    var i;\\n\\n    if (r !== 0) {\\n      var carry = 0;\\n\\n      for (i = 0; i < this.length; i++) {\\n        var newCarry = this.words[i] & carryMask;\\n        var c = ((this.words[i] | 0) - newCarry) << r;\\n        this.words[i] = c | carry;\\n        carry = newCarry >>> (26 - r);\\n      }\\n\\n      if (carry) {\\n        this.words[i] = carry;\\n        this.length++;\\n      }\\n    }\\n\\n    if (s !== 0) {\\n      for (i = this.length - 1; i >= 0; i--) {\\n        this.words[i + s] = this.words[i];\\n      }\\n\\n      for (i = 0; i < s; i++) {\\n        this.words[i] = 0;\\n      }\\n\\n      this.length += s;\\n    }\\n\\n    return this._strip();\\n  };\\n\\n  BN.prototype.ishln = function ishln (bits) {\\n    // TODO(indutny): implement me\\n    assert(this.negative === 0);\\n    return this.iushln(bits);\\n  };\\n\\n  // Shift-right in-place\\n  // NOTE: `hint` is a lowest bit before trailing zeroes\\n  // NOTE: if `extended` is present - it will be filled with destroyed bits\\n  BN.prototype.iushrn = function iushrn (bits, hint, extended) {\\n    assert(typeof bits === 'number' && bits >= 0);\\n    var h;\\n    if (hint) {\\n      h = (hint - (hint % 26)) / 26;\\n    } else {\\n      h = 0;\\n    }\\n\\n    var r = bits % 26;\\n    var s = Math.min((bits - r) / 26, this.length);\\n    var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r);\\n    var maskedWords = extended;\\n\\n    h -= s;\\n    h = Math.max(0, h);\\n\\n    // Extended mode, copy masked part\\n    if (maskedWords) {\\n      for (var i = 0; i < s; i++) {\\n        maskedWords.words[i] = this.words[i];\\n      }\\n      maskedWords.length = s;\\n    }\\n\\n    if (s === 0) {\\n      // No-op, we should not move anything at all\\n    } else if (this.length > s) {\\n      this.length -= s;\\n      for (i = 0; i < this.length; i++) {\\n        this.words[i] = this.words[i + s];\\n      }\\n    } else {\\n      this.words[0] = 0;\\n      this.length = 1;\\n    }\\n\\n    var carry = 0;\\n    for (i = this.length - 1; i >= 0 && (carry !== 0 || i >= h); i--) {\\n      var word = this.words[i] | 0;\\n      this.words[i] = (carry << (26 - r)) | (word >>> r);\\n      carry = word & mask;\\n    }\\n\\n    // Push carried bits as a mask\\n    if (maskedWords && carry !== 0) {\\n      maskedWords.words[maskedWords.length++] = carry;\\n    }\\n\\n    if (this.length === 0) {\\n      this.words[0] = 0;\\n      this.length = 1;\\n    }\\n\\n    return this._strip();\\n  };\\n\\n  BN.prototype.ishrn = function ishrn (bits, hint, extended) {\\n    // TODO(indutny): implement me\\n    assert(this.negative === 0);\\n    return this.iushrn(bits, hint, extended);\\n  };\\n\\n  // Shift-left\\n  BN.prototype.shln = function shln (bits) {\\n    return this.clone().ishln(bits);\\n  };\\n\\n  BN.prototype.ushln = function ushln (bits) {\\n    return this.clone().iushln(bits);\\n  };\\n\\n  // Shift-right\\n  BN.prototype.shrn = function shrn (bits) {\\n    return this.clone().ishrn(bits);\\n  };\\n\\n  BN.prototype.ushrn = function ushrn (bits) {\\n    return this.clone().iushrn(bits);\\n  };\\n\\n  // Test if n bit is set\\n  BN.prototype.testn = function testn (bit) {\\n    assert(typeof bit === 'number' && bit >= 0);\\n    var r = bit % 26;\\n    var s = (bit - r) / 26;\\n    var q = 1 << r;\\n\\n    // Fast case: bit is much higher than all existing words\\n    if (this.length <= s) return false;\\n\\n    // Check bit and return\\n    var w = this.words[s];\\n\\n    return !!(w & q);\\n  };\\n\\n  // Return only lowers bits of number (in-place)\\n  BN.prototype.imaskn = function imaskn (bits) {\\n    assert(typeof bits === 'number' && bits >= 0);\\n    var r = bits % 26;\\n    var s = (bits - r) / 26;\\n\\n    assert(this.negative === 0, 'imaskn works only with positive numbers');\\n\\n    if (this.length <= s) {\\n      return this;\\n    }\\n\\n    if (r !== 0) {\\n      s++;\\n    }\\n    this.length = Math.min(s, this.length);\\n\\n    if (r !== 0) {\\n      var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r);\\n      this.words[this.length - 1] &= mask;\\n    }\\n\\n    return this._strip();\\n  };\\n\\n  // Return only lowers bits of number\\n  BN.prototype.maskn = function maskn (bits) {\\n    return this.clone().imaskn(bits);\\n  };\\n\\n  // Add plain number `num` to `this`\\n  BN.prototype.iaddn = function iaddn (num) {\\n    assert(typeof num === 'number');\\n    assert(num < 0x4000000);\\n    if (num < 0) return this.isubn(-num);\\n\\n    // Possible sign change\\n    if (this.negative !== 0) {\\n      if (this.length === 1 && (this.words[0] | 0) <= num) {\\n        this.words[0] = num - (this.words[0] | 0);\\n        this.negative = 0;\\n        return this;\\n      }\\n\\n      this.negative = 0;\\n      this.isubn(num);\\n      this.negative = 1;\\n      return this;\\n    }\\n\\n    // Add without checks\\n    return this._iaddn(num);\\n  };\\n\\n  BN.prototype._iaddn = function _iaddn (num) {\\n    this.words[0] += num;\\n\\n    // Carry\\n    for (var i = 0; i < this.length && this.words[i] >= 0x4000000; i++) {\\n      this.words[i] -= 0x4000000;\\n      if (i === this.length - 1) {\\n        this.words[i + 1] = 1;\\n      } else {\\n        this.words[i + 1]++;\\n      }\\n    }\\n    this.length = Math.max(this.length, i + 1);\\n\\n    return this;\\n  };\\n\\n  // Subtract plain number `num` from `this`\\n  BN.prototype.isubn = function isubn (num) {\\n    assert(typeof num === 'number');\\n    assert(num < 0x4000000);\\n    if (num < 0) return this.iaddn(-num);\\n\\n    if (this.negative !== 0) {\\n      this.negative = 0;\\n      this.iaddn(num);\\n      this.negative = 1;\\n      return this;\\n    }\\n\\n    this.words[0] -= num;\\n\\n    if (this.length === 1 && this.words[0] < 0) {\\n      this.words[0] = -this.words[0];\\n      this.negative = 1;\\n    } else {\\n      // Carry\\n      for (var i = 0; i < this.length && this.words[i] < 0; i++) {\\n        this.words[i] += 0x4000000;\\n        this.words[i + 1] -= 1;\\n      }\\n    }\\n\\n    return this._strip();\\n  };\\n\\n  BN.prototype.addn = function addn (num) {\\n    return this.clone().iaddn(num);\\n  };\\n\\n  BN.prototype.subn = function subn (num) {\\n    return this.clone().isubn(num);\\n  };\\n\\n  BN.prototype.iabs = function iabs () {\\n    this.negative = 0;\\n\\n    return this;\\n  };\\n\\n  BN.prototype.abs = function abs () {\\n    return this.clone().iabs();\\n  };\\n\\n  BN.prototype._ishlnsubmul = function _ishlnsubmul (num, mul, shift) {\\n    var len = num.length + shift;\\n    var i;\\n\\n    this._expand(len);\\n\\n    var w;\\n    var carry = 0;\\n    for (i = 0; i < num.length; i++) {\\n      w = (this.words[i + shift] | 0) + carry;\\n      var right = (num.words[i] | 0) * mul;\\n      w -= right & 0x3ffffff;\\n      carry = (w >> 26) - ((right / 0x4000000) | 0);\\n      this.words[i + shift] = w & 0x3ffffff;\\n    }\\n    for (; i < this.length - shift; i++) {\\n      w = (this.words[i + shift] | 0) + carry;\\n      carry = w >> 26;\\n      this.words[i + shift] = w & 0x3ffffff;\\n    }\\n\\n    if (carry === 0) return this._strip();\\n\\n    // Subtraction overflow\\n    assert(carry === -1);\\n    carry = 0;\\n    for (i = 0; i < this.length; i++) {\\n      w = -(this.words[i] | 0) + carry;\\n      carry = w >> 26;\\n      this.words[i] = w & 0x3ffffff;\\n    }\\n    this.negative = 1;\\n\\n    return this._strip();\\n  };\\n\\n  BN.prototype._wordDiv = function _wordDiv (num, mode) {\\n    var shift = this.length - num.length;\\n\\n    var a = this.clone();\\n    var b = num;\\n\\n    // Normalize\\n    var bhi = b.words[b.length - 1] | 0;\\n    var bhiBits = this._countBits(bhi);\\n    shift = 26 - bhiBits;\\n    if (shift !== 0) {\\n      b = b.ushln(shift);\\n      a.iushln(shift);\\n      bhi = b.words[b.length - 1] | 0;\\n    }\\n\\n    // Initialize quotient\\n    var m = a.length - b.length;\\n    var q;\\n\\n    if (mode !== 'mod') {\\n      q = new BN(null);\\n      q.length = m + 1;\\n      q.words = new Array(q.length);\\n      for (var i = 0; i < q.length; i++) {\\n        q.words[i] = 0;\\n      }\\n    }\\n\\n    var diff = a.clone()._ishlnsubmul(b, 1, m);\\n    if (diff.negative === 0) {\\n      a = diff;\\n      if (q) {\\n        q.words[m] = 1;\\n      }\\n    }\\n\\n    for (var j = m - 1; j >= 0; j--) {\\n      var qj = (a.words[b.length + j] | 0) * 0x4000000 +\\n        (a.words[b.length + j - 1] | 0);\\n\\n      // NOTE: (qj / bhi) is (0x3ffffff * 0x4000000 + 0x3ffffff) / 0x2000000 max\\n      // (0x7ffffff)\\n      qj = Math.min((qj / bhi) | 0, 0x3ffffff);\\n\\n      a._ishlnsubmul(b, qj, j);\\n      while (a.negative !== 0) {\\n        qj--;\\n        a.negative = 0;\\n        a._ishlnsubmul(b, 1, j);\\n        if (!a.isZero()) {\\n          a.negative ^= 1;\\n        }\\n      }\\n      if (q) {\\n        q.words[j] = qj;\\n      }\\n    }\\n    if (q) {\\n      q._strip();\\n    }\\n    a._strip();\\n\\n    // Denormalize\\n    if (mode !== 'div' && shift !== 0) {\\n      a.iushrn(shift);\\n    }\\n\\n    return {\\n      div: q || null,\\n      mod: a\\n    };\\n  };\\n\\n  // NOTE: 1) `mode` can be set to `mod` to request mod only,\\n  //       to `div` to request div only, or be absent to\\n  //       request both div & mod\\n  //       2) `positive` is true if unsigned mod is requested\\n  BN.prototype.divmod = function divmod (num, mode, positive) {\\n    assert(!num.isZero());\\n\\n    if (this.isZero()) {\\n      return {\\n        div: new BN(0),\\n        mod: new BN(0)\\n      };\\n    }\\n\\n    var div, mod, res;\\n    if (this.negative !== 0 && num.negative === 0) {\\n      res = this.neg().divmod(num, mode);\\n\\n      if (mode !== 'mod') {\\n        div = res.div.neg();\\n      }\\n\\n      if (mode !== 'div') {\\n        mod = res.mod.neg();\\n        if (positive && mod.negative !== 0) {\\n          mod.iadd(num);\\n        }\\n      }\\n\\n      return {\\n        div: div,\\n        mod: mod\\n      };\\n    }\\n\\n    if (this.negative === 0 && num.negative !== 0) {\\n      res = this.divmod(num.neg(), mode);\\n\\n      if (mode !== 'mod') {\\n        div = res.div.neg();\\n      }\\n\\n      return {\\n        div: div,\\n        mod: res.mod\\n      };\\n    }\\n\\n    if ((this.negative & num.negative) !== 0) {\\n      res = this.neg().divmod(num.neg(), mode);\\n\\n      if (mode !== 'div') {\\n        mod = res.mod.neg();\\n        if (positive && mod.negative !== 0) {\\n          mod.isub(num);\\n        }\\n      }\\n\\n      return {\\n        div: res.div,\\n        mod: mod\\n      };\\n    }\\n\\n    // Both numbers are positive at this point\\n\\n    // Strip both numbers to approximate shift value\\n    if (num.length > this.length || this.cmp(num) < 0) {\\n      return {\\n        div: new BN(0),\\n        mod: this\\n      };\\n    }\\n\\n    // Very short reduction\\n    if (num.length === 1) {\\n      if (mode === 'div') {\\n        return {\\n          div: this.divn(num.words[0]),\\n          mod: null\\n        };\\n      }\\n\\n      if (mode === 'mod') {\\n        return {\\n          div: null,\\n          mod: new BN(this.modrn(num.words[0]))\\n        };\\n      }\\n\\n      return {\\n        div: this.divn(num.words[0]),\\n        mod: new BN(this.modrn(num.words[0]))\\n      };\\n    }\\n\\n    return this._wordDiv(num, mode);\\n  };\\n\\n  // Find `this` / `num`\\n  BN.prototype.div = function div (num) {\\n    return this.divmod(num, 'div', false).div;\\n  };\\n\\n  // Find `this` % `num`\\n  BN.prototype.mod = function mod (num) {\\n    return this.divmod(num, 'mod', false).mod;\\n  };\\n\\n  BN.prototype.umod = function umod (num) {\\n    return this.divmod(num, 'mod', true).mod;\\n  };\\n\\n  // Find Round(`this` / `num`)\\n  BN.prototype.divRound = function divRound (num) {\\n    var dm = this.divmod(num);\\n\\n    // Fast case - exact division\\n    if (dm.mod.isZero()) return dm.div;\\n\\n    var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;\\n\\n    var half = num.ushrn(1);\\n    var r2 = num.andln(1);\\n    var cmp = mod.cmp(half);\\n\\n    // Round down\\n    if (cmp < 0 || (r2 === 1 && cmp === 0)) return dm.div;\\n\\n    // Round up\\n    return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);\\n  };\\n\\n  BN.prototype.modrn = function modrn (num) {\\n    var isNegNum = num < 0;\\n    if (isNegNum) num = -num;\\n\\n    assert(num <= 0x3ffffff);\\n    var p = (1 << 26) % num;\\n\\n    var acc = 0;\\n    for (var i = this.length - 1; i >= 0; i--) {\\n      acc = (p * acc + (this.words[i] | 0)) % num;\\n    }\\n\\n    return isNegNum ? -acc : acc;\\n  };\\n\\n  // WARNING: DEPRECATED\\n  BN.prototype.modn = function modn (num) {\\n    return this.modrn(num);\\n  };\\n\\n  // In-place division by number\\n  BN.prototype.idivn = function idivn (num) {\\n    var isNegNum = num < 0;\\n    if (isNegNum) num = -num;\\n\\n    assert(num <= 0x3ffffff);\\n\\n    var carry = 0;\\n    for (var i = this.length - 1; i >= 0; i--) {\\n      var w = (this.words[i] | 0) + carry * 0x4000000;\\n      this.words[i] = (w / num) | 0;\\n      carry = w % num;\\n    }\\n\\n    this._strip();\\n    return isNegNum ? this.ineg() : this;\\n  };\\n\\n  BN.prototype.divn = function divn (num) {\\n    return this.clone().idivn(num);\\n  };\\n\\n  BN.prototype.egcd = function egcd (p) {\\n    assert(p.negative === 0);\\n    assert(!p.isZero());\\n\\n    var x = this;\\n    var y = p.clone();\\n\\n    if (x.negative !== 0) {\\n      x = x.umod(p);\\n    } else {\\n      x = x.clone();\\n    }\\n\\n    // A * x + B * y = x\\n    var A = new BN(1);\\n    var B = new BN(0);\\n\\n    // C * x + D * y = y\\n    var C = new BN(0);\\n    var D = new BN(1);\\n\\n    var g = 0;\\n\\n    while (x.isEven() && y.isEven()) {\\n      x.iushrn(1);\\n      y.iushrn(1);\\n      ++g;\\n    }\\n\\n    var yp = y.clone();\\n    var xp = x.clone();\\n\\n    while (!x.isZero()) {\\n      for (var i = 0, im = 1; (x.words[0] & im) === 0 && i < 26; ++i, im <<= 1);\\n      if (i > 0) {\\n        x.iushrn(i);\\n        while (i-- > 0) {\\n          if (A.isOdd() || B.isOdd()) {\\n            A.iadd(yp);\\n            B.isub(xp);\\n          }\\n\\n          A.iushrn(1);\\n          B.iushrn(1);\\n        }\\n      }\\n\\n      for (var j = 0, jm = 1; (y.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);\\n      if (j > 0) {\\n        y.iushrn(j);\\n        while (j-- > 0) {\\n          if (C.isOdd() || D.isOdd()) {\\n            C.iadd(yp);\\n            D.isub(xp);\\n          }\\n\\n          C.iushrn(1);\\n          D.iushrn(1);\\n        }\\n      }\\n\\n      if (x.cmp(y) >= 0) {\\n        x.isub(y);\\n        A.isub(C);\\n        B.isub(D);\\n      } else {\\n        y.isub(x);\\n        C.isub(A);\\n        D.isub(B);\\n      }\\n    }\\n\\n    return {\\n      a: C,\\n      b: D,\\n      gcd: y.iushln(g)\\n    };\\n  };\\n\\n  // This is reduced incarnation of the binary EEA\\n  // above, designated to invert members of the\\n  // _prime_ fields F(p) at a maximal speed\\n  BN.prototype._invmp = function _invmp (p) {\\n    assert(p.negative === 0);\\n    assert(!p.isZero());\\n\\n    var a = this;\\n    var b = p.clone();\\n\\n    if (a.negative !== 0) {\\n      a = a.umod(p);\\n    } else {\\n      a = a.clone();\\n    }\\n\\n    var x1 = new BN(1);\\n    var x2 = new BN(0);\\n\\n    var delta = b.clone();\\n\\n    while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {\\n      for (var i = 0, im = 1; (a.words[0] & im) === 0 && i < 26; ++i, im <<= 1);\\n      if (i > 0) {\\n        a.iushrn(i);\\n        while (i-- > 0) {\\n          if (x1.isOdd()) {\\n            x1.iadd(delta);\\n          }\\n\\n          x1.iushrn(1);\\n        }\\n      }\\n\\n      for (var j = 0, jm = 1; (b.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);\\n      if (j > 0) {\\n        b.iushrn(j);\\n        while (j-- > 0) {\\n          if (x2.isOdd()) {\\n            x2.iadd(delta);\\n          }\\n\\n          x2.iushrn(1);\\n        }\\n      }\\n\\n      if (a.cmp(b) >= 0) {\\n        a.isub(b);\\n        x1.isub(x2);\\n      } else {\\n        b.isub(a);\\n        x2.isub(x1);\\n      }\\n    }\\n\\n    var res;\\n    if (a.cmpn(1) === 0) {\\n      res = x1;\\n    } else {\\n      res = x2;\\n    }\\n\\n    if (res.cmpn(0) < 0) {\\n      res.iadd(p);\\n    }\\n\\n    return res;\\n  };\\n\\n  BN.prototype.gcd = function gcd (num) {\\n    if (this.isZero()) return num.abs();\\n    if (num.isZero()) return this.abs();\\n\\n    var a = this.clone();\\n    var b = num.clone();\\n    a.negative = 0;\\n    b.negative = 0;\\n\\n    // Remove common factor of two\\n    for (var shift = 0; a.isEven() && b.isEven(); shift++) {\\n      a.iushrn(1);\\n      b.iushrn(1);\\n    }\\n\\n    do {\\n      while (a.isEven()) {\\n        a.iushrn(1);\\n      }\\n      while (b.isEven()) {\\n        b.iushrn(1);\\n      }\\n\\n      var r = a.cmp(b);\\n      if (r < 0) {\\n        // Swap `a` and `b` to make `a` always bigger than `b`\\n        var t = a;\\n        a = b;\\n        b = t;\\n      } else if (r === 0 || b.cmpn(1) === 0) {\\n        break;\\n      }\\n\\n      a.isub(b);\\n    } while (true);\\n\\n    return b.iushln(shift);\\n  };\\n\\n  // Invert number in the field F(num)\\n  BN.prototype.invm = function invm (num) {\\n    return this.egcd(num).a.umod(num);\\n  };\\n\\n  BN.prototype.isEven = function isEven () {\\n    return (this.words[0] & 1) === 0;\\n  };\\n\\n  BN.prototype.isOdd = function isOdd () {\\n    return (this.words[0] & 1) === 1;\\n  };\\n\\n  // And first word and num\\n  BN.prototype.andln = function andln (num) {\\n    return this.words[0] & num;\\n  };\\n\\n  // Increment at the bit position in-line\\n  BN.prototype.bincn = function bincn (bit) {\\n    assert(typeof bit === 'number');\\n    var r = bit % 26;\\n    var s = (bit - r) / 26;\\n    var q = 1 << r;\\n\\n    // Fast case: bit is much higher than all existing words\\n    if (this.length <= s) {\\n      this._expand(s + 1);\\n      this.words[s] |= q;\\n      return this;\\n    }\\n\\n    // Add bit and propagate, if needed\\n    var carry = q;\\n    for (var i = s; carry !== 0 && i < this.length; i++) {\\n      var w = this.words[i] | 0;\\n      w += carry;\\n      carry = w >>> 26;\\n      w &= 0x3ffffff;\\n      this.words[i] = w;\\n    }\\n    if (carry !== 0) {\\n      this.words[i] = carry;\\n      this.length++;\\n    }\\n    return this;\\n  };\\n\\n  BN.prototype.isZero = function isZero () {\\n    return this.length === 1 && this.words[0] === 0;\\n  };\\n\\n  BN.prototype.cmpn = function cmpn (num) {\\n    var negative = num < 0;\\n\\n    if (this.negative !== 0 && !negative) return -1;\\n    if (this.negative === 0 && negative) return 1;\\n\\n    this._strip();\\n\\n    var res;\\n    if (this.length > 1) {\\n      res = 1;\\n    } else {\\n      if (negative) {\\n        num = -num;\\n      }\\n\\n      assert(num <= 0x3ffffff, 'Number is too big');\\n\\n      var w = this.words[0] | 0;\\n      res = w === num ? 0 : w < num ? -1 : 1;\\n    }\\n    if (this.negative !== 0) return -res | 0;\\n    return res;\\n  };\\n\\n  // Compare two numbers and return:\\n  // 1 - if `this` > `num`\\n  // 0 - if `this` == `num`\\n  // -1 - if `this` < `num`\\n  BN.prototype.cmp = function cmp (num) {\\n    if (this.negative !== 0 && num.negative === 0) return -1;\\n    if (this.negative === 0 && num.negative !== 0) return 1;\\n\\n    var res = this.ucmp(num);\\n    if (this.negative !== 0) return -res | 0;\\n    return res;\\n  };\\n\\n  // Unsigned comparison\\n  BN.prototype.ucmp = function ucmp (num) {\\n    // At this point both numbers have the same sign\\n    if (this.length > num.length) return 1;\\n    if (this.length < num.length) return -1;\\n\\n    var res = 0;\\n    for (var i = this.length - 1; i >= 0; i--) {\\n      var a = this.words[i] | 0;\\n      var b = num.words[i] | 0;\\n\\n      if (a === b) continue;\\n      if (a < b) {\\n        res = -1;\\n      } else if (a > b) {\\n        res = 1;\\n      }\\n      break;\\n    }\\n    return res;\\n  };\\n\\n  BN.prototype.gtn = function gtn (num) {\\n    return this.cmpn(num) === 1;\\n  };\\n\\n  BN.prototype.gt = function gt (num) {\\n    return this.cmp(num) === 1;\\n  };\\n\\n  BN.prototype.gten = function gten (num) {\\n    return this.cmpn(num) >= 0;\\n  };\\n\\n  BN.prototype.gte = function gte (num) {\\n    return this.cmp(num) >= 0;\\n  };\\n\\n  BN.prototype.ltn = function ltn (num) {\\n    return this.cmpn(num) === -1;\\n  };\\n\\n  BN.prototype.lt = function lt (num) {\\n    return this.cmp(num) === -1;\\n  };\\n\\n  BN.prototype.lten = function lten (num) {\\n    return this.cmpn(num) <= 0;\\n  };\\n\\n  BN.prototype.lte = function lte (num) {\\n    return this.cmp(num) <= 0;\\n  };\\n\\n  BN.prototype.eqn = function eqn (num) {\\n    return this.cmpn(num) === 0;\\n  };\\n\\n  BN.prototype.eq = function eq (num) {\\n    return this.cmp(num) === 0;\\n  };\\n\\n  //\\n  // A reduce context, could be using montgomery or something better, depending\\n  // on the `m` itself.\\n  //\\n  BN.red = function red (num) {\\n    return new Red(num);\\n  };\\n\\n  BN.prototype.toRed = function toRed (ctx) {\\n    assert(!this.red, 'Already a number in reduction context');\\n    assert(this.negative === 0, 'red works only with positives');\\n    return ctx.convertTo(this)._forceRed(ctx);\\n  };\\n\\n  BN.prototype.fromRed = function fromRed () {\\n    assert(this.red, 'fromRed works only with numbers in reduction context');\\n    return this.red.convertFrom(this);\\n  };\\n\\n  BN.prototype._forceRed = function _forceRed (ctx) {\\n    this.red = ctx;\\n    return this;\\n  };\\n\\n  BN.prototype.forceRed = function forceRed (ctx) {\\n    assert(!this.red, 'Already a number in reduction context');\\n    return this._forceRed(ctx);\\n  };\\n\\n  BN.prototype.redAdd = function redAdd (num) {\\n    assert(this.red, 'redAdd works only with red numbers');\\n    return this.red.add(this, num);\\n  };\\n\\n  BN.prototype.redIAdd = function redIAdd (num) {\\n    assert(this.red, 'redIAdd works only with red numbers');\\n    return this.red.iadd(this, num);\\n  };\\n\\n  BN.prototype.redSub = function redSub (num) {\\n    assert(this.red, 'redSub works only with red numbers');\\n    return this.red.sub(this, num);\\n  };\\n\\n  BN.prototype.redISub = function redISub (num) {\\n    assert(this.red, 'redISub works only with red numbers');\\n    return this.red.isub(this, num);\\n  };\\n\\n  BN.prototype.redShl = function redShl (num) {\\n    assert(this.red, 'redShl works only with red numbers');\\n    return this.red.shl(this, num);\\n  };\\n\\n  BN.prototype.redMul = function redMul (num) {\\n    assert(this.red, 'redMul works only with red numbers');\\n    this.red._verify2(this, num);\\n    return this.red.mul(this, num);\\n  };\\n\\n  BN.prototype.redIMul = function redIMul (num) {\\n    assert(this.red, 'redMul works only with red numbers');\\n    this.red._verify2(this, num);\\n    return this.red.imul(this, num);\\n  };\\n\\n  BN.prototype.redSqr = function redSqr () {\\n    assert(this.red, 'redSqr works only with red numbers');\\n    this.red._verify1(this);\\n    return this.red.sqr(this);\\n  };\\n\\n  BN.prototype.redISqr = function redISqr () {\\n    assert(this.red, 'redISqr works only with red numbers');\\n    this.red._verify1(this);\\n    return this.red.isqr(this);\\n  };\\n\\n  // Square root over p\\n  BN.prototype.redSqrt = function redSqrt () {\\n    assert(this.red, 'redSqrt works only with red numbers');\\n    this.red._verify1(this);\\n    return this.red.sqrt(this);\\n  };\\n\\n  BN.prototype.redInvm = function redInvm () {\\n    assert(this.red, 'redInvm works only with red numbers');\\n    this.red._verify1(this);\\n    return this.red.invm(this);\\n  };\\n\\n  // Return negative clone of `this` % `red modulo`\\n  BN.prototype.redNeg = function redNeg () {\\n    assert(this.red, 'redNeg works only with red numbers');\\n    this.red._verify1(this);\\n    return this.red.neg(this);\\n  };\\n\\n  BN.prototype.redPow = function redPow (num) {\\n    assert(this.red && !num.red, 'redPow(normalNum)');\\n    this.red._verify1(this);\\n    return this.red.pow(this, num);\\n  };\\n\\n  // Prime numbers with efficient reduction\\n  var primes = {\\n    k256: null,\\n    p224: null,\\n    p192: null,\\n    p25519: null\\n  };\\n\\n  // Pseudo-Mersenne prime\\n  function MPrime (name, p) {\\n    // P = 2 ^ N - K\\n    this.name = name;\\n    this.p = new BN(p, 16);\\n    this.n = this.p.bitLength();\\n    this.k = new BN(1).iushln(this.n).isub(this.p);\\n\\n    this.tmp = this._tmp();\\n  }\\n\\n  MPrime.prototype._tmp = function _tmp () {\\n    var tmp = new BN(null);\\n    tmp.words = new Array(Math.ceil(this.n / 13));\\n    return tmp;\\n  };\\n\\n  MPrime.prototype.ireduce = function ireduce (num) {\\n    // Assumes that `num` is less than `P^2`\\n    // num = HI * (2 ^ N - K) + HI * K + LO = HI * K + LO (mod P)\\n    var r = num;\\n    var rlen;\\n\\n    do {\\n      this.split(r, this.tmp);\\n      r = this.imulK(r);\\n      r = r.iadd(this.tmp);\\n      rlen = r.bitLength();\\n    } while (rlen > this.n);\\n\\n    var cmp = rlen < this.n ? -1 : r.ucmp(this.p);\\n    if (cmp === 0) {\\n      r.words[0] = 0;\\n      r.length = 1;\\n    } else if (cmp > 0) {\\n      r.isub(this.p);\\n    } else {\\n      if (r.strip !== undefined) {\\n        // r is a BN v4 instance\\n        r.strip();\\n      } else {\\n        // r is a BN v5 instance\\n        r._strip();\\n      }\\n    }\\n\\n    return r;\\n  };\\n\\n  MPrime.prototype.split = function split (input, out) {\\n    input.iushrn(this.n, 0, out);\\n  };\\n\\n  MPrime.prototype.imulK = function imulK (num) {\\n    return num.imul(this.k);\\n  };\\n\\n  function K256 () {\\n    MPrime.call(\\n      this,\\n      'k256',\\n      'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f');\\n  }\\n  inherits(K256, MPrime);\\n\\n  K256.prototype.split = function split (input, output) {\\n    // 256 = 9 * 26 + 22\\n    var mask = 0x3fffff;\\n\\n    var outLen = Math.min(input.length, 9);\\n    for (var i = 0; i < outLen; i++) {\\n      output.words[i] = input.words[i];\\n    }\\n    output.length = outLen;\\n\\n    if (input.length <= 9) {\\n      input.words[0] = 0;\\n      input.length = 1;\\n      return;\\n    }\\n\\n    // Shift by 9 limbs\\n    var prev = input.words[9];\\n    output.words[output.length++] = prev & mask;\\n\\n    for (i = 10; i < input.length; i++) {\\n      var next = input.words[i] | 0;\\n      input.words[i - 10] = ((next & mask) << 4) | (prev >>> 22);\\n      prev = next;\\n    }\\n    prev >>>= 22;\\n    input.words[i - 10] = prev;\\n    if (prev === 0 && input.length > 10) {\\n      input.length -= 10;\\n    } else {\\n      input.length -= 9;\\n    }\\n  };\\n\\n  K256.prototype.imulK = function imulK (num) {\\n    // K = 0x1000003d1 = [ 0x40, 0x3d1 ]\\n    num.words[num.length] = 0;\\n    num.words[num.length + 1] = 0;\\n    num.length += 2;\\n\\n    // bounded at: 0x40 * 0x3ffffff + 0x3d0 = 0x100000390\\n    var lo = 0;\\n    for (var i = 0; i < num.length; i++) {\\n      var w = num.words[i] | 0;\\n      lo += w * 0x3d1;\\n      num.words[i] = lo & 0x3ffffff;\\n      lo = w * 0x40 + ((lo / 0x4000000) | 0);\\n    }\\n\\n    // Fast length reduction\\n    if (num.words[num.length - 1] === 0) {\\n      num.length--;\\n      if (num.words[num.length - 1] === 0) {\\n        num.length--;\\n      }\\n    }\\n    return num;\\n  };\\n\\n  function P224 () {\\n    MPrime.call(\\n      this,\\n      'p224',\\n      'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001');\\n  }\\n  inherits(P224, MPrime);\\n\\n  function P192 () {\\n    MPrime.call(\\n      this,\\n      'p192',\\n      'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff');\\n  }\\n  inherits(P192, MPrime);\\n\\n  function P25519 () {\\n    // 2 ^ 255 - 19\\n    MPrime.call(\\n      this,\\n      '25519',\\n      '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed');\\n  }\\n  inherits(P25519, MPrime);\\n\\n  P25519.prototype.imulK = function imulK (num) {\\n    // K = 0x13\\n    var carry = 0;\\n    for (var i = 0; i < num.length; i++) {\\n      var hi = (num.words[i] | 0) * 0x13 + carry;\\n      var lo = hi & 0x3ffffff;\\n      hi >>>= 26;\\n\\n      num.words[i] = lo;\\n      carry = hi;\\n    }\\n    if (carry !== 0) {\\n      num.words[num.length++] = carry;\\n    }\\n    return num;\\n  };\\n\\n  // Exported mostly for testing purposes, use plain name instead\\n  BN._prime = function prime (name) {\\n    // Cached version of prime\\n    if (primes[name]) return primes[name];\\n\\n    var prime;\\n    if (name === 'k256') {\\n      prime = new K256();\\n    } else if (name === 'p224') {\\n      prime = new P224();\\n    } else if (name === 'p192') {\\n      prime = new P192();\\n    } else if (name === 'p25519') {\\n      prime = new P25519();\\n    } else {\\n      throw new Error('Unknown prime ' + name);\\n    }\\n    primes[name] = prime;\\n\\n    return prime;\\n  };\\n\\n  //\\n  // Base reduction engine\\n  //\\n  function Red (m) {\\n    if (typeof m === 'string') {\\n      var prime = BN._prime(m);\\n      this.m = prime.p;\\n      this.prime = prime;\\n    } else {\\n      assert(m.gtn(1), 'modulus must be greater than 1');\\n      this.m = m;\\n      this.prime = null;\\n    }\\n  }\\n\\n  Red.prototype._verify1 = function _verify1 (a) {\\n    assert(a.negative === 0, 'red works only with positives');\\n    assert(a.red, 'red works only with red numbers');\\n  };\\n\\n  Red.prototype._verify2 = function _verify2 (a, b) {\\n    assert((a.negative | b.negative) === 0, 'red works only with positives');\\n    assert(a.red && a.red === b.red,\\n      'red works only with red numbers');\\n  };\\n\\n  Red.prototype.imod = function imod (a) {\\n    if (this.prime) return this.prime.ireduce(a)._forceRed(this);\\n\\n    move(a, a.umod(this.m)._forceRed(this));\\n    return a;\\n  };\\n\\n  Red.prototype.neg = function neg (a) {\\n    if (a.isZero()) {\\n      return a.clone();\\n    }\\n\\n    return this.m.sub(a)._forceRed(this);\\n  };\\n\\n  Red.prototype.add = function add (a, b) {\\n    this._verify2(a, b);\\n\\n    var res = a.add(b);\\n    if (res.cmp(this.m) >= 0) {\\n      res.isub(this.m);\\n    }\\n    return res._forceRed(this);\\n  };\\n\\n  Red.prototype.iadd = function iadd (a, b) {\\n    this._verify2(a, b);\\n\\n    var res = a.iadd(b);\\n    if (res.cmp(this.m) >= 0) {\\n      res.isub(this.m);\\n    }\\n    return res;\\n  };\\n\\n  Red.prototype.sub = function sub (a, b) {\\n    this._verify2(a, b);\\n\\n    var res = a.sub(b);\\n    if (res.cmpn(0) < 0) {\\n      res.iadd(this.m);\\n    }\\n    return res._forceRed(this);\\n  };\\n\\n  Red.prototype.isub = function isub (a, b) {\\n    this._verify2(a, b);\\n\\n    var res = a.isub(b);\\n    if (res.cmpn(0) < 0) {\\n      res.iadd(this.m);\\n    }\\n    return res;\\n  };\\n\\n  Red.prototype.shl = function shl (a, num) {\\n    this._verify1(a);\\n    return this.imod(a.ushln(num));\\n  };\\n\\n  Red.prototype.imul = function imul (a, b) {\\n    this._verify2(a, b);\\n    return this.imod(a.imul(b));\\n  };\\n\\n  Red.prototype.mul = function mul (a, b) {\\n    this._verify2(a, b);\\n    return this.imod(a.mul(b));\\n  };\\n\\n  Red.prototype.isqr = function isqr (a) {\\n    return this.imul(a, a.clone());\\n  };\\n\\n  Red.prototype.sqr = function sqr (a) {\\n    return this.mul(a, a);\\n  };\\n\\n  Red.prototype.sqrt = function sqrt (a) {\\n    if (a.isZero()) return a.clone();\\n\\n    var mod3 = this.m.andln(3);\\n    assert(mod3 % 2 === 1);\\n\\n    // Fast case\\n    if (mod3 === 3) {\\n      var pow = this.m.add(new BN(1)).iushrn(2);\\n      return this.pow(a, pow);\\n    }\\n\\n    // Tonelli-Shanks algorithm (Totally unoptimized and slow)\\n    //\\n    // Find Q and S, that Q * 2 ^ S = (P - 1)\\n    var q = this.m.subn(1);\\n    var s = 0;\\n    while (!q.isZero() && q.andln(1) === 0) {\\n      s++;\\n      q.iushrn(1);\\n    }\\n    assert(!q.isZero());\\n\\n    var one = new BN(1).toRed(this);\\n    var nOne = one.redNeg();\\n\\n    // Find quadratic non-residue\\n    // NOTE: Max is such because of generalized Riemann hypothesis.\\n    var lpow = this.m.subn(1).iushrn(1);\\n    var z = this.m.bitLength();\\n    z = new BN(2 * z * z).toRed(this);\\n\\n    while (this.pow(z, lpow).cmp(nOne) !== 0) {\\n      z.redIAdd(nOne);\\n    }\\n\\n    var c = this.pow(z, q);\\n    var r = this.pow(a, q.addn(1).iushrn(1));\\n    var t = this.pow(a, q);\\n    var m = s;\\n    while (t.cmp(one) !== 0) {\\n      var tmp = t;\\n      for (var i = 0; tmp.cmp(one) !== 0; i++) {\\n        tmp = tmp.redSqr();\\n      }\\n      assert(i < m);\\n      var b = this.pow(c, new BN(1).iushln(m - i - 1));\\n\\n      r = r.redMul(b);\\n      c = b.redSqr();\\n      t = t.redMul(c);\\n      m = i;\\n    }\\n\\n    return r;\\n  };\\n\\n  Red.prototype.invm = function invm (a) {\\n    var inv = a._invmp(this.m);\\n    if (inv.negative !== 0) {\\n      inv.negative = 0;\\n      return this.imod(inv).redNeg();\\n    } else {\\n      return this.imod(inv);\\n    }\\n  };\\n\\n  Red.prototype.pow = function pow (a, num) {\\n    if (num.isZero()) return new BN(1).toRed(this);\\n    if (num.cmpn(1) === 0) return a.clone();\\n\\n    var windowSize = 4;\\n    var wnd = new Array(1 << windowSize);\\n    wnd[0] = new BN(1).toRed(this);\\n    wnd[1] = a;\\n    for (var i = 2; i < wnd.length; i++) {\\n      wnd[i] = this.mul(wnd[i - 1], a);\\n    }\\n\\n    var res = wnd[0];\\n    var current = 0;\\n    var currentLen = 0;\\n    var start = num.bitLength() % 26;\\n    if (start === 0) {\\n      start = 26;\\n    }\\n\\n    for (i = num.length - 1; i >= 0; i--) {\\n      var word = num.words[i];\\n      for (var j = start - 1; j >= 0; j--) {\\n        var bit = (word >> j) & 1;\\n        if (res !== wnd[0]) {\\n          res = this.sqr(res);\\n        }\\n\\n        if (bit === 0 && current === 0) {\\n          currentLen = 0;\\n          continue;\\n        }\\n\\n        current <<= 1;\\n        current |= bit;\\n        currentLen++;\\n        if (currentLen !== windowSize && (i !== 0 || j !== 0)) continue;\\n\\n        res = this.mul(res, wnd[current]);\\n        currentLen = 0;\\n        current = 0;\\n      }\\n      start = 26;\\n    }\\n\\n    return res;\\n  };\\n\\n  Red.prototype.convertTo = function convertTo (num) {\\n    var r = num.umod(this.m);\\n\\n    return r === num ? r.clone() : r;\\n  };\\n\\n  Red.prototype.convertFrom = function convertFrom (num) {\\n    var res = num.clone();\\n    res.red = null;\\n    return res;\\n  };\\n\\n  //\\n  // Montgomery method engine\\n  //\\n\\n  BN.mont = function mont (num) {\\n    return new Mont(num);\\n  };\\n\\n  function Mont (m) {\\n    Red.call(this, m);\\n\\n    this.shift = this.m.bitLength();\\n    if (this.shift % 26 !== 0) {\\n      this.shift += 26 - (this.shift % 26);\\n    }\\n\\n    this.r = new BN(1).iushln(this.shift);\\n    this.r2 = this.imod(this.r.sqr());\\n    this.rinv = this.r._invmp(this.m);\\n\\n    this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);\\n    this.minv = this.minv.umod(this.r);\\n    this.minv = this.r.sub(this.minv);\\n  }\\n  inherits(Mont, Red);\\n\\n  Mont.prototype.convertTo = function convertTo (num) {\\n    return this.imod(num.ushln(this.shift));\\n  };\\n\\n  Mont.prototype.convertFrom = function convertFrom (num) {\\n    var r = this.imod(num.mul(this.rinv));\\n    r.red = null;\\n    return r;\\n  };\\n\\n  Mont.prototype.imul = function imul (a, b) {\\n    if (a.isZero() || b.isZero()) {\\n      a.words[0] = 0;\\n      a.length = 1;\\n      return a;\\n    }\\n\\n    var t = a.imul(b);\\n    var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);\\n    var u = t.isub(c).iushrn(this.shift);\\n    var res = u;\\n\\n    if (u.cmp(this.m) >= 0) {\\n      res = u.isub(this.m);\\n    } else if (u.cmpn(0) < 0) {\\n      res = u.iadd(this.m);\\n    }\\n\\n    return res._forceRed(this);\\n  };\\n\\n  Mont.prototype.mul = function mul (a, b) {\\n    if (a.isZero() || b.isZero()) return new BN(0)._forceRed(this);\\n\\n    var t = a.mul(b);\\n    var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);\\n    var u = t.isub(c).iushrn(this.shift);\\n    var res = u;\\n    if (u.cmp(this.m) >= 0) {\\n      res = u.isub(this.m);\\n    } else if (u.cmpn(0) < 0) {\\n      res = u.iadd(this.m);\\n    }\\n\\n    return res._forceRed(this);\\n  };\\n\\n  Mont.prototype.invm = function invm (a) {\\n    // (AR)^-1 * R^2 = (A^-1 * R^-1) * R^2 = A^-1 * R\\n    var res = this.imod(a._invmp(this.m).mul(this.r2));\\n    return res._forceRed(this);\\n  };\\n})( false || module, this);\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/bn.js/lib/bn.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/borsh/lib/index.js\":\n/*!*****************************************!*\\\n  !*** ./node_modules/borsh/lib/index.js ***!\n  \\*****************************************/\n/***/ (function(__unused_webpack_module, exports, __webpack_require__) {\n\n\"use strict\";\neval(\"/* provided dependency */ var Buffer = __webpack_require__(/*! buffer */ \\\"./node_modules/buffer/index.js\\\")[\\\"Buffer\\\"];\\n\\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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\\n    Object.defineProperty(o, \\\"default\\\", { enumerable: true, value: v });\\n}) : function(o, v) {\\n    o[\\\"default\\\"] = v;\\n});\\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\\n    if (typeof Reflect === \\\"object\\\" && typeof Reflect.decorate === \\\"function\\\") r = Reflect.decorate(decorators, target, key, desc);\\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\\n};\\nvar __importStar = (this && this.__importStar) || function (mod) {\\n    if (mod && mod.__esModule) return mod;\\n    var result = {};\\n    if (mod != null) for (var k in mod) if (k !== \\\"default\\\" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\\n    __setModuleDefault(result, mod);\\n    return result;\\n};\\nvar __importDefault = (this && this.__importDefault) || function (mod) {\\n    return (mod && mod.__esModule) ? mod : { \\\"default\\\": mod };\\n};\\nObject.defineProperty(exports, \\\"__esModule\\\", ({ value: true }));\\nexports.deserializeUnchecked = exports.deserialize = exports.serialize = exports.BinaryReader = exports.BinaryWriter = exports.BorshError = exports.baseDecode = exports.baseEncode = void 0;\\nconst bn_js_1 = __importDefault(__webpack_require__(/*! bn.js */ \\\"./node_modules/bn.js/lib/bn.js\\\"));\\nconst bs58_1 = __importDefault(__webpack_require__(/*! bs58 */ \\\"./node_modules/bs58/index.js\\\"));\\n// TODO: Make sure this polyfill not included when not required\\nconst encoding = __importStar(__webpack_require__(/*! text-encoding-utf-8 */ \\\"./node_modules/text-encoding-utf-8/lib/encoding.lib.js\\\"));\\nconst ResolvedTextDecoder = typeof TextDecoder !== \\\"function\\\" ? encoding.TextDecoder : TextDecoder;\\nconst textDecoder = new ResolvedTextDecoder(\\\"utf-8\\\", { fatal: true });\\nfunction baseEncode(value) {\\n    if (typeof value === \\\"string\\\") {\\n        value = Buffer.from(value, \\\"utf8\\\");\\n    }\\n    return bs58_1.default.encode(Buffer.from(value));\\n}\\nexports.baseEncode = baseEncode;\\nfunction baseDecode(value) {\\n    return Buffer.from(bs58_1.default.decode(value));\\n}\\nexports.baseDecode = baseDecode;\\nconst INITIAL_LENGTH = 1024;\\nclass BorshError extends Error {\\n    constructor(message) {\\n        super(message);\\n        this.fieldPath = [];\\n        this.originalMessage = message;\\n    }\\n    addToFieldPath(fieldName) {\\n        this.fieldPath.splice(0, 0, fieldName);\\n        // NOTE: Modifying message directly as jest doesn't use .toString()\\n        this.message = this.originalMessage + \\\": \\\" + this.fieldPath.join(\\\".\\\");\\n    }\\n}\\nexports.BorshError = BorshError;\\n/// Binary encoder.\\nclass BinaryWriter {\\n    constructor() {\\n        this.buf = Buffer.alloc(INITIAL_LENGTH);\\n        this.length = 0;\\n    }\\n    maybeResize() {\\n        if (this.buf.length < 16 + this.length) {\\n            this.buf = Buffer.concat([this.buf, Buffer.alloc(INITIAL_LENGTH)]);\\n        }\\n    }\\n    writeU8(value) {\\n        this.maybeResize();\\n        this.buf.writeUInt8(value, this.length);\\n        this.length += 1;\\n    }\\n    writeU16(value) {\\n        this.maybeResize();\\n        this.buf.writeUInt16LE(value, this.length);\\n        this.length += 2;\\n    }\\n    writeU32(value) {\\n        this.maybeResize();\\n        this.buf.writeUInt32LE(value, this.length);\\n        this.length += 4;\\n    }\\n    writeU64(value) {\\n        this.maybeResize();\\n        this.writeBuffer(Buffer.from(new bn_js_1.default(value).toArray(\\\"le\\\", 8)));\\n    }\\n    writeU128(value) {\\n        this.maybeResize();\\n        this.writeBuffer(Buffer.from(new bn_js_1.default(value).toArray(\\\"le\\\", 16)));\\n    }\\n    writeU256(value) {\\n        this.maybeResize();\\n        this.writeBuffer(Buffer.from(new bn_js_1.default(value).toArray(\\\"le\\\", 32)));\\n    }\\n    writeU512(value) {\\n        this.maybeResize();\\n        this.writeBuffer(Buffer.from(new bn_js_1.default(value).toArray(\\\"le\\\", 64)));\\n    }\\n    writeBuffer(buffer) {\\n        // Buffer.from is needed as this.buf.subarray can return plain Uint8Array in browser\\n        this.buf = Buffer.concat([\\n            Buffer.from(this.buf.subarray(0, this.length)),\\n            buffer,\\n            Buffer.alloc(INITIAL_LENGTH),\\n        ]);\\n        this.length += buffer.length;\\n    }\\n    writeString(str) {\\n        this.maybeResize();\\n        const b = Buffer.from(str, \\\"utf8\\\");\\n        this.writeU32(b.length);\\n        this.writeBuffer(b);\\n    }\\n    writeFixedArray(array) {\\n        this.writeBuffer(Buffer.from(array));\\n    }\\n    writeArray(array, fn) {\\n        this.maybeResize();\\n        this.writeU32(array.length);\\n        for (const elem of array) {\\n            this.maybeResize();\\n            fn(elem);\\n        }\\n    }\\n    toArray() {\\n        return this.buf.subarray(0, this.length);\\n    }\\n}\\nexports.BinaryWriter = BinaryWriter;\\nfunction handlingRangeError(target, propertyKey, propertyDescriptor) {\\n    const originalMethod = propertyDescriptor.value;\\n    propertyDescriptor.value = function (...args) {\\n        try {\\n            return originalMethod.apply(this, args);\\n        }\\n        catch (e) {\\n            if (e instanceof RangeError) {\\n                const code = e.code;\\n                if ([\\\"ERR_BUFFER_OUT_OF_BOUNDS\\\", \\\"ERR_OUT_OF_RANGE\\\"].indexOf(code) >= 0) {\\n                    throw new BorshError(\\\"Reached the end of buffer when deserializing\\\");\\n                }\\n            }\\n            throw e;\\n        }\\n    };\\n}\\nclass BinaryReader {\\n    constructor(buf) {\\n        this.buf = buf;\\n        this.offset = 0;\\n    }\\n    readU8() {\\n        const value = this.buf.readUInt8(this.offset);\\n        this.offset += 1;\\n        return value;\\n    }\\n    readU16() {\\n        const value = this.buf.readUInt16LE(this.offset);\\n        this.offset += 2;\\n        return value;\\n    }\\n    readU32() {\\n        const value = this.buf.readUInt32LE(this.offset);\\n        this.offset += 4;\\n        return value;\\n    }\\n    readU64() {\\n        const buf = this.readBuffer(8);\\n        return new bn_js_1.default(buf, \\\"le\\\");\\n    }\\n    readU128() {\\n        const buf = this.readBuffer(16);\\n        return new bn_js_1.default(buf, \\\"le\\\");\\n    }\\n    readU256() {\\n        const buf = this.readBuffer(32);\\n        return new bn_js_1.default(buf, \\\"le\\\");\\n    }\\n    readU512() {\\n        const buf = this.readBuffer(64);\\n        return new bn_js_1.default(buf, \\\"le\\\");\\n    }\\n    readBuffer(len) {\\n        if (this.offset + len > this.buf.length) {\\n            throw new BorshError(`Expected buffer length ${len} isn't within bounds`);\\n        }\\n        const result = this.buf.slice(this.offset, this.offset + len);\\n        this.offset += len;\\n        return result;\\n    }\\n    readString() {\\n        const len = this.readU32();\\n        const buf = this.readBuffer(len);\\n        try {\\n            // NOTE: Using TextDecoder to fail on invalid UTF-8\\n            return textDecoder.decode(buf);\\n        }\\n        catch (e) {\\n            throw new BorshError(`Error decoding UTF-8 string: ${e}`);\\n        }\\n    }\\n    readFixedArray(len) {\\n        return new Uint8Array(this.readBuffer(len));\\n    }\\n    readArray(fn) {\\n        const len = this.readU32();\\n        const result = Array();\\n        for (let i = 0; i < len; ++i) {\\n            result.push(fn());\\n        }\\n        return result;\\n    }\\n}\\n__decorate([\\n    handlingRangeError\\n], BinaryReader.prototype, \\\"readU8\\\", null);\\n__decorate([\\n    handlingRangeError\\n], BinaryReader.prototype, \\\"readU16\\\", null);\\n__decorate([\\n    handlingRangeError\\n], BinaryReader.prototype, \\\"readU32\\\", null);\\n__decorate([\\n    handlingRangeError\\n], BinaryReader.prototype, \\\"readU64\\\", null);\\n__decorate([\\n    handlingRangeError\\n], BinaryReader.prototype, \\\"readU128\\\", null);\\n__decorate([\\n    handlingRangeError\\n], BinaryReader.prototype, \\\"readU256\\\", null);\\n__decorate([\\n    handlingRangeError\\n], BinaryReader.prototype, \\\"readU512\\\", null);\\n__decorate([\\n    handlingRangeError\\n], BinaryReader.prototype, \\\"readString\\\", null);\\n__decorate([\\n    handlingRangeError\\n], BinaryReader.prototype, \\\"readFixedArray\\\", null);\\n__decorate([\\n    handlingRangeError\\n], BinaryReader.prototype, \\\"readArray\\\", null);\\nexports.BinaryReader = BinaryReader;\\nfunction capitalizeFirstLetter(string) {\\n    return string.charAt(0).toUpperCase() + string.slice(1);\\n}\\nfunction serializeField(schema, fieldName, value, fieldType, writer) {\\n    try {\\n        // TODO: Handle missing values properly (make sure they never result in just skipped write)\\n        if (typeof fieldType === \\\"string\\\") {\\n            writer[`write${capitalizeFirstLetter(fieldType)}`](value);\\n        }\\n        else if (fieldType instanceof Array) {\\n            if (typeof fieldType[0] === \\\"number\\\") {\\n                if (value.length !== fieldType[0]) {\\n                    throw new BorshError(`Expecting byte array of length ${fieldType[0]}, but got ${value.length} bytes`);\\n                }\\n                writer.writeFixedArray(value);\\n            }\\n            else if (fieldType.length === 2 && typeof fieldType[1] === \\\"number\\\") {\\n                if (value.length !== fieldType[1]) {\\n                    throw new BorshError(`Expecting byte array of length ${fieldType[1]}, but got ${value.length} bytes`);\\n                }\\n                for (let i = 0; i < fieldType[1]; i++) {\\n                    serializeField(schema, null, value[i], fieldType[0], writer);\\n                }\\n            }\\n            else {\\n                writer.writeArray(value, (item) => {\\n                    serializeField(schema, fieldName, item, fieldType[0], writer);\\n                });\\n            }\\n        }\\n        else if (fieldType.kind !== undefined) {\\n            switch (fieldType.kind) {\\n                case \\\"option\\\": {\\n                    if (value === null || value === undefined) {\\n                        writer.writeU8(0);\\n                    }\\n                    else {\\n                        writer.writeU8(1);\\n                        serializeField(schema, fieldName, value, fieldType.type, writer);\\n                    }\\n                    break;\\n                }\\n                case \\\"map\\\": {\\n                    writer.writeU32(value.size);\\n                    value.forEach((val, key) => {\\n                        serializeField(schema, fieldName, key, fieldType.key, writer);\\n                        serializeField(schema, fieldName, val, fieldType.value, writer);\\n                    });\\n                    break;\\n                }\\n                default:\\n                    throw new BorshError(`FieldType ${fieldType} unrecognized`);\\n            }\\n        }\\n        else {\\n            serializeStruct(schema, value, writer);\\n        }\\n    }\\n    catch (error) {\\n        if (error instanceof BorshError) {\\n            error.addToFieldPath(fieldName);\\n        }\\n        throw error;\\n    }\\n}\\nfunction serializeStruct(schema, obj, writer) {\\n    if (typeof obj.borshSerialize === \\\"function\\\") {\\n        obj.borshSerialize(writer);\\n        return;\\n    }\\n    const structSchema = schema.get(obj.constructor);\\n    if (!structSchema) {\\n        throw new BorshError(`Class ${obj.constructor.name} is missing in schema`);\\n    }\\n    if (structSchema.kind === \\\"struct\\\") {\\n        structSchema.fields.map(([fieldName, fieldType]) => {\\n            serializeField(schema, fieldName, obj[fieldName], fieldType, writer);\\n        });\\n    }\\n    else if (structSchema.kind === \\\"enum\\\") {\\n        const name = obj[structSchema.field];\\n        for (let idx = 0; idx < structSchema.values.length; ++idx) {\\n            const [fieldName, fieldType] = structSchema.values[idx];\\n            if (fieldName === name) {\\n                writer.writeU8(idx);\\n                serializeField(schema, fieldName, obj[fieldName], fieldType, writer);\\n                break;\\n            }\\n        }\\n    }\\n    else {\\n        throw new BorshError(`Unexpected schema kind: ${structSchema.kind} for ${obj.constructor.name}`);\\n    }\\n}\\n/// Serialize given object using schema of the form:\\n/// { class_name -> [ [field_name, field_type], .. ], .. }\\nfunction serialize(schema, obj, Writer = BinaryWriter) {\\n    const writer = new Writer();\\n    serializeStruct(schema, obj, writer);\\n    return writer.toArray();\\n}\\nexports.serialize = serialize;\\nfunction deserializeField(schema, fieldName, fieldType, reader) {\\n    try {\\n        if (typeof fieldType === \\\"string\\\") {\\n            return reader[`read${capitalizeFirstLetter(fieldType)}`]();\\n        }\\n        if (fieldType instanceof Array) {\\n            if (typeof fieldType[0] === \\\"number\\\") {\\n                return reader.readFixedArray(fieldType[0]);\\n            }\\n            else if (typeof fieldType[1] === \\\"number\\\") {\\n                const arr = [];\\n                for (let i = 0; i < fieldType[1]; i++) {\\n                    arr.push(deserializeField(schema, null, fieldType[0], reader));\\n                }\\n                return arr;\\n            }\\n            else {\\n                return reader.readArray(() => deserializeField(schema, fieldName, fieldType[0], reader));\\n            }\\n        }\\n        if (fieldType.kind === \\\"option\\\") {\\n            const option = reader.readU8();\\n            if (option) {\\n                return deserializeField(schema, fieldName, fieldType.type, reader);\\n            }\\n            return undefined;\\n        }\\n        if (fieldType.kind === \\\"map\\\") {\\n            let map = new Map();\\n            const length = reader.readU32();\\n            for (let i = 0; i < length; i++) {\\n                const key = deserializeField(schema, fieldName, fieldType.key, reader);\\n                const val = deserializeField(schema, fieldName, fieldType.value, reader);\\n                map.set(key, val);\\n            }\\n            return map;\\n        }\\n        return deserializeStruct(schema, fieldType, reader);\\n    }\\n    catch (error) {\\n        if (error instanceof BorshError) {\\n            error.addToFieldPath(fieldName);\\n        }\\n        throw error;\\n    }\\n}\\nfunction deserializeStruct(schema, classType, reader) {\\n    if (typeof classType.borshDeserialize === \\\"function\\\") {\\n        return classType.borshDeserialize(reader);\\n    }\\n    const structSchema = schema.get(classType);\\n    if (!structSchema) {\\n        throw new BorshError(`Class ${classType.name} is missing in schema`);\\n    }\\n    if (structSchema.kind === \\\"struct\\\") {\\n        const result = {};\\n        for (const [fieldName, fieldType] of schema.get(classType).fields) {\\n            result[fieldName] = deserializeField(schema, fieldName, fieldType, reader);\\n        }\\n        return new classType(result);\\n    }\\n    if (structSchema.kind === \\\"enum\\\") {\\n        const idx = reader.readU8();\\n        if (idx >= structSchema.values.length) {\\n            throw new BorshError(`Enum index: ${idx} is out of range`);\\n        }\\n        const [fieldName, fieldType] = structSchema.values[idx];\\n        const fieldValue = deserializeField(schema, fieldName, fieldType, reader);\\n        return new classType({ [fieldName]: fieldValue });\\n    }\\n    throw new BorshError(`Unexpected schema kind: ${structSchema.kind} for ${classType.constructor.name}`);\\n}\\n/// Deserializes object from bytes using schema.\\nfunction deserialize(schema, classType, buffer, Reader = BinaryReader) {\\n    const reader = new Reader(buffer);\\n    const result = deserializeStruct(schema, classType, reader);\\n    if (reader.offset < buffer.length) {\\n        throw new BorshError(`Unexpected ${buffer.length - reader.offset} bytes after deserialized data`);\\n    }\\n    return result;\\n}\\nexports.deserialize = deserialize;\\n/// Deserializes object from bytes using schema, without checking the length read\\nfunction deserializeUnchecked(schema, classType, buffer, Reader = BinaryReader) {\\n    const reader = new Reader(buffer);\\n    return deserializeStruct(schema, classType, reader);\\n}\\nexports.deserializeUnchecked = deserializeUnchecked;\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/borsh/lib/index.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/bs58/index.js\":\n/*!************************************!*\\\n  !*** ./node_modules/bs58/index.js ***!\n  \\************************************/\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\neval(\"var basex = __webpack_require__(/*! base-x */ \\\"./node_modules/base-x/src/index.js\\\")\\nvar ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'\\n\\nmodule.exports = basex(ALPHABET)\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/bs58/index.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/buffer/index.js\":\n/*!**************************************!*\\\n  !*** ./node_modules/buffer/index.js ***!\n  \\**************************************/\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\neval(\"/*!\\n * The buffer module from node.js, for the browser.\\n *\\n * @author   Feross Aboukhadijeh <https://feross.org>\\n * @license  MIT\\n */\\n/* eslint-disable no-proto */\\n\\n\\n\\nconst base64 = __webpack_require__(/*! base64-js */ \\\"./node_modules/base64-js/index.js\\\")\\nconst ieee754 = __webpack_require__(/*! ieee754 */ \\\"./node_modules/ieee754/index.js\\\")\\nconst customInspectSymbol =\\n  (typeof Symbol === 'function' && typeof Symbol['for'] === 'function') // eslint-disable-line dot-notation\\n    ? Symbol['for']('nodejs.util.inspect.custom') // eslint-disable-line dot-notation\\n    : null\\n\\nexports.Buffer = Buffer\\nexports.SlowBuffer = SlowBuffer\\nexports.INSPECT_MAX_BYTES = 50\\n\\nconst K_MAX_LENGTH = 0x7fffffff\\nexports.kMaxLength = K_MAX_LENGTH\\n\\n/**\\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\\n *   === true    Use Uint8Array implementation (fastest)\\n *   === false   Print warning and recommend using `buffer` v4.x which has an Object\\n *               implementation (most compatible, even IE6)\\n *\\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\\n * Opera 11.6+, iOS 4.2+.\\n *\\n * We report that the browser does not support typed arrays if the are not subclassable\\n * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`\\n * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support\\n * for __proto__ and has a buggy typed array implementation.\\n */\\nBuffer.TYPED_ARRAY_SUPPORT = typedArraySupport()\\n\\nif (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&\\n    typeof console.error === 'function') {\\n  console.error(\\n    'This browser lacks typed array (Uint8Array) support which is required by ' +\\n    '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'\\n  )\\n}\\n\\nfunction typedArraySupport () {\\n  // Can typed array instances can be augmented?\\n  try {\\n    const arr = new Uint8Array(1)\\n    const proto = { foo: function () { return 42 } }\\n    Object.setPrototypeOf(proto, Uint8Array.prototype)\\n    Object.setPrototypeOf(arr, proto)\\n    return arr.foo() === 42\\n  } catch (e) {\\n    return false\\n  }\\n}\\n\\nObject.defineProperty(Buffer.prototype, 'parent', {\\n  enumerable: true,\\n  get: function () {\\n    if (!Buffer.isBuffer(this)) return undefined\\n    return this.buffer\\n  }\\n})\\n\\nObject.defineProperty(Buffer.prototype, 'offset', {\\n  enumerable: true,\\n  get: function () {\\n    if (!Buffer.isBuffer(this)) return undefined\\n    return this.byteOffset\\n  }\\n})\\n\\nfunction createBuffer (length) {\\n  if (length > K_MAX_LENGTH) {\\n    throw new RangeError('The value \\\"' + length + '\\\" is invalid for option \\\"size\\\"')\\n  }\\n  // Return an augmented `Uint8Array` instance\\n  const buf = new Uint8Array(length)\\n  Object.setPrototypeOf(buf, Buffer.prototype)\\n  return buf\\n}\\n\\n/**\\n * The Buffer constructor returns instances of `Uint8Array` that have their\\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\\n * returns a single octet.\\n *\\n * The `Uint8Array` prototype remains unmodified.\\n */\\n\\nfunction Buffer (arg, encodingOrOffset, length) {\\n  // Common case.\\n  if (typeof arg === 'number') {\\n    if (typeof encodingOrOffset === 'string') {\\n      throw new TypeError(\\n        'The \\\"string\\\" argument must be of type string. Received type number'\\n      )\\n    }\\n    return allocUnsafe(arg)\\n  }\\n  return from(arg, encodingOrOffset, length)\\n}\\n\\nBuffer.poolSize = 8192 // not used by this implementation\\n\\nfunction from (value, encodingOrOffset, length) {\\n  if (typeof value === 'string') {\\n    return fromString(value, encodingOrOffset)\\n  }\\n\\n  if (ArrayBuffer.isView(value)) {\\n    return fromArrayView(value)\\n  }\\n\\n  if (value == null) {\\n    throw new TypeError(\\n      'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\\n      'or Array-like Object. Received type ' + (typeof value)\\n    )\\n  }\\n\\n  if (isInstance(value, ArrayBuffer) ||\\n      (value && isInstance(value.buffer, ArrayBuffer))) {\\n    return fromArrayBuffer(value, encodingOrOffset, length)\\n  }\\n\\n  if (typeof SharedArrayBuffer !== 'undefined' &&\\n      (isInstance(value, SharedArrayBuffer) ||\\n      (value && isInstance(value.buffer, SharedArrayBuffer)))) {\\n    return fromArrayBuffer(value, encodingOrOffset, length)\\n  }\\n\\n  if (typeof value === 'number') {\\n    throw new TypeError(\\n      'The \\\"value\\\" argument must not be of type number. Received type number'\\n    )\\n  }\\n\\n  const valueOf = value.valueOf && value.valueOf()\\n  if (valueOf != null && valueOf !== value) {\\n    return Buffer.from(valueOf, encodingOrOffset, length)\\n  }\\n\\n  const b = fromObject(value)\\n  if (b) return b\\n\\n  if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&\\n      typeof value[Symbol.toPrimitive] === 'function') {\\n    return Buffer.from(value[Symbol.toPrimitive]('string'), encodingOrOffset, length)\\n  }\\n\\n  throw new TypeError(\\n    'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\\n    'or Array-like Object. Received type ' + (typeof value)\\n  )\\n}\\n\\n/**\\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\\n * if value is a number.\\n * Buffer.from(str[, encoding])\\n * Buffer.from(array)\\n * Buffer.from(buffer)\\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\\n **/\\nBuffer.from = function (value, encodingOrOffset, length) {\\n  return from(value, encodingOrOffset, length)\\n}\\n\\n// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:\\n// https://github.com/feross/buffer/pull/148\\nObject.setPrototypeOf(Buffer.prototype, Uint8Array.prototype)\\nObject.setPrototypeOf(Buffer, Uint8Array)\\n\\nfunction assertSize (size) {\\n  if (typeof size !== 'number') {\\n    throw new TypeError('\\\"size\\\" argument must be of type number')\\n  } else if (size < 0) {\\n    throw new RangeError('The value \\\"' + size + '\\\" is invalid for option \\\"size\\\"')\\n  }\\n}\\n\\nfunction alloc (size, fill, encoding) {\\n  assertSize(size)\\n  if (size <= 0) {\\n    return createBuffer(size)\\n  }\\n  if (fill !== undefined) {\\n    // Only pay attention to encoding if it's a string. This\\n    // prevents accidentally sending in a number that would\\n    // be interpreted as a start offset.\\n    return typeof encoding === 'string'\\n      ? createBuffer(size).fill(fill, encoding)\\n      : createBuffer(size).fill(fill)\\n  }\\n  return createBuffer(size)\\n}\\n\\n/**\\n * Creates a new filled Buffer instance.\\n * alloc(size[, fill[, encoding]])\\n **/\\nBuffer.alloc = function (size, fill, encoding) {\\n  return alloc(size, fill, encoding)\\n}\\n\\nfunction allocUnsafe (size) {\\n  assertSize(size)\\n  return createBuffer(size < 0 ? 0 : checked(size) | 0)\\n}\\n\\n/**\\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\\n * */\\nBuffer.allocUnsafe = function (size) {\\n  return allocUnsafe(size)\\n}\\n/**\\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\\n */\\nBuffer.allocUnsafeSlow = function (size) {\\n  return allocUnsafe(size)\\n}\\n\\nfunction fromString (string, encoding) {\\n  if (typeof encoding !== 'string' || encoding === '') {\\n    encoding = 'utf8'\\n  }\\n\\n  if (!Buffer.isEncoding(encoding)) {\\n    throw new TypeError('Unknown encoding: ' + encoding)\\n  }\\n\\n  const length = byteLength(string, encoding) | 0\\n  let buf = createBuffer(length)\\n\\n  const actual = buf.write(string, encoding)\\n\\n  if (actual !== length) {\\n    // Writing a hex string, for example, that contains invalid characters will\\n    // cause everything after the first invalid character to be ignored. (e.g.\\n    // 'abxxcd' will be treated as 'ab')\\n    buf = buf.slice(0, actual)\\n  }\\n\\n  return buf\\n}\\n\\nfunction fromArrayLike (array) {\\n  const length = array.length < 0 ? 0 : checked(array.length) | 0\\n  const buf = createBuffer(length)\\n  for (let i = 0; i < length; i += 1) {\\n    buf[i] = array[i] & 255\\n  }\\n  return buf\\n}\\n\\nfunction fromArrayView (arrayView) {\\n  if (isInstance(arrayView, Uint8Array)) {\\n    const copy = new Uint8Array(arrayView)\\n    return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength)\\n  }\\n  return fromArrayLike(arrayView)\\n}\\n\\nfunction fromArrayBuffer (array, byteOffset, length) {\\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\\n    throw new RangeError('\\\"offset\\\" is outside of buffer bounds')\\n  }\\n\\n  if (array.byteLength < byteOffset + (length || 0)) {\\n    throw new RangeError('\\\"length\\\" is outside of buffer bounds')\\n  }\\n\\n  let buf\\n  if (byteOffset === undefined && length === undefined) {\\n    buf = new Uint8Array(array)\\n  } else if (length === undefined) {\\n    buf = new Uint8Array(array, byteOffset)\\n  } else {\\n    buf = new Uint8Array(array, byteOffset, length)\\n  }\\n\\n  // Return an augmented `Uint8Array` instance\\n  Object.setPrototypeOf(buf, Buffer.prototype)\\n\\n  return buf\\n}\\n\\nfunction fromObject (obj) {\\n  if (Buffer.isBuffer(obj)) {\\n    const len = checked(obj.length) | 0\\n    const buf = createBuffer(len)\\n\\n    if (buf.length === 0) {\\n      return buf\\n    }\\n\\n    obj.copy(buf, 0, 0, len)\\n    return buf\\n  }\\n\\n  if (obj.length !== undefined) {\\n    if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {\\n      return createBuffer(0)\\n    }\\n    return fromArrayLike(obj)\\n  }\\n\\n  if (obj.type === 'Buffer' && Array.isArray(obj.data)) {\\n    return fromArrayLike(obj.data)\\n  }\\n}\\n\\nfunction checked (length) {\\n  // Note: cannot use `length < K_MAX_LENGTH` here because that fails when\\n  // length is NaN (which is otherwise coerced to zero.)\\n  if (length >= K_MAX_LENGTH) {\\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\\n                         'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')\\n  }\\n  return length | 0\\n}\\n\\nfunction SlowBuffer (length) {\\n  if (+length != length) { // eslint-disable-line eqeqeq\\n    length = 0\\n  }\\n  return Buffer.alloc(+length)\\n}\\n\\nBuffer.isBuffer = function isBuffer (b) {\\n  return b != null && b._isBuffer === true &&\\n    b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false\\n}\\n\\nBuffer.compare = function compare (a, b) {\\n  if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)\\n  if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)\\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\\n    throw new TypeError(\\n      'The \\\"buf1\\\", \\\"buf2\\\" arguments must be one of type Buffer or Uint8Array'\\n    )\\n  }\\n\\n  if (a === b) return 0\\n\\n  let x = a.length\\n  let y = b.length\\n\\n  for (let i = 0, len = Math.min(x, y); i < len; ++i) {\\n    if (a[i] !== b[i]) {\\n      x = a[i]\\n      y = b[i]\\n      break\\n    }\\n  }\\n\\n  if (x < y) return -1\\n  if (y < x) return 1\\n  return 0\\n}\\n\\nBuffer.isEncoding = function isEncoding (encoding) {\\n  switch (String(encoding).toLowerCase()) {\\n    case 'hex':\\n    case 'utf8':\\n    case 'utf-8':\\n    case 'ascii':\\n    case 'latin1':\\n    case 'binary':\\n    case 'base64':\\n    case 'ucs2':\\n    case 'ucs-2':\\n    case 'utf16le':\\n    case 'utf-16le':\\n      return true\\n    default:\\n      return false\\n  }\\n}\\n\\nBuffer.concat = function concat (list, length) {\\n  if (!Array.isArray(list)) {\\n    throw new TypeError('\\\"list\\\" argument must be an Array of Buffers')\\n  }\\n\\n  if (list.length === 0) {\\n    return Buffer.alloc(0)\\n  }\\n\\n  let i\\n  if (length === undefined) {\\n    length = 0\\n    for (i = 0; i < list.length; ++i) {\\n      length += list[i].length\\n    }\\n  }\\n\\n  const buffer = Buffer.allocUnsafe(length)\\n  let pos = 0\\n  for (i = 0; i < list.length; ++i) {\\n    let buf = list[i]\\n    if (isInstance(buf, Uint8Array)) {\\n      if (pos + buf.length > buffer.length) {\\n        if (!Buffer.isBuffer(buf)) buf = Buffer.from(buf)\\n        buf.copy(buffer, pos)\\n      } else {\\n        Uint8Array.prototype.set.call(\\n          buffer,\\n          buf,\\n          pos\\n        )\\n      }\\n    } else if (!Buffer.isBuffer(buf)) {\\n      throw new TypeError('\\\"list\\\" argument must be an Array of Buffers')\\n    } else {\\n      buf.copy(buffer, pos)\\n    }\\n    pos += buf.length\\n  }\\n  return buffer\\n}\\n\\nfunction byteLength (string, encoding) {\\n  if (Buffer.isBuffer(string)) {\\n    return string.length\\n  }\\n  if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {\\n    return string.byteLength\\n  }\\n  if (typeof string !== 'string') {\\n    throw new TypeError(\\n      'The \\\"string\\\" argument must be one of type string, Buffer, or ArrayBuffer. ' +\\n      'Received type ' + typeof string\\n    )\\n  }\\n\\n  const len = string.length\\n  const mustMatch = (arguments.length > 2 && arguments[2] === true)\\n  if (!mustMatch && len === 0) return 0\\n\\n  // Use a for loop to avoid recursion\\n  let loweredCase = false\\n  for (;;) {\\n    switch (encoding) {\\n      case 'ascii':\\n      case 'latin1':\\n      case 'binary':\\n        return len\\n      case 'utf8':\\n      case 'utf-8':\\n        return utf8ToBytes(string).length\\n      case 'ucs2':\\n      case 'ucs-2':\\n      case 'utf16le':\\n      case 'utf-16le':\\n        return len * 2\\n      case 'hex':\\n        return len >>> 1\\n      case 'base64':\\n        return base64ToBytes(string).length\\n      default:\\n        if (loweredCase) {\\n          return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8\\n        }\\n        encoding = ('' + encoding).toLowerCase()\\n        loweredCase = true\\n    }\\n  }\\n}\\nBuffer.byteLength = byteLength\\n\\nfunction slowToString (encoding, start, end) {\\n  let loweredCase = false\\n\\n  // No need to verify that \\\"this.length <= MAX_UINT32\\\" since it's a read-only\\n  // property of a typed array.\\n\\n  // This behaves neither like String nor Uint8Array in that we set start/end\\n  // to their upper/lower bounds if the value passed is out of range.\\n  // undefined is handled specially as per ECMA-262 6th Edition,\\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\\n  if (start === undefined || start < 0) {\\n    start = 0\\n  }\\n  // Return early if start > this.length. Done here to prevent potential uint32\\n  // coercion fail below.\\n  if (start > this.length) {\\n    return ''\\n  }\\n\\n  if (end === undefined || end > this.length) {\\n    end = this.length\\n  }\\n\\n  if (end <= 0) {\\n    return ''\\n  }\\n\\n  // Force coercion to uint32. This will also coerce falsey/NaN values to 0.\\n  end >>>= 0\\n  start >>>= 0\\n\\n  if (end <= start) {\\n    return ''\\n  }\\n\\n  if (!encoding) encoding = 'utf8'\\n\\n  while (true) {\\n    switch (encoding) {\\n      case 'hex':\\n        return hexSlice(this, start, end)\\n\\n      case 'utf8':\\n      case 'utf-8':\\n        return utf8Slice(this, start, end)\\n\\n      case 'ascii':\\n        return asciiSlice(this, start, end)\\n\\n      case 'latin1':\\n      case 'binary':\\n        return latin1Slice(this, start, end)\\n\\n      case 'base64':\\n        return base64Slice(this, start, end)\\n\\n      case 'ucs2':\\n      case 'ucs-2':\\n      case 'utf16le':\\n      case 'utf-16le':\\n        return utf16leSlice(this, start, end)\\n\\n      default:\\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\\n        encoding = (encoding + '').toLowerCase()\\n        loweredCase = true\\n    }\\n  }\\n}\\n\\n// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)\\n// to detect a Buffer instance. It's not possible to use `instanceof Buffer`\\n// reliably in a browserify context because there could be multiple different\\n// copies of the 'buffer' package in use. This method works even for Buffer\\n// instances that were created from another copy of the `buffer` package.\\n// See: https://github.com/feross/buffer/issues/154\\nBuffer.prototype._isBuffer = true\\n\\nfunction swap (b, n, m) {\\n  const i = b[n]\\n  b[n] = b[m]\\n  b[m] = i\\n}\\n\\nBuffer.prototype.swap16 = function swap16 () {\\n  const len = this.length\\n  if (len % 2 !== 0) {\\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\\n  }\\n  for (let i = 0; i < len; i += 2) {\\n    swap(this, i, i + 1)\\n  }\\n  return this\\n}\\n\\nBuffer.prototype.swap32 = function swap32 () {\\n  const len = this.length\\n  if (len % 4 !== 0) {\\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\\n  }\\n  for (let i = 0; i < len; i += 4) {\\n    swap(this, i, i + 3)\\n    swap(this, i + 1, i + 2)\\n  }\\n  return this\\n}\\n\\nBuffer.prototype.swap64 = function swap64 () {\\n  const len = this.length\\n  if (len % 8 !== 0) {\\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\\n  }\\n  for (let i = 0; i < len; i += 8) {\\n    swap(this, i, i + 7)\\n    swap(this, i + 1, i + 6)\\n    swap(this, i + 2, i + 5)\\n    swap(this, i + 3, i + 4)\\n  }\\n  return this\\n}\\n\\nBuffer.prototype.toString = function toString () {\\n  const length = this.length\\n  if (length === 0) return ''\\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\\n  return slowToString.apply(this, arguments)\\n}\\n\\nBuffer.prototype.toLocaleString = Buffer.prototype.toString\\n\\nBuffer.prototype.equals = function equals (b) {\\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\\n  if (this === b) return true\\n  return Buffer.compare(this, b) === 0\\n}\\n\\nBuffer.prototype.inspect = function inspect () {\\n  let str = ''\\n  const max = exports.INSPECT_MAX_BYTES\\n  str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()\\n  if (this.length > max) str += ' ... '\\n  return '<Buffer ' + str + '>'\\n}\\nif (customInspectSymbol) {\\n  Buffer.prototype[customInspectSymbol] = Buffer.prototype.inspect\\n}\\n\\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\\n  if (isInstance(target, Uint8Array)) {\\n    target = Buffer.from(target, target.offset, target.byteLength)\\n  }\\n  if (!Buffer.isBuffer(target)) {\\n    throw new TypeError(\\n      'The \\\"target\\\" argument must be one of type Buffer or Uint8Array. ' +\\n      'Received type ' + (typeof target)\\n    )\\n  }\\n\\n  if (start === undefined) {\\n    start = 0\\n  }\\n  if (end === undefined) {\\n    end = target ? target.length : 0\\n  }\\n  if (thisStart === undefined) {\\n    thisStart = 0\\n  }\\n  if (thisEnd === undefined) {\\n    thisEnd = this.length\\n  }\\n\\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\\n    throw new RangeError('out of range index')\\n  }\\n\\n  if (thisStart >= thisEnd && start >= end) {\\n    return 0\\n  }\\n  if (thisStart >= thisEnd) {\\n    return -1\\n  }\\n  if (start >= end) {\\n    return 1\\n  }\\n\\n  start >>>= 0\\n  end >>>= 0\\n  thisStart >>>= 0\\n  thisEnd >>>= 0\\n\\n  if (this === target) return 0\\n\\n  let x = thisEnd - thisStart\\n  let y = end - start\\n  const len = Math.min(x, y)\\n\\n  const thisCopy = this.slice(thisStart, thisEnd)\\n  const targetCopy = target.slice(start, end)\\n\\n  for (let i = 0; i < len; ++i) {\\n    if (thisCopy[i] !== targetCopy[i]) {\\n      x = thisCopy[i]\\n      y = targetCopy[i]\\n      break\\n    }\\n  }\\n\\n  if (x < y) return -1\\n  if (y < x) return 1\\n  return 0\\n}\\n\\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\\n//\\n// Arguments:\\n// - buffer - a Buffer to search\\n// - val - a string, Buffer, or number\\n// - byteOffset - an index into `buffer`; will be clamped to an int32\\n// - encoding - an optional encoding, relevant is val is a string\\n// - dir - true for indexOf, false for lastIndexOf\\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\\n  // Empty buffer means no match\\n  if (buffer.length === 0) return -1\\n\\n  // Normalize byteOffset\\n  if (typeof byteOffset === 'string') {\\n    encoding = byteOffset\\n    byteOffset = 0\\n  } else if (byteOffset > 0x7fffffff) {\\n    byteOffset = 0x7fffffff\\n  } else if (byteOffset < -0x80000000) {\\n    byteOffset = -0x80000000\\n  }\\n  byteOffset = +byteOffset // Coerce to Number.\\n  if (numberIsNaN(byteOffset)) {\\n    // byteOffset: it it's undefined, null, NaN, \\\"foo\\\", etc, search whole buffer\\n    byteOffset = dir ? 0 : (buffer.length - 1)\\n  }\\n\\n  // Normalize byteOffset: negative offsets start from the end of the buffer\\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\\n  if (byteOffset >= buffer.length) {\\n    if (dir) return -1\\n    else byteOffset = buffer.length - 1\\n  } else if (byteOffset < 0) {\\n    if (dir) byteOffset = 0\\n    else return -1\\n  }\\n\\n  // Normalize val\\n  if (typeof val === 'string') {\\n    val = Buffer.from(val, encoding)\\n  }\\n\\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\\n  if (Buffer.isBuffer(val)) {\\n    // Special case: looking for empty string/buffer always fails\\n    if (val.length === 0) {\\n      return -1\\n    }\\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\\n  } else if (typeof val === 'number') {\\n    val = val & 0xFF // Search for a byte value [0-255]\\n    if (typeof Uint8Array.prototype.indexOf === 'function') {\\n      if (dir) {\\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\\n      } else {\\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\\n      }\\n    }\\n    return arrayIndexOf(buffer, [val], byteOffset, encoding, dir)\\n  }\\n\\n  throw new TypeError('val must be string, number or Buffer')\\n}\\n\\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\\n  let indexSize = 1\\n  let arrLength = arr.length\\n  let valLength = val.length\\n\\n  if (encoding !== undefined) {\\n    encoding = String(encoding).toLowerCase()\\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\\n        encoding === 'utf16le' || encoding === 'utf-16le') {\\n      if (arr.length < 2 || val.length < 2) {\\n        return -1\\n      }\\n      indexSize = 2\\n      arrLength /= 2\\n      valLength /= 2\\n      byteOffset /= 2\\n    }\\n  }\\n\\n  function read (buf, i) {\\n    if (indexSize === 1) {\\n      return buf[i]\\n    } else {\\n      return buf.readUInt16BE(i * indexSize)\\n    }\\n  }\\n\\n  let i\\n  if (dir) {\\n    let foundIndex = -1\\n    for (i = byteOffset; i < arrLength; i++) {\\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\\n        if (foundIndex === -1) foundIndex = i\\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\\n      } else {\\n        if (foundIndex !== -1) i -= i - foundIndex\\n        foundIndex = -1\\n      }\\n    }\\n  } else {\\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\\n    for (i = byteOffset; i >= 0; i--) {\\n      let found = true\\n      for (let j = 0; j < valLength; j++) {\\n        if (read(arr, i + j) !== read(val, j)) {\\n          found = false\\n          break\\n        }\\n      }\\n      if (found) return i\\n    }\\n  }\\n\\n  return -1\\n}\\n\\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\\n  return this.indexOf(val, byteOffset, encoding) !== -1\\n}\\n\\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\\n}\\n\\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\\n}\\n\\nfunction hexWrite (buf, string, offset, length) {\\n  offset = Number(offset) || 0\\n  const remaining = buf.length - offset\\n  if (!length) {\\n    length = remaining\\n  } else {\\n    length = Number(length)\\n    if (length > remaining) {\\n      length = remaining\\n    }\\n  }\\n\\n  const strLen = string.length\\n\\n  if (length > strLen / 2) {\\n    length = strLen / 2\\n  }\\n  let i\\n  for (i = 0; i < length; ++i) {\\n    const parsed = parseInt(string.substr(i * 2, 2), 16)\\n    if (numberIsNaN(parsed)) return i\\n    buf[offset + i] = parsed\\n  }\\n  return i\\n}\\n\\nfunction utf8Write (buf, string, offset, length) {\\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\\n}\\n\\nfunction asciiWrite (buf, string, offset, length) {\\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\\n}\\n\\nfunction base64Write (buf, string, offset, length) {\\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\\n}\\n\\nfunction ucs2Write (buf, string, offset, length) {\\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\\n}\\n\\nBuffer.prototype.write = function write (string, offset, length, encoding) {\\n  // Buffer#write(string)\\n  if (offset === undefined) {\\n    encoding = 'utf8'\\n    length = this.length\\n    offset = 0\\n  // Buffer#write(string, encoding)\\n  } else if (length === undefined && typeof offset === 'string') {\\n    encoding = offset\\n    length = this.length\\n    offset = 0\\n  // Buffer#write(string, offset[, length][, encoding])\\n  } else if (isFinite(offset)) {\\n    offset = offset >>> 0\\n    if (isFinite(length)) {\\n      length = length >>> 0\\n      if (encoding === undefined) encoding = 'utf8'\\n    } else {\\n      encoding = length\\n      length = undefined\\n    }\\n  } else {\\n    throw new Error(\\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\\n    )\\n  }\\n\\n  const remaining = this.length - offset\\n  if (length === undefined || length > remaining) length = remaining\\n\\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\\n    throw new RangeError('Attempt to write outside buffer bounds')\\n  }\\n\\n  if (!encoding) encoding = 'utf8'\\n\\n  let loweredCase = false\\n  for (;;) {\\n    switch (encoding) {\\n      case 'hex':\\n        return hexWrite(this, string, offset, length)\\n\\n      case 'utf8':\\n      case 'utf-8':\\n        return utf8Write(this, string, offset, length)\\n\\n      case 'ascii':\\n      case 'latin1':\\n      case 'binary':\\n        return asciiWrite(this, string, offset, length)\\n\\n      case 'base64':\\n        // Warning: maxLength not taken into account in base64Write\\n        return base64Write(this, string, offset, length)\\n\\n      case 'ucs2':\\n      case 'ucs-2':\\n      case 'utf16le':\\n      case 'utf-16le':\\n        return ucs2Write(this, string, offset, length)\\n\\n      default:\\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\\n        encoding = ('' + encoding).toLowerCase()\\n        loweredCase = true\\n    }\\n  }\\n}\\n\\nBuffer.prototype.toJSON = function toJSON () {\\n  return {\\n    type: 'Buffer',\\n    data: Array.prototype.slice.call(this._arr || this, 0)\\n  }\\n}\\n\\nfunction base64Slice (buf, start, end) {\\n  if (start === 0 && end === buf.length) {\\n    return base64.fromByteArray(buf)\\n  } else {\\n    return base64.fromByteArray(buf.slice(start, end))\\n  }\\n}\\n\\nfunction utf8Slice (buf, start, end) {\\n  end = Math.min(buf.length, end)\\n  const res = []\\n\\n  let i = start\\n  while (i < end) {\\n    const firstByte = buf[i]\\n    let codePoint = null\\n    let bytesPerSequence = (firstByte > 0xEF)\\n      ? 4\\n      : (firstByte > 0xDF)\\n          ? 3\\n          : (firstByte > 0xBF)\\n              ? 2\\n              : 1\\n\\n    if (i + bytesPerSequence <= end) {\\n      let secondByte, thirdByte, fourthByte, tempCodePoint\\n\\n      switch (bytesPerSequence) {\\n        case 1:\\n          if (firstByte < 0x80) {\\n            codePoint = firstByte\\n          }\\n          break\\n        case 2:\\n          secondByte = buf[i + 1]\\n          if ((secondByte & 0xC0) === 0x80) {\\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\\n            if (tempCodePoint > 0x7F) {\\n              codePoint = tempCodePoint\\n            }\\n          }\\n          break\\n        case 3:\\n          secondByte = buf[i + 1]\\n          thirdByte = buf[i + 2]\\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\\n              codePoint = tempCodePoint\\n            }\\n          }\\n          break\\n        case 4:\\n          secondByte = buf[i + 1]\\n          thirdByte = buf[i + 2]\\n          fourthByte = buf[i + 3]\\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\\n              codePoint = tempCodePoint\\n            }\\n          }\\n      }\\n    }\\n\\n    if (codePoint === null) {\\n      // we did not generate a valid codePoint so insert a\\n      // replacement char (U+FFFD) and advance only 1 byte\\n      codePoint = 0xFFFD\\n      bytesPerSequence = 1\\n    } else if (codePoint > 0xFFFF) {\\n      // encode to utf16 (surrogate pair dance)\\n      codePoint -= 0x10000\\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\\n      codePoint = 0xDC00 | codePoint & 0x3FF\\n    }\\n\\n    res.push(codePoint)\\n    i += bytesPerSequence\\n  }\\n\\n  return decodeCodePointsArray(res)\\n}\\n\\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\\n// the lowest limit is Chrome, with 0x10000 args.\\n// We go 1 magnitude less, for safety\\nconst MAX_ARGUMENTS_LENGTH = 0x1000\\n\\nfunction decodeCodePointsArray (codePoints) {\\n  const len = codePoints.length\\n  if (len <= MAX_ARGUMENTS_LENGTH) {\\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\\n  }\\n\\n  // Decode in chunks to avoid \\\"call stack size exceeded\\\".\\n  let res = ''\\n  let i = 0\\n  while (i < len) {\\n    res += String.fromCharCode.apply(\\n      String,\\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\\n    )\\n  }\\n  return res\\n}\\n\\nfunction asciiSlice (buf, start, end) {\\n  let ret = ''\\n  end = Math.min(buf.length, end)\\n\\n  for (let i = start; i < end; ++i) {\\n    ret += String.fromCharCode(buf[i] & 0x7F)\\n  }\\n  return ret\\n}\\n\\nfunction latin1Slice (buf, start, end) {\\n  let ret = ''\\n  end = Math.min(buf.length, end)\\n\\n  for (let i = start; i < end; ++i) {\\n    ret += String.fromCharCode(buf[i])\\n  }\\n  return ret\\n}\\n\\nfunction hexSlice (buf, start, end) {\\n  const len = buf.length\\n\\n  if (!start || start < 0) start = 0\\n  if (!end || end < 0 || end > len) end = len\\n\\n  let out = ''\\n  for (let i = start; i < end; ++i) {\\n    out += hexSliceLookupTable[buf[i]]\\n  }\\n  return out\\n}\\n\\nfunction utf16leSlice (buf, start, end) {\\n  const bytes = buf.slice(start, end)\\n  let res = ''\\n  // If bytes.length is odd, the last 8 bits must be ignored (same as node.js)\\n  for (let i = 0; i < bytes.length - 1; i += 2) {\\n    res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256))\\n  }\\n  return res\\n}\\n\\nBuffer.prototype.slice = function slice (start, end) {\\n  const len = this.length\\n  start = ~~start\\n  end = end === undefined ? len : ~~end\\n\\n  if (start < 0) {\\n    start += len\\n    if (start < 0) start = 0\\n  } else if (start > len) {\\n    start = len\\n  }\\n\\n  if (end < 0) {\\n    end += len\\n    if (end < 0) end = 0\\n  } else if (end > len) {\\n    end = len\\n  }\\n\\n  if (end < start) end = start\\n\\n  const newBuf = this.subarray(start, end)\\n  // Return an augmented `Uint8Array` instance\\n  Object.setPrototypeOf(newBuf, Buffer.prototype)\\n\\n  return newBuf\\n}\\n\\n/*\\n * Need to make sure that buffer isn't trying to write out of bounds.\\n */\\nfunction checkOffset (offset, ext, length) {\\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\\n}\\n\\nBuffer.prototype.readUintLE =\\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\\n  offset = offset >>> 0\\n  byteLength = byteLength >>> 0\\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\\n\\n  let val = this[offset]\\n  let mul = 1\\n  let i = 0\\n  while (++i < byteLength && (mul *= 0x100)) {\\n    val += this[offset + i] * mul\\n  }\\n\\n  return val\\n}\\n\\nBuffer.prototype.readUintBE =\\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\\n  offset = offset >>> 0\\n  byteLength = byteLength >>> 0\\n  if (!noAssert) {\\n    checkOffset(offset, byteLength, this.length)\\n  }\\n\\n  let val = this[offset + --byteLength]\\n  let mul = 1\\n  while (byteLength > 0 && (mul *= 0x100)) {\\n    val += this[offset + --byteLength] * mul\\n  }\\n\\n  return val\\n}\\n\\nBuffer.prototype.readUint8 =\\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\\n  offset = offset >>> 0\\n  if (!noAssert) checkOffset(offset, 1, this.length)\\n  return this[offset]\\n}\\n\\nBuffer.prototype.readUint16LE =\\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\\n  offset = offset >>> 0\\n  if (!noAssert) checkOffset(offset, 2, this.length)\\n  return this[offset] | (this[offset + 1] << 8)\\n}\\n\\nBuffer.prototype.readUint16BE =\\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\\n  offset = offset >>> 0\\n  if (!noAssert) checkOffset(offset, 2, this.length)\\n  return (this[offset] << 8) | this[offset + 1]\\n}\\n\\nBuffer.prototype.readUint32LE =\\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\\n  offset = offset >>> 0\\n  if (!noAssert) checkOffset(offset, 4, this.length)\\n\\n  return ((this[offset]) |\\n      (this[offset + 1] << 8) |\\n      (this[offset + 2] << 16)) +\\n      (this[offset + 3] * 0x1000000)\\n}\\n\\nBuffer.prototype.readUint32BE =\\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\\n  offset = offset >>> 0\\n  if (!noAssert) checkOffset(offset, 4, this.length)\\n\\n  return (this[offset] * 0x1000000) +\\n    ((this[offset + 1] << 16) |\\n    (this[offset + 2] << 8) |\\n    this[offset + 3])\\n}\\n\\nBuffer.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE (offset) {\\n  offset = offset >>> 0\\n  validateNumber(offset, 'offset')\\n  const first = this[offset]\\n  const last = this[offset + 7]\\n  if (first === undefined || last === undefined) {\\n    boundsError(offset, this.length - 8)\\n  }\\n\\n  const lo = first +\\n    this[++offset] * 2 ** 8 +\\n    this[++offset] * 2 ** 16 +\\n    this[++offset] * 2 ** 24\\n\\n  const hi = this[++offset] +\\n    this[++offset] * 2 ** 8 +\\n    this[++offset] * 2 ** 16 +\\n    last * 2 ** 24\\n\\n  return BigInt(lo) + (BigInt(hi) << BigInt(32))\\n})\\n\\nBuffer.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE (offset) {\\n  offset = offset >>> 0\\n  validateNumber(offset, 'offset')\\n  const first = this[offset]\\n  const last = this[offset + 7]\\n  if (first === undefined || last === undefined) {\\n    boundsError(offset, this.length - 8)\\n  }\\n\\n  const hi = first * 2 ** 24 +\\n    this[++offset] * 2 ** 16 +\\n    this[++offset] * 2 ** 8 +\\n    this[++offset]\\n\\n  const lo = this[++offset] * 2 ** 24 +\\n    this[++offset] * 2 ** 16 +\\n    this[++offset] * 2 ** 8 +\\n    last\\n\\n  return (BigInt(hi) << BigInt(32)) + BigInt(lo)\\n})\\n\\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\\n  offset = offset >>> 0\\n  byteLength = byteLength >>> 0\\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\\n\\n  let val = this[offset]\\n  let mul = 1\\n  let i = 0\\n  while (++i < byteLength && (mul *= 0x100)) {\\n    val += this[offset + i] * mul\\n  }\\n  mul *= 0x80\\n\\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\\n\\n  return val\\n}\\n\\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\\n  offset = offset >>> 0\\n  byteLength = byteLength >>> 0\\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\\n\\n  let i = byteLength\\n  let mul = 1\\n  let val = this[offset + --i]\\n  while (i > 0 && (mul *= 0x100)) {\\n    val += this[offset + --i] * mul\\n  }\\n  mul *= 0x80\\n\\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\\n\\n  return val\\n}\\n\\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\\n  offset = offset >>> 0\\n  if (!noAssert) checkOffset(offset, 1, this.length)\\n  if (!(this[offset] & 0x80)) return (this[offset])\\n  return ((0xff - this[offset] + 1) * -1)\\n}\\n\\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\\n  offset = offset >>> 0\\n  if (!noAssert) checkOffset(offset, 2, this.length)\\n  const val = this[offset] | (this[offset + 1] << 8)\\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\\n}\\n\\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\\n  offset = offset >>> 0\\n  if (!noAssert) checkOffset(offset, 2, this.length)\\n  const val = this[offset + 1] | (this[offset] << 8)\\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\\n}\\n\\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\\n  offset = offset >>> 0\\n  if (!noAssert) checkOffset(offset, 4, this.length)\\n\\n  return (this[offset]) |\\n    (this[offset + 1] << 8) |\\n    (this[offset + 2] << 16) |\\n    (this[offset + 3] << 24)\\n}\\n\\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\\n  offset = offset >>> 0\\n  if (!noAssert) checkOffset(offset, 4, this.length)\\n\\n  return (this[offset] << 24) |\\n    (this[offset + 1] << 16) |\\n    (this[offset + 2] << 8) |\\n    (this[offset + 3])\\n}\\n\\nBuffer.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE (offset) {\\n  offset = offset >>> 0\\n  validateNumber(offset, 'offset')\\n  const first = this[offset]\\n  const last = this[offset + 7]\\n  if (first === undefined || last === undefined) {\\n    boundsError(offset, this.length - 8)\\n  }\\n\\n  const val = this[offset + 4] +\\n    this[offset + 5] * 2 ** 8 +\\n    this[offset + 6] * 2 ** 16 +\\n    (last << 24) // Overflow\\n\\n  return (BigInt(val) << BigInt(32)) +\\n    BigInt(first +\\n    this[++offset] * 2 ** 8 +\\n    this[++offset] * 2 ** 16 +\\n    this[++offset] * 2 ** 24)\\n})\\n\\nBuffer.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE (offset) {\\n  offset = offset >>> 0\\n  validateNumber(offset, 'offset')\\n  const first = this[offset]\\n  const last = this[offset + 7]\\n  if (first === undefined || last === undefined) {\\n    boundsError(offset, this.length - 8)\\n  }\\n\\n  const val = (first << 24) + // Overflow\\n    this[++offset] * 2 ** 16 +\\n    this[++offset] * 2 ** 8 +\\n    this[++offset]\\n\\n  return (BigInt(val) << BigInt(32)) +\\n    BigInt(this[++offset] * 2 ** 24 +\\n    this[++offset] * 2 ** 16 +\\n    this[++offset] * 2 ** 8 +\\n    last)\\n})\\n\\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\\n  offset = offset >>> 0\\n  if (!noAssert) checkOffset(offset, 4, this.length)\\n  return ieee754.read(this, offset, true, 23, 4)\\n}\\n\\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\\n  offset = offset >>> 0\\n  if (!noAssert) checkOffset(offset, 4, this.length)\\n  return ieee754.read(this, offset, false, 23, 4)\\n}\\n\\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\\n  offset = offset >>> 0\\n  if (!noAssert) checkOffset(offset, 8, this.length)\\n  return ieee754.read(this, offset, true, 52, 8)\\n}\\n\\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\\n  offset = offset >>> 0\\n  if (!noAssert) checkOffset(offset, 8, this.length)\\n  return ieee754.read(this, offset, false, 52, 8)\\n}\\n\\nfunction checkInt (buf, value, offset, ext, max, min) {\\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\\\"buffer\\\" argument must be a Buffer instance')\\n  if (value > max || value < min) throw new RangeError('\\\"value\\\" argument is out of bounds')\\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\\n}\\n\\nBuffer.prototype.writeUintLE =\\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\\n  value = +value\\n  offset = offset >>> 0\\n  byteLength = byteLength >>> 0\\n  if (!noAssert) {\\n    const maxBytes = Math.pow(2, 8 * byteLength) - 1\\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\\n  }\\n\\n  let mul = 1\\n  let i = 0\\n  this[offset] = value & 0xFF\\n  while (++i < byteLength && (mul *= 0x100)) {\\n    this[offset + i] = (value / mul) & 0xFF\\n  }\\n\\n  return offset + byteLength\\n}\\n\\nBuffer.prototype.writeUintBE =\\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\\n  value = +value\\n  offset = offset >>> 0\\n  byteLength = byteLength >>> 0\\n  if (!noAssert) {\\n    const maxBytes = Math.pow(2, 8 * byteLength) - 1\\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\\n  }\\n\\n  let i = byteLength - 1\\n  let mul = 1\\n  this[offset + i] = value & 0xFF\\n  while (--i >= 0 && (mul *= 0x100)) {\\n    this[offset + i] = (value / mul) & 0xFF\\n  }\\n\\n  return offset + byteLength\\n}\\n\\nBuffer.prototype.writeUint8 =\\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\\n  value = +value\\n  offset = offset >>> 0\\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\\n  this[offset] = (value & 0xff)\\n  return offset + 1\\n}\\n\\nBuffer.prototype.writeUint16LE =\\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\\n  value = +value\\n  offset = offset >>> 0\\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\\n  this[offset] = (value & 0xff)\\n  this[offset + 1] = (value >>> 8)\\n  return offset + 2\\n}\\n\\nBuffer.prototype.writeUint16BE =\\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\\n  value = +value\\n  offset = offset >>> 0\\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\\n  this[offset] = (value >>> 8)\\n  this[offset + 1] = (value & 0xff)\\n  return offset + 2\\n}\\n\\nBuffer.prototype.writeUint32LE =\\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\\n  value = +value\\n  offset = offset >>> 0\\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\\n  this[offset + 3] = (value >>> 24)\\n  this[offset + 2] = (value >>> 16)\\n  this[offset + 1] = (value >>> 8)\\n  this[offset] = (value & 0xff)\\n  return offset + 4\\n}\\n\\nBuffer.prototype.writeUint32BE =\\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\\n  value = +value\\n  offset = offset >>> 0\\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\\n  this[offset] = (value >>> 24)\\n  this[offset + 1] = (value >>> 16)\\n  this[offset + 2] = (value >>> 8)\\n  this[offset + 3] = (value & 0xff)\\n  return offset + 4\\n}\\n\\nfunction wrtBigUInt64LE (buf, value, offset, min, max) {\\n  checkIntBI(value, min, max, buf, offset, 7)\\n\\n  let lo = Number(value & BigInt(0xffffffff))\\n  buf[offset++] = lo\\n  lo = lo >> 8\\n  buf[offset++] = lo\\n  lo = lo >> 8\\n  buf[offset++] = lo\\n  lo = lo >> 8\\n  buf[offset++] = lo\\n  let hi = Number(value >> BigInt(32) & BigInt(0xffffffff))\\n  buf[offset++] = hi\\n  hi = hi >> 8\\n  buf[offset++] = hi\\n  hi = hi >> 8\\n  buf[offset++] = hi\\n  hi = hi >> 8\\n  buf[offset++] = hi\\n  return offset\\n}\\n\\nfunction wrtBigUInt64BE (buf, value, offset, min, max) {\\n  checkIntBI(value, min, max, buf, offset, 7)\\n\\n  let lo = Number(value & BigInt(0xffffffff))\\n  buf[offset + 7] = lo\\n  lo = lo >> 8\\n  buf[offset + 6] = lo\\n  lo = lo >> 8\\n  buf[offset + 5] = lo\\n  lo = lo >> 8\\n  buf[offset + 4] = lo\\n  let hi = Number(value >> BigInt(32) & BigInt(0xffffffff))\\n  buf[offset + 3] = hi\\n  hi = hi >> 8\\n  buf[offset + 2] = hi\\n  hi = hi >> 8\\n  buf[offset + 1] = hi\\n  hi = hi >> 8\\n  buf[offset] = hi\\n  return offset + 8\\n}\\n\\nBuffer.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE (value, offset = 0) {\\n  return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt('0xffffffffffffffff'))\\n})\\n\\nBuffer.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE (value, offset = 0) {\\n  return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt('0xffffffffffffffff'))\\n})\\n\\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\\n  value = +value\\n  offset = offset >>> 0\\n  if (!noAssert) {\\n    const limit = Math.pow(2, (8 * byteLength) - 1)\\n\\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\\n  }\\n\\n  let i = 0\\n  let mul = 1\\n  let sub = 0\\n  this[offset] = value & 0xFF\\n  while (++i < byteLength && (mul *= 0x100)) {\\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\\n      sub = 1\\n    }\\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\\n  }\\n\\n  return offset + byteLength\\n}\\n\\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\\n  value = +value\\n  offset = offset >>> 0\\n  if (!noAssert) {\\n    const limit = Math.pow(2, (8 * byteLength) - 1)\\n\\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\\n  }\\n\\n  let i = byteLength - 1\\n  let mul = 1\\n  let sub = 0\\n  this[offset + i] = value & 0xFF\\n  while (--i >= 0 && (mul *= 0x100)) {\\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\\n      sub = 1\\n    }\\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\\n  }\\n\\n  return offset + byteLength\\n}\\n\\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\\n  value = +value\\n  offset = offset >>> 0\\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\\n  if (value < 0) value = 0xff + value + 1\\n  this[offset] = (value & 0xff)\\n  return offset + 1\\n}\\n\\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\\n  value = +value\\n  offset = offset >>> 0\\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\\n  this[offset] = (value & 0xff)\\n  this[offset + 1] = (value >>> 8)\\n  return offset + 2\\n}\\n\\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\\n  value = +value\\n  offset = offset >>> 0\\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\\n  this[offset] = (value >>> 8)\\n  this[offset + 1] = (value & 0xff)\\n  return offset + 2\\n}\\n\\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\\n  value = +value\\n  offset = offset >>> 0\\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\\n  this[offset] = (value & 0xff)\\n  this[offset + 1] = (value >>> 8)\\n  this[offset + 2] = (value >>> 16)\\n  this[offset + 3] = (value >>> 24)\\n  return offset + 4\\n}\\n\\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\\n  value = +value\\n  offset = offset >>> 0\\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\\n  if (value < 0) value = 0xffffffff + value + 1\\n  this[offset] = (value >>> 24)\\n  this[offset + 1] = (value >>> 16)\\n  this[offset + 2] = (value >>> 8)\\n  this[offset + 3] = (value & 0xff)\\n  return offset + 4\\n}\\n\\nBuffer.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE (value, offset = 0) {\\n  return wrtBigUInt64LE(this, value, offset, -BigInt('0x8000000000000000'), BigInt('0x7fffffffffffffff'))\\n})\\n\\nBuffer.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE (value, offset = 0) {\\n  return wrtBigUInt64BE(this, value, offset, -BigInt('0x8000000000000000'), BigInt('0x7fffffffffffffff'))\\n})\\n\\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\\n  if (offset < 0) throw new RangeError('Index out of range')\\n}\\n\\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\\n  value = +value\\n  offset = offset >>> 0\\n  if (!noAssert) {\\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\\n  }\\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\\n  return offset + 4\\n}\\n\\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\\n  return writeFloat(this, value, offset, true, noAssert)\\n}\\n\\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\\n  return writeFloat(this, value, offset, false, noAssert)\\n}\\n\\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\\n  value = +value\\n  offset = offset >>> 0\\n  if (!noAssert) {\\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\\n  }\\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\\n  return offset + 8\\n}\\n\\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\\n  return writeDouble(this, value, offset, true, noAssert)\\n}\\n\\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\\n  return writeDouble(this, value, offset, false, noAssert)\\n}\\n\\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\\n  if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')\\n  if (!start) start = 0\\n  if (!end && end !== 0) end = this.length\\n  if (targetStart >= target.length) targetStart = target.length\\n  if (!targetStart) targetStart = 0\\n  if (end > 0 && end < start) end = start\\n\\n  // Copy 0 bytes; we're done\\n  if (end === start) return 0\\n  if (target.length === 0 || this.length === 0) return 0\\n\\n  // Fatal error conditions\\n  if (targetStart < 0) {\\n    throw new RangeError('targetStart out of bounds')\\n  }\\n  if (start < 0 || start >= this.length) throw new RangeError('Index out of range')\\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\\n\\n  // Are we oob?\\n  if (end > this.length) end = this.length\\n  if (target.length - targetStart < end - start) {\\n    end = target.length - targetStart + start\\n  }\\n\\n  const len = end - start\\n\\n  if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {\\n    // Use built-in when available, missing from IE11\\n    this.copyWithin(targetStart, start, end)\\n  } else {\\n    Uint8Array.prototype.set.call(\\n      target,\\n      this.subarray(start, end),\\n      targetStart\\n    )\\n  }\\n\\n  return len\\n}\\n\\n// Usage:\\n//    buffer.fill(number[, offset[, end]])\\n//    buffer.fill(buffer[, offset[, end]])\\n//    buffer.fill(string[, offset[, end]][, encoding])\\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\\n  // Handle string cases:\\n  if (typeof val === 'string') {\\n    if (typeof start === 'string') {\\n      encoding = start\\n      start = 0\\n      end = this.length\\n    } else if (typeof end === 'string') {\\n      encoding = end\\n      end = this.length\\n    }\\n    if (encoding !== undefined && typeof encoding !== 'string') {\\n      throw new TypeError('encoding must be a string')\\n    }\\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\\n      throw new TypeError('Unknown encoding: ' + encoding)\\n    }\\n    if (val.length === 1) {\\n      const code = val.charCodeAt(0)\\n      if ((encoding === 'utf8' && code < 128) ||\\n          encoding === 'latin1') {\\n        // Fast path: If `val` fits into a single byte, use that numeric value.\\n        val = code\\n      }\\n    }\\n  } else if (typeof val === 'number') {\\n    val = val & 255\\n  } else if (typeof val === 'boolean') {\\n    val = Number(val)\\n  }\\n\\n  // Invalid ranges are not set to a default, so can range check early.\\n  if (start < 0 || this.length < start || this.length < end) {\\n    throw new RangeError('Out of range index')\\n  }\\n\\n  if (end <= start) {\\n    return this\\n  }\\n\\n  start = start >>> 0\\n  end = end === undefined ? this.length : end >>> 0\\n\\n  if (!val) val = 0\\n\\n  let i\\n  if (typeof val === 'number') {\\n    for (i = start; i < end; ++i) {\\n      this[i] = val\\n    }\\n  } else {\\n    const bytes = Buffer.isBuffer(val)\\n      ? val\\n      : Buffer.from(val, encoding)\\n    const len = bytes.length\\n    if (len === 0) {\\n      throw new TypeError('The value \\\"' + val +\\n        '\\\" is invalid for argument \\\"value\\\"')\\n    }\\n    for (i = 0; i < end - start; ++i) {\\n      this[i + start] = bytes[i % len]\\n    }\\n  }\\n\\n  return this\\n}\\n\\n// CUSTOM ERRORS\\n// =============\\n\\n// Simplified versions from Node, changed for Buffer-only usage\\nconst errors = {}\\nfunction E (sym, getMessage, Base) {\\n  errors[sym] = class NodeError extends Base {\\n    constructor () {\\n      super()\\n\\n      Object.defineProperty(this, 'message', {\\n        value: getMessage.apply(this, arguments),\\n        writable: true,\\n        configurable: true\\n      })\\n\\n      // Add the error code to the name to include it in the stack trace.\\n      this.name = `${this.name} [${sym}]`\\n      // Access the stack to generate the error message including the error code\\n      // from the name.\\n      this.stack // eslint-disable-line no-unused-expressions\\n      // Reset the name to the actual name.\\n      delete this.name\\n    }\\n\\n    get code () {\\n      return sym\\n    }\\n\\n    set code (value) {\\n      Object.defineProperty(this, 'code', {\\n        configurable: true,\\n        enumerable: true,\\n        value,\\n        writable: true\\n      })\\n    }\\n\\n    toString () {\\n      return `${this.name} [${sym}]: ${this.message}`\\n    }\\n  }\\n}\\n\\nE('ERR_BUFFER_OUT_OF_BOUNDS',\\n  function (name) {\\n    if (name) {\\n      return `${name} is outside of buffer bounds`\\n    }\\n\\n    return 'Attempt to access memory outside buffer bounds'\\n  }, RangeError)\\nE('ERR_INVALID_ARG_TYPE',\\n  function (name, actual) {\\n    return `The \\\"${name}\\\" argument must be of type number. Received type ${typeof actual}`\\n  }, TypeError)\\nE('ERR_OUT_OF_RANGE',\\n  function (str, range, input) {\\n    let msg = `The value of \\\"${str}\\\" is out of range.`\\n    let received = input\\n    if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {\\n      received = addNumericalSeparator(String(input))\\n    } else if (typeof input === 'bigint') {\\n      received = String(input)\\n      if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) {\\n        received = addNumericalSeparator(received)\\n      }\\n      received += 'n'\\n    }\\n    msg += ` It must be ${range}. Received ${received}`\\n    return msg\\n  }, RangeError)\\n\\nfunction addNumericalSeparator (val) {\\n  let res = ''\\n  let i = val.length\\n  const start = val[0] === '-' ? 1 : 0\\n  for (; i >= start + 4; i -= 3) {\\n    res = `_${val.slice(i - 3, i)}${res}`\\n  }\\n  return `${val.slice(0, i)}${res}`\\n}\\n\\n// CHECK FUNCTIONS\\n// ===============\\n\\nfunction checkBounds (buf, offset, byteLength) {\\n  validateNumber(offset, 'offset')\\n  if (buf[offset] === undefined || buf[offset + byteLength] === undefined) {\\n    boundsError(offset, buf.length - (byteLength + 1))\\n  }\\n}\\n\\nfunction checkIntBI (value, min, max, buf, offset, byteLength) {\\n  if (value > max || value < min) {\\n    const n = typeof min === 'bigint' ? 'n' : ''\\n    let range\\n    if (byteLength > 3) {\\n      if (min === 0 || min === BigInt(0)) {\\n        range = `>= 0${n} and < 2${n} ** ${(byteLength + 1) * 8}${n}`\\n      } else {\\n        range = `>= -(2${n} ** ${(byteLength + 1) * 8 - 1}${n}) and < 2 ** ` +\\n                `${(byteLength + 1) * 8 - 1}${n}`\\n      }\\n    } else {\\n      range = `>= ${min}${n} and <= ${max}${n}`\\n    }\\n    throw new errors.ERR_OUT_OF_RANGE('value', range, value)\\n  }\\n  checkBounds(buf, offset, byteLength)\\n}\\n\\nfunction validateNumber (value, name) {\\n  if (typeof value !== 'number') {\\n    throw new errors.ERR_INVALID_ARG_TYPE(name, 'number', value)\\n  }\\n}\\n\\nfunction boundsError (value, length, type) {\\n  if (Math.floor(value) !== value) {\\n    validateNumber(value, type)\\n    throw new errors.ERR_OUT_OF_RANGE(type || 'offset', 'an integer', value)\\n  }\\n\\n  if (length < 0) {\\n    throw new errors.ERR_BUFFER_OUT_OF_BOUNDS()\\n  }\\n\\n  throw new errors.ERR_OUT_OF_RANGE(type || 'offset',\\n                                    `>= ${type ? 1 : 0} and <= ${length}`,\\n                                    value)\\n}\\n\\n// HELPER FUNCTIONS\\n// ================\\n\\nconst INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g\\n\\nfunction base64clean (str) {\\n  // Node takes equal signs as end of the Base64 encoding\\n  str = str.split('=')[0]\\n  // Node strips out invalid characters like \\\\n and \\\\t from the string, base64-js does not\\n  str = str.trim().replace(INVALID_BASE64_RE, '')\\n  // Node converts strings with length < 2 to ''\\n  if (str.length < 2) return ''\\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\\n  while (str.length % 4 !== 0) {\\n    str = str + '='\\n  }\\n  return str\\n}\\n\\nfunction utf8ToBytes (string, units) {\\n  units = units || Infinity\\n  let codePoint\\n  const length = string.length\\n  let leadSurrogate = null\\n  const bytes = []\\n\\n  for (let i = 0; i < length; ++i) {\\n    codePoint = string.charCodeAt(i)\\n\\n    // is surrogate component\\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\\n      // last char was a lead\\n      if (!leadSurrogate) {\\n        // no lead yet\\n        if (codePoint > 0xDBFF) {\\n          // unexpected trail\\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\\n          continue\\n        } else if (i + 1 === length) {\\n          // unpaired lead\\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\\n          continue\\n        }\\n\\n        // valid lead\\n        leadSurrogate = codePoint\\n\\n        continue\\n      }\\n\\n      // 2 leads in a row\\n      if (codePoint < 0xDC00) {\\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\\n        leadSurrogate = codePoint\\n        continue\\n      }\\n\\n      // valid surrogate pair\\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\\n    } else if (leadSurrogate) {\\n      // valid bmp char, but last char was a lead\\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\\n    }\\n\\n    leadSurrogate = null\\n\\n    // encode utf8\\n    if (codePoint < 0x80) {\\n      if ((units -= 1) < 0) break\\n      bytes.push(codePoint)\\n    } else if (codePoint < 0x800) {\\n      if ((units -= 2) < 0) break\\n      bytes.push(\\n        codePoint >> 0x6 | 0xC0,\\n        codePoint & 0x3F | 0x80\\n      )\\n    } else if (codePoint < 0x10000) {\\n      if ((units -= 3) < 0) break\\n      bytes.push(\\n        codePoint >> 0xC | 0xE0,\\n        codePoint >> 0x6 & 0x3F | 0x80,\\n        codePoint & 0x3F | 0x80\\n      )\\n    } else if (codePoint < 0x110000) {\\n      if ((units -= 4) < 0) break\\n      bytes.push(\\n        codePoint >> 0x12 | 0xF0,\\n        codePoint >> 0xC & 0x3F | 0x80,\\n        codePoint >> 0x6 & 0x3F | 0x80,\\n        codePoint & 0x3F | 0x80\\n      )\\n    } else {\\n      throw new Error('Invalid code point')\\n    }\\n  }\\n\\n  return bytes\\n}\\n\\nfunction asciiToBytes (str) {\\n  const byteArray = []\\n  for (let i = 0; i < str.length; ++i) {\\n    // Node's code seems to be doing this and not & 0x7F..\\n    byteArray.push(str.charCodeAt(i) & 0xFF)\\n  }\\n  return byteArray\\n}\\n\\nfunction utf16leToBytes (str, units) {\\n  let c, hi, lo\\n  const byteArray = []\\n  for (let i = 0; i < str.length; ++i) {\\n    if ((units -= 2) < 0) break\\n\\n    c = str.charCodeAt(i)\\n    hi = c >> 8\\n    lo = c % 256\\n    byteArray.push(lo)\\n    byteArray.push(hi)\\n  }\\n\\n  return byteArray\\n}\\n\\nfunction base64ToBytes (str) {\\n  return base64.toByteArray(base64clean(str))\\n}\\n\\nfunction blitBuffer (src, dst, offset, length) {\\n  let i\\n  for (i = 0; i < length; ++i) {\\n    if ((i + offset >= dst.length) || (i >= src.length)) break\\n    dst[i + offset] = src[i]\\n  }\\n  return i\\n}\\n\\n// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass\\n// the `instanceof` check but they should be treated as of that type.\\n// See: https://github.com/feross/buffer/issues/166\\nfunction isInstance (obj, type) {\\n  return obj instanceof type ||\\n    (obj != null && obj.constructor != null && obj.constructor.name != null &&\\n      obj.constructor.name === type.name)\\n}\\nfunction numberIsNaN (obj) {\\n  // For IE11 support\\n  return obj !== obj // eslint-disable-line no-self-compare\\n}\\n\\n// Create lookup table for `toString('hex')`\\n// See: https://github.com/feross/buffer/issues/219\\nconst hexSliceLookupTable = (function () {\\n  const alphabet = '0123456789abcdef'\\n  const table = new Array(256)\\n  for (let i = 0; i < 16; ++i) {\\n    const i16 = i * 16\\n    for (let j = 0; j < 16; ++j) {\\n      table[i16 + j] = alphabet[i] + alphabet[j]\\n    }\\n  }\\n  return table\\n})()\\n\\n// Return not function with Error if BigInt not supported\\nfunction defineBigIntMethod (fn) {\\n  return typeof BigInt === 'undefined' ? BufferBigIntNotDefined : fn\\n}\\n\\nfunction BufferBigIntNotDefined () {\\n  throw new Error('BigInt not supported')\\n}\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/buffer/index.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/eventemitter3/index.js\":\n/*!*********************************************!*\\\n  !*** ./node_modules/eventemitter3/index.js ***!\n  \\*********************************************/\n/***/ ((module) => {\n\n\"use strict\";\neval(\"\\n\\nvar has = Object.prototype.hasOwnProperty\\n  , prefix = '~';\\n\\n/**\\n * Constructor to create a storage for our `EE` objects.\\n * An `Events` instance is a plain object whose properties are event names.\\n *\\n * @constructor\\n * @private\\n */\\nfunction Events() {}\\n\\n//\\n// We try to not inherit from `Object.prototype`. In some engines creating an\\n// instance in this way is faster than calling `Object.create(null)` directly.\\n// If `Object.create(null)` is not supported we prefix the event names with a\\n// character to make sure that the built-in object properties are not\\n// overridden or used as an attack vector.\\n//\\nif (Object.create) {\\n  Events.prototype = Object.create(null);\\n\\n  //\\n  // This hack is needed because the `__proto__` property is still inherited in\\n  // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.\\n  //\\n  if (!new Events().__proto__) prefix = false;\\n}\\n\\n/**\\n * Representation of a single event listener.\\n *\\n * @param {Function} fn The listener function.\\n * @param {*} context The context to invoke the listener with.\\n * @param {Boolean} [once=false] Specify if the listener is a one-time listener.\\n * @constructor\\n * @private\\n */\\nfunction EE(fn, context, once) {\\n  this.fn = fn;\\n  this.context = context;\\n  this.once = once || false;\\n}\\n\\n/**\\n * Add a listener for a given event.\\n *\\n * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.\\n * @param {(String|Symbol)} event The event name.\\n * @param {Function} fn The listener function.\\n * @param {*} context The context to invoke the listener with.\\n * @param {Boolean} once Specify if the listener is a one-time listener.\\n * @returns {EventEmitter}\\n * @private\\n */\\nfunction addListener(emitter, event, fn, context, once) {\\n  if (typeof fn !== 'function') {\\n    throw new TypeError('The listener must be a function');\\n  }\\n\\n  var listener = new EE(fn, context || emitter, once)\\n    , evt = prefix ? prefix + event : event;\\n\\n  if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;\\n  else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);\\n  else emitter._events[evt] = [emitter._events[evt], listener];\\n\\n  return emitter;\\n}\\n\\n/**\\n * Clear event by name.\\n *\\n * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.\\n * @param {(String|Symbol)} evt The Event name.\\n * @private\\n */\\nfunction clearEvent(emitter, evt) {\\n  if (--emitter._eventsCount === 0) emitter._events = new Events();\\n  else delete emitter._events[evt];\\n}\\n\\n/**\\n * Minimal `EventEmitter` interface that is molded against the Node.js\\n * `EventEmitter` interface.\\n *\\n * @constructor\\n * @public\\n */\\nfunction EventEmitter() {\\n  this._events = new Events();\\n  this._eventsCount = 0;\\n}\\n\\n/**\\n * Return an array listing the events for which the emitter has registered\\n * listeners.\\n *\\n * @returns {Array}\\n * @public\\n */\\nEventEmitter.prototype.eventNames = function eventNames() {\\n  var names = []\\n    , events\\n    , name;\\n\\n  if (this._eventsCount === 0) return names;\\n\\n  for (name in (events = this._events)) {\\n    if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);\\n  }\\n\\n  if (Object.getOwnPropertySymbols) {\\n    return names.concat(Object.getOwnPropertySymbols(events));\\n  }\\n\\n  return names;\\n};\\n\\n/**\\n * Return the listeners registered for a given event.\\n *\\n * @param {(String|Symbol)} event The event name.\\n * @returns {Array} The registered listeners.\\n * @public\\n */\\nEventEmitter.prototype.listeners = function listeners(event) {\\n  var evt = prefix ? prefix + event : event\\n    , handlers = this._events[evt];\\n\\n  if (!handlers) return [];\\n  if (handlers.fn) return [handlers.fn];\\n\\n  for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {\\n    ee[i] = handlers[i].fn;\\n  }\\n\\n  return ee;\\n};\\n\\n/**\\n * Return the number of listeners listening to a given event.\\n *\\n * @param {(String|Symbol)} event The event name.\\n * @returns {Number} The number of listeners.\\n * @public\\n */\\nEventEmitter.prototype.listenerCount = function listenerCount(event) {\\n  var evt = prefix ? prefix + event : event\\n    , listeners = this._events[evt];\\n\\n  if (!listeners) return 0;\\n  if (listeners.fn) return 1;\\n  return listeners.length;\\n};\\n\\n/**\\n * Calls each of the listeners registered for a given event.\\n *\\n * @param {(String|Symbol)} event The event name.\\n * @returns {Boolean} `true` if the event had listeners, else `false`.\\n * @public\\n */\\nEventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {\\n  var evt = prefix ? prefix + event : event;\\n\\n  if (!this._events[evt]) return false;\\n\\n  var listeners = this._events[evt]\\n    , len = arguments.length\\n    , args\\n    , i;\\n\\n  if (listeners.fn) {\\n    if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);\\n\\n    switch (len) {\\n      case 1: return listeners.fn.call(listeners.context), true;\\n      case 2: return listeners.fn.call(listeners.context, a1), true;\\n      case 3: return listeners.fn.call(listeners.context, a1, a2), true;\\n      case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;\\n      case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;\\n      case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;\\n    }\\n\\n    for (i = 1, args = new Array(len -1); i < len; i++) {\\n      args[i - 1] = arguments[i];\\n    }\\n\\n    listeners.fn.apply(listeners.context, args);\\n  } else {\\n    var length = listeners.length\\n      , j;\\n\\n    for (i = 0; i < length; i++) {\\n      if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);\\n\\n      switch (len) {\\n        case 1: listeners[i].fn.call(listeners[i].context); break;\\n        case 2: listeners[i].fn.call(listeners[i].context, a1); break;\\n        case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;\\n        case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;\\n        default:\\n          if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {\\n            args[j - 1] = arguments[j];\\n          }\\n\\n          listeners[i].fn.apply(listeners[i].context, args);\\n      }\\n    }\\n  }\\n\\n  return true;\\n};\\n\\n/**\\n * Add a listener for a given event.\\n *\\n * @param {(String|Symbol)} event The event name.\\n * @param {Function} fn The listener function.\\n * @param {*} [context=this] The context to invoke the listener with.\\n * @returns {EventEmitter} `this`.\\n * @public\\n */\\nEventEmitter.prototype.on = function on(event, fn, context) {\\n  return addListener(this, event, fn, context, false);\\n};\\n\\n/**\\n * Add a one-time listener for a given event.\\n *\\n * @param {(String|Symbol)} event The event name.\\n * @param {Function} fn The listener function.\\n * @param {*} [context=this] The context to invoke the listener with.\\n * @returns {EventEmitter} `this`.\\n * @public\\n */\\nEventEmitter.prototype.once = function once(event, fn, context) {\\n  return addListener(this, event, fn, context, true);\\n};\\n\\n/**\\n * Remove the listeners of a given event.\\n *\\n * @param {(String|Symbol)} event The event name.\\n * @param {Function} fn Only remove the listeners that match this function.\\n * @param {*} context Only remove the listeners that have this context.\\n * @param {Boolean} once Only remove one-time listeners.\\n * @returns {EventEmitter} `this`.\\n * @public\\n */\\nEventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {\\n  var evt = prefix ? prefix + event : event;\\n\\n  if (!this._events[evt]) return this;\\n  if (!fn) {\\n    clearEvent(this, evt);\\n    return this;\\n  }\\n\\n  var listeners = this._events[evt];\\n\\n  if (listeners.fn) {\\n    if (\\n      listeners.fn === fn &&\\n      (!once || listeners.once) &&\\n      (!context || listeners.context === context)\\n    ) {\\n      clearEvent(this, evt);\\n    }\\n  } else {\\n    for (var i = 0, events = [], length = listeners.length; i < length; i++) {\\n      if (\\n        listeners[i].fn !== fn ||\\n        (once && !listeners[i].once) ||\\n        (context && listeners[i].context !== context)\\n      ) {\\n        events.push(listeners[i]);\\n      }\\n    }\\n\\n    //\\n    // Reset the array, or remove it completely if we have no more listeners.\\n    //\\n    if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;\\n    else clearEvent(this, evt);\\n  }\\n\\n  return this;\\n};\\n\\n/**\\n * Remove all listeners, or those of the specified event.\\n *\\n * @param {(String|Symbol)} [event] The event name.\\n * @returns {EventEmitter} `this`.\\n * @public\\n */\\nEventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {\\n  var evt;\\n\\n  if (event) {\\n    evt = prefix ? prefix + event : event;\\n    if (this._events[evt]) clearEvent(this, evt);\\n  } else {\\n    this._events = new Events();\\n    this._eventsCount = 0;\\n  }\\n\\n  return this;\\n};\\n\\n//\\n// Alias methods names because people roll like that.\\n//\\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\\nEventEmitter.prototype.addListener = EventEmitter.prototype.on;\\n\\n//\\n// Expose the prefix.\\n//\\nEventEmitter.prefixed = prefix;\\n\\n//\\n// Allow `EventEmitter` to be imported as module namespace.\\n//\\nEventEmitter.EventEmitter = EventEmitter;\\n\\n//\\n// Expose the module.\\n//\\nif (true) {\\n  module.exports = EventEmitter;\\n}\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/eventemitter3/index.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/ieee754/index.js\":\n/*!***************************************!*\\\n  !*** ./node_modules/ieee754/index.js ***!\n  \\***************************************/\n/***/ ((__unused_webpack_module, exports) => {\n\neval(\"/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */\\nexports.read = function (buffer, offset, isLE, mLen, nBytes) {\\n  var e, m\\n  var eLen = (nBytes * 8) - mLen - 1\\n  var eMax = (1 << eLen) - 1\\n  var eBias = eMax >> 1\\n  var nBits = -7\\n  var i = isLE ? (nBytes - 1) : 0\\n  var d = isLE ? -1 : 1\\n  var s = buffer[offset + i]\\n\\n  i += d\\n\\n  e = s & ((1 << (-nBits)) - 1)\\n  s >>= (-nBits)\\n  nBits += eLen\\n  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\\n\\n  m = e & ((1 << (-nBits)) - 1)\\n  e >>= (-nBits)\\n  nBits += mLen\\n  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\\n\\n  if (e === 0) {\\n    e = 1 - eBias\\n  } else if (e === eMax) {\\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\\n  } else {\\n    m = m + Math.pow(2, mLen)\\n    e = e - eBias\\n  }\\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\\n}\\n\\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\\n  var e, m, c\\n  var eLen = (nBytes * 8) - mLen - 1\\n  var eMax = (1 << eLen) - 1\\n  var eBias = eMax >> 1\\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\\n  var i = isLE ? 0 : (nBytes - 1)\\n  var d = isLE ? 1 : -1\\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\\n\\n  value = Math.abs(value)\\n\\n  if (isNaN(value) || value === Infinity) {\\n    m = isNaN(value) ? 1 : 0\\n    e = eMax\\n  } else {\\n    e = Math.floor(Math.log(value) / Math.LN2)\\n    if (value * (c = Math.pow(2, -e)) < 1) {\\n      e--\\n      c *= 2\\n    }\\n    if (e + eBias >= 1) {\\n      value += rt / c\\n    } else {\\n      value += rt * Math.pow(2, 1 - eBias)\\n    }\\n    if (value * c >= 2) {\\n      e++\\n      c /= 2\\n    }\\n\\n    if (e + eBias >= eMax) {\\n      m = 0\\n      e = eMax\\n    } else if (e + eBias >= 1) {\\n      m = ((value * c) - 1) * Math.pow(2, mLen)\\n      e = e + eBias\\n    } else {\\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\\n      e = 0\\n    }\\n  }\\n\\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\\n\\n  e = (e << mLen) | m\\n  eLen += mLen\\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\\n\\n  buffer[offset + i - d] |= s * 128\\n}\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/ieee754/index.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/jayson/lib/client/browser/index.js\":\n/*!*********************************************************!*\\\n  !*** ./node_modules/jayson/lib/client/browser/index.js ***!\n  \\*********************************************************/\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\neval(\"\\n\\nconst uuid = (__webpack_require__(/*! uuid */ \\\"./node_modules/uuid/dist/esm-browser/index.js\\\").v4);\\nconst generateRequest = __webpack_require__(/*! ../../generateRequest */ \\\"./node_modules/jayson/lib/generateRequest.js\\\");\\n\\n/**\\n * Constructor for a Jayson Browser Client that does not depend any node.js core libraries\\n * @class ClientBrowser\\n * @param {Function} callServer Method that calls the server, receives the stringified request and a regular node-style callback\\n * @param {Object} [options]\\n * @param {Function} [options.reviver] Reviver function for JSON\\n * @param {Function} [options.replacer] Replacer function for JSON\\n * @param {Number} [options.version=2] JSON-RPC version to use (1|2)\\n * @param {Function} [options.generator] Function to use for generating request IDs\\n *  @param {Boolean} [options.notificationIdNull=false] When true, version 2 requests will set id to null instead of omitting it\\n * @return {ClientBrowser}\\n */\\nconst ClientBrowser = function(callServer, options) {\\n  if(!(this instanceof ClientBrowser)) {\\n    return new ClientBrowser(callServer, options);\\n  }\\n\\n  if (!options) {\\n    options = {};\\n  }\\n\\n  this.options = {\\n    reviver: typeof options.reviver !== 'undefined' ? options.reviver : null,\\n    replacer: typeof options.replacer !== 'undefined' ? options.replacer : null,\\n    generator: typeof options.generator !== 'undefined' ? options.generator : function() { return uuid(); },\\n    version: typeof options.version !== 'undefined' ? options.version : 2,\\n    notificationIdNull: typeof options.notificationIdNull === 'boolean' ? options.notificationIdNull : false,\\n  };\\n\\n  this.callServer = callServer;\\n};\\n\\nmodule.exports = ClientBrowser;\\n\\n/**\\n *  Creates a request and dispatches it if given a callback.\\n *  @param {String|Array} method A batch request if passed an Array, or a method name if passed a String\\n *  @param {Array|Object} [params] Parameters for the method\\n *  @param {String|Number} [id] Optional id. If undefined an id will be generated. If null it creates a notification request\\n *  @param {Function} [callback] Request callback. If specified, executes the request rather than only returning it.\\n *  @throws {TypeError} Invalid parameters\\n *  @return {Object} JSON-RPC 1.0 or 2.0 compatible request\\n */\\nClientBrowser.prototype.request = function(method, params, id, callback) {\\n  const self = this;\\n  let request = null;\\n\\n  // is this a batch request?\\n  const isBatch = Array.isArray(method) && typeof params === 'function';\\n\\n  if (this.options.version === 1 && isBatch) {\\n    throw new TypeError('JSON-RPC 1.0 does not support batching');\\n  }\\n\\n  // is this a raw request?\\n  const isRaw = !isBatch && method && typeof method === 'object' && typeof params === 'function';\\n\\n  if(isBatch || isRaw) {\\n    callback = params;\\n    request = method;\\n  } else {\\n    if(typeof id === 'function') {\\n      callback = id;\\n      // specifically undefined because \\\"null\\\" is a notification request\\n      id = undefined;\\n    }\\n\\n    const hasCallback = typeof callback === 'function';\\n\\n    try {\\n      request = generateRequest(method, params, id, {\\n        generator: this.options.generator,\\n        version: this.options.version,\\n        notificationIdNull: this.options.notificationIdNull,\\n      });\\n    } catch(err) {\\n      if(hasCallback) {\\n        return callback(err);\\n      }\\n      throw err;\\n    }\\n\\n    // no callback means we should just return a raw request\\n    if(!hasCallback) {\\n      return request;\\n    }\\n\\n  }\\n\\n  let message;\\n  try {\\n    message = JSON.stringify(request, this.options.replacer);\\n  } catch(err) {\\n    return callback(err);\\n  }\\n\\n  this.callServer(message, function(err, response) {\\n    self._parseResponse(err, response, callback);\\n  });\\n\\n  // always return the raw request\\n  return request;\\n};\\n\\n/**\\n * Parses a response from a server\\n * @param {Object} err Error to pass on that is unrelated to the actual response\\n * @param {String} responseText JSON-RPC 1.0 or 2.0 response\\n * @param {Function} callback Callback that will receive different arguments depending on the amount of parameters\\n * @private\\n */\\nClientBrowser.prototype._parseResponse = function(err, responseText, callback) {\\n  if(err) {\\n    callback(err);\\n    return;\\n  }\\n\\n  if(!responseText) {\\n    // empty response text, assume that is correct because it could be a\\n    // notification which jayson does not give any body for\\n    return callback();\\n  }\\n\\n  let response;\\n  try {\\n    response = JSON.parse(responseText, this.options.reviver);\\n  } catch(err) {\\n    return callback(err);\\n  }\\n\\n  if(callback.length === 3) {\\n    // if callback length is 3, we split callback arguments on error and response\\n\\n    // is batch response?\\n    if(Array.isArray(response)) {\\n\\n      // neccesary to split strictly on validity according to spec here\\n      const isError = function(res) {\\n        return typeof res.error !== 'undefined';\\n      };\\n\\n      const isNotError = function (res) {\\n        return !isError(res);\\n      };\\n\\n      return callback(null, response.filter(isError), response.filter(isNotError));\\n    \\n    } else {\\n\\n      // split regardless of validity\\n      return callback(null, response.error, response.result);\\n    \\n    }\\n  \\n  }\\n\\n  callback(null, response);\\n};\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/jayson/lib/client/browser/index.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/jayson/lib/generateRequest.js\":\n/*!****************************************************!*\\\n  !*** ./node_modules/jayson/lib/generateRequest.js ***!\n  \\****************************************************/\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\n\"use strict\";\neval(\"\\n\\nconst uuid = (__webpack_require__(/*! uuid */ \\\"./node_modules/uuid/dist/esm-browser/index.js\\\").v4);\\n\\n/**\\n *  Generates a JSON-RPC 1.0 or 2.0 request\\n *  @param {String} method Name of method to call\\n *  @param {Array|Object} params Array of parameters passed to the method as specified, or an object of parameter names and corresponding value\\n *  @param {String|Number|null} [id] Request ID can be a string, number, null for explicit notification or left out for automatic generation\\n *  @param {Object} [options]\\n *  @param {Number} [options.version=2] JSON-RPC version to use (1 or 2)\\n *  @param {Boolean} [options.notificationIdNull=false] When true, version 2 requests will set id to null instead of omitting it\\n *  @param {Function} [options.generator] Passed the request, and the options object and is expected to return a request ID\\n *  @throws {TypeError} If any of the parameters are invalid\\n *  @return {Object} A JSON-RPC 1.0 or 2.0 request\\n *  @memberOf Utils\\n */\\nconst generateRequest = function(method, params, id, options) {\\n  if(typeof method !== 'string') {\\n    throw new TypeError(method + ' must be a string');\\n  }\\n\\n  options = options || {};\\n\\n  // check valid version provided\\n  const version = typeof options.version === 'number' ? options.version : 2;\\n  if (version !== 1 && version !== 2) {\\n    throw new TypeError(version + ' must be 1 or 2');\\n  }\\n\\n  const request = {\\n    method: method\\n  };\\n\\n  if(version === 2) {\\n    request.jsonrpc = '2.0';\\n  }\\n\\n  if(params) {\\n    // params given, but invalid?\\n    if(typeof params !== 'object' && !Array.isArray(params)) {\\n      throw new TypeError(params + ' must be an object, array or omitted');\\n    }\\n    request.params = params;\\n  }\\n\\n  // if id was left out, generate one (null means explicit notification)\\n  if(typeof(id) === 'undefined') {\\n    const generator = typeof options.generator === 'function' ? options.generator : function() { return uuid(); };\\n    request.id = generator(request, options);\\n  } else if (version === 2 && id === null) {\\n    // we have a version 2 notification\\n    if (options.notificationIdNull) {\\n      request.id = null; // id will not be set at all unless option provided\\n    }\\n  } else {\\n    request.id = id;\\n  }\\n\\n  return request;\\n};\\n\\nmodule.exports = generateRequest;\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/jayson/lib/generateRequest.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/rpc-websockets/dist/index.browser.js\":\n/*!***********************************************************!*\\\n  !*** ./node_modules/rpc-websockets/dist/index.browser.js ***!\n  \\***********************************************************/\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\neval(\"\\n\\nvar _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ \\\"./node_modules/@babel/runtime/helpers/interopRequireDefault.js\\\");\\n\\nObject.defineProperty(exports, \\\"__esModule\\\", ({\\n  value: true\\n}));\\nexports.Client = void 0;\\n\\nvar _createClass2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/createClass */ \\\"./node_modules/@babel/runtime/helpers/createClass.js\\\"));\\n\\nvar _classCallCheck2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ \\\"./node_modules/@babel/runtime/helpers/classCallCheck.js\\\"));\\n\\nvar _inherits2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/inherits */ \\\"./node_modules/@babel/runtime/helpers/inherits.js\\\"));\\n\\nvar _possibleConstructorReturn2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/possibleConstructorReturn */ \\\"./node_modules/@babel/runtime/helpers/possibleConstructorReturn.js\\\"));\\n\\nvar _getPrototypeOf2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/getPrototypeOf */ \\\"./node_modules/@babel/runtime/helpers/getPrototypeOf.js\\\"));\\n\\nvar _websocket = _interopRequireDefault(__webpack_require__(/*! ./lib/client/websocket.browser */ \\\"./node_modules/rpc-websockets/dist/lib/client/websocket.browser.js\\\"));\\n\\nvar _client = _interopRequireDefault(__webpack_require__(/*! ./lib/client */ \\\"./node_modules/rpc-websockets/dist/lib/client.js\\\"));\\n\\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2[\\\"default\\\"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2[\\\"default\\\"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2[\\\"default\\\"])(this, result); }; }\\n\\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \\\"undefined\\\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \\\"function\\\") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }\\n\\nvar Client = /*#__PURE__*/function (_CommonClient) {\\n  (0, _inherits2[\\\"default\\\"])(Client, _CommonClient);\\n\\n  var _super = _createSuper(Client);\\n\\n  function Client() {\\n    var address = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : \\\"ws://localhost:8080\\\";\\n\\n    var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},\\n        _ref$autoconnect = _ref.autoconnect,\\n        autoconnect = _ref$autoconnect === void 0 ? true : _ref$autoconnect,\\n        _ref$reconnect = _ref.reconnect,\\n        reconnect = _ref$reconnect === void 0 ? true : _ref$reconnect,\\n        _ref$reconnect_interv = _ref.reconnect_interval,\\n        reconnect_interval = _ref$reconnect_interv === void 0 ? 1000 : _ref$reconnect_interv,\\n        _ref$max_reconnects = _ref.max_reconnects,\\n        max_reconnects = _ref$max_reconnects === void 0 ? 5 : _ref$max_reconnects;\\n\\n    var generate_request_id = arguments.length > 2 ? arguments[2] : undefined;\\n    (0, _classCallCheck2[\\\"default\\\"])(this, Client);\\n    return _super.call(this, _websocket[\\\"default\\\"], address, {\\n      autoconnect: autoconnect,\\n      reconnect: reconnect,\\n      reconnect_interval: reconnect_interval,\\n      max_reconnects: max_reconnects\\n    }, generate_request_id);\\n  }\\n\\n  return (0, _createClass2[\\\"default\\\"])(Client);\\n}(_client[\\\"default\\\"]);\\n\\nexports.Client = Client;\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/rpc-websockets/dist/index.browser.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/rpc-websockets/dist/lib/client.js\":\n/*!********************************************************!*\\\n  !*** ./node_modules/rpc-websockets/dist/lib/client.js ***!\n  \\********************************************************/\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\neval(\"/* provided dependency */ var Buffer = __webpack_require__(/*! buffer */ \\\"./node_modules/buffer/index.js\\\")[\\\"Buffer\\\"];\\n/**\\n * \\\"Client\\\" wraps \\\"ws\\\" or a browser-implemented \\\"WebSocket\\\" library\\n * according to the environment providing JSON RPC 2.0 support on top.\\n * @module Client\\n */\\n\\n\\nvar _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ \\\"./node_modules/@babel/runtime/helpers/interopRequireDefault.js\\\");\\n\\nObject.defineProperty(exports, \\\"__esModule\\\", ({\\n  value: true\\n}));\\nexports[\\\"default\\\"] = void 0;\\n\\nvar _regenerator = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/regenerator */ \\\"./node_modules/@babel/runtime/regenerator/index.js\\\"));\\n\\nvar _asyncToGenerator2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/asyncToGenerator */ \\\"./node_modules/@babel/runtime/helpers/asyncToGenerator.js\\\"));\\n\\nvar _typeof2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/typeof */ \\\"./node_modules/@babel/runtime/helpers/typeof.js\\\"));\\n\\nvar _classCallCheck2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ \\\"./node_modules/@babel/runtime/helpers/classCallCheck.js\\\"));\\n\\nvar _createClass2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/createClass */ \\\"./node_modules/@babel/runtime/helpers/createClass.js\\\"));\\n\\nvar _inherits2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/inherits */ \\\"./node_modules/@babel/runtime/helpers/inherits.js\\\"));\\n\\nvar _possibleConstructorReturn2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/possibleConstructorReturn */ \\\"./node_modules/@babel/runtime/helpers/possibleConstructorReturn.js\\\"));\\n\\nvar _getPrototypeOf2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/getPrototypeOf */ \\\"./node_modules/@babel/runtime/helpers/getPrototypeOf.js\\\"));\\n\\nvar _eventemitter = __webpack_require__(/*! eventemitter3 */ \\\"./node_modules/eventemitter3/index.js\\\");\\n\\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2[\\\"default\\\"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2[\\\"default\\\"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2[\\\"default\\\"])(this, result); }; }\\n\\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \\\"undefined\\\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \\\"function\\\") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }\\n\\nvar __rest = void 0 && (void 0).__rest || function (s, e) {\\n  var t = {};\\n\\n  for (var p in s) {\\n    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];\\n  }\\n\\n  if (s != null && typeof Object.getOwnPropertySymbols === \\\"function\\\") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\\n    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];\\n  }\\n  return t;\\n}; // @ts-ignore\\n\\n\\nvar CommonClient = /*#__PURE__*/function (_EventEmitter) {\\n  (0, _inherits2[\\\"default\\\"])(CommonClient, _EventEmitter);\\n\\n  var _super = _createSuper(CommonClient);\\n\\n  /**\\n   * Instantiate a Client class.\\n   * @constructor\\n   * @param {webSocketFactory} webSocketFactory - factory method for WebSocket\\n   * @param {String} address - url to a websocket server\\n   * @param {Object} options - ws options object with reconnect parameters\\n   * @param {Function} generate_request_id - custom generation request Id\\n   * @return {CommonClient}\\n   */\\n  function CommonClient(webSocketFactory) {\\n    var _this;\\n\\n    var address = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : \\\"ws://localhost:8080\\\";\\n\\n    var _a = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\\n\\n    var generate_request_id = arguments.length > 3 ? arguments[3] : undefined;\\n    (0, _classCallCheck2[\\\"default\\\"])(this, CommonClient);\\n\\n    var _a$autoconnect = _a.autoconnect,\\n        autoconnect = _a$autoconnect === void 0 ? true : _a$autoconnect,\\n        _a$reconnect = _a.reconnect,\\n        reconnect = _a$reconnect === void 0 ? true : _a$reconnect,\\n        _a$reconnect_interval = _a.reconnect_interval,\\n        reconnect_interval = _a$reconnect_interval === void 0 ? 1000 : _a$reconnect_interval,\\n        _a$max_reconnects = _a.max_reconnects,\\n        max_reconnects = _a$max_reconnects === void 0 ? 5 : _a$max_reconnects,\\n        rest_options = __rest(_a, [\\\"autoconnect\\\", \\\"reconnect\\\", \\\"reconnect_interval\\\", \\\"max_reconnects\\\"]);\\n\\n    _this = _super.call(this);\\n    _this.webSocketFactory = webSocketFactory;\\n    _this.queue = {};\\n    _this.rpc_id = 0;\\n    _this.address = address;\\n    _this.autoconnect = autoconnect;\\n    _this.ready = false;\\n    _this.reconnect = reconnect;\\n    _this.reconnect_interval = reconnect_interval;\\n    _this.max_reconnects = max_reconnects;\\n    _this.rest_options = rest_options;\\n    _this.current_reconnects = 0;\\n\\n    _this.generate_request_id = generate_request_id || function () {\\n      return ++_this.rpc_id;\\n    };\\n\\n    if (_this.autoconnect) _this._connect(_this.address, Object.assign({\\n      autoconnect: _this.autoconnect,\\n      reconnect: _this.reconnect,\\n      reconnect_interval: _this.reconnect_interval,\\n      max_reconnects: _this.max_reconnects\\n    }, _this.rest_options));\\n    return _this;\\n  }\\n  /**\\n   * Connects to a defined server if not connected already.\\n   * @method\\n   * @return {Undefined}\\n   */\\n\\n\\n  (0, _createClass2[\\\"default\\\"])(CommonClient, [{\\n    key: \\\"connect\\\",\\n    value: function connect() {\\n      if (this.socket) return;\\n\\n      this._connect(this.address, Object.assign({\\n        autoconnect: this.autoconnect,\\n        reconnect: this.reconnect,\\n        reconnect_interval: this.reconnect_interval,\\n        max_reconnects: this.max_reconnects\\n      }, this.rest_options));\\n    }\\n    /**\\n     * Calls a registered RPC method on server.\\n     * @method\\n     * @param {String} method - RPC method name\\n     * @param {Object|Array} params - optional method parameters\\n     * @param {Number} timeout - RPC reply timeout value\\n     * @param {Object} ws_opts - options passed to ws\\n     * @return {Promise}\\n     */\\n\\n  }, {\\n    key: \\\"call\\\",\\n    value: function call(method, params, timeout, ws_opts) {\\n      var _this2 = this;\\n\\n      if (!ws_opts && \\\"object\\\" === (0, _typeof2[\\\"default\\\"])(timeout)) {\\n        ws_opts = timeout;\\n        timeout = null;\\n      }\\n\\n      return new Promise(function (resolve, reject) {\\n        if (!_this2.ready) return reject(new Error(\\\"socket not ready\\\"));\\n\\n        var rpc_id = _this2.generate_request_id(method, params);\\n\\n        var message = {\\n          jsonrpc: \\\"2.0\\\",\\n          method: method,\\n          params: params || null,\\n          id: rpc_id\\n        };\\n\\n        _this2.socket.send(JSON.stringify(message), ws_opts, function (error) {\\n          if (error) return reject(error);\\n          _this2.queue[rpc_id] = {\\n            promise: [resolve, reject]\\n          };\\n\\n          if (timeout) {\\n            _this2.queue[rpc_id].timeout = setTimeout(function () {\\n              delete _this2.queue[rpc_id];\\n              reject(new Error(\\\"reply timeout\\\"));\\n            }, timeout);\\n          }\\n        });\\n      });\\n    }\\n    /**\\n     * Logins with the other side of the connection.\\n     * @method\\n     * @param {Object} params - Login credentials object\\n     * @return {Promise}\\n     */\\n\\n  }, {\\n    key: \\\"login\\\",\\n    value: function () {\\n      var _login = (0, _asyncToGenerator2[\\\"default\\\"])( /*#__PURE__*/_regenerator[\\\"default\\\"].mark(function _callee(params) {\\n        var resp;\\n        return _regenerator[\\\"default\\\"].wrap(function _callee$(_context) {\\n          while (1) {\\n            switch (_context.prev = _context.next) {\\n              case 0:\\n                _context.next = 2;\\n                return this.call(\\\"rpc.login\\\", params);\\n\\n              case 2:\\n                resp = _context.sent;\\n\\n                if (resp) {\\n                  _context.next = 5;\\n                  break;\\n                }\\n\\n                throw new Error(\\\"authentication failed\\\");\\n\\n              case 5:\\n                return _context.abrupt(\\\"return\\\", resp);\\n\\n              case 6:\\n              case \\\"end\\\":\\n                return _context.stop();\\n            }\\n          }\\n        }, _callee, this);\\n      }));\\n\\n      function login(_x) {\\n        return _login.apply(this, arguments);\\n      }\\n\\n      return login;\\n    }()\\n    /**\\n     * Fetches a list of client's methods registered on server.\\n     * @method\\n     * @return {Array}\\n     */\\n\\n  }, {\\n    key: \\\"listMethods\\\",\\n    value: function () {\\n      var _listMethods = (0, _asyncToGenerator2[\\\"default\\\"])( /*#__PURE__*/_regenerator[\\\"default\\\"].mark(function _callee2() {\\n        return _regenerator[\\\"default\\\"].wrap(function _callee2$(_context2) {\\n          while (1) {\\n            switch (_context2.prev = _context2.next) {\\n              case 0:\\n                _context2.next = 2;\\n                return this.call(\\\"__listMethods\\\");\\n\\n              case 2:\\n                return _context2.abrupt(\\\"return\\\", _context2.sent);\\n\\n              case 3:\\n              case \\\"end\\\":\\n                return _context2.stop();\\n            }\\n          }\\n        }, _callee2, this);\\n      }));\\n\\n      function listMethods() {\\n        return _listMethods.apply(this, arguments);\\n      }\\n\\n      return listMethods;\\n    }()\\n    /**\\n     * Sends a JSON-RPC 2.0 notification to server.\\n     * @method\\n     * @param {String} method - RPC method name\\n     * @param {Object} params - optional method parameters\\n     * @return {Promise}\\n     */\\n\\n  }, {\\n    key: \\\"notify\\\",\\n    value: function notify(method, params) {\\n      var _this3 = this;\\n\\n      return new Promise(function (resolve, reject) {\\n        if (!_this3.ready) return reject(new Error(\\\"socket not ready\\\"));\\n        var message = {\\n          jsonrpc: \\\"2.0\\\",\\n          method: method,\\n          params: params || null\\n        };\\n\\n        _this3.socket.send(JSON.stringify(message), function (error) {\\n          if (error) return reject(error);\\n          resolve();\\n        });\\n      });\\n    }\\n    /**\\n     * Subscribes for a defined event.\\n     * @method\\n     * @param {String|Array} event - event name\\n     * @return {Undefined}\\n     * @throws {Error}\\n     */\\n\\n  }, {\\n    key: \\\"subscribe\\\",\\n    value: function () {\\n      var _subscribe = (0, _asyncToGenerator2[\\\"default\\\"])( /*#__PURE__*/_regenerator[\\\"default\\\"].mark(function _callee3(event) {\\n        var result;\\n        return _regenerator[\\\"default\\\"].wrap(function _callee3$(_context3) {\\n          while (1) {\\n            switch (_context3.prev = _context3.next) {\\n              case 0:\\n                if (typeof event === \\\"string\\\") event = [event];\\n                _context3.next = 3;\\n                return this.call(\\\"rpc.on\\\", event);\\n\\n              case 3:\\n                result = _context3.sent;\\n\\n                if (!(typeof event === \\\"string\\\" && result[event] !== \\\"ok\\\")) {\\n                  _context3.next = 6;\\n                  break;\\n                }\\n\\n                throw new Error(\\\"Failed subscribing to an event '\\\" + event + \\\"' with: \\\" + result[event]);\\n\\n              case 6:\\n                return _context3.abrupt(\\\"return\\\", result);\\n\\n              case 7:\\n              case \\\"end\\\":\\n                return _context3.stop();\\n            }\\n          }\\n        }, _callee3, this);\\n      }));\\n\\n      function subscribe(_x2) {\\n        return _subscribe.apply(this, arguments);\\n      }\\n\\n      return subscribe;\\n    }()\\n    /**\\n     * Unsubscribes from a defined event.\\n     * @method\\n     * @param {String|Array} event - event name\\n     * @return {Undefined}\\n     * @throws {Error}\\n     */\\n\\n  }, {\\n    key: \\\"unsubscribe\\\",\\n    value: function () {\\n      var _unsubscribe = (0, _asyncToGenerator2[\\\"default\\\"])( /*#__PURE__*/_regenerator[\\\"default\\\"].mark(function _callee4(event) {\\n        var result;\\n        return _regenerator[\\\"default\\\"].wrap(function _callee4$(_context4) {\\n          while (1) {\\n            switch (_context4.prev = _context4.next) {\\n              case 0:\\n                if (typeof event === \\\"string\\\") event = [event];\\n                _context4.next = 3;\\n                return this.call(\\\"rpc.off\\\", event);\\n\\n              case 3:\\n                result = _context4.sent;\\n\\n                if (!(typeof event === \\\"string\\\" && result[event] !== \\\"ok\\\")) {\\n                  _context4.next = 6;\\n                  break;\\n                }\\n\\n                throw new Error(\\\"Failed unsubscribing from an event with: \\\" + result);\\n\\n              case 6:\\n                return _context4.abrupt(\\\"return\\\", result);\\n\\n              case 7:\\n              case \\\"end\\\":\\n                return _context4.stop();\\n            }\\n          }\\n        }, _callee4, this);\\n      }));\\n\\n      function unsubscribe(_x3) {\\n        return _unsubscribe.apply(this, arguments);\\n      }\\n\\n      return unsubscribe;\\n    }()\\n    /**\\n     * Closes a WebSocket connection gracefully.\\n     * @method\\n     * @param {Number} code - socket close code\\n     * @param {String} data - optional data to be sent before closing\\n     * @return {Undefined}\\n     */\\n\\n  }, {\\n    key: \\\"close\\\",\\n    value: function close(code, data) {\\n      this.socket.close(code || 1000, data);\\n    }\\n    /**\\n     * Connection/Message handler.\\n     * @method\\n     * @private\\n     * @param {String} address - WebSocket API address\\n     * @param {Object} options - ws options object\\n     * @return {Undefined}\\n     */\\n\\n  }, {\\n    key: \\\"_connect\\\",\\n    value: function _connect(address, options) {\\n      var _this4 = this;\\n\\n      this.socket = this.webSocketFactory(address, options);\\n      this.socket.addEventListener(\\\"open\\\", function () {\\n        _this4.ready = true;\\n\\n        _this4.emit(\\\"open\\\");\\n\\n        _this4.current_reconnects = 0;\\n      });\\n      this.socket.addEventListener(\\\"message\\\", function (_ref) {\\n        var message = _ref.data;\\n        if (message instanceof ArrayBuffer) message = Buffer.from(message).toString();\\n\\n        try {\\n          message = JSON.parse(message);\\n        } catch (error) {\\n          return;\\n        } // check if any listeners are attached and forward event\\n\\n\\n        if (message.notification && _this4.listeners(message.notification).length) {\\n          if (!Object.keys(message.params).length) return _this4.emit(message.notification);\\n          var args = [message.notification];\\n          if (message.params.constructor === Object) args.push(message.params);else // using for-loop instead of unshift/spread because performance is better\\n            for (var i = 0; i < message.params.length; i++) {\\n              args.push(message.params[i]);\\n            } // run as microtask so that pending queue messages are resolved first\\n          // eslint-disable-next-line prefer-spread\\n\\n          return Promise.resolve().then(function () {\\n            _this4.emit.apply(_this4, args);\\n          });\\n        }\\n\\n        if (!_this4.queue[message.id]) {\\n          // general JSON RPC 2.0 events\\n          if (message.method && message.params) {\\n            // run as microtask so that pending queue messages are resolved first\\n            return Promise.resolve().then(function () {\\n              _this4.emit(message.method, message.params);\\n            });\\n          }\\n\\n          return;\\n        } // reject early since server's response is invalid\\n\\n\\n        if (\\\"error\\\" in message === \\\"result\\\" in message) _this4.queue[message.id].promise[1](new Error(\\\"Server response malformed. Response must include either \\\\\\\"result\\\\\\\"\\\" + \\\" or \\\\\\\"error\\\\\\\", but not both.\\\"));\\n        if (_this4.queue[message.id].timeout) clearTimeout(_this4.queue[message.id].timeout);\\n        if (message.error) _this4.queue[message.id].promise[1](message.error);else _this4.queue[message.id].promise[0](message.result);\\n        delete _this4.queue[message.id];\\n      });\\n      this.socket.addEventListener(\\\"error\\\", function (error) {\\n        return _this4.emit(\\\"error\\\", error);\\n      });\\n      this.socket.addEventListener(\\\"close\\\", function (_ref2) {\\n        var code = _ref2.code,\\n            reason = _ref2.reason;\\n        if (_this4.ready) // Delay close event until internal state is updated\\n          setTimeout(function () {\\n            return _this4.emit(\\\"close\\\", code, reason);\\n          }, 0);\\n        _this4.ready = false;\\n        _this4.socket = undefined;\\n        if (code === 1000) return;\\n        _this4.current_reconnects++;\\n        if (_this4.reconnect && (_this4.max_reconnects > _this4.current_reconnects || _this4.max_reconnects === 0)) setTimeout(function () {\\n          return _this4._connect(address, options);\\n        }, _this4.reconnect_interval);\\n      });\\n    }\\n  }]);\\n  return CommonClient;\\n}(_eventemitter.EventEmitter);\\n\\nexports[\\\"default\\\"] = CommonClient;\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/rpc-websockets/dist/lib/client.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/rpc-websockets/dist/lib/client/websocket.browser.js\":\n/*!**************************************************************************!*\\\n  !*** ./node_modules/rpc-websockets/dist/lib/client/websocket.browser.js ***!\n  \\**************************************************************************/\n/***/ ((__unused_webpack_module, exports, __webpack_require__) => {\n\n\"use strict\";\neval(\"/**\\n * WebSocket implements a browser-side WebSocket specification.\\n * @module Client\\n */\\n\\n\\nvar _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ \\\"./node_modules/@babel/runtime/helpers/interopRequireDefault.js\\\");\\n\\nObject.defineProperty(exports, \\\"__esModule\\\", ({\\n  value: true\\n}));\\nexports[\\\"default\\\"] = _default;\\n\\nvar _classCallCheck2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/classCallCheck */ \\\"./node_modules/@babel/runtime/helpers/classCallCheck.js\\\"));\\n\\nvar _createClass2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/createClass */ \\\"./node_modules/@babel/runtime/helpers/createClass.js\\\"));\\n\\nvar _inherits2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/inherits */ \\\"./node_modules/@babel/runtime/helpers/inherits.js\\\"));\\n\\nvar _possibleConstructorReturn2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/possibleConstructorReturn */ \\\"./node_modules/@babel/runtime/helpers/possibleConstructorReturn.js\\\"));\\n\\nvar _getPrototypeOf2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/getPrototypeOf */ \\\"./node_modules/@babel/runtime/helpers/getPrototypeOf.js\\\"));\\n\\nvar _eventemitter = __webpack_require__(/*! eventemitter3 */ \\\"./node_modules/eventemitter3/index.js\\\");\\n\\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2[\\\"default\\\"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2[\\\"default\\\"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2[\\\"default\\\"])(this, result); }; }\\n\\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \\\"undefined\\\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \\\"function\\\") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }\\n\\nvar WebSocketBrowserImpl = /*#__PURE__*/function (_EventEmitter) {\\n  (0, _inherits2[\\\"default\\\"])(WebSocketBrowserImpl, _EventEmitter);\\n\\n  var _super = _createSuper(WebSocketBrowserImpl);\\n\\n  /** Instantiate a WebSocket class\\n   * @constructor\\n   * @param {String} address - url to a websocket server\\n   * @param {(Object)} options - websocket options\\n   * @param {(String|Array)} protocols - a list of protocols\\n   * @return {WebSocketBrowserImpl} - returns a WebSocket instance\\n   */\\n  function WebSocketBrowserImpl(address, options, protocols) {\\n    var _this;\\n\\n    (0, _classCallCheck2[\\\"default\\\"])(this, WebSocketBrowserImpl);\\n    _this = _super.call(this);\\n    _this.socket = new window.WebSocket(address, protocols);\\n\\n    _this.socket.onopen = function () {\\n      return _this.emit(\\\"open\\\");\\n    };\\n\\n    _this.socket.onmessage = function (event) {\\n      return _this.emit(\\\"message\\\", event.data);\\n    };\\n\\n    _this.socket.onerror = function (error) {\\n      return _this.emit(\\\"error\\\", error);\\n    };\\n\\n    _this.socket.onclose = function (event) {\\n      _this.emit(\\\"close\\\", event.code, event.reason);\\n    };\\n\\n    return _this;\\n  }\\n  /**\\n   * Sends data through a websocket connection\\n   * @method\\n   * @param {(String|Object)} data - data to be sent via websocket\\n   * @param {Object} optionsOrCallback - ws options\\n   * @param {Function} callback - a callback called once the data is sent\\n   * @return {Undefined}\\n   */\\n\\n\\n  (0, _createClass2[\\\"default\\\"])(WebSocketBrowserImpl, [{\\n    key: \\\"send\\\",\\n    value: function send(data, optionsOrCallback, callback) {\\n      var cb = callback || optionsOrCallback;\\n\\n      try {\\n        this.socket.send(data);\\n        cb();\\n      } catch (error) {\\n        cb(error);\\n      }\\n    }\\n    /**\\n     * Closes an underlying socket\\n     * @method\\n     * @param {Number} code - status code explaining why the connection is being closed\\n     * @param {String} reason - a description why the connection is closing\\n     * @return {Undefined}\\n     * @throws {Error}\\n     */\\n\\n  }, {\\n    key: \\\"close\\\",\\n    value: function close(code, reason) {\\n      this.socket.close(code, reason);\\n    }\\n  }, {\\n    key: \\\"addEventListener\\\",\\n    value: function addEventListener(type, listener, options) {\\n      this.socket.addEventListener(type, listener, options);\\n    }\\n  }]);\\n  return WebSocketBrowserImpl;\\n}(_eventemitter.EventEmitter);\\n/**\\n * factory method for common WebSocket instance\\n * @method\\n * @param {String} address - url to a websocket server\\n * @param {(Object)} options - websocket options\\n * @return {Undefined}\\n */\\n\\n\\nfunction _default(address, options) {\\n  return new WebSocketBrowserImpl(address, options);\\n}\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/rpc-websockets/dist/lib/client/websocket.browser.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/safe-buffer/index.js\":\n/*!*******************************************!*\\\n  !*** ./node_modules/safe-buffer/index.js ***!\n  \\*******************************************/\n/***/ ((module, exports, __webpack_require__) => {\n\neval(\"/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */\\n/* eslint-disable node/no-deprecated-api */\\nvar buffer = __webpack_require__(/*! buffer */ \\\"./node_modules/buffer/index.js\\\")\\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\\nSafeBuffer.prototype = Object.create(Buffer.prototype)\\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\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/safe-buffer/index.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/text-encoding-utf-8/lib/encoding.lib.js\":\n/*!**************************************************************!*\\\n  !*** ./node_modules/text-encoding-utf-8/lib/encoding.lib.js ***!\n  \\**************************************************************/\n/***/ ((__unused_webpack_module, exports) => {\n\n\"use strict\";\neval(\"\\n\\n// This is free and unencumbered software released into the public domain.\\n// See LICENSE.md for more information.\\n\\n//\\n// Utilities\\n//\\n\\n/**\\n * @param {number} a The number to test.\\n * @param {number} min The minimum value in the range, inclusive.\\n * @param {number} max The maximum value in the range, inclusive.\\n * @return {boolean} True if a >= min and a <= max.\\n */\\nfunction inRange(a, min, max) {\\n  return min <= a && a <= max;\\n}\\n\\n/**\\n * @param {*} o\\n * @return {Object}\\n */\\nfunction ToDictionary(o) {\\n  if (o === undefined) return {};\\n  if (o === Object(o)) return o;\\n  throw TypeError('Could not convert argument to dictionary');\\n}\\n\\n/**\\n * @param {string} string Input string of UTF-16 code units.\\n * @return {!Array.<number>} Code points.\\n */\\nfunction stringToCodePoints(string) {\\n  // https://heycam.github.io/webidl/#dfn-obtain-unicode\\n\\n  // 1. Let S be the DOMString value.\\n  var s = String(string);\\n\\n  // 2. Let n be the length of S.\\n  var n = s.length;\\n\\n  // 3. Initialize i to 0.\\n  var i = 0;\\n\\n  // 4. Initialize U to be an empty sequence of Unicode characters.\\n  var u = [];\\n\\n  // 5. While i < n:\\n  while (i < n) {\\n\\n    // 1. Let c be the code unit in S at index i.\\n    var c = s.charCodeAt(i);\\n\\n    // 2. Depending on the value of c:\\n\\n    // c < 0xD800 or c > 0xDFFF\\n    if (c < 0xD800 || c > 0xDFFF) {\\n      // Append to U the Unicode character with code point c.\\n      u.push(c);\\n    }\\n\\n    // 0xDC00 ≤ c ≤ 0xDFFF\\n    else if (0xDC00 <= c && c <= 0xDFFF) {\\n      // Append to U a U+FFFD REPLACEMENT CHARACTER.\\n      u.push(0xFFFD);\\n    }\\n\\n    // 0xD800 ≤ c ≤ 0xDBFF\\n    else if (0xD800 <= c && c <= 0xDBFF) {\\n      // 1. If i = n−1, then append to U a U+FFFD REPLACEMENT\\n      // CHARACTER.\\n      if (i === n - 1) {\\n        u.push(0xFFFD);\\n      }\\n      // 2. Otherwise, i < n−1:\\n      else {\\n        // 1. Let d be the code unit in S at index i+1.\\n        var d = string.charCodeAt(i + 1);\\n\\n        // 2. If 0xDC00 ≤ d ≤ 0xDFFF, then:\\n        if (0xDC00 <= d && d <= 0xDFFF) {\\n          // 1. Let a be c & 0x3FF.\\n          var a = c & 0x3FF;\\n\\n          // 2. Let b be d & 0x3FF.\\n          var b = d & 0x3FF;\\n\\n          // 3. Append to U the Unicode character with code point\\n          // 2^16+2^10*a+b.\\n          u.push(0x10000 + (a << 10) + b);\\n\\n          // 4. Set i to i+1.\\n          i += 1;\\n        }\\n\\n        // 3. Otherwise, d < 0xDC00 or d > 0xDFFF. Append to U a\\n        // U+FFFD REPLACEMENT CHARACTER.\\n        else  {\\n          u.push(0xFFFD);\\n        }\\n      }\\n    }\\n\\n    // 3. Set i to i+1.\\n    i += 1;\\n  }\\n\\n  // 6. Return U.\\n  return u;\\n}\\n\\n/**\\n * @param {!Array.<number>} code_points Array of code points.\\n * @return {string} string String of UTF-16 code units.\\n */\\nfunction codePointsToString(code_points) {\\n  var s = '';\\n  for (var i = 0; i < code_points.length; ++i) {\\n    var cp = code_points[i];\\n    if (cp <= 0xFFFF) {\\n      s += String.fromCharCode(cp);\\n    } else {\\n      cp -= 0x10000;\\n      s += String.fromCharCode((cp >> 10) + 0xD800,\\n                               (cp & 0x3FF) + 0xDC00);\\n    }\\n  }\\n  return s;\\n}\\n\\n\\n//\\n// Implementation of Encoding specification\\n// https://encoding.spec.whatwg.org/\\n//\\n\\n//\\n// 3. Terminology\\n//\\n\\n/**\\n * End-of-stream is a special token that signifies no more tokens\\n * are in the stream.\\n * @const\\n */ var end_of_stream = -1;\\n\\n/**\\n * A stream represents an ordered sequence of tokens.\\n *\\n * @constructor\\n * @param {!(Array.<number>|Uint8Array)} tokens Array of tokens that provide the\\n * stream.\\n */\\nfunction Stream(tokens) {\\n  /** @type {!Array.<number>} */\\n  this.tokens = [].slice.call(tokens);\\n}\\n\\nStream.prototype = {\\n  /**\\n   * @return {boolean} True if end-of-stream has been hit.\\n   */\\n  endOfStream: function() {\\n    return !this.tokens.length;\\n  },\\n\\n  /**\\n   * When a token is read from a stream, the first token in the\\n   * stream must be returned and subsequently removed, and\\n   * end-of-stream must be returned otherwise.\\n   *\\n   * @return {number} Get the next token from the stream, or\\n   * end_of_stream.\\n   */\\n   read: function() {\\n    if (!this.tokens.length)\\n      return end_of_stream;\\n     return this.tokens.shift();\\n   },\\n\\n  /**\\n   * When one or more tokens are prepended to a stream, those tokens\\n   * must be inserted, in given order, before the first token in the\\n   * stream.\\n   *\\n   * @param {(number|!Array.<number>)} token The token(s) to prepend to the stream.\\n   */\\n  prepend: function(token) {\\n    if (Array.isArray(token)) {\\n      var tokens = /**@type {!Array.<number>}*/(token);\\n      while (tokens.length)\\n        this.tokens.unshift(tokens.pop());\\n    } else {\\n      this.tokens.unshift(token);\\n    }\\n  },\\n\\n  /**\\n   * When one or more tokens are pushed to a stream, those tokens\\n   * must be inserted, in given order, after the last token in the\\n   * stream.\\n   *\\n   * @param {(number|!Array.<number>)} token The tokens(s) to prepend to the stream.\\n   */\\n  push: function(token) {\\n    if (Array.isArray(token)) {\\n      var tokens = /**@type {!Array.<number>}*/(token);\\n      while (tokens.length)\\n        this.tokens.push(tokens.shift());\\n    } else {\\n      this.tokens.push(token);\\n    }\\n  }\\n};\\n\\n//\\n// 4. Encodings\\n//\\n\\n// 4.1 Encoders and decoders\\n\\n/** @const */\\nvar finished = -1;\\n\\n/**\\n * @param {boolean} fatal If true, decoding errors raise an exception.\\n * @param {number=} opt_code_point Override the standard fallback code point.\\n * @return {number} The code point to insert on a decoding error.\\n */\\nfunction decoderError(fatal, opt_code_point) {\\n  if (fatal)\\n    throw TypeError('Decoder error');\\n  return opt_code_point || 0xFFFD;\\n}\\n\\n//\\n// 7. API\\n//\\n\\n/** @const */ var DEFAULT_ENCODING = 'utf-8';\\n\\n// 7.1 Interface TextDecoder\\n\\n/**\\n * @constructor\\n * @param {string=} encoding The label of the encoding;\\n *     defaults to 'utf-8'.\\n * @param {Object=} options\\n */\\nfunction TextDecoder(encoding, options) {\\n  if (!(this instanceof TextDecoder)) {\\n    return new TextDecoder(encoding, options);\\n  }\\n  encoding = encoding !== undefined ? String(encoding).toLowerCase() : DEFAULT_ENCODING;\\n  if (encoding !== DEFAULT_ENCODING) {\\n    throw new Error('Encoding not supported. Only utf-8 is supported');\\n  }\\n  options = ToDictionary(options);\\n\\n  /** @private @type {boolean} */\\n  this._streaming = false;\\n  /** @private @type {boolean} */\\n  this._BOMseen = false;\\n  /** @private @type {?Decoder} */\\n  this._decoder = null;\\n  /** @private @type {boolean} */\\n  this._fatal = Boolean(options['fatal']);\\n  /** @private @type {boolean} */\\n  this._ignoreBOM = Boolean(options['ignoreBOM']);\\n\\n  Object.defineProperty(this, 'encoding', {value: 'utf-8'});\\n  Object.defineProperty(this, 'fatal', {value: this._fatal});\\n  Object.defineProperty(this, 'ignoreBOM', {value: this._ignoreBOM});\\n}\\n\\nTextDecoder.prototype = {\\n  /**\\n   * @param {ArrayBufferView=} input The buffer of bytes to decode.\\n   * @param {Object=} options\\n   * @return {string} The decoded string.\\n   */\\n  decode: function decode(input, options) {\\n    var bytes;\\n    if (typeof input === 'object' && input instanceof ArrayBuffer) {\\n      bytes = new Uint8Array(input);\\n    } else if (typeof input === 'object' && 'buffer' in input &&\\n               input.buffer instanceof ArrayBuffer) {\\n      bytes = new Uint8Array(input.buffer,\\n                             input.byteOffset,\\n                             input.byteLength);\\n    } else {\\n      bytes = new Uint8Array(0);\\n    }\\n\\n    options = ToDictionary(options);\\n\\n    if (!this._streaming) {\\n      this._decoder = new UTF8Decoder({fatal: this._fatal});\\n      this._BOMseen = false;\\n    }\\n    this._streaming = Boolean(options['stream']);\\n\\n    var input_stream = new Stream(bytes);\\n\\n    var code_points = [];\\n\\n    /** @type {?(number|!Array.<number>)} */\\n    var result;\\n\\n    while (!input_stream.endOfStream()) {\\n      result = this._decoder.handler(input_stream, input_stream.read());\\n      if (result === finished)\\n        break;\\n      if (result === null)\\n        continue;\\n      if (Array.isArray(result))\\n        code_points.push.apply(code_points, /**@type {!Array.<number>}*/(result));\\n      else\\n        code_points.push(result);\\n    }\\n    if (!this._streaming) {\\n      do {\\n        result = this._decoder.handler(input_stream, input_stream.read());\\n        if (result === finished)\\n          break;\\n        if (result === null)\\n          continue;\\n        if (Array.isArray(result))\\n          code_points.push.apply(code_points, /**@type {!Array.<number>}*/(result));\\n        else\\n          code_points.push(result);\\n      } while (!input_stream.endOfStream());\\n      this._decoder = null;\\n    }\\n\\n    if (code_points.length) {\\n      // If encoding is one of utf-8, utf-16be, and utf-16le, and\\n      // ignore BOM flag and BOM seen flag are unset, run these\\n      // subsubsteps:\\n      if (['utf-8'].indexOf(this.encoding) !== -1 &&\\n          !this._ignoreBOM && !this._BOMseen) {\\n        // If token is U+FEFF, set BOM seen flag.\\n        if (code_points[0] === 0xFEFF) {\\n          this._BOMseen = true;\\n          code_points.shift();\\n        } else {\\n          // Otherwise, if token is not end-of-stream, set BOM seen\\n          // flag and append token to output.\\n          this._BOMseen = true;\\n        }\\n      }\\n    }\\n\\n    return codePointsToString(code_points);\\n  }\\n};\\n\\n// 7.2 Interface TextEncoder\\n\\n/**\\n * @constructor\\n * @param {string=} encoding The label of the encoding;\\n *     defaults to 'utf-8'.\\n * @param {Object=} options\\n */\\nfunction TextEncoder(encoding, options) {\\n  if (!(this instanceof TextEncoder))\\n    return new TextEncoder(encoding, options);\\n  encoding = encoding !== undefined ? String(encoding).toLowerCase() : DEFAULT_ENCODING;\\n  if (encoding !== DEFAULT_ENCODING) {\\n    throw new Error('Encoding not supported. Only utf-8 is supported');\\n  }\\n  options = ToDictionary(options);\\n\\n  /** @private @type {boolean} */\\n  this._streaming = false;\\n  /** @private @type {?Encoder} */\\n  this._encoder = null;\\n  /** @private @type {{fatal: boolean}} */\\n  this._options = {fatal: Boolean(options['fatal'])};\\n\\n  Object.defineProperty(this, 'encoding', {value: 'utf-8'});\\n}\\n\\nTextEncoder.prototype = {\\n  /**\\n   * @param {string=} opt_string The string to encode.\\n   * @param {Object=} options\\n   * @return {Uint8Array} Encoded bytes, as a Uint8Array.\\n   */\\n  encode: function encode(opt_string, options) {\\n    opt_string = opt_string ? String(opt_string) : '';\\n    options = ToDictionary(options);\\n\\n    // NOTE: This option is nonstandard. None of the encodings\\n    // permitted for encoding (i.e. UTF-8, UTF-16) are stateful,\\n    // so streaming is not necessary.\\n    if (!this._streaming)\\n      this._encoder = new UTF8Encoder(this._options);\\n    this._streaming = Boolean(options['stream']);\\n\\n    var bytes = [];\\n    var input_stream = new Stream(stringToCodePoints(opt_string));\\n    /** @type {?(number|!Array.<number>)} */\\n    var result;\\n    while (!input_stream.endOfStream()) {\\n      result = this._encoder.handler(input_stream, input_stream.read());\\n      if (result === finished)\\n        break;\\n      if (Array.isArray(result))\\n        bytes.push.apply(bytes, /**@type {!Array.<number>}*/(result));\\n      else\\n        bytes.push(result);\\n    }\\n    if (!this._streaming) {\\n      while (true) {\\n        result = this._encoder.handler(input_stream, input_stream.read());\\n        if (result === finished)\\n          break;\\n        if (Array.isArray(result))\\n          bytes.push.apply(bytes, /**@type {!Array.<number>}*/(result));\\n        else\\n          bytes.push(result);\\n      }\\n      this._encoder = null;\\n    }\\n    return new Uint8Array(bytes);\\n  }\\n};\\n\\n//\\n// 8. The encoding\\n//\\n\\n// 8.1 utf-8\\n\\n/**\\n * @constructor\\n * @implements {Decoder}\\n * @param {{fatal: boolean}} options\\n */\\nfunction UTF8Decoder(options) {\\n  var fatal = options.fatal;\\n\\n  // utf-8's decoder's has an associated utf-8 code point, utf-8\\n  // bytes seen, and utf-8 bytes needed (all initially 0), a utf-8\\n  // lower boundary (initially 0x80), and a utf-8 upper boundary\\n  // (initially 0xBF).\\n  var /** @type {number} */ utf8_code_point = 0,\\n      /** @type {number} */ utf8_bytes_seen = 0,\\n      /** @type {number} */ utf8_bytes_needed = 0,\\n      /** @type {number} */ utf8_lower_boundary = 0x80,\\n      /** @type {number} */ utf8_upper_boundary = 0xBF;\\n\\n  /**\\n   * @param {Stream} stream The stream of bytes being decoded.\\n   * @param {number} bite The next byte read from the stream.\\n   * @return {?(number|!Array.<number>)} The next code point(s)\\n   *     decoded, or null if not enough data exists in the input\\n   *     stream to decode a complete code point.\\n   */\\n  this.handler = function(stream, bite) {\\n    // 1. If byte is end-of-stream and utf-8 bytes needed is not 0,\\n    // set utf-8 bytes needed to 0 and return error.\\n    if (bite === end_of_stream && utf8_bytes_needed !== 0) {\\n      utf8_bytes_needed = 0;\\n      return decoderError(fatal);\\n    }\\n\\n    // 2. If byte is end-of-stream, return finished.\\n    if (bite === end_of_stream)\\n      return finished;\\n\\n    // 3. If utf-8 bytes needed is 0, based on byte:\\n    if (utf8_bytes_needed === 0) {\\n\\n      // 0x00 to 0x7F\\n      if (inRange(bite, 0x00, 0x7F)) {\\n        // Return a code point whose value is byte.\\n        return bite;\\n      }\\n\\n      // 0xC2 to 0xDF\\n      if (inRange(bite, 0xC2, 0xDF)) {\\n        // Set utf-8 bytes needed to 1 and utf-8 code point to byte\\n        // − 0xC0.\\n        utf8_bytes_needed = 1;\\n        utf8_code_point = bite - 0xC0;\\n      }\\n\\n      // 0xE0 to 0xEF\\n      else if (inRange(bite, 0xE0, 0xEF)) {\\n        // 1. If byte is 0xE0, set utf-8 lower boundary to 0xA0.\\n        if (bite === 0xE0)\\n          utf8_lower_boundary = 0xA0;\\n        // 2. If byte is 0xED, set utf-8 upper boundary to 0x9F.\\n        if (bite === 0xED)\\n          utf8_upper_boundary = 0x9F;\\n        // 3. Set utf-8 bytes needed to 2 and utf-8 code point to\\n        // byte − 0xE0.\\n        utf8_bytes_needed = 2;\\n        utf8_code_point = bite - 0xE0;\\n      }\\n\\n      // 0xF0 to 0xF4\\n      else if (inRange(bite, 0xF0, 0xF4)) {\\n        // 1. If byte is 0xF0, set utf-8 lower boundary to 0x90.\\n        if (bite === 0xF0)\\n          utf8_lower_boundary = 0x90;\\n        // 2. If byte is 0xF4, set utf-8 upper boundary to 0x8F.\\n        if (bite === 0xF4)\\n          utf8_upper_boundary = 0x8F;\\n        // 3. Set utf-8 bytes needed to 3 and utf-8 code point to\\n        // byte − 0xF0.\\n        utf8_bytes_needed = 3;\\n        utf8_code_point = bite - 0xF0;\\n      }\\n\\n      // Otherwise\\n      else {\\n        // Return error.\\n        return decoderError(fatal);\\n      }\\n\\n      // Then (byte is in the range 0xC2 to 0xF4) set utf-8 code\\n      // point to utf-8 code point << (6 × utf-8 bytes needed) and\\n      // return continue.\\n      utf8_code_point = utf8_code_point << (6 * utf8_bytes_needed);\\n      return null;\\n    }\\n\\n    // 4. If byte is not in the range utf-8 lower boundary to utf-8\\n    // upper boundary, run these substeps:\\n    if (!inRange(bite, utf8_lower_boundary, utf8_upper_boundary)) {\\n\\n      // 1. Set utf-8 code point, utf-8 bytes needed, and utf-8\\n      // bytes seen to 0, set utf-8 lower boundary to 0x80, and set\\n      // utf-8 upper boundary to 0xBF.\\n      utf8_code_point = utf8_bytes_needed = utf8_bytes_seen = 0;\\n      utf8_lower_boundary = 0x80;\\n      utf8_upper_boundary = 0xBF;\\n\\n      // 2. Prepend byte to stream.\\n      stream.prepend(bite);\\n\\n      // 3. Return error.\\n      return decoderError(fatal);\\n    }\\n\\n    // 5. Set utf-8 lower boundary to 0x80 and utf-8 upper boundary\\n    // to 0xBF.\\n    utf8_lower_boundary = 0x80;\\n    utf8_upper_boundary = 0xBF;\\n\\n    // 6. Increase utf-8 bytes seen by one and set utf-8 code point\\n    // to utf-8 code point + (byte − 0x80) << (6 × (utf-8 bytes\\n    // needed − utf-8 bytes seen)).\\n    utf8_bytes_seen += 1;\\n    utf8_code_point += (bite - 0x80) << (6 * (utf8_bytes_needed - utf8_bytes_seen));\\n\\n    // 7. If utf-8 bytes seen is not equal to utf-8 bytes needed,\\n    // continue.\\n    if (utf8_bytes_seen !== utf8_bytes_needed)\\n      return null;\\n\\n    // 8. Let code point be utf-8 code point.\\n    var code_point = utf8_code_point;\\n\\n    // 9. Set utf-8 code point, utf-8 bytes needed, and utf-8 bytes\\n    // seen to 0.\\n    utf8_code_point = utf8_bytes_needed = utf8_bytes_seen = 0;\\n\\n    // 10. Return a code point whose value is code point.\\n    return code_point;\\n  };\\n}\\n\\n/**\\n * @constructor\\n * @implements {Encoder}\\n * @param {{fatal: boolean}} options\\n */\\nfunction UTF8Encoder(options) {\\n  var fatal = options.fatal;\\n  /**\\n   * @param {Stream} stream Input stream.\\n   * @param {number} code_point Next code point read from the stream.\\n   * @return {(number|!Array.<number>)} Byte(s) to emit.\\n   */\\n  this.handler = function(stream, code_point) {\\n    // 1. If code point is end-of-stream, return finished.\\n    if (code_point === end_of_stream)\\n      return finished;\\n\\n    // 2. If code point is in the range U+0000 to U+007F, return a\\n    // byte whose value is code point.\\n    if (inRange(code_point, 0x0000, 0x007f))\\n      return code_point;\\n\\n    // 3. Set count and offset based on the range code point is in:\\n    var count, offset;\\n    // U+0080 to U+07FF:    1 and 0xC0\\n    if (inRange(code_point, 0x0080, 0x07FF)) {\\n      count = 1;\\n      offset = 0xC0;\\n    }\\n    // U+0800 to U+FFFF:    2 and 0xE0\\n    else if (inRange(code_point, 0x0800, 0xFFFF)) {\\n      count = 2;\\n      offset = 0xE0;\\n    }\\n    // U+10000 to U+10FFFF: 3 and 0xF0\\n    else if (inRange(code_point, 0x10000, 0x10FFFF)) {\\n      count = 3;\\n      offset = 0xF0;\\n    }\\n\\n    // 4.Let bytes be a byte sequence whose first byte is (code\\n    // point >> (6 × count)) + offset.\\n    var bytes = [(code_point >> (6 * count)) + offset];\\n\\n    // 5. Run these substeps while count is greater than 0:\\n    while (count > 0) {\\n\\n      // 1. Set temp to code point >> (6 × (count − 1)).\\n      var temp = code_point >> (6 * (count - 1));\\n\\n      // 2. Append to bytes 0x80 | (temp & 0x3F).\\n      bytes.push(0x80 | (temp & 0x3F));\\n\\n      // 3. Decrease count by one.\\n      count -= 1;\\n    }\\n\\n    // 6. Return bytes bytes, in order.\\n    return bytes;\\n  };\\n}\\n\\nexports.TextEncoder = TextEncoder;\\nexports.TextDecoder = TextDecoder;\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/text-encoding-utf-8/lib/encoding.lib.js?\");\n\n/***/ }),\n\n/***/ \"./src/domain/amountSchema.ts\":\n/*!************************************!*\\\n  !*** ./src/domain/amountSchema.ts ***!\n  \\************************************/\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"amountSchema\\\": () => (/* binding */ amountSchema)\\n/* harmony export */ });\\n/* harmony import */ var _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @solana/buffer-layout */ \\\"./node_modules/@solana/buffer-layout/lib/Layout.js\\\");\\n/* harmony import */ var _solana_buffer_layout_utils__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @solana/buffer-layout-utils */ \\\"./node_modules/@solana/buffer-layout-utils/lib/esm/index.mjs\\\");\\n\\n\\nconst amountSchema = (0,_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_0__.struct)([(0,_solana_buffer_layout_utils__WEBPACK_IMPORTED_MODULE_1__.u64)('amount')]);\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./src/domain/amountSchema.ts?\");\n\n/***/ }),\n\n/***/ \"./src/domain/instructions.ts\":\n/*!************************************!*\\\n  !*** ./src/domain/instructions.ts ***!\n  \\************************************/\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"FlashLoanInstruction\\\": () => (/* binding */ FlashLoanInstruction)\\n/* harmony export */ });\\nvar FlashLoanInstruction;\\n(function (FlashLoanInstruction) {\\n    FlashLoanInstruction[FlashLoanInstruction[\\\"InitLendingMarket\\\"] = 0] = \\\"InitLendingMarket\\\";\\n    FlashLoanInstruction[FlashLoanInstruction[\\\"SetLendingMarketOwner\\\"] = 1] = \\\"SetLendingMarketOwner\\\";\\n    FlashLoanInstruction[FlashLoanInstruction[\\\"InitReserve\\\"] = 2] = \\\"InitReserve\\\";\\n    FlashLoanInstruction[FlashLoanInstruction[\\\"Deposit\\\"] = 3] = \\\"Deposit\\\";\\n    FlashLoanInstruction[FlashLoanInstruction[\\\"Withdraw\\\"] = 4] = \\\"Withdraw\\\";\\n    FlashLoanInstruction[FlashLoanInstruction[\\\"FlashLoan\\\"] = 5] = \\\"FlashLoan\\\";\\n    FlashLoanInstruction[FlashLoanInstruction[\\\"UpdateReserveConfig\\\"] = 6] = \\\"UpdateReserveConfig\\\";\\n    FlashLoanInstruction[FlashLoanInstruction[\\\"FlashBorrow\\\"] = 7] = \\\"FlashBorrow\\\";\\n    FlashLoanInstruction[FlashLoanInstruction[\\\"FlashRepay\\\"] = 8] = \\\"FlashRepay\\\";\\n    FlashLoanInstruction[FlashLoanInstruction[\\\"Sync\\\"] = 9] = \\\"Sync\\\";\\n})(FlashLoanInstruction || (FlashLoanInstruction = {}));\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./src/domain/instructions.ts?\");\n\n/***/ }),\n\n/***/ \"./src/domain/reserve/index.ts\":\n/*!*************************************!*\\\n  !*** ./src/domain/reserve/index.ts ***!\n  \\*************************************/\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"Reserve\\\": () => (/* reexport safe */ _reserve__WEBPACK_IMPORTED_MODULE_0__.Reserve)\\n/* harmony export */ });\\n/* harmony import */ var _reserve__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./reserve */ \\\"./src/domain/reserve/reserve.ts\\\");\\n\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./src/domain/reserve/index.ts?\");\n\n/***/ }),\n\n/***/ \"./src/domain/reserve/reserve.ts\":\n/*!***************************************!*\\\n  !*** ./src/domain/reserve/reserve.ts ***!\n  \\***************************************/\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"Reserve\\\": () => (/* binding */ Reserve)\\n/* harmony export */ });\\n/* harmony import */ var _solana_web3_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @solana/web3.js */ \\\"./node_modules/@solana/web3.js/lib/index.browser.esm.js\\\");\\n/* harmony import */ var _solana_spl_token__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @solana/spl-token */ \\\"./node_modules/@solana/spl-token/lib/esm/constants.js\\\");\\n/* harmony import */ var _utils_const__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../utils/const */ \\\"./src/utils/const.ts\\\");\\n/* harmony import */ var _domain_amountSchema__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../domain/amountSchema */ \\\"./src/domain/amountSchema.ts\\\");\\n/* harmony import */ var _domain_instructions__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! #domain/instructions */ \\\"./src/domain/instructions.ts\\\");\\n/* provided dependency */ var Buffer = __webpack_require__(/*! buffer */ \\\"./node_modules/buffer/index.js\\\")[\\\"Buffer\\\"];\\n\\n\\n\\n\\n\\nvar FeeCalculation;\\n(function (FeeCalculation) {\\n    /// Fee added to amount: fee = rate * amount\\n    FeeCalculation[FeeCalculation[\\\"Exclusive\\\"] = 0] = \\\"Exclusive\\\";\\n    /// Fee included in amount: fee = (rate / (1 + rate)) * amount\\n    FeeCalculation[FeeCalculation[\\\"Inclusive\\\"] = 1] = \\\"Inclusive\\\";\\n})(FeeCalculation || (FeeCalculation = {}));\\nclass Reserve {\\n    constructor(data, pubkey) {\\n        this.data = data;\\n        this.pubkey = pubkey;\\n    }\\n    fee(amount, feeCalculation = FeeCalculation.Exclusive) {\\n        const borrowFeeRate = Number(this.data.config.fees.flash_loan_fee_wad) / 1e18;\\n        const textureFeeRate = this.data.config.fees.texture_fee_percentage / 1e3;\\n        if (borrowFeeRate > 0 && amount > 0) {\\n            let needToAssessTextureFee = textureFeeRate > 0;\\n            const minimumFee = needToAssessTextureFee ? 2 : 1;\\n            let borrowFeeAmount;\\n            switch (feeCalculation) {\\n                case FeeCalculation.Exclusive:\\n                    borrowFeeAmount = amount * borrowFeeRate;\\n                    break;\\n                case FeeCalculation.Inclusive:\\n                    borrowFeeAmount = amount * (borrowFeeRate / (1 + borrowFeeRate));\\n                    break;\\n            }\\n            const borrowFee = Math.max(borrowFeeAmount, minimumFee);\\n            if (borrowFee >= amount) {\\n                throw new Error('Borrow amount is too small to receive liquidity after fees');\\n            }\\n            const textureFee = needToAssessTextureFee ? (Math.max(borrowFee * textureFeeRate, 1)) : 0;\\n            return borrowFee;\\n        }\\n        return 0;\\n    }\\n    availableLiquidity() {\\n        return Number(this.data.liquidity.available_amount);\\n    }\\n    flashBorrow(amount, destination) {\\n        const [lendingMarketAuthority] = _solana_web3_js__WEBPACK_IMPORTED_MODULE_0__.PublicKey.findProgramAddressSync([this.data.lending_market.toBuffer()], _utils_const__WEBPACK_IMPORTED_MODULE_1__.FLASH_LOAN_ID);\\n        const keys = [\\n            Reserve.meta(this.data.liquidity.supply_pubkey, false, true),\\n            Reserve.meta(destination, false, true),\\n            Reserve.meta(this.pubkey, false, true),\\n            Reserve.meta(this.data.lending_market, false, false),\\n            Reserve.meta(lendingMarketAuthority, false, false),\\n            Reserve.meta(_solana_web3_js__WEBPACK_IMPORTED_MODULE_0__.SYSVAR_INSTRUCTIONS_PUBKEY, false, false),\\n            Reserve.meta(_solana_spl_token__WEBPACK_IMPORTED_MODULE_4__.TOKEN_PROGRAM_ID, false, false),\\n        ];\\n        const buffer = Buffer.alloc(8);\\n        _domain_amountSchema__WEBPACK_IMPORTED_MODULE_2__.amountSchema.encode({ amount }, buffer);\\n        return this.instruction(keys, Buffer.from([\\n            _domain_instructions__WEBPACK_IMPORTED_MODULE_3__.FlashLoanInstruction.FlashBorrow,\\n            ...buffer,\\n        ]));\\n    }\\n    flashRepay(amount, source, authority) {\\n        const keys = [\\n            Reserve.meta(source, false, true),\\n            Reserve.meta(this.data.liquidity.supply_pubkey, false, true),\\n            Reserve.meta(this.data.config.fee_receiver, false, true),\\n            Reserve.meta(this.pubkey, false, true),\\n            Reserve.meta(this.data.lending_market, false, false),\\n            Reserve.meta(authority, true, false),\\n            Reserve.meta(_solana_web3_js__WEBPACK_IMPORTED_MODULE_0__.SYSVAR_INSTRUCTIONS_PUBKEY, false, false),\\n            Reserve.meta(_solana_spl_token__WEBPACK_IMPORTED_MODULE_4__.TOKEN_PROGRAM_ID, false, false),\\n        ];\\n        const buffer = Buffer.alloc(8);\\n        _domain_amountSchema__WEBPACK_IMPORTED_MODULE_2__.amountSchema.encode({ amount }, buffer);\\n        return this.instruction(keys, Buffer.from([\\n            _domain_instructions__WEBPACK_IMPORTED_MODULE_3__.FlashLoanInstruction.FlashRepay,\\n            ...buffer,\\n        ]));\\n    }\\n    instruction(keys, data, programId = _utils_const__WEBPACK_IMPORTED_MODULE_1__.FLASH_LOAN_ID) {\\n        return new _solana_web3_js__WEBPACK_IMPORTED_MODULE_0__.TransactionInstruction({\\n            keys,\\n            programId,\\n            data,\\n        });\\n    }\\n    static meta(pubkey, isSigner, isWritable) {\\n        return { pubkey, isSigner, isWritable };\\n    }\\n}\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./src/domain/reserve/reserve.ts?\");\n\n/***/ }),\n\n/***/ \"./src/index.ts\":\n/*!**********************!*\\\n  !*** ./src/index.ts ***!\n  \\**********************/\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"AccountService\\\": () => (/* reexport safe */ _infrastructure_accountService__WEBPACK_IMPORTED_MODULE_0__.AccountService),\\n/* harmony export */   \\\"FLASH_LOAN_ID\\\": () => (/* reexport safe */ _utils_const__WEBPACK_IMPORTED_MODULE_2__.FLASH_LOAN_ID),\\n/* harmony export */   \\\"Reserve\\\": () => (/* reexport safe */ _domain_reserve__WEBPACK_IMPORTED_MODULE_1__.Reserve)\\n/* harmony export */ });\\n/* harmony import */ var _infrastructure_accountService__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./infrastructure/accountService */ \\\"./src/infrastructure/accountService/index.ts\\\");\\n/* harmony import */ var _domain_reserve__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./domain/reserve */ \\\"./src/domain/reserve/index.ts\\\");\\n/* harmony import */ var _utils_const__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./utils/const */ \\\"./src/utils/const.ts\\\");\\n\\n\\n\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./src/index.ts?\");\n\n/***/ }),\n\n/***/ \"./src/infrastructure/accountService/decode.ts\":\n/*!*****************************************************!*\\\n  !*** ./src/infrastructure/accountService/decode.ts ***!\n  \\*****************************************************/\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"reserveDecode\\\": () => (/* binding */ reserveDecode)\\n/* harmony export */ });\\n/* harmony import */ var _layout_reserve__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./layout/reserve */ \\\"./src/infrastructure/accountService/layout/reserve/index.ts\\\");\\n\\nfunction reserveDecode(data) {\\n    return _layout_reserve__WEBPACK_IMPORTED_MODULE_0__.reserveLayout.decode(data);\\n}\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./src/infrastructure/accountService/decode.ts?\");\n\n/***/ }),\n\n/***/ \"./src/infrastructure/accountService/index.ts\":\n/*!****************************************************!*\\\n  !*** ./src/infrastructure/accountService/index.ts ***!\n  \\****************************************************/\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"AccountService\\\": () => (/* binding */ AccountService)\\n/* harmony export */ });\\n/* harmony import */ var _domain_reserve__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../domain/reserve */ \\\"./src/domain/reserve/index.ts\\\");\\n/* harmony import */ var _utils_const__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../utils/const */ \\\"./src/utils/const.ts\\\");\\n/* harmony import */ var _decode__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./decode */ \\\"./src/infrastructure/accountService/decode.ts\\\");\\n/* harmony import */ var _layout_reserve__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./layout/reserve */ \\\"./src/infrastructure/accountService/layout/reserve/index.ts\\\");\\n\\n\\n\\n\\nclass AccountService {\\n    constructor(connection) {\\n        this.connection = connection;\\n    }\\n    getAllReserves(programId = _utils_const__WEBPACK_IMPORTED_MODULE_1__.FLASH_LOAN_ID) {\\n        return this.getProgramAccounts(programId, [{ dataSize: _layout_reserve__WEBPACK_IMPORTED_MODULE_3__.reserveLayout.span }])\\n            .then((accounts) => accounts.map(({ account, pubkey }) => new _domain_reserve__WEBPACK_IMPORTED_MODULE_0__.Reserve((0,_decode__WEBPACK_IMPORTED_MODULE_2__.reserveDecode)(account.data), pubkey)));\\n    }\\n    getReserveInfo(reserveAddress) {\\n        return this.getAccountInfo(reserveAddress, _decode__WEBPACK_IMPORTED_MODULE_2__.reserveDecode).then((data) => new _domain_reserve__WEBPACK_IMPORTED_MODULE_0__.Reserve(data, reserveAddress));\\n    }\\n    getProgramAccounts(publicKey, filters) {\\n        return this.connection.getProgramAccounts(publicKey, { filters });\\n    }\\n    getAccountInfo(publicKey, decoder) {\\n        return this.connection.getAccountInfo(publicKey)\\n            .then((accountInfo) => {\\n            if (!accountInfo) {\\n                return Promise.reject(`getAccountInfo: account ${publicKey.toBase58()} not found`);\\n            }\\n            return decoder(accountInfo.data);\\n        });\\n    }\\n}\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./src/infrastructure/accountService/index.ts?\");\n\n/***/ }),\n\n/***/ \"./src/infrastructure/accountService/layout/reserve/index.ts\":\n/*!*******************************************************************!*\\\n  !*** ./src/infrastructure/accountService/layout/reserve/index.ts ***!\n  \\*******************************************************************/\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"reserveLayout\\\": () => (/* reexport safe */ _reserve__WEBPACK_IMPORTED_MODULE_0__.reserveLayout)\\n/* harmony export */ });\\n/* harmony import */ var _reserve__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./reserve */ \\\"./src/infrastructure/accountService/layout/reserve/reserve.ts\\\");\\n\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./src/infrastructure/accountService/layout/reserve/index.ts?\");\n\n/***/ }),\n\n/***/ \"./src/infrastructure/accountService/layout/reserve/reserve.ts\":\n/*!*********************************************************************!*\\\n  !*** ./src/infrastructure/accountService/layout/reserve/reserve.ts ***!\n  \\*********************************************************************/\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"reserveLayout\\\": () => (/* binding */ reserveLayout)\\n/* harmony export */ });\\n/* harmony import */ var _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @solana/buffer-layout */ \\\"./node_modules/@solana/buffer-layout/lib/Layout.js\\\");\\n/* harmony import */ var _solana_buffer_layout_utils__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @solana/buffer-layout-utils */ \\\"./node_modules/@solana/buffer-layout-utils/lib/esm/index.mjs\\\");\\n/* harmony import */ var _reserveLiquidity__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./reserveLiquidity */ \\\"./src/infrastructure/accountService/layout/reserve/reserveLiquidity.ts\\\");\\n/* harmony import */ var _reserveLpTokens__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./reserveLpTokens */ \\\"./src/infrastructure/accountService/layout/reserve/reserveLpTokens.ts\\\");\\n/* harmony import */ var _reserveConfig__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./reserveConfig */ \\\"./src/infrastructure/accountService/layout/reserve/reserveConfig.ts\\\");\\n\\n\\n\\n\\n\\nconst reserveLayout = (0,_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_0__.struct)([\\n    (0,_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_0__.u8)('version'),\\n    (0,_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_0__.blob)(7, '_padding'),\\n    (0,_solana_buffer_layout_utils__WEBPACK_IMPORTED_MODULE_1__.u64)('last_update'),\\n    (0,_solana_buffer_layout_utils__WEBPACK_IMPORTED_MODULE_1__.publicKey)('lending_market'),\\n    _reserveLiquidity__WEBPACK_IMPORTED_MODULE_2__.reserveLiquidityLayout,\\n    _reserveLpTokens__WEBPACK_IMPORTED_MODULE_3__.reserveLpTokensLayout,\\n    _reserveConfig__WEBPACK_IMPORTED_MODULE_4__.reserveConfigLayout,\\n    (0,_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_0__.blob)(40, '_future_padding'),\\n]);\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./src/infrastructure/accountService/layout/reserve/reserve.ts?\");\n\n/***/ }),\n\n/***/ \"./src/infrastructure/accountService/layout/reserve/reserveConfig.ts\":\n/*!***************************************************************************!*\\\n  !*** ./src/infrastructure/accountService/layout/reserve/reserveConfig.ts ***!\n  \\***************************************************************************/\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"reserveConfigLayout\\\": () => (/* binding */ reserveConfigLayout)\\n/* harmony export */ });\\n/* harmony import */ var _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @solana/buffer-layout */ \\\"./node_modules/@solana/buffer-layout/lib/Layout.js\\\");\\n/* harmony import */ var _solana_buffer_layout_utils__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @solana/buffer-layout-utils */ \\\"./node_modules/@solana/buffer-layout-utils/lib/esm/index.mjs\\\");\\n/* harmony import */ var _reserveFees__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./reserveFees */ \\\"./src/infrastructure/accountService/layout/reserve/reserveFees.ts\\\");\\n\\n\\n\\nconst reserveConfigLayout = (0,_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_0__.struct)([\\n    _reserveFees__WEBPACK_IMPORTED_MODULE_2__.reserveFeesLayout,\\n    (0,_solana_buffer_layout_utils__WEBPACK_IMPORTED_MODULE_1__.u64)('deposit_limit'),\\n    (0,_solana_buffer_layout_utils__WEBPACK_IMPORTED_MODULE_1__.publicKey)('fee_receiver'),\\n    (0,_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_0__.blob)(32, '_future_padding1'),\\n    (0,_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_0__.blob)(32, '_future_padding2'),\\n], 'config');\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./src/infrastructure/accountService/layout/reserve/reserveConfig.ts?\");\n\n/***/ }),\n\n/***/ \"./src/infrastructure/accountService/layout/reserve/reserveFees.ts\":\n/*!*************************************************************************!*\\\n  !*** ./src/infrastructure/accountService/layout/reserve/reserveFees.ts ***!\n  \\*************************************************************************/\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"reserveFeesLayout\\\": () => (/* binding */ reserveFeesLayout)\\n/* harmony export */ });\\n/* harmony import */ var _solana_buffer_layout_utils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @solana/buffer-layout-utils */ \\\"./node_modules/@solana/buffer-layout-utils/lib/esm/index.mjs\\\");\\n/* harmony import */ var _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @solana/buffer-layout */ \\\"./node_modules/@solana/buffer-layout/lib/Layout.js\\\");\\n\\n\\nconst reserveFeesLayout = (0,_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_1__.struct)([\\n    (0,_solana_buffer_layout_utils__WEBPACK_IMPORTED_MODULE_0__.u64)('flash_loan_fee_wad'),\\n    (0,_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_1__.u8)('texture_fee_percentage'),\\n    (0,_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_1__.blob)(7, '_padding'),\\n], 'fees');\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./src/infrastructure/accountService/layout/reserve/reserveFees.ts?\");\n\n/***/ }),\n\n/***/ \"./src/infrastructure/accountService/layout/reserve/reserveLiquidity.ts\":\n/*!******************************************************************************!*\\\n  !*** ./src/infrastructure/accountService/layout/reserve/reserveLiquidity.ts ***!\n  \\******************************************************************************/\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"reserveLiquidityLayout\\\": () => (/* binding */ reserveLiquidityLayout)\\n/* harmony export */ });\\n/* harmony import */ var _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @solana/buffer-layout */ \\\"./node_modules/@solana/buffer-layout/lib/Layout.js\\\");\\n/* harmony import */ var _solana_buffer_layout_utils__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @solana/buffer-layout-utils */ \\\"./node_modules/@solana/buffer-layout-utils/lib/esm/index.mjs\\\");\\n\\n\\nconst reserveLiquidityLayout = (0,_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_0__.struct)([\\n    (0,_solana_buffer_layout_utils__WEBPACK_IMPORTED_MODULE_1__.publicKey)('mint_pubkey'),\\n    (0,_solana_buffer_layout_utils__WEBPACK_IMPORTED_MODULE_1__.u64)('mint_decimals'),\\n    (0,_solana_buffer_layout_utils__WEBPACK_IMPORTED_MODULE_1__.publicKey)('supply_pubkey'),\\n    (0,_solana_buffer_layout_utils__WEBPACK_IMPORTED_MODULE_1__.u64)('available_amount'),\\n], 'liquidity');\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./src/infrastructure/accountService/layout/reserve/reserveLiquidity.ts?\");\n\n/***/ }),\n\n/***/ \"./src/infrastructure/accountService/layout/reserve/reserveLpTokens.ts\":\n/*!*****************************************************************************!*\\\n  !*** ./src/infrastructure/accountService/layout/reserve/reserveLpTokens.ts ***!\n  \\*****************************************************************************/\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"reserveLpTokensLayout\\\": () => (/* binding */ reserveLpTokensLayout)\\n/* harmony export */ });\\n/* harmony import */ var _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @solana/buffer-layout */ \\\"./node_modules/@solana/buffer-layout/lib/Layout.js\\\");\\n/* harmony import */ var _solana_buffer_layout_utils__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @solana/buffer-layout-utils */ \\\"./node_modules/@solana/buffer-layout-utils/lib/esm/index.mjs\\\");\\n\\n\\nconst reserveLpTokensLayout = (0,_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_0__.struct)([\\n    (0,_solana_buffer_layout_utils__WEBPACK_IMPORTED_MODULE_1__.publicKey)('mint_pubkey'),\\n    (0,_solana_buffer_layout_utils__WEBPACK_IMPORTED_MODULE_1__.u64)('mint_total_supply'),\\n    (0,_solana_buffer_layout_utils__WEBPACK_IMPORTED_MODULE_1__.publicKey)('supply_pubkey'),\\n], 'lp_tokens_info');\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./src/infrastructure/accountService/layout/reserve/reserveLpTokens.ts?\");\n\n/***/ }),\n\n/***/ \"./src/utils/const.ts\":\n/*!****************************!*\\\n  !*** ./src/utils/const.ts ***!\n  \\****************************/\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"FLASH_LOAN_ID\\\": () => (/* binding */ FLASH_LOAN_ID),\\n/* harmony export */   \\\"USDC_RESERVE\\\": () => (/* binding */ USDC_RESERVE),\\n/* harmony export */   \\\"WSOL_RESERVE\\\": () => (/* binding */ WSOL_RESERVE)\\n/* harmony export */ });\\n/* harmony import */ var _solana_web3_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @solana/web3.js */ \\\"./node_modules/@solana/web3.js/lib/index.browser.esm.js\\\");\\n\\nconst FLASH_LOAN_ID = new _solana_web3_js__WEBPACK_IMPORTED_MODULE_0__.PublicKey('F1aShdFVv12jar3oM2fi6SDqbefSnnCVRzaxbPH3you7');\\nconst WSOL_RESERVE = new _solana_web3_js__WEBPACK_IMPORTED_MODULE_0__.PublicKey('EY9dLpeVro64JBTFUSNfo6Vu1r1R1MJVgTbDFtqFRKBD');\\nconst USDC_RESERVE = new _solana_web3_js__WEBPACK_IMPORTED_MODULE_0__.PublicKey('8qow5YNnT9NfvxVsxYMiKV4ddggT5gEe3uLUvjQ6uYaZ');\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./src/utils/const.ts?\");\n\n/***/ }),\n\n/***/ \"./node_modules/uuid/dist/esm-browser/index.js\":\n/*!*****************************************************!*\\\n  !*** ./node_modules/uuid/dist/esm-browser/index.js ***!\n  \\*****************************************************/\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"NIL\\\": () => (/* reexport safe */ _nil_js__WEBPACK_IMPORTED_MODULE_4__[\\\"default\\\"]),\\n/* harmony export */   \\\"parse\\\": () => (/* reexport safe */ _parse_js__WEBPACK_IMPORTED_MODULE_8__[\\\"default\\\"]),\\n/* harmony export */   \\\"stringify\\\": () => (/* reexport safe */ _stringify_js__WEBPACK_IMPORTED_MODULE_7__[\\\"default\\\"]),\\n/* harmony export */   \\\"v1\\\": () => (/* reexport safe */ _v1_js__WEBPACK_IMPORTED_MODULE_0__[\\\"default\\\"]),\\n/* harmony export */   \\\"v3\\\": () => (/* reexport safe */ _v3_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"]),\\n/* harmony export */   \\\"v4\\\": () => (/* reexport safe */ _v4_js__WEBPACK_IMPORTED_MODULE_2__[\\\"default\\\"]),\\n/* harmony export */   \\\"v5\\\": () => (/* reexport safe */ _v5_js__WEBPACK_IMPORTED_MODULE_3__[\\\"default\\\"]),\\n/* harmony export */   \\\"validate\\\": () => (/* reexport safe */ _validate_js__WEBPACK_IMPORTED_MODULE_6__[\\\"default\\\"]),\\n/* harmony export */   \\\"version\\\": () => (/* reexport safe */ _version_js__WEBPACK_IMPORTED_MODULE_5__[\\\"default\\\"])\\n/* harmony export */ });\\n/* harmony import */ var _v1_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./v1.js */ \\\"./node_modules/uuid/dist/esm-browser/v1.js\\\");\\n/* harmony import */ var _v3_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./v3.js */ \\\"./node_modules/uuid/dist/esm-browser/v3.js\\\");\\n/* harmony import */ var _v4_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./v4.js */ \\\"./node_modules/uuid/dist/esm-browser/v4.js\\\");\\n/* harmony import */ var _v5_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./v5.js */ \\\"./node_modules/uuid/dist/esm-browser/v5.js\\\");\\n/* harmony import */ var _nil_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./nil.js */ \\\"./node_modules/uuid/dist/esm-browser/nil.js\\\");\\n/* harmony import */ var _version_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./version.js */ \\\"./node_modules/uuid/dist/esm-browser/version.js\\\");\\n/* harmony import */ var _validate_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./validate.js */ \\\"./node_modules/uuid/dist/esm-browser/validate.js\\\");\\n/* harmony import */ var _stringify_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./stringify.js */ \\\"./node_modules/uuid/dist/esm-browser/stringify.js\\\");\\n/* harmony import */ var _parse_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./parse.js */ \\\"./node_modules/uuid/dist/esm-browser/parse.js\\\");\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/uuid/dist/esm-browser/index.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/uuid/dist/esm-browser/md5.js\":\n/*!***************************************************!*\\\n  !*** ./node_modules/uuid/dist/esm-browser/md5.js ***!\n  \\***************************************************/\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"default\\\": () => (__WEBPACK_DEFAULT_EXPORT__)\\n/* harmony export */ });\\n/*\\n * Browser-compatible JavaScript MD5\\n *\\n * Modification of JavaScript MD5\\n * https://github.com/blueimp/JavaScript-MD5\\n *\\n * Copyright 2011, Sebastian Tschan\\n * https://blueimp.net\\n *\\n * Licensed under the MIT license:\\n * https://opensource.org/licenses/MIT\\n *\\n * Based on\\n * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message\\n * Digest Algorithm, as defined in RFC 1321.\\n * Version 2.2 Copyright (C) Paul Johnston 1999 - 2009\\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\\n * Distributed under the BSD License\\n * See http://pajhome.org.uk/crypt/md5 for more info.\\n */\\nfunction md5(bytes) {\\n  if (typeof bytes === 'string') {\\n    var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape\\n\\n    bytes = new Uint8Array(msg.length);\\n\\n    for (var i = 0; i < msg.length; ++i) {\\n      bytes[i] = msg.charCodeAt(i);\\n    }\\n  }\\n\\n  return md5ToHexEncodedArray(wordsToMd5(bytesToWords(bytes), bytes.length * 8));\\n}\\n/*\\n * Convert an array of little-endian words to an array of bytes\\n */\\n\\n\\nfunction md5ToHexEncodedArray(input) {\\n  var output = [];\\n  var length32 = input.length * 32;\\n  var hexTab = '0123456789abcdef';\\n\\n  for (var i = 0; i < length32; i += 8) {\\n    var x = input[i >> 5] >>> i % 32 & 0xff;\\n    var hex = parseInt(hexTab.charAt(x >>> 4 & 0x0f) + hexTab.charAt(x & 0x0f), 16);\\n    output.push(hex);\\n  }\\n\\n  return output;\\n}\\n/**\\n * Calculate output length with padding and bit length\\n */\\n\\n\\nfunction getOutputLength(inputLength8) {\\n  return (inputLength8 + 64 >>> 9 << 4) + 14 + 1;\\n}\\n/*\\n * Calculate the MD5 of an array of little-endian words, and a bit length.\\n */\\n\\n\\nfunction wordsToMd5(x, len) {\\n  /* append padding */\\n  x[len >> 5] |= 0x80 << len % 32;\\n  x[getOutputLength(len) - 1] = len;\\n  var a = 1732584193;\\n  var b = -271733879;\\n  var c = -1732584194;\\n  var d = 271733878;\\n\\n  for (var i = 0; i < x.length; i += 16) {\\n    var olda = a;\\n    var oldb = b;\\n    var oldc = c;\\n    var oldd = d;\\n    a = md5ff(a, b, c, d, x[i], 7, -680876936);\\n    d = md5ff(d, a, b, c, x[i + 1], 12, -389564586);\\n    c = md5ff(c, d, a, b, x[i + 2], 17, 606105819);\\n    b = md5ff(b, c, d, a, x[i + 3], 22, -1044525330);\\n    a = md5ff(a, b, c, d, x[i + 4], 7, -176418897);\\n    d = md5ff(d, a, b, c, x[i + 5], 12, 1200080426);\\n    c = md5ff(c, d, a, b, x[i + 6], 17, -1473231341);\\n    b = md5ff(b, c, d, a, x[i + 7], 22, -45705983);\\n    a = md5ff(a, b, c, d, x[i + 8], 7, 1770035416);\\n    d = md5ff(d, a, b, c, x[i + 9], 12, -1958414417);\\n    c = md5ff(c, d, a, b, x[i + 10], 17, -42063);\\n    b = md5ff(b, c, d, a, x[i + 11], 22, -1990404162);\\n    a = md5ff(a, b, c, d, x[i + 12], 7, 1804603682);\\n    d = md5ff(d, a, b, c, x[i + 13], 12, -40341101);\\n    c = md5ff(c, d, a, b, x[i + 14], 17, -1502002290);\\n    b = md5ff(b, c, d, a, x[i + 15], 22, 1236535329);\\n    a = md5gg(a, b, c, d, x[i + 1], 5, -165796510);\\n    d = md5gg(d, a, b, c, x[i + 6], 9, -1069501632);\\n    c = md5gg(c, d, a, b, x[i + 11], 14, 643717713);\\n    b = md5gg(b, c, d, a, x[i], 20, -373897302);\\n    a = md5gg(a, b, c, d, x[i + 5], 5, -701558691);\\n    d = md5gg(d, a, b, c, x[i + 10], 9, 38016083);\\n    c = md5gg(c, d, a, b, x[i + 15], 14, -660478335);\\n    b = md5gg(b, c, d, a, x[i + 4], 20, -405537848);\\n    a = md5gg(a, b, c, d, x[i + 9], 5, 568446438);\\n    d = md5gg(d, a, b, c, x[i + 14], 9, -1019803690);\\n    c = md5gg(c, d, a, b, x[i + 3], 14, -187363961);\\n    b = md5gg(b, c, d, a, x[i + 8], 20, 1163531501);\\n    a = md5gg(a, b, c, d, x[i + 13], 5, -1444681467);\\n    d = md5gg(d, a, b, c, x[i + 2], 9, -51403784);\\n    c = md5gg(c, d, a, b, x[i + 7], 14, 1735328473);\\n    b = md5gg(b, c, d, a, x[i + 12], 20, -1926607734);\\n    a = md5hh(a, b, c, d, x[i + 5], 4, -378558);\\n    d = md5hh(d, a, b, c, x[i + 8], 11, -2022574463);\\n    c = md5hh(c, d, a, b, x[i + 11], 16, 1839030562);\\n    b = md5hh(b, c, d, a, x[i + 14], 23, -35309556);\\n    a = md5hh(a, b, c, d, x[i + 1], 4, -1530992060);\\n    d = md5hh(d, a, b, c, x[i + 4], 11, 1272893353);\\n    c = md5hh(c, d, a, b, x[i + 7], 16, -155497632);\\n    b = md5hh(b, c, d, a, x[i + 10], 23, -1094730640);\\n    a = md5hh(a, b, c, d, x[i + 13], 4, 681279174);\\n    d = md5hh(d, a, b, c, x[i], 11, -358537222);\\n    c = md5hh(c, d, a, b, x[i + 3], 16, -722521979);\\n    b = md5hh(b, c, d, a, x[i + 6], 23, 76029189);\\n    a = md5hh(a, b, c, d, x[i + 9], 4, -640364487);\\n    d = md5hh(d, a, b, c, x[i + 12], 11, -421815835);\\n    c = md5hh(c, d, a, b, x[i + 15], 16, 530742520);\\n    b = md5hh(b, c, d, a, x[i + 2], 23, -995338651);\\n    a = md5ii(a, b, c, d, x[i], 6, -198630844);\\n    d = md5ii(d, a, b, c, x[i + 7], 10, 1126891415);\\n    c = md5ii(c, d, a, b, x[i + 14], 15, -1416354905);\\n    b = md5ii(b, c, d, a, x[i + 5], 21, -57434055);\\n    a = md5ii(a, b, c, d, x[i + 12], 6, 1700485571);\\n    d = md5ii(d, a, b, c, x[i + 3], 10, -1894986606);\\n    c = md5ii(c, d, a, b, x[i + 10], 15, -1051523);\\n    b = md5ii(b, c, d, a, x[i + 1], 21, -2054922799);\\n    a = md5ii(a, b, c, d, x[i + 8], 6, 1873313359);\\n    d = md5ii(d, a, b, c, x[i + 15], 10, -30611744);\\n    c = md5ii(c, d, a, b, x[i + 6], 15, -1560198380);\\n    b = md5ii(b, c, d, a, x[i + 13], 21, 1309151649);\\n    a = md5ii(a, b, c, d, x[i + 4], 6, -145523070);\\n    d = md5ii(d, a, b, c, x[i + 11], 10, -1120210379);\\n    c = md5ii(c, d, a, b, x[i + 2], 15, 718787259);\\n    b = md5ii(b, c, d, a, x[i + 9], 21, -343485551);\\n    a = safeAdd(a, olda);\\n    b = safeAdd(b, oldb);\\n    c = safeAdd(c, oldc);\\n    d = safeAdd(d, oldd);\\n  }\\n\\n  return [a, b, c, d];\\n}\\n/*\\n * Convert an array bytes to an array of little-endian words\\n * Characters >255 have their high-byte silently ignored.\\n */\\n\\n\\nfunction bytesToWords(input) {\\n  if (input.length === 0) {\\n    return [];\\n  }\\n\\n  var length8 = input.length * 8;\\n  var output = new Uint32Array(getOutputLength(length8));\\n\\n  for (var i = 0; i < length8; i += 8) {\\n    output[i >> 5] |= (input[i / 8] & 0xff) << i % 32;\\n  }\\n\\n  return output;\\n}\\n/*\\n * Add integers, wrapping at 2^32. This uses 16-bit operations internally\\n * to work around bugs in some JS interpreters.\\n */\\n\\n\\nfunction safeAdd(x, y) {\\n  var lsw = (x & 0xffff) + (y & 0xffff);\\n  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);\\n  return msw << 16 | lsw & 0xffff;\\n}\\n/*\\n * Bitwise rotate a 32-bit number to the left.\\n */\\n\\n\\nfunction bitRotateLeft(num, cnt) {\\n  return num << cnt | num >>> 32 - cnt;\\n}\\n/*\\n * These functions implement the four basic operations the algorithm uses.\\n */\\n\\n\\nfunction md5cmn(q, a, b, x, s, t) {\\n  return safeAdd(bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x, t)), s), b);\\n}\\n\\nfunction md5ff(a, b, c, d, x, s, t) {\\n  return md5cmn(b & c | ~b & d, a, b, x, s, t);\\n}\\n\\nfunction md5gg(a, b, c, d, x, s, t) {\\n  return md5cmn(b & d | c & ~d, a, b, x, s, t);\\n}\\n\\nfunction md5hh(a, b, c, d, x, s, t) {\\n  return md5cmn(b ^ c ^ d, a, b, x, s, t);\\n}\\n\\nfunction md5ii(a, b, c, d, x, s, t) {\\n  return md5cmn(c ^ (b | ~d), a, b, x, s, t);\\n}\\n\\n/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (md5);\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/uuid/dist/esm-browser/md5.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/uuid/dist/esm-browser/nil.js\":\n/*!***************************************************!*\\\n  !*** ./node_modules/uuid/dist/esm-browser/nil.js ***!\n  \\***************************************************/\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"default\\\": () => (__WEBPACK_DEFAULT_EXPORT__)\\n/* harmony export */ });\\n/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ('00000000-0000-0000-0000-000000000000');\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/uuid/dist/esm-browser/nil.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/uuid/dist/esm-browser/parse.js\":\n/*!*****************************************************!*\\\n  !*** ./node_modules/uuid/dist/esm-browser/parse.js ***!\n  \\*****************************************************/\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"default\\\": () => (__WEBPACK_DEFAULT_EXPORT__)\\n/* harmony export */ });\\n/* harmony import */ var _validate_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./validate.js */ \\\"./node_modules/uuid/dist/esm-browser/validate.js\\\");\\n\\n\\nfunction parse(uuid) {\\n  if (!(0,_validate_js__WEBPACK_IMPORTED_MODULE_0__[\\\"default\\\"])(uuid)) {\\n    throw TypeError('Invalid UUID');\\n  }\\n\\n  var v;\\n  var arr = new Uint8Array(16); // Parse ########-....-....-....-............\\n\\n  arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;\\n  arr[1] = v >>> 16 & 0xff;\\n  arr[2] = v >>> 8 & 0xff;\\n  arr[3] = v & 0xff; // Parse ........-####-....-....-............\\n\\n  arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8;\\n  arr[5] = v & 0xff; // Parse ........-....-####-....-............\\n\\n  arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8;\\n  arr[7] = v & 0xff; // Parse ........-....-....-####-............\\n\\n  arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8;\\n  arr[9] = v & 0xff; // Parse ........-....-....-....-############\\n  // (Use \\\"/\\\" to avoid 32-bit truncation when bit-shifting high-order bytes)\\n\\n  arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff;\\n  arr[11] = v / 0x100000000 & 0xff;\\n  arr[12] = v >>> 24 & 0xff;\\n  arr[13] = v >>> 16 & 0xff;\\n  arr[14] = v >>> 8 & 0xff;\\n  arr[15] = v & 0xff;\\n  return arr;\\n}\\n\\n/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (parse);\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/uuid/dist/esm-browser/parse.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/uuid/dist/esm-browser/regex.js\":\n/*!*****************************************************!*\\\n  !*** ./node_modules/uuid/dist/esm-browser/regex.js ***!\n  \\*****************************************************/\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"default\\\": () => (__WEBPACK_DEFAULT_EXPORT__)\\n/* harmony export */ });\\n/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i);\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/uuid/dist/esm-browser/regex.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/uuid/dist/esm-browser/rng.js\":\n/*!***************************************************!*\\\n  !*** ./node_modules/uuid/dist/esm-browser/rng.js ***!\n  \\***************************************************/\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"default\\\": () => (/* binding */ rng)\\n/* harmony export */ });\\n// Unique ID creation requires a high quality random # generator. In the browser we therefore\\n// require the crypto API and do not support built-in fallback to lower quality random number\\n// generators (like Math.random()).\\nvar getRandomValues;\\nvar rnds8 = new Uint8Array(16);\\nfunction rng() {\\n  // lazy load so that environments that need to polyfill have a chance to do so\\n  if (!getRandomValues) {\\n    // getRandomValues needs to be invoked in a context where \\\"this\\\" is a Crypto implementation. Also,\\n    // find the complete implementation of crypto (msCrypto) on IE11.\\n    getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto !== 'undefined' && typeof msCrypto.getRandomValues === 'function' && msCrypto.getRandomValues.bind(msCrypto);\\n\\n    if (!getRandomValues) {\\n      throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');\\n    }\\n  }\\n\\n  return getRandomValues(rnds8);\\n}\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/uuid/dist/esm-browser/rng.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/uuid/dist/esm-browser/sha1.js\":\n/*!****************************************************!*\\\n  !*** ./node_modules/uuid/dist/esm-browser/sha1.js ***!\n  \\****************************************************/\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"default\\\": () => (__WEBPACK_DEFAULT_EXPORT__)\\n/* harmony export */ });\\n// Adapted from Chris Veness' SHA1 code at\\n// http://www.movable-type.co.uk/scripts/sha1.html\\nfunction f(s, x, y, z) {\\n  switch (s) {\\n    case 0:\\n      return x & y ^ ~x & z;\\n\\n    case 1:\\n      return x ^ y ^ z;\\n\\n    case 2:\\n      return x & y ^ x & z ^ y & z;\\n\\n    case 3:\\n      return x ^ y ^ z;\\n  }\\n}\\n\\nfunction ROTL(x, n) {\\n  return x << n | x >>> 32 - n;\\n}\\n\\nfunction sha1(bytes) {\\n  var K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6];\\n  var H = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0];\\n\\n  if (typeof bytes === 'string') {\\n    var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape\\n\\n    bytes = [];\\n\\n    for (var i = 0; i < msg.length; ++i) {\\n      bytes.push(msg.charCodeAt(i));\\n    }\\n  } else if (!Array.isArray(bytes)) {\\n    // Convert Array-like to Array\\n    bytes = Array.prototype.slice.call(bytes);\\n  }\\n\\n  bytes.push(0x80);\\n  var l = bytes.length / 4 + 2;\\n  var N = Math.ceil(l / 16);\\n  var M = new Array(N);\\n\\n  for (var _i = 0; _i < N; ++_i) {\\n    var arr = new Uint32Array(16);\\n\\n    for (var j = 0; j < 16; ++j) {\\n      arr[j] = bytes[_i * 64 + j * 4] << 24 | bytes[_i * 64 + j * 4 + 1] << 16 | bytes[_i * 64 + j * 4 + 2] << 8 | bytes[_i * 64 + j * 4 + 3];\\n    }\\n\\n    M[_i] = arr;\\n  }\\n\\n  M[N - 1][14] = (bytes.length - 1) * 8 / Math.pow(2, 32);\\n  M[N - 1][14] = Math.floor(M[N - 1][14]);\\n  M[N - 1][15] = (bytes.length - 1) * 8 & 0xffffffff;\\n\\n  for (var _i2 = 0; _i2 < N; ++_i2) {\\n    var W = new Uint32Array(80);\\n\\n    for (var t = 0; t < 16; ++t) {\\n      W[t] = M[_i2][t];\\n    }\\n\\n    for (var _t = 16; _t < 80; ++_t) {\\n      W[_t] = ROTL(W[_t - 3] ^ W[_t - 8] ^ W[_t - 14] ^ W[_t - 16], 1);\\n    }\\n\\n    var a = H[0];\\n    var b = H[1];\\n    var c = H[2];\\n    var d = H[3];\\n    var e = H[4];\\n\\n    for (var _t2 = 0; _t2 < 80; ++_t2) {\\n      var s = Math.floor(_t2 / 20);\\n      var T = ROTL(a, 5) + f(s, b, c, d) + e + K[s] + W[_t2] >>> 0;\\n      e = d;\\n      d = c;\\n      c = ROTL(b, 30) >>> 0;\\n      b = a;\\n      a = T;\\n    }\\n\\n    H[0] = H[0] + a >>> 0;\\n    H[1] = H[1] + b >>> 0;\\n    H[2] = H[2] + c >>> 0;\\n    H[3] = H[3] + d >>> 0;\\n    H[4] = H[4] + e >>> 0;\\n  }\\n\\n  return [H[0] >> 24 & 0xff, H[0] >> 16 & 0xff, H[0] >> 8 & 0xff, H[0] & 0xff, H[1] >> 24 & 0xff, H[1] >> 16 & 0xff, H[1] >> 8 & 0xff, H[1] & 0xff, H[2] >> 24 & 0xff, H[2] >> 16 & 0xff, H[2] >> 8 & 0xff, H[2] & 0xff, H[3] >> 24 & 0xff, H[3] >> 16 & 0xff, H[3] >> 8 & 0xff, H[3] & 0xff, H[4] >> 24 & 0xff, H[4] >> 16 & 0xff, H[4] >> 8 & 0xff, H[4] & 0xff];\\n}\\n\\n/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (sha1);\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/uuid/dist/esm-browser/sha1.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/uuid/dist/esm-browser/stringify.js\":\n/*!*********************************************************!*\\\n  !*** ./node_modules/uuid/dist/esm-browser/stringify.js ***!\n  \\*********************************************************/\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"default\\\": () => (__WEBPACK_DEFAULT_EXPORT__)\\n/* harmony export */ });\\n/* harmony import */ var _validate_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./validate.js */ \\\"./node_modules/uuid/dist/esm-browser/validate.js\\\");\\n\\n/**\\n * Convert array of 16 byte values to UUID string format of the form:\\n * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX\\n */\\n\\nvar byteToHex = [];\\n\\nfor (var i = 0; i < 256; ++i) {\\n  byteToHex.push((i + 0x100).toString(16).substr(1));\\n}\\n\\nfunction stringify(arr) {\\n  var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\\n  // Note: Be careful editing this code!  It's been tuned for performance\\n  // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434\\n  var uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID.  If this throws, it's likely due to one\\n  // of the following:\\n  // - One or more input array values don't map to a hex octet (leading to\\n  // \\\"undefined\\\" in the uuid)\\n  // - Invalid input values for the RFC `version` or `variant` fields\\n\\n  if (!(0,_validate_js__WEBPACK_IMPORTED_MODULE_0__[\\\"default\\\"])(uuid)) {\\n    throw TypeError('Stringified UUID is invalid');\\n  }\\n\\n  return uuid;\\n}\\n\\n/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (stringify);\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/uuid/dist/esm-browser/stringify.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/uuid/dist/esm-browser/v1.js\":\n/*!**************************************************!*\\\n  !*** ./node_modules/uuid/dist/esm-browser/v1.js ***!\n  \\**************************************************/\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"default\\\": () => (__WEBPACK_DEFAULT_EXPORT__)\\n/* harmony export */ });\\n/* harmony import */ var _rng_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./rng.js */ \\\"./node_modules/uuid/dist/esm-browser/rng.js\\\");\\n/* harmony import */ var _stringify_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./stringify.js */ \\\"./node_modules/uuid/dist/esm-browser/stringify.js\\\");\\n\\n // **`v1()` - Generate time-based UUID**\\n//\\n// Inspired by https://github.com/LiosK/UUID.js\\n// and http://docs.python.org/library/uuid.html\\n\\nvar _nodeId;\\n\\nvar _clockseq; // Previous uuid creation time\\n\\n\\nvar _lastMSecs = 0;\\nvar _lastNSecs = 0; // See https://github.com/uuidjs/uuid for API details\\n\\nfunction v1(options, buf, offset) {\\n  var i = buf && offset || 0;\\n  var b = buf || new Array(16);\\n  options = options || {};\\n  var node = options.node || _nodeId;\\n  var clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq; // node and clockseq need to be initialized to random values if they're not\\n  // specified.  We do this lazily to minimize issues related to insufficient\\n  // system entropy.  See #189\\n\\n  if (node == null || clockseq == null) {\\n    var seedBytes = options.random || (options.rng || _rng_js__WEBPACK_IMPORTED_MODULE_0__[\\\"default\\\"])();\\n\\n    if (node == null) {\\n      // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)\\n      node = _nodeId = [seedBytes[0] | 0x01, seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]];\\n    }\\n\\n    if (clockseq == null) {\\n      // Per 4.2.2, randomize (14 bit) clockseq\\n      clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff;\\n    }\\n  } // UUID timestamps are 100 nano-second units since the Gregorian epoch,\\n  // (1582-10-15 00:00).  JSNumbers aren't precise enough for this, so\\n  // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs'\\n  // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.\\n\\n\\n  var msecs = options.msecs !== undefined ? options.msecs : Date.now(); // Per 4.2.1.2, use count of uuid's generated during the current clock\\n  // cycle to simulate higher resolution clock\\n\\n  var nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1; // Time since last uuid creation (in msecs)\\n\\n  var dt = msecs - _lastMSecs + (nsecs - _lastNSecs) / 10000; // Per 4.2.1.2, Bump clockseq on clock regression\\n\\n  if (dt < 0 && options.clockseq === undefined) {\\n    clockseq = clockseq + 1 & 0x3fff;\\n  } // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new\\n  // time interval\\n\\n\\n  if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) {\\n    nsecs = 0;\\n  } // Per 4.2.1.2 Throw error if too many uuids are requested\\n\\n\\n  if (nsecs >= 10000) {\\n    throw new Error(\\\"uuid.v1(): Can't create more than 10M uuids/sec\\\");\\n  }\\n\\n  _lastMSecs = msecs;\\n  _lastNSecs = nsecs;\\n  _clockseq = clockseq; // Per 4.1.4 - Convert from unix epoch to Gregorian epoch\\n\\n  msecs += 12219292800000; // `time_low`\\n\\n  var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;\\n  b[i++] = tl >>> 24 & 0xff;\\n  b[i++] = tl >>> 16 & 0xff;\\n  b[i++] = tl >>> 8 & 0xff;\\n  b[i++] = tl & 0xff; // `time_mid`\\n\\n  var tmh = msecs / 0x100000000 * 10000 & 0xfffffff;\\n  b[i++] = tmh >>> 8 & 0xff;\\n  b[i++] = tmh & 0xff; // `time_high_and_version`\\n\\n  b[i++] = tmh >>> 24 & 0xf | 0x10; // include version\\n\\n  b[i++] = tmh >>> 16 & 0xff; // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)\\n\\n  b[i++] = clockseq >>> 8 | 0x80; // `clock_seq_low`\\n\\n  b[i++] = clockseq & 0xff; // `node`\\n\\n  for (var n = 0; n < 6; ++n) {\\n    b[i + n] = node[n];\\n  }\\n\\n  return buf || (0,_stringify_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"])(b);\\n}\\n\\n/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (v1);\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/uuid/dist/esm-browser/v1.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/uuid/dist/esm-browser/v3.js\":\n/*!**************************************************!*\\\n  !*** ./node_modules/uuid/dist/esm-browser/v3.js ***!\n  \\**************************************************/\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"default\\\": () => (__WEBPACK_DEFAULT_EXPORT__)\\n/* harmony export */ });\\n/* harmony import */ var _v35_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./v35.js */ \\\"./node_modules/uuid/dist/esm-browser/v35.js\\\");\\n/* harmony import */ var _md5_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./md5.js */ \\\"./node_modules/uuid/dist/esm-browser/md5.js\\\");\\n\\n\\nvar v3 = (0,_v35_js__WEBPACK_IMPORTED_MODULE_0__[\\\"default\\\"])('v3', 0x30, _md5_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"]);\\n/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (v3);\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/uuid/dist/esm-browser/v3.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/uuid/dist/esm-browser/v35.js\":\n/*!***************************************************!*\\\n  !*** ./node_modules/uuid/dist/esm-browser/v35.js ***!\n  \\***************************************************/\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"DNS\\\": () => (/* binding */ DNS),\\n/* harmony export */   \\\"URL\\\": () => (/* binding */ URL),\\n/* harmony export */   \\\"default\\\": () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)\\n/* harmony export */ });\\n/* harmony import */ var _stringify_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./stringify.js */ \\\"./node_modules/uuid/dist/esm-browser/stringify.js\\\");\\n/* harmony import */ var _parse_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./parse.js */ \\\"./node_modules/uuid/dist/esm-browser/parse.js\\\");\\n\\n\\n\\nfunction stringToBytes(str) {\\n  str = unescape(encodeURIComponent(str)); // UTF8 escape\\n\\n  var bytes = [];\\n\\n  for (var i = 0; i < str.length; ++i) {\\n    bytes.push(str.charCodeAt(i));\\n  }\\n\\n  return bytes;\\n}\\n\\nvar DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';\\nvar URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';\\n/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(name, version, hashfunc) {\\n  function generateUUID(value, namespace, buf, offset) {\\n    if (typeof value === 'string') {\\n      value = stringToBytes(value);\\n    }\\n\\n    if (typeof namespace === 'string') {\\n      namespace = (0,_parse_js__WEBPACK_IMPORTED_MODULE_0__[\\\"default\\\"])(namespace);\\n    }\\n\\n    if (namespace.length !== 16) {\\n      throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)');\\n    } // Compute hash of namespace and value, Per 4.3\\n    // Future: Use spread syntax when supported on all platforms, e.g. `bytes =\\n    // hashfunc([...namespace, ... value])`\\n\\n\\n    var bytes = new Uint8Array(16 + value.length);\\n    bytes.set(namespace);\\n    bytes.set(value, namespace.length);\\n    bytes = hashfunc(bytes);\\n    bytes[6] = bytes[6] & 0x0f | version;\\n    bytes[8] = bytes[8] & 0x3f | 0x80;\\n\\n    if (buf) {\\n      offset = offset || 0;\\n\\n      for (var i = 0; i < 16; ++i) {\\n        buf[offset + i] = bytes[i];\\n      }\\n\\n      return buf;\\n    }\\n\\n    return (0,_stringify_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"])(bytes);\\n  } // Function#name is not settable on some platforms (#270)\\n\\n\\n  try {\\n    generateUUID.name = name; // eslint-disable-next-line no-empty\\n  } catch (err) {} // For CommonJS default export support\\n\\n\\n  generateUUID.DNS = DNS;\\n  generateUUID.URL = URL;\\n  return generateUUID;\\n}\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/uuid/dist/esm-browser/v35.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/uuid/dist/esm-browser/v4.js\":\n/*!**************************************************!*\\\n  !*** ./node_modules/uuid/dist/esm-browser/v4.js ***!\n  \\**************************************************/\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"default\\\": () => (__WEBPACK_DEFAULT_EXPORT__)\\n/* harmony export */ });\\n/* harmony import */ var _rng_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./rng.js */ \\\"./node_modules/uuid/dist/esm-browser/rng.js\\\");\\n/* harmony import */ var _stringify_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./stringify.js */ \\\"./node_modules/uuid/dist/esm-browser/stringify.js\\\");\\n\\n\\n\\nfunction v4(options, buf, offset) {\\n  options = options || {};\\n  var rnds = options.random || (options.rng || _rng_js__WEBPACK_IMPORTED_MODULE_0__[\\\"default\\\"])(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`\\n\\n  rnds[6] = rnds[6] & 0x0f | 0x40;\\n  rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided\\n\\n  if (buf) {\\n    offset = offset || 0;\\n\\n    for (var i = 0; i < 16; ++i) {\\n      buf[offset + i] = rnds[i];\\n    }\\n\\n    return buf;\\n  }\\n\\n  return (0,_stringify_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"])(rnds);\\n}\\n\\n/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (v4);\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/uuid/dist/esm-browser/v4.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/uuid/dist/esm-browser/v5.js\":\n/*!**************************************************!*\\\n  !*** ./node_modules/uuid/dist/esm-browser/v5.js ***!\n  \\**************************************************/\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"default\\\": () => (__WEBPACK_DEFAULT_EXPORT__)\\n/* harmony export */ });\\n/* harmony import */ var _v35_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./v35.js */ \\\"./node_modules/uuid/dist/esm-browser/v35.js\\\");\\n/* harmony import */ var _sha1_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./sha1.js */ \\\"./node_modules/uuid/dist/esm-browser/sha1.js\\\");\\n\\n\\nvar v5 = (0,_v35_js__WEBPACK_IMPORTED_MODULE_0__[\\\"default\\\"])('v5', 0x50, _sha1_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"]);\\n/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (v5);\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/uuid/dist/esm-browser/v5.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/uuid/dist/esm-browser/validate.js\":\n/*!********************************************************!*\\\n  !*** ./node_modules/uuid/dist/esm-browser/validate.js ***!\n  \\********************************************************/\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"default\\\": () => (__WEBPACK_DEFAULT_EXPORT__)\\n/* harmony export */ });\\n/* harmony import */ var _regex_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./regex.js */ \\\"./node_modules/uuid/dist/esm-browser/regex.js\\\");\\n\\n\\nfunction validate(uuid) {\\n  return typeof uuid === 'string' && _regex_js__WEBPACK_IMPORTED_MODULE_0__[\\\"default\\\"].test(uuid);\\n}\\n\\n/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (validate);\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/uuid/dist/esm-browser/validate.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/uuid/dist/esm-browser/version.js\":\n/*!*******************************************************!*\\\n  !*** ./node_modules/uuid/dist/esm-browser/version.js ***!\n  \\*******************************************************/\n/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"default\\\": () => (__WEBPACK_DEFAULT_EXPORT__)\\n/* harmony export */ });\\n/* harmony import */ var _validate_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./validate.js */ \\\"./node_modules/uuid/dist/esm-browser/validate.js\\\");\\n\\n\\nfunction version(uuid) {\\n  if (!(0,_validate_js__WEBPACK_IMPORTED_MODULE_0__[\\\"default\\\"])(uuid)) {\\n    throw TypeError('Invalid UUID');\\n  }\\n\\n  return parseInt(uuid.substr(14, 1), 16);\\n}\\n\\n/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (version);\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/uuid/dist/esm-browser/version.js?\");\n\n/***/ }),\n\n/***/ \"?51ea\":\n/*!************************!*\\\n  !*** crypto (ignored) ***!\n  \\************************/\n/***/ (() => {\n\neval(\"/* (ignored) */\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/crypto_(ignored)?\");\n\n/***/ }),\n\n/***/ \"?ce41\":\n/*!************************!*\\\n  !*** crypto (ignored) ***!\n  \\************************/\n/***/ (() => {\n\neval(\"/* (ignored) */\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/crypto_(ignored)?\");\n\n/***/ }),\n\n/***/ \"?8131\":\n/*!************************!*\\\n  !*** buffer (ignored) ***!\n  \\************************/\n/***/ (() => {\n\neval(\"/* (ignored) */\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/buffer_(ignored)?\");\n\n/***/ }),\n\n/***/ \"./node_modules/@babel/runtime/helpers/assertThisInitialized.js\":\n/*!**********************************************************************!*\\\n  !*** ./node_modules/@babel/runtime/helpers/assertThisInitialized.js ***!\n  \\**********************************************************************/\n/***/ ((module) => {\n\neval(\"function _assertThisInitialized(self) {\\n  if (self === void 0) {\\n    throw new ReferenceError(\\\"this hasn't been initialised - super() hasn't been called\\\");\\n  }\\n  return self;\\n}\\nmodule.exports = _assertThisInitialized, module.exports.__esModule = true, module.exports[\\\"default\\\"] = module.exports;\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@babel/runtime/helpers/assertThisInitialized.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/@babel/runtime/helpers/asyncToGenerator.js\":\n/*!*****************************************************************!*\\\n  !*** ./node_modules/@babel/runtime/helpers/asyncToGenerator.js ***!\n  \\*****************************************************************/\n/***/ ((module) => {\n\neval(\"function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\\n  try {\\n    var info = gen[key](arg);\\n    var value = info.value;\\n  } catch (error) {\\n    reject(error);\\n    return;\\n  }\\n  if (info.done) {\\n    resolve(value);\\n  } else {\\n    Promise.resolve(value).then(_next, _throw);\\n  }\\n}\\nfunction _asyncToGenerator(fn) {\\n  return function () {\\n    var self = this,\\n      args = arguments;\\n    return new Promise(function (resolve, reject) {\\n      var gen = fn.apply(self, args);\\n      function _next(value) {\\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \\\"next\\\", value);\\n      }\\n      function _throw(err) {\\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \\\"throw\\\", err);\\n      }\\n      _next(undefined);\\n    });\\n  };\\n}\\nmodule.exports = _asyncToGenerator, module.exports.__esModule = true, module.exports[\\\"default\\\"] = module.exports;\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@babel/runtime/helpers/asyncToGenerator.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/@babel/runtime/helpers/classCallCheck.js\":\n/*!***************************************************************!*\\\n  !*** ./node_modules/@babel/runtime/helpers/classCallCheck.js ***!\n  \\***************************************************************/\n/***/ ((module) => {\n\neval(\"function _classCallCheck(instance, Constructor) {\\n  if (!(instance instanceof Constructor)) {\\n    throw new TypeError(\\\"Cannot call a class as a function\\\");\\n  }\\n}\\nmodule.exports = _classCallCheck, module.exports.__esModule = true, module.exports[\\\"default\\\"] = module.exports;\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@babel/runtime/helpers/classCallCheck.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/@babel/runtime/helpers/createClass.js\":\n/*!************************************************************!*\\\n  !*** ./node_modules/@babel/runtime/helpers/createClass.js ***!\n  \\************************************************************/\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\neval(\"var toPropertyKey = __webpack_require__(/*! ./toPropertyKey.js */ \\\"./node_modules/@babel/runtime/helpers/toPropertyKey.js\\\");\\nfunction _defineProperties(target, props) {\\n  for (var i = 0; i < props.length; i++) {\\n    var descriptor = props[i];\\n    descriptor.enumerable = descriptor.enumerable || false;\\n    descriptor.configurable = true;\\n    if (\\\"value\\\" in descriptor) descriptor.writable = true;\\n    Object.defineProperty(target, toPropertyKey(descriptor.key), descriptor);\\n  }\\n}\\nfunction _createClass(Constructor, protoProps, staticProps) {\\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\\n  if (staticProps) _defineProperties(Constructor, staticProps);\\n  Object.defineProperty(Constructor, \\\"prototype\\\", {\\n    writable: false\\n  });\\n  return Constructor;\\n}\\nmodule.exports = _createClass, module.exports.__esModule = true, module.exports[\\\"default\\\"] = module.exports;\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@babel/runtime/helpers/createClass.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/@babel/runtime/helpers/getPrototypeOf.js\":\n/*!***************************************************************!*\\\n  !*** ./node_modules/@babel/runtime/helpers/getPrototypeOf.js ***!\n  \\***************************************************************/\n/***/ ((module) => {\n\neval(\"function _getPrototypeOf(o) {\\n  module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {\\n    return o.__proto__ || Object.getPrototypeOf(o);\\n  }, module.exports.__esModule = true, module.exports[\\\"default\\\"] = module.exports;\\n  return _getPrototypeOf(o);\\n}\\nmodule.exports = _getPrototypeOf, module.exports.__esModule = true, module.exports[\\\"default\\\"] = module.exports;\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@babel/runtime/helpers/getPrototypeOf.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/@babel/runtime/helpers/inherits.js\":\n/*!*********************************************************!*\\\n  !*** ./node_modules/@babel/runtime/helpers/inherits.js ***!\n  \\*********************************************************/\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\neval(\"var setPrototypeOf = __webpack_require__(/*! ./setPrototypeOf.js */ \\\"./node_modules/@babel/runtime/helpers/setPrototypeOf.js\\\");\\nfunction _inherits(subClass, superClass) {\\n  if (typeof superClass !== \\\"function\\\" && superClass !== null) {\\n    throw new TypeError(\\\"Super expression must either be null or a function\\\");\\n  }\\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\\n    constructor: {\\n      value: subClass,\\n      writable: true,\\n      configurable: true\\n    }\\n  });\\n  Object.defineProperty(subClass, \\\"prototype\\\", {\\n    writable: false\\n  });\\n  if (superClass) setPrototypeOf(subClass, superClass);\\n}\\nmodule.exports = _inherits, module.exports.__esModule = true, module.exports[\\\"default\\\"] = module.exports;\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@babel/runtime/helpers/inherits.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/@babel/runtime/helpers/interopRequireDefault.js\":\n/*!**********************************************************************!*\\\n  !*** ./node_modules/@babel/runtime/helpers/interopRequireDefault.js ***!\n  \\**********************************************************************/\n/***/ ((module) => {\n\neval(\"function _interopRequireDefault(obj) {\\n  return obj && obj.__esModule ? obj : {\\n    \\\"default\\\": obj\\n  };\\n}\\nmodule.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports[\\\"default\\\"] = module.exports;\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@babel/runtime/helpers/interopRequireDefault.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/@babel/runtime/helpers/possibleConstructorReturn.js\":\n/*!**************************************************************************!*\\\n  !*** ./node_modules/@babel/runtime/helpers/possibleConstructorReturn.js ***!\n  \\**************************************************************************/\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\neval(\"var _typeof = (__webpack_require__(/*! ./typeof.js */ \\\"./node_modules/@babel/runtime/helpers/typeof.js\\\")[\\\"default\\\"]);\\nvar assertThisInitialized = __webpack_require__(/*! ./assertThisInitialized.js */ \\\"./node_modules/@babel/runtime/helpers/assertThisInitialized.js\\\");\\nfunction _possibleConstructorReturn(self, call) {\\n  if (call && (_typeof(call) === \\\"object\\\" || typeof call === \\\"function\\\")) {\\n    return call;\\n  } else if (call !== void 0) {\\n    throw new TypeError(\\\"Derived constructors may only return object or undefined\\\");\\n  }\\n  return assertThisInitialized(self);\\n}\\nmodule.exports = _possibleConstructorReturn, module.exports.__esModule = true, module.exports[\\\"default\\\"] = module.exports;\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@babel/runtime/helpers/possibleConstructorReturn.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/@babel/runtime/helpers/regeneratorRuntime.js\":\n/*!*******************************************************************!*\\\n  !*** ./node_modules/@babel/runtime/helpers/regeneratorRuntime.js ***!\n  \\*******************************************************************/\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\neval(\"var _typeof = (__webpack_require__(/*! ./typeof.js */ \\\"./node_modules/@babel/runtime/helpers/typeof.js\\\")[\\\"default\\\"]);\\nfunction _regeneratorRuntime() {\\n  \\\"use strict\\\"; /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */\\n  module.exports = _regeneratorRuntime = function _regeneratorRuntime() {\\n    return exports;\\n  }, module.exports.__esModule = true, module.exports[\\\"default\\\"] = module.exports;\\n  var exports = {},\\n    Op = Object.prototype,\\n    hasOwn = Op.hasOwnProperty,\\n    defineProperty = Object.defineProperty || function (obj, key, desc) {\\n      obj[key] = desc.value;\\n    },\\n    $Symbol = \\\"function\\\" == typeof Symbol ? Symbol : {},\\n    iteratorSymbol = $Symbol.iterator || \\\"@@iterator\\\",\\n    asyncIteratorSymbol = $Symbol.asyncIterator || \\\"@@asyncIterator\\\",\\n    toStringTagSymbol = $Symbol.toStringTag || \\\"@@toStringTag\\\";\\n  function define(obj, key, value) {\\n    return Object.defineProperty(obj, key, {\\n      value: value,\\n      enumerable: !0,\\n      configurable: !0,\\n      writable: !0\\n    }), obj[key];\\n  }\\n  try {\\n    define({}, \\\"\\\");\\n  } catch (err) {\\n    define = function define(obj, key, value) {\\n      return obj[key] = value;\\n    };\\n  }\\n  function wrap(innerFn, outerFn, self, tryLocsList) {\\n    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,\\n      generator = Object.create(protoGenerator.prototype),\\n      context = new Context(tryLocsList || []);\\n    return defineProperty(generator, \\\"_invoke\\\", {\\n      value: makeInvokeMethod(innerFn, self, context)\\n    }), generator;\\n  }\\n  function tryCatch(fn, obj, arg) {\\n    try {\\n      return {\\n        type: \\\"normal\\\",\\n        arg: fn.call(obj, arg)\\n      };\\n    } catch (err) {\\n      return {\\n        type: \\\"throw\\\",\\n        arg: err\\n      };\\n    }\\n  }\\n  exports.wrap = wrap;\\n  var ContinueSentinel = {};\\n  function Generator() {}\\n  function GeneratorFunction() {}\\n  function GeneratorFunctionPrototype() {}\\n  var IteratorPrototype = {};\\n  define(IteratorPrototype, iteratorSymbol, function () {\\n    return this;\\n  });\\n  var getProto = Object.getPrototypeOf,\\n    NativeIteratorPrototype = getProto && getProto(getProto(values([])));\\n  NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);\\n  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);\\n  function defineIteratorMethods(prototype) {\\n    [\\\"next\\\", \\\"throw\\\", \\\"return\\\"].forEach(function (method) {\\n      define(prototype, method, function (arg) {\\n        return this._invoke(method, arg);\\n      });\\n    });\\n  }\\n  function AsyncIterator(generator, PromiseImpl) {\\n    function invoke(method, arg, resolve, reject) {\\n      var record = tryCatch(generator[method], generator, arg);\\n      if (\\\"throw\\\" !== record.type) {\\n        var result = record.arg,\\n          value = result.value;\\n        return value && \\\"object\\\" == _typeof(value) && hasOwn.call(value, \\\"__await\\\") ? PromiseImpl.resolve(value.__await).then(function (value) {\\n          invoke(\\\"next\\\", value, resolve, reject);\\n        }, function (err) {\\n          invoke(\\\"throw\\\", err, resolve, reject);\\n        }) : PromiseImpl.resolve(value).then(function (unwrapped) {\\n          result.value = unwrapped, resolve(result);\\n        }, function (error) {\\n          return invoke(\\\"throw\\\", error, resolve, reject);\\n        });\\n      }\\n      reject(record.arg);\\n    }\\n    var previousPromise;\\n    defineProperty(this, \\\"_invoke\\\", {\\n      value: function value(method, arg) {\\n        function callInvokeWithMethodAndArg() {\\n          return new PromiseImpl(function (resolve, reject) {\\n            invoke(method, arg, resolve, reject);\\n          });\\n        }\\n        return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();\\n      }\\n    });\\n  }\\n  function makeInvokeMethod(innerFn, self, context) {\\n    var state = \\\"suspendedStart\\\";\\n    return function (method, arg) {\\n      if (\\\"executing\\\" === state) throw new Error(\\\"Generator is already running\\\");\\n      if (\\\"completed\\\" === state) {\\n        if (\\\"throw\\\" === method) throw arg;\\n        return doneResult();\\n      }\\n      for (context.method = method, context.arg = arg;;) {\\n        var delegate = context.delegate;\\n        if (delegate) {\\n          var delegateResult = maybeInvokeDelegate(delegate, context);\\n          if (delegateResult) {\\n            if (delegateResult === ContinueSentinel) continue;\\n            return delegateResult;\\n          }\\n        }\\n        if (\\\"next\\\" === context.method) context.sent = context._sent = context.arg;else if (\\\"throw\\\" === context.method) {\\n          if (\\\"suspendedStart\\\" === state) throw state = \\\"completed\\\", context.arg;\\n          context.dispatchException(context.arg);\\n        } else \\\"return\\\" === context.method && context.abrupt(\\\"return\\\", context.arg);\\n        state = \\\"executing\\\";\\n        var record = tryCatch(innerFn, self, context);\\n        if (\\\"normal\\\" === record.type) {\\n          if (state = context.done ? \\\"completed\\\" : \\\"suspendedYield\\\", record.arg === ContinueSentinel) continue;\\n          return {\\n            value: record.arg,\\n            done: context.done\\n          };\\n        }\\n        \\\"throw\\\" === record.type && (state = \\\"completed\\\", context.method = \\\"throw\\\", context.arg = record.arg);\\n      }\\n    };\\n  }\\n  function maybeInvokeDelegate(delegate, context) {\\n    var methodName = context.method,\\n      method = delegate.iterator[methodName];\\n    if (undefined === method) return context.delegate = null, \\\"throw\\\" === methodName && delegate.iterator[\\\"return\\\"] && (context.method = \\\"return\\\", context.arg = undefined, maybeInvokeDelegate(delegate, context), \\\"throw\\\" === context.method) || \\\"return\\\" !== methodName && (context.method = \\\"throw\\\", context.arg = new TypeError(\\\"The iterator does not provide a '\\\" + methodName + \\\"' method\\\")), ContinueSentinel;\\n    var record = tryCatch(method, delegate.iterator, context.arg);\\n    if (\\\"throw\\\" === record.type) return context.method = \\\"throw\\\", context.arg = record.arg, context.delegate = null, ContinueSentinel;\\n    var info = record.arg;\\n    return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, \\\"return\\\" !== context.method && (context.method = \\\"next\\\", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = \\\"throw\\\", context.arg = new TypeError(\\\"iterator result is not an object\\\"), context.delegate = null, ContinueSentinel);\\n  }\\n  function pushTryEntry(locs) {\\n    var entry = {\\n      tryLoc: locs[0]\\n    };\\n    1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);\\n  }\\n  function resetTryEntry(entry) {\\n    var record = entry.completion || {};\\n    record.type = \\\"normal\\\", delete record.arg, entry.completion = record;\\n  }\\n  function Context(tryLocsList) {\\n    this.tryEntries = [{\\n      tryLoc: \\\"root\\\"\\n    }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);\\n  }\\n  function values(iterable) {\\n    if (iterable) {\\n      var iteratorMethod = iterable[iteratorSymbol];\\n      if (iteratorMethod) return iteratorMethod.call(iterable);\\n      if (\\\"function\\\" == typeof iterable.next) return iterable;\\n      if (!isNaN(iterable.length)) {\\n        var i = -1,\\n          next = function next() {\\n            for (; ++i < iterable.length;) {\\n              if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;\\n            }\\n            return next.value = undefined, next.done = !0, next;\\n          };\\n        return next.next = next;\\n      }\\n    }\\n    return {\\n      next: doneResult\\n    };\\n  }\\n  function doneResult() {\\n    return {\\n      value: undefined,\\n      done: !0\\n    };\\n  }\\n  return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, \\\"constructor\\\", {\\n    value: GeneratorFunctionPrototype,\\n    configurable: !0\\n  }), defineProperty(GeneratorFunctionPrototype, \\\"constructor\\\", {\\n    value: GeneratorFunction,\\n    configurable: !0\\n  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, \\\"GeneratorFunction\\\"), exports.isGeneratorFunction = function (genFun) {\\n    var ctor = \\\"function\\\" == typeof genFun && genFun.constructor;\\n    return !!ctor && (ctor === GeneratorFunction || \\\"GeneratorFunction\\\" === (ctor.displayName || ctor.name));\\n  }, exports.mark = function (genFun) {\\n    return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, \\\"GeneratorFunction\\\")), genFun.prototype = Object.create(Gp), genFun;\\n  }, exports.awrap = function (arg) {\\n    return {\\n      __await: arg\\n    };\\n  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {\\n    return this;\\n  }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {\\n    void 0 === PromiseImpl && (PromiseImpl = Promise);\\n    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);\\n    return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {\\n      return result.done ? result.value : iter.next();\\n    });\\n  }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, \\\"Generator\\\"), define(Gp, iteratorSymbol, function () {\\n    return this;\\n  }), define(Gp, \\\"toString\\\", function () {\\n    return \\\"[object Generator]\\\";\\n  }), exports.keys = function (val) {\\n    var object = Object(val),\\n      keys = [];\\n    for (var key in object) {\\n      keys.push(key);\\n    }\\n    return keys.reverse(), function next() {\\n      for (; keys.length;) {\\n        var key = keys.pop();\\n        if (key in object) return next.value = key, next.done = !1, next;\\n      }\\n      return next.done = !0, next;\\n    };\\n  }, exports.values = values, Context.prototype = {\\n    constructor: Context,\\n    reset: function reset(skipTempReset) {\\n      if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = \\\"next\\\", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) {\\n        \\\"t\\\" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);\\n      }\\n    },\\n    stop: function stop() {\\n      this.done = !0;\\n      var rootRecord = this.tryEntries[0].completion;\\n      if (\\\"throw\\\" === rootRecord.type) throw rootRecord.arg;\\n      return this.rval;\\n    },\\n    dispatchException: function dispatchException(exception) {\\n      if (this.done) throw exception;\\n      var context = this;\\n      function handle(loc, caught) {\\n        return record.type = \\\"throw\\\", record.arg = exception, context.next = loc, caught && (context.method = \\\"next\\\", context.arg = undefined), !!caught;\\n      }\\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\\n        var entry = this.tryEntries[i],\\n          record = entry.completion;\\n        if (\\\"root\\\" === entry.tryLoc) return handle(\\\"end\\\");\\n        if (entry.tryLoc <= this.prev) {\\n          var hasCatch = hasOwn.call(entry, \\\"catchLoc\\\"),\\n            hasFinally = hasOwn.call(entry, \\\"finallyLoc\\\");\\n          if (hasCatch && hasFinally) {\\n            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);\\n            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);\\n          } else if (hasCatch) {\\n            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);\\n          } else {\\n            if (!hasFinally) throw new Error(\\\"try statement without catch or finally\\\");\\n            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);\\n          }\\n        }\\n      }\\n    },\\n    abrupt: function abrupt(type, arg) {\\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\\n        var entry = this.tryEntries[i];\\n        if (entry.tryLoc <= this.prev && hasOwn.call(entry, \\\"finallyLoc\\\") && this.prev < entry.finallyLoc) {\\n          var finallyEntry = entry;\\n          break;\\n        }\\n      }\\n      finallyEntry && (\\\"break\\\" === type || \\\"continue\\\" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);\\n      var record = finallyEntry ? finallyEntry.completion : {};\\n      return record.type = type, record.arg = arg, finallyEntry ? (this.method = \\\"next\\\", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);\\n    },\\n    complete: function complete(record, afterLoc) {\\n      if (\\\"throw\\\" === record.type) throw record.arg;\\n      return \\\"break\\\" === record.type || \\\"continue\\\" === record.type ? this.next = record.arg : \\\"return\\\" === record.type ? (this.rval = this.arg = record.arg, this.method = \\\"return\\\", this.next = \\\"end\\\") : \\\"normal\\\" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;\\n    },\\n    finish: function finish(finallyLoc) {\\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\\n        var entry = this.tryEntries[i];\\n        if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;\\n      }\\n    },\\n    \\\"catch\\\": function _catch(tryLoc) {\\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\\n        var entry = this.tryEntries[i];\\n        if (entry.tryLoc === tryLoc) {\\n          var record = entry.completion;\\n          if (\\\"throw\\\" === record.type) {\\n            var thrown = record.arg;\\n            resetTryEntry(entry);\\n          }\\n          return thrown;\\n        }\\n      }\\n      throw new Error(\\\"illegal catch attempt\\\");\\n    },\\n    delegateYield: function delegateYield(iterable, resultName, nextLoc) {\\n      return this.delegate = {\\n        iterator: values(iterable),\\n        resultName: resultName,\\n        nextLoc: nextLoc\\n      }, \\\"next\\\" === this.method && (this.arg = undefined), ContinueSentinel;\\n    }\\n  }, exports;\\n}\\nmodule.exports = _regeneratorRuntime, module.exports.__esModule = true, module.exports[\\\"default\\\"] = module.exports;\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@babel/runtime/helpers/regeneratorRuntime.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/@babel/runtime/helpers/setPrototypeOf.js\":\n/*!***************************************************************!*\\\n  !*** ./node_modules/@babel/runtime/helpers/setPrototypeOf.js ***!\n  \\***************************************************************/\n/***/ ((module) => {\n\neval(\"function _setPrototypeOf(o, p) {\\n  module.exports = _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {\\n    o.__proto__ = p;\\n    return o;\\n  }, module.exports.__esModule = true, module.exports[\\\"default\\\"] = module.exports;\\n  return _setPrototypeOf(o, p);\\n}\\nmodule.exports = _setPrototypeOf, module.exports.__esModule = true, module.exports[\\\"default\\\"] = module.exports;\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@babel/runtime/helpers/setPrototypeOf.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/@babel/runtime/helpers/toPrimitive.js\":\n/*!************************************************************!*\\\n  !*** ./node_modules/@babel/runtime/helpers/toPrimitive.js ***!\n  \\************************************************************/\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\neval(\"var _typeof = (__webpack_require__(/*! ./typeof.js */ \\\"./node_modules/@babel/runtime/helpers/typeof.js\\\")[\\\"default\\\"]);\\nfunction _toPrimitive(input, hint) {\\n  if (_typeof(input) !== \\\"object\\\" || input === null) return input;\\n  var prim = input[Symbol.toPrimitive];\\n  if (prim !== undefined) {\\n    var res = prim.call(input, hint || \\\"default\\\");\\n    if (_typeof(res) !== \\\"object\\\") return res;\\n    throw new TypeError(\\\"@@toPrimitive must return a primitive value.\\\");\\n  }\\n  return (hint === \\\"string\\\" ? String : Number)(input);\\n}\\nmodule.exports = _toPrimitive, module.exports.__esModule = true, module.exports[\\\"default\\\"] = module.exports;\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@babel/runtime/helpers/toPrimitive.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/@babel/runtime/helpers/toPropertyKey.js\":\n/*!**************************************************************!*\\\n  !*** ./node_modules/@babel/runtime/helpers/toPropertyKey.js ***!\n  \\**************************************************************/\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\neval(\"var _typeof = (__webpack_require__(/*! ./typeof.js */ \\\"./node_modules/@babel/runtime/helpers/typeof.js\\\")[\\\"default\\\"]);\\nvar toPrimitive = __webpack_require__(/*! ./toPrimitive.js */ \\\"./node_modules/@babel/runtime/helpers/toPrimitive.js\\\");\\nfunction _toPropertyKey(arg) {\\n  var key = toPrimitive(arg, \\\"string\\\");\\n  return _typeof(key) === \\\"symbol\\\" ? key : String(key);\\n}\\nmodule.exports = _toPropertyKey, module.exports.__esModule = true, module.exports[\\\"default\\\"] = module.exports;\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@babel/runtime/helpers/toPropertyKey.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/@babel/runtime/helpers/typeof.js\":\n/*!*******************************************************!*\\\n  !*** ./node_modules/@babel/runtime/helpers/typeof.js ***!\n  \\*******************************************************/\n/***/ ((module) => {\n\neval(\"function _typeof(obj) {\\n  \\\"@babel/helpers - typeof\\\";\\n\\n  return (module.exports = _typeof = \\\"function\\\" == typeof Symbol && \\\"symbol\\\" == typeof Symbol.iterator ? function (obj) {\\n    return typeof obj;\\n  } : function (obj) {\\n    return obj && \\\"function\\\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \\\"symbol\\\" : typeof obj;\\n  }, module.exports.__esModule = true, module.exports[\\\"default\\\"] = module.exports), _typeof(obj);\\n}\\nmodule.exports = _typeof, module.exports.__esModule = true, module.exports[\\\"default\\\"] = module.exports;\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@babel/runtime/helpers/typeof.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/@babel/runtime/regenerator/index.js\":\n/*!**********************************************************!*\\\n  !*** ./node_modules/@babel/runtime/regenerator/index.js ***!\n  \\**********************************************************/\n/***/ ((module, __unused_webpack_exports, __webpack_require__) => {\n\neval(\"// TODO(Babel 8): Remove this file.\\n\\nvar runtime = __webpack_require__(/*! ../helpers/regeneratorRuntime */ \\\"./node_modules/@babel/runtime/helpers/regeneratorRuntime.js\\\")();\\nmodule.exports = runtime;\\n\\n// Copied from https://github.com/facebook/regenerator/blob/main/packages/runtime/runtime.js#L736=\\ntry {\\n  regeneratorRuntime = runtime;\\n} catch (accidentalStrictMode) {\\n  if (typeof globalThis === \\\"object\\\") {\\n    globalThis.regeneratorRuntime = runtime;\\n  } else {\\n    Function(\\\"r\\\", \\\"regeneratorRuntime = r\\\")(runtime);\\n  }\\n}\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@babel/runtime/regenerator/index.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/@noble/ed25519/lib/esm/index.js\":\n/*!******************************************************!*\\\n  !*** ./node_modules/@noble/ed25519/lib/esm/index.js ***!\n  \\******************************************************/\n/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"var crypto__WEBPACK_IMPORTED_MODULE_0___namespace_cache;\\n__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"CURVE\\\": () => (/* binding */ CURVE),\\n/* harmony export */   \\\"ExtendedPoint\\\": () => (/* binding */ ExtendedPoint),\\n/* harmony export */   \\\"Point\\\": () => (/* binding */ Point),\\n/* harmony export */   \\\"RistrettoPoint\\\": () => (/* binding */ RistrettoPoint),\\n/* harmony export */   \\\"Signature\\\": () => (/* binding */ Signature),\\n/* harmony export */   \\\"curve25519\\\": () => (/* binding */ curve25519),\\n/* harmony export */   \\\"getPublicKey\\\": () => (/* binding */ getPublicKey),\\n/* harmony export */   \\\"getSharedSecret\\\": () => (/* binding */ getSharedSecret),\\n/* harmony export */   \\\"sign\\\": () => (/* binding */ sign),\\n/* harmony export */   \\\"sync\\\": () => (/* binding */ sync),\\n/* harmony export */   \\\"utils\\\": () => (/* binding */ utils),\\n/* harmony export */   \\\"verify\\\": () => (/* binding */ verify)\\n/* harmony export */ });\\n/* harmony import */ var crypto__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! crypto */ \\\"?51ea\\\");\\n/*! noble-ed25519 - MIT License (c) 2019 Paul Miller (paulmillr.com) */\\n\\nconst _0n = BigInt(0);\\nconst _1n = BigInt(1);\\nconst _2n = BigInt(2);\\nconst CU_O = BigInt('7237005577332262213973186563042994240857116359379907606001950938285454250989');\\nconst CURVE = Object.freeze({\\n    a: BigInt(-1),\\n    d: BigInt('37095705934669439343138083508754565189542113879843219016388785533085940283555'),\\n    P: BigInt('57896044618658097711785492504343953926634992332820282019728792003956564819949'),\\n    l: CU_O,\\n    n: CU_O,\\n    h: BigInt(8),\\n    Gx: BigInt('15112221349535400772501151409588531511454012693041857206046113283949847762202'),\\n    Gy: BigInt('46316835694926478169428394003475163141307993866256225615783033603165251855960'),\\n});\\n\\nconst POW_2_256 = BigInt('0x10000000000000000000000000000000000000000000000000000000000000000');\\nconst SQRT_M1 = BigInt('19681161376707505956807079304988542015446066515923890162744021073123829784752');\\nconst SQRT_D = BigInt('6853475219497561581579357271197624642482790079785650197046958215289687604742');\\nconst SQRT_AD_MINUS_ONE = BigInt('25063068953384623474111414158702152701244531502492656460079210482610430750235');\\nconst INVSQRT_A_MINUS_D = BigInt('54469307008909316920995813868745141605393597292927456921205312896311721017578');\\nconst ONE_MINUS_D_SQ = BigInt('1159843021668779879193775521855586647937357759715417654439879720876111806838');\\nconst D_MINUS_ONE_SQ = BigInt('40440834346308536858101042469323190826248399146238708352240133220865137265952');\\nclass ExtendedPoint {\\n    constructor(x, y, z, t) {\\n        this.x = x;\\n        this.y = y;\\n        this.z = z;\\n        this.t = t;\\n    }\\n    static fromAffine(p) {\\n        if (!(p instanceof Point)) {\\n            throw new TypeError('ExtendedPoint#fromAffine: expected Point');\\n        }\\n        if (p.equals(Point.ZERO))\\n            return ExtendedPoint.ZERO;\\n        return new ExtendedPoint(p.x, p.y, _1n, mod(p.x * p.y));\\n    }\\n    static toAffineBatch(points) {\\n        const toInv = invertBatch(points.map((p) => p.z));\\n        return points.map((p, i) => p.toAffine(toInv[i]));\\n    }\\n    static normalizeZ(points) {\\n        return this.toAffineBatch(points).map(this.fromAffine);\\n    }\\n    equals(other) {\\n        assertExtPoint(other);\\n        const { x: X1, y: Y1, z: Z1 } = this;\\n        const { x: X2, y: Y2, z: Z2 } = other;\\n        const X1Z2 = mod(X1 * Z2);\\n        const X2Z1 = mod(X2 * Z1);\\n        const Y1Z2 = mod(Y1 * Z2);\\n        const Y2Z1 = mod(Y2 * Z1);\\n        return X1Z2 === X2Z1 && Y1Z2 === Y2Z1;\\n    }\\n    negate() {\\n        return new ExtendedPoint(mod(-this.x), this.y, this.z, mod(-this.t));\\n    }\\n    double() {\\n        const { x: X1, y: Y1, z: Z1 } = this;\\n        const { a } = CURVE;\\n        const A = mod(X1 * X1);\\n        const B = mod(Y1 * Y1);\\n        const C = mod(_2n * mod(Z1 * Z1));\\n        const D = mod(a * A);\\n        const x1y1 = X1 + Y1;\\n        const E = mod(mod(x1y1 * x1y1) - A - B);\\n        const G = D + B;\\n        const F = G - C;\\n        const H = D - B;\\n        const X3 = mod(E * F);\\n        const Y3 = mod(G * H);\\n        const T3 = mod(E * H);\\n        const Z3 = mod(F * G);\\n        return new ExtendedPoint(X3, Y3, Z3, T3);\\n    }\\n    add(other) {\\n        assertExtPoint(other);\\n        const { x: X1, y: Y1, z: Z1, t: T1 } = this;\\n        const { x: X2, y: Y2, z: Z2, t: T2 } = other;\\n        const A = mod((Y1 - X1) * (Y2 + X2));\\n        const B = mod((Y1 + X1) * (Y2 - X2));\\n        const F = mod(B - A);\\n        if (F === _0n)\\n            return this.double();\\n        const C = mod(Z1 * _2n * T2);\\n        const D = mod(T1 * _2n * Z2);\\n        const E = D + C;\\n        const G = B + A;\\n        const H = D - C;\\n        const X3 = mod(E * F);\\n        const Y3 = mod(G * H);\\n        const T3 = mod(E * H);\\n        const Z3 = mod(F * G);\\n        return new ExtendedPoint(X3, Y3, Z3, T3);\\n    }\\n    subtract(other) {\\n        return this.add(other.negate());\\n    }\\n    precomputeWindow(W) {\\n        const windows = 1 + 256 / W;\\n        const points = [];\\n        let p = this;\\n        let base = p;\\n        for (let window = 0; window < windows; window++) {\\n            base = p;\\n            points.push(base);\\n            for (let i = 1; i < 2 ** (W - 1); i++) {\\n                base = base.add(p);\\n                points.push(base);\\n            }\\n            p = base.double();\\n        }\\n        return points;\\n    }\\n    wNAF(n, affinePoint) {\\n        if (!affinePoint && this.equals(ExtendedPoint.BASE))\\n            affinePoint = Point.BASE;\\n        const W = (affinePoint && affinePoint._WINDOW_SIZE) || 1;\\n        if (256 % W) {\\n            throw new Error('Point#wNAF: Invalid precomputation window, must be power of 2');\\n        }\\n        let precomputes = affinePoint && pointPrecomputes.get(affinePoint);\\n        if (!precomputes) {\\n            precomputes = this.precomputeWindow(W);\\n            if (affinePoint && W !== 1) {\\n                precomputes = ExtendedPoint.normalizeZ(precomputes);\\n                pointPrecomputes.set(affinePoint, precomputes);\\n            }\\n        }\\n        let p = ExtendedPoint.ZERO;\\n        let f = ExtendedPoint.ZERO;\\n        const windows = 1 + 256 / W;\\n        const windowSize = 2 ** (W - 1);\\n        const mask = BigInt(2 ** W - 1);\\n        const maxNumber = 2 ** W;\\n        const shiftBy = BigInt(W);\\n        for (let window = 0; window < windows; window++) {\\n            const offset = window * windowSize;\\n            let wbits = Number(n & mask);\\n            n >>= shiftBy;\\n            if (wbits > windowSize) {\\n                wbits -= maxNumber;\\n                n += _1n;\\n            }\\n            if (wbits === 0) {\\n                let pr = precomputes[offset];\\n                if (window % 2)\\n                    pr = pr.negate();\\n                f = f.add(pr);\\n            }\\n            else {\\n                let cached = precomputes[offset + Math.abs(wbits) - 1];\\n                if (wbits < 0)\\n                    cached = cached.negate();\\n                p = p.add(cached);\\n            }\\n        }\\n        return ExtendedPoint.normalizeZ([p, f])[0];\\n    }\\n    multiply(scalar, affinePoint) {\\n        return this.wNAF(normalizeScalar(scalar, CURVE.l), affinePoint);\\n    }\\n    multiplyUnsafe(scalar) {\\n        let n = normalizeScalar(scalar, CURVE.l, false);\\n        const G = ExtendedPoint.BASE;\\n        const P0 = ExtendedPoint.ZERO;\\n        if (n === _0n)\\n            return P0;\\n        if (this.equals(P0) || n === _1n)\\n            return this;\\n        if (this.equals(G))\\n            return this.wNAF(n);\\n        let p = P0;\\n        let d = this;\\n        while (n > _0n) {\\n            if (n & _1n)\\n                p = p.add(d);\\n            d = d.double();\\n            n >>= _1n;\\n        }\\n        return p;\\n    }\\n    isSmallOrder() {\\n        return this.multiplyUnsafe(CURVE.h).equals(ExtendedPoint.ZERO);\\n    }\\n    isTorsionFree() {\\n        return this.multiplyUnsafe(CURVE.l).equals(ExtendedPoint.ZERO);\\n    }\\n    toAffine(invZ = invert(this.z)) {\\n        const { x, y, z } = this;\\n        const ax = mod(x * invZ);\\n        const ay = mod(y * invZ);\\n        const zz = mod(z * invZ);\\n        if (zz !== _1n)\\n            throw new Error('invZ was invalid');\\n        return new Point(ax, ay);\\n    }\\n    fromRistrettoBytes() {\\n        legacyRist();\\n    }\\n    toRistrettoBytes() {\\n        legacyRist();\\n    }\\n    fromRistrettoHash() {\\n        legacyRist();\\n    }\\n}\\nExtendedPoint.BASE = new ExtendedPoint(CURVE.Gx, CURVE.Gy, _1n, mod(CURVE.Gx * CURVE.Gy));\\nExtendedPoint.ZERO = new ExtendedPoint(_0n, _1n, _1n, _0n);\\nfunction assertExtPoint(other) {\\n    if (!(other instanceof ExtendedPoint))\\n        throw new TypeError('ExtendedPoint expected');\\n}\\nfunction assertRstPoint(other) {\\n    if (!(other instanceof RistrettoPoint))\\n        throw new TypeError('RistrettoPoint expected');\\n}\\nfunction legacyRist() {\\n    throw new Error('Legacy method: switch to RistrettoPoint');\\n}\\nclass RistrettoPoint {\\n    constructor(ep) {\\n        this.ep = ep;\\n    }\\n    static calcElligatorRistrettoMap(r0) {\\n        const { d } = CURVE;\\n        const r = mod(SQRT_M1 * r0 * r0);\\n        const Ns = mod((r + _1n) * ONE_MINUS_D_SQ);\\n        let c = BigInt(-1);\\n        const D = mod((c - d * r) * mod(r + d));\\n        let { isValid: Ns_D_is_sq, value: s } = uvRatio(Ns, D);\\n        let s_ = mod(s * r0);\\n        if (!edIsNegative(s_))\\n            s_ = mod(-s_);\\n        if (!Ns_D_is_sq)\\n            s = s_;\\n        if (!Ns_D_is_sq)\\n            c = r;\\n        const Nt = mod(c * (r - _1n) * D_MINUS_ONE_SQ - D);\\n        const s2 = s * s;\\n        const W0 = mod((s + s) * D);\\n        const W1 = mod(Nt * SQRT_AD_MINUS_ONE);\\n        const W2 = mod(_1n - s2);\\n        const W3 = mod(_1n + s2);\\n        return new ExtendedPoint(mod(W0 * W3), mod(W2 * W1), mod(W1 * W3), mod(W0 * W2));\\n    }\\n    static hashToCurve(hex) {\\n        hex = ensureBytes(hex, 64);\\n        const r1 = bytes255ToNumberLE(hex.slice(0, 32));\\n        const R1 = this.calcElligatorRistrettoMap(r1);\\n        const r2 = bytes255ToNumberLE(hex.slice(32, 64));\\n        const R2 = this.calcElligatorRistrettoMap(r2);\\n        return new RistrettoPoint(R1.add(R2));\\n    }\\n    static fromHex(hex) {\\n        hex = ensureBytes(hex, 32);\\n        const { a, d } = CURVE;\\n        const emsg = 'RistrettoPoint.fromHex: the hex is not valid encoding of RistrettoPoint';\\n        const s = bytes255ToNumberLE(hex);\\n        if (!equalBytes(numberTo32BytesLE(s), hex) || edIsNegative(s))\\n            throw new Error(emsg);\\n        const s2 = mod(s * s);\\n        const u1 = mod(_1n + a * s2);\\n        const u2 = mod(_1n - a * s2);\\n        const u1_2 = mod(u1 * u1);\\n        const u2_2 = mod(u2 * u2);\\n        const v = mod(a * d * u1_2 - u2_2);\\n        const { isValid, value: I } = invertSqrt(mod(v * u2_2));\\n        const Dx = mod(I * u2);\\n        const Dy = mod(I * Dx * v);\\n        let x = mod((s + s) * Dx);\\n        if (edIsNegative(x))\\n            x = mod(-x);\\n        const y = mod(u1 * Dy);\\n        const t = mod(x * y);\\n        if (!isValid || edIsNegative(t) || y === _0n)\\n            throw new Error(emsg);\\n        return new RistrettoPoint(new ExtendedPoint(x, y, _1n, t));\\n    }\\n    toRawBytes() {\\n        let { x, y, z, t } = this.ep;\\n        const u1 = mod(mod(z + y) * mod(z - y));\\n        const u2 = mod(x * y);\\n        const u2sq = mod(u2 * u2);\\n        const { value: invsqrt } = invertSqrt(mod(u1 * u2sq));\\n        const D1 = mod(invsqrt * u1);\\n        const D2 = mod(invsqrt * u2);\\n        const zInv = mod(D1 * D2 * t);\\n        let D;\\n        if (edIsNegative(t * zInv)) {\\n            let _x = mod(y * SQRT_M1);\\n            let _y = mod(x * SQRT_M1);\\n            x = _x;\\n            y = _y;\\n            D = mod(D1 * INVSQRT_A_MINUS_D);\\n        }\\n        else {\\n            D = D2;\\n        }\\n        if (edIsNegative(x * zInv))\\n            y = mod(-y);\\n        let s = mod((z - y) * D);\\n        if (edIsNegative(s))\\n            s = mod(-s);\\n        return numberTo32BytesLE(s);\\n    }\\n    toHex() {\\n        return bytesToHex(this.toRawBytes());\\n    }\\n    toString() {\\n        return this.toHex();\\n    }\\n    equals(other) {\\n        assertRstPoint(other);\\n        const a = this.ep;\\n        const b = other.ep;\\n        const one = mod(a.x * b.y) === mod(a.y * b.x);\\n        const two = mod(a.y * b.y) === mod(a.x * b.x);\\n        return one || two;\\n    }\\n    add(other) {\\n        assertRstPoint(other);\\n        return new RistrettoPoint(this.ep.add(other.ep));\\n    }\\n    subtract(other) {\\n        assertRstPoint(other);\\n        return new RistrettoPoint(this.ep.subtract(other.ep));\\n    }\\n    multiply(scalar) {\\n        return new RistrettoPoint(this.ep.multiply(scalar));\\n    }\\n    multiplyUnsafe(scalar) {\\n        return new RistrettoPoint(this.ep.multiplyUnsafe(scalar));\\n    }\\n}\\nRistrettoPoint.BASE = new RistrettoPoint(ExtendedPoint.BASE);\\nRistrettoPoint.ZERO = new RistrettoPoint(ExtendedPoint.ZERO);\\nconst pointPrecomputes = new WeakMap();\\nclass Point {\\n    constructor(x, y) {\\n        this.x = x;\\n        this.y = y;\\n    }\\n    _setWindowSize(windowSize) {\\n        this._WINDOW_SIZE = windowSize;\\n        pointPrecomputes.delete(this);\\n    }\\n    static fromHex(hex, strict = true) {\\n        const { d, P } = CURVE;\\n        hex = ensureBytes(hex, 32);\\n        const normed = hex.slice();\\n        normed[31] = hex[31] & ~0x80;\\n        const y = bytesToNumberLE(normed);\\n        if (strict && y >= P)\\n            throw new Error('Expected 0 < hex < P');\\n        if (!strict && y >= POW_2_256)\\n            throw new Error('Expected 0 < hex < 2**256');\\n        const y2 = mod(y * y);\\n        const u = mod(y2 - _1n);\\n        const v = mod(d * y2 + _1n);\\n        let { isValid, value: x } = uvRatio(u, v);\\n        if (!isValid)\\n            throw new Error('Point.fromHex: invalid y coordinate');\\n        const isXOdd = (x & _1n) === _1n;\\n        const isLastByteOdd = (hex[31] & 0x80) !== 0;\\n        if (isLastByteOdd !== isXOdd) {\\n            x = mod(-x);\\n        }\\n        return new Point(x, y);\\n    }\\n    static async fromPrivateKey(privateKey) {\\n        return (await getExtendedPublicKey(privateKey)).point;\\n    }\\n    toRawBytes() {\\n        const bytes = numberTo32BytesLE(this.y);\\n        bytes[31] |= this.x & _1n ? 0x80 : 0;\\n        return bytes;\\n    }\\n    toHex() {\\n        return bytesToHex(this.toRawBytes());\\n    }\\n    toX25519() {\\n        const { y } = this;\\n        const u = mod((_1n + y) * invert(_1n - y));\\n        return numberTo32BytesLE(u);\\n    }\\n    isTorsionFree() {\\n        return ExtendedPoint.fromAffine(this).isTorsionFree();\\n    }\\n    equals(other) {\\n        return this.x === other.x && this.y === other.y;\\n    }\\n    negate() {\\n        return new Point(mod(-this.x), this.y);\\n    }\\n    add(other) {\\n        return ExtendedPoint.fromAffine(this).add(ExtendedPoint.fromAffine(other)).toAffine();\\n    }\\n    subtract(other) {\\n        return this.add(other.negate());\\n    }\\n    multiply(scalar) {\\n        return ExtendedPoint.fromAffine(this).multiply(scalar, this).toAffine();\\n    }\\n}\\nPoint.BASE = new Point(CURVE.Gx, CURVE.Gy);\\nPoint.ZERO = new Point(_0n, _1n);\\nclass Signature {\\n    constructor(r, s) {\\n        this.r = r;\\n        this.s = s;\\n        this.assertValidity();\\n    }\\n    static fromHex(hex) {\\n        const bytes = ensureBytes(hex, 64);\\n        const r = Point.fromHex(bytes.slice(0, 32), false);\\n        const s = bytesToNumberLE(bytes.slice(32, 64));\\n        return new Signature(r, s);\\n    }\\n    assertValidity() {\\n        const { r, s } = this;\\n        if (!(r instanceof Point))\\n            throw new Error('Expected Point instance');\\n        normalizeScalar(s, CURVE.l, false);\\n        return this;\\n    }\\n    toRawBytes() {\\n        const u8 = new Uint8Array(64);\\n        u8.set(this.r.toRawBytes());\\n        u8.set(numberTo32BytesLE(this.s), 32);\\n        return u8;\\n    }\\n    toHex() {\\n        return bytesToHex(this.toRawBytes());\\n    }\\n}\\n\\nfunction concatBytes(...arrays) {\\n    if (!arrays.every((a) => a instanceof Uint8Array))\\n        throw new Error('Expected Uint8Array list');\\n    if (arrays.length === 1)\\n        return arrays[0];\\n    const length = arrays.reduce((a, arr) => a + arr.length, 0);\\n    const result = new Uint8Array(length);\\n    for (let i = 0, pad = 0; i < arrays.length; i++) {\\n        const arr = arrays[i];\\n        result.set(arr, pad);\\n        pad += arr.length;\\n    }\\n    return result;\\n}\\nconst hexes = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, '0'));\\nfunction bytesToHex(uint8a) {\\n    if (!(uint8a instanceof Uint8Array))\\n        throw new Error('Uint8Array expected');\\n    let hex = '';\\n    for (let i = 0; i < uint8a.length; i++) {\\n        hex += hexes[uint8a[i]];\\n    }\\n    return hex;\\n}\\nfunction hexToBytes(hex) {\\n    if (typeof hex !== 'string') {\\n        throw new TypeError('hexToBytes: expected string, got ' + typeof hex);\\n    }\\n    if (hex.length % 2)\\n        throw new Error('hexToBytes: received invalid unpadded hex');\\n    const array = new Uint8Array(hex.length / 2);\\n    for (let i = 0; i < array.length; i++) {\\n        const j = i * 2;\\n        const hexByte = hex.slice(j, j + 2);\\n        const byte = Number.parseInt(hexByte, 16);\\n        if (Number.isNaN(byte) || byte < 0)\\n            throw new Error('Invalid byte sequence');\\n        array[i] = byte;\\n    }\\n    return array;\\n}\\nfunction numberTo32BytesBE(num) {\\n    const length = 32;\\n    const hex = num.toString(16).padStart(length * 2, '0');\\n    return hexToBytes(hex);\\n}\\nfunction numberTo32BytesLE(num) {\\n    return numberTo32BytesBE(num).reverse();\\n}\\nfunction edIsNegative(num) {\\n    return (mod(num) & _1n) === _1n;\\n}\\nfunction bytesToNumberLE(uint8a) {\\n    if (!(uint8a instanceof Uint8Array))\\n        throw new Error('Expected Uint8Array');\\n    return BigInt('0x' + bytesToHex(Uint8Array.from(uint8a).reverse()));\\n}\\nconst MAX_255B = BigInt('0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff');\\nfunction bytes255ToNumberLE(bytes) {\\n    return mod(bytesToNumberLE(bytes) & MAX_255B);\\n}\\nfunction mod(a, b = CURVE.P) {\\n    const res = a % b;\\n    return res >= _0n ? res : b + res;\\n}\\nfunction invert(number, modulo = CURVE.P) {\\n    if (number === _0n || modulo <= _0n) {\\n        throw new Error(`invert: expected positive integers, got n=${number} mod=${modulo}`);\\n    }\\n    let a = mod(number, modulo);\\n    let b = modulo;\\n    let x = _0n, y = _1n, u = _1n, v = _0n;\\n    while (a !== _0n) {\\n        const q = b / a;\\n        const r = b % a;\\n        const m = x - u * q;\\n        const n = y - v * q;\\n        b = a, a = r, x = u, y = v, u = m, v = n;\\n    }\\n    const gcd = b;\\n    if (gcd !== _1n)\\n        throw new Error('invert: does not exist');\\n    return mod(x, modulo);\\n}\\nfunction invertBatch(nums, p = CURVE.P) {\\n    const tmp = new Array(nums.length);\\n    const lastMultiplied = nums.reduce((acc, num, i) => {\\n        if (num === _0n)\\n            return acc;\\n        tmp[i] = acc;\\n        return mod(acc * num, p);\\n    }, _1n);\\n    const inverted = invert(lastMultiplied, p);\\n    nums.reduceRight((acc, num, i) => {\\n        if (num === _0n)\\n            return acc;\\n        tmp[i] = mod(acc * tmp[i], p);\\n        return mod(acc * num, p);\\n    }, inverted);\\n    return tmp;\\n}\\nfunction pow2(x, power) {\\n    const { P } = CURVE;\\n    let res = x;\\n    while (power-- > _0n) {\\n        res *= res;\\n        res %= P;\\n    }\\n    return res;\\n}\\nfunction pow_2_252_3(x) {\\n    const { P } = CURVE;\\n    const _5n = BigInt(5);\\n    const _10n = BigInt(10);\\n    const _20n = BigInt(20);\\n    const _40n = BigInt(40);\\n    const _80n = BigInt(80);\\n    const x2 = (x * x) % P;\\n    const b2 = (x2 * x) % P;\\n    const b4 = (pow2(b2, _2n) * b2) % P;\\n    const b5 = (pow2(b4, _1n) * x) % P;\\n    const b10 = (pow2(b5, _5n) * b5) % P;\\n    const b20 = (pow2(b10, _10n) * b10) % P;\\n    const b40 = (pow2(b20, _20n) * b20) % P;\\n    const b80 = (pow2(b40, _40n) * b40) % P;\\n    const b160 = (pow2(b80, _80n) * b80) % P;\\n    const b240 = (pow2(b160, _80n) * b80) % P;\\n    const b250 = (pow2(b240, _10n) * b10) % P;\\n    const pow_p_5_8 = (pow2(b250, _2n) * x) % P;\\n    return { pow_p_5_8, b2 };\\n}\\nfunction uvRatio(u, v) {\\n    const v3 = mod(v * v * v);\\n    const v7 = mod(v3 * v3 * v);\\n    const pow = pow_2_252_3(u * v7).pow_p_5_8;\\n    let x = mod(u * v3 * pow);\\n    const vx2 = mod(v * x * x);\\n    const root1 = x;\\n    const root2 = mod(x * SQRT_M1);\\n    const useRoot1 = vx2 === u;\\n    const useRoot2 = vx2 === mod(-u);\\n    const noRoot = vx2 === mod(-u * SQRT_M1);\\n    if (useRoot1)\\n        x = root1;\\n    if (useRoot2 || noRoot)\\n        x = root2;\\n    if (edIsNegative(x))\\n        x = mod(-x);\\n    return { isValid: useRoot1 || useRoot2, value: x };\\n}\\nfunction invertSqrt(number) {\\n    return uvRatio(_1n, number);\\n}\\nfunction modlLE(hash) {\\n    return mod(bytesToNumberLE(hash), CURVE.l);\\n}\\nfunction equalBytes(b1, b2) {\\n    if (b1.length !== b2.length) {\\n        return false;\\n    }\\n    for (let i = 0; i < b1.length; i++) {\\n        if (b1[i] !== b2[i]) {\\n            return false;\\n        }\\n    }\\n    return true;\\n}\\nfunction ensureBytes(hex, expectedLength) {\\n    const bytes = hex instanceof Uint8Array ? Uint8Array.from(hex) : hexToBytes(hex);\\n    if (typeof expectedLength === 'number' && bytes.length !== expectedLength)\\n        throw new Error(`Expected ${expectedLength} bytes`);\\n    return bytes;\\n}\\nfunction normalizeScalar(num, max, strict = true) {\\n    if (!max)\\n        throw new TypeError('Specify max value');\\n    if (typeof num === 'number' && Number.isSafeInteger(num))\\n        num = BigInt(num);\\n    if (typeof num === 'bigint' && num < max) {\\n        if (strict) {\\n            if (_0n < num)\\n                return num;\\n        }\\n        else {\\n            if (_0n <= num)\\n                return num;\\n        }\\n    }\\n    throw new TypeError('Expected valid scalar: 0 < scalar < max');\\n}\\nfunction adjustBytes25519(bytes) {\\n    bytes[0] &= 248;\\n    bytes[31] &= 127;\\n    bytes[31] |= 64;\\n    return bytes;\\n}\\nfunction decodeScalar25519(n) {\\n    return bytesToNumberLE(adjustBytes25519(ensureBytes(n, 32)));\\n}\\nfunction checkPrivateKey(key) {\\n    key =\\n        typeof key === 'bigint' || typeof key === 'number'\\n            ? numberTo32BytesBE(normalizeScalar(key, POW_2_256))\\n            : ensureBytes(key);\\n    if (key.length !== 32)\\n        throw new Error(`Expected 32 bytes`);\\n    return key;\\n}\\nfunction getKeyFromHash(hashed) {\\n    const head = adjustBytes25519(hashed.slice(0, 32));\\n    const prefix = hashed.slice(32, 64);\\n    const scalar = modlLE(head);\\n    const point = Point.BASE.multiply(scalar);\\n    const pointBytes = point.toRawBytes();\\n    return { head, prefix, scalar, point, pointBytes };\\n}\\nlet _sha512Sync;\\nfunction sha512s(...m) {\\n    if (typeof _sha512Sync !== 'function')\\n        throw new Error('utils.sha512Sync must be set to use sync methods');\\n    return _sha512Sync(...m);\\n}\\nasync function getExtendedPublicKey(key) {\\n    return getKeyFromHash(await utils.sha512(checkPrivateKey(key)));\\n}\\nfunction getExtendedPublicKeySync(key) {\\n    return getKeyFromHash(sha512s(checkPrivateKey(key)));\\n}\\nasync function getPublicKey(privateKey) {\\n    return (await getExtendedPublicKey(privateKey)).pointBytes;\\n}\\nfunction getPublicKeySync(privateKey) {\\n    return getExtendedPublicKeySync(privateKey).pointBytes;\\n}\\nasync function sign(message, privateKey) {\\n    message = ensureBytes(message);\\n    const { prefix, scalar, pointBytes } = await getExtendedPublicKey(privateKey);\\n    const r = modlLE(await utils.sha512(prefix, message));\\n    const R = Point.BASE.multiply(r);\\n    const k = modlLE(await utils.sha512(R.toRawBytes(), pointBytes, message));\\n    const s = mod(r + k * scalar, CURVE.l);\\n    return new Signature(R, s).toRawBytes();\\n}\\nfunction signSync(message, privateKey) {\\n    message = ensureBytes(message);\\n    const { prefix, scalar, pointBytes } = getExtendedPublicKeySync(privateKey);\\n    const r = modlLE(sha512s(prefix, message));\\n    const R = Point.BASE.multiply(r);\\n    const k = modlLE(sha512s(R.toRawBytes(), pointBytes, message));\\n    const s = mod(r + k * scalar, CURVE.l);\\n    return new Signature(R, s).toRawBytes();\\n}\\nfunction prepareVerification(sig, message, publicKey) {\\n    message = ensureBytes(message);\\n    if (!(publicKey instanceof Point))\\n        publicKey = Point.fromHex(publicKey, false);\\n    const { r, s } = sig instanceof Signature ? sig.assertValidity() : Signature.fromHex(sig);\\n    const SB = ExtendedPoint.BASE.multiplyUnsafe(s);\\n    return { r, s, SB, pub: publicKey, msg: message };\\n}\\nfunction finishVerification(publicKey, r, SB, hashed) {\\n    const k = modlLE(hashed);\\n    const kA = ExtendedPoint.fromAffine(publicKey).multiplyUnsafe(k);\\n    const RkA = ExtendedPoint.fromAffine(r).add(kA);\\n    return RkA.subtract(SB).multiplyUnsafe(CURVE.h).equals(ExtendedPoint.ZERO);\\n}\\nasync function verify(sig, message, publicKey) {\\n    const { r, SB, msg, pub } = prepareVerification(sig, message, publicKey);\\n    const hashed = await utils.sha512(r.toRawBytes(), pub.toRawBytes(), msg);\\n    return finishVerification(pub, r, SB, hashed);\\n}\\nfunction verifySync(sig, message, publicKey) {\\n    const { r, SB, msg, pub } = prepareVerification(sig, message, publicKey);\\n    const hashed = sha512s(r.toRawBytes(), pub.toRawBytes(), msg);\\n    return finishVerification(pub, r, SB, hashed);\\n}\\nconst sync = {\\n    getExtendedPublicKey: getExtendedPublicKeySync,\\n    getPublicKey: getPublicKeySync,\\n    sign: signSync,\\n    verify: verifySync,\\n};\\nasync function getSharedSecret(privateKey, publicKey) {\\n    const { head } = await getExtendedPublicKey(privateKey);\\n    const u = Point.fromHex(publicKey).toX25519();\\n    return curve25519.scalarMult(head, u);\\n}\\nPoint.BASE._setWindowSize(8);\\nfunction cswap(swap, x_2, x_3) {\\n    const dummy = mod(swap * (x_2 - x_3));\\n    x_2 = mod(x_2 - dummy);\\n    x_3 = mod(x_3 + dummy);\\n    return [x_2, x_3];\\n}\\nfunction montgomeryLadder(pointU, scalar) {\\n    const { P } = CURVE;\\n    const u = normalizeScalar(pointU, P);\\n    const k = normalizeScalar(scalar, P);\\n    const a24 = BigInt(121665);\\n    const x_1 = u;\\n    let x_2 = _1n;\\n    let z_2 = _0n;\\n    let x_3 = u;\\n    let z_3 = _1n;\\n    let swap = _0n;\\n    let sw;\\n    for (let t = BigInt(255 - 1); t >= _0n; t--) {\\n        const k_t = (k >> t) & _1n;\\n        swap ^= k_t;\\n        sw = cswap(swap, x_2, x_3);\\n        x_2 = sw[0];\\n        x_3 = sw[1];\\n        sw = cswap(swap, z_2, z_3);\\n        z_2 = sw[0];\\n        z_3 = sw[1];\\n        swap = k_t;\\n        const A = x_2 + z_2;\\n        const AA = mod(A * A);\\n        const B = x_2 - z_2;\\n        const BB = mod(B * B);\\n        const E = AA - BB;\\n        const C = x_3 + z_3;\\n        const D = x_3 - z_3;\\n        const DA = mod(D * A);\\n        const CB = mod(C * B);\\n        const dacb = DA + CB;\\n        const da_cb = DA - CB;\\n        x_3 = mod(dacb * dacb);\\n        z_3 = mod(x_1 * mod(da_cb * da_cb));\\n        x_2 = mod(AA * BB);\\n        z_2 = mod(E * (AA + mod(a24 * E)));\\n    }\\n    sw = cswap(swap, x_2, x_3);\\n    x_2 = sw[0];\\n    x_3 = sw[1];\\n    sw = cswap(swap, z_2, z_3);\\n    z_2 = sw[0];\\n    z_3 = sw[1];\\n    const { pow_p_5_8, b2 } = pow_2_252_3(z_2);\\n    const xp2 = mod(pow2(pow_p_5_8, BigInt(3)) * b2);\\n    return mod(x_2 * xp2);\\n}\\nfunction encodeUCoordinate(u) {\\n    return numberTo32BytesLE(mod(u, CURVE.P));\\n}\\nfunction decodeUCoordinate(uEnc) {\\n    const u = ensureBytes(uEnc, 32);\\n    u[31] &= 127;\\n    return bytesToNumberLE(u);\\n}\\nconst curve25519 = {\\n    BASE_POINT_U: '0900000000000000000000000000000000000000000000000000000000000000',\\n    scalarMult(privateKey, publicKey) {\\n        const u = decodeUCoordinate(publicKey);\\n        const p = decodeScalar25519(privateKey);\\n        const pu = montgomeryLadder(u, p);\\n        if (pu === _0n)\\n            throw new Error('Invalid private or public key received');\\n        return encodeUCoordinate(pu);\\n    },\\n    scalarMultBase(privateKey) {\\n        return curve25519.scalarMult(privateKey, curve25519.BASE_POINT_U);\\n    },\\n};\\nconst crypto = {\\n    node: /*#__PURE__*/ (crypto__WEBPACK_IMPORTED_MODULE_0___namespace_cache || (crypto__WEBPACK_IMPORTED_MODULE_0___namespace_cache = __webpack_require__.t(crypto__WEBPACK_IMPORTED_MODULE_0__, 2))),\\n    web: typeof self === 'object' && 'crypto' in self ? self.crypto : undefined,\\n};\\nconst utils = {\\n    bytesToHex,\\n    hexToBytes,\\n    concatBytes,\\n    getExtendedPublicKey,\\n    mod,\\n    invert,\\n    TORSION_SUBGROUP: [\\n        '0100000000000000000000000000000000000000000000000000000000000000',\\n        'c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac037a',\\n        '0000000000000000000000000000000000000000000000000000000000000080',\\n        '26e8958fc2b227b045c3f489f2ef98f0d5dfac05d3c63339b13802886d53fc05',\\n        'ecffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f',\\n        '26e8958fc2b227b045c3f489f2ef98f0d5dfac05d3c63339b13802886d53fc85',\\n        '0000000000000000000000000000000000000000000000000000000000000000',\\n        'c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac03fa',\\n    ],\\n    hashToPrivateScalar: (hash) => {\\n        hash = ensureBytes(hash);\\n        if (hash.length < 40 || hash.length > 1024)\\n            throw new Error('Expected 40-1024 bytes of private key as per FIPS 186');\\n        return mod(bytesToNumberLE(hash), CURVE.l - _1n) + _1n;\\n    },\\n    randomBytes: (bytesLength = 32) => {\\n        if (crypto.web) {\\n            return crypto.web.getRandomValues(new Uint8Array(bytesLength));\\n        }\\n        else if (crypto.node) {\\n            const { randomBytes } = crypto.node;\\n            return new Uint8Array(randomBytes(bytesLength).buffer);\\n        }\\n        else {\\n            throw new Error(\\\"The environment doesn't have randomBytes function\\\");\\n        }\\n    },\\n    randomPrivateKey: () => {\\n        return utils.randomBytes(32);\\n    },\\n    sha512: async (...messages) => {\\n        const message = concatBytes(...messages);\\n        if (crypto.web) {\\n            const buffer = await crypto.web.subtle.digest('SHA-512', message.buffer);\\n            return new Uint8Array(buffer);\\n        }\\n        else if (crypto.node) {\\n            return Uint8Array.from(crypto.node.createHash('sha512').update(message).digest());\\n        }\\n        else {\\n            throw new Error(\\\"The environment doesn't have sha512 function\\\");\\n        }\\n    },\\n    precompute(windowSize = 8, point = Point.BASE) {\\n        const cached = point.equals(Point.BASE) ? point : new Point(point.x, point.y);\\n        cached._setWindowSize(windowSize);\\n        cached.multiply(_2n);\\n        return cached;\\n    },\\n    sha512Sync: undefined,\\n};\\nObject.defineProperties(utils, {\\n    sha512Sync: {\\n        configurable: false,\\n        get() {\\n            return _sha512Sync;\\n        },\\n        set(val) {\\n            if (!_sha512Sync)\\n                _sha512Sync = val;\\n        },\\n    },\\n});\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@noble/ed25519/lib/esm/index.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/@noble/hashes/esm/_assert.js\":\n/*!***************************************************!*\\\n  !*** ./node_modules/@noble/hashes/esm/_assert.js ***!\n  \\***************************************************/\n/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"bool\\\": () => (/* binding */ bool),\\n/* harmony export */   \\\"bytes\\\": () => (/* binding */ bytes),\\n/* harmony export */   \\\"default\\\": () => (__WEBPACK_DEFAULT_EXPORT__),\\n/* harmony export */   \\\"exists\\\": () => (/* binding */ exists),\\n/* harmony export */   \\\"hash\\\": () => (/* binding */ hash),\\n/* harmony export */   \\\"number\\\": () => (/* binding */ number),\\n/* harmony export */   \\\"output\\\": () => (/* binding */ output)\\n/* harmony export */ });\\nfunction number(n) {\\n    if (!Number.isSafeInteger(n) || n < 0)\\n        throw new Error(`Wrong positive integer: ${n}`);\\n}\\nfunction bool(b) {\\n    if (typeof b !== 'boolean')\\n        throw new Error(`Expected boolean, not ${b}`);\\n}\\nfunction bytes(b, ...lengths) {\\n    if (!(b instanceof Uint8Array))\\n        throw new TypeError('Expected Uint8Array');\\n    if (lengths.length > 0 && !lengths.includes(b.length))\\n        throw new TypeError(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);\\n}\\nfunction hash(hash) {\\n    if (typeof hash !== 'function' || typeof hash.create !== 'function')\\n        throw new Error('Hash should be wrapped by utils.wrapConstructor');\\n    number(hash.outputLen);\\n    number(hash.blockLen);\\n}\\nfunction exists(instance, checkFinished = true) {\\n    if (instance.destroyed)\\n        throw new Error('Hash instance has been destroyed');\\n    if (checkFinished && instance.finished)\\n        throw new Error('Hash#digest() has already been called');\\n}\\nfunction output(out, instance) {\\n    bytes(out);\\n    const min = instance.outputLen;\\n    if (out.length < min) {\\n        throw new Error(`digestInto() expects output buffer of length at least ${min}`);\\n    }\\n}\\nconst assert = {\\n    number,\\n    bool,\\n    bytes,\\n    hash,\\n    exists,\\n    output,\\n};\\n/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (assert);\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@noble/hashes/esm/_assert.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/@noble/hashes/esm/_sha2.js\":\n/*!*************************************************!*\\\n  !*** ./node_modules/@noble/hashes/esm/_sha2.js ***!\n  \\*************************************************/\n/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"SHA2\\\": () => (/* binding */ SHA2)\\n/* harmony export */ });\\n/* harmony import */ var _assert_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./_assert.js */ \\\"./node_modules/@noble/hashes/esm/_assert.js\\\");\\n/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./utils.js */ \\\"./node_modules/@noble/hashes/esm/utils.js\\\");\\n\\n\\n// Polyfill for Safari 14\\nfunction setBigUint64(view, byteOffset, value, isLE) {\\n    if (typeof view.setBigUint64 === 'function')\\n        return view.setBigUint64(byteOffset, value, isLE);\\n    const _32n = BigInt(32);\\n    const _u32_max = BigInt(0xffffffff);\\n    const wh = Number((value >> _32n) & _u32_max);\\n    const wl = Number(value & _u32_max);\\n    const h = isLE ? 4 : 0;\\n    const l = isLE ? 0 : 4;\\n    view.setUint32(byteOffset + h, wh, isLE);\\n    view.setUint32(byteOffset + l, wl, isLE);\\n}\\n// Base SHA2 class (RFC 6234)\\nclass SHA2 extends _utils_js__WEBPACK_IMPORTED_MODULE_1__.Hash {\\n    constructor(blockLen, outputLen, padOffset, isLE) {\\n        super();\\n        this.blockLen = blockLen;\\n        this.outputLen = outputLen;\\n        this.padOffset = padOffset;\\n        this.isLE = isLE;\\n        this.finished = false;\\n        this.length = 0;\\n        this.pos = 0;\\n        this.destroyed = false;\\n        this.buffer = new Uint8Array(blockLen);\\n        this.view = (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.createView)(this.buffer);\\n    }\\n    update(data) {\\n        _assert_js__WEBPACK_IMPORTED_MODULE_0__[\\\"default\\\"].exists(this);\\n        const { view, buffer, blockLen } = this;\\n        data = (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.toBytes)(data);\\n        const len = data.length;\\n        for (let pos = 0; pos < len;) {\\n            const take = Math.min(blockLen - this.pos, len - pos);\\n            // Fast path: we have at least one block in input, cast it to view and process\\n            if (take === blockLen) {\\n                const dataView = (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.createView)(data);\\n                for (; blockLen <= len - pos; pos += blockLen)\\n                    this.process(dataView, pos);\\n                continue;\\n            }\\n            buffer.set(data.subarray(pos, pos + take), this.pos);\\n            this.pos += take;\\n            pos += take;\\n            if (this.pos === blockLen) {\\n                this.process(view, 0);\\n                this.pos = 0;\\n            }\\n        }\\n        this.length += data.length;\\n        this.roundClean();\\n        return this;\\n    }\\n    digestInto(out) {\\n        _assert_js__WEBPACK_IMPORTED_MODULE_0__[\\\"default\\\"].exists(this);\\n        _assert_js__WEBPACK_IMPORTED_MODULE_0__[\\\"default\\\"].output(out, this);\\n        this.finished = true;\\n        // Padding\\n        // We can avoid allocation of buffer for padding completely if it\\n        // was previously not allocated here. But it won't change performance.\\n        const { buffer, view, blockLen, isLE } = this;\\n        let { pos } = this;\\n        // append the bit '1' to the message\\n        buffer[pos++] = 0b10000000;\\n        this.buffer.subarray(pos).fill(0);\\n        // we have less than padOffset left in buffer, so we cannot put length in current block, need process it and pad again\\n        if (this.padOffset > blockLen - pos) {\\n            this.process(view, 0);\\n            pos = 0;\\n        }\\n        // Pad until full block byte with zeros\\n        for (let i = pos; i < blockLen; i++)\\n            buffer[i] = 0;\\n        // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that\\n        // You need to write around 2 exabytes (u64_max / 8 / (1024**6)) for this to happen.\\n        // So we just write lowest 64 bits of that value.\\n        setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);\\n        this.process(view, 0);\\n        const oview = (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.createView)(out);\\n        const len = this.outputLen;\\n        if (len % 4)\\n            throw new Error('_sha2: outputLen should be aligned to 32bit');\\n        const state = this.get();\\n        const outLen = len / 4;\\n        if (outLen > state.length)\\n            throw new Error('_sha2: outputLen bigger than state');\\n        for (let i = 0; i < outLen; i++)\\n            oview.setUint32(4 * i, state[i], isLE);\\n    }\\n    digest() {\\n        const { buffer, outputLen } = this;\\n        this.digestInto(buffer);\\n        const res = buffer.slice(0, outputLen);\\n        this.destroy();\\n        return res;\\n    }\\n    _cloneInto(to) {\\n        to || (to = new this.constructor());\\n        to.set(...this.get());\\n        const { blockLen, buffer, length, finished, destroyed, pos } = this;\\n        to.length = length;\\n        to.pos = pos;\\n        to.finished = finished;\\n        to.destroyed = destroyed;\\n        if (length % blockLen)\\n            to.buffer.set(buffer);\\n        return to;\\n    }\\n}\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@noble/hashes/esm/_sha2.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/@noble/hashes/esm/_u64.js\":\n/*!************************************************!*\\\n  !*** ./node_modules/@noble/hashes/esm/_u64.js ***!\n  \\************************************************/\n/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"add\\\": () => (/* binding */ add),\\n/* harmony export */   \\\"default\\\": () => (__WEBPACK_DEFAULT_EXPORT__),\\n/* harmony export */   \\\"fromBig\\\": () => (/* binding */ fromBig),\\n/* harmony export */   \\\"split\\\": () => (/* binding */ split),\\n/* harmony export */   \\\"toBig\\\": () => (/* binding */ toBig)\\n/* harmony export */ });\\nconst U32_MASK64 = BigInt(2 ** 32 - 1);\\nconst _32n = BigInt(32);\\n// We are not using BigUint64Array, because they are extremely slow as per 2022\\nfunction fromBig(n, le = false) {\\n    if (le)\\n        return { h: Number(n & U32_MASK64), l: Number((n >> _32n) & U32_MASK64) };\\n    return { h: Number((n >> _32n) & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };\\n}\\nfunction split(lst, le = false) {\\n    let Ah = new Uint32Array(lst.length);\\n    let Al = new Uint32Array(lst.length);\\n    for (let i = 0; i < lst.length; i++) {\\n        const { h, l } = fromBig(lst[i], le);\\n        [Ah[i], Al[i]] = [h, l];\\n    }\\n    return [Ah, Al];\\n}\\nconst toBig = (h, l) => (BigInt(h >>> 0) << _32n) | BigInt(l >>> 0);\\n// for Shift in [0, 32)\\nconst shrSH = (h, l, s) => h >>> s;\\nconst shrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);\\n// Right rotate for Shift in [1, 32)\\nconst rotrSH = (h, l, s) => (h >>> s) | (l << (32 - s));\\nconst rotrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);\\n// Right rotate for Shift in (32, 64), NOTE: 32 is special case.\\nconst rotrBH = (h, l, s) => (h << (64 - s)) | (l >>> (s - 32));\\nconst rotrBL = (h, l, s) => (h >>> (s - 32)) | (l << (64 - s));\\n// Right rotate for shift===32 (just swaps l&h)\\nconst rotr32H = (h, l) => l;\\nconst rotr32L = (h, l) => h;\\n// Left rotate for Shift in [1, 32)\\nconst rotlSH = (h, l, s) => (h << s) | (l >>> (32 - s));\\nconst rotlSL = (h, l, s) => (l << s) | (h >>> (32 - s));\\n// Left rotate for Shift in (32, 64), NOTE: 32 is special case.\\nconst rotlBH = (h, l, s) => (l << (s - 32)) | (h >>> (64 - s));\\nconst rotlBL = (h, l, s) => (h << (s - 32)) | (l >>> (64 - s));\\n// JS uses 32-bit signed integers for bitwise operations which means we cannot\\n// simple take carry out of low bit sum by shift, we need to use division.\\n// Removing \\\"export\\\" has 5% perf penalty -_-\\nfunction add(Ah, Al, Bh, Bl) {\\n    const l = (Al >>> 0) + (Bl >>> 0);\\n    return { h: (Ah + Bh + ((l / 2 ** 32) | 0)) | 0, l: l | 0 };\\n}\\n// Addition with more than 2 elements\\nconst add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);\\nconst add3H = (low, Ah, Bh, Ch) => (Ah + Bh + Ch + ((low / 2 ** 32) | 0)) | 0;\\nconst add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);\\nconst add4H = (low, Ah, Bh, Ch, Dh) => (Ah + Bh + Ch + Dh + ((low / 2 ** 32) | 0)) | 0;\\nconst add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);\\nconst add5H = (low, Ah, Bh, Ch, Dh, Eh) => (Ah + Bh + Ch + Dh + Eh + ((low / 2 ** 32) | 0)) | 0;\\n// prettier-ignore\\nconst u64 = {\\n    fromBig, split, toBig,\\n    shrSH, shrSL,\\n    rotrSH, rotrSL, rotrBH, rotrBL,\\n    rotr32H, rotr32L,\\n    rotlSH, rotlSL, rotlBH, rotlBL,\\n    add, add3L, add3H, add4L, add4H, add5H, add5L,\\n};\\n/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (u64);\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@noble/hashes/esm/_u64.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/@noble/hashes/esm/cryptoBrowser.js\":\n/*!*********************************************************!*\\\n  !*** ./node_modules/@noble/hashes/esm/cryptoBrowser.js ***!\n  \\*********************************************************/\n/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"crypto\\\": () => (/* binding */ crypto)\\n/* harmony export */ });\\nconst crypto = {\\n    node: undefined,\\n    web: typeof self === 'object' && 'crypto' in self ? self.crypto : undefined,\\n};\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@noble/hashes/esm/cryptoBrowser.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/@noble/hashes/esm/hmac.js\":\n/*!************************************************!*\\\n  !*** ./node_modules/@noble/hashes/esm/hmac.js ***!\n  \\************************************************/\n/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"hmac\\\": () => (/* binding */ hmac)\\n/* harmony export */ });\\n/* harmony import */ var _assert_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./_assert.js */ \\\"./node_modules/@noble/hashes/esm/_assert.js\\\");\\n/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./utils.js */ \\\"./node_modules/@noble/hashes/esm/utils.js\\\");\\n\\n\\n// HMAC (RFC 2104)\\nclass HMAC extends _utils_js__WEBPACK_IMPORTED_MODULE_1__.Hash {\\n    constructor(hash, _key) {\\n        super();\\n        this.finished = false;\\n        this.destroyed = false;\\n        _assert_js__WEBPACK_IMPORTED_MODULE_0__[\\\"default\\\"].hash(hash);\\n        const key = (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.toBytes)(_key);\\n        this.iHash = hash.create();\\n        if (typeof this.iHash.update !== 'function')\\n            throw new TypeError('Expected instance of class which extends utils.Hash');\\n        this.blockLen = this.iHash.blockLen;\\n        this.outputLen = this.iHash.outputLen;\\n        const blockLen = this.blockLen;\\n        const pad = new Uint8Array(blockLen);\\n        // blockLen can be bigger than outputLen\\n        pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);\\n        for (let i = 0; i < pad.length; i++)\\n            pad[i] ^= 0x36;\\n        this.iHash.update(pad);\\n        // By doing update (processing of first block) of outer hash here we can re-use it between multiple calls via clone\\n        this.oHash = hash.create();\\n        // Undo internal XOR && apply outer XOR\\n        for (let i = 0; i < pad.length; i++)\\n            pad[i] ^= 0x36 ^ 0x5c;\\n        this.oHash.update(pad);\\n        pad.fill(0);\\n    }\\n    update(buf) {\\n        _assert_js__WEBPACK_IMPORTED_MODULE_0__[\\\"default\\\"].exists(this);\\n        this.iHash.update(buf);\\n        return this;\\n    }\\n    digestInto(out) {\\n        _assert_js__WEBPACK_IMPORTED_MODULE_0__[\\\"default\\\"].exists(this);\\n        _assert_js__WEBPACK_IMPORTED_MODULE_0__[\\\"default\\\"].bytes(out, this.outputLen);\\n        this.finished = true;\\n        this.iHash.digestInto(out);\\n        this.oHash.update(out);\\n        this.oHash.digestInto(out);\\n        this.destroy();\\n    }\\n    digest() {\\n        const out = new Uint8Array(this.oHash.outputLen);\\n        this.digestInto(out);\\n        return out;\\n    }\\n    _cloneInto(to) {\\n        // Create new instance without calling constructor since key already in state and we don't know it.\\n        to || (to = Object.create(Object.getPrototypeOf(this), {}));\\n        const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;\\n        to = to;\\n        to.finished = finished;\\n        to.destroyed = destroyed;\\n        to.blockLen = blockLen;\\n        to.outputLen = outputLen;\\n        to.oHash = oHash._cloneInto(to.oHash);\\n        to.iHash = iHash._cloneInto(to.iHash);\\n        return to;\\n    }\\n    destroy() {\\n        this.destroyed = true;\\n        this.oHash.destroy();\\n        this.iHash.destroy();\\n    }\\n}\\n/**\\n * HMAC: RFC2104 message authentication code.\\n * @param hash - function that would be used e.g. sha256\\n * @param key - message key\\n * @param message - message data\\n */\\nconst hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();\\nhmac.create = (hash, key) => new HMAC(hash, key);\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@noble/hashes/esm/hmac.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/@noble/hashes/esm/sha256.js\":\n/*!**************************************************!*\\\n  !*** ./node_modules/@noble/hashes/esm/sha256.js ***!\n  \\**************************************************/\n/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"sha256\\\": () => (/* binding */ sha256)\\n/* harmony export */ });\\n/* harmony import */ var _sha2_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./_sha2.js */ \\\"./node_modules/@noble/hashes/esm/_sha2.js\\\");\\n/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./utils.js */ \\\"./node_modules/@noble/hashes/esm/utils.js\\\");\\n\\n\\n// Choice: a ? b : c\\nconst Chi = (a, b, c) => (a & b) ^ (~a & c);\\n// Majority function, true if any two inpust is true\\nconst Maj = (a, b, c) => (a & b) ^ (a & c) ^ (b & c);\\n// Round constants:\\n// first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311)\\n// prettier-ignore\\nconst SHA256_K = new Uint32Array([\\n    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,\\n    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,\\n    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,\\n    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,\\n    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\\n    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,\\n    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,\\n    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2\\n]);\\n// Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):\\n// prettier-ignore\\nconst IV = new Uint32Array([\\n    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19\\n]);\\n// Temporary buffer, not used to store anything between runs\\n// Named this way because it matches specification.\\nconst SHA256_W = new Uint32Array(64);\\nclass SHA256 extends _sha2_js__WEBPACK_IMPORTED_MODULE_0__.SHA2 {\\n    constructor() {\\n        super(64, 32, 8, false);\\n        // We cannot use array here since array allows indexing by variable\\n        // which means optimizer/compiler cannot use registers.\\n        this.A = IV[0] | 0;\\n        this.B = IV[1] | 0;\\n        this.C = IV[2] | 0;\\n        this.D = IV[3] | 0;\\n        this.E = IV[4] | 0;\\n        this.F = IV[5] | 0;\\n        this.G = IV[6] | 0;\\n        this.H = IV[7] | 0;\\n    }\\n    get() {\\n        const { A, B, C, D, E, F, G, H } = this;\\n        return [A, B, C, D, E, F, G, H];\\n    }\\n    // prettier-ignore\\n    set(A, B, C, D, E, F, G, H) {\\n        this.A = A | 0;\\n        this.B = B | 0;\\n        this.C = C | 0;\\n        this.D = D | 0;\\n        this.E = E | 0;\\n        this.F = F | 0;\\n        this.G = G | 0;\\n        this.H = H | 0;\\n    }\\n    process(view, offset) {\\n        // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array\\n        for (let i = 0; i < 16; i++, offset += 4)\\n            SHA256_W[i] = view.getUint32(offset, false);\\n        for (let i = 16; i < 64; i++) {\\n            const W15 = SHA256_W[i - 15];\\n            const W2 = SHA256_W[i - 2];\\n            const s0 = (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.rotr)(W15, 7) ^ (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.rotr)(W15, 18) ^ (W15 >>> 3);\\n            const s1 = (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.rotr)(W2, 17) ^ (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.rotr)(W2, 19) ^ (W2 >>> 10);\\n            SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) | 0;\\n        }\\n        // Compression function main loop, 64 rounds\\n        let { A, B, C, D, E, F, G, H } = this;\\n        for (let i = 0; i < 64; i++) {\\n            const sigma1 = (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.rotr)(E, 6) ^ (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.rotr)(E, 11) ^ (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.rotr)(E, 25);\\n            const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;\\n            const sigma0 = (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.rotr)(A, 2) ^ (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.rotr)(A, 13) ^ (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.rotr)(A, 22);\\n            const T2 = (sigma0 + Maj(A, B, C)) | 0;\\n            H = G;\\n            G = F;\\n            F = E;\\n            E = (D + T1) | 0;\\n            D = C;\\n            C = B;\\n            B = A;\\n            A = (T1 + T2) | 0;\\n        }\\n        // Add the compressed chunk to the current hash value\\n        A = (A + this.A) | 0;\\n        B = (B + this.B) | 0;\\n        C = (C + this.C) | 0;\\n        D = (D + this.D) | 0;\\n        E = (E + this.E) | 0;\\n        F = (F + this.F) | 0;\\n        G = (G + this.G) | 0;\\n        H = (H + this.H) | 0;\\n        this.set(A, B, C, D, E, F, G, H);\\n    }\\n    roundClean() {\\n        SHA256_W.fill(0);\\n    }\\n    destroy() {\\n        this.set(0, 0, 0, 0, 0, 0, 0, 0);\\n        this.buffer.fill(0);\\n    }\\n}\\n/**\\n * SHA2-256 hash function\\n * @param message - data that would be hashed\\n */\\nconst sha256 = (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.wrapConstructor)(() => new SHA256());\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@noble/hashes/esm/sha256.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/@noble/hashes/esm/sha3.js\":\n/*!************************************************!*\\\n  !*** ./node_modules/@noble/hashes/esm/sha3.js ***!\n  \\************************************************/\n/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"Keccak\\\": () => (/* binding */ Keccak),\\n/* harmony export */   \\\"keccakP\\\": () => (/* binding */ keccakP),\\n/* harmony export */   \\\"keccak_224\\\": () => (/* binding */ keccak_224),\\n/* harmony export */   \\\"keccak_256\\\": () => (/* binding */ keccak_256),\\n/* harmony export */   \\\"keccak_384\\\": () => (/* binding */ keccak_384),\\n/* harmony export */   \\\"keccak_512\\\": () => (/* binding */ keccak_512),\\n/* harmony export */   \\\"sha3_224\\\": () => (/* binding */ sha3_224),\\n/* harmony export */   \\\"sha3_256\\\": () => (/* binding */ sha3_256),\\n/* harmony export */   \\\"sha3_384\\\": () => (/* binding */ sha3_384),\\n/* harmony export */   \\\"sha3_512\\\": () => (/* binding */ sha3_512),\\n/* harmony export */   \\\"shake128\\\": () => (/* binding */ shake128),\\n/* harmony export */   \\\"shake256\\\": () => (/* binding */ shake256)\\n/* harmony export */ });\\n/* harmony import */ var _assert_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./_assert.js */ \\\"./node_modules/@noble/hashes/esm/_assert.js\\\");\\n/* harmony import */ var _u64_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./_u64.js */ \\\"./node_modules/@noble/hashes/esm/_u64.js\\\");\\n/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./utils.js */ \\\"./node_modules/@noble/hashes/esm/utils.js\\\");\\n\\n\\n\\n// Various per round constants calculations\\nconst [SHA3_PI, SHA3_ROTL, _SHA3_IOTA] = [[], [], []];\\nconst _0n = BigInt(0);\\nconst _1n = BigInt(1);\\nconst _2n = BigInt(2);\\nconst _7n = BigInt(7);\\nconst _256n = BigInt(256);\\nconst _0x71n = BigInt(0x71);\\nfor (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {\\n    // Pi\\n    [x, y] = [y, (2 * x + 3 * y) % 5];\\n    SHA3_PI.push(2 * (5 * y + x));\\n    // Rotational\\n    SHA3_ROTL.push((((round + 1) * (round + 2)) / 2) % 64);\\n    // Iota\\n    let t = _0n;\\n    for (let j = 0; j < 7; j++) {\\n        R = ((R << _1n) ^ ((R >> _7n) * _0x71n)) % _256n;\\n        if (R & _2n)\\n            t ^= _1n << ((_1n << BigInt(j)) - _1n);\\n    }\\n    _SHA3_IOTA.push(t);\\n}\\nconst [SHA3_IOTA_H, SHA3_IOTA_L] = _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].split(_SHA3_IOTA, true);\\n// Left rotation (without 0, 32, 64)\\nconst rotlH = (h, l, s) => s > 32 ? _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].rotlBH(h, l, s) : _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].rotlSH(h, l, s);\\nconst rotlL = (h, l, s) => s > 32 ? _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].rotlBL(h, l, s) : _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].rotlSL(h, l, s);\\n// Same as keccakf1600, but allows to skip some rounds\\nfunction keccakP(s, rounds = 24) {\\n    const B = new Uint32Array(5 * 2);\\n    // NOTE: all indices are x2 since we store state as u32 instead of u64 (bigints to slow in js)\\n    for (let round = 24 - rounds; round < 24; round++) {\\n        // Theta θ\\n        for (let x = 0; x < 10; x++)\\n            B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];\\n        for (let x = 0; x < 10; x += 2) {\\n            const idx1 = (x + 8) % 10;\\n            const idx0 = (x + 2) % 10;\\n            const B0 = B[idx0];\\n            const B1 = B[idx0 + 1];\\n            const Th = rotlH(B0, B1, 1) ^ B[idx1];\\n            const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];\\n            for (let y = 0; y < 50; y += 10) {\\n                s[x + y] ^= Th;\\n                s[x + y + 1] ^= Tl;\\n            }\\n        }\\n        // Rho (ρ) and Pi (π)\\n        let curH = s[2];\\n        let curL = s[3];\\n        for (let t = 0; t < 24; t++) {\\n            const shift = SHA3_ROTL[t];\\n            const Th = rotlH(curH, curL, shift);\\n            const Tl = rotlL(curH, curL, shift);\\n            const PI = SHA3_PI[t];\\n            curH = s[PI];\\n            curL = s[PI + 1];\\n            s[PI] = Th;\\n            s[PI + 1] = Tl;\\n        }\\n        // Chi (χ)\\n        for (let y = 0; y < 50; y += 10) {\\n            for (let x = 0; x < 10; x++)\\n                B[x] = s[y + x];\\n            for (let x = 0; x < 10; x++)\\n                s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];\\n        }\\n        // Iota (ι)\\n        s[0] ^= SHA3_IOTA_H[round];\\n        s[1] ^= SHA3_IOTA_L[round];\\n    }\\n    B.fill(0);\\n}\\nclass Keccak extends _utils_js__WEBPACK_IMPORTED_MODULE_2__.Hash {\\n    // NOTE: we accept arguments in bytes instead of bits here.\\n    constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {\\n        super();\\n        this.blockLen = blockLen;\\n        this.suffix = suffix;\\n        this.outputLen = outputLen;\\n        this.enableXOF = enableXOF;\\n        this.rounds = rounds;\\n        this.pos = 0;\\n        this.posOut = 0;\\n        this.finished = false;\\n        this.destroyed = false;\\n        // Can be passed from user as dkLen\\n        _assert_js__WEBPACK_IMPORTED_MODULE_0__[\\\"default\\\"].number(outputLen);\\n        // 1600 = 5x5 matrix of 64bit.  1600 bits === 200 bytes\\n        if (0 >= this.blockLen || this.blockLen >= 200)\\n            throw new Error('Sha3 supports only keccak-f1600 function');\\n        this.state = new Uint8Array(200);\\n        this.state32 = (0,_utils_js__WEBPACK_IMPORTED_MODULE_2__.u32)(this.state);\\n    }\\n    keccak() {\\n        keccakP(this.state32, this.rounds);\\n        this.posOut = 0;\\n        this.pos = 0;\\n    }\\n    update(data) {\\n        _assert_js__WEBPACK_IMPORTED_MODULE_0__[\\\"default\\\"].exists(this);\\n        const { blockLen, state } = this;\\n        data = (0,_utils_js__WEBPACK_IMPORTED_MODULE_2__.toBytes)(data);\\n        const len = data.length;\\n        for (let pos = 0; pos < len;) {\\n            const take = Math.min(blockLen - this.pos, len - pos);\\n            for (let i = 0; i < take; i++)\\n                state[this.pos++] ^= data[pos++];\\n            if (this.pos === blockLen)\\n                this.keccak();\\n        }\\n        return this;\\n    }\\n    finish() {\\n        if (this.finished)\\n            return;\\n        this.finished = true;\\n        const { state, suffix, pos, blockLen } = this;\\n        // Do the padding\\n        state[pos] ^= suffix;\\n        if ((suffix & 0x80) !== 0 && pos === blockLen - 1)\\n            this.keccak();\\n        state[blockLen - 1] ^= 0x80;\\n        this.keccak();\\n    }\\n    writeInto(out) {\\n        _assert_js__WEBPACK_IMPORTED_MODULE_0__[\\\"default\\\"].exists(this, false);\\n        _assert_js__WEBPACK_IMPORTED_MODULE_0__[\\\"default\\\"].bytes(out);\\n        this.finish();\\n        const bufferOut = this.state;\\n        const { blockLen } = this;\\n        for (let pos = 0, len = out.length; pos < len;) {\\n            if (this.posOut >= blockLen)\\n                this.keccak();\\n            const take = Math.min(blockLen - this.posOut, len - pos);\\n            out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);\\n            this.posOut += take;\\n            pos += take;\\n        }\\n        return out;\\n    }\\n    xofInto(out) {\\n        // Sha3/Keccak usage with XOF is probably mistake, only SHAKE instances can do XOF\\n        if (!this.enableXOF)\\n            throw new Error('XOF is not possible for this instance');\\n        return this.writeInto(out);\\n    }\\n    xof(bytes) {\\n        _assert_js__WEBPACK_IMPORTED_MODULE_0__[\\\"default\\\"].number(bytes);\\n        return this.xofInto(new Uint8Array(bytes));\\n    }\\n    digestInto(out) {\\n        _assert_js__WEBPACK_IMPORTED_MODULE_0__[\\\"default\\\"].output(out, this);\\n        if (this.finished)\\n            throw new Error('digest() was already called');\\n        this.writeInto(out);\\n        this.destroy();\\n        return out;\\n    }\\n    digest() {\\n        return this.digestInto(new Uint8Array(this.outputLen));\\n    }\\n    destroy() {\\n        this.destroyed = true;\\n        this.state.fill(0);\\n    }\\n    _cloneInto(to) {\\n        const { blockLen, suffix, outputLen, rounds, enableXOF } = this;\\n        to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, rounds));\\n        to.state32.set(this.state32);\\n        to.pos = this.pos;\\n        to.posOut = this.posOut;\\n        to.finished = this.finished;\\n        to.rounds = rounds;\\n        // Suffix can change in cSHAKE\\n        to.suffix = suffix;\\n        to.outputLen = outputLen;\\n        to.enableXOF = enableXOF;\\n        to.destroyed = this.destroyed;\\n        return to;\\n    }\\n}\\nconst gen = (suffix, blockLen, outputLen) => (0,_utils_js__WEBPACK_IMPORTED_MODULE_2__.wrapConstructor)(() => new Keccak(blockLen, suffix, outputLen));\\nconst sha3_224 = gen(0x06, 144, 224 / 8);\\n/**\\n * SHA3-256 hash function\\n * @param message - that would be hashed\\n */\\nconst sha3_256 = gen(0x06, 136, 256 / 8);\\nconst sha3_384 = gen(0x06, 104, 384 / 8);\\nconst sha3_512 = gen(0x06, 72, 512 / 8);\\nconst keccak_224 = gen(0x01, 144, 224 / 8);\\n/**\\n * keccak-256 hash function. Different from SHA3-256.\\n * @param message - that would be hashed\\n */\\nconst keccak_256 = gen(0x01, 136, 256 / 8);\\nconst keccak_384 = gen(0x01, 104, 384 / 8);\\nconst keccak_512 = gen(0x01, 72, 512 / 8);\\nconst genShake = (suffix, blockLen, outputLen) => (0,_utils_js__WEBPACK_IMPORTED_MODULE_2__.wrapConstructorWithOpts)((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === undefined ? outputLen : opts.dkLen, true));\\nconst shake128 = genShake(0x1f, 168, 128 / 8);\\nconst shake256 = genShake(0x1f, 136, 256 / 8);\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@noble/hashes/esm/sha3.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/@noble/hashes/esm/sha512.js\":\n/*!**************************************************!*\\\n  !*** ./node_modules/@noble/hashes/esm/sha512.js ***!\n  \\**************************************************/\n/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"SHA512\\\": () => (/* binding */ SHA512),\\n/* harmony export */   \\\"sha384\\\": () => (/* binding */ sha384),\\n/* harmony export */   \\\"sha512\\\": () => (/* binding */ sha512),\\n/* harmony export */   \\\"sha512_256\\\": () => (/* binding */ sha512_256)\\n/* harmony export */ });\\n/* harmony import */ var _sha2_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./_sha2.js */ \\\"./node_modules/@noble/hashes/esm/_sha2.js\\\");\\n/* harmony import */ var _u64_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./_u64.js */ \\\"./node_modules/@noble/hashes/esm/_u64.js\\\");\\n/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./utils.js */ \\\"./node_modules/@noble/hashes/esm/utils.js\\\");\\n\\n\\n\\n// Round contants (first 32 bits of the fractional parts of the cube roots of the first 80 primes 2..409):\\n// prettier-ignore\\nconst [SHA512_Kh, SHA512_Kl] = _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].split([\\n    '0x428a2f98d728ae22', '0x7137449123ef65cd', '0xb5c0fbcfec4d3b2f', '0xe9b5dba58189dbbc',\\n    '0x3956c25bf348b538', '0x59f111f1b605d019', '0x923f82a4af194f9b', '0xab1c5ed5da6d8118',\\n    '0xd807aa98a3030242', '0x12835b0145706fbe', '0x243185be4ee4b28c', '0x550c7dc3d5ffb4e2',\\n    '0x72be5d74f27b896f', '0x80deb1fe3b1696b1', '0x9bdc06a725c71235', '0xc19bf174cf692694',\\n    '0xe49b69c19ef14ad2', '0xefbe4786384f25e3', '0x0fc19dc68b8cd5b5', '0x240ca1cc77ac9c65',\\n    '0x2de92c6f592b0275', '0x4a7484aa6ea6e483', '0x5cb0a9dcbd41fbd4', '0x76f988da831153b5',\\n    '0x983e5152ee66dfab', '0xa831c66d2db43210', '0xb00327c898fb213f', '0xbf597fc7beef0ee4',\\n    '0xc6e00bf33da88fc2', '0xd5a79147930aa725', '0x06ca6351e003826f', '0x142929670a0e6e70',\\n    '0x27b70a8546d22ffc', '0x2e1b21385c26c926', '0x4d2c6dfc5ac42aed', '0x53380d139d95b3df',\\n    '0x650a73548baf63de', '0x766a0abb3c77b2a8', '0x81c2c92e47edaee6', '0x92722c851482353b',\\n    '0xa2bfe8a14cf10364', '0xa81a664bbc423001', '0xc24b8b70d0f89791', '0xc76c51a30654be30',\\n    '0xd192e819d6ef5218', '0xd69906245565a910', '0xf40e35855771202a', '0x106aa07032bbd1b8',\\n    '0x19a4c116b8d2d0c8', '0x1e376c085141ab53', '0x2748774cdf8eeb99', '0x34b0bcb5e19b48a8',\\n    '0x391c0cb3c5c95a63', '0x4ed8aa4ae3418acb', '0x5b9cca4f7763e373', '0x682e6ff3d6b2b8a3',\\n    '0x748f82ee5defb2fc', '0x78a5636f43172f60', '0x84c87814a1f0ab72', '0x8cc702081a6439ec',\\n    '0x90befffa23631e28', '0xa4506cebde82bde9', '0xbef9a3f7b2c67915', '0xc67178f2e372532b',\\n    '0xca273eceea26619c', '0xd186b8c721c0c207', '0xeada7dd6cde0eb1e', '0xf57d4f7fee6ed178',\\n    '0x06f067aa72176fba', '0x0a637dc5a2c898a6', '0x113f9804bef90dae', '0x1b710b35131c471b',\\n    '0x28db77f523047d84', '0x32caab7b40c72493', '0x3c9ebe0a15c9bebc', '0x431d67c49c100d4c',\\n    '0x4cc5d4becb3e42b6', '0x597f299cfc657e2a', '0x5fcb6fab3ad6faec', '0x6c44198c4a475817'\\n].map(n => BigInt(n)));\\n// Temporary buffer, not used to store anything between runs\\nconst SHA512_W_H = new Uint32Array(80);\\nconst SHA512_W_L = new Uint32Array(80);\\nclass SHA512 extends _sha2_js__WEBPACK_IMPORTED_MODULE_0__.SHA2 {\\n    constructor() {\\n        super(128, 64, 16, false);\\n        // We cannot use array here since array allows indexing by variable which means optimizer/compiler cannot use registers.\\n        // Also looks cleaner and easier to verify with spec.\\n        // Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):\\n        // h -- high 32 bits, l -- low 32 bits\\n        this.Ah = 0x6a09e667 | 0;\\n        this.Al = 0xf3bcc908 | 0;\\n        this.Bh = 0xbb67ae85 | 0;\\n        this.Bl = 0x84caa73b | 0;\\n        this.Ch = 0x3c6ef372 | 0;\\n        this.Cl = 0xfe94f82b | 0;\\n        this.Dh = 0xa54ff53a | 0;\\n        this.Dl = 0x5f1d36f1 | 0;\\n        this.Eh = 0x510e527f | 0;\\n        this.El = 0xade682d1 | 0;\\n        this.Fh = 0x9b05688c | 0;\\n        this.Fl = 0x2b3e6c1f | 0;\\n        this.Gh = 0x1f83d9ab | 0;\\n        this.Gl = 0xfb41bd6b | 0;\\n        this.Hh = 0x5be0cd19 | 0;\\n        this.Hl = 0x137e2179 | 0;\\n    }\\n    // prettier-ignore\\n    get() {\\n        const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;\\n        return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];\\n    }\\n    // prettier-ignore\\n    set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {\\n        this.Ah = Ah | 0;\\n        this.Al = Al | 0;\\n        this.Bh = Bh | 0;\\n        this.Bl = Bl | 0;\\n        this.Ch = Ch | 0;\\n        this.Cl = Cl | 0;\\n        this.Dh = Dh | 0;\\n        this.Dl = Dl | 0;\\n        this.Eh = Eh | 0;\\n        this.El = El | 0;\\n        this.Fh = Fh | 0;\\n        this.Fl = Fl | 0;\\n        this.Gh = Gh | 0;\\n        this.Gl = Gl | 0;\\n        this.Hh = Hh | 0;\\n        this.Hl = Hl | 0;\\n    }\\n    process(view, offset) {\\n        // Extend the first 16 words into the remaining 64 words w[16..79] of the message schedule array\\n        for (let i = 0; i < 16; i++, offset += 4) {\\n            SHA512_W_H[i] = view.getUint32(offset);\\n            SHA512_W_L[i] = view.getUint32((offset += 4));\\n        }\\n        for (let i = 16; i < 80; i++) {\\n            // s0 := (w[i-15] rightrotate 1) xor (w[i-15] rightrotate 8) xor (w[i-15] rightshift 7)\\n            const W15h = SHA512_W_H[i - 15] | 0;\\n            const W15l = SHA512_W_L[i - 15] | 0;\\n            const s0h = _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].rotrSH(W15h, W15l, 1) ^ _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].rotrSH(W15h, W15l, 8) ^ _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].shrSH(W15h, W15l, 7);\\n            const s0l = _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].rotrSL(W15h, W15l, 1) ^ _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].rotrSL(W15h, W15l, 8) ^ _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].shrSL(W15h, W15l, 7);\\n            // s1 := (w[i-2] rightrotate 19) xor (w[i-2] rightrotate 61) xor (w[i-2] rightshift 6)\\n            const W2h = SHA512_W_H[i - 2] | 0;\\n            const W2l = SHA512_W_L[i - 2] | 0;\\n            const s1h = _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].rotrSH(W2h, W2l, 19) ^ _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].rotrBH(W2h, W2l, 61) ^ _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].shrSH(W2h, W2l, 6);\\n            const s1l = _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].rotrSL(W2h, W2l, 19) ^ _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].rotrBL(W2h, W2l, 61) ^ _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].shrSL(W2h, W2l, 6);\\n            // SHA256_W[i] = s0 + s1 + SHA256_W[i - 7] + SHA256_W[i - 16];\\n            const SUMl = _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);\\n            const SUMh = _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);\\n            SHA512_W_H[i] = SUMh | 0;\\n            SHA512_W_L[i] = SUMl | 0;\\n        }\\n        let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;\\n        // Compression function main loop, 80 rounds\\n        for (let i = 0; i < 80; i++) {\\n            // S1 := (e rightrotate 14) xor (e rightrotate 18) xor (e rightrotate 41)\\n            const sigma1h = _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].rotrSH(Eh, El, 14) ^ _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].rotrSH(Eh, El, 18) ^ _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].rotrBH(Eh, El, 41);\\n            const sigma1l = _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].rotrSL(Eh, El, 14) ^ _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].rotrSL(Eh, El, 18) ^ _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].rotrBL(Eh, El, 41);\\n            //const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;\\n            const CHIh = (Eh & Fh) ^ (~Eh & Gh);\\n            const CHIl = (El & Fl) ^ (~El & Gl);\\n            // T1 = H + sigma1 + Chi(E, F, G) + SHA512_K[i] + SHA512_W[i]\\n            // prettier-ignore\\n            const T1ll = _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);\\n            const T1h = _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);\\n            const T1l = T1ll | 0;\\n            // S0 := (a rightrotate 28) xor (a rightrotate 34) xor (a rightrotate 39)\\n            const sigma0h = _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].rotrSH(Ah, Al, 28) ^ _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].rotrBH(Ah, Al, 34) ^ _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].rotrBH(Ah, Al, 39);\\n            const sigma0l = _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].rotrSL(Ah, Al, 28) ^ _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].rotrBL(Ah, Al, 34) ^ _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].rotrBL(Ah, Al, 39);\\n            const MAJh = (Ah & Bh) ^ (Ah & Ch) ^ (Bh & Ch);\\n            const MAJl = (Al & Bl) ^ (Al & Cl) ^ (Bl & Cl);\\n            Hh = Gh | 0;\\n            Hl = Gl | 0;\\n            Gh = Fh | 0;\\n            Gl = Fl | 0;\\n            Fh = Eh | 0;\\n            Fl = El | 0;\\n            ({ h: Eh, l: El } = _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));\\n            Dh = Ch | 0;\\n            Dl = Cl | 0;\\n            Ch = Bh | 0;\\n            Cl = Bl | 0;\\n            Bh = Ah | 0;\\n            Bl = Al | 0;\\n            const All = _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].add3L(T1l, sigma0l, MAJl);\\n            Ah = _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].add3H(All, T1h, sigma0h, MAJh);\\n            Al = All | 0;\\n        }\\n        // Add the compressed chunk to the current hash value\\n        ({ h: Ah, l: Al } = _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));\\n        ({ h: Bh, l: Bl } = _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));\\n        ({ h: Ch, l: Cl } = _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));\\n        ({ h: Dh, l: Dl } = _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));\\n        ({ h: Eh, l: El } = _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));\\n        ({ h: Fh, l: Fl } = _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));\\n        ({ h: Gh, l: Gl } = _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));\\n        ({ h: Hh, l: Hl } = _u64_js__WEBPACK_IMPORTED_MODULE_1__[\\\"default\\\"].add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));\\n        this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);\\n    }\\n    roundClean() {\\n        SHA512_W_H.fill(0);\\n        SHA512_W_L.fill(0);\\n    }\\n    destroy() {\\n        this.buffer.fill(0);\\n        this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);\\n    }\\n}\\nclass SHA512_256 extends SHA512 {\\n    constructor() {\\n        super();\\n        // h -- high 32 bits, l -- low 32 bits\\n        this.Ah = 0x22312194 | 0;\\n        this.Al = 0xfc2bf72c | 0;\\n        this.Bh = 0x9f555fa3 | 0;\\n        this.Bl = 0xc84c64c2 | 0;\\n        this.Ch = 0x2393b86b | 0;\\n        this.Cl = 0x6f53b151 | 0;\\n        this.Dh = 0x96387719 | 0;\\n        this.Dl = 0x5940eabd | 0;\\n        this.Eh = 0x96283ee2 | 0;\\n        this.El = 0xa88effe3 | 0;\\n        this.Fh = 0xbe5e1e25 | 0;\\n        this.Fl = 0x53863992 | 0;\\n        this.Gh = 0x2b0199fc | 0;\\n        this.Gl = 0x2c85b8aa | 0;\\n        this.Hh = 0x0eb72ddc | 0;\\n        this.Hl = 0x81c52ca2 | 0;\\n        this.outputLen = 32;\\n    }\\n}\\nclass SHA384 extends SHA512 {\\n    constructor() {\\n        super();\\n        // h -- high 32 bits, l -- low 32 bits\\n        this.Ah = 0xcbbb9d5d | 0;\\n        this.Al = 0xc1059ed8 | 0;\\n        this.Bh = 0x629a292a | 0;\\n        this.Bl = 0x367cd507 | 0;\\n        this.Ch = 0x9159015a | 0;\\n        this.Cl = 0x3070dd17 | 0;\\n        this.Dh = 0x152fecd8 | 0;\\n        this.Dl = 0xf70e5939 | 0;\\n        this.Eh = 0x67332667 | 0;\\n        this.El = 0xffc00b31 | 0;\\n        this.Fh = 0x8eb44a87 | 0;\\n        this.Fl = 0x68581511 | 0;\\n        this.Gh = 0xdb0c2e0d | 0;\\n        this.Gl = 0x64f98fa7 | 0;\\n        this.Hh = 0x47b5481d | 0;\\n        this.Hl = 0xbefa4fa4 | 0;\\n        this.outputLen = 48;\\n    }\\n}\\nconst sha512 = (0,_utils_js__WEBPACK_IMPORTED_MODULE_2__.wrapConstructor)(() => new SHA512());\\nconst sha512_256 = (0,_utils_js__WEBPACK_IMPORTED_MODULE_2__.wrapConstructor)(() => new SHA512_256());\\nconst sha384 = (0,_utils_js__WEBPACK_IMPORTED_MODULE_2__.wrapConstructor)(() => new SHA384());\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@noble/hashes/esm/sha512.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/@noble/hashes/esm/utils.js\":\n/*!*************************************************!*\\\n  !*** ./node_modules/@noble/hashes/esm/utils.js ***!\n  \\*************************************************/\n/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"Hash\\\": () => (/* binding */ Hash),\\n/* harmony export */   \\\"asyncLoop\\\": () => (/* binding */ asyncLoop),\\n/* harmony export */   \\\"bytesToHex\\\": () => (/* binding */ bytesToHex),\\n/* harmony export */   \\\"checkOpts\\\": () => (/* binding */ checkOpts),\\n/* harmony export */   \\\"concatBytes\\\": () => (/* binding */ concatBytes),\\n/* harmony export */   \\\"createView\\\": () => (/* binding */ createView),\\n/* harmony export */   \\\"hexToBytes\\\": () => (/* binding */ hexToBytes),\\n/* harmony export */   \\\"isLE\\\": () => (/* binding */ isLE),\\n/* harmony export */   \\\"nextTick\\\": () => (/* binding */ nextTick),\\n/* harmony export */   \\\"randomBytes\\\": () => (/* binding */ randomBytes),\\n/* harmony export */   \\\"rotr\\\": () => (/* binding */ rotr),\\n/* harmony export */   \\\"toBytes\\\": () => (/* binding */ toBytes),\\n/* harmony export */   \\\"u32\\\": () => (/* binding */ u32),\\n/* harmony export */   \\\"u8\\\": () => (/* binding */ u8),\\n/* harmony export */   \\\"utf8ToBytes\\\": () => (/* binding */ utf8ToBytes),\\n/* harmony export */   \\\"wrapConstructor\\\": () => (/* binding */ wrapConstructor),\\n/* harmony export */   \\\"wrapConstructorWithOpts\\\": () => (/* binding */ wrapConstructorWithOpts)\\n/* harmony export */ });\\n/* harmony import */ var _noble_hashes_crypto__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @noble/hashes/crypto */ \\\"./node_modules/@noble/hashes/esm/cryptoBrowser.js\\\");\\n/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */\\n// The import here is via the package name. This is to ensure\\n// that exports mapping/resolution does fall into place.\\n\\n// Cast array to different type\\nconst u8 = (arr) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\\nconst u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));\\n// Cast array to view\\nconst createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\\n// The rotate right (circular right shift) operation for uint32\\nconst rotr = (word, shift) => (word << (32 - shift)) | (word >>> shift);\\nconst isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;\\n// There is almost no big endian hardware, but js typed arrays uses platform specific endianness.\\n// So, just to be sure not to corrupt anything.\\nif (!isLE)\\n    throw new Error('Non little-endian hardware is not supported');\\nconst hexes = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, '0'));\\n/**\\n * @example bytesToHex(Uint8Array.from([0xde, 0xad, 0xbe, 0xef]))\\n */\\nfunction bytesToHex(uint8a) {\\n    // pre-caching improves the speed 6x\\n    if (!(uint8a instanceof Uint8Array))\\n        throw new Error('Uint8Array expected');\\n    let hex = '';\\n    for (let i = 0; i < uint8a.length; i++) {\\n        hex += hexes[uint8a[i]];\\n    }\\n    return hex;\\n}\\n/**\\n * @example hexToBytes('deadbeef')\\n */\\nfunction hexToBytes(hex) {\\n    if (typeof hex !== 'string') {\\n        throw new TypeError('hexToBytes: expected string, got ' + typeof hex);\\n    }\\n    if (hex.length % 2)\\n        throw new Error('hexToBytes: received invalid unpadded hex');\\n    const array = new Uint8Array(hex.length / 2);\\n    for (let i = 0; i < array.length; i++) {\\n        const j = i * 2;\\n        const hexByte = hex.slice(j, j + 2);\\n        const byte = Number.parseInt(hexByte, 16);\\n        if (Number.isNaN(byte) || byte < 0)\\n            throw new Error('Invalid byte sequence');\\n        array[i] = byte;\\n    }\\n    return array;\\n}\\n// There is no setImmediate in browser and setTimeout is slow. However, call to async function will return Promise\\n// which will be fullfiled only on next scheduler queue processing step and this is exactly what we need.\\nconst nextTick = async () => { };\\n// Returns control to thread each 'tick' ms to avoid blocking\\nasync function asyncLoop(iters, tick, cb) {\\n    let ts = Date.now();\\n    for (let i = 0; i < iters; i++) {\\n        cb(i);\\n        // Date.now() is not monotonic, so in case if clock goes backwards we return return control too\\n        const diff = Date.now() - ts;\\n        if (diff >= 0 && diff < tick)\\n            continue;\\n        await nextTick();\\n        ts += diff;\\n    }\\n}\\nfunction utf8ToBytes(str) {\\n    if (typeof str !== 'string') {\\n        throw new TypeError(`utf8ToBytes expected string, got ${typeof str}`);\\n    }\\n    return new TextEncoder().encode(str);\\n}\\nfunction toBytes(data) {\\n    if (typeof data === 'string')\\n        data = utf8ToBytes(data);\\n    if (!(data instanceof Uint8Array))\\n        throw new TypeError(`Expected input type is Uint8Array (got ${typeof data})`);\\n    return data;\\n}\\n/**\\n * Concats Uint8Array-s into one; like `Buffer.concat([buf1, buf2])`\\n * @example concatBytes(buf1, buf2)\\n */\\nfunction concatBytes(...arrays) {\\n    if (!arrays.every((a) => a instanceof Uint8Array))\\n        throw new Error('Uint8Array list expected');\\n    if (arrays.length === 1)\\n        return arrays[0];\\n    const length = arrays.reduce((a, arr) => a + arr.length, 0);\\n    const result = new Uint8Array(length);\\n    for (let i = 0, pad = 0; i < arrays.length; i++) {\\n        const arr = arrays[i];\\n        result.set(arr, pad);\\n        pad += arr.length;\\n    }\\n    return result;\\n}\\n// For runtime check if class implements interface\\nclass Hash {\\n    // Safe version that clones internal state\\n    clone() {\\n        return this._cloneInto();\\n    }\\n}\\n// Check if object doens't have custom constructor (like Uint8Array/Array)\\nconst isPlainObject = (obj) => Object.prototype.toString.call(obj) === '[object Object]' && obj.constructor === Object;\\nfunction checkOpts(defaults, opts) {\\n    if (opts !== undefined && (typeof opts !== 'object' || !isPlainObject(opts)))\\n        throw new TypeError('Options should be object or undefined');\\n    const merged = Object.assign(defaults, opts);\\n    return merged;\\n}\\nfunction wrapConstructor(hashConstructor) {\\n    const hashC = (message) => hashConstructor().update(toBytes(message)).digest();\\n    const tmp = hashConstructor();\\n    hashC.outputLen = tmp.outputLen;\\n    hashC.blockLen = tmp.blockLen;\\n    hashC.create = () => hashConstructor();\\n    return hashC;\\n}\\nfunction wrapConstructorWithOpts(hashCons) {\\n    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\\n    const tmp = hashCons({});\\n    hashC.outputLen = tmp.outputLen;\\n    hashC.blockLen = tmp.blockLen;\\n    hashC.create = (opts) => hashCons(opts);\\n    return hashC;\\n}\\n/**\\n * Secure PRNG\\n */\\nfunction randomBytes(bytesLength = 32) {\\n    if (_noble_hashes_crypto__WEBPACK_IMPORTED_MODULE_0__.crypto.web) {\\n        return _noble_hashes_crypto__WEBPACK_IMPORTED_MODULE_0__.crypto.web.getRandomValues(new Uint8Array(bytesLength));\\n    }\\n    else if (_noble_hashes_crypto__WEBPACK_IMPORTED_MODULE_0__.crypto.node) {\\n        return new Uint8Array(_noble_hashes_crypto__WEBPACK_IMPORTED_MODULE_0__.crypto.node.randomBytes(bytesLength).buffer);\\n    }\\n    else {\\n        throw new Error(\\\"The environment doesn't have randomBytes function\\\");\\n    }\\n}\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@noble/hashes/esm/utils.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/@noble/secp256k1/lib/esm/index.js\":\n/*!********************************************************!*\\\n  !*** ./node_modules/@noble/secp256k1/lib/esm/index.js ***!\n  \\********************************************************/\n/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"var crypto__WEBPACK_IMPORTED_MODULE_0___namespace_cache;\\n__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"CURVE\\\": () => (/* binding */ CURVE),\\n/* harmony export */   \\\"Point\\\": () => (/* binding */ Point),\\n/* harmony export */   \\\"Signature\\\": () => (/* binding */ Signature),\\n/* harmony export */   \\\"getPublicKey\\\": () => (/* binding */ getPublicKey),\\n/* harmony export */   \\\"getSharedSecret\\\": () => (/* binding */ getSharedSecret),\\n/* harmony export */   \\\"recoverPublicKey\\\": () => (/* binding */ recoverPublicKey),\\n/* harmony export */   \\\"schnorr\\\": () => (/* binding */ schnorr),\\n/* harmony export */   \\\"sign\\\": () => (/* binding */ sign),\\n/* harmony export */   \\\"signSync\\\": () => (/* binding */ signSync),\\n/* harmony export */   \\\"utils\\\": () => (/* binding */ utils),\\n/* harmony export */   \\\"verify\\\": () => (/* binding */ verify)\\n/* harmony export */ });\\n/* harmony import */ var crypto__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! crypto */ \\\"?ce41\\\");\\n/*! noble-secp256k1 - MIT License (c) 2019 Paul Miller (paulmillr.com) */\\n\\nconst _0n = BigInt(0);\\nconst _1n = BigInt(1);\\nconst _2n = BigInt(2);\\nconst _3n = BigInt(3);\\nconst _8n = BigInt(8);\\nconst CURVE = Object.freeze({\\n    a: _0n,\\n    b: BigInt(7),\\n    P: BigInt('0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f'),\\n    n: BigInt('0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141'),\\n    h: _1n,\\n    Gx: BigInt('55066263022277343669578718895168534326250603453777594175500187360389116729240'),\\n    Gy: BigInt('32670510020758816978083085130507043184471273380659243275938904335757337482424'),\\n    beta: BigInt('0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee'),\\n});\\n\\nfunction weistrass(x) {\\n    const { a, b } = CURVE;\\n    const x2 = mod(x * x);\\n    const x3 = mod(x2 * x);\\n    return mod(x3 + a * x + b);\\n}\\nconst USE_ENDOMORPHISM = CURVE.a === _0n;\\nclass ShaError extends Error {\\n    constructor(message) {\\n        super(message);\\n    }\\n}\\nclass JacobianPoint {\\n    constructor(x, y, z) {\\n        this.x = x;\\n        this.y = y;\\n        this.z = z;\\n    }\\n    static fromAffine(p) {\\n        if (!(p instanceof Point)) {\\n            throw new TypeError('JacobianPoint#fromAffine: expected Point');\\n        }\\n        return new JacobianPoint(p.x, p.y, _1n);\\n    }\\n    static toAffineBatch(points) {\\n        const toInv = invertBatch(points.map((p) => p.z));\\n        return points.map((p, i) => p.toAffine(toInv[i]));\\n    }\\n    static normalizeZ(points) {\\n        return JacobianPoint.toAffineBatch(points).map(JacobianPoint.fromAffine);\\n    }\\n    equals(other) {\\n        if (!(other instanceof JacobianPoint))\\n            throw new TypeError('JacobianPoint expected');\\n        const { x: X1, y: Y1, z: Z1 } = this;\\n        const { x: X2, y: Y2, z: Z2 } = other;\\n        const Z1Z1 = mod(Z1 * Z1);\\n        const Z2Z2 = mod(Z2 * Z2);\\n        const U1 = mod(X1 * Z2Z2);\\n        const U2 = mod(X2 * Z1Z1);\\n        const S1 = mod(mod(Y1 * Z2) * Z2Z2);\\n        const S2 = mod(mod(Y2 * Z1) * Z1Z1);\\n        return U1 === U2 && S1 === S2;\\n    }\\n    negate() {\\n        return new JacobianPoint(this.x, mod(-this.y), this.z);\\n    }\\n    double() {\\n        const { x: X1, y: Y1, z: Z1 } = this;\\n        const A = mod(X1 * X1);\\n        const B = mod(Y1 * Y1);\\n        const C = mod(B * B);\\n        const x1b = X1 + B;\\n        const D = mod(_2n * (mod(x1b * x1b) - A - C));\\n        const E = mod(_3n * A);\\n        const F = mod(E * E);\\n        const X3 = mod(F - _2n * D);\\n        const Y3 = mod(E * (D - X3) - _8n * C);\\n        const Z3 = mod(_2n * Y1 * Z1);\\n        return new JacobianPoint(X3, Y3, Z3);\\n    }\\n    add(other) {\\n        if (!(other instanceof JacobianPoint))\\n            throw new TypeError('JacobianPoint expected');\\n        const { x: X1, y: Y1, z: Z1 } = this;\\n        const { x: X2, y: Y2, z: Z2 } = other;\\n        if (X2 === _0n || Y2 === _0n)\\n            return this;\\n        if (X1 === _0n || Y1 === _0n)\\n            return other;\\n        const Z1Z1 = mod(Z1 * Z1);\\n        const Z2Z2 = mod(Z2 * Z2);\\n        const U1 = mod(X1 * Z2Z2);\\n        const U2 = mod(X2 * Z1Z1);\\n        const S1 = mod(mod(Y1 * Z2) * Z2Z2);\\n        const S2 = mod(mod(Y2 * Z1) * Z1Z1);\\n        const H = mod(U2 - U1);\\n        const r = mod(S2 - S1);\\n        if (H === _0n) {\\n            if (r === _0n) {\\n                return this.double();\\n            }\\n            else {\\n                return JacobianPoint.ZERO;\\n            }\\n        }\\n        const HH = mod(H * H);\\n        const HHH = mod(H * HH);\\n        const V = mod(U1 * HH);\\n        const X3 = mod(r * r - HHH - _2n * V);\\n        const Y3 = mod(r * (V - X3) - S1 * HHH);\\n        const Z3 = mod(Z1 * Z2 * H);\\n        return new JacobianPoint(X3, Y3, Z3);\\n    }\\n    subtract(other) {\\n        return this.add(other.negate());\\n    }\\n    multiplyUnsafe(scalar) {\\n        const P0 = JacobianPoint.ZERO;\\n        if (typeof scalar === 'bigint' && scalar === _0n)\\n            return P0;\\n        let n = normalizeScalar(scalar);\\n        if (n === _1n)\\n            return this;\\n        if (!USE_ENDOMORPHISM) {\\n            let p = P0;\\n            let d = this;\\n            while (n > _0n) {\\n                if (n & _1n)\\n                    p = p.add(d);\\n                d = d.double();\\n                n >>= _1n;\\n            }\\n            return p;\\n        }\\n        let { k1neg, k1, k2neg, k2 } = splitScalarEndo(n);\\n        let k1p = P0;\\n        let k2p = P0;\\n        let d = this;\\n        while (k1 > _0n || k2 > _0n) {\\n            if (k1 & _1n)\\n                k1p = k1p.add(d);\\n            if (k2 & _1n)\\n                k2p = k2p.add(d);\\n            d = d.double();\\n            k1 >>= _1n;\\n            k2 >>= _1n;\\n        }\\n        if (k1neg)\\n            k1p = k1p.negate();\\n        if (k2neg)\\n            k2p = k2p.negate();\\n        k2p = new JacobianPoint(mod(k2p.x * CURVE.beta), k2p.y, k2p.z);\\n        return k1p.add(k2p);\\n    }\\n    precomputeWindow(W) {\\n        const windows = USE_ENDOMORPHISM ? 128 / W + 1 : 256 / W + 1;\\n        const points = [];\\n        let p = this;\\n        let base = p;\\n        for (let window = 0; window < windows; window++) {\\n            base = p;\\n            points.push(base);\\n            for (let i = 1; i < 2 ** (W - 1); i++) {\\n                base = base.add(p);\\n                points.push(base);\\n            }\\n            p = base.double();\\n        }\\n        return points;\\n    }\\n    wNAF(n, affinePoint) {\\n        if (!affinePoint && this.equals(JacobianPoint.BASE))\\n            affinePoint = Point.BASE;\\n        const W = (affinePoint && affinePoint._WINDOW_SIZE) || 1;\\n        if (256 % W) {\\n            throw new Error('Point#wNAF: Invalid precomputation window, must be power of 2');\\n        }\\n        let precomputes = affinePoint && pointPrecomputes.get(affinePoint);\\n        if (!precomputes) {\\n            precomputes = this.precomputeWindow(W);\\n            if (affinePoint && W !== 1) {\\n                precomputes = JacobianPoint.normalizeZ(precomputes);\\n                pointPrecomputes.set(affinePoint, precomputes);\\n            }\\n        }\\n        let p = JacobianPoint.ZERO;\\n        let f = JacobianPoint.ZERO;\\n        const windows = 1 + (USE_ENDOMORPHISM ? 128 / W : 256 / W);\\n        const windowSize = 2 ** (W - 1);\\n        const mask = BigInt(2 ** W - 1);\\n        const maxNumber = 2 ** W;\\n        const shiftBy = BigInt(W);\\n        for (let window = 0; window < windows; window++) {\\n            const offset = window * windowSize;\\n            let wbits = Number(n & mask);\\n            n >>= shiftBy;\\n            if (wbits > windowSize) {\\n                wbits -= maxNumber;\\n                n += _1n;\\n            }\\n            if (wbits === 0) {\\n                let pr = precomputes[offset];\\n                if (window % 2)\\n                    pr = pr.negate();\\n                f = f.add(pr);\\n            }\\n            else {\\n                let cached = precomputes[offset + Math.abs(wbits) - 1];\\n                if (wbits < 0)\\n                    cached = cached.negate();\\n                p = p.add(cached);\\n            }\\n        }\\n        return { p, f };\\n    }\\n    multiply(scalar, affinePoint) {\\n        let n = normalizeScalar(scalar);\\n        let point;\\n        let fake;\\n        if (USE_ENDOMORPHISM) {\\n            const { k1neg, k1, k2neg, k2 } = splitScalarEndo(n);\\n            let { p: k1p, f: f1p } = this.wNAF(k1, affinePoint);\\n            let { p: k2p, f: f2p } = this.wNAF(k2, affinePoint);\\n            if (k1neg)\\n                k1p = k1p.negate();\\n            if (k2neg)\\n                k2p = k2p.negate();\\n            k2p = new JacobianPoint(mod(k2p.x * CURVE.beta), k2p.y, k2p.z);\\n            point = k1p.add(k2p);\\n            fake = f1p.add(f2p);\\n        }\\n        else {\\n            const { p, f } = this.wNAF(n, affinePoint);\\n            point = p;\\n            fake = f;\\n        }\\n        return JacobianPoint.normalizeZ([point, fake])[0];\\n    }\\n    toAffine(invZ = invert(this.z)) {\\n        const { x, y, z } = this;\\n        const iz1 = invZ;\\n        const iz2 = mod(iz1 * iz1);\\n        const iz3 = mod(iz2 * iz1);\\n        const ax = mod(x * iz2);\\n        const ay = mod(y * iz3);\\n        const zz = mod(z * iz1);\\n        if (zz !== _1n)\\n            throw new Error('invZ was invalid');\\n        return new Point(ax, ay);\\n    }\\n}\\nJacobianPoint.BASE = new JacobianPoint(CURVE.Gx, CURVE.Gy, _1n);\\nJacobianPoint.ZERO = new JacobianPoint(_0n, _1n, _0n);\\nconst pointPrecomputes = new WeakMap();\\nclass Point {\\n    constructor(x, y) {\\n        this.x = x;\\n        this.y = y;\\n    }\\n    _setWindowSize(windowSize) {\\n        this._WINDOW_SIZE = windowSize;\\n        pointPrecomputes.delete(this);\\n    }\\n    hasEvenY() {\\n        return this.y % _2n === _0n;\\n    }\\n    static fromCompressedHex(bytes) {\\n        const isShort = bytes.length === 32;\\n        const x = bytesToNumber(isShort ? bytes : bytes.subarray(1));\\n        if (!isValidFieldElement(x))\\n            throw new Error('Point is not on curve');\\n        const y2 = weistrass(x);\\n        let y = sqrtMod(y2);\\n        const isYOdd = (y & _1n) === _1n;\\n        if (isShort) {\\n            if (isYOdd)\\n                y = mod(-y);\\n        }\\n        else {\\n            const isFirstByteOdd = (bytes[0] & 1) === 1;\\n            if (isFirstByteOdd !== isYOdd)\\n                y = mod(-y);\\n        }\\n        const point = new Point(x, y);\\n        point.assertValidity();\\n        return point;\\n    }\\n    static fromUncompressedHex(bytes) {\\n        const x = bytesToNumber(bytes.subarray(1, 33));\\n        const y = bytesToNumber(bytes.subarray(33, 65));\\n        const point = new Point(x, y);\\n        point.assertValidity();\\n        return point;\\n    }\\n    static fromHex(hex) {\\n        const bytes = ensureBytes(hex);\\n        const len = bytes.length;\\n        const header = bytes[0];\\n        if (len === 32 || (len === 33 && (header === 0x02 || header === 0x03))) {\\n            return this.fromCompressedHex(bytes);\\n        }\\n        if (len === 65 && header === 0x04)\\n            return this.fromUncompressedHex(bytes);\\n        throw new Error(`Point.fromHex: received invalid point. Expected 32-33 compressed bytes or 65 uncompressed bytes, not ${len}`);\\n    }\\n    static fromPrivateKey(privateKey) {\\n        return Point.BASE.multiply(normalizePrivateKey(privateKey));\\n    }\\n    static fromSignature(msgHash, signature, recovery) {\\n        msgHash = ensureBytes(msgHash);\\n        const h = truncateHash(msgHash);\\n        const { r, s } = normalizeSignature(signature);\\n        if (recovery !== 0 && recovery !== 1) {\\n            throw new Error('Cannot recover signature: invalid recovery bit');\\n        }\\n        const prefix = recovery & 1 ? '03' : '02';\\n        const R = Point.fromHex(prefix + numTo32bStr(r));\\n        const { n } = CURVE;\\n        const rinv = invert(r, n);\\n        const u1 = mod(-h * rinv, n);\\n        const u2 = mod(s * rinv, n);\\n        const Q = Point.BASE.multiplyAndAddUnsafe(R, u1, u2);\\n        if (!Q)\\n            throw new Error('Cannot recover signature: point at infinify');\\n        Q.assertValidity();\\n        return Q;\\n    }\\n    toRawBytes(isCompressed = false) {\\n        return hexToBytes(this.toHex(isCompressed));\\n    }\\n    toHex(isCompressed = false) {\\n        const x = numTo32bStr(this.x);\\n        if (isCompressed) {\\n            const prefix = this.hasEvenY() ? '02' : '03';\\n            return `${prefix}${x}`;\\n        }\\n        else {\\n            return `04${x}${numTo32bStr(this.y)}`;\\n        }\\n    }\\n    toHexX() {\\n        return this.toHex(true).slice(2);\\n    }\\n    toRawX() {\\n        return this.toRawBytes(true).slice(1);\\n    }\\n    assertValidity() {\\n        const msg = 'Point is not on elliptic curve';\\n        const { x, y } = this;\\n        if (!isValidFieldElement(x) || !isValidFieldElement(y))\\n            throw new Error(msg);\\n        const left = mod(y * y);\\n        const right = weistrass(x);\\n        if (mod(left - right) !== _0n)\\n            throw new Error(msg);\\n    }\\n    equals(other) {\\n        return this.x === other.x && this.y === other.y;\\n    }\\n    negate() {\\n        return new Point(this.x, mod(-this.y));\\n    }\\n    double() {\\n        return JacobianPoint.fromAffine(this).double().toAffine();\\n    }\\n    add(other) {\\n        return JacobianPoint.fromAffine(this).add(JacobianPoint.fromAffine(other)).toAffine();\\n    }\\n    subtract(other) {\\n        return this.add(other.negate());\\n    }\\n    multiply(scalar) {\\n        return JacobianPoint.fromAffine(this).multiply(scalar, this).toAffine();\\n    }\\n    multiplyAndAddUnsafe(Q, a, b) {\\n        const P = JacobianPoint.fromAffine(this);\\n        const aP = a === _0n || a === _1n || this !== Point.BASE ? P.multiplyUnsafe(a) : P.multiply(a);\\n        const bQ = JacobianPoint.fromAffine(Q).multiplyUnsafe(b);\\n        const sum = aP.add(bQ);\\n        return sum.equals(JacobianPoint.ZERO) ? undefined : sum.toAffine();\\n    }\\n}\\nPoint.BASE = new Point(CURVE.Gx, CURVE.Gy);\\nPoint.ZERO = new Point(_0n, _0n);\\nfunction sliceDER(s) {\\n    return Number.parseInt(s[0], 16) >= 8 ? '00' + s : s;\\n}\\nfunction parseDERInt(data) {\\n    if (data.length < 2 || data[0] !== 0x02) {\\n        throw new Error(`Invalid signature integer tag: ${bytesToHex(data)}`);\\n    }\\n    const len = data[1];\\n    const res = data.subarray(2, len + 2);\\n    if (!len || res.length !== len) {\\n        throw new Error(`Invalid signature integer: wrong length`);\\n    }\\n    if (res[0] === 0x00 && res[1] <= 0x7f) {\\n        throw new Error('Invalid signature integer: trailing length');\\n    }\\n    return { data: bytesToNumber(res), left: data.subarray(len + 2) };\\n}\\nfunction parseDERSignature(data) {\\n    if (data.length < 2 || data[0] != 0x30) {\\n        throw new Error(`Invalid signature tag: ${bytesToHex(data)}`);\\n    }\\n    if (data[1] !== data.length - 2) {\\n        throw new Error('Invalid signature: incorrect length');\\n    }\\n    const { data: r, left: sBytes } = parseDERInt(data.subarray(2));\\n    const { data: s, left: rBytesLeft } = parseDERInt(sBytes);\\n    if (rBytesLeft.length) {\\n        throw new Error(`Invalid signature: left bytes after parsing: ${bytesToHex(rBytesLeft)}`);\\n    }\\n    return { r, s };\\n}\\nclass Signature {\\n    constructor(r, s) {\\n        this.r = r;\\n        this.s = s;\\n        this.assertValidity();\\n    }\\n    static fromCompact(hex) {\\n        const arr = hex instanceof Uint8Array;\\n        const name = 'Signature.fromCompact';\\n        if (typeof hex !== 'string' && !arr)\\n            throw new TypeError(`${name}: Expected string or Uint8Array`);\\n        const str = arr ? bytesToHex(hex) : hex;\\n        if (str.length !== 128)\\n            throw new Error(`${name}: Expected 64-byte hex`);\\n        return new Signature(hexToNumber(str.slice(0, 64)), hexToNumber(str.slice(64, 128)));\\n    }\\n    static fromDER(hex) {\\n        const arr = hex instanceof Uint8Array;\\n        if (typeof hex !== 'string' && !arr)\\n            throw new TypeError(`Signature.fromDER: Expected string or Uint8Array`);\\n        const { r, s } = parseDERSignature(arr ? hex : hexToBytes(hex));\\n        return new Signature(r, s);\\n    }\\n    static fromHex(hex) {\\n        return this.fromDER(hex);\\n    }\\n    assertValidity() {\\n        const { r, s } = this;\\n        if (!isWithinCurveOrder(r))\\n            throw new Error('Invalid Signature: r must be 0 < r < n');\\n        if (!isWithinCurveOrder(s))\\n            throw new Error('Invalid Signature: s must be 0 < s < n');\\n    }\\n    hasHighS() {\\n        const HALF = CURVE.n >> _1n;\\n        return this.s > HALF;\\n    }\\n    normalizeS() {\\n        return this.hasHighS() ? new Signature(this.r, CURVE.n - this.s) : this;\\n    }\\n    toDERRawBytes(isCompressed = false) {\\n        return hexToBytes(this.toDERHex(isCompressed));\\n    }\\n    toDERHex(isCompressed = false) {\\n        const sHex = sliceDER(numberToHexUnpadded(this.s));\\n        if (isCompressed)\\n            return sHex;\\n        const rHex = sliceDER(numberToHexUnpadded(this.r));\\n        const rLen = numberToHexUnpadded(rHex.length / 2);\\n        const sLen = numberToHexUnpadded(sHex.length / 2);\\n        const length = numberToHexUnpadded(rHex.length / 2 + sHex.length / 2 + 4);\\n        return `30${length}02${rLen}${rHex}02${sLen}${sHex}`;\\n    }\\n    toRawBytes() {\\n        return this.toDERRawBytes();\\n    }\\n    toHex() {\\n        return this.toDERHex();\\n    }\\n    toCompactRawBytes() {\\n        return hexToBytes(this.toCompactHex());\\n    }\\n    toCompactHex() {\\n        return numTo32bStr(this.r) + numTo32bStr(this.s);\\n    }\\n}\\nfunction concatBytes(...arrays) {\\n    if (!arrays.every((b) => b instanceof Uint8Array))\\n        throw new Error('Uint8Array list expected');\\n    if (arrays.length === 1)\\n        return arrays[0];\\n    const length = arrays.reduce((a, arr) => a + arr.length, 0);\\n    const result = new Uint8Array(length);\\n    for (let i = 0, pad = 0; i < arrays.length; i++) {\\n        const arr = arrays[i];\\n        result.set(arr, pad);\\n        pad += arr.length;\\n    }\\n    return result;\\n}\\nconst hexes = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, '0'));\\nfunction bytesToHex(uint8a) {\\n    if (!(uint8a instanceof Uint8Array))\\n        throw new Error('Expected Uint8Array');\\n    let hex = '';\\n    for (let i = 0; i < uint8a.length; i++) {\\n        hex += hexes[uint8a[i]];\\n    }\\n    return hex;\\n}\\nconst POW_2_256 = BigInt('0x10000000000000000000000000000000000000000000000000000000000000000');\\nfunction numTo32bStr(num) {\\n    if (typeof num !== 'bigint')\\n        throw new Error('Expected bigint');\\n    if (!(_0n <= num && num < POW_2_256))\\n        throw new Error('Expected number < 2^256');\\n    return num.toString(16).padStart(64, '0');\\n}\\nfunction numTo32b(num) {\\n    const b = hexToBytes(numTo32bStr(num));\\n    if (b.length !== 32)\\n        throw new Error('Error: expected 32 bytes');\\n    return b;\\n}\\nfunction numberToHexUnpadded(num) {\\n    const hex = num.toString(16);\\n    return hex.length & 1 ? `0${hex}` : hex;\\n}\\nfunction hexToNumber(hex) {\\n    if (typeof hex !== 'string') {\\n        throw new TypeError('hexToNumber: expected string, got ' + typeof hex);\\n    }\\n    return BigInt(`0x${hex}`);\\n}\\nfunction hexToBytes(hex) {\\n    if (typeof hex !== 'string') {\\n        throw new TypeError('hexToBytes: expected string, got ' + typeof hex);\\n    }\\n    if (hex.length % 2)\\n        throw new Error('hexToBytes: received invalid unpadded hex' + hex.length);\\n    const array = new Uint8Array(hex.length / 2);\\n    for (let i = 0; i < array.length; i++) {\\n        const j = i * 2;\\n        const hexByte = hex.slice(j, j + 2);\\n        const byte = Number.parseInt(hexByte, 16);\\n        if (Number.isNaN(byte) || byte < 0)\\n            throw new Error('Invalid byte sequence');\\n        array[i] = byte;\\n    }\\n    return array;\\n}\\nfunction bytesToNumber(bytes) {\\n    return hexToNumber(bytesToHex(bytes));\\n}\\nfunction ensureBytes(hex) {\\n    return hex instanceof Uint8Array ? Uint8Array.from(hex) : hexToBytes(hex);\\n}\\nfunction normalizeScalar(num) {\\n    if (typeof num === 'number' && Number.isSafeInteger(num) && num > 0)\\n        return BigInt(num);\\n    if (typeof num === 'bigint' && isWithinCurveOrder(num))\\n        return num;\\n    throw new TypeError('Expected valid private scalar: 0 < scalar < curve.n');\\n}\\nfunction mod(a, b = CURVE.P) {\\n    const result = a % b;\\n    return result >= _0n ? result : b + result;\\n}\\nfunction pow2(x, power) {\\n    const { P } = CURVE;\\n    let res = x;\\n    while (power-- > _0n) {\\n        res *= res;\\n        res %= P;\\n    }\\n    return res;\\n}\\nfunction sqrtMod(x) {\\n    const { P } = CURVE;\\n    const _6n = BigInt(6);\\n    const _11n = BigInt(11);\\n    const _22n = BigInt(22);\\n    const _23n = BigInt(23);\\n    const _44n = BigInt(44);\\n    const _88n = BigInt(88);\\n    const b2 = (x * x * x) % P;\\n    const b3 = (b2 * b2 * x) % P;\\n    const b6 = (pow2(b3, _3n) * b3) % P;\\n    const b9 = (pow2(b6, _3n) * b3) % P;\\n    const b11 = (pow2(b9, _2n) * b2) % P;\\n    const b22 = (pow2(b11, _11n) * b11) % P;\\n    const b44 = (pow2(b22, _22n) * b22) % P;\\n    const b88 = (pow2(b44, _44n) * b44) % P;\\n    const b176 = (pow2(b88, _88n) * b88) % P;\\n    const b220 = (pow2(b176, _44n) * b44) % P;\\n    const b223 = (pow2(b220, _3n) * b3) % P;\\n    const t1 = (pow2(b223, _23n) * b22) % P;\\n    const t2 = (pow2(t1, _6n) * b2) % P;\\n    return pow2(t2, _2n);\\n}\\nfunction invert(number, modulo = CURVE.P) {\\n    if (number === _0n || modulo <= _0n) {\\n        throw new Error(`invert: expected positive integers, got n=${number} mod=${modulo}`);\\n    }\\n    let a = mod(number, modulo);\\n    let b = modulo;\\n    let x = _0n, y = _1n, u = _1n, v = _0n;\\n    while (a !== _0n) {\\n        const q = b / a;\\n        const r = b % a;\\n        const m = x - u * q;\\n        const n = y - v * q;\\n        b = a, a = r, x = u, y = v, u = m, v = n;\\n    }\\n    const gcd = b;\\n    if (gcd !== _1n)\\n        throw new Error('invert: does not exist');\\n    return mod(x, modulo);\\n}\\nfunction invertBatch(nums, p = CURVE.P) {\\n    const scratch = new Array(nums.length);\\n    const lastMultiplied = nums.reduce((acc, num, i) => {\\n        if (num === _0n)\\n            return acc;\\n        scratch[i] = acc;\\n        return mod(acc * num, p);\\n    }, _1n);\\n    const inverted = invert(lastMultiplied, p);\\n    nums.reduceRight((acc, num, i) => {\\n        if (num === _0n)\\n            return acc;\\n        scratch[i] = mod(acc * scratch[i], p);\\n        return mod(acc * num, p);\\n    }, inverted);\\n    return scratch;\\n}\\nconst divNearest = (a, b) => (a + b / _2n) / b;\\nconst ENDO = {\\n    a1: BigInt('0x3086d221a7d46bcde86c90e49284eb15'),\\n    b1: -_1n * BigInt('0xe4437ed6010e88286f547fa90abfe4c3'),\\n    a2: BigInt('0x114ca50f7a8e2f3f657c1108d9d44cfd8'),\\n    b2: BigInt('0x3086d221a7d46bcde86c90e49284eb15'),\\n    POW_2_128: BigInt('0x100000000000000000000000000000000'),\\n};\\nfunction splitScalarEndo(k) {\\n    const { n } = CURVE;\\n    const { a1, b1, a2, b2, POW_2_128 } = ENDO;\\n    const c1 = divNearest(b2 * k, n);\\n    const c2 = divNearest(-b1 * k, n);\\n    let k1 = mod(k - c1 * a1 - c2 * a2, n);\\n    let k2 = mod(-c1 * b1 - c2 * b2, n);\\n    const k1neg = k1 > POW_2_128;\\n    const k2neg = k2 > POW_2_128;\\n    if (k1neg)\\n        k1 = n - k1;\\n    if (k2neg)\\n        k2 = n - k2;\\n    if (k1 > POW_2_128 || k2 > POW_2_128) {\\n        throw new Error('splitScalarEndo: Endomorphism failed, k=' + k);\\n    }\\n    return { k1neg, k1, k2neg, k2 };\\n}\\nfunction truncateHash(hash) {\\n    const { n } = CURVE;\\n    const byteLength = hash.length;\\n    const delta = byteLength * 8 - 256;\\n    let h = bytesToNumber(hash);\\n    if (delta > 0)\\n        h = h >> BigInt(delta);\\n    if (h >= n)\\n        h -= n;\\n    return h;\\n}\\nlet _sha256Sync;\\nlet _hmacSha256Sync;\\nclass HmacDrbg {\\n    constructor() {\\n        this.v = new Uint8Array(32).fill(1);\\n        this.k = new Uint8Array(32).fill(0);\\n        this.counter = 0;\\n    }\\n    hmac(...values) {\\n        return utils.hmacSha256(this.k, ...values);\\n    }\\n    hmacSync(...values) {\\n        return _hmacSha256Sync(this.k, ...values);\\n    }\\n    checkSync() {\\n        if (typeof _hmacSha256Sync !== 'function')\\n            throw new ShaError('hmacSha256Sync needs to be set');\\n    }\\n    incr() {\\n        if (this.counter >= 1000)\\n            throw new Error('Tried 1,000 k values for sign(), all were invalid');\\n        this.counter += 1;\\n    }\\n    async reseed(seed = new Uint8Array()) {\\n        this.k = await this.hmac(this.v, Uint8Array.from([0x00]), seed);\\n        this.v = await this.hmac(this.v);\\n        if (seed.length === 0)\\n            return;\\n        this.k = await this.hmac(this.v, Uint8Array.from([0x01]), seed);\\n        this.v = await this.hmac(this.v);\\n    }\\n    reseedSync(seed = new Uint8Array()) {\\n        this.checkSync();\\n        this.k = this.hmacSync(this.v, Uint8Array.from([0x00]), seed);\\n        this.v = this.hmacSync(this.v);\\n        if (seed.length === 0)\\n            return;\\n        this.k = this.hmacSync(this.v, Uint8Array.from([0x01]), seed);\\n        this.v = this.hmacSync(this.v);\\n    }\\n    async generate() {\\n        this.incr();\\n        this.v = await this.hmac(this.v);\\n        return this.v;\\n    }\\n    generateSync() {\\n        this.checkSync();\\n        this.incr();\\n        this.v = this.hmacSync(this.v);\\n        return this.v;\\n    }\\n}\\nfunction isWithinCurveOrder(num) {\\n    return _0n < num && num < CURVE.n;\\n}\\nfunction isValidFieldElement(num) {\\n    return _0n < num && num < CURVE.P;\\n}\\nfunction kmdToSig(kBytes, m, d) {\\n    const k = bytesToNumber(kBytes);\\n    if (!isWithinCurveOrder(k))\\n        return;\\n    const { n } = CURVE;\\n    const q = Point.BASE.multiply(k);\\n    const r = mod(q.x, n);\\n    if (r === _0n)\\n        return;\\n    const s = mod(invert(k, n) * mod(m + d * r, n), n);\\n    if (s === _0n)\\n        return;\\n    const sig = new Signature(r, s);\\n    const recovery = (q.x === sig.r ? 0 : 2) | Number(q.y & _1n);\\n    return { sig, recovery };\\n}\\nfunction normalizePrivateKey(key) {\\n    let num;\\n    if (typeof key === 'bigint') {\\n        num = key;\\n    }\\n    else if (typeof key === 'number' && Number.isSafeInteger(key) && key > 0) {\\n        num = BigInt(key);\\n    }\\n    else if (typeof key === 'string') {\\n        if (key.length !== 64)\\n            throw new Error('Expected 32 bytes of private key');\\n        num = hexToNumber(key);\\n    }\\n    else if (key instanceof Uint8Array) {\\n        if (key.length !== 32)\\n            throw new Error('Expected 32 bytes of private key');\\n        num = bytesToNumber(key);\\n    }\\n    else {\\n        throw new TypeError('Expected valid private key');\\n    }\\n    if (!isWithinCurveOrder(num))\\n        throw new Error('Expected private key: 0 < key < n');\\n    return num;\\n}\\nfunction normalizePublicKey(publicKey) {\\n    if (publicKey instanceof Point) {\\n        publicKey.assertValidity();\\n        return publicKey;\\n    }\\n    else {\\n        return Point.fromHex(publicKey);\\n    }\\n}\\nfunction normalizeSignature(signature) {\\n    if (signature instanceof Signature) {\\n        signature.assertValidity();\\n        return signature;\\n    }\\n    try {\\n        return Signature.fromDER(signature);\\n    }\\n    catch (error) {\\n        return Signature.fromCompact(signature);\\n    }\\n}\\nfunction getPublicKey(privateKey, isCompressed = false) {\\n    return Point.fromPrivateKey(privateKey).toRawBytes(isCompressed);\\n}\\nfunction recoverPublicKey(msgHash, signature, recovery, isCompressed = false) {\\n    return Point.fromSignature(msgHash, signature, recovery).toRawBytes(isCompressed);\\n}\\nfunction isProbPub(item) {\\n    const arr = item instanceof Uint8Array;\\n    const str = typeof item === 'string';\\n    const len = (arr || str) && item.length;\\n    if (arr)\\n        return len === 33 || len === 65;\\n    if (str)\\n        return len === 66 || len === 130;\\n    if (item instanceof Point)\\n        return true;\\n    return false;\\n}\\nfunction getSharedSecret(privateA, publicB, isCompressed = false) {\\n    if (isProbPub(privateA))\\n        throw new TypeError('getSharedSecret: first arg must be private key');\\n    if (!isProbPub(publicB))\\n        throw new TypeError('getSharedSecret: second arg must be public key');\\n    const b = normalizePublicKey(publicB);\\n    b.assertValidity();\\n    return b.multiply(normalizePrivateKey(privateA)).toRawBytes(isCompressed);\\n}\\nfunction bits2int(bytes) {\\n    const slice = bytes.length > 32 ? bytes.slice(0, 32) : bytes;\\n    return bytesToNumber(slice);\\n}\\nfunction bits2octets(bytes) {\\n    const z1 = bits2int(bytes);\\n    const z2 = mod(z1, CURVE.n);\\n    return int2octets(z2 < _0n ? z1 : z2);\\n}\\nfunction int2octets(num) {\\n    return numTo32b(num);\\n}\\nfunction initSigArgs(msgHash, privateKey, extraEntropy) {\\n    if (msgHash == null)\\n        throw new Error(`sign: expected valid message hash, not \\\"${msgHash}\\\"`);\\n    const h1 = ensureBytes(msgHash);\\n    const d = normalizePrivateKey(privateKey);\\n    const seedArgs = [int2octets(d), bits2octets(h1)];\\n    if (extraEntropy != null) {\\n        if (extraEntropy === true)\\n            extraEntropy = utils.randomBytes(32);\\n        const e = ensureBytes(extraEntropy);\\n        if (e.length !== 32)\\n            throw new Error('sign: Expected 32 bytes of extra data');\\n        seedArgs.push(e);\\n    }\\n    const seed = concatBytes(...seedArgs);\\n    const m = bits2int(h1);\\n    return { seed, m, d };\\n}\\nfunction finalizeSig(recSig, opts) {\\n    let { sig, recovery } = recSig;\\n    const { canonical, der, recovered } = Object.assign({ canonical: true, der: true }, opts);\\n    if (canonical && sig.hasHighS()) {\\n        sig = sig.normalizeS();\\n        recovery ^= 1;\\n    }\\n    const hashed = der ? sig.toDERRawBytes() : sig.toCompactRawBytes();\\n    return recovered ? [hashed, recovery] : hashed;\\n}\\nasync function sign(msgHash, privKey, opts = {}) {\\n    const { seed, m, d } = initSigArgs(msgHash, privKey, opts.extraEntropy);\\n    let sig;\\n    const drbg = new HmacDrbg();\\n    await drbg.reseed(seed);\\n    while (!(sig = kmdToSig(await drbg.generate(), m, d)))\\n        await drbg.reseed();\\n    return finalizeSig(sig, opts);\\n}\\nfunction signSync(msgHash, privKey, opts = {}) {\\n    const { seed, m, d } = initSigArgs(msgHash, privKey, opts.extraEntropy);\\n    let sig;\\n    const drbg = new HmacDrbg();\\n    drbg.reseedSync(seed);\\n    while (!(sig = kmdToSig(drbg.generateSync(), m, d)))\\n        drbg.reseedSync();\\n    return finalizeSig(sig, opts);\\n}\\n\\nconst vopts = { strict: true };\\nfunction verify(signature, msgHash, publicKey, opts = vopts) {\\n    let sig;\\n    try {\\n        sig = normalizeSignature(signature);\\n        msgHash = ensureBytes(msgHash);\\n    }\\n    catch (error) {\\n        return false;\\n    }\\n    const { r, s } = sig;\\n    if (opts.strict && sig.hasHighS())\\n        return false;\\n    const h = truncateHash(msgHash);\\n    let P;\\n    try {\\n        P = normalizePublicKey(publicKey);\\n    }\\n    catch (error) {\\n        return false;\\n    }\\n    const { n } = CURVE;\\n    const sinv = invert(s, n);\\n    const u1 = mod(h * sinv, n);\\n    const u2 = mod(r * sinv, n);\\n    const R = Point.BASE.multiplyAndAddUnsafe(P, u1, u2);\\n    if (!R)\\n        return false;\\n    const v = mod(R.x, n);\\n    return v === r;\\n}\\nfunction schnorrChallengeFinalize(ch) {\\n    return mod(bytesToNumber(ch), CURVE.n);\\n}\\nclass SchnorrSignature {\\n    constructor(r, s) {\\n        this.r = r;\\n        this.s = s;\\n        this.assertValidity();\\n    }\\n    static fromHex(hex) {\\n        const bytes = ensureBytes(hex);\\n        if (bytes.length !== 64)\\n            throw new TypeError(`SchnorrSignature.fromHex: expected 64 bytes, not ${bytes.length}`);\\n        const r = bytesToNumber(bytes.subarray(0, 32));\\n        const s = bytesToNumber(bytes.subarray(32, 64));\\n        return new SchnorrSignature(r, s);\\n    }\\n    assertValidity() {\\n        const { r, s } = this;\\n        if (!isValidFieldElement(r) || !isWithinCurveOrder(s))\\n            throw new Error('Invalid signature');\\n    }\\n    toHex() {\\n        return numTo32bStr(this.r) + numTo32bStr(this.s);\\n    }\\n    toRawBytes() {\\n        return hexToBytes(this.toHex());\\n    }\\n}\\nfunction schnorrGetPublicKey(privateKey) {\\n    return Point.fromPrivateKey(privateKey).toRawX();\\n}\\nclass InternalSchnorrSignature {\\n    constructor(message, privateKey, auxRand = utils.randomBytes()) {\\n        if (message == null)\\n            throw new TypeError(`sign: Expected valid message, not \\\"${message}\\\"`);\\n        this.m = ensureBytes(message);\\n        const { x, scalar } = this.getScalar(normalizePrivateKey(privateKey));\\n        this.px = x;\\n        this.d = scalar;\\n        this.rand = ensureBytes(auxRand);\\n        if (this.rand.length !== 32)\\n            throw new TypeError('sign: Expected 32 bytes of aux randomness');\\n    }\\n    getScalar(priv) {\\n        const point = Point.fromPrivateKey(priv);\\n        const scalar = point.hasEvenY() ? priv : CURVE.n - priv;\\n        return { point, scalar, x: point.toRawX() };\\n    }\\n    initNonce(d, t0h) {\\n        return numTo32b(d ^ bytesToNumber(t0h));\\n    }\\n    finalizeNonce(k0h) {\\n        const k0 = mod(bytesToNumber(k0h), CURVE.n);\\n        if (k0 === _0n)\\n            throw new Error('sign: Creation of signature failed. k is zero');\\n        const { point: R, x: rx, scalar: k } = this.getScalar(k0);\\n        return { R, rx, k };\\n    }\\n    finalizeSig(R, k, e, d) {\\n        return new SchnorrSignature(R.x, mod(k + e * d, CURVE.n)).toRawBytes();\\n    }\\n    error() {\\n        throw new Error('sign: Invalid signature produced');\\n    }\\n    async calc() {\\n        const { m, d, px, rand } = this;\\n        const tag = utils.taggedHash;\\n        const t = this.initNonce(d, await tag(TAGS.aux, rand));\\n        const { R, rx, k } = this.finalizeNonce(await tag(TAGS.nonce, t, px, m));\\n        const e = schnorrChallengeFinalize(await tag(TAGS.challenge, rx, px, m));\\n        const sig = this.finalizeSig(R, k, e, d);\\n        if (!(await schnorrVerify(sig, m, px)))\\n            this.error();\\n        return sig;\\n    }\\n    calcSync() {\\n        const { m, d, px, rand } = this;\\n        const tag = utils.taggedHashSync;\\n        const t = this.initNonce(d, tag(TAGS.aux, rand));\\n        const { R, rx, k } = this.finalizeNonce(tag(TAGS.nonce, t, px, m));\\n        const e = schnorrChallengeFinalize(tag(TAGS.challenge, rx, px, m));\\n        const sig = this.finalizeSig(R, k, e, d);\\n        if (!schnorrVerifySync(sig, m, px))\\n            this.error();\\n        return sig;\\n    }\\n}\\nasync function schnorrSign(msg, privKey, auxRand) {\\n    return new InternalSchnorrSignature(msg, privKey, auxRand).calc();\\n}\\nfunction schnorrSignSync(msg, privKey, auxRand) {\\n    return new InternalSchnorrSignature(msg, privKey, auxRand).calcSync();\\n}\\nfunction initSchnorrVerify(signature, message, publicKey) {\\n    const raw = signature instanceof SchnorrSignature;\\n    const sig = raw ? signature : SchnorrSignature.fromHex(signature);\\n    if (raw)\\n        sig.assertValidity();\\n    return {\\n        ...sig,\\n        m: ensureBytes(message),\\n        P: normalizePublicKey(publicKey),\\n    };\\n}\\nfunction finalizeSchnorrVerify(r, P, s, e) {\\n    const R = Point.BASE.multiplyAndAddUnsafe(P, normalizePrivateKey(s), mod(-e, CURVE.n));\\n    if (!R || !R.hasEvenY() || R.x !== r)\\n        return false;\\n    return true;\\n}\\nasync function schnorrVerify(signature, message, publicKey) {\\n    try {\\n        const { r, s, m, P } = initSchnorrVerify(signature, message, publicKey);\\n        const e = schnorrChallengeFinalize(await utils.taggedHash(TAGS.challenge, numTo32b(r), P.toRawX(), m));\\n        return finalizeSchnorrVerify(r, P, s, e);\\n    }\\n    catch (error) {\\n        return false;\\n    }\\n}\\nfunction schnorrVerifySync(signature, message, publicKey) {\\n    try {\\n        const { r, s, m, P } = initSchnorrVerify(signature, message, publicKey);\\n        const e = schnorrChallengeFinalize(utils.taggedHashSync(TAGS.challenge, numTo32b(r), P.toRawX(), m));\\n        return finalizeSchnorrVerify(r, P, s, e);\\n    }\\n    catch (error) {\\n        if (error instanceof ShaError)\\n            throw error;\\n        return false;\\n    }\\n}\\nconst schnorr = {\\n    Signature: SchnorrSignature,\\n    getPublicKey: schnorrGetPublicKey,\\n    sign: schnorrSign,\\n    verify: schnorrVerify,\\n    signSync: schnorrSignSync,\\n    verifySync: schnorrVerifySync,\\n};\\nPoint.BASE._setWindowSize(8);\\nconst crypto = {\\n    node: /*#__PURE__*/ (crypto__WEBPACK_IMPORTED_MODULE_0___namespace_cache || (crypto__WEBPACK_IMPORTED_MODULE_0___namespace_cache = __webpack_require__.t(crypto__WEBPACK_IMPORTED_MODULE_0__, 2))),\\n    web: typeof self === 'object' && 'crypto' in self ? self.crypto : undefined,\\n};\\nconst TAGS = {\\n    challenge: 'BIP0340/challenge',\\n    aux: 'BIP0340/aux',\\n    nonce: 'BIP0340/nonce',\\n};\\nconst TAGGED_HASH_PREFIXES = {};\\nconst utils = {\\n    bytesToHex,\\n    hexToBytes,\\n    concatBytes,\\n    mod,\\n    invert,\\n    isValidPrivateKey(privateKey) {\\n        try {\\n            normalizePrivateKey(privateKey);\\n            return true;\\n        }\\n        catch (error) {\\n            return false;\\n        }\\n    },\\n    _bigintTo32Bytes: numTo32b,\\n    _normalizePrivateKey: normalizePrivateKey,\\n    hashToPrivateKey: (hash) => {\\n        hash = ensureBytes(hash);\\n        if (hash.length < 40 || hash.length > 1024)\\n            throw new Error('Expected 40-1024 bytes of private key as per FIPS 186');\\n        const num = mod(bytesToNumber(hash), CURVE.n - _1n) + _1n;\\n        return numTo32b(num);\\n    },\\n    randomBytes: (bytesLength = 32) => {\\n        if (crypto.web) {\\n            return crypto.web.getRandomValues(new Uint8Array(bytesLength));\\n        }\\n        else if (crypto.node) {\\n            const { randomBytes } = crypto.node;\\n            return Uint8Array.from(randomBytes(bytesLength));\\n        }\\n        else {\\n            throw new Error(\\\"The environment doesn't have randomBytes function\\\");\\n        }\\n    },\\n    randomPrivateKey: () => {\\n        return utils.hashToPrivateKey(utils.randomBytes(40));\\n    },\\n    sha256: async (...messages) => {\\n        if (crypto.web) {\\n            const buffer = await crypto.web.subtle.digest('SHA-256', concatBytes(...messages));\\n            return new Uint8Array(buffer);\\n        }\\n        else if (crypto.node) {\\n            const { createHash } = crypto.node;\\n            const hash = createHash('sha256');\\n            messages.forEach((m) => hash.update(m));\\n            return Uint8Array.from(hash.digest());\\n        }\\n        else {\\n            throw new Error(\\\"The environment doesn't have sha256 function\\\");\\n        }\\n    },\\n    hmacSha256: async (key, ...messages) => {\\n        if (crypto.web) {\\n            const ckey = await crypto.web.subtle.importKey('raw', key, { name: 'HMAC', hash: { name: 'SHA-256' } }, false, ['sign']);\\n            const message = concatBytes(...messages);\\n            const buffer = await crypto.web.subtle.sign('HMAC', ckey, message);\\n            return new Uint8Array(buffer);\\n        }\\n        else if (crypto.node) {\\n            const { createHmac } = crypto.node;\\n            const hash = createHmac('sha256', key);\\n            messages.forEach((m) => hash.update(m));\\n            return Uint8Array.from(hash.digest());\\n        }\\n        else {\\n            throw new Error(\\\"The environment doesn't have hmac-sha256 function\\\");\\n        }\\n    },\\n    sha256Sync: undefined,\\n    hmacSha256Sync: undefined,\\n    taggedHash: async (tag, ...messages) => {\\n        let tagP = TAGGED_HASH_PREFIXES[tag];\\n        if (tagP === undefined) {\\n            const tagH = await utils.sha256(Uint8Array.from(tag, (c) => c.charCodeAt(0)));\\n            tagP = concatBytes(tagH, tagH);\\n            TAGGED_HASH_PREFIXES[tag] = tagP;\\n        }\\n        return utils.sha256(tagP, ...messages);\\n    },\\n    taggedHashSync: (tag, ...messages) => {\\n        if (typeof _sha256Sync !== 'function')\\n            throw new ShaError('sha256Sync is undefined, you need to set it');\\n        let tagP = TAGGED_HASH_PREFIXES[tag];\\n        if (tagP === undefined) {\\n            const tagH = _sha256Sync(Uint8Array.from(tag, (c) => c.charCodeAt(0)));\\n            tagP = concatBytes(tagH, tagH);\\n            TAGGED_HASH_PREFIXES[tag] = tagP;\\n        }\\n        return _sha256Sync(tagP, ...messages);\\n    },\\n    precompute(windowSize = 8, point = Point.BASE) {\\n        const cached = point === Point.BASE ? point : new Point(point.x, point.y);\\n        cached._setWindowSize(windowSize);\\n        cached.multiply(_3n);\\n        return cached;\\n    },\\n};\\nObject.defineProperties(utils, {\\n    sha256Sync: {\\n        configurable: false,\\n        get() {\\n            return _sha256Sync;\\n        },\\n        set(val) {\\n            if (!_sha256Sync)\\n                _sha256Sync = val;\\n        },\\n    },\\n    hmacSha256Sync: {\\n        configurable: false,\\n        get() {\\n            return _hmacSha256Sync;\\n        },\\n        set(val) {\\n            if (!_hmacSha256Sync)\\n                _hmacSha256Sync = val;\\n        },\\n    },\\n});\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@noble/secp256k1/lib/esm/index.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/@solana/buffer-layout-utils/lib/esm/base.mjs\":\n/*!*******************************************************************!*\\\n  !*** ./node_modules/@solana/buffer-layout-utils/lib/esm/base.mjs ***!\n  \\*******************************************************************/\n/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"encodeDecode\\\": () => (/* binding */ encodeDecode)\\n/* harmony export */ });\\nconst encodeDecode = (layout) => {\\n    const decode = layout.decode.bind(layout);\\n    const encode = layout.encode.bind(layout);\\n    return { decode, encode };\\n};\\n//# sourceMappingURL=base.js.map\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@solana/buffer-layout-utils/lib/esm/base.mjs?\");\n\n/***/ }),\n\n/***/ \"./node_modules/@solana/buffer-layout-utils/lib/esm/bigint.mjs\":\n/*!*********************************************************************!*\\\n  !*** ./node_modules/@solana/buffer-layout-utils/lib/esm/bigint.mjs ***!\n  \\*********************************************************************/\n/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"bigInt\\\": () => (/* binding */ bigInt),\\n/* harmony export */   \\\"bigIntBE\\\": () => (/* binding */ bigIntBE),\\n/* harmony export */   \\\"u128\\\": () => (/* binding */ u128),\\n/* harmony export */   \\\"u128be\\\": () => (/* binding */ u128be),\\n/* harmony export */   \\\"u192\\\": () => (/* binding */ u192),\\n/* harmony export */   \\\"u192be\\\": () => (/* binding */ u192be),\\n/* harmony export */   \\\"u256\\\": () => (/* binding */ u256),\\n/* harmony export */   \\\"u256be\\\": () => (/* binding */ u256be),\\n/* harmony export */   \\\"u64\\\": () => (/* binding */ u64),\\n/* harmony export */   \\\"u64be\\\": () => (/* binding */ u64be)\\n/* harmony export */ });\\n/* harmony import */ var _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @solana/buffer-layout */ \\\"./node_modules/@solana/buffer-layout/lib/Layout.js\\\");\\n/* harmony import */ var bigint_buffer__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! bigint-buffer */ \\\"./node_modules/bigint-buffer/dist/browser.js\\\");\\n/* harmony import */ var _base_mjs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./base.mjs */ \\\"./node_modules/@solana/buffer-layout-utils/lib/esm/base.mjs\\\");\\n/* provided dependency */ var Buffer = __webpack_require__(/*! buffer */ \\\"./node_modules/buffer/index.js\\\")[\\\"Buffer\\\"];\\n\\n\\n\\nconst bigInt = (length) => (property) => {\\n    const layout = (0,_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_0__.blob)(length, property);\\n    const { encode, decode } = (0,_base_mjs__WEBPACK_IMPORTED_MODULE_2__.encodeDecode)(layout);\\n    const bigIntLayout = layout;\\n    bigIntLayout.decode = (buffer, offset) => {\\n        const src = decode(buffer, offset);\\n        return (0,bigint_buffer__WEBPACK_IMPORTED_MODULE_1__.toBigIntLE)(Buffer.from(src));\\n    };\\n    bigIntLayout.encode = (bigInt, buffer, offset) => {\\n        const src = (0,bigint_buffer__WEBPACK_IMPORTED_MODULE_1__.toBufferLE)(bigInt, length);\\n        return encode(src, buffer, offset);\\n    };\\n    return bigIntLayout;\\n};\\nconst bigIntBE = (length) => (property) => {\\n    const layout = (0,_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_0__.blob)(length, property);\\n    const { encode, decode } = (0,_base_mjs__WEBPACK_IMPORTED_MODULE_2__.encodeDecode)(layout);\\n    const bigIntLayout = layout;\\n    bigIntLayout.decode = (buffer, offset) => {\\n        const src = decode(buffer, offset);\\n        return (0,bigint_buffer__WEBPACK_IMPORTED_MODULE_1__.toBigIntBE)(Buffer.from(src));\\n    };\\n    bigIntLayout.encode = (bigInt, buffer, offset) => {\\n        const src = (0,bigint_buffer__WEBPACK_IMPORTED_MODULE_1__.toBufferBE)(bigInt, length);\\n        return encode(src, buffer, offset);\\n    };\\n    return bigIntLayout;\\n};\\nconst u64 = bigInt(8);\\nconst u64be = bigIntBE(8);\\nconst u128 = bigInt(16);\\nconst u128be = bigIntBE(16);\\nconst u192 = bigInt(24);\\nconst u192be = bigIntBE(24);\\nconst u256 = bigInt(32);\\nconst u256be = bigIntBE(32);\\n//# sourceMappingURL=bigint.js.map\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@solana/buffer-layout-utils/lib/esm/bigint.mjs?\");\n\n/***/ }),\n\n/***/ \"./node_modules/@solana/buffer-layout-utils/lib/esm/decimal.mjs\":\n/*!**********************************************************************!*\\\n  !*** ./node_modules/@solana/buffer-layout-utils/lib/esm/decimal.mjs ***!\n  \\**********************************************************************/\n/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"WAD\\\": () => (/* binding */ WAD),\\n/* harmony export */   \\\"decimal\\\": () => (/* binding */ decimal)\\n/* harmony export */ });\\n/* harmony import */ var bignumber_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! bignumber.js */ \\\"./node_modules/bignumber.js/bignumber.mjs\\\");\\n/* harmony import */ var _base_mjs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./base.mjs */ \\\"./node_modules/@solana/buffer-layout-utils/lib/esm/base.mjs\\\");\\n/* harmony import */ var _bigint_mjs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./bigint.mjs */ \\\"./node_modules/@solana/buffer-layout-utils/lib/esm/bigint.mjs\\\");\\n\\n\\n\\nconst WAD = new bignumber_js__WEBPACK_IMPORTED_MODULE_0__[\\\"default\\\"]('1e+18');\\nconst decimal = (property) => {\\n    const layout = (0,_bigint_mjs__WEBPACK_IMPORTED_MODULE_2__.u128)(property);\\n    const { encode, decode } = (0,_base_mjs__WEBPACK_IMPORTED_MODULE_1__.encodeDecode)(layout);\\n    const decimalLayout = layout;\\n    decimalLayout.decode = (buffer, offset) => {\\n        const src = decode(buffer, offset).toString();\\n        return new bignumber_js__WEBPACK_IMPORTED_MODULE_0__[\\\"default\\\"](src).div(WAD);\\n    };\\n    decimalLayout.encode = (decimal, buffer, offset) => {\\n        const src = BigInt(decimal.times(WAD).integerValue().toString());\\n        return encode(src, buffer, offset);\\n    };\\n    return decimalLayout;\\n};\\n//# sourceMappingURL=decimal.js.map\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@solana/buffer-layout-utils/lib/esm/decimal.mjs?\");\n\n/***/ }),\n\n/***/ \"./node_modules/@solana/buffer-layout-utils/lib/esm/index.mjs\":\n/*!********************************************************************!*\\\n  !*** ./node_modules/@solana/buffer-layout-utils/lib/esm/index.mjs ***!\n  \\********************************************************************/\n/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"WAD\\\": () => (/* reexport safe */ _decimal_mjs__WEBPACK_IMPORTED_MODULE_2__.WAD),\\n/* harmony export */   \\\"bigInt\\\": () => (/* reexport safe */ _bigint_mjs__WEBPACK_IMPORTED_MODULE_1__.bigInt),\\n/* harmony export */   \\\"bigIntBE\\\": () => (/* reexport safe */ _bigint_mjs__WEBPACK_IMPORTED_MODULE_1__.bigIntBE),\\n/* harmony export */   \\\"bool\\\": () => (/* reexport safe */ _native_mjs__WEBPACK_IMPORTED_MODULE_3__.bool),\\n/* harmony export */   \\\"decimal\\\": () => (/* reexport safe */ _decimal_mjs__WEBPACK_IMPORTED_MODULE_2__.decimal),\\n/* harmony export */   \\\"encodeDecode\\\": () => (/* reexport safe */ _base_mjs__WEBPACK_IMPORTED_MODULE_0__.encodeDecode),\\n/* harmony export */   \\\"publicKey\\\": () => (/* reexport safe */ _web3_mjs__WEBPACK_IMPORTED_MODULE_4__.publicKey),\\n/* harmony export */   \\\"u128\\\": () => (/* reexport safe */ _bigint_mjs__WEBPACK_IMPORTED_MODULE_1__.u128),\\n/* harmony export */   \\\"u128be\\\": () => (/* reexport safe */ _bigint_mjs__WEBPACK_IMPORTED_MODULE_1__.u128be),\\n/* harmony export */   \\\"u192\\\": () => (/* reexport safe */ _bigint_mjs__WEBPACK_IMPORTED_MODULE_1__.u192),\\n/* harmony export */   \\\"u192be\\\": () => (/* reexport safe */ _bigint_mjs__WEBPACK_IMPORTED_MODULE_1__.u192be),\\n/* harmony export */   \\\"u256\\\": () => (/* reexport safe */ _bigint_mjs__WEBPACK_IMPORTED_MODULE_1__.u256),\\n/* harmony export */   \\\"u256be\\\": () => (/* reexport safe */ _bigint_mjs__WEBPACK_IMPORTED_MODULE_1__.u256be),\\n/* harmony export */   \\\"u64\\\": () => (/* reexport safe */ _bigint_mjs__WEBPACK_IMPORTED_MODULE_1__.u64),\\n/* harmony export */   \\\"u64be\\\": () => (/* reexport safe */ _bigint_mjs__WEBPACK_IMPORTED_MODULE_1__.u64be)\\n/* harmony export */ });\\n/* harmony import */ var _base_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./base.mjs */ \\\"./node_modules/@solana/buffer-layout-utils/lib/esm/base.mjs\\\");\\n/* harmony import */ var _bigint_mjs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./bigint.mjs */ \\\"./node_modules/@solana/buffer-layout-utils/lib/esm/bigint.mjs\\\");\\n/* harmony import */ var _decimal_mjs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./decimal.mjs */ \\\"./node_modules/@solana/buffer-layout-utils/lib/esm/decimal.mjs\\\");\\n/* harmony import */ var _native_mjs__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./native.mjs */ \\\"./node_modules/@solana/buffer-layout-utils/lib/esm/native.mjs\\\");\\n/* harmony import */ var _web3_mjs__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./web3.mjs */ \\\"./node_modules/@solana/buffer-layout-utils/lib/esm/web3.mjs\\\");\\n\\n\\n\\n\\n\\n//# sourceMappingURL=index.js.map\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@solana/buffer-layout-utils/lib/esm/index.mjs?\");\n\n/***/ }),\n\n/***/ \"./node_modules/@solana/buffer-layout-utils/lib/esm/native.mjs\":\n/*!*********************************************************************!*\\\n  !*** ./node_modules/@solana/buffer-layout-utils/lib/esm/native.mjs ***!\n  \\*********************************************************************/\n/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"bool\\\": () => (/* binding */ bool)\\n/* harmony export */ });\\n/* harmony import */ var _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @solana/buffer-layout */ \\\"./node_modules/@solana/buffer-layout/lib/Layout.js\\\");\\n/* harmony import */ var _base_mjs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./base.mjs */ \\\"./node_modules/@solana/buffer-layout-utils/lib/esm/base.mjs\\\");\\n\\n\\nconst bool = (property) => {\\n    const layout = (0,_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_0__.u8)(property);\\n    const { encode, decode } = (0,_base_mjs__WEBPACK_IMPORTED_MODULE_1__.encodeDecode)(layout);\\n    const boolLayout = layout;\\n    boolLayout.decode = (buffer, offset) => {\\n        const src = decode(buffer, offset);\\n        return !!src;\\n    };\\n    boolLayout.encode = (bool, buffer, offset) => {\\n        const src = Number(bool);\\n        return encode(src, buffer, offset);\\n    };\\n    return boolLayout;\\n};\\n//# sourceMappingURL=native.js.map\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@solana/buffer-layout-utils/lib/esm/native.mjs?\");\n\n/***/ }),\n\n/***/ \"./node_modules/@solana/buffer-layout-utils/lib/esm/web3.mjs\":\n/*!*******************************************************************!*\\\n  !*** ./node_modules/@solana/buffer-layout-utils/lib/esm/web3.mjs ***!\n  \\*******************************************************************/\n/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"publicKey\\\": () => (/* binding */ publicKey)\\n/* harmony export */ });\\n/* harmony import */ var _solana_buffer_layout__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @solana/buffer-layout */ \\\"./node_modules/@solana/buffer-layout/lib/Layout.js\\\");\\n/* harmony import */ var _solana_web3_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @solana/web3.js */ \\\"./node_modules/@solana/web3.js/lib/index.browser.esm.js\\\");\\n/* harmony import */ var _base_mjs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./base.mjs */ \\\"./node_modules/@solana/buffer-layout-utils/lib/esm/base.mjs\\\");\\n\\n\\n\\nconst publicKey = (property) => {\\n    const layout = (0,_solana_buffer_layout__WEBPACK_IMPORTED_MODULE_0__.blob)(32, property);\\n    const { encode, decode } = (0,_base_mjs__WEBPACK_IMPORTED_MODULE_2__.encodeDecode)(layout);\\n    const publicKeyLayout = layout;\\n    publicKeyLayout.decode = (buffer, offset) => {\\n        const src = decode(buffer, offset);\\n        return new _solana_web3_js__WEBPACK_IMPORTED_MODULE_1__.PublicKey(src);\\n    };\\n    publicKeyLayout.encode = (publicKey, buffer, offset) => {\\n        const src = publicKey.toBuffer();\\n        return encode(src, buffer, offset);\\n    };\\n    return publicKeyLayout;\\n};\\n//# sourceMappingURL=web3.js.map\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@solana/buffer-layout-utils/lib/esm/web3.mjs?\");\n\n/***/ }),\n\n/***/ \"./node_modules/@solana/spl-token/lib/esm/constants.js\":\n/*!*************************************************************!*\\\n  !*** ./node_modules/@solana/spl-token/lib/esm/constants.js ***!\n  \\*************************************************************/\n/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"ASSOCIATED_TOKEN_PROGRAM_ID\\\": () => (/* binding */ ASSOCIATED_TOKEN_PROGRAM_ID),\\n/* harmony export */   \\\"NATIVE_MINT\\\": () => (/* binding */ NATIVE_MINT),\\n/* harmony export */   \\\"NATIVE_MINT_2022\\\": () => (/* binding */ NATIVE_MINT_2022),\\n/* harmony export */   \\\"TOKEN_2022_PROGRAM_ID\\\": () => (/* binding */ TOKEN_2022_PROGRAM_ID),\\n/* harmony export */   \\\"TOKEN_PROGRAM_ID\\\": () => (/* binding */ TOKEN_PROGRAM_ID),\\n/* harmony export */   \\\"programSupportsExtensions\\\": () => (/* binding */ programSupportsExtensions)\\n/* harmony export */ });\\n/* harmony import */ var _solana_web3_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @solana/web3.js */ \\\"./node_modules/@solana/web3.js/lib/index.browser.esm.js\\\");\\n\\n/** Address of the SPL Token program */\\nconst TOKEN_PROGRAM_ID = new _solana_web3_js__WEBPACK_IMPORTED_MODULE_0__.PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA');\\n/** Address of the SPL Token 2022 program */\\nconst TOKEN_2022_PROGRAM_ID = new _solana_web3_js__WEBPACK_IMPORTED_MODULE_0__.PublicKey('TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb');\\n/** Address of the SPL Associated Token Account program */\\nconst ASSOCIATED_TOKEN_PROGRAM_ID = new _solana_web3_js__WEBPACK_IMPORTED_MODULE_0__.PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');\\n/** Address of the special mint for wrapped native SOL in spl-token */\\nconst NATIVE_MINT = new _solana_web3_js__WEBPACK_IMPORTED_MODULE_0__.PublicKey('So11111111111111111111111111111111111111112');\\n/** Address of the special mint for wrapped native SOL in spl-token-2022 */\\nconst NATIVE_MINT_2022 = new _solana_web3_js__WEBPACK_IMPORTED_MODULE_0__.PublicKey('9pan9bMn5HatX4EJdBwg9VgCa7Uz5HL8N1m5D3NdXejP');\\n/** Check that the token program provided is not `Tokenkeg...`, useful when using extensions */\\nfunction programSupportsExtensions(programId) {\\n    if (programId === TOKEN_PROGRAM_ID) {\\n        return false;\\n    }\\n    else {\\n        return true;\\n    }\\n}\\n//# sourceMappingURL=constants.js.map\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/@solana/spl-token/lib/esm/constants.js?\");\n\n/***/ }),\n\n/***/ \"./node_modules/bignumber.js/bignumber.mjs\":\n/*!*************************************************!*\\\n  !*** ./node_modules/bignumber.js/bignumber.mjs ***!\n  \\*************************************************/\n/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"BigNumber\\\": () => (/* binding */ BigNumber),\\n/* harmony export */   \\\"default\\\": () => (__WEBPACK_DEFAULT_EXPORT__)\\n/* harmony export */ });\\n/*\\r\\n *      bignumber.js v9.1.1\\r\\n *      A JavaScript library for arbitrary-precision arithmetic.\\r\\n *      https://github.com/MikeMcl/bignumber.js\\r\\n *      Copyright (c) 2022 Michael Mclaughlin <M8ch88l@gmail.com>\\r\\n *      MIT Licensed.\\r\\n *\\r\\n *      BigNumber.prototype methods     |  BigNumber methods\\r\\n *                                      |\\r\\n *      absoluteValue            abs    |  clone\\r\\n *      comparedTo                      |  config               set\\r\\n *      decimalPlaces            dp     |      DECIMAL_PLACES\\r\\n *      dividedBy                div    |      ROUNDING_MODE\\r\\n *      dividedToIntegerBy       idiv   |      EXPONENTIAL_AT\\r\\n *      exponentiatedBy          pow    |      RANGE\\r\\n *      integerValue                    |      CRYPTO\\r\\n *      isEqualTo                eq     |      MODULO_MODE\\r\\n *      isFinite                        |      POW_PRECISION\\r\\n *      isGreaterThan            gt     |      FORMAT\\r\\n *      isGreaterThanOrEqualTo   gte    |      ALPHABET\\r\\n *      isInteger                       |  isBigNumber\\r\\n *      isLessThan               lt     |  maximum              max\\r\\n *      isLessThanOrEqualTo      lte    |  minimum              min\\r\\n *      isNaN                           |  random\\r\\n *      isNegative                      |  sum\\r\\n *      isPositive                      |\\r\\n *      isZero                          |\\r\\n *      minus                           |\\r\\n *      modulo                   mod    |\\r\\n *      multipliedBy             times  |\\r\\n *      negated                         |\\r\\n *      plus                            |\\r\\n *      precision                sd     |\\r\\n *      shiftedBy                       |\\r\\n *      squareRoot               sqrt   |\\r\\n *      toExponential                   |\\r\\n *      toFixed                         |\\r\\n *      toFormat                        |\\r\\n *      toFraction                      |\\r\\n *      toJSON                          |\\r\\n *      toNumber                        |\\r\\n *      toPrecision                     |\\r\\n *      toString                        |\\r\\n *      valueOf                         |\\r\\n *\\r\\n */\\r\\n\\r\\n\\r\\nvar\\r\\n  isNumeric = /^-?(?:\\\\d+(?:\\\\.\\\\d*)?|\\\\.\\\\d+)(?:e[+-]?\\\\d+)?$/i,\\r\\n  mathceil = Math.ceil,\\r\\n  mathfloor = Math.floor,\\r\\n\\r\\n  bignumberError = '[BigNumber Error] ',\\r\\n  tooManyDigits = bignumberError + 'Number primitive has more than 15 significant digits: ',\\r\\n\\r\\n  BASE = 1e14,\\r\\n  LOG_BASE = 14,\\r\\n  MAX_SAFE_INTEGER = 0x1fffffffffffff,         // 2^53 - 1\\r\\n  // MAX_INT32 = 0x7fffffff,                   // 2^31 - 1\\r\\n  POWS_TEN = [1, 10, 100, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13],\\r\\n  SQRT_BASE = 1e7,\\r\\n\\r\\n  // EDITABLE\\r\\n  // The limit on the value of DECIMAL_PLACES, TO_EXP_NEG, TO_EXP_POS, MIN_EXP, MAX_EXP, and\\r\\n  // the arguments to toExponential, toFixed, toFormat, and toPrecision.\\r\\n  MAX = 1E9;                                   // 0 to MAX_INT32\\r\\n\\r\\n\\r\\n/*\\r\\n * Create and return a BigNumber constructor.\\r\\n */\\r\\nfunction clone(configObject) {\\r\\n  var div, convertBase, parseNumeric,\\r\\n    P = BigNumber.prototype = { constructor: BigNumber, toString: null, valueOf: null },\\r\\n    ONE = new BigNumber(1),\\r\\n\\r\\n\\r\\n    //----------------------------- EDITABLE CONFIG DEFAULTS -------------------------------\\r\\n\\r\\n\\r\\n    // The default values below must be integers within the inclusive ranges stated.\\r\\n    // The values can also be changed at run-time using BigNumber.set.\\r\\n\\r\\n    // The maximum number of decimal places for operations involving division.\\r\\n    DECIMAL_PLACES = 20,                     // 0 to MAX\\r\\n\\r\\n    // The rounding mode used when rounding to the above decimal places, and when using\\r\\n    // toExponential, toFixed, toFormat and toPrecision, and round (default value).\\r\\n    // UP         0 Away from zero.\\r\\n    // DOWN       1 Towards zero.\\r\\n    // CEIL       2 Towards +Infinity.\\r\\n    // FLOOR      3 Towards -Infinity.\\r\\n    // HALF_UP    4 Towards nearest neighbour. If equidistant, up.\\r\\n    // HALF_DOWN  5 Towards nearest neighbour. If equidistant, down.\\r\\n    // HALF_EVEN  6 Towards nearest neighbour. If equidistant, towards even neighbour.\\r\\n    // HALF_CEIL  7 Towards nearest neighbour. If equidistant, towards +Infinity.\\r\\n    // HALF_FLOOR 8 Towards nearest neighbour. If equidistant, towards -Infinity.\\r\\n    ROUNDING_MODE = 4,                       // 0 to 8\\r\\n\\r\\n    // EXPONENTIAL_AT : [TO_EXP_NEG , TO_EXP_POS]\\r\\n\\r\\n    // The exponent value at and beneath which toString returns exponential notation.\\r\\n    // Number type: -7\\r\\n    TO_EXP_NEG = -7,                         // 0 to -MAX\\r\\n\\r\\n    // The exponent value at and above which toString returns exponential notation.\\r\\n    // Number type: 21\\r\\n    TO_EXP_POS = 21,                         // 0 to MAX\\r\\n\\r\\n    // RANGE : [MIN_EXP, MAX_EXP]\\r\\n\\r\\n    // The minimum exponent value, beneath which underflow to zero occurs.\\r\\n    // Number type: -324  (5e-324)\\r\\n    MIN_EXP = -1e7,                          // -1 to -MAX\\r\\n\\r\\n    // The maximum exponent value, above which overflow to Infinity occurs.\\r\\n    // Number type:  308  (1.7976931348623157e+308)\\r\\n    // For MAX_EXP > 1e7, e.g. new BigNumber('1e100000000').plus(1) may be slow.\\r\\n    MAX_EXP = 1e7,                           // 1 to MAX\\r\\n\\r\\n    // Whether to use cryptographically-secure random number generation, if available.\\r\\n    CRYPTO = false,                          // true or false\\r\\n\\r\\n    // The modulo mode used when calculating the modulus: a mod n.\\r\\n    // The quotient (q = a / n) is calculated according to the corresponding rounding mode.\\r\\n    // The remainder (r) is calculated as: r = a - n * q.\\r\\n    //\\r\\n    // UP        0 The remainder is positive if the dividend is negative, else is negative.\\r\\n    // DOWN      1 The remainder has the same sign as the dividend.\\r\\n    //             This modulo mode is commonly known as 'truncated division' and is\\r\\n    //             equivalent to (a % n) in JavaScript.\\r\\n    // FLOOR     3 The remainder has the same sign as the divisor (Python %).\\r\\n    // HALF_EVEN 6 This modulo mode implements the IEEE 754 remainder function.\\r\\n    // EUCLID    9 Euclidian division. q = sign(n) * floor(a / abs(n)).\\r\\n    //             The remainder is always positive.\\r\\n    //\\r\\n    // The truncated division, floored division, Euclidian division and IEEE 754 remainder\\r\\n    // modes are commonly used for the modulus operation.\\r\\n    // Although the other rounding modes can also be used, they may not give useful results.\\r\\n    MODULO_MODE = 1,                         // 0 to 9\\r\\n\\r\\n    // The maximum number of significant digits of the result of the exponentiatedBy operation.\\r\\n    // If POW_PRECISION is 0, there will be unlimited significant digits.\\r\\n    POW_PRECISION = 0,                       // 0 to MAX\\r\\n\\r\\n    // The format specification used by the BigNumber.prototype.toFormat method.\\r\\n    FORMAT = {\\r\\n      prefix: '',\\r\\n      groupSize: 3,\\r\\n      secondaryGroupSize: 0,\\r\\n      groupSeparator: ',',\\r\\n      decimalSeparator: '.',\\r\\n      fractionGroupSize: 0,\\r\\n      fractionGroupSeparator: '\\\\xA0',        // non-breaking space\\r\\n      suffix: ''\\r\\n    },\\r\\n\\r\\n    // The alphabet used for base conversion. It must be at least 2 characters long, with no '+',\\r\\n    // '-', '.', whitespace, or repeated character.\\r\\n    // '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_'\\r\\n    ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz',\\r\\n    alphabetHasNormalDecimalDigits = true;\\r\\n\\r\\n\\r\\n  //------------------------------------------------------------------------------------------\\r\\n\\r\\n\\r\\n  // CONSTRUCTOR\\r\\n\\r\\n\\r\\n  /*\\r\\n   * The BigNumber constructor and exported function.\\r\\n   * Create and return a new instance of a BigNumber object.\\r\\n   *\\r\\n   * v {number|string|BigNumber} A numeric value.\\r\\n   * [b] {number} The base of v. Integer, 2 to ALPHABET.length inclusive.\\r\\n   */\\r\\n  function BigNumber(v, b) {\\r\\n    var alphabet, c, caseChanged, e, i, isNum, len, str,\\r\\n      x = this;\\r\\n\\r\\n    // Enable constructor call without `new`.\\r\\n    if (!(x instanceof BigNumber)) return new BigNumber(v, b);\\r\\n\\r\\n    if (b == null) {\\r\\n\\r\\n      if (v && v._isBigNumber === true) {\\r\\n        x.s = v.s;\\r\\n\\r\\n        if (!v.c || v.e > MAX_EXP) {\\r\\n          x.c = x.e = null;\\r\\n        } else if (v.e < MIN_EXP) {\\r\\n          x.c = [x.e = 0];\\r\\n        } else {\\r\\n          x.e = v.e;\\r\\n          x.c = v.c.slice();\\r\\n        }\\r\\n\\r\\n        return;\\r\\n      }\\r\\n\\r\\n      if ((isNum = typeof v == 'number') && v * 0 == 0) {\\r\\n\\r\\n        // Use `1 / n` to handle minus zero also.\\r\\n        x.s = 1 / v < 0 ? (v = -v, -1) : 1;\\r\\n\\r\\n        // Fast path for integers, where n < 2147483648 (2**31).\\r\\n        if (v === ~~v) {\\r\\n          for (e = 0, i = v; i >= 10; i /= 10, e++);\\r\\n\\r\\n          if (e > MAX_EXP) {\\r\\n            x.c = x.e = null;\\r\\n          } else {\\r\\n            x.e = e;\\r\\n            x.c = [v];\\r\\n          }\\r\\n\\r\\n          return;\\r\\n        }\\r\\n\\r\\n        str = String(v);\\r\\n      } else {\\r\\n\\r\\n        if (!isNumeric.test(str = String(v))) return parseNumeric(x, str, isNum);\\r\\n\\r\\n        x.s = str.charCodeAt(0) == 45 ? (str = str.slice(1), -1) : 1;\\r\\n      }\\r\\n\\r\\n      // Decimal point?\\r\\n      if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');\\r\\n\\r\\n      // Exponential form?\\r\\n      if ((i = str.search(/e/i)) > 0) {\\r\\n\\r\\n        // Determine exponent.\\r\\n        if (e < 0) e = i;\\r\\n        e += +str.slice(i + 1);\\r\\n        str = str.substring(0, i);\\r\\n      } else if (e < 0) {\\r\\n\\r\\n        // Integer.\\r\\n        e = str.length;\\r\\n      }\\r\\n\\r\\n    } else {\\r\\n\\r\\n      // '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}'\\r\\n      intCheck(b, 2, ALPHABET.length, 'Base');\\r\\n\\r\\n      // Allow exponential notation to be used with base 10 argument, while\\r\\n      // also rounding to DECIMAL_PLACES as with other bases.\\r\\n      if (b == 10 && alphabetHasNormalDecimalDigits) {\\r\\n        x = new BigNumber(v);\\r\\n        return round(x, DECIMAL_PLACES + x.e + 1, ROUNDING_MODE);\\r\\n      }\\r\\n\\r\\n      str = String(v);\\r\\n\\r\\n      if (isNum = typeof v == 'number') {\\r\\n\\r\\n        // Avoid potential interpretation of Infinity and NaN as base 44+ values.\\r\\n        if (v * 0 != 0) return parseNumeric(x, str, isNum, b);\\r\\n\\r\\n        x.s = 1 / v < 0 ? (str = str.slice(1), -1) : 1;\\r\\n\\r\\n        // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'\\r\\n        if (BigNumber.DEBUG && str.replace(/^0\\\\.0*|\\\\./, '').length > 15) {\\r\\n          throw Error\\r\\n           (tooManyDigits + v);\\r\\n        }\\r\\n      } else {\\r\\n        x.s = str.charCodeAt(0) === 45 ? (str = str.slice(1), -1) : 1;\\r\\n      }\\r\\n\\r\\n      alphabet = ALPHABET.slice(0, b);\\r\\n      e = i = 0;\\r\\n\\r\\n      // Check that str is a valid base b number.\\r\\n      // Don't use RegExp, so alphabet can contain special characters.\\r\\n      for (len = str.length; i < len; i++) {\\r\\n        if (alphabet.indexOf(c = str.charAt(i)) < 0) {\\r\\n          if (c == '.') {\\r\\n\\r\\n            // If '.' is not the first character and it has not be found before.\\r\\n            if (i > e) {\\r\\n              e = len;\\r\\n              continue;\\r\\n            }\\r\\n          } else if (!caseChanged) {\\r\\n\\r\\n            // Allow e.g. hexadecimal 'FF' as well as 'ff'.\\r\\n            if (str == str.toUpperCase() && (str = str.toLowerCase()) ||\\r\\n                str == str.toLowerCase() && (str = str.toUpperCase())) {\\r\\n              caseChanged = true;\\r\\n              i = -1;\\r\\n              e = 0;\\r\\n              continue;\\r\\n            }\\r\\n          }\\r\\n\\r\\n          return parseNumeric(x, String(v), isNum, b);\\r\\n        }\\r\\n      }\\r\\n\\r\\n      // Prevent later check for length on converted number.\\r\\n      isNum = false;\\r\\n      str = convertBase(str, b, 10, x.s);\\r\\n\\r\\n      // Decimal point?\\r\\n      if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');\\r\\n      else e = str.length;\\r\\n    }\\r\\n\\r\\n    // Determine leading zeros.\\r\\n    for (i = 0; str.charCodeAt(i) === 48; i++);\\r\\n\\r\\n    // Determine trailing zeros.\\r\\n    for (len = str.length; str.charCodeAt(--len) === 48;);\\r\\n\\r\\n    if (str = str.slice(i, ++len)) {\\r\\n      len -= i;\\r\\n\\r\\n      // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'\\r\\n      if (isNum && BigNumber.DEBUG &&\\r\\n        len > 15 && (v > MAX_SAFE_INTEGER || v !== mathfloor(v))) {\\r\\n          throw Error\\r\\n           (tooManyDigits + (x.s * v));\\r\\n      }\\r\\n\\r\\n       // Overflow?\\r\\n      if ((e = e - i - 1) > MAX_EXP) {\\r\\n\\r\\n        // Infinity.\\r\\n        x.c = x.e = null;\\r\\n\\r\\n      // Underflow?\\r\\n      } else if (e < MIN_EXP) {\\r\\n\\r\\n        // Zero.\\r\\n        x.c = [x.e = 0];\\r\\n      } else {\\r\\n        x.e = e;\\r\\n        x.c = [];\\r\\n\\r\\n        // Transform base\\r\\n\\r\\n        // e is the base 10 exponent.\\r\\n        // i is where to slice str to get the first element of the coefficient array.\\r\\n        i = (e + 1) % LOG_BASE;\\r\\n        if (e < 0) i += LOG_BASE;  // i < 1\\r\\n\\r\\n        if (i < len) {\\r\\n          if (i) x.c.push(+str.slice(0, i));\\r\\n\\r\\n          for (len -= LOG_BASE; i < len;) {\\r\\n            x.c.push(+str.slice(i, i += LOG_BASE));\\r\\n          }\\r\\n\\r\\n          i = LOG_BASE - (str = str.slice(i)).length;\\r\\n        } else {\\r\\n          i -= len;\\r\\n        }\\r\\n\\r\\n        for (; i--; str += '0');\\r\\n        x.c.push(+str);\\r\\n      }\\r\\n    } else {\\r\\n\\r\\n      // Zero.\\r\\n      x.c = [x.e = 0];\\r\\n    }\\r\\n  }\\r\\n\\r\\n\\r\\n  // CONSTRUCTOR PROPERTIES\\r\\n\\r\\n\\r\\n  BigNumber.clone = clone;\\r\\n\\r\\n  BigNumber.ROUND_UP = 0;\\r\\n  BigNumber.ROUND_DOWN = 1;\\r\\n  BigNumber.ROUND_CEIL = 2;\\r\\n  BigNumber.ROUND_FLOOR = 3;\\r\\n  BigNumber.ROUND_HALF_UP = 4;\\r\\n  BigNumber.ROUND_HALF_DOWN = 5;\\r\\n  BigNumber.ROUND_HALF_EVEN = 6;\\r\\n  BigNumber.ROUND_HALF_CEIL = 7;\\r\\n  BigNumber.ROUND_HALF_FLOOR = 8;\\r\\n  BigNumber.EUCLID = 9;\\r\\n\\r\\n\\r\\n  /*\\r\\n   * Configure infrequently-changing library-wide settings.\\r\\n   *\\r\\n   * Accept an object with the following optional properties (if the value of a property is\\r\\n   * a number, it must be an integer within the inclusive range stated):\\r\\n   *\\r\\n   *   DECIMAL_PLACES   {number}           0 to MAX\\r\\n   *   ROUNDING_MODE    {number}           0 to 8\\r\\n   *   EXPONENTIAL_AT   {number|number[]}  -MAX to MAX  or  [-MAX to 0, 0 to MAX]\\r\\n   *   RANGE            {number|number[]}  -MAX to MAX (not zero)  or  [-MAX to -1, 1 to MAX]\\r\\n   *   CRYPTO           {boolean}          true or false\\r\\n   *   MODULO_MODE      {number}           0 to 9\\r\\n   *   POW_PRECISION       {number}           0 to MAX\\r\\n   *   ALPHABET         {string}           A string of two or more unique characters which does\\r\\n   *                                       not contain '.'.\\r\\n   *   FORMAT           {object}           An object with some of the following properties:\\r\\n   *     prefix                 {string}\\r\\n   *     groupSize              {number}\\r\\n   *     secondaryGroupSize     {number}\\r\\n   *     groupSeparator         {string}\\r\\n   *     decimalSeparator       {string}\\r\\n   *     fractionGroupSize      {number}\\r\\n   *     fractionGroupSeparator {string}\\r\\n   *     suffix                 {string}\\r\\n   *\\r\\n   * (The values assigned to the above FORMAT object properties are not checked for validity.)\\r\\n   *\\r\\n   * E.g.\\r\\n   * BigNumber.config({ DECIMAL_PLACES : 20, ROUNDING_MODE : 4 })\\r\\n   *\\r\\n   * Ignore properties/parameters set to null or undefined, except for ALPHABET.\\r\\n   *\\r\\n   * Return an object with the properties current values.\\r\\n   */\\r\\n  BigNumber.config = BigNumber.set = function (obj) {\\r\\n    var p, v;\\r\\n\\r\\n    if (obj != null) {\\r\\n\\r\\n      if (typeof obj == 'object') {\\r\\n\\r\\n        // DECIMAL_PLACES {number} Integer, 0 to MAX inclusive.\\r\\n        // '[BigNumber Error] DECIMAL_PLACES {not a primitive number|not an integer|out of range}: {v}'\\r\\n        if (obj.hasOwnProperty(p = 'DECIMAL_PLACES')) {\\r\\n          v = obj[p];\\r\\n          intCheck(v, 0, MAX, p);\\r\\n          DECIMAL_PLACES = v;\\r\\n        }\\r\\n\\r\\n        // ROUNDING_MODE {number} Integer, 0 to 8 inclusive.\\r\\n        // '[BigNumber Error] ROUNDING_MODE {not a primitive number|not an integer|out of range}: {v}'\\r\\n        if (obj.hasOwnProperty(p = 'ROUNDING_MODE')) {\\r\\n          v = obj[p];\\r\\n          intCheck(v, 0, 8, p);\\r\\n          ROUNDING_MODE = v;\\r\\n        }\\r\\n\\r\\n        // EXPONENTIAL_AT {number|number[]}\\r\\n        // Integer, -MAX to MAX inclusive or\\r\\n        // [integer -MAX to 0 inclusive, 0 to MAX inclusive].\\r\\n        // '[BigNumber Error] EXPONENTIAL_AT {not a primitive number|not an integer|out of range}: {v}'\\r\\n        if (obj.hasOwnProperty(p = 'EXPONENTIAL_AT')) {\\r\\n          v = obj[p];\\r\\n          if (v && v.pop) {\\r\\n            intCheck(v[0], -MAX, 0, p);\\r\\n            intCheck(v[1], 0, MAX, p);\\r\\n            TO_EXP_NEG = v[0];\\r\\n            TO_EXP_POS = v[1];\\r\\n          } else {\\r\\n            intCheck(v, -MAX, MAX, p);\\r\\n            TO_EXP_NEG = -(TO_EXP_POS = v < 0 ? -v : v);\\r\\n          }\\r\\n        }\\r\\n\\r\\n        // RANGE {number|number[]} Non-zero integer, -MAX to MAX inclusive or\\r\\n        // [integer -MAX to -1 inclusive, integer 1 to MAX inclusive].\\r\\n        // '[BigNumber Error] RANGE {not a primitive number|not an integer|out of range|cannot be zero}: {v}'\\r\\n        if (obj.hasOwnProperty(p = 'RANGE')) {\\r\\n          v = obj[p];\\r\\n          if (v && v.pop) {\\r\\n            intCheck(v[0], -MAX, -1, p);\\r\\n            intCheck(v[1], 1, MAX, p);\\r\\n            MIN_EXP = v[0];\\r\\n            MAX_EXP = v[1];\\r\\n          } else {\\r\\n            intCheck(v, -MAX, MAX, p);\\r\\n            if (v) {\\r\\n              MIN_EXP = -(MAX_EXP = v < 0 ? -v : v);\\r\\n            } else {\\r\\n              throw Error\\r\\n               (bignumberError + p + ' cannot be zero: ' + v);\\r\\n            }\\r\\n          }\\r\\n        }\\r\\n\\r\\n        // CRYPTO {boolean} true or false.\\r\\n        // '[BigNumber Error] CRYPTO not true or false: {v}'\\r\\n        // '[BigNumber Error] crypto unavailable'\\r\\n        if (obj.hasOwnProperty(p = 'CRYPTO')) {\\r\\n          v = obj[p];\\r\\n          if (v === !!v) {\\r\\n            if (v) {\\r\\n              if (typeof crypto != 'undefined' && crypto &&\\r\\n               (crypto.getRandomValues || crypto.randomBytes)) {\\r\\n                CRYPTO = v;\\r\\n              } else {\\r\\n                CRYPTO = !v;\\r\\n                throw Error\\r\\n                 (bignumberError + 'crypto unavailable');\\r\\n              }\\r\\n            } else {\\r\\n              CRYPTO = v;\\r\\n            }\\r\\n          } else {\\r\\n            throw Error\\r\\n             (bignumberError + p + ' not true or false: ' + v);\\r\\n          }\\r\\n        }\\r\\n\\r\\n        // MODULO_MODE {number} Integer, 0 to 9 inclusive.\\r\\n        // '[BigNumber Error] MODULO_MODE {not a primitive number|not an integer|out of range}: {v}'\\r\\n        if (obj.hasOwnProperty(p = 'MODULO_MODE')) {\\r\\n          v = obj[p];\\r\\n          intCheck(v, 0, 9, p);\\r\\n          MODULO_MODE = v;\\r\\n        }\\r\\n\\r\\n        // POW_PRECISION {number} Integer, 0 to MAX inclusive.\\r\\n        // '[BigNumber Error] POW_PRECISION {not a primitive number|not an integer|out of range}: {v}'\\r\\n        if (obj.hasOwnProperty(p = 'POW_PRECISION')) {\\r\\n          v = obj[p];\\r\\n          intCheck(v, 0, MAX, p);\\r\\n          POW_PRECISION = v;\\r\\n        }\\r\\n\\r\\n        // FORMAT {object}\\r\\n        // '[BigNumber Error] FORMAT not an object: {v}'\\r\\n        if (obj.hasOwnProperty(p = 'FORMAT')) {\\r\\n          v = obj[p];\\r\\n          if (typeof v == 'object') FORMAT = v;\\r\\n          else throw Error\\r\\n           (bignumberError + p + ' not an object: ' + v);\\r\\n        }\\r\\n\\r\\n        // ALPHABET {string}\\r\\n        // '[BigNumber Error] ALPHABET invalid: {v}'\\r\\n        if (obj.hasOwnProperty(p = 'ALPHABET')) {\\r\\n          v = obj[p];\\r\\n\\r\\n          // Disallow if less than two characters,\\r\\n          // or if it contains '+', '-', '.', whitespace, or a repeated character.\\r\\n          if (typeof v == 'string' && !/^.?$|[+\\\\-.\\\\s]|(.).*\\\\1/.test(v)) {\\r\\n            alphabetHasNormalDecimalDigits = v.slice(0, 10) == '0123456789';\\r\\n            ALPHABET = v;\\r\\n          } else {\\r\\n            throw Error\\r\\n             (bignumberError + p + ' invalid: ' + v);\\r\\n          }\\r\\n        }\\r\\n\\r\\n      } else {\\r\\n\\r\\n        // '[BigNumber Error] Object expected: {v}'\\r\\n        throw Error\\r\\n         (bignumberError + 'Object expected: ' + obj);\\r\\n      }\\r\\n    }\\r\\n\\r\\n    return {\\r\\n      DECIMAL_PLACES: DECIMAL_PLACES,\\r\\n      ROUNDING_MODE: ROUNDING_MODE,\\r\\n      EXPONENTIAL_AT: [TO_EXP_NEG, TO_EXP_POS],\\r\\n      RANGE: [MIN_EXP, MAX_EXP],\\r\\n      CRYPTO: CRYPTO,\\r\\n      MODULO_MODE: MODULO_MODE,\\r\\n      POW_PRECISION: POW_PRECISION,\\r\\n      FORMAT: FORMAT,\\r\\n      ALPHABET: ALPHABET\\r\\n    };\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   * Return true if v is a BigNumber instance, otherwise return false.\\r\\n   *\\r\\n   * If BigNumber.DEBUG is true, throw if a BigNumber instance is not well-formed.\\r\\n   *\\r\\n   * v {any}\\r\\n   *\\r\\n   * '[BigNumber Error] Invalid BigNumber: {v}'\\r\\n   */\\r\\n  BigNumber.isBigNumber = function (v) {\\r\\n    if (!v || v._isBigNumber !== true) return false;\\r\\n    if (!BigNumber.DEBUG) return true;\\r\\n\\r\\n    var i, n,\\r\\n      c = v.c,\\r\\n      e = v.e,\\r\\n      s = v.s;\\r\\n\\r\\n    out: if ({}.toString.call(c) == '[object Array]') {\\r\\n\\r\\n      if ((s === 1 || s === -1) && e >= -MAX && e <= MAX && e === mathfloor(e)) {\\r\\n\\r\\n        // If the first element is zero, the BigNumber value must be zero.\\r\\n        if (c[0] === 0) {\\r\\n          if (e === 0 && c.length === 1) return true;\\r\\n          break out;\\r\\n        }\\r\\n\\r\\n        // Calculate number of digits that c[0] should have, based on the exponent.\\r\\n        i = (e + 1) % LOG_BASE;\\r\\n        if (i < 1) i += LOG_BASE;\\r\\n\\r\\n        // Calculate number of digits of c[0].\\r\\n        //if (Math.ceil(Math.log(c[0] + 1) / Math.LN10) == i) {\\r\\n        if (String(c[0]).length == i) {\\r\\n\\r\\n          for (i = 0; i < c.length; i++) {\\r\\n            n = c[i];\\r\\n            if (n < 0 || n >= BASE || n !== mathfloor(n)) break out;\\r\\n          }\\r\\n\\r\\n          // Last element cannot be zero, unless it is the only element.\\r\\n          if (n !== 0) return true;\\r\\n        }\\r\\n      }\\r\\n\\r\\n    // Infinity/NaN\\r\\n    } else if (c === null && e === null && (s === null || s === 1 || s === -1)) {\\r\\n      return true;\\r\\n    }\\r\\n\\r\\n    throw Error\\r\\n      (bignumberError + 'Invalid BigNumber: ' + v);\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   * Return a new BigNumber whose value is the maximum of the arguments.\\r\\n   *\\r\\n   * arguments {number|string|BigNumber}\\r\\n   */\\r\\n  BigNumber.maximum = BigNumber.max = function () {\\r\\n    return maxOrMin(arguments, P.lt);\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   * Return a new BigNumber whose value is the minimum of the arguments.\\r\\n   *\\r\\n   * arguments {number|string|BigNumber}\\r\\n   */\\r\\n  BigNumber.minimum = BigNumber.min = function () {\\r\\n    return maxOrMin(arguments, P.gt);\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   * Return a new BigNumber with a random value equal to or greater than 0 and less than 1,\\r\\n   * and with dp, or DECIMAL_PLACES if dp is omitted, decimal places (or less if trailing\\r\\n   * zeros are produced).\\r\\n   *\\r\\n   * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\\r\\n   *\\r\\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp}'\\r\\n   * '[BigNumber Error] crypto unavailable'\\r\\n   */\\r\\n  BigNumber.random = (function () {\\r\\n    var pow2_53 = 0x20000000000000;\\r\\n\\r\\n    // Return a 53 bit integer n, where 0 <= n < 9007199254740992.\\r\\n    // Check if Math.random() produces more than 32 bits of randomness.\\r\\n    // If it does, assume at least 53 bits are produced, otherwise assume at least 30 bits.\\r\\n    // 0x40000000 is 2^30, 0x800000 is 2^23, 0x1fffff is 2^21 - 1.\\r\\n    var random53bitInt = (Math.random() * pow2_53) & 0x1fffff\\r\\n     ? function () { return mathfloor(Math.random() * pow2_53); }\\r\\n     : function () { return ((Math.random() * 0x40000000 | 0) * 0x800000) +\\r\\n       (Math.random() * 0x800000 | 0); };\\r\\n\\r\\n    return function (dp) {\\r\\n      var a, b, e, k, v,\\r\\n        i = 0,\\r\\n        c = [],\\r\\n        rand = new BigNumber(ONE);\\r\\n\\r\\n      if (dp == null) dp = DECIMAL_PLACES;\\r\\n      else intCheck(dp, 0, MAX);\\r\\n\\r\\n      k = mathceil(dp / LOG_BASE);\\r\\n\\r\\n      if (CRYPTO) {\\r\\n\\r\\n        // Browsers supporting crypto.getRandomValues.\\r\\n        if (crypto.getRandomValues) {\\r\\n\\r\\n          a = crypto.getRandomValues(new Uint32Array(k *= 2));\\r\\n\\r\\n          for (; i < k;) {\\r\\n\\r\\n            // 53 bits:\\r\\n            // ((Math.pow(2, 32) - 1) * Math.pow(2, 21)).toString(2)\\r\\n            // 11111 11111111 11111111 11111111 11100000 00000000 00000000\\r\\n            // ((Math.pow(2, 32) - 1) >>> 11).toString(2)\\r\\n            //                                     11111 11111111 11111111\\r\\n            // 0x20000 is 2^21.\\r\\n            v = a[i] * 0x20000 + (a[i + 1] >>> 11);\\r\\n\\r\\n            // Rejection sampling:\\r\\n            // 0 <= v < 9007199254740992\\r\\n            // Probability that v >= 9e15, is\\r\\n            // 7199254740992 / 9007199254740992 ~= 0.0008, i.e. 1 in 1251\\r\\n            if (v >= 9e15) {\\r\\n              b = crypto.getRandomValues(new Uint32Array(2));\\r\\n              a[i] = b[0];\\r\\n              a[i + 1] = b[1];\\r\\n            } else {\\r\\n\\r\\n              // 0 <= v <= 8999999999999999\\r\\n              // 0 <= (v % 1e14) <= 99999999999999\\r\\n              c.push(v % 1e14);\\r\\n              i += 2;\\r\\n            }\\r\\n          }\\r\\n          i = k / 2;\\r\\n\\r\\n        // Node.js supporting crypto.randomBytes.\\r\\n        } else if (crypto.randomBytes) {\\r\\n\\r\\n          // buffer\\r\\n          a = crypto.randomBytes(k *= 7);\\r\\n\\r\\n          for (; i < k;) {\\r\\n\\r\\n            // 0x1000000000000 is 2^48, 0x10000000000 is 2^40\\r\\n            // 0x100000000 is 2^32, 0x1000000 is 2^24\\r\\n            // 11111 11111111 11111111 11111111 11111111 11111111 11111111\\r\\n            // 0 <= v < 9007199254740992\\r\\n            v = ((a[i] & 31) * 0x1000000000000) + (a[i + 1] * 0x10000000000) +\\r\\n               (a[i + 2] * 0x100000000) + (a[i + 3] * 0x1000000) +\\r\\n               (a[i + 4] << 16) + (a[i + 5] << 8) + a[i + 6];\\r\\n\\r\\n            if (v >= 9e15) {\\r\\n              crypto.randomBytes(7).copy(a, i);\\r\\n            } else {\\r\\n\\r\\n              // 0 <= (v % 1e14) <= 99999999999999\\r\\n              c.push(v % 1e14);\\r\\n              i += 7;\\r\\n            }\\r\\n          }\\r\\n          i = k / 7;\\r\\n        } else {\\r\\n          CRYPTO = false;\\r\\n          throw Error\\r\\n           (bignumberError + 'crypto unavailable');\\r\\n        }\\r\\n      }\\r\\n\\r\\n      // Use Math.random.\\r\\n      if (!CRYPTO) {\\r\\n\\r\\n        for (; i < k;) {\\r\\n          v = random53bitInt();\\r\\n          if (v < 9e15) c[i++] = v % 1e14;\\r\\n        }\\r\\n      }\\r\\n\\r\\n      k = c[--i];\\r\\n      dp %= LOG_BASE;\\r\\n\\r\\n      // Convert trailing digits to zeros according to dp.\\r\\n      if (k && dp) {\\r\\n        v = POWS_TEN[LOG_BASE - dp];\\r\\n        c[i] = mathfloor(k / v) * v;\\r\\n      }\\r\\n\\r\\n      // Remove trailing elements which are zero.\\r\\n      for (; c[i] === 0; c.pop(), i--);\\r\\n\\r\\n      // Zero?\\r\\n      if (i < 0) {\\r\\n        c = [e = 0];\\r\\n      } else {\\r\\n\\r\\n        // Remove leading elements which are zero and adjust exponent accordingly.\\r\\n        for (e = -1 ; c[0] === 0; c.splice(0, 1), e -= LOG_BASE);\\r\\n\\r\\n        // Count the digits of the first element of c to determine leading zeros, and...\\r\\n        for (i = 1, v = c[0]; v >= 10; v /= 10, i++);\\r\\n\\r\\n        // adjust the exponent accordingly.\\r\\n        if (i < LOG_BASE) e -= LOG_BASE - i;\\r\\n      }\\r\\n\\r\\n      rand.e = e;\\r\\n      rand.c = c;\\r\\n      return rand;\\r\\n    };\\r\\n  })();\\r\\n\\r\\n\\r\\n   /*\\r\\n   * Return a BigNumber whose value is the sum of the arguments.\\r\\n   *\\r\\n   * arguments {number|string|BigNumber}\\r\\n   */\\r\\n  BigNumber.sum = function () {\\r\\n    var i = 1,\\r\\n      args = arguments,\\r\\n      sum = new BigNumber(args[0]);\\r\\n    for (; i < args.length;) sum = sum.plus(args[i++]);\\r\\n    return sum;\\r\\n  };\\r\\n\\r\\n\\r\\n  // PRIVATE FUNCTIONS\\r\\n\\r\\n\\r\\n  // Called by BigNumber and BigNumber.prototype.toString.\\r\\n  convertBase = (function () {\\r\\n    var decimal = '0123456789';\\r\\n\\r\\n    /*\\r\\n     * Convert string of baseIn to an array of numbers of baseOut.\\r\\n     * Eg. toBaseOut('255', 10, 16) returns [15, 15].\\r\\n     * Eg. toBaseOut('ff', 16, 10) returns [2, 5, 5].\\r\\n     */\\r\\n    function toBaseOut(str, baseIn, baseOut, alphabet) {\\r\\n      var j,\\r\\n        arr = [0],\\r\\n        arrL,\\r\\n        i = 0,\\r\\n        len = str.length;\\r\\n\\r\\n      for (; i < len;) {\\r\\n        for (arrL = arr.length; arrL--; arr[arrL] *= baseIn);\\r\\n\\r\\n        arr[0] += alphabet.indexOf(str.charAt(i++));\\r\\n\\r\\n        for (j = 0; j < arr.length; j++) {\\r\\n\\r\\n          if (arr[j] > baseOut - 1) {\\r\\n            if (arr[j + 1] == null) arr[j + 1] = 0;\\r\\n            arr[j + 1] += arr[j] / baseOut | 0;\\r\\n            arr[j] %= baseOut;\\r\\n          }\\r\\n        }\\r\\n      }\\r\\n\\r\\n      return arr.reverse();\\r\\n    }\\r\\n\\r\\n    // Convert a numeric string of baseIn to a numeric string of baseOut.\\r\\n    // If the caller is toString, we are converting from base 10 to baseOut.\\r\\n    // If the caller is BigNumber, we are converting from baseIn to base 10.\\r\\n    return function (str, baseIn, baseOut, sign, callerIsToString) {\\r\\n      var alphabet, d, e, k, r, x, xc, y,\\r\\n        i = str.indexOf('.'),\\r\\n        dp = DECIMAL_PLACES,\\r\\n        rm = ROUNDING_MODE;\\r\\n\\r\\n      // Non-integer.\\r\\n      if (i >= 0) {\\r\\n        k = POW_PRECISION;\\r\\n\\r\\n        // Unlimited precision.\\r\\n        POW_PRECISION = 0;\\r\\n        str = str.replace('.', '');\\r\\n        y = new BigNumber(baseIn);\\r\\n        x = y.pow(str.length - i);\\r\\n        POW_PRECISION = k;\\r\\n\\r\\n        // Convert str as if an integer, then restore the fraction part by dividing the\\r\\n        // result by its base raised to a power.\\r\\n\\r\\n        y.c = toBaseOut(toFixedPoint(coeffToString(x.c), x.e, '0'),\\r\\n         10, baseOut, decimal);\\r\\n        y.e = y.c.length;\\r\\n      }\\r\\n\\r\\n      // Convert the number as integer.\\r\\n\\r\\n      xc = toBaseOut(str, baseIn, baseOut, callerIsToString\\r\\n       ? (alphabet = ALPHABET, decimal)\\r\\n       : (alphabet = decimal, ALPHABET));\\r\\n\\r\\n      // xc now represents str as an integer and converted to baseOut. e is the exponent.\\r\\n      e = k = xc.length;\\r\\n\\r\\n      // Remove trailing zeros.\\r\\n      for (; xc[--k] == 0; xc.pop());\\r\\n\\r\\n      // Zero?\\r\\n      if (!xc[0]) return alphabet.charAt(0);\\r\\n\\r\\n      // Does str represent an integer? If so, no need for the division.\\r\\n      if (i < 0) {\\r\\n        --e;\\r\\n      } else {\\r\\n        x.c = xc;\\r\\n        x.e = e;\\r\\n\\r\\n        // The sign is needed for correct rounding.\\r\\n        x.s = sign;\\r\\n        x = div(x, y, dp, rm, baseOut);\\r\\n        xc = x.c;\\r\\n        r = x.r;\\r\\n        e = x.e;\\r\\n      }\\r\\n\\r\\n      // xc now represents str converted to baseOut.\\r\\n\\r\\n      // THe index of the rounding digit.\\r\\n      d = e + dp + 1;\\r\\n\\r\\n      // The rounding digit: the digit to the right of the digit that may be rounded up.\\r\\n      i = xc[d];\\r\\n\\r\\n      // Look at the rounding digits and mode to determine whether to round up.\\r\\n\\r\\n      k = baseOut / 2;\\r\\n      r = r || d < 0 || xc[d + 1] != null;\\r\\n\\r\\n      r = rm < 4 ? (i != null || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\\r\\n            : i > k || i == k &&(rm == 4 || r || rm == 6 && xc[d - 1] & 1 ||\\r\\n             rm == (x.s < 0 ? 8 : 7));\\r\\n\\r\\n      // If the index of the rounding digit is not greater than zero, or xc represents\\r\\n      // zero, then the result of the base conversion is zero or, if rounding up, a value\\r\\n      // such as 0.00001.\\r\\n      if (d < 1 || !xc[0]) {\\r\\n\\r\\n        // 1^-dp or 0\\r\\n        str = r ? toFixedPoint(alphabet.charAt(1), -dp, alphabet.charAt(0)) : alphabet.charAt(0);\\r\\n      } else {\\r\\n\\r\\n        // Truncate xc to the required number of decimal places.\\r\\n        xc.length = d;\\r\\n\\r\\n        // Round up?\\r\\n        if (r) {\\r\\n\\r\\n          // Rounding up may mean the previous digit has to be rounded up and so on.\\r\\n          for (--baseOut; ++xc[--d] > baseOut;) {\\r\\n            xc[d] = 0;\\r\\n\\r\\n            if (!d) {\\r\\n              ++e;\\r\\n              xc = [1].concat(xc);\\r\\n            }\\r\\n          }\\r\\n        }\\r\\n\\r\\n        // Determine trailing zeros.\\r\\n        for (k = xc.length; !xc[--k];);\\r\\n\\r\\n        // E.g. [4, 11, 15] becomes 4bf.\\r\\n        for (i = 0, str = ''; i <= k; str += alphabet.charAt(xc[i++]));\\r\\n\\r\\n        // Add leading zeros, decimal point and trailing zeros as required.\\r\\n        str = toFixedPoint(str, e, alphabet.charAt(0));\\r\\n      }\\r\\n\\r\\n      // The caller will add the sign.\\r\\n      return str;\\r\\n    };\\r\\n  })();\\r\\n\\r\\n\\r\\n  // Perform division in the specified base. Called by div and convertBase.\\r\\n  div = (function () {\\r\\n\\r\\n    // Assume non-zero x and k.\\r\\n    function multiply(x, k, base) {\\r\\n      var m, temp, xlo, xhi,\\r\\n        carry = 0,\\r\\n        i = x.length,\\r\\n        klo = k % SQRT_BASE,\\r\\n        khi = k / SQRT_BASE | 0;\\r\\n\\r\\n      for (x = x.slice(); i--;) {\\r\\n        xlo = x[i] % SQRT_BASE;\\r\\n        xhi = x[i] / SQRT_BASE | 0;\\r\\n        m = khi * xlo + xhi * klo;\\r\\n        temp = klo * xlo + ((m % SQRT_BASE) * SQRT_BASE) + carry;\\r\\n        carry = (temp / base | 0) + (m / SQRT_BASE | 0) + khi * xhi;\\r\\n        x[i] = temp % base;\\r\\n      }\\r\\n\\r\\n      if (carry) x = [carry].concat(x);\\r\\n\\r\\n      return x;\\r\\n    }\\r\\n\\r\\n    function compare(a, b, aL, bL) {\\r\\n      var i, cmp;\\r\\n\\r\\n      if (aL != bL) {\\r\\n        cmp = aL > bL ? 1 : -1;\\r\\n      } else {\\r\\n\\r\\n        for (i = cmp = 0; i < aL; i++) {\\r\\n\\r\\n          if (a[i] != b[i]) {\\r\\n            cmp = a[i] > b[i] ? 1 : -1;\\r\\n            break;\\r\\n          }\\r\\n        }\\r\\n      }\\r\\n\\r\\n      return cmp;\\r\\n    }\\r\\n\\r\\n    function subtract(a, b, aL, base) {\\r\\n      var i = 0;\\r\\n\\r\\n      // Subtract b from a.\\r\\n      for (; aL--;) {\\r\\n        a[aL] -= i;\\r\\n        i = a[aL] < b[aL] ? 1 : 0;\\r\\n        a[aL] = i * base + a[aL] - b[aL];\\r\\n      }\\r\\n\\r\\n      // Remove leading zeros.\\r\\n      for (; !a[0] && a.length > 1; a.splice(0, 1));\\r\\n    }\\r\\n\\r\\n    // x: dividend, y: divisor.\\r\\n    return function (x, y, dp, rm, base) {\\r\\n      var cmp, e, i, more, n, prod, prodL, q, qc, rem, remL, rem0, xi, xL, yc0,\\r\\n        yL, yz,\\r\\n        s = x.s == y.s ? 1 : -1,\\r\\n        xc = x.c,\\r\\n        yc = y.c;\\r\\n\\r\\n      // Either NaN, Infinity or 0?\\r\\n      if (!xc || !xc[0] || !yc || !yc[0]) {\\r\\n\\r\\n        return new BigNumber(\\r\\n\\r\\n         // Return NaN if either NaN, or both Infinity or 0.\\r\\n         !x.s || !y.s || (xc ? yc && xc[0] == yc[0] : !yc) ? NaN :\\r\\n\\r\\n          // Return ±0 if x is ±0 or y is ±Infinity, or return ±Infinity as y is ±0.\\r\\n          xc && xc[0] == 0 || !yc ? s * 0 : s / 0\\r\\n       );\\r\\n      }\\r\\n\\r\\n      q = new BigNumber(s);\\r\\n      qc = q.c = [];\\r\\n      e = x.e - y.e;\\r\\n      s = dp + e + 1;\\r\\n\\r\\n      if (!base) {\\r\\n        base = BASE;\\r\\n        e = bitFloor(x.e / LOG_BASE) - bitFloor(y.e / LOG_BASE);\\r\\n        s = s / LOG_BASE | 0;\\r\\n      }\\r\\n\\r\\n      // Result exponent may be one less then the current value of e.\\r\\n      // The coefficients of the BigNumbers from convertBase may have trailing zeros.\\r\\n      for (i = 0; yc[i] == (xc[i] || 0); i++);\\r\\n\\r\\n      if (yc[i] > (xc[i] || 0)) e--;\\r\\n\\r\\n      if (s < 0) {\\r\\n        qc.push(1);\\r\\n        more = true;\\r\\n      } else {\\r\\n        xL = xc.length;\\r\\n        yL = yc.length;\\r\\n        i = 0;\\r\\n        s += 2;\\r\\n\\r\\n        // Normalise xc and yc so highest order digit of yc is >= base / 2.\\r\\n\\r\\n        n = mathfloor(base / (yc[0] + 1));\\r\\n\\r\\n        // Not necessary, but to handle odd bases where yc[0] == (base / 2) - 1.\\r\\n        // if (n > 1 || n++ == 1 && yc[0] < base / 2) {\\r\\n        if (n > 1) {\\r\\n          yc = multiply(yc, n, base);\\r\\n          xc = multiply(xc, n, base);\\r\\n          yL = yc.length;\\r\\n          xL = xc.length;\\r\\n        }\\r\\n\\r\\n        xi = yL;\\r\\n        rem = xc.slice(0, yL);\\r\\n        remL = rem.length;\\r\\n\\r\\n        // Add zeros to make remainder as long as divisor.\\r\\n        for (; remL < yL; rem[remL++] = 0);\\r\\n        yz = yc.slice();\\r\\n        yz = [0].concat(yz);\\r\\n        yc0 = yc[0];\\r\\n        if (yc[1] >= base / 2) yc0++;\\r\\n        // Not necessary, but to prevent trial digit n > base, when using base 3.\\r\\n        // else if (base == 3 && yc0 == 1) yc0 = 1 + 1e-15;\\r\\n\\r\\n        do {\\r\\n          n = 0;\\r\\n\\r\\n          // Compare divisor and remainder.\\r\\n          cmp = compare(yc, rem, yL, remL);\\r\\n\\r\\n          // If divisor < remainder.\\r\\n          if (cmp < 0) {\\r\\n\\r\\n            // Calculate trial digit, n.\\r\\n\\r\\n            rem0 = rem[0];\\r\\n            if (yL != remL) rem0 = rem0 * base + (rem[1] || 0);\\r\\n\\r\\n            // n is how many times the divisor goes into the current remainder.\\r\\n            n = mathfloor(rem0 / yc0);\\r\\n\\r\\n            //  Algorithm:\\r\\n            //  product = divisor multiplied by trial digit (n).\\r\\n            //  Compare product and remainder.\\r\\n            //  If product is greater than remainder:\\r\\n            //    Subtract divisor from product, decrement trial digit.\\r\\n            //  Subtract product from remainder.\\r\\n            //  If product was less than remainder at the last compare:\\r\\n            //    Compare new remainder and divisor.\\r\\n            //    If remainder is greater than divisor:\\r\\n            //      Subtract divisor from remainder, increment trial digit.\\r\\n\\r\\n            if (n > 1) {\\r\\n\\r\\n              // n may be > base only when base is 3.\\r\\n              if (n >= base) n = base - 1;\\r\\n\\r\\n              // product = divisor * trial digit.\\r\\n              prod = multiply(yc, n, base);\\r\\n              prodL = prod.length;\\r\\n              remL = rem.length;\\r\\n\\r\\n              // Compare product and remainder.\\r\\n              // If product > remainder then trial digit n too high.\\r\\n              // n is 1 too high about 5% of the time, and is not known to have\\r\\n              // ever been more than 1 too high.\\r\\n              while (compare(prod, rem, prodL, remL) == 1) {\\r\\n                n--;\\r\\n\\r\\n                // Subtract divisor from product.\\r\\n                subtract(prod, yL < prodL ? yz : yc, prodL, base);\\r\\n                prodL = prod.length;\\r\\n                cmp = 1;\\r\\n              }\\r\\n            } else {\\r\\n\\r\\n              // n is 0 or 1, cmp is -1.\\r\\n              // If n is 0, there is no need to compare yc and rem again below,\\r\\n              // so change cmp to 1 to avoid it.\\r\\n              // If n is 1, leave cmp as -1, so yc and rem are compared again.\\r\\n              if (n == 0) {\\r\\n\\r\\n                // divisor < remainder, so n must be at least 1.\\r\\n                cmp = n = 1;\\r\\n              }\\r\\n\\r\\n              // product = divisor\\r\\n              prod = yc.slice();\\r\\n              prodL = prod.length;\\r\\n            }\\r\\n\\r\\n            if (prodL < remL) prod = [0].concat(prod);\\r\\n\\r\\n            // Subtract product from remainder.\\r\\n            subtract(rem, prod, remL, base);\\r\\n            remL = rem.length;\\r\\n\\r\\n             // If product was < remainder.\\r\\n            if (cmp == -1) {\\r\\n\\r\\n              // Compare divisor and new remainder.\\r\\n              // If divisor < new remainder, subtract divisor from remainder.\\r\\n              // Trial digit n too low.\\r\\n              // n is 1 too low about 5% of the time, and very rarely 2 too low.\\r\\n              while (compare(yc, rem, yL, remL) < 1) {\\r\\n                n++;\\r\\n\\r\\n                // Subtract divisor from remainder.\\r\\n                subtract(rem, yL < remL ? yz : yc, remL, base);\\r\\n                remL = rem.length;\\r\\n              }\\r\\n            }\\r\\n          } else if (cmp === 0) {\\r\\n            n++;\\r\\n            rem = [0];\\r\\n          } // else cmp === 1 and n will be 0\\r\\n\\r\\n          // Add the next digit, n, to the result array.\\r\\n          qc[i++] = n;\\r\\n\\r\\n          // Update the remainder.\\r\\n          if (rem[0]) {\\r\\n            rem[remL++] = xc[xi] || 0;\\r\\n          } else {\\r\\n            rem = [xc[xi]];\\r\\n            remL = 1;\\r\\n          }\\r\\n        } while ((xi++ < xL || rem[0] != null) && s--);\\r\\n\\r\\n        more = rem[0] != null;\\r\\n\\r\\n        // Leading zero?\\r\\n        if (!qc[0]) qc.splice(0, 1);\\r\\n      }\\r\\n\\r\\n      if (base == BASE) {\\r\\n\\r\\n        // To calculate q.e, first get the number of digits of qc[0].\\r\\n        for (i = 1, s = qc[0]; s >= 10; s /= 10, i++);\\r\\n\\r\\n        round(q, dp + (q.e = i + e * LOG_BASE - 1) + 1, rm, more);\\r\\n\\r\\n      // Caller is convertBase.\\r\\n      } else {\\r\\n        q.e = e;\\r\\n        q.r = +more;\\r\\n      }\\r\\n\\r\\n      return q;\\r\\n    };\\r\\n  })();\\r\\n\\r\\n\\r\\n  /*\\r\\n   * Return a string representing the value of BigNumber n in fixed-point or exponential\\r\\n   * notation rounded to the specified decimal places or significant digits.\\r\\n   *\\r\\n   * n: a BigNumber.\\r\\n   * i: the index of the last digit required (i.e. the digit that may be rounded up).\\r\\n   * rm: the rounding mode.\\r\\n   * id: 1 (toExponential) or 2 (toPrecision).\\r\\n   */\\r\\n  function format(n, i, rm, id) {\\r\\n    var c0, e, ne, len, str;\\r\\n\\r\\n    if (rm == null) rm = ROUNDING_MODE;\\r\\n    else intCheck(rm, 0, 8);\\r\\n\\r\\n    if (!n.c) return n.toString();\\r\\n\\r\\n    c0 = n.c[0];\\r\\n    ne = n.e;\\r\\n\\r\\n    if (i == null) {\\r\\n      str = coeffToString(n.c);\\r\\n      str = id == 1 || id == 2 && (ne <= TO_EXP_NEG || ne >= TO_EXP_POS)\\r\\n       ? toExponential(str, ne)\\r\\n       : toFixedPoint(str, ne, '0');\\r\\n    } else {\\r\\n      n = round(new BigNumber(n), i, rm);\\r\\n\\r\\n      // n.e may have changed if the value was rounded up.\\r\\n      e = n.e;\\r\\n\\r\\n      str = coeffToString(n.c);\\r\\n      len = str.length;\\r\\n\\r\\n      // toPrecision returns exponential notation if the number of significant digits\\r\\n      // specified is less than the number of digits necessary to represent the integer\\r\\n      // part of the value in fixed-point notation.\\r\\n\\r\\n      // Exponential notation.\\r\\n      if (id == 1 || id == 2 && (i <= e || e <= TO_EXP_NEG)) {\\r\\n\\r\\n        // Append zeros?\\r\\n        for (; len < i; str += '0', len++);\\r\\n        str = toExponential(str, e);\\r\\n\\r\\n      // Fixed-point notation.\\r\\n      } else {\\r\\n        i -= ne;\\r\\n        str = toFixedPoint(str, e, '0');\\r\\n\\r\\n        // Append zeros?\\r\\n        if (e + 1 > len) {\\r\\n          if (--i > 0) for (str += '.'; i--; str += '0');\\r\\n        } else {\\r\\n          i += e - len;\\r\\n          if (i > 0) {\\r\\n            if (e + 1 == len) str += '.';\\r\\n            for (; i--; str += '0');\\r\\n          }\\r\\n        }\\r\\n      }\\r\\n    }\\r\\n\\r\\n    return n.s < 0 && c0 ? '-' + str : str;\\r\\n  }\\r\\n\\r\\n\\r\\n  // Handle BigNumber.max and BigNumber.min.\\r\\n  function maxOrMin(args, method) {\\r\\n    var n,\\r\\n      i = 1,\\r\\n      m = new BigNumber(args[0]);\\r\\n\\r\\n    for (; i < args.length; i++) {\\r\\n      n = new BigNumber(args[i]);\\r\\n\\r\\n      // If any number is NaN, return NaN.\\r\\n      if (!n.s) {\\r\\n        m = n;\\r\\n        break;\\r\\n      } else if (method.call(m, n)) {\\r\\n        m = n;\\r\\n      }\\r\\n    }\\r\\n\\r\\n    return m;\\r\\n  }\\r\\n\\r\\n\\r\\n  /*\\r\\n   * Strip trailing zeros, calculate base 10 exponent and check against MIN_EXP and MAX_EXP.\\r\\n   * Called by minus, plus and times.\\r\\n   */\\r\\n  function normalise(n, c, e) {\\r\\n    var i = 1,\\r\\n      j = c.length;\\r\\n\\r\\n     // Remove trailing zeros.\\r\\n    for (; !c[--j]; c.pop());\\r\\n\\r\\n    // Calculate the base 10 exponent. First get the number of digits of c[0].\\r\\n    for (j = c[0]; j >= 10; j /= 10, i++);\\r\\n\\r\\n    // Overflow?\\r\\n    if ((e = i + e * LOG_BASE - 1) > MAX_EXP) {\\r\\n\\r\\n      // Infinity.\\r\\n      n.c = n.e = null;\\r\\n\\r\\n    // Underflow?\\r\\n    } else if (e < MIN_EXP) {\\r\\n\\r\\n      // Zero.\\r\\n      n.c = [n.e = 0];\\r\\n    } else {\\r\\n      n.e = e;\\r\\n      n.c = c;\\r\\n    }\\r\\n\\r\\n    return n;\\r\\n  }\\r\\n\\r\\n\\r\\n  // Handle values that fail the validity test in BigNumber.\\r\\n  parseNumeric = (function () {\\r\\n    var basePrefix = /^(-?)0([xbo])(?=\\\\w[\\\\w.]*$)/i,\\r\\n      dotAfter = /^([^.]+)\\\\.$/,\\r\\n      dotBefore = /^\\\\.([^.]+)$/,\\r\\n      isInfinityOrNaN = /^-?(Infinity|NaN)$/,\\r\\n      whitespaceOrPlus = /^\\\\s*\\\\+(?=[\\\\w.])|^\\\\s+|\\\\s+$/g;\\r\\n\\r\\n    return function (x, str, isNum, b) {\\r\\n      var base,\\r\\n        s = isNum ? str : str.replace(whitespaceOrPlus, '');\\r\\n\\r\\n      // No exception on ±Infinity or NaN.\\r\\n      if (isInfinityOrNaN.test(s)) {\\r\\n        x.s = isNaN(s) ? null : s < 0 ? -1 : 1;\\r\\n      } else {\\r\\n        if (!isNum) {\\r\\n\\r\\n          // basePrefix = /^(-?)0([xbo])(?=\\\\w[\\\\w.]*$)/i\\r\\n          s = s.replace(basePrefix, function (m, p1, p2) {\\r\\n            base = (p2 = p2.toLowerCase()) == 'x' ? 16 : p2 == 'b' ? 2 : 8;\\r\\n            return !b || b == base ? p1 : m;\\r\\n          });\\r\\n\\r\\n          if (b) {\\r\\n            base = b;\\r\\n\\r\\n            // E.g. '1.' to '1', '.1' to '0.1'\\r\\n            s = s.replace(dotAfter, '$1').replace(dotBefore, '0.$1');\\r\\n          }\\r\\n\\r\\n          if (str != s) return new BigNumber(s, base);\\r\\n        }\\r\\n\\r\\n        // '[BigNumber Error] Not a number: {n}'\\r\\n        // '[BigNumber Error] Not a base {b} number: {n}'\\r\\n        if (BigNumber.DEBUG) {\\r\\n          throw Error\\r\\n            (bignumberError + 'Not a' + (b ? ' base ' + b : '') + ' number: ' + str);\\r\\n        }\\r\\n\\r\\n        // NaN\\r\\n        x.s = null;\\r\\n      }\\r\\n\\r\\n      x.c = x.e = null;\\r\\n    }\\r\\n  })();\\r\\n\\r\\n\\r\\n  /*\\r\\n   * Round x to sd significant digits using rounding mode rm. Check for over/under-flow.\\r\\n   * If r is truthy, it is known that there are more digits after the rounding digit.\\r\\n   */\\r\\n  function round(x, sd, rm, r) {\\r\\n    var d, i, j, k, n, ni, rd,\\r\\n      xc = x.c,\\r\\n      pows10 = POWS_TEN;\\r\\n\\r\\n    // if x is not Infinity or NaN...\\r\\n    if (xc) {\\r\\n\\r\\n      // rd is the rounding digit, i.e. the digit after the digit that may be rounded up.\\r\\n      // n is a base 1e14 number, the value of the element of array x.c containing rd.\\r\\n      // ni is the index of n within x.c.\\r\\n      // d is the number of digits of n.\\r\\n      // i is the index of rd within n including leading zeros.\\r\\n      // j is the actual index of rd within n (if < 0, rd is a leading zero).\\r\\n      out: {\\r\\n\\r\\n        // Get the number of digits of the first element of xc.\\r\\n        for (d = 1, k = xc[0]; k >= 10; k /= 10, d++);\\r\\n        i = sd - d;\\r\\n\\r\\n        // If the rounding digit is in the first element of xc...\\r\\n        if (i < 0) {\\r\\n          i += LOG_BASE;\\r\\n          j = sd;\\r\\n          n = xc[ni = 0];\\r\\n\\r\\n          // Get the rounding digit at index j of n.\\r\\n          rd = n / pows10[d - j - 1] % 10 | 0;\\r\\n        } else {\\r\\n          ni = mathceil((i + 1) / LOG_BASE);\\r\\n\\r\\n          if (ni >= xc.length) {\\r\\n\\r\\n            if (r) {\\r\\n\\r\\n              // Needed by sqrt.\\r\\n              for (; xc.length <= ni; xc.push(0));\\r\\n              n = rd = 0;\\r\\n              d = 1;\\r\\n              i %= LOG_BASE;\\r\\n              j = i - LOG_BASE + 1;\\r\\n            } else {\\r\\n              break out;\\r\\n            }\\r\\n          } else {\\r\\n            n = k = xc[ni];\\r\\n\\r\\n            // Get the number of digits of n.\\r\\n            for (d = 1; k >= 10; k /= 10, d++);\\r\\n\\r\\n            // Get the index of rd within n.\\r\\n            i %= LOG_BASE;\\r\\n\\r\\n            // Get the index of rd within n, adjusted for leading zeros.\\r\\n            // The number of leading zeros of n is given by LOG_BASE - d.\\r\\n            j = i - LOG_BASE + d;\\r\\n\\r\\n            // Get the rounding digit at index j of n.\\r\\n            rd = j < 0 ? 0 : n / pows10[d - j - 1] % 10 | 0;\\r\\n          }\\r\\n        }\\r\\n\\r\\n        r = r || sd < 0 ||\\r\\n\\r\\n        // Are there any non-zero digits after the rounding digit?\\r\\n        // The expression  n % pows10[d - j - 1]  returns all digits of n to the right\\r\\n        // of the digit at j, e.g. if n is 908714 and j is 2, the expression gives 714.\\r\\n         xc[ni + 1] != null || (j < 0 ? n : n % pows10[d - j - 1]);\\r\\n\\r\\n        r = rm < 4\\r\\n         ? (rd || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\\r\\n         : rd > 5 || rd == 5 && (rm == 4 || r || rm == 6 &&\\r\\n\\r\\n          // Check whether the digit to the left of the rounding digit is odd.\\r\\n          ((i > 0 ? j > 0 ? n / pows10[d - j] : 0 : xc[ni - 1]) % 10) & 1 ||\\r\\n           rm == (x.s < 0 ? 8 : 7));\\r\\n\\r\\n        if (sd < 1 || !xc[0]) {\\r\\n          xc.length = 0;\\r\\n\\r\\n          if (r) {\\r\\n\\r\\n            // Convert sd to decimal places.\\r\\n            sd -= x.e + 1;\\r\\n\\r\\n            // 1, 0.1, 0.01, 0.001, 0.0001 etc.\\r\\n            xc[0] = pows10[(LOG_BASE - sd % LOG_BASE) % LOG_BASE];\\r\\n            x.e = -sd || 0;\\r\\n          } else {\\r\\n\\r\\n            // Zero.\\r\\n            xc[0] = x.e = 0;\\r\\n          }\\r\\n\\r\\n          return x;\\r\\n        }\\r\\n\\r\\n        // Remove excess digits.\\r\\n        if (i == 0) {\\r\\n          xc.length = ni;\\r\\n          k = 1;\\r\\n          ni--;\\r\\n        } else {\\r\\n          xc.length = ni + 1;\\r\\n          k = pows10[LOG_BASE - i];\\r\\n\\r\\n          // E.g. 56700 becomes 56000 if 7 is the rounding digit.\\r\\n          // j > 0 means i > number of leading zeros of n.\\r\\n          xc[ni] = j > 0 ? mathfloor(n / pows10[d - j] % pows10[j]) * k : 0;\\r\\n        }\\r\\n\\r\\n        // Round up?\\r\\n        if (r) {\\r\\n\\r\\n          for (; ;) {\\r\\n\\r\\n            // If the digit to be rounded up is in the first element of xc...\\r\\n            if (ni == 0) {\\r\\n\\r\\n              // i will be the length of xc[0] before k is added.\\r\\n              for (i = 1, j = xc[0]; j >= 10; j /= 10, i++);\\r\\n              j = xc[0] += k;\\r\\n              for (k = 1; j >= 10; j /= 10, k++);\\r\\n\\r\\n              // if i != k the length has increased.\\r\\n              if (i != k) {\\r\\n                x.e++;\\r\\n                if (xc[0] == BASE) xc[0] = 1;\\r\\n              }\\r\\n\\r\\n              break;\\r\\n            } else {\\r\\n              xc[ni] += k;\\r\\n              if (xc[ni] != BASE) break;\\r\\n              xc[ni--] = 0;\\r\\n              k = 1;\\r\\n            }\\r\\n          }\\r\\n        }\\r\\n\\r\\n        // Remove trailing zeros.\\r\\n        for (i = xc.length; xc[--i] === 0; xc.pop());\\r\\n      }\\r\\n\\r\\n      // Overflow? Infinity.\\r\\n      if (x.e > MAX_EXP) {\\r\\n        x.c = x.e = null;\\r\\n\\r\\n      // Underflow? Zero.\\r\\n      } else if (x.e < MIN_EXP) {\\r\\n        x.c = [x.e = 0];\\r\\n      }\\r\\n    }\\r\\n\\r\\n    return x;\\r\\n  }\\r\\n\\r\\n\\r\\n  function valueOf(n) {\\r\\n    var str,\\r\\n      e = n.e;\\r\\n\\r\\n    if (e === null) return n.toString();\\r\\n\\r\\n    str = coeffToString(n.c);\\r\\n\\r\\n    str = e <= TO_EXP_NEG || e >= TO_EXP_POS\\r\\n      ? toExponential(str, e)\\r\\n      : toFixedPoint(str, e, '0');\\r\\n\\r\\n    return n.s < 0 ? '-' + str : str;\\r\\n  }\\r\\n\\r\\n\\r\\n  // PROTOTYPE/INSTANCE METHODS\\r\\n\\r\\n\\r\\n  /*\\r\\n   * Return a new BigNumber whose value is the absolute value of this BigNumber.\\r\\n   */\\r\\n  P.absoluteValue = P.abs = function () {\\r\\n    var x = new BigNumber(this);\\r\\n    if (x.s < 0) x.s = 1;\\r\\n    return x;\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   * Return\\r\\n   *   1 if the value of this BigNumber is greater than the value of BigNumber(y, b),\\r\\n   *   -1 if the value of this BigNumber is less than the value of BigNumber(y, b),\\r\\n   *   0 if they have the same value,\\r\\n   *   or null if the value of either is NaN.\\r\\n   */\\r\\n  P.comparedTo = function (y, b) {\\r\\n    return compare(this, new BigNumber(y, b));\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   * If dp is undefined or null or true or false, return the number of decimal places of the\\r\\n   * value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN.\\r\\n   *\\r\\n   * Otherwise, if dp is a number, return a new BigNumber whose value is the value of this\\r\\n   * BigNumber rounded to a maximum of dp decimal places using rounding mode rm, or\\r\\n   * ROUNDING_MODE if rm is omitted.\\r\\n   *\\r\\n   * [dp] {number} Decimal places: integer, 0 to MAX inclusive.\\r\\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\\r\\n   *\\r\\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\\r\\n   */\\r\\n  P.decimalPlaces = P.dp = function (dp, rm) {\\r\\n    var c, n, v,\\r\\n      x = this;\\r\\n\\r\\n    if (dp != null) {\\r\\n      intCheck(dp, 0, MAX);\\r\\n      if (rm == null) rm = ROUNDING_MODE;\\r\\n      else intCheck(rm, 0, 8);\\r\\n\\r\\n      return round(new BigNumber(x), dp + x.e + 1, rm);\\r\\n    }\\r\\n\\r\\n    if (!(c = x.c)) return null;\\r\\n    n = ((v = c.length - 1) - bitFloor(this.e / LOG_BASE)) * LOG_BASE;\\r\\n\\r\\n    // Subtract the number of trailing zeros of the last number.\\r\\n    if (v = c[v]) for (; v % 10 == 0; v /= 10, n--);\\r\\n    if (n < 0) n = 0;\\r\\n\\r\\n    return n;\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   *  n / 0 = I\\r\\n   *  n / N = N\\r\\n   *  n / I = 0\\r\\n   *  0 / n = 0\\r\\n   *  0 / 0 = N\\r\\n   *  0 / N = N\\r\\n   *  0 / I = 0\\r\\n   *  N / n = N\\r\\n   *  N / 0 = N\\r\\n   *  N / N = N\\r\\n   *  N / I = N\\r\\n   *  I / n = I\\r\\n   *  I / 0 = I\\r\\n   *  I / N = N\\r\\n   *  I / I = N\\r\\n   *\\r\\n   * Return a new BigNumber whose value is the value of this BigNumber divided by the value of\\r\\n   * BigNumber(y, b), rounded according to DECIMAL_PLACES and ROUNDING_MODE.\\r\\n   */\\r\\n  P.dividedBy = P.div = function (y, b) {\\r\\n    return div(this, new BigNumber(y, b), DECIMAL_PLACES, ROUNDING_MODE);\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   * Return a new BigNumber whose value is the integer part of dividing the value of this\\r\\n   * BigNumber by the value of BigNumber(y, b).\\r\\n   */\\r\\n  P.dividedToIntegerBy = P.idiv = function (y, b) {\\r\\n    return div(this, new BigNumber(y, b), 0, 1);\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   * Return a BigNumber whose value is the value of this BigNumber exponentiated by n.\\r\\n   *\\r\\n   * If m is present, return the result modulo m.\\r\\n   * If n is negative round according to DECIMAL_PLACES and ROUNDING_MODE.\\r\\n   * If POW_PRECISION is non-zero and m is not present, round to POW_PRECISION using ROUNDING_MODE.\\r\\n   *\\r\\n   * The modular power operation works efficiently when x, n, and m are integers, otherwise it\\r\\n   * is equivalent to calculating x.exponentiatedBy(n).modulo(m) with a POW_PRECISION of 0.\\r\\n   *\\r\\n   * n {number|string|BigNumber} The exponent. An integer.\\r\\n   * [m] {number|string|BigNumber} The modulus.\\r\\n   *\\r\\n   * '[BigNumber Error] Exponent not an integer: {n}'\\r\\n   */\\r\\n  P.exponentiatedBy = P.pow = function (n, m) {\\r\\n    var half, isModExp, i, k, more, nIsBig, nIsNeg, nIsOdd, y,\\r\\n      x = this;\\r\\n\\r\\n    n = new BigNumber(n);\\r\\n\\r\\n    // Allow NaN and ±Infinity, but not other non-integers.\\r\\n    if (n.c && !n.isInteger()) {\\r\\n      throw Error\\r\\n        (bignumberError + 'Exponent not an integer: ' + valueOf(n));\\r\\n    }\\r\\n\\r\\n    if (m != null) m = new BigNumber(m);\\r\\n\\r\\n    // Exponent of MAX_SAFE_INTEGER is 15.\\r\\n    nIsBig = n.e > 14;\\r\\n\\r\\n    // If x is NaN, ±Infinity, ±0 or ±1, or n is ±Infinity, NaN or ±0.\\r\\n    if (!x.c || !x.c[0] || x.c[0] == 1 && !x.e && x.c.length == 1 || !n.c || !n.c[0]) {\\r\\n\\r\\n      // The sign of the result of pow when x is negative depends on the evenness of n.\\r\\n      // If +n overflows to ±Infinity, the evenness of n would be not be known.\\r\\n      y = new BigNumber(Math.pow(+valueOf(x), nIsBig ? n.s * (2 - isOdd(n)) : +valueOf(n)));\\r\\n      return m ? y.mod(m) : y;\\r\\n    }\\r\\n\\r\\n    nIsNeg = n.s < 0;\\r\\n\\r\\n    if (m) {\\r\\n\\r\\n      // x % m returns NaN if abs(m) is zero, or m is NaN.\\r\\n      if (m.c ? !m.c[0] : !m.s) return new BigNumber(NaN);\\r\\n\\r\\n      isModExp = !nIsNeg && x.isInteger() && m.isInteger();\\r\\n\\r\\n      if (isModExp) x = x.mod(m);\\r\\n\\r\\n    // Overflow to ±Infinity: >=2**1e10 or >=1.0000024**1e15.\\r\\n    // Underflow to ±0: <=0.79**1e10 or <=0.9999975**1e15.\\r\\n    } else if (n.e > 9 && (x.e > 0 || x.e < -1 || (x.e == 0\\r\\n      // [1, 240000000]\\r\\n      ? x.c[0] > 1 || nIsBig && x.c[1] >= 24e7\\r\\n      // [80000000000000]  [99999750000000]\\r\\n      : x.c[0] < 8e13 || nIsBig && x.c[0] <= 9999975e7))) {\\r\\n\\r\\n      // If x is negative and n is odd, k = -0, else k = 0.\\r\\n      k = x.s < 0 && isOdd(n) ? -0 : 0;\\r\\n\\r\\n      // If x >= 1, k = ±Infinity.\\r\\n      if (x.e > -1) k = 1 / k;\\r\\n\\r\\n      // If n is negative return ±0, else return ±Infinity.\\r\\n      return new BigNumber(nIsNeg ? 1 / k : k);\\r\\n\\r\\n    } else if (POW_PRECISION) {\\r\\n\\r\\n      // Truncating each coefficient array to a length of k after each multiplication\\r\\n      // equates to truncating significant digits to POW_PRECISION + [28, 41],\\r\\n      // i.e. there will be a minimum of 28 guard digits retained.\\r\\n      k = mathceil(POW_PRECISION / LOG_BASE + 2);\\r\\n    }\\r\\n\\r\\n    if (nIsBig) {\\r\\n      half = new BigNumber(0.5);\\r\\n      if (nIsNeg) n.s = 1;\\r\\n      nIsOdd = isOdd(n);\\r\\n    } else {\\r\\n      i = Math.abs(+valueOf(n));\\r\\n      nIsOdd = i % 2;\\r\\n    }\\r\\n\\r\\n    y = new BigNumber(ONE);\\r\\n\\r\\n    // Performs 54 loop iterations for n of 9007199254740991.\\r\\n    for (; ;) {\\r\\n\\r\\n      if (nIsOdd) {\\r\\n        y = y.times(x);\\r\\n        if (!y.c) break;\\r\\n\\r\\n        if (k) {\\r\\n          if (y.c.length > k) y.c.length = k;\\r\\n        } else if (isModExp) {\\r\\n          y = y.mod(m);    //y = y.minus(div(y, m, 0, MODULO_MODE).times(m));\\r\\n        }\\r\\n      }\\r\\n\\r\\n      if (i) {\\r\\n        i = mathfloor(i / 2);\\r\\n        if (i === 0) break;\\r\\n        nIsOdd = i % 2;\\r\\n      } else {\\r\\n        n = n.times(half);\\r\\n        round(n, n.e + 1, 1);\\r\\n\\r\\n        if (n.e > 14) {\\r\\n          nIsOdd = isOdd(n);\\r\\n        } else {\\r\\n          i = +valueOf(n);\\r\\n          if (i === 0) break;\\r\\n          nIsOdd = i % 2;\\r\\n        }\\r\\n      }\\r\\n\\r\\n      x = x.times(x);\\r\\n\\r\\n      if (k) {\\r\\n        if (x.c && x.c.length > k) x.c.length = k;\\r\\n      } else if (isModExp) {\\r\\n        x = x.mod(m);    //x = x.minus(div(x, m, 0, MODULO_MODE).times(m));\\r\\n      }\\r\\n    }\\r\\n\\r\\n    if (isModExp) return y;\\r\\n    if (nIsNeg) y = ONE.div(y);\\r\\n\\r\\n    return m ? y.mod(m) : k ? round(y, POW_PRECISION, ROUNDING_MODE, more) : y;\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   * Return a new BigNumber whose value is the value of this BigNumber rounded to an integer\\r\\n   * using rounding mode rm, or ROUNDING_MODE if rm is omitted.\\r\\n   *\\r\\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\\r\\n   *\\r\\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {rm}'\\r\\n   */\\r\\n  P.integerValue = function (rm) {\\r\\n    var n = new BigNumber(this);\\r\\n    if (rm == null) rm = ROUNDING_MODE;\\r\\n    else intCheck(rm, 0, 8);\\r\\n    return round(n, n.e + 1, rm);\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   * Return true if the value of this BigNumber is equal to the value of BigNumber(y, b),\\r\\n   * otherwise return false.\\r\\n   */\\r\\n  P.isEqualTo = P.eq = function (y, b) {\\r\\n    return compare(this, new BigNumber(y, b)) === 0;\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   * Return true if the value of this BigNumber is a finite number, otherwise return false.\\r\\n   */\\r\\n  P.isFinite = function () {\\r\\n    return !!this.c;\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   * Return true if the value of this BigNumber is greater than the value of BigNumber(y, b),\\r\\n   * otherwise return false.\\r\\n   */\\r\\n  P.isGreaterThan = P.gt = function (y, b) {\\r\\n    return compare(this, new BigNumber(y, b)) > 0;\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   * Return true if the value of this BigNumber is greater than or equal to the value of\\r\\n   * BigNumber(y, b), otherwise return false.\\r\\n   */\\r\\n  P.isGreaterThanOrEqualTo = P.gte = function (y, b) {\\r\\n    return (b = compare(this, new BigNumber(y, b))) === 1 || b === 0;\\r\\n\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   * Return true if the value of this BigNumber is an integer, otherwise return false.\\r\\n   */\\r\\n  P.isInteger = function () {\\r\\n    return !!this.c && bitFloor(this.e / LOG_BASE) > this.c.length - 2;\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   * Return true if the value of this BigNumber is less than the value of BigNumber(y, b),\\r\\n   * otherwise return false.\\r\\n   */\\r\\n  P.isLessThan = P.lt = function (y, b) {\\r\\n    return compare(this, new BigNumber(y, b)) < 0;\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   * Return true if the value of this BigNumber is less than or equal to the value of\\r\\n   * BigNumber(y, b), otherwise return false.\\r\\n   */\\r\\n  P.isLessThanOrEqualTo = P.lte = function (y, b) {\\r\\n    return (b = compare(this, new BigNumber(y, b))) === -1 || b === 0;\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   * Return true if the value of this BigNumber is NaN, otherwise return false.\\r\\n   */\\r\\n  P.isNaN = function () {\\r\\n    return !this.s;\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   * Return true if the value of this BigNumber is negative, otherwise return false.\\r\\n   */\\r\\n  P.isNegative = function () {\\r\\n    return this.s < 0;\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   * Return true if the value of this BigNumber is positive, otherwise return false.\\r\\n   */\\r\\n  P.isPositive = function () {\\r\\n    return this.s > 0;\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   * Return true if the value of this BigNumber is 0 or -0, otherwise return false.\\r\\n   */\\r\\n  P.isZero = function () {\\r\\n    return !!this.c && this.c[0] == 0;\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   *  n - 0 = n\\r\\n   *  n - N = N\\r\\n   *  n - I = -I\\r\\n   *  0 - n = -n\\r\\n   *  0 - 0 = 0\\r\\n   *  0 - N = N\\r\\n   *  0 - I = -I\\r\\n   *  N - n = N\\r\\n   *  N - 0 = N\\r\\n   *  N - N = N\\r\\n   *  N - I = N\\r\\n   *  I - n = I\\r\\n   *  I - 0 = I\\r\\n   *  I - N = N\\r\\n   *  I - I = N\\r\\n   *\\r\\n   * Return a new BigNumber whose value is the value of this BigNumber minus the value of\\r\\n   * BigNumber(y, b).\\r\\n   */\\r\\n  P.minus = function (y, b) {\\r\\n    var i, j, t, xLTy,\\r\\n      x = this,\\r\\n      a = x.s;\\r\\n\\r\\n    y = new BigNumber(y, b);\\r\\n    b = y.s;\\r\\n\\r\\n    // Either NaN?\\r\\n    if (!a || !b) return new BigNumber(NaN);\\r\\n\\r\\n    // Signs differ?\\r\\n    if (a != b) {\\r\\n      y.s = -b;\\r\\n      return x.plus(y);\\r\\n    }\\r\\n\\r\\n    var xe = x.e / LOG_BASE,\\r\\n      ye = y.e / LOG_BASE,\\r\\n      xc = x.c,\\r\\n      yc = y.c;\\r\\n\\r\\n    if (!xe || !ye) {\\r\\n\\r\\n      // Either Infinity?\\r\\n      if (!xc || !yc) return xc ? (y.s = -b, y) : new BigNumber(yc ? x : NaN);\\r\\n\\r\\n      // Either zero?\\r\\n      if (!xc[0] || !yc[0]) {\\r\\n\\r\\n        // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.\\r\\n        return yc[0] ? (y.s = -b, y) : new BigNumber(xc[0] ? x :\\r\\n\\r\\n         // IEEE 754 (2008) 6.3: n - n = -0 when rounding to -Infinity\\r\\n         ROUNDING_MODE == 3 ? -0 : 0);\\r\\n      }\\r\\n    }\\r\\n\\r\\n    xe = bitFloor(xe);\\r\\n    ye = bitFloor(ye);\\r\\n    xc = xc.slice();\\r\\n\\r\\n    // Determine which is the bigger number.\\r\\n    if (a = xe - ye) {\\r\\n\\r\\n      if (xLTy = a < 0) {\\r\\n        a = -a;\\r\\n        t = xc;\\r\\n      } else {\\r\\n        ye = xe;\\r\\n        t = yc;\\r\\n      }\\r\\n\\r\\n      t.reverse();\\r\\n\\r\\n      // Prepend zeros to equalise exponents.\\r\\n      for (b = a; b--; t.push(0));\\r\\n      t.reverse();\\r\\n    } else {\\r\\n\\r\\n      // Exponents equal. Check digit by digit.\\r\\n      j = (xLTy = (a = xc.length) < (b = yc.length)) ? a : b;\\r\\n\\r\\n      for (a = b = 0; b < j; b++) {\\r\\n\\r\\n        if (xc[b] != yc[b]) {\\r\\n          xLTy = xc[b] < yc[b];\\r\\n          break;\\r\\n        }\\r\\n      }\\r\\n    }\\r\\n\\r\\n    // x < y? Point xc to the array of the bigger number.\\r\\n    if (xLTy) t = xc, xc = yc, yc = t, y.s = -y.s;\\r\\n\\r\\n    b = (j = yc.length) - (i = xc.length);\\r\\n\\r\\n    // Append zeros to xc if shorter.\\r\\n    // No need to add zeros to yc if shorter as subtract only needs to start at yc.length.\\r\\n    if (b > 0) for (; b--; xc[i++] = 0);\\r\\n    b = BASE - 1;\\r\\n\\r\\n    // Subtract yc from xc.\\r\\n    for (; j > a;) {\\r\\n\\r\\n      if (xc[--j] < yc[j]) {\\r\\n        for (i = j; i && !xc[--i]; xc[i] = b);\\r\\n        --xc[i];\\r\\n        xc[j] += BASE;\\r\\n      }\\r\\n\\r\\n      xc[j] -= yc[j];\\r\\n    }\\r\\n\\r\\n    // Remove leading zeros and adjust exponent accordingly.\\r\\n    for (; xc[0] == 0; xc.splice(0, 1), --ye);\\r\\n\\r\\n    // Zero?\\r\\n    if (!xc[0]) {\\r\\n\\r\\n      // Following IEEE 754 (2008) 6.3,\\r\\n      // n - n = +0  but  n - n = -0  when rounding towards -Infinity.\\r\\n      y.s = ROUNDING_MODE == 3 ? -1 : 1;\\r\\n      y.c = [y.e = 0];\\r\\n      return y;\\r\\n    }\\r\\n\\r\\n    // No need to check for Infinity as +x - +y != Infinity && -x - -y != Infinity\\r\\n    // for finite x and y.\\r\\n    return normalise(y, xc, ye);\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   *   n % 0 =  N\\r\\n   *   n % N =  N\\r\\n   *   n % I =  n\\r\\n   *   0 % n =  0\\r\\n   *  -0 % n = -0\\r\\n   *   0 % 0 =  N\\r\\n   *   0 % N =  N\\r\\n   *   0 % I =  0\\r\\n   *   N % n =  N\\r\\n   *   N % 0 =  N\\r\\n   *   N % N =  N\\r\\n   *   N % I =  N\\r\\n   *   I % n =  N\\r\\n   *   I % 0 =  N\\r\\n   *   I % N =  N\\r\\n   *   I % I =  N\\r\\n   *\\r\\n   * Return a new BigNumber whose value is the value of this BigNumber modulo the value of\\r\\n   * BigNumber(y, b). The result depends on the value of MODULO_MODE.\\r\\n   */\\r\\n  P.modulo = P.mod = function (y, b) {\\r\\n    var q, s,\\r\\n      x = this;\\r\\n\\r\\n    y = new BigNumber(y, b);\\r\\n\\r\\n    // Return NaN if x is Infinity or NaN, or y is NaN or zero.\\r\\n    if (!x.c || !y.s || y.c && !y.c[0]) {\\r\\n      return new BigNumber(NaN);\\r\\n\\r\\n    // Return x if y is Infinity or x is zero.\\r\\n    } else if (!y.c || x.c && !x.c[0]) {\\r\\n      return new BigNumber(x);\\r\\n    }\\r\\n\\r\\n    if (MODULO_MODE == 9) {\\r\\n\\r\\n      // Euclidian division: q = sign(y) * floor(x / abs(y))\\r\\n      // r = x - qy    where  0 <= r < abs(y)\\r\\n      s = y.s;\\r\\n      y.s = 1;\\r\\n      q = div(x, y, 0, 3);\\r\\n      y.s = s;\\r\\n      q.s *= s;\\r\\n    } else {\\r\\n      q = div(x, y, 0, MODULO_MODE);\\r\\n    }\\r\\n\\r\\n    y = x.minus(q.times(y));\\r\\n\\r\\n    // To match JavaScript %, ensure sign of zero is sign of dividend.\\r\\n    if (!y.c[0] && MODULO_MODE == 1) y.s = x.s;\\r\\n\\r\\n    return y;\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   *  n * 0 = 0\\r\\n   *  n * N = N\\r\\n   *  n * I = I\\r\\n   *  0 * n = 0\\r\\n   *  0 * 0 = 0\\r\\n   *  0 * N = N\\r\\n   *  0 * I = N\\r\\n   *  N * n = N\\r\\n   *  N * 0 = N\\r\\n   *  N * N = N\\r\\n   *  N * I = N\\r\\n   *  I * n = I\\r\\n   *  I * 0 = N\\r\\n   *  I * N = N\\r\\n   *  I * I = I\\r\\n   *\\r\\n   * Return a new BigNumber whose value is the value of this BigNumber multiplied by the value\\r\\n   * of BigNumber(y, b).\\r\\n   */\\r\\n  P.multipliedBy = P.times = function (y, b) {\\r\\n    var c, e, i, j, k, m, xcL, xlo, xhi, ycL, ylo, yhi, zc,\\r\\n      base, sqrtBase,\\r\\n      x = this,\\r\\n      xc = x.c,\\r\\n      yc = (y = new BigNumber(y, b)).c;\\r\\n\\r\\n    // Either NaN, ±Infinity or ±0?\\r\\n    if (!xc || !yc || !xc[0] || !yc[0]) {\\r\\n\\r\\n      // Return NaN if either is NaN, or one is 0 and the other is Infinity.\\r\\n      if (!x.s || !y.s || xc && !xc[0] && !yc || yc && !yc[0] && !xc) {\\r\\n        y.c = y.e = y.s = null;\\r\\n      } else {\\r\\n        y.s *= x.s;\\r\\n\\r\\n        // Return ±Infinity if either is ±Infinity.\\r\\n        if (!xc || !yc) {\\r\\n          y.c = y.e = null;\\r\\n\\r\\n        // Return ±0 if either is ±0.\\r\\n        } else {\\r\\n          y.c = [0];\\r\\n          y.e = 0;\\r\\n        }\\r\\n      }\\r\\n\\r\\n      return y;\\r\\n    }\\r\\n\\r\\n    e = bitFloor(x.e / LOG_BASE) + bitFloor(y.e / LOG_BASE);\\r\\n    y.s *= x.s;\\r\\n    xcL = xc.length;\\r\\n    ycL = yc.length;\\r\\n\\r\\n    // Ensure xc points to longer array and xcL to its length.\\r\\n    if (xcL < ycL) zc = xc, xc = yc, yc = zc, i = xcL, xcL = ycL, ycL = i;\\r\\n\\r\\n    // Initialise the result array with zeros.\\r\\n    for (i = xcL + ycL, zc = []; i--; zc.push(0));\\r\\n\\r\\n    base = BASE;\\r\\n    sqrtBase = SQRT_BASE;\\r\\n\\r\\n    for (i = ycL; --i >= 0;) {\\r\\n      c = 0;\\r\\n      ylo = yc[i] % sqrtBase;\\r\\n      yhi = yc[i] / sqrtBase | 0;\\r\\n\\r\\n      for (k = xcL, j = i + k; j > i;) {\\r\\n        xlo = xc[--k] % sqrtBase;\\r\\n        xhi = xc[k] / sqrtBase | 0;\\r\\n        m = yhi * xlo + xhi * ylo;\\r\\n        xlo = ylo * xlo + ((m % sqrtBase) * sqrtBase) + zc[j] + c;\\r\\n        c = (xlo / base | 0) + (m / sqrtBase | 0) + yhi * xhi;\\r\\n        zc[j--] = xlo % base;\\r\\n      }\\r\\n\\r\\n      zc[j] = c;\\r\\n    }\\r\\n\\r\\n    if (c) {\\r\\n      ++e;\\r\\n    } else {\\r\\n      zc.splice(0, 1);\\r\\n    }\\r\\n\\r\\n    return normalise(y, zc, e);\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   * Return a new BigNumber whose value is the value of this BigNumber negated,\\r\\n   * i.e. multiplied by -1.\\r\\n   */\\r\\n  P.negated = function () {\\r\\n    var x = new BigNumber(this);\\r\\n    x.s = -x.s || null;\\r\\n    return x;\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   *  n + 0 = n\\r\\n   *  n + N = N\\r\\n   *  n + I = I\\r\\n   *  0 + n = n\\r\\n   *  0 + 0 = 0\\r\\n   *  0 + N = N\\r\\n   *  0 + I = I\\r\\n   *  N + n = N\\r\\n   *  N + 0 = N\\r\\n   *  N + N = N\\r\\n   *  N + I = N\\r\\n   *  I + n = I\\r\\n   *  I + 0 = I\\r\\n   *  I + N = N\\r\\n   *  I + I = I\\r\\n   *\\r\\n   * Return a new BigNumber whose value is the value of this BigNumber plus the value of\\r\\n   * BigNumber(y, b).\\r\\n   */\\r\\n  P.plus = function (y, b) {\\r\\n    var t,\\r\\n      x = this,\\r\\n      a = x.s;\\r\\n\\r\\n    y = new BigNumber(y, b);\\r\\n    b = y.s;\\r\\n\\r\\n    // Either NaN?\\r\\n    if (!a || !b) return new BigNumber(NaN);\\r\\n\\r\\n    // Signs differ?\\r\\n     if (a != b) {\\r\\n      y.s = -b;\\r\\n      return x.minus(y);\\r\\n    }\\r\\n\\r\\n    var xe = x.e / LOG_BASE,\\r\\n      ye = y.e / LOG_BASE,\\r\\n      xc = x.c,\\r\\n      yc = y.c;\\r\\n\\r\\n    if (!xe || !ye) {\\r\\n\\r\\n      // Return ±Infinity if either ±Infinity.\\r\\n      if (!xc || !yc) return new BigNumber(a / 0);\\r\\n\\r\\n      // Either zero?\\r\\n      // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.\\r\\n      if (!xc[0] || !yc[0]) return yc[0] ? y : new BigNumber(xc[0] ? x : a * 0);\\r\\n    }\\r\\n\\r\\n    xe = bitFloor(xe);\\r\\n    ye = bitFloor(ye);\\r\\n    xc = xc.slice();\\r\\n\\r\\n    // Prepend zeros to equalise exponents. Faster to use reverse then do unshifts.\\r\\n    if (a = xe - ye) {\\r\\n      if (a > 0) {\\r\\n        ye = xe;\\r\\n        t = yc;\\r\\n      } else {\\r\\n        a = -a;\\r\\n        t = xc;\\r\\n      }\\r\\n\\r\\n      t.reverse();\\r\\n      for (; a--; t.push(0));\\r\\n      t.reverse();\\r\\n    }\\r\\n\\r\\n    a = xc.length;\\r\\n    b = yc.length;\\r\\n\\r\\n    // Point xc to the longer array, and b to the shorter length.\\r\\n    if (a - b < 0) t = yc, yc = xc, xc = t, b = a;\\r\\n\\r\\n    // Only start adding at yc.length - 1 as the further digits of xc can be ignored.\\r\\n    for (a = 0; b;) {\\r\\n      a = (xc[--b] = xc[b] + yc[b] + a) / BASE | 0;\\r\\n      xc[b] = BASE === xc[b] ? 0 : xc[b] % BASE;\\r\\n    }\\r\\n\\r\\n    if (a) {\\r\\n      xc = [a].concat(xc);\\r\\n      ++ye;\\r\\n    }\\r\\n\\r\\n    // No need to check for zero, as +x + +y != 0 && -x + -y != 0\\r\\n    // ye = MAX_EXP + 1 possible\\r\\n    return normalise(y, xc, ye);\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   * If sd is undefined or null or true or false, return the number of significant digits of\\r\\n   * the value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN.\\r\\n   * If sd is true include integer-part trailing zeros in the count.\\r\\n   *\\r\\n   * Otherwise, if sd is a number, return a new BigNumber whose value is the value of this\\r\\n   * BigNumber rounded to a maximum of sd significant digits using rounding mode rm, or\\r\\n   * ROUNDING_MODE if rm is omitted.\\r\\n   *\\r\\n   * sd {number|boolean} number: significant digits: integer, 1 to MAX inclusive.\\r\\n   *                     boolean: whether to count integer-part trailing zeros: true or false.\\r\\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\\r\\n   *\\r\\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}'\\r\\n   */\\r\\n  P.precision = P.sd = function (sd, rm) {\\r\\n    var c, n, v,\\r\\n      x = this;\\r\\n\\r\\n    if (sd != null && sd !== !!sd) {\\r\\n      intCheck(sd, 1, MAX);\\r\\n      if (rm == null) rm = ROUNDING_MODE;\\r\\n      else intCheck(rm, 0, 8);\\r\\n\\r\\n      return round(new BigNumber(x), sd, rm);\\r\\n    }\\r\\n\\r\\n    if (!(c = x.c)) return null;\\r\\n    v = c.length - 1;\\r\\n    n = v * LOG_BASE + 1;\\r\\n\\r\\n    if (v = c[v]) {\\r\\n\\r\\n      // Subtract the number of trailing zeros of the last element.\\r\\n      for (; v % 10 == 0; v /= 10, n--);\\r\\n\\r\\n      // Add the number of digits of the first element.\\r\\n      for (v = c[0]; v >= 10; v /= 10, n++);\\r\\n    }\\r\\n\\r\\n    if (sd && x.e + 1 > n) n = x.e + 1;\\r\\n\\r\\n    return n;\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   * Return a new BigNumber whose value is the value of this BigNumber shifted by k places\\r\\n   * (powers of 10). Shift to the right if n > 0, and to the left if n < 0.\\r\\n   *\\r\\n   * k {number} Integer, -MAX_SAFE_INTEGER to MAX_SAFE_INTEGER inclusive.\\r\\n   *\\r\\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {k}'\\r\\n   */\\r\\n  P.shiftedBy = function (k) {\\r\\n    intCheck(k, -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER);\\r\\n    return this.times('1e' + k);\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   *  sqrt(-n) =  N\\r\\n   *  sqrt(N) =  N\\r\\n   *  sqrt(-I) =  N\\r\\n   *  sqrt(I) =  I\\r\\n   *  sqrt(0) =  0\\r\\n   *  sqrt(-0) = -0\\r\\n   *\\r\\n   * Return a new BigNumber whose value is the square root of the value of this BigNumber,\\r\\n   * rounded according to DECIMAL_PLACES and ROUNDING_MODE.\\r\\n   */\\r\\n  P.squareRoot = P.sqrt = function () {\\r\\n    var m, n, r, rep, t,\\r\\n      x = this,\\r\\n      c = x.c,\\r\\n      s = x.s,\\r\\n      e = x.e,\\r\\n      dp = DECIMAL_PLACES + 4,\\r\\n      half = new BigNumber('0.5');\\r\\n\\r\\n    // Negative/NaN/Infinity/zero?\\r\\n    if (s !== 1 || !c || !c[0]) {\\r\\n      return new BigNumber(!s || s < 0 && (!c || c[0]) ? NaN : c ? x : 1 / 0);\\r\\n    }\\r\\n\\r\\n    // Initial estimate.\\r\\n    s = Math.sqrt(+valueOf(x));\\r\\n\\r\\n    // Math.sqrt underflow/overflow?\\r\\n    // Pass x to Math.sqrt as integer, then adjust the exponent of the result.\\r\\n    if (s == 0 || s == 1 / 0) {\\r\\n      n = coeffToString(c);\\r\\n      if ((n.length + e) % 2 == 0) n += '0';\\r\\n      s = Math.sqrt(+n);\\r\\n      e = bitFloor((e + 1) / 2) - (e < 0 || e % 2);\\r\\n\\r\\n      if (s == 1 / 0) {\\r\\n        n = '5e' + e;\\r\\n      } else {\\r\\n        n = s.toExponential();\\r\\n        n = n.slice(0, n.indexOf('e') + 1) + e;\\r\\n      }\\r\\n\\r\\n      r = new BigNumber(n);\\r\\n    } else {\\r\\n      r = new BigNumber(s + '');\\r\\n    }\\r\\n\\r\\n    // Check for zero.\\r\\n    // r could be zero if MIN_EXP is changed after the this value was created.\\r\\n    // This would cause a division by zero (x/t) and hence Infinity below, which would cause\\r\\n    // coeffToString to throw.\\r\\n    if (r.c[0]) {\\r\\n      e = r.e;\\r\\n      s = e + dp;\\r\\n      if (s < 3) s = 0;\\r\\n\\r\\n      // Newton-Raphson iteration.\\r\\n      for (; ;) {\\r\\n        t = r;\\r\\n        r = half.times(t.plus(div(x, t, dp, 1)));\\r\\n\\r\\n        if (coeffToString(t.c).slice(0, s) === (n = coeffToString(r.c)).slice(0, s)) {\\r\\n\\r\\n          // The exponent of r may here be one less than the final result exponent,\\r\\n          // e.g 0.0009999 (e-4) --> 0.001 (e-3), so adjust s so the rounding digits\\r\\n          // are indexed correctly.\\r\\n          if (r.e < e) --s;\\r\\n          n = n.slice(s - 3, s + 1);\\r\\n\\r\\n          // The 4th rounding digit may be in error by -1 so if the 4 rounding digits\\r\\n          // are 9999 or 4999 (i.e. approaching a rounding boundary) continue the\\r\\n          // iteration.\\r\\n          if (n == '9999' || !rep && n == '4999') {\\r\\n\\r\\n            // On the first iteration only, check to see if rounding up gives the\\r\\n            // exact result as the nines may infinitely repeat.\\r\\n            if (!rep) {\\r\\n              round(t, t.e + DECIMAL_PLACES + 2, 0);\\r\\n\\r\\n              if (t.times(t).eq(x)) {\\r\\n                r = t;\\r\\n                break;\\r\\n              }\\r\\n            }\\r\\n\\r\\n            dp += 4;\\r\\n            s += 4;\\r\\n            rep = 1;\\r\\n          } else {\\r\\n\\r\\n            // If rounding digits are null, 0{0,4} or 50{0,3}, check for exact\\r\\n            // result. If not, then there are further digits and m will be truthy.\\r\\n            if (!+n || !+n.slice(1) && n.charAt(0) == '5') {\\r\\n\\r\\n              // Truncate to the first rounding digit.\\r\\n              round(r, r.e + DECIMAL_PLACES + 2, 1);\\r\\n              m = !r.times(r).eq(x);\\r\\n            }\\r\\n\\r\\n            break;\\r\\n          }\\r\\n        }\\r\\n      }\\r\\n    }\\r\\n\\r\\n    return round(r, r.e + DECIMAL_PLACES + 1, ROUNDING_MODE, m);\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   * Return a string representing the value of this BigNumber in exponential notation and\\r\\n   * rounded using ROUNDING_MODE to dp fixed decimal places.\\r\\n   *\\r\\n   * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\\r\\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\\r\\n   *\\r\\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\\r\\n   */\\r\\n  P.toExponential = function (dp, rm) {\\r\\n    if (dp != null) {\\r\\n      intCheck(dp, 0, MAX);\\r\\n      dp++;\\r\\n    }\\r\\n    return format(this, dp, rm, 1);\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   * Return a string representing the value of this BigNumber in fixed-point notation rounding\\r\\n   * to dp fixed decimal places using rounding mode rm, or ROUNDING_MODE if rm is omitted.\\r\\n   *\\r\\n   * Note: as with JavaScript's number type, (-0).toFixed(0) is '0',\\r\\n   * but e.g. (-0.00001).toFixed(0) is '-0'.\\r\\n   *\\r\\n   * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\\r\\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\\r\\n   *\\r\\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\\r\\n   */\\r\\n  P.toFixed = function (dp, rm) {\\r\\n    if (dp != null) {\\r\\n      intCheck(dp, 0, MAX);\\r\\n      dp = dp + this.e + 1;\\r\\n    }\\r\\n    return format(this, dp, rm);\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   * Return a string representing the value of this BigNumber in fixed-point notation rounded\\r\\n   * using rm or ROUNDING_MODE to dp decimal places, and formatted according to the properties\\r\\n   * of the format or FORMAT object (see BigNumber.set).\\r\\n   *\\r\\n   * The formatting object may contain some or all of the properties shown below.\\r\\n   *\\r\\n   * FORMAT = {\\r\\n   *   prefix: '',\\r\\n   *   groupSize: 3,\\r\\n   *   secondaryGroupSize: 0,\\r\\n   *   groupSeparator: ',',\\r\\n   *   decimalSeparator: '.',\\r\\n   *   fractionGroupSize: 0,\\r\\n   *   fractionGroupSeparator: '\\\\xA0',      // non-breaking space\\r\\n   *   suffix: ''\\r\\n   * };\\r\\n   *\\r\\n   * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\\r\\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\\r\\n   * [format] {object} Formatting options. See FORMAT pbject above.\\r\\n   *\\r\\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\\r\\n   * '[BigNumber Error] Argument not an object: {format}'\\r\\n   */\\r\\n  P.toFormat = function (dp, rm, format) {\\r\\n    var str,\\r\\n      x = this;\\r\\n\\r\\n    if (format == null) {\\r\\n      if (dp != null && rm && typeof rm == 'object') {\\r\\n        format = rm;\\r\\n        rm = null;\\r\\n      } else if (dp && typeof dp == 'object') {\\r\\n        format = dp;\\r\\n        dp = rm = null;\\r\\n      } else {\\r\\n        format = FORMAT;\\r\\n      }\\r\\n    } else if (typeof format != 'object') {\\r\\n      throw Error\\r\\n        (bignumberError + 'Argument not an object: ' + format);\\r\\n    }\\r\\n\\r\\n    str = x.toFixed(dp, rm);\\r\\n\\r\\n    if (x.c) {\\r\\n      var i,\\r\\n        arr = str.split('.'),\\r\\n        g1 = +format.groupSize,\\r\\n        g2 = +format.secondaryGroupSize,\\r\\n        groupSeparator = format.groupSeparator || '',\\r\\n        intPart = arr[0],\\r\\n        fractionPart = arr[1],\\r\\n        isNeg = x.s < 0,\\r\\n        intDigits = isNeg ? intPart.slice(1) : intPart,\\r\\n        len = intDigits.length;\\r\\n\\r\\n      if (g2) i = g1, g1 = g2, g2 = i, len -= i;\\r\\n\\r\\n      if (g1 > 0 && len > 0) {\\r\\n        i = len % g1 || g1;\\r\\n        intPart = intDigits.substr(0, i);\\r\\n        for (; i < len; i += g1) intPart += groupSeparator + intDigits.substr(i, g1);\\r\\n        if (g2 > 0) intPart += groupSeparator + intDigits.slice(i);\\r\\n        if (isNeg) intPart = '-' + intPart;\\r\\n      }\\r\\n\\r\\n      str = fractionPart\\r\\n       ? intPart + (format.decimalSeparator || '') + ((g2 = +format.fractionGroupSize)\\r\\n        ? fractionPart.replace(new RegExp('\\\\\\\\d{' + g2 + '}\\\\\\\\B', 'g'),\\r\\n         '$&' + (format.fractionGroupSeparator || ''))\\r\\n        : fractionPart)\\r\\n       : intPart;\\r\\n    }\\r\\n\\r\\n    return (format.prefix || '') + str + (format.suffix || '');\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   * Return an array of two BigNumbers representing the value of this BigNumber as a simple\\r\\n   * fraction with an integer numerator and an integer denominator.\\r\\n   * The denominator will be a positive non-zero value less than or equal to the specified\\r\\n   * maximum denominator. If a maximum denominator is not specified, the denominator will be\\r\\n   * the lowest value necessary to represent the number exactly.\\r\\n   *\\r\\n   * [md] {number|string|BigNumber} Integer >= 1, or Infinity. The maximum denominator.\\r\\n   *\\r\\n   * '[BigNumber Error] Argument {not an integer|out of range} : {md}'\\r\\n   */\\r\\n  P.toFraction = function (md) {\\r\\n    var d, d0, d1, d2, e, exp, n, n0, n1, q, r, s,\\r\\n      x = this,\\r\\n      xc = x.c;\\r\\n\\r\\n    if (md != null) {\\r\\n      n = new BigNumber(md);\\r\\n\\r\\n      // Throw if md is less than one or is not an integer, unless it is Infinity.\\r\\n      if (!n.isInteger() && (n.c || n.s !== 1) || n.lt(ONE)) {\\r\\n        throw Error\\r\\n          (bignumberError + 'Argument ' +\\r\\n            (n.isInteger() ? 'out of range: ' : 'not an integer: ') + valueOf(n));\\r\\n      }\\r\\n    }\\r\\n\\r\\n    if (!xc) return new BigNumber(x);\\r\\n\\r\\n    d = new BigNumber(ONE);\\r\\n    n1 = d0 = new BigNumber(ONE);\\r\\n    d1 = n0 = new BigNumber(ONE);\\r\\n    s = coeffToString(xc);\\r\\n\\r\\n    // Determine initial denominator.\\r\\n    // d is a power of 10 and the minimum max denominator that specifies the value exactly.\\r\\n    e = d.e = s.length - x.e - 1;\\r\\n    d.c[0] = POWS_TEN[(exp = e % LOG_BASE) < 0 ? LOG_BASE + exp : exp];\\r\\n    md = !md || n.comparedTo(d) > 0 ? (e > 0 ? d : n1) : n;\\r\\n\\r\\n    exp = MAX_EXP;\\r\\n    MAX_EXP = 1 / 0;\\r\\n    n = new BigNumber(s);\\r\\n\\r\\n    // n0 = d1 = 0\\r\\n    n0.c[0] = 0;\\r\\n\\r\\n    for (; ;)  {\\r\\n      q = div(n, d, 0, 1);\\r\\n      d2 = d0.plus(q.times(d1));\\r\\n      if (d2.comparedTo(md) == 1) break;\\r\\n      d0 = d1;\\r\\n      d1 = d2;\\r\\n      n1 = n0.plus(q.times(d2 = n1));\\r\\n      n0 = d2;\\r\\n      d = n.minus(q.times(d2 = d));\\r\\n      n = d2;\\r\\n    }\\r\\n\\r\\n    d2 = div(md.minus(d0), d1, 0, 1);\\r\\n    n0 = n0.plus(d2.times(n1));\\r\\n    d0 = d0.plus(d2.times(d1));\\r\\n    n0.s = n1.s = x.s;\\r\\n    e = e * 2;\\r\\n\\r\\n    // Determine which fraction is closer to x, n0/d0 or n1/d1\\r\\n    r = div(n1, d1, e, ROUNDING_MODE).minus(x).abs().comparedTo(\\r\\n        div(n0, d0, e, ROUNDING_MODE).minus(x).abs()) < 1 ? [n1, d1] : [n0, d0];\\r\\n\\r\\n    MAX_EXP = exp;\\r\\n\\r\\n    return r;\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   * Return the value of this BigNumber converted to a number primitive.\\r\\n   */\\r\\n  P.toNumber = function () {\\r\\n    return +valueOf(this);\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   * Return a string representing the value of this BigNumber rounded to sd significant digits\\r\\n   * using rounding mode rm or ROUNDING_MODE. If sd is less than the number of digits\\r\\n   * necessary to represent the integer part of the value in fixed-point notation, then use\\r\\n   * exponential notation.\\r\\n   *\\r\\n   * [sd] {number} Significant digits. Integer, 1 to MAX inclusive.\\r\\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\\r\\n   *\\r\\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}'\\r\\n   */\\r\\n  P.toPrecision = function (sd, rm) {\\r\\n    if (sd != null) intCheck(sd, 1, MAX);\\r\\n    return format(this, sd, rm, 2);\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   * Return a string representing the value of this BigNumber in base b, or base 10 if b is\\r\\n   * omitted. If a base is specified, including base 10, round according to DECIMAL_PLACES and\\r\\n   * ROUNDING_MODE. If a base is not specified, and this BigNumber has a positive exponent\\r\\n   * that is equal to or greater than TO_EXP_POS, or a negative exponent equal to or less than\\r\\n   * TO_EXP_NEG, return exponential notation.\\r\\n   *\\r\\n   * [b] {number} Integer, 2 to ALPHABET.length inclusive.\\r\\n   *\\r\\n   * '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}'\\r\\n   */\\r\\n  P.toString = function (b) {\\r\\n    var str,\\r\\n      n = this,\\r\\n      s = n.s,\\r\\n      e = n.e;\\r\\n\\r\\n    // Infinity or NaN?\\r\\n    if (e === null) {\\r\\n      if (s) {\\r\\n        str = 'Infinity';\\r\\n        if (s < 0) str = '-' + str;\\r\\n      } else {\\r\\n        str = 'NaN';\\r\\n      }\\r\\n    } else {\\r\\n      if (b == null) {\\r\\n        str = e <= TO_EXP_NEG || e >= TO_EXP_POS\\r\\n         ? toExponential(coeffToString(n.c), e)\\r\\n         : toFixedPoint(coeffToString(n.c), e, '0');\\r\\n      } else if (b === 10 && alphabetHasNormalDecimalDigits) {\\r\\n        n = round(new BigNumber(n), DECIMAL_PLACES + e + 1, ROUNDING_MODE);\\r\\n        str = toFixedPoint(coeffToString(n.c), n.e, '0');\\r\\n      } else {\\r\\n        intCheck(b, 2, ALPHABET.length, 'Base');\\r\\n        str = convertBase(toFixedPoint(coeffToString(n.c), e, '0'), 10, b, s, true);\\r\\n      }\\r\\n\\r\\n      if (s < 0 && n.c[0]) str = '-' + str;\\r\\n    }\\r\\n\\r\\n    return str;\\r\\n  };\\r\\n\\r\\n\\r\\n  /*\\r\\n   * Return as toString, but do not accept a base argument, and include the minus sign for\\r\\n   * negative zero.\\r\\n   */\\r\\n  P.valueOf = P.toJSON = function () {\\r\\n    return valueOf(this);\\r\\n  };\\r\\n\\r\\n\\r\\n  P._isBigNumber = true;\\r\\n\\r\\n  P[Symbol.toStringTag] = 'BigNumber';\\r\\n\\r\\n  // Node.js v10.12.0+\\r\\n  P[Symbol.for('nodejs.util.inspect.custom')] = P.valueOf;\\r\\n\\r\\n  if (configObject != null) BigNumber.set(configObject);\\r\\n\\r\\n  return BigNumber;\\r\\n}\\r\\n\\r\\n\\r\\n// PRIVATE HELPER FUNCTIONS\\r\\n\\r\\n// These functions don't need access to variables,\\r\\n// e.g. DECIMAL_PLACES, in the scope of the `clone` function above.\\r\\n\\r\\n\\r\\nfunction bitFloor(n) {\\r\\n  var i = n | 0;\\r\\n  return n > 0 || n === i ? i : i - 1;\\r\\n}\\r\\n\\r\\n\\r\\n// Return a coefficient array as a string of base 10 digits.\\r\\nfunction coeffToString(a) {\\r\\n  var s, z,\\r\\n    i = 1,\\r\\n    j = a.length,\\r\\n    r = a[0] + '';\\r\\n\\r\\n  for (; i < j;) {\\r\\n    s = a[i++] + '';\\r\\n    z = LOG_BASE - s.length;\\r\\n    for (; z--; s = '0' + s);\\r\\n    r += s;\\r\\n  }\\r\\n\\r\\n  // Determine trailing zeros.\\r\\n  for (j = r.length; r.charCodeAt(--j) === 48;);\\r\\n\\r\\n  return r.slice(0, j + 1 || 1);\\r\\n}\\r\\n\\r\\n\\r\\n// Compare the value of BigNumbers x and y.\\r\\nfunction compare(x, y) {\\r\\n  var a, b,\\r\\n    xc = x.c,\\r\\n    yc = y.c,\\r\\n    i = x.s,\\r\\n    j = y.s,\\r\\n    k = x.e,\\r\\n    l = y.e;\\r\\n\\r\\n  // Either NaN?\\r\\n  if (!i || !j) return null;\\r\\n\\r\\n  a = xc && !xc[0];\\r\\n  b = yc && !yc[0];\\r\\n\\r\\n  // Either zero?\\r\\n  if (a || b) return a ? b ? 0 : -j : i;\\r\\n\\r\\n  // Signs differ?\\r\\n  if (i != j) return i;\\r\\n\\r\\n  a = i < 0;\\r\\n  b = k == l;\\r\\n\\r\\n  // Either Infinity?\\r\\n  if (!xc || !yc) return b ? 0 : !xc ^ a ? 1 : -1;\\r\\n\\r\\n  // Compare exponents.\\r\\n  if (!b) return k > l ^ a ? 1 : -1;\\r\\n\\r\\n  j = (k = xc.length) < (l = yc.length) ? k : l;\\r\\n\\r\\n  // Compare digit by digit.\\r\\n  for (i = 0; i < j; i++) if (xc[i] != yc[i]) return xc[i] > yc[i] ^ a ? 1 : -1;\\r\\n\\r\\n  // Compare lengths.\\r\\n  return k == l ? 0 : k > l ^ a ? 1 : -1;\\r\\n}\\r\\n\\r\\n\\r\\n/*\\r\\n * Check that n is a primitive number, an integer, and in range, otherwise throw.\\r\\n */\\r\\nfunction intCheck(n, min, max, name) {\\r\\n  if (n < min || n > max || n !== mathfloor(n)) {\\r\\n    throw Error\\r\\n     (bignumberError + (name || 'Argument') + (typeof n == 'number'\\r\\n       ? n < min || n > max ? ' out of range: ' : ' not an integer: '\\r\\n       : ' not a primitive number: ') + String(n));\\r\\n  }\\r\\n}\\r\\n\\r\\n\\r\\n// Assumes finite n.\\r\\nfunction isOdd(n) {\\r\\n  var k = n.c.length - 1;\\r\\n  return bitFloor(n.e / LOG_BASE) == k && n.c[k] % 2 != 0;\\r\\n}\\r\\n\\r\\n\\r\\nfunction toExponential(str, e) {\\r\\n  return (str.length > 1 ? str.charAt(0) + '.' + str.slice(1) : str) +\\r\\n   (e < 0 ? 'e' : 'e+') + e;\\r\\n}\\r\\n\\r\\n\\r\\nfunction toFixedPoint(str, e, z) {\\r\\n  var len, zs;\\r\\n\\r\\n  // Negative exponent?\\r\\n  if (e < 0) {\\r\\n\\r\\n    // Prepend zeros.\\r\\n    for (zs = z + '.'; ++e; zs += z);\\r\\n    str = zs + str;\\r\\n\\r\\n  // Positive exponent\\r\\n  } else {\\r\\n    len = str.length;\\r\\n\\r\\n    // Append zeros.\\r\\n    if (++e > len) {\\r\\n      for (zs = z, e -= len; --e; zs += z);\\r\\n      str += zs;\\r\\n    } else if (e < len) {\\r\\n      str = str.slice(0, e) + '.' + str.slice(e);\\r\\n    }\\r\\n  }\\r\\n\\r\\n  return str;\\r\\n}\\r\\n\\r\\n\\r\\n// EXPORT\\r\\n\\r\\n\\r\\nvar BigNumber = clone();\\r\\n\\r\\n/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (BigNumber);\\r\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/bignumber.js/bignumber.mjs?\");\n\n/***/ }),\n\n/***/ \"./node_modules/superstruct/lib/index.es.js\":\n/*!**************************************************!*\\\n  !*** ./node_modules/superstruct/lib/index.es.js ***!\n  \\**************************************************/\n/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {\n\n\"use strict\";\neval(\"__webpack_require__.r(__webpack_exports__);\\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\\n/* harmony export */   \\\"Struct\\\": () => (/* binding */ Struct),\\n/* harmony export */   \\\"StructError\\\": () => (/* binding */ StructError),\\n/* harmony export */   \\\"any\\\": () => (/* binding */ any),\\n/* harmony export */   \\\"array\\\": () => (/* binding */ array),\\n/* harmony export */   \\\"assert\\\": () => (/* binding */ assert),\\n/* harmony export */   \\\"assign\\\": () => (/* binding */ assign),\\n/* harmony export */   \\\"boolean\\\": () => (/* binding */ boolean),\\n/* harmony export */   \\\"coerce\\\": () => (/* binding */ coerce),\\n/* harmony export */   \\\"create\\\": () => (/* binding */ create),\\n/* harmony export */   \\\"date\\\": () => (/* binding */ date),\\n/* harmony export */   \\\"defaulted\\\": () => (/* binding */ defaulted),\\n/* harmony export */   \\\"define\\\": () => (/* binding */ define),\\n/* harmony export */   \\\"deprecated\\\": () => (/* binding */ deprecated),\\n/* harmony export */   \\\"dynamic\\\": () => (/* binding */ dynamic),\\n/* harmony export */   \\\"empty\\\": () => (/* binding */ empty),\\n/* harmony export */   \\\"enums\\\": () => (/* binding */ enums),\\n/* harmony export */   \\\"func\\\": () => (/* binding */ func),\\n/* harmony export */   \\\"instance\\\": () => (/* binding */ instance),\\n/* harmony export */   \\\"integer\\\": () => (/* binding */ integer),\\n/* harmony export */   \\\"intersection\\\": () => (/* binding */ intersection),\\n/* harmony export */   \\\"is\\\": () => (/* binding */ is),\\n/* harmony export */   \\\"lazy\\\": () => (/* binding */ lazy),\\n/* harmony export */   \\\"literal\\\": () => (/* binding */ literal),\\n/* harmony export */   \\\"map\\\": () => (/* binding */ map),\\n/* harmony export */   \\\"mask\\\": () => (/* binding */ mask),\\n/* harmony export */   \\\"max\\\": () => (/* binding */ max),\\n/* harmony export */   \\\"min\\\": () => (/* binding */ min),\\n/* harmony export */   \\\"never\\\": () => (/* binding */ never),\\n/* harmony export */   \\\"nullable\\\": () => (/* binding */ nullable),\\n/* harmony export */   \\\"number\\\": () => (/* binding */ number),\\n/* harmony export */   \\\"object\\\": () => (/* binding */ object),\\n/* harmony export */   \\\"omit\\\": () => (/* binding */ omit),\\n/* harmony export */   \\\"optional\\\": () => (/* binding */ optional),\\n/* harmony export */   \\\"partial\\\": () => (/* binding */ partial),\\n/* harmony export */   \\\"pattern\\\": () => (/* binding */ pattern),\\n/* harmony export */   \\\"pick\\\": () => (/* binding */ pick),\\n/* harmony export */   \\\"record\\\": () => (/* binding */ record),\\n/* harmony export */   \\\"refine\\\": () => (/* binding */ refine),\\n/* harmony export */   \\\"regexp\\\": () => (/* binding */ regexp),\\n/* harmony export */   \\\"set\\\": () => (/* binding */ set),\\n/* harmony export */   \\\"size\\\": () => (/* binding */ size),\\n/* harmony export */   \\\"string\\\": () => (/* binding */ string),\\n/* harmony export */   \\\"struct\\\": () => (/* binding */ struct),\\n/* harmony export */   \\\"trimmed\\\": () => (/* binding */ trimmed),\\n/* harmony export */   \\\"tuple\\\": () => (/* binding */ tuple),\\n/* harmony export */   \\\"type\\\": () => (/* binding */ type),\\n/* harmony export */   \\\"union\\\": () => (/* binding */ union),\\n/* harmony export */   \\\"unknown\\\": () => (/* binding */ unknown),\\n/* harmony export */   \\\"validate\\\": () => (/* binding */ validate)\\n/* harmony export */ });\\n/**\\n * A `StructFailure` represents a single specific failure in validation.\\n */\\n\\n/**\\n * `StructError` objects are thrown (or returned) when validation fails.\\n *\\n * Validation logic is design to exit early for maximum performance. The error\\n * represents the first error encountered during validation. For more detail,\\n * the `error.failures` property is a generator function that can be run to\\n * continue validation and receive all the failures in the data.\\n */\\nclass StructError extends TypeError {\\n  constructor(failure, failures) {\\n    let cached;\\n    const {\\n      message,\\n      ...rest\\n    } = failure;\\n    const {\\n      path\\n    } = failure;\\n    const msg = path.length === 0 ? message : \\\"At path: \\\" + path.join('.') + \\\" -- \\\" + message;\\n    super(msg);\\n    Object.assign(this, rest);\\n    this.name = this.constructor.name;\\n\\n    this.failures = () => {\\n      var _cached;\\n\\n      return (_cached = cached) != null ? _cached : cached = [failure, ...failures()];\\n    };\\n  }\\n\\n}\\n\\n/**\\n * Check if a value is an iterator.\\n */\\nfunction isIterable(x) {\\n  return isObject(x) && typeof x[Symbol.iterator] === 'function';\\n}\\n/**\\n * Check if a value is a plain object.\\n */\\n\\n\\nfunction isObject(x) {\\n  return typeof x === 'object' && x != null;\\n}\\n/**\\n * Check if a value is a plain object.\\n */\\n\\nfunction isPlainObject(x) {\\n  if (Object.prototype.toString.call(x) !== '[object Object]') {\\n    return false;\\n  }\\n\\n  const prototype = Object.getPrototypeOf(x);\\n  return prototype === null || prototype === Object.prototype;\\n}\\n/**\\n * Return a value as a printable string.\\n */\\n\\nfunction print(value) {\\n  return typeof value === 'string' ? JSON.stringify(value) : \\\"\\\" + value;\\n}\\n/**\\n * Shifts (removes and returns) the first value from the `input` iterator.\\n * Like `Array.prototype.shift()` but for an `Iterator`.\\n */\\n\\nfunction shiftIterator(input) {\\n  const {\\n    done,\\n    value\\n  } = input.next();\\n  return done ? undefined : value;\\n}\\n/**\\n * Convert a single validation result to a failure.\\n */\\n\\nfunction toFailure(result, context, struct, value) {\\n  if (result === true) {\\n    return;\\n  } else if (result === false) {\\n    result = {};\\n  } else if (typeof result === 'string') {\\n    result = {\\n      message: result\\n    };\\n  }\\n\\n  const {\\n    path,\\n    branch\\n  } = context;\\n  const {\\n    type\\n  } = struct;\\n  const {\\n    refinement,\\n    message = \\\"Expected a value of type `\\\" + type + \\\"`\\\" + (refinement ? \\\" with refinement `\\\" + refinement + \\\"`\\\" : '') + \\\", but received: `\\\" + print(value) + \\\"`\\\"\\n  } = result;\\n  return {\\n    value,\\n    type,\\n    refinement,\\n    key: path[path.length - 1],\\n    path,\\n    branch,\\n    ...result,\\n    message\\n  };\\n}\\n/**\\n * Convert a validation result to an iterable of failures.\\n */\\n\\nfunction* toFailures(result, context, struct, value) {\\n  if (!isIterable(result)) {\\n    result = [result];\\n  }\\n\\n  for (const r of result) {\\n    const failure = toFailure(r, context, struct, value);\\n\\n    if (failure) {\\n      yield failure;\\n    }\\n  }\\n}\\n/**\\n * Check a value against a struct, traversing deeply into nested values, and\\n * returning an iterator of failures or success.\\n */\\n\\nfunction* run(value, struct, options = {}) {\\n  const {\\n    path = [],\\n    branch = [value],\\n    coerce = false,\\n    mask = false\\n  } = options;\\n  const ctx = {\\n    path,\\n    branch\\n  };\\n\\n  if (coerce) {\\n    value = struct.coercer(value, ctx);\\n\\n    if (mask && struct.type !== 'type' && isObject(struct.schema) && isObject(value) && !Array.isArray(value)) {\\n      for (const key in value) {\\n        if (struct.schema[key] === undefined) {\\n          delete value[key];\\n        }\\n      }\\n    }\\n  }\\n\\n  let valid = true;\\n\\n  for (const failure of struct.validator(value, ctx)) {\\n    valid = false;\\n    yield [failure, undefined];\\n  }\\n\\n  for (let [k, v, s] of struct.entries(value, ctx)) {\\n    const ts = run(v, s, {\\n      path: k === undefined ? path : [...path, k],\\n      branch: k === undefined ? branch : [...branch, v],\\n      coerce,\\n      mask\\n    });\\n\\n    for (const t of ts) {\\n      if (t[0]) {\\n        valid = false;\\n        yield [t[0], undefined];\\n      } else if (coerce) {\\n        v = t[1];\\n\\n        if (k === undefined) {\\n          value = v;\\n        } else if (value instanceof Map) {\\n          value.set(k, v);\\n        } else if (value instanceof Set) {\\n          value.add(v);\\n        } else if (isObject(value)) {\\n          value[k] = v;\\n        }\\n      }\\n    }\\n  }\\n\\n  if (valid) {\\n    for (const failure of struct.refiner(value, ctx)) {\\n      valid = false;\\n      yield [failure, undefined];\\n    }\\n  }\\n\\n  if (valid) {\\n    yield [undefined, value];\\n  }\\n}\\n\\n/**\\n * `Struct` objects encapsulate the validation logic for a specific type of\\n * values. Once constructed, you use the `assert`, `is` or `validate` helpers to\\n * validate unknown input data against the struct.\\n */\\n\\nclass Struct {\\n  constructor(props) {\\n    const {\\n      type,\\n      schema,\\n      validator,\\n      refiner,\\n      coercer = value => value,\\n      entries = function* () {}\\n    } = props;\\n    this.type = type;\\n    this.schema = schema;\\n    this.entries = entries;\\n    this.coercer = coercer;\\n\\n    if (validator) {\\n      this.validator = (value, context) => {\\n        const result = validator(value, context);\\n        return toFailures(result, context, this, value);\\n      };\\n    } else {\\n      this.validator = () => [];\\n    }\\n\\n    if (refiner) {\\n      this.refiner = (value, context) => {\\n        const result = refiner(value, context);\\n        return toFailures(result, context, this, value);\\n      };\\n    } else {\\n      this.refiner = () => [];\\n    }\\n  }\\n  /**\\n   * Assert that a value passes the struct's validation, throwing if it doesn't.\\n   */\\n\\n\\n  assert(value) {\\n    return assert(value, this);\\n  }\\n  /**\\n   * Create a value with the struct's coercion logic, then validate it.\\n   */\\n\\n\\n  create(value) {\\n    return create(value, this);\\n  }\\n  /**\\n   * Check if a value passes the struct's validation.\\n   */\\n\\n\\n  is(value) {\\n    return is(value, this);\\n  }\\n  /**\\n   * Mask a value, coercing and validating it, but returning only the subset of\\n   * properties defined by the struct's schema.\\n   */\\n\\n\\n  mask(value) {\\n    return mask(value, this);\\n  }\\n  /**\\n   * Validate a value with the struct's validation logic, returning a tuple\\n   * representing the result.\\n   *\\n   * You may optionally pass `true` for the `withCoercion` argument to coerce\\n   * the value before attempting to validate it. If you do, the result will\\n   * contain the coerced result when successful.\\n   */\\n\\n\\n  validate(value, options = {}) {\\n    return validate(value, this, options);\\n  }\\n\\n}\\n/**\\n * Assert that a value passes a struct, throwing if it doesn't.\\n */\\n\\nfunction assert(value, struct) {\\n  const result = validate(value, struct);\\n\\n  if (result[0]) {\\n    throw result[0];\\n  }\\n}\\n/**\\n * Create a value with the coercion logic of struct and validate it.\\n */\\n\\nfunction create(value, struct) {\\n  const result = validate(value, struct, {\\n    coerce: true\\n  });\\n\\n  if (result[0]) {\\n    throw result[0];\\n  } else {\\n    return result[1];\\n  }\\n}\\n/**\\n * Mask a value, returning only the subset of properties defined by a struct.\\n */\\n\\nfunction mask(value, struct) {\\n  const result = validate(value, struct, {\\n    coerce: true,\\n    mask: true\\n  });\\n\\n  if (result[0]) {\\n    throw result[0];\\n  } else {\\n    return result[1];\\n  }\\n}\\n/**\\n * Check if a value passes a struct.\\n */\\n\\nfunction is(value, struct) {\\n  const result = validate(value, struct);\\n  return !result[0];\\n}\\n/**\\n * Validate a value against a struct, returning an error if invalid, or the\\n * value (with potential coercion) if valid.\\n */\\n\\nfunction validate(value, struct, options = {}) {\\n  const tuples = run(value, struct, options);\\n  const tuple = shiftIterator(tuples);\\n\\n  if (tuple[0]) {\\n    const error = new StructError(tuple[0], function* () {\\n      for (const t of tuples) {\\n        if (t[0]) {\\n          yield t[0];\\n        }\\n      }\\n    });\\n    return [error, undefined];\\n  } else {\\n    const v = tuple[1];\\n    return [undefined, v];\\n  }\\n}\\n\\nfunction assign(...Structs) {\\n  const schemas = Structs.map(s => s.schema);\\n  const schema = Object.assign({}, ...schemas);\\n  return object(schema);\\n}\\n/**\\n * Define a new struct type with a custom validation function.\\n */\\n\\nfunction define(name, validator) {\\n  return new Struct({\\n    type: name,\\n    schema: null,\\n    validator\\n  });\\n}\\n/**\\n * Create a new struct based on an existing struct, but the value is allowed to\\n * be `undefined`. `log` will be called if the value is not `undefined`.\\n */\\n\\nfunction deprecated(struct, log) {\\n  return new Struct({ ...struct,\\n    refiner: (value, ctx) => value === undefined || struct.refiner(value, ctx),\\n\\n    validator(value, ctx) {\\n      if (value === undefined) {\\n        return true;\\n      } else {\\n        log(value, ctx);\\n        return struct.validator(value, ctx);\\n      }\\n    }\\n\\n  });\\n}\\n/**\\n * Create a struct with dynamic validation logic.\\n *\\n * The callback will receive the value currently being validated, and must\\n * return a struct object to validate it with. This can be useful to model\\n * validation logic that changes based on its input.\\n */\\n\\nfunction dynamic(fn) {\\n  return new Struct({\\n    type: 'dynamic',\\n    schema: null,\\n\\n    *entries(value, ctx) {\\n      const struct = fn(value, ctx);\\n      yield* struct.entries(value, ctx);\\n    },\\n\\n    validator(value, ctx) {\\n      const struct = fn(value, ctx);\\n      return struct.validator(value, ctx);\\n    },\\n\\n    coercer(value, ctx) {\\n      const struct = fn(value, ctx);\\n      return struct.coercer(value, ctx);\\n    }\\n\\n  });\\n}\\n/**\\n * Create a struct with lazily evaluated validation logic.\\n *\\n * The first time validation is run with the struct, the callback will be called\\n * and must return a struct object to use. This is useful for cases where you\\n * want to have self-referential structs for nested data structures to avoid a\\n * circular definition problem.\\n */\\n\\nfunction lazy(fn) {\\n  let struct;\\n  return new Struct({\\n    type: 'lazy',\\n    schema: null,\\n\\n    *entries(value, ctx) {\\n      var _struct;\\n\\n      (_struct = struct) != null ? _struct : struct = fn();\\n      yield* struct.entries(value, ctx);\\n    },\\n\\n    validator(value, ctx) {\\n      var _struct2;\\n\\n      (_struct2 = struct) != null ? _struct2 : struct = fn();\\n      return struct.validator(value, ctx);\\n    },\\n\\n    coercer(value, ctx) {\\n      var _struct3;\\n\\n      (_struct3 = struct) != null ? _struct3 : struct = fn();\\n      return struct.coercer(value, ctx);\\n    }\\n\\n  });\\n}\\n/**\\n * Create a new struct based on an existing object struct, but excluding\\n * specific properties.\\n *\\n * Like TypeScript's `Omit` utility.\\n */\\n\\nfunction omit(struct, keys) {\\n  const {\\n    schema\\n  } = struct;\\n  const subschema = { ...schema\\n  };\\n\\n  for (const key of keys) {\\n    delete subschema[key];\\n  }\\n\\n  return object(subschema);\\n}\\n/**\\n * Create a new struct based on an existing object struct, but with all of its\\n * properties allowed to be `undefined`.\\n *\\n * Like TypeScript's `Partial` utility.\\n */\\n\\nfunction partial(struct) {\\n  const schema = struct instanceof Struct ? { ...struct.schema\\n  } : { ...struct\\n  };\\n\\n  for (const key in schema) {\\n    schema[key] = optional(schema[key]);\\n  }\\n\\n  return object(schema);\\n}\\n/**\\n * Create a new struct based on an existing object struct, but only including\\n * specific properties.\\n *\\n * Like TypeScript's `Pick` utility.\\n */\\n\\nfunction pick(struct, keys) {\\n  const {\\n    schema\\n  } = struct;\\n  const subschema = {};\\n\\n  for (const key of keys) {\\n    subschema[key] = schema[key];\\n  }\\n\\n  return object(subschema);\\n}\\n/**\\n * Define a new struct type with a custom validation function.\\n *\\n * @deprecated This function has been renamed to `define`.\\n */\\n\\nfunction struct(name, validator) {\\n  console.warn('superstruct@0.11 - The `struct` helper has been renamed to `define`.');\\n  return define(name, validator);\\n}\\n\\n/**\\n * Ensure that any value passes validation.\\n */\\n\\nfunction any() {\\n  return define('any', () => true);\\n}\\nfunction array(Element) {\\n  return new Struct({\\n    type: 'array',\\n    schema: Element,\\n\\n    *entries(value) {\\n      if (Element && Array.isArray(value)) {\\n        for (const [i, v] of value.entries()) {\\n          yield [i, v, Element];\\n        }\\n      }\\n    },\\n\\n    coercer(value) {\\n      return Array.isArray(value) ? value.slice() : value;\\n    },\\n\\n    validator(value) {\\n      return Array.isArray(value) || \\\"Expected an array value, but received: \\\" + print(value);\\n    }\\n\\n  });\\n}\\n/**\\n * Ensure that a value is a boolean.\\n */\\n\\nfunction boolean() {\\n  return define('boolean', value => {\\n    return typeof value === 'boolean';\\n  });\\n}\\n/**\\n * Ensure that a value is a valid `Date`.\\n *\\n * Note: this also ensures that the value is *not* an invalid `Date` object,\\n * which can occur when parsing a date fails but still returns a `Date`.\\n */\\n\\nfunction date() {\\n  return define('date', value => {\\n    return value instanceof Date && !isNaN(value.getTime()) || \\\"Expected a valid `Date` object, but received: \\\" + print(value);\\n  });\\n}\\nfunction enums(values) {\\n  const schema = {};\\n  const description = values.map(v => print(v)).join();\\n\\n  for (const key of values) {\\n    schema[key] = key;\\n  }\\n\\n  return new Struct({\\n    type: 'enums',\\n    schema,\\n\\n    validator(value) {\\n      return values.includes(value) || \\\"Expected one of `\\\" + description + \\\"`, but received: \\\" + print(value);\\n    }\\n\\n  });\\n}\\n/**\\n * Ensure that a value is a function.\\n */\\n\\nfunction func() {\\n  return define('func', value => {\\n    return typeof value === 'function' || \\\"Expected a function, but received: \\\" + print(value);\\n  });\\n}\\n/**\\n * Ensure that a value is an instance of a specific class.\\n */\\n\\nfunction instance(Class) {\\n  return define('instance', value => {\\n    return value instanceof Class || \\\"Expected a `\\\" + Class.name + \\\"` instance, but received: \\\" + print(value);\\n  });\\n}\\n/**\\n * Ensure that a value is an integer.\\n */\\n\\nfunction integer() {\\n  return define('integer', value => {\\n    return typeof value === 'number' && !isNaN(value) && Number.isInteger(value) || \\\"Expected an integer, but received: \\\" + print(value);\\n  });\\n}\\nfunction intersection(Structs) {\\n  return new Struct({\\n    type: 'intersection',\\n    schema: null,\\n\\n    *entries(value, ctx) {\\n      for (const S of Structs) {\\n        yield* S.entries(value, ctx);\\n      }\\n    },\\n\\n    *validator(value, ctx) {\\n      for (const S of Structs) {\\n        yield* S.validator(value, ctx);\\n      }\\n    },\\n\\n    *refiner(value, ctx) {\\n      for (const S of Structs) {\\n        yield* S.refiner(value, ctx);\\n      }\\n    }\\n\\n  });\\n}\\nfunction literal(constant) {\\n  const description = print(constant);\\n  const t = typeof constant;\\n  return new Struct({\\n    type: 'literal',\\n    schema: t === 'string' || t === 'number' || t === 'boolean' ? constant : null,\\n\\n    validator(value) {\\n      return value === constant || \\\"Expected the literal `\\\" + description + \\\"`, but received: \\\" + print(value);\\n    }\\n\\n  });\\n}\\nfunction map(Key, Value) {\\n  return new Struct({\\n    type: 'map',\\n    schema: null,\\n\\n    *entries(value) {\\n      if (Key && Value && value instanceof Map) {\\n        for (const [k, v] of value.entries()) {\\n          yield [k, k, Key];\\n          yield [k, v, Value];\\n        }\\n      }\\n    },\\n\\n    coercer(value) {\\n      return value instanceof Map ? new Map(value) : value;\\n    },\\n\\n    validator(value) {\\n      return value instanceof Map || \\\"Expected a `Map` object, but received: \\\" + print(value);\\n    }\\n\\n  });\\n}\\n/**\\n * Ensure that no value ever passes validation.\\n */\\n\\nfunction never() {\\n  return define('never', () => false);\\n}\\n/**\\n * Augment an existing struct to allow `null` values.\\n */\\n\\nfunction nullable(struct) {\\n  return new Struct({ ...struct,\\n    validator: (value, ctx) => value === null || struct.validator(value, ctx),\\n    refiner: (value, ctx) => value === null || struct.refiner(value, ctx)\\n  });\\n}\\n/**\\n * Ensure that a value is a number.\\n */\\n\\nfunction number() {\\n  return define('number', value => {\\n    return typeof value === 'number' && !isNaN(value) || \\\"Expected a number, but received: \\\" + print(value);\\n  });\\n}\\nfunction object(schema) {\\n  const knowns = schema ? Object.keys(schema) : [];\\n  const Never = never();\\n  return new Struct({\\n    type: 'object',\\n    schema: schema ? schema : null,\\n\\n    *entries(value) {\\n      if (schema && isObject(value)) {\\n        const unknowns = new Set(Object.keys(value));\\n\\n        for (const key of knowns) {\\n          unknowns.delete(key);\\n          yield [key, value[key], schema[key]];\\n        }\\n\\n        for (const key of unknowns) {\\n          yield [key, value[key], Never];\\n        }\\n      }\\n    },\\n\\n    validator(value) {\\n      return isObject(value) || \\\"Expected an object, but received: \\\" + print(value);\\n    },\\n\\n    coercer(value) {\\n      return isObject(value) ? { ...value\\n      } : value;\\n    }\\n\\n  });\\n}\\n/**\\n * Augment a struct to allow `undefined` values.\\n */\\n\\nfunction optional(struct) {\\n  return new Struct({ ...struct,\\n    validator: (value, ctx) => value === undefined || struct.validator(value, ctx),\\n    refiner: (value, ctx) => value === undefined || struct.refiner(value, ctx)\\n  });\\n}\\n/**\\n * Ensure that a value is an object with keys and values of specific types, but\\n * without ensuring any specific shape of properties.\\n *\\n * Like TypeScript's `Record` utility.\\n */\\n\\nfunction record(Key, Value) {\\n  return new Struct({\\n    type: 'record',\\n    schema: null,\\n\\n    *entries(value) {\\n      if (isObject(value)) {\\n        for (const k in value) {\\n          const v = value[k];\\n          yield [k, k, Key];\\n          yield [k, v, Value];\\n        }\\n      }\\n    },\\n\\n    validator(value) {\\n      return isObject(value) || \\\"Expected an object, but received: \\\" + print(value);\\n    }\\n\\n  });\\n}\\n/**\\n * Ensure that a value is a `RegExp`.\\n *\\n * Note: this does not test the value against the regular expression! For that\\n * you need to use the `pattern()` refinement.\\n */\\n\\nfunction regexp() {\\n  return define('regexp', value => {\\n    return value instanceof RegExp;\\n  });\\n}\\nfunction set(Element) {\\n  return new Struct({\\n    type: 'set',\\n    schema: null,\\n\\n    *entries(value) {\\n      if (Element && value instanceof Set) {\\n        for (const v of value) {\\n          yield [v, v, Element];\\n        }\\n      }\\n    },\\n\\n    coercer(value) {\\n      return value instanceof Set ? new Set(value) : value;\\n    },\\n\\n    validator(value) {\\n      return value instanceof Set || \\\"Expected a `Set` object, but received: \\\" + print(value);\\n    }\\n\\n  });\\n}\\n/**\\n * Ensure that a value is a string.\\n */\\n\\nfunction string() {\\n  return define('string', value => {\\n    return typeof value === 'string' || \\\"Expected a string, but received: \\\" + print(value);\\n  });\\n}\\nfunction tuple(Elements) {\\n  const Never = never();\\n  return new Struct({\\n    type: 'tuple',\\n    schema: null,\\n\\n    *entries(value) {\\n      if (Array.isArray(value)) {\\n        const length = Math.max(Elements.length, value.length);\\n\\n        for (let i = 0; i < length; i++) {\\n          yield [i, value[i], Elements[i] || Never];\\n        }\\n      }\\n    },\\n\\n    validator(value) {\\n      return Array.isArray(value) || \\\"Expected an array, but received: \\\" + print(value);\\n    }\\n\\n  });\\n}\\n/**\\n * Ensure that a value has a set of known properties of specific types.\\n *\\n * Note: Unrecognized properties are allowed and untouched. This is similar to\\n * how TypeScript's structural typing works.\\n */\\n\\nfunction type(schema) {\\n  const keys = Object.keys(schema);\\n  return new Struct({\\n    type: 'type',\\n    schema,\\n\\n    *entries(value) {\\n      if (isObject(value)) {\\n        for (const k of keys) {\\n          yield [k, value[k], schema[k]];\\n        }\\n      }\\n    },\\n\\n    validator(value) {\\n      return isObject(value) || \\\"Expected an object, but received: \\\" + print(value);\\n    }\\n\\n  });\\n}\\nfunction union(Structs) {\\n  const description = Structs.map(s => s.type).join(' | ');\\n  return new Struct({\\n    type: 'union',\\n    schema: null,\\n\\n    validator(value, ctx) {\\n      const failures = [];\\n\\n      for (const S of Structs) {\\n        const [...tuples] = run(value, S, ctx);\\n        const [first] = tuples;\\n\\n        if (!first[0]) {\\n          return [];\\n        } else {\\n          for (const [failure] of tuples) {\\n            if (failure) {\\n              failures.push(failure);\\n            }\\n          }\\n        }\\n      }\\n\\n      return [\\\"Expected the value to satisfy a union of `\\\" + description + \\\"`, but received: \\\" + print(value), ...failures];\\n    }\\n\\n  });\\n}\\n/**\\n * Ensure that any value passes validation, without widening its type to `any`.\\n */\\n\\nfunction unknown() {\\n  return define('unknown', () => true);\\n}\\n\\n/**\\n * Augment a `Struct` to add an additional coercion step to its input.\\n *\\n * This allows you to transform input data before validating it, to increase the\\n * likelihood that it passes validation—for example for default values, parsing\\n * different formats, etc.\\n *\\n * Note: You must use `create(value, Struct)` on the value to have the coercion\\n * take effect! Using simply `assert()` or `is()` will not use coercion.\\n */\\n\\nfunction coerce(struct, condition, coercer) {\\n  return new Struct({ ...struct,\\n    coercer: (value, ctx) => {\\n      return is(value, condition) ? struct.coercer(coercer(value, ctx), ctx) : struct.coercer(value, ctx);\\n    }\\n  });\\n}\\n/**\\n * Augment a struct to replace `undefined` values with a default.\\n *\\n * Note: You must use `create(value, Struct)` on the value to have the coercion\\n * take effect! Using simply `assert()` or `is()` will not use coercion.\\n */\\n\\nfunction defaulted(struct, fallback, options = {}) {\\n  return coerce(struct, unknown(), x => {\\n    const f = typeof fallback === 'function' ? fallback() : fallback;\\n\\n    if (x === undefined) {\\n      return f;\\n    }\\n\\n    if (!options.strict && isPlainObject(x) && isPlainObject(f)) {\\n      const ret = { ...x\\n      };\\n      let changed = false;\\n\\n      for (const key in f) {\\n        if (ret[key] === undefined) {\\n          ret[key] = f[key];\\n          changed = true;\\n        }\\n      }\\n\\n      if (changed) {\\n        return ret;\\n      }\\n    }\\n\\n    return x;\\n  });\\n}\\n/**\\n * Augment a struct to trim string inputs.\\n *\\n * Note: You must use `create(value, Struct)` on the value to have the coercion\\n * take effect! Using simply `assert()` or `is()` will not use coercion.\\n */\\n\\nfunction trimmed(struct) {\\n  return coerce(struct, string(), x => x.trim());\\n}\\n\\n/**\\n * Ensure that a string, array, map, or set is empty.\\n */\\n\\nfunction empty(struct) {\\n  const expected = \\\"Expected an empty \\\" + struct.type;\\n  return refine(struct, 'empty', value => {\\n    if (value instanceof Map || value instanceof Set) {\\n      const {\\n        size\\n      } = value;\\n      return size === 0 || expected + \\\" but received one with a size of `\\\" + size + \\\"`\\\";\\n    } else {\\n      const {\\n        length\\n      } = value;\\n      return length === 0 || expected + \\\" but received one with a length of `\\\" + length + \\\"`\\\";\\n    }\\n  });\\n}\\n/**\\n * Ensure that a number or date is below a threshold.\\n */\\n\\nfunction max(struct, threshold, options = {}) {\\n  const {\\n    exclusive\\n  } = options;\\n  return refine(struct, 'max', value => {\\n    return exclusive ? value < threshold : value <= threshold || \\\"Expected a \\\" + struct.type + \\\" greater than \\\" + (exclusive ? '' : 'or equal to ') + threshold + \\\" but received `\\\" + value + \\\"`\\\";\\n  });\\n}\\n/**\\n * Ensure that a number or date is above a threshold.\\n */\\n\\nfunction min(struct, threshold, options = {}) {\\n  const {\\n    exclusive\\n  } = options;\\n  return refine(struct, 'min', value => {\\n    return exclusive ? value > threshold : value >= threshold || \\\"Expected a \\\" + struct.type + \\\" greater than \\\" + (exclusive ? '' : 'or equal to ') + threshold + \\\" but received `\\\" + value + \\\"`\\\";\\n  });\\n}\\n/**\\n * Ensure that a string matches a regular expression.\\n */\\n\\nfunction pattern(struct, regexp) {\\n  return refine(struct, 'pattern', value => {\\n    return regexp.test(value) || \\\"Expected a \\\" + struct.type + \\\" matching `/\\\" + regexp.source + \\\"/` but received \\\\\\\"\\\" + value + \\\"\\\\\\\"\\\";\\n  });\\n}\\n/**\\n * Ensure that a string, array, number, date, map, or set has a size (or length, or time) between `min` and `max`.\\n */\\n\\nfunction size(struct, min, max = min) {\\n  const expected = \\\"Expected a \\\" + struct.type;\\n  const of = min === max ? \\\"of `\\\" + min + \\\"`\\\" : \\\"between `\\\" + min + \\\"` and `\\\" + max + \\\"`\\\";\\n  return refine(struct, 'size', value => {\\n    if (typeof value === 'number' || value instanceof Date) {\\n      return min <= value && value <= max || expected + \\\" \\\" + of + \\\" but received `\\\" + value + \\\"`\\\";\\n    } else if (value instanceof Map || value instanceof Set) {\\n      const {\\n        size\\n      } = value;\\n      return min <= size && size <= max || expected + \\\" with a size \\\" + of + \\\" but received one with a size of `\\\" + size + \\\"`\\\";\\n    } else {\\n      const {\\n        length\\n      } = value;\\n      return min <= length && length <= max || expected + \\\" with a length \\\" + of + \\\" but received one with a length of `\\\" + length + \\\"`\\\";\\n    }\\n  });\\n}\\n/**\\n * Augment a `Struct` to add an additional refinement to the validation.\\n *\\n * The refiner function is guaranteed to receive a value of the struct's type,\\n * because the struct's existing validation will already have passed. This\\n * allows you to layer additional validation on top of existing structs.\\n */\\n\\nfunction refine(struct, name, refiner) {\\n  return new Struct({ ...struct,\\n\\n    *refiner(value, ctx) {\\n      yield* struct.refiner(value, ctx);\\n      const result = refiner(value, ctx);\\n      const failures = toFailures(result, ctx, struct, value);\\n\\n      for (const failure of failures) {\\n        yield { ...failure,\\n          refinement: name\\n        };\\n      }\\n    }\\n\\n  });\\n}\\n\\n\\n//# sourceMappingURL=index.es.js.map\\n\\n\\n//# sourceURL=webpack://solana-flash-loan-sdk/./node_modules/superstruct/lib/index.es.js?\");\n\n/***/ })\n\n/******/ \t});\n/************************************************************************/\n/******/ \t// The module cache\n/******/ \tvar __webpack_module_cache__ = {};\n/******/ \t\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/ \t\t// Check if module is in cache\n/******/ \t\tvar cachedModule = __webpack_module_cache__[moduleId];\n/******/ \t\tif (cachedModule !== undefined) {\n/******/ \t\t\treturn cachedModule.exports;\n/******/ \t\t}\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = __webpack_module_cache__[moduleId] = {\n/******/ \t\t\tid: moduleId,\n/******/ \t\t\tloaded: false,\n/******/ \t\t\texports: {}\n/******/ \t\t};\n/******/ \t\n/******/ \t\t// Execute the module function\n/******/ \t\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/ \t\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.loaded = true;\n/******/ \t\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/ \t\n/************************************************************************/\n/******/ \t/* webpack/runtime/compat get default export */\n/******/ \t(() => {\n/******/ \t\t// getDefaultExport function for compatibility with non-harmony modules\n/******/ \t\t__webpack_require__.n = (module) => {\n/******/ \t\t\tvar getter = module && module.__esModule ?\n/******/ \t\t\t\t() => (module['default']) :\n/******/ \t\t\t\t() => (module);\n/******/ \t\t\t__webpack_require__.d(getter, { a: getter });\n/******/ \t\t\treturn getter;\n/******/ \t\t};\n/******/ \t})();\n/******/ \t\n/******/ \t/* webpack/runtime/create fake namespace object */\n/******/ \t(() => {\n/******/ \t\tvar getProto = Object.getPrototypeOf ? (obj) => (Object.getPrototypeOf(obj)) : (obj) => (obj.__proto__);\n/******/ \t\tvar leafPrototypes;\n/******/ \t\t// create a fake namespace object\n/******/ \t\t// mode & 1: value is a module id, require it\n/******/ \t\t// mode & 2: merge all properties of value into the ns\n/******/ \t\t// mode & 4: return value when already ns object\n/******/ \t\t// mode & 16: return value when it's Promise-like\n/******/ \t\t// mode & 8|1: behave like require\n/******/ \t\t__webpack_require__.t = function(value, mode) {\n/******/ \t\t\tif(mode & 1) value = this(value);\n/******/ \t\t\tif(mode & 8) return value;\n/******/ \t\t\tif(typeof value === 'object' && value) {\n/******/ \t\t\t\tif((mode & 4) && value.__esModule) return value;\n/******/ \t\t\t\tif((mode & 16) && typeof value.then === 'function') return value;\n/******/ \t\t\t}\n/******/ \t\t\tvar ns = Object.create(null);\n/******/ \t\t\t__webpack_require__.r(ns);\n/******/ \t\t\tvar def = {};\n/******/ \t\t\tleafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];\n/******/ \t\t\tfor(var current = mode & 2 && value; typeof current == 'object' && !~leafPrototypes.indexOf(current); current = getProto(current)) {\n/******/ \t\t\t\tObject.getOwnPropertyNames(current).forEach((key) => (def[key] = () => (value[key])));\n/******/ \t\t\t}\n/******/ \t\t\tdef['default'] = () => (value);\n/******/ \t\t\t__webpack_require__.d(ns, def);\n/******/ \t\t\treturn ns;\n/******/ \t\t};\n/******/ \t})();\n/******/ \t\n/******/ \t/* webpack/runtime/define property getters */\n/******/ \t(() => {\n/******/ \t\t// define getter functions for harmony exports\n/******/ \t\t__webpack_require__.d = (exports, definition) => {\n/******/ \t\t\tfor(var key in definition) {\n/******/ \t\t\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n/******/ \t\t\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n/******/ \t\t\t\t}\n/******/ \t\t\t}\n/******/ \t\t};\n/******/ \t})();\n/******/ \t\n/******/ \t/* webpack/runtime/hasOwnProperty shorthand */\n/******/ \t(() => {\n/******/ \t\t__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))\n/******/ \t})();\n/******/ \t\n/******/ \t/* webpack/runtime/make namespace object */\n/******/ \t(() => {\n/******/ \t\t// define __esModule on exports\n/******/ \t\t__webpack_require__.r = (exports) => {\n/******/ \t\t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n/******/ \t\t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n/******/ \t\t\t}\n/******/ \t\t\tObject.defineProperty(exports, '__esModule', { value: true });\n/******/ \t\t};\n/******/ \t})();\n/******/ \t\n/******/ \t/* webpack/runtime/node module decorator */\n/******/ \t(() => {\n/******/ \t\t__webpack_require__.nmd = (module) => {\n/******/ \t\t\tmodule.paths = [];\n/******/ \t\t\tif (!module.children) module.children = [];\n/******/ \t\t\treturn module;\n/******/ \t\t};\n/******/ \t})();\n/******/ \t\n/************************************************************************/\n/******/ \t\n/******/ \t// startup\n/******/ \t// Load entry module and return exports\n/******/ \t// This entry module can't be inlined because the eval devtool is used.\n/******/ \tvar __webpack_exports__ = __webpack_require__(\"./src/index.ts\");\n/******/ \t\n/******/ \treturn __webpack_exports__;\n/******/ })()\n;\n});"]}