@pooflabs/web 0.0.83-rc2 → 0.0.84

package/dist/{index-p1LvAs78.esm.js → index-XHbmzFFO.esm.js}

@@ -9259,15 +9259,15 @@ function requireBuffer$1 () {
 
 var bufferExports$1 = requireBuffer$1();
 
-var safeBuffer = {exports: {}};
+var safeBuffer$1 = {exports: {}};
 
 /*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
 
-var hasRequiredSafeBuffer;
+var hasRequiredSafeBuffer$1;
 
-function requireSafeBuffer () {
-	if (hasRequiredSafeBuffer) return safeBuffer.exports;
-	hasRequiredSafeBuffer = 1;
+function requireSafeBuffer$1 () {
+	if (hasRequiredSafeBuffer$1) return safeBuffer$1.exports;
+	hasRequiredSafeBuffer$1 = 1;
 	(function (module, exports$1) {
 		/* eslint-disable node/no-deprecated-api */
 		var buffer = requireBuffer$1();
@@ -9333,23 +9333,23 @@ function requireSafeBuffer () {
 		  }
 		  return buffer.SlowBuffer(size)
 		}; 
-	} (safeBuffer, safeBuffer.exports));
-	return safeBuffer.exports;
+	} (safeBuffer$1, safeBuffer$1.exports));
+	return safeBuffer$1.exports;
 }
 
-var src;
-var hasRequiredSrc;
+var src$1;
+var hasRequiredSrc$1;
 
-function requireSrc () {
-	if (hasRequiredSrc) return src;
-	hasRequiredSrc = 1;
+function requireSrc$1 () {
+	if (hasRequiredSrc$1) return src$1;
+	hasRequiredSrc$1 = 1;
 	// base-x encoding / decoding
 	// Copyright (c) 2018 base-x contributors
 	// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)
 	// Distributed under the MIT software license, see the accompanying
 	// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
 	// @ts-ignore
-	var _Buffer = requireSafeBuffer().Buffer;
+	var _Buffer = requireSafeBuffer$1().Buffer;
 	function base (ALPHABET) {
 	  if (ALPHABET.length >= 255) { throw new TypeError('Alphabet too long') }
 	  var BASE_MAP = new Uint8Array(256);
@@ -9464,8 +9464,8 @@ function requireSrc () {
 	    decode: decode
 	  }
 	}
-	src = base;
-	return src;
+	src$1 = base;
+	return src$1;
 }
 
 var bs58$1;
@@ -9474,7 +9474,7 @@ var hasRequiredBs58;
 function requireBs58 () {
 	if (hasRequiredBs58) return bs58$1;
 	hasRequiredBs58 = 1;
-	var basex = requireSrc();
+	var basex = requireSrc$1();
 	var ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
 
 	bs58$1 = basex(ALPHABET);
@@ -9561,6 +9561,12 @@ async function genSolanaMessage(address, nonce) {
 // Serialization Helpers
 // ─────────────────────────────────────────────────────────────
 function isHexString(value) {
+    // Only strings can be hex-encoded. Numbers, BNs, and other shapes coming back
+    // from the API for u64Val/i64Val should fall through to `new BN(value)` which
+    // accepts those shapes natively. Without this guard, calling .startsWith on a
+    // non-string blows up with TypeError.
+    if (typeof value !== "string")
+        return false;
     // Matches strings containing only 0-9, a-f, or A-F (optionally prefixed with 0x)
     let testValue = value;
     // Handle negative values
@@ -9656,8 +9662,11 @@ async function buildSetDocumentsTransaction(connection, idl, anchorProvider, pay
     }
     else if (idl.address === "poof4b5pk1L9tmThvBmaABjcyjfhFGbMbQP5BXk2QZp") {
         const program = new Program(idl, anchorProvider);
+        // Targets `set_documents_v2` (Vec<u8> ra_indices). The on-chain program
+        // also exposes the legacy `set_documents` (Vec<u64>) so SDKs already on npm
+        // continue to work — but new releases of this SDK speak v2 only.
         tx = await program.methods
-            .setDocuments(args.app_id, prepareAnchorArgs(args.documents), args.delete_paths, args.txData, simulate)
+            .setDocumentsV2(args.app_id, prepareAnchorArgs(args.documents), args.delete_paths, args.txData, simulate)
             .preInstructions(instructions)
             .accounts({
             payer: payerPublicKey
@@ -10012,11 +10021,17 @@ async function makeApiRequest(method, urlPath, data, _overrides) {
         if (_overrides === null || _overrides === void 0 ? void 0 : _overrides.headers) {
             Object.assign(headers, _overrides.headers);
         }
+        // Writes (PUT/POST/DELETE) can take significantly longer than reads —
+        // server-side they may trigger ad-hoc LUT creation (create + extend +
+        // wait-for-finalization, ~15-30s on mainnet). Use a larger default for
+        // non-GET so the SDK doesn't time out before client-api responds.
+        const isRead = method.toUpperCase() === "GET";
+        const defaultTimeout = isRead ? 30000 : 90000;
         const requestConfig = {
             method,
             url: `${config.apiUrl}${urlPath.startsWith("/") ? urlPath : `/${urlPath}`}`,
             headers,
-            timeout: (_a = _overrides === null || _overrides === void 0 ? void 0 : _overrides.timeout) !== null && _a !== void 0 ? _a : 30000,
+            timeout: (_a = _overrides === null || _overrides === void 0 ? void 0 : _overrides.timeout) !== null && _a !== void 0 ? _a : defaultTimeout,
         };
         if (method !== "GET" && method !== "get") {
             requestConfig.data = data ? JSON.stringify(data) : {};
@@ -10661,21 +10676,38 @@ async function setMany(many, options) {
             setDocumentData: tx.transactionArgs.setDocumentData,
             deletePaths: tx.transactionArgs.deletePaths,
             idl: tx.idl,
-            txData: (_b = (_a = tx.txData) === null || _a === void 0 ? void 0 : _a.map((txData) => {
-                var _a;
-                return ({
-                    pluginFunctionKey: txData.pluginFunctionKey,
-                    txData: bufferExports$1.Buffer.from(txData.txData),
-                    raIndices: (_a = txData.raIndices) === null || _a === void 0 ? void 0 : _a.map((raIndex) => {
-                        if (isHexString(raIndex)) {
-                            return new BN(raIndex, "hex");
-                        }
-                        else {
-                            return new BN(raIndex);
+            txData: (_b = (_a = tx.txData) === null || _a === void 0 ? void 0 : _a.map((txData) => ({
+                pluginFunctionKey: txData.pluginFunctionKey,
+                txData: bufferExports$1.Buffer.from(txData.txData),
+                // raIndices is Vec<u8> on-chain (serialized as Buffer/bytes). The server may send
+                // it as a Buffer, a number[], a Uint8Array, or — over JSON — as Node's serialized
+                // Buffer shape {type: "Buffer", data: number[]} (the default `JSON.stringify(buf)`
+                // output). Normalise all of those to Buffer here. Each value must fit in u8 (matches
+                // Solana's instruction-level account indexing); throw clearly if anything is out of range.
+                raIndices: (() => {
+                    const raw = txData.raIndices;
+                    if (raw == null)
+                        return bufferExports$1.Buffer.alloc(0);
+                    if (bufferExports$1.Buffer.isBuffer(raw))
+                        return raw;
+                    if (raw instanceof Uint8Array)
+                        return bufferExports$1.Buffer.from(raw);
+                    // Node's JSON-serialised Buffer: {type: "Buffer", data: number[]}
+                    const arrayLike = Array.isArray(raw)
+                        ? raw
+                        : (raw && typeof raw === 'object' && Array.isArray(raw.data))
+                            ? raw.data
+                            : (() => { throw new Error(`raIndices has unexpected shape: ${typeof raw}`); })();
+                    const bytes = arrayLike.map((raIndex) => {
+                        const n = isHexString(raIndex) ? parseInt(raIndex, 16) : Number(raIndex);
+                        if (!Number.isInteger(n) || n < 0 || n > 255) {
+                            throw new Error(`raIndex ${raIndex} is not a valid u8 (must be integer in 0..255)`);
                         }
-                    }),
-                });
-            })) !== null && _b !== void 0 ? _b : [],
+                        return n;
+                    });
+                    return bufferExports$1.Buffer.from(bytes);
+                })(),
+            }))) !== null && _b !== void 0 ? _b : [],
         };
         const config = await getConfig();
         const solTransaction = {
@@ -15677,7 +15709,7 @@ async function loadDependencies() {
         const [reactModule, reactDomModule, phantomModule] = await Promise.all([
             import('react'),
             import('react-dom/client'),
-            import('./index-dyXVIGCy.esm.js')
+            import('./index-CH2G5Y9i.esm.js')
         ]);
         // Extract default export from ESM module namespace
         // Dynamic import() returns { default: Module, ...exports }, not the module directly
@@ -20126,132 +20158,220 @@ function createSolanaRpcSubscriptionsFromTransport(transport) {
   });
 }
 
-// base-x encoding / decoding
-// Copyright (c) 2018 base-x contributors
-// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)
-// Distributed under the MIT software license, see the accompanying
-// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
-function base (ALPHABET) {
-  if (ALPHABET.length >= 255) { throw new TypeError('Alphabet too long') }
-  const BASE_MAP = new Uint8Array(256);
-  for (let j = 0; j < BASE_MAP.length; j++) {
-    BASE_MAP[j] = 255;
-  }
-  for (let i = 0; i < ALPHABET.length; i++) {
-    const x = ALPHABET.charAt(i);
-    const xc = x.charCodeAt(0);
-    if (BASE_MAP[xc] !== 255) { throw new TypeError(x + ' is ambiguous') }
-    BASE_MAP[xc] = i;
-  }
-  const BASE = ALPHABET.length;
-  const LEADER = ALPHABET.charAt(0);
-  const FACTOR = Math.log(BASE) / Math.log(256); // log(BASE) / log(256), rounded up
-  const iFACTOR = Math.log(256) / Math.log(BASE); // log(256) / log(BASE), rounded up
-  function encode (source) {
-    // eslint-disable-next-line no-empty
-    if (source instanceof Uint8Array) ; else if (ArrayBuffer.isView(source)) {
-      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
-    } else if (Array.isArray(source)) {
-      source = Uint8Array.from(source);
-    }
-    if (!(source instanceof Uint8Array)) { throw new TypeError('Expected Uint8Array') }
-    if (source.length === 0) { return '' }
-    // Skip & count leading zeroes.
-    let zeroes = 0;
-    let length = 0;
-    let pbegin = 0;
-    const pend = source.length;
-    while (pbegin !== pend && source[pbegin] === 0) {
-      pbegin++;
-      zeroes++;
-    }
-    // Allocate enough space in big-endian base58 representation.
-    const size = ((pend - pbegin) * iFACTOR + 1) >>> 0;
-    const b58 = new Uint8Array(size);
-    // Process the bytes.
-    while (pbegin !== pend) {
-      let carry = source[pbegin];
-      // Apply "b58 = b58 * 256 + ch".
-      let i = 0;
-      for (let it1 = size - 1; (carry !== 0 || i < length) && (it1 !== -1); it1--, i++) {
-        carry += (256 * b58[it1]) >>> 0;
-        b58[it1] = (carry % BASE) >>> 0;
-        carry = (carry / BASE) >>> 0;
-      }
-      if (carry !== 0) { throw new Error('Non-zero carry') }
-      length = i;
-      pbegin++;
-    }
-    // Skip leading zeroes in base58 result.
-    let it2 = size - length;
-    while (it2 !== size && b58[it2] === 0) {
-      it2++;
-    }
-    // Translate the result into a string.
-    let str = LEADER.repeat(zeroes);
-    for (; it2 < size; ++it2) { str += ALPHABET.charAt(b58[it2]); }
-    return str
-  }
-  function decodeUnsafe (source) {
-    if (typeof source !== 'string') { throw new TypeError('Expected String') }
-    if (source.length === 0) { return new Uint8Array() }
-    let psz = 0;
-    // Skip and count leading '1's.
-    let zeroes = 0;
-    let length = 0;
-    while (source[psz] === LEADER) {
-      zeroes++;
-      psz++;
-    }
-    // Allocate enough space in big-endian base256 representation.
-    const size = (((source.length - psz) * FACTOR) + 1) >>> 0; // log(58) / log(256), rounded up.
-    const b256 = new Uint8Array(size);
-    // Process the characters.
-    while (psz < source.length) {
-      // Find code of next character
-      const charCode = source.charCodeAt(psz);
-      // Base map can not be indexed using char code
-      if (charCode > 255) { return }
-      // Decode character
-      let carry = BASE_MAP[charCode];
-      // Invalid character
-      if (carry === 255) { return }
-      let i = 0;
-      for (let it3 = size - 1; (carry !== 0 || i < length) && (it3 !== -1); it3--, i++) {
-        carry += (BASE * b256[it3]) >>> 0;
-        b256[it3] = (carry % 256) >>> 0;
-        carry = (carry / 256) >>> 0;
-      }
-      if (carry !== 0) { throw new Error('Non-zero carry') }
-      length = i;
-      psz++;
-    }
-    // Skip leading zeroes in b256.
-    let it4 = size - length;
-    while (it4 !== size && b256[it4] === 0) {
-      it4++;
-    }
-    const vch = new Uint8Array(zeroes + (size - it4));
-    let j = zeroes;
-    while (it4 !== size) {
-      vch[j++] = b256[it4++];
-    }
-    return vch
-  }
-  function decode (string) {
-    const buffer = decodeUnsafe(string);
-    if (buffer) { return buffer }
-    throw new Error('Non-base' + BASE + ' character')
-  }
-  return {
-    encode,
-    decodeUnsafe,
-    decode
-  }
+var safeBuffer = {exports: {}};
+
+/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
+
+var hasRequiredSafeBuffer;
+
+function requireSafeBuffer () {
+	if (hasRequiredSafeBuffer) return safeBuffer.exports;
+	hasRequiredSafeBuffer = 1;
+	(function (module, exports$1) {
+		/* eslint-disable node/no-deprecated-api */
+		var buffer = requireBuffer();
+		var Buffer = buffer.Buffer;
+
+		// alternative to using Object.keys for old browsers
+		function copyProps (src, dst) {
+		  for (var key in src) {
+		    dst[key] = src[key];
+		  }
+		}
+		if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
+		  module.exports = buffer;
+		} else {
+		  // Copy properties from require('buffer')
+		  copyProps(buffer, exports$1);
+		  exports$1.Buffer = SafeBuffer;
+		}
+
+		function SafeBuffer (arg, encodingOrOffset, length) {
+		  return Buffer(arg, encodingOrOffset, length)
+		}
+
+		SafeBuffer.prototype = Object.create(Buffer.prototype);
+
+		// Copy static methods from Buffer
+		copyProps(Buffer, SafeBuffer);
+
+		SafeBuffer.from = function (arg, encodingOrOffset, length) {
+		  if (typeof arg === 'number') {
+		    throw new TypeError('Argument must not be a number')
+		  }
+		  return Buffer(arg, encodingOrOffset, length)
+		};
+
+		SafeBuffer.alloc = function (size, fill, encoding) {
+		  if (typeof size !== 'number') {
+		    throw new TypeError('Argument must be a number')
+		  }
+		  var buf = Buffer(size);
+		  if (fill !== undefined) {
+		    if (typeof encoding === 'string') {
+		      buf.fill(fill, encoding);
+		    } else {
+		      buf.fill(fill);
+		    }
+		  } else {
+		    buf.fill(0);
+		  }
+		  return buf
+		};
+
+		SafeBuffer.allocUnsafe = function (size) {
+		  if (typeof size !== 'number') {
+		    throw new TypeError('Argument must be a number')
+		  }
+		  return Buffer(size)
+		};
+
+		SafeBuffer.allocUnsafeSlow = function (size) {
+		  if (typeof size !== 'number') {
+		    throw new TypeError('Argument must be a number')
+		  }
+		  return buffer.SlowBuffer(size)
+		}; 
+	} (safeBuffer, safeBuffer.exports));
+	return safeBuffer.exports;
+}
+
+var src;
+var hasRequiredSrc;
+
+function requireSrc () {
+	if (hasRequiredSrc) return src;
+	hasRequiredSrc = 1;
+	// base-x encoding / decoding
+	// Copyright (c) 2018 base-x contributors
+	// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)
+	// Distributed under the MIT software license, see the accompanying
+	// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+	// @ts-ignore
+	var _Buffer = requireSafeBuffer().Buffer;
+	function base (ALPHABET) {
+	  if (ALPHABET.length >= 255) { throw new TypeError('Alphabet too long') }
+	  var BASE_MAP = new Uint8Array(256);
+	  for (var j = 0; j < BASE_MAP.length; j++) {
+	    BASE_MAP[j] = 255;
+	  }
+	  for (var i = 0; i < ALPHABET.length; i++) {
+	    var x = ALPHABET.charAt(i);
+	    var xc = x.charCodeAt(0);
+	    if (BASE_MAP[xc] !== 255) { throw new TypeError(x + ' is ambiguous') }
+	    BASE_MAP[xc] = i;
+	  }
+	  var BASE = ALPHABET.length;
+	  var LEADER = ALPHABET.charAt(0);
+	  var FACTOR = Math.log(BASE) / Math.log(256); // log(BASE) / log(256), rounded up
+	  var iFACTOR = Math.log(256) / Math.log(BASE); // log(256) / log(BASE), rounded up
+	  function encode (source) {
+	    if (Array.isArray(source) || source instanceof Uint8Array) { source = _Buffer.from(source); }
+	    if (!_Buffer.isBuffer(source)) { throw new TypeError('Expected Buffer') }
+	    if (source.length === 0) { return '' }
+	        // Skip & count leading zeroes.
+	    var zeroes = 0;
+	    var length = 0;
+	    var pbegin = 0;
+	    var pend = source.length;
+	    while (pbegin !== pend && source[pbegin] === 0) {
+	      pbegin++;
+	      zeroes++;
+	    }
+	        // Allocate enough space in big-endian base58 representation.
+	    var size = ((pend - pbegin) * iFACTOR + 1) >>> 0;
+	    var b58 = new Uint8Array(size);
+	        // Process the bytes.
+	    while (pbegin !== pend) {
+	      var carry = source[pbegin];
+	            // Apply "b58 = b58 * 256 + ch".
+	      var i = 0;
+	      for (var it1 = size - 1; (carry !== 0 || i < length) && (it1 !== -1); it1--, i++) {
+	        carry += (256 * b58[it1]) >>> 0;
+	        b58[it1] = (carry % BASE) >>> 0;
+	        carry = (carry / BASE) >>> 0;
+	      }
+	      if (carry !== 0) { throw new Error('Non-zero carry') }
+	      length = i;
+	      pbegin++;
+	    }
+	        // Skip leading zeroes in base58 result.
+	    var it2 = size - length;
+	    while (it2 !== size && b58[it2] === 0) {
+	      it2++;
+	    }
+	        // Translate the result into a string.
+	    var str = LEADER.repeat(zeroes);
+	    for (; it2 < size; ++it2) { str += ALPHABET.charAt(b58[it2]); }
+	    return str
+	  }
+	  function decodeUnsafe (source) {
+	    if (typeof source !== 'string') { throw new TypeError('Expected String') }
+	    if (source.length === 0) { return _Buffer.alloc(0) }
+	    var psz = 0;
+	        // Skip and count leading '1's.
+	    var zeroes = 0;
+	    var length = 0;
+	    while (source[psz] === LEADER) {
+	      zeroes++;
+	      psz++;
+	    }
+	        // Allocate enough space in big-endian base256 representation.
+	    var size = (((source.length - psz) * FACTOR) + 1) >>> 0; // log(58) / log(256), rounded up.
+	    var b256 = new Uint8Array(size);
+	        // Process the characters.
+	    while (psz < source.length) {
+	            // Find code of next character
+	      var charCode = source.charCodeAt(psz);
+	            // Base map can not be indexed using char code
+	      if (charCode > 255) { return }
+	            // Decode character
+	      var carry = BASE_MAP[charCode];
+	            // Invalid character
+	      if (carry === 255) { return }
+	      var i = 0;
+	      for (var it3 = size - 1; (carry !== 0 || i < length) && (it3 !== -1); it3--, i++) {
+	        carry += (BASE * b256[it3]) >>> 0;
+	        b256[it3] = (carry % 256) >>> 0;
+	        carry = (carry / 256) >>> 0;
+	      }
+	      if (carry !== 0) { throw new Error('Non-zero carry') }
+	      length = i;
+	      psz++;
+	    }
+	        // Skip leading zeroes in b256.
+	    var it4 = size - length;
+	    while (it4 !== size && b256[it4] === 0) {
+	      it4++;
+	    }
+	    var vch = _Buffer.allocUnsafe(zeroes + (size - it4));
+	    vch.fill(0x00, 0, zeroes);
+	    var j = zeroes;
+	    while (it4 !== size) {
+	      vch[j++] = b256[it4++];
+	    }
+	    return vch
+	  }
+	  function decode (string) {
+	    var buffer = decodeUnsafe(string);
+	    if (buffer) { return buffer }
+	    throw new Error('Non-base' + BASE + ' character')
+	  }
+	  return {
+	    encode: encode,
+	    decodeUnsafe: decodeUnsafe,
+	    decode: decode
+	  }
+	}
+	src = base;
+	return src;
 }
 
+var srcExports = requireSrc();
+var basex = /*@__PURE__*/getDefaultExportFromCjs$1(srcExports);
+
 var ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
-var base58 = base(ALPHABET);
+var base58 = basex(ALPHABET);
 
 var index = /*#__PURE__*/Object.freeze({
 	__proto__: null,
@@ -21170,7 +21290,7 @@ async function loadMwaProtocol() {
         return mwaProtocolLoadPromise;
     mwaProtocolLoadPromise = (async () => {
         try {
-            mwaProtocolModule = await import('./index.browser-CbVXUCv0.esm.js');
+            mwaProtocolModule = await import('./index.browser-D8VWPXTZ.esm.js');
         }
         catch (e) {
             console.warn('[SolanaMobileWallet] @solana-mobile/mobile-wallet-adapter-protocol-web3js not installed. Install it to enable Seeker wallet support.');
@@ -21192,7 +21312,7 @@ async function registerMobileWalletAdapter(config) {
     if (typeof window === 'undefined')
         return;
     try {
-        const walletStandardMobile = await import('./index.browser-Dekybe_E.esm.js');
+        const walletStandardMobile = await import('./index.browser-Cgj7Hs6n.esm.js');
         const registerMwa = walletStandardMobile.registerMwa || ((_a = walletStandardMobile.default) === null || _a === void 0 ? void 0 : _a.registerMwa);
         if (!registerMwa) {
             console.warn('[SolanaMobileWallet] registerMwa not found in @solana-mobile/wallet-standard-mobile');
@@ -22130,4 +22250,4 @@ class PrivyExpoProvider {
 }
 
 export { getCachedData as $, subscribe as A, useAuth as B, deserializeTransaction as C, getIdToken as D, setPlatform as E, getPlatform as F, PrivyWalletProvider as G, DEFAULT_TEST_ADDRESS as H, isMobileWalletAvailable as I, registerMobileWalletAdapter as J, PrivyExpoProvider as K, InsufficientBalanceError as L, MockAuthProvider as M, ServerSessionManager as N, OffchainAuthProvider as O, PhantomWalletProvider as P, buildSetDocumentsTransaction as Q, ReactNativeSessionManager as R, SolanaMobileWalletProvider as S, clearCache as T, closeAllSubscriptions as U, convertRemainingAccounts as V, WebSessionManager as W, createSessionWithPrivy as X, createSessionWithSignature as Y, genAuthNonce as Z, genSolanaMessage as _, base58 as a, getMany as a0, reconnectWithNewAuth as a1, refreshSession as a2, signSessionCreateMessage as a3, bufferExports as b, getCurrentUser as c, onAuthLoadingChanged as d, getAuthLoading as e, logout as f, getDefaultExportFromCjs$1 as g, getConfig as h, init as i, getAuthProvider as j, get as k, login as l, setMany as m, setFile as n, onAuthStateChanged as o, getFiles as p, runQueryMany as q, runQuery as r, set as s, runExpression as t, runExpressionMany as u, signMessage as v, signTransaction as w, signAndSubmitTransaction as x, count as y, aggregate as z };
-//# sourceMappingURL=index-p1LvAs78.esm.js.map
+//# sourceMappingURL=index-XHbmzFFO.esm.js.map