@leofcoin/chain 1.5.65 → 1.5.67

package/exports/browser/{_polyfill-node.url-1q06MepH.js → _polyfill-node.url-Bp9XkJZf.js}

@@ -1,4 +1,4 @@
-import { g as global } from './_polyfill-node.child_process-rc1HO9Xs.js';
+import { g as global } from './_polyfill-node.child_process-BsjYmFff.js';
 
 /*! https://mths.be/punycode v1.4.1 by @mathias */
 

package/exports/browser/{browser-1GyRaZxg-C9SpI6hG.js → browser-Ei0BXMlu-C1_XUL9Y.js}

@@ -1,5 +1,5 @@
-import { g as getDefaultExportFromCjs } from './node-browser-0Ly80awM.js';
-import './_polyfill-node.child_process-rc1HO9Xs.js';
+import { g as getDefaultExportFromCjs } from './node-browser-DqIklEKv.js';
+import './_polyfill-node.child_process-BsjYmFff.js';
 
 var global;
 var hasRequiredGlobal;

package/exports/browser/browser-store.js

@@ -70,310 +70,61 @@ class KeyValue {
     }
 }
 
-const instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);
-
-let idbProxyableTypes;
-let cursorAdvanceMethods;
-// This is a function to prevent it throwing up in node environments.
-function getIdbProxyableTypes() {
-    return (idbProxyableTypes ||
-        (idbProxyableTypes = [
-            IDBDatabase,
-            IDBObjectStore,
-            IDBIndex,
-            IDBCursor,
-            IDBTransaction,
-        ]));
-}
-// This is a function to prevent it throwing up in node environments.
-function getCursorAdvanceMethods() {
-    return (cursorAdvanceMethods ||
-        (cursorAdvanceMethods = [
-            IDBCursor.prototype.advance,
-            IDBCursor.prototype.continue,
-            IDBCursor.prototype.continuePrimaryKey,
-        ]));
-}
-const transactionDoneMap = new WeakMap();
-const transformCache = new WeakMap();
-const reverseTransformCache = new WeakMap();
-function promisifyRequest(request) {
-    const promise = new Promise((resolve, reject) => {
-        const unlisten = () => {
-            request.removeEventListener('success', success);
-            request.removeEventListener('error', error);
-        };
-        const success = () => {
-            resolve(wrap(request.result));
-            unlisten();
-        };
-        const error = () => {
-            reject(request.error);
-            unlisten();
-        };
-        request.addEventListener('success', success);
-        request.addEventListener('error', error);
-    });
-    // This mapping exists in reverseTransformCache but doesn't doesn't exist in transformCache. This
-    // is because we create many promises from a single IDBRequest.
-    reverseTransformCache.set(promise, request);
-    return promise;
-}
-function cacheDonePromiseForTransaction(tx) {
-    // Early bail if we've already created a done promise for this transaction.
-    if (transactionDoneMap.has(tx))
-        return;
-    const done = new Promise((resolve, reject) => {
-        const unlisten = () => {
-            tx.removeEventListener('complete', complete);
-            tx.removeEventListener('error', error);
-            tx.removeEventListener('abort', error);
-        };
-        const complete = () => {
-            resolve();
-            unlisten();
-        };
-        const error = () => {
-            reject(tx.error || new DOMException('AbortError', 'AbortError'));
-            unlisten();
-        };
-        tx.addEventListener('complete', complete);
-        tx.addEventListener('error', error);
-        tx.addEventListener('abort', error);
-    });
-    // Cache it for later retrieval.
-    transactionDoneMap.set(tx, done);
-}
-let idbProxyTraps = {
-    get(target, prop, receiver) {
-        if (target instanceof IDBTransaction) {
-            // Special handling for transaction.done.
-            if (prop === 'done')
-                return transactionDoneMap.get(target);
-            // Make tx.store return the only store in the transaction, or undefined if there are many.
-            if (prop === 'store') {
-                return receiver.objectStoreNames[1]
-                    ? undefined
-                    : receiver.objectStore(receiver.objectStoreNames[0]);
-            }
-        }
-        // Else transform whatever we get back.
-        return wrap(target[prop]);
-    },
-    set(target, prop, value) {
-        target[prop] = value;
-        return true;
-    },
-    has(target, prop) {
-        if (target instanceof IDBTransaction &&
-            (prop === 'done' || prop === 'store')) {
-            return true;
-        }
-        return prop in target;
-    },
-};
-function replaceTraps(callback) {
-    idbProxyTraps = callback(idbProxyTraps);
-}
-function wrapFunction(func) {
-    // Due to expected object equality (which is enforced by the caching in `wrap`), we
-    // only create one new func per func.
-    // Cursor methods are special, as the behaviour is a little more different to standard IDB. In
-    // IDB, you advance the cursor and wait for a new 'success' on the IDBRequest that gave you the
-    // cursor. It's kinda like a promise that can resolve with many values. That doesn't make sense
-    // with real promises, so each advance methods returns a new promise for the cursor object, or
-    // undefined if the end of the cursor has been reached.
-    if (getCursorAdvanceMethods().includes(func)) {
-        return function (...args) {
-            // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
-            // the original object.
-            func.apply(unwrap(this), args);
-            return wrap(this.request);
-        };
-    }
-    return function (...args) {
-        // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
-        // the original object.
-        return wrap(func.apply(unwrap(this), args));
-    };
-}
-function transformCachableValue(value) {
-    if (typeof value === 'function')
-        return wrapFunction(value);
-    // This doesn't return, it just creates a 'done' promise for the transaction,
-    // which is later returned for transaction.done (see idbObjectHandler).
-    if (value instanceof IDBTransaction)
-        cacheDonePromiseForTransaction(value);
-    if (instanceOfAny(value, getIdbProxyableTypes()))
-        return new Proxy(value, idbProxyTraps);
-    // Return the same value back if we're not going to transform it.
-    return value;
-}
-function wrap(value) {
-    // We sometimes generate multiple promises from a single IDBRequest (eg when cursoring), because
-    // IDB is weird and a single IDBRequest can yield many responses, so these can't be cached.
-    if (value instanceof IDBRequest)
-        return promisifyRequest(value);
-    // If we've already transformed this value before, reuse the transformed value.
-    // This is faster, but it also provides object equality.
-    if (transformCache.has(value))
-        return transformCache.get(value);
-    const newValue = transformCachableValue(value);
-    // Not all types are transformed.
-    // These may be primitive types, so they can't be WeakMap keys.
-    if (newValue !== value) {
-        transformCache.set(value, newValue);
-        reverseTransformCache.set(newValue, value);
-    }
-    return newValue;
-}
-const unwrap = (value) => reverseTransformCache.get(value);
-
-/**
- * Open a database.
- *
- * @param name Name of the database.
- * @param version Schema version.
- * @param callbacks Additional callbacks.
- */
-function openDB(name, version, { blocked, upgrade, blocking, terminated } = {}) {
-    const request = indexedDB.open(name, version);
-    const openPromise = wrap(request);
-    if (upgrade) {
-        request.addEventListener('upgradeneeded', (event) => {
-            upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction), event);
-        });
-    }
-    if (blocked) {
-        request.addEventListener('blocked', (event) => blocked(
-        // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
-        event.oldVersion, event.newVersion, event));
-    }
-    openPromise
-        .then((db) => {
-        if (terminated)
-            db.addEventListener('close', () => terminated());
-        if (blocking) {
-            db.addEventListener('versionchange', (event) => blocking(event.oldVersion, event.newVersion, event));
-        }
-    })
-        .catch(() => { });
-    return openPromise;
-}
-
-const readMethods = ['get', 'getKey', 'getAll', 'getAllKeys', 'count'];
-const writeMethods = ['put', 'add', 'delete', 'clear'];
-const cachedMethods = new Map();
-function getMethod(target, prop) {
-    if (!(target instanceof IDBDatabase &&
-        !(prop in target) &&
-        typeof prop === 'string')) {
-        return;
-    }
-    if (cachedMethods.get(prop))
-        return cachedMethods.get(prop);
-    const targetFuncName = prop.replace(/FromIndex$/, '');
-    const useIndex = prop !== targetFuncName;
-    const isWrite = writeMethods.includes(targetFuncName);
-    if (
-    // Bail if the target doesn't exist on the target. Eg, getAll isn't in Edge.
-    !(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) ||
-        !(isWrite || readMethods.includes(targetFuncName))) {
-        return;
-    }
-    const method = async function (storeName, ...args) {
-        // isWrite ? 'readwrite' : undefined gzipps better, but fails in Edge :(
-        const tx = this.transaction(storeName, isWrite ? 'readwrite' : 'readonly');
-        let target = tx.store;
-        if (useIndex)
-            target = target.index(args.shift());
-        // Must reject if op rejects.
-        // If it's a write operation, must reject if tx.done rejects.
-        // Must reject with op rejection first.
-        // Must resolve with op value.
-        // Must handle both promises (no unhandled rejections)
-        return (await Promise.all([
-            target[targetFuncName](...args),
-            isWrite && tx.done,
-        ]))[0];
-    };
-    cachedMethods.set(prop, method);
-    return method;
+if (!globalThis.DEBUG) {
+  let DEBUG = [];
+  if (globalThis.localStorage) {
+    DEBUG = globalThis.localStorage.getItem('DEBUG');
+    globalThis.DEBUG = DEBUG ? DEBUG.split(',') : [DEBUG];
+  }
+}
+
+const debug$1 = (target, text) => {
+  if (!globalThis.DEBUG && globalThis.DEBUG.length === 0) return;
+  if (
+    globalThis.DEBUG === 'true' ||
+    globalThis.DEBUG === true ||
+    globalThis.DEBUG?.indexOf(target) !== -1 ||
+    globalThis.DEBUG?.indexOf('*') !== -1 ||
+    globalThis.DEBUG?.indexOf(target.split('/')[0]) !== -1
+  )
+    if (text) console.log('\x1b[34m\x1b[1m%s', `${target}: ${text}`, '\x1b[0m');
+    else console.log('\x1b[34m\x1b[1m%s', `${target}`, '\x1b[0m');
+};
+
+if (!globalThis.debug) {
+  globalThis.debug = debug$1;
+
+  globalThis.createDebugger = (target) => (text) => debug$1(target, text);
 }
-replaceTraps((oldTraps) => ({
-    ...oldTraps,
-    get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),
-    has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop),
-}));
-
-const advanceMethodProps = ['continue', 'continuePrimaryKey', 'advance'];
-const methodMap = {};
-const advanceResults = new WeakMap();
-const ittrProxiedCursorToOriginalProxy = new WeakMap();
-const cursorIteratorTraps = {
-    get(target, prop) {
-        if (!advanceMethodProps.includes(prop))
-            return target[prop];
-        let cachedFunc = methodMap[prop];
-        if (!cachedFunc) {
-            cachedFunc = methodMap[prop] = function (...args) {
-                advanceResults.set(this, ittrProxiedCursorToOriginalProxy.get(this)[prop](...args));
-            };
-        }
-        return cachedFunc;
-    },
-};
-async function* iterate(...args) {
-    // tslint:disable-next-line:no-this-assignment
-    let cursor = this;
-    if (!(cursor instanceof IDBCursor)) {
-        cursor = await cursor.openCursor(...args);
-    }
-    if (!cursor)
-        return;
-    cursor = cursor;
-    const proxiedCursor = new Proxy(cursor, cursorIteratorTraps);
-    ittrProxiedCursorToOriginalProxy.set(proxiedCursor, cursor);
-    // Map this double-proxy back to the original, so other cursor methods work.
-    reverseTransformCache.set(proxiedCursor, unwrap(cursor));
-    while (cursor) {
-        yield proxiedCursor;
-        // If one of the advancing methods was not called, call continue().
-        cursor = await (advanceResults.get(proxiedCursor) || cursor.continue());
-        advanceResults.delete(proxiedCursor);
-    }
-}
-function isIteratorProp(target, prop) {
-    return ((prop === Symbol.asyncIterator &&
-        instanceOfAny(target, [IDBIndex, IDBObjectStore, IDBCursor])) ||
-        (prop === 'iterate' && instanceOfAny(target, [IDBIndex, IDBObjectStore])));
-}
-replaceTraps((oldTraps) => ({
-    ...oldTraps,
-    get(target, prop, receiver) {
-        if (isIteratorProp(target, prop))
-            return iterate;
-        return oldTraps.get(target, prop, receiver);
-    },
-    has(target, prop) {
-        return isIteratorProp(target, prop) || oldTraps.has(target, prop);
-    },
-}));
 
+const debug = globalThis.createDebugger('leofcoin/storage');
+const opfsRoot = await navigator.storage.getDirectory();
 class BrowerStore {
     db;
     name;
     root;
+    inWorker;
     version;
-    init(name = 'storage', root = '.leofcoin', version = '1') {
+    busy;
+    queue = [];
+    async init(name = 'storage', root = '.leofcoin', version = '1', inWorker = false) {
         this.version = version;
         this.name = name;
-        this.root = root;
-        this.db = openDB(`${root}/${name}`, Number(version), {
-            upgrade(db) {
-                db.createObjectStore(name);
+        this.root = opfsRoot;
+        this.inWorker = inWorker;
+        let directoryHandle;
+        try {
+            directoryHandle = await opfsRoot.getDirectoryHandle(this.name, {
+                create: true
+            });
+            if (inWorker) {
+                directoryHandle = await directoryHandle.createSyncAccessHandle();
             }
-        });
+        }
+        catch (error) {
+            console.error(error);
+        }
+        this.db = directoryHandle;
     }
     toKeyPath(key) {
         if (key instanceof KeyPath)
@@ -386,40 +137,102 @@ class BrowerStore {
         // @ts-ignore
         return value.uint8Array;
     }
+    async has(key) {
+        debug(`has ${this.toKeyPath(key)}`);
+        try {
+            await this.db.getFileHandle(this.toKeyPath(key));
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
     async get(key) {
-        return (await this.db).get(this.name, this.toKeyPath(key));
+        debug(`get ${this.toKeyPath(key)}`);
+        let handle = await this.db.getFileHandle(this.toKeyPath(key));
+        let readBuffer;
+        if (this.inWorker) {
+            handle = await handle.createSyncAccessHandle();
+            const fileSize = handle.getSize();
+            // Read file content to a buffer.
+            const buffer = new DataView(new ArrayBuffer(fileSize));
+            readBuffer = handle.read(buffer, { at: 0 });
+            handle.close();
+        }
+        else {
+            const file = await handle.getFile();
+            readBuffer = await file.arrayBuffer();
+        }
+        return new Uint8Array(readBuffer);
     }
     async put(key, value) {
-        return (await this.db).put(this.name, this.toKeyValue(value), this.toKeyPath(key));
+        const promise = () => new Promise(async (resolve) => {
+            debug(`put ${this.toKeyPath(key)}`);
+            let handle = await this.db.getFileHandle(this.toKeyPath(key), { create: true });
+            let writeable;
+            if (this.inWorker) {
+                writeable = await handle.createSyncAccessHandle();
+            }
+            else {
+                writeable = await handle.createWritable();
+            }
+            (await writeable).write(this.toKeyValue(value));
+            (await writeable).close();
+            resolve(true);
+            if (this.queue.length > 0 && !this.busy) {
+                this.runQueue();
+            }
+        });
+        this.queue.push(promise);
+        this.runQueue();
+        return promise;
+    }
+    async runQueue() {
+        if (this.queue.length > 0) {
+            this.busy = true;
+            const next = this.queue.shift();
+            await next();
+            return this.runQueue();
+        }
+        else {
+            this.busy = false;
+        }
     }
     async delete(key) {
-        return (await this.db).delete(this.name, this.toKeyPath(key));
+        debug(`delete ${this.toKeyPath(key)}`);
+        return this.db.removeEntry(this.toKeyPath(key));
     }
     async clear() {
-        return (await this.db).clear(this.name);
+        debug(`clear ${this.toKeyPath(key)}`);
+        for await (const key of this.db.keys()) {
+            await this.db.removeEntry(key);
+        }
     }
     async values(limit = -1) {
-        const values = [];
-        const tx = (await this.db).transaction(this.name);
-        for await (const cursor of tx.store) {
-            values.push(cursor.value);
-            if (limit && values.length === limit)
-                return values;
+        debug(`values ${limit}`);
+        let values = [];
+        for await (const cursor of this.db.values()) {
+            values.push(cursor.getFile());
+            if (limit && values.length === limit) {
+                values = await Promise.all(values);
+                return Promise.all(values.map(async (file) => new Uint8Array(await file.arrayBuffer())));
+            }
         }
-        return values;
+        values = await Promise.all(values);
+        return Promise.all(values.map(async (file) => new Uint8Array(await file.arrayBuffer())));
     }
     async keys(limit = -1) {
+        debug(`keys ${limit}`);
         const keys = [];
-        const tx = (await this.db).transaction(this.name);
-        for await (const cursor of tx.store) {
-            keys.push(cursor.key);
+        for await (const cursor of this.db.keys()) {
+            keys.push(cursor);
             if (limit && keys.length === limit)
                 return keys;
         }
         return keys;
     }
     async iterate() {
-        return (await this.db).transaction(this.name).store;
+        return this.db.entries();
     }
 }
 

package/exports/browser/chain.js

@@ -1,10 +1,12 @@
-import { c as BigNumber, L as Logger, v as version$1, h as hexZeroPad, i as isBigNumberish, d as arrayify, e as isBytes, T as TransactionMessage, t as toBase58, C as ContractMessage, R as RawTransactionMessage, f as getDefaultExportFromCjs, B as BlockMessage, a as BWMessage, b as BWRequestMessage } from './_polyfill-node.child_process-rc1HO9Xs.js';
+import { c as BigNumber, L as Logger, v as version$1, h as hexZeroPad, i as isBigNumberish, d as arrayify, e as isBytes, T as TransactionMessage, t as toBase58, C as ContractMessage, R as RawTransactionMessage, f as getDefaultExportFromCjs, B as BlockMessage, a as BWMessage, b as BWRequestMessage } from './_polyfill-node.child_process-BsjYmFff.js';
 
 if (!globalThis.DEBUG) {
   let DEBUG = [];
   if (globalThis.localStorage) {
     DEBUG = globalThis.localStorage.getItem('DEBUG');
-    globalThis.DEBUG = DEBUG ? DEBUG.split(',') : [DEBUG];
+    globalThis.DEBUG = DEBUG.startsWith('[')
+      ? JSON.parse(DEBUG).split(',')
+      : [DEBUG];
   }
 }
 
@@ -21,10 +23,12 @@ const debug$5 = (target, text) => {
     else console.log('\x1b[34m\x1b[1m%s', `${target}`, '\x1b[0m');
 };
 
+const createDebugger = (target) => (text) => debug$5(target, text);
+
 if (!globalThis.debug) {
   globalThis.debug = debug$5;
-
-  globalThis.createDebugger = (target) => (text) => debug$5(target, text);
+  // todo: deprecate
+  globalThis.createDebugger = createDebugger;
 }
 
 const logger$1 = new Logger(version$1);
@@ -700,12 +704,17 @@ var debug_1 = debug$4;
 
 	// Coercion.
 	// Extract anything that could conceivably be a part of a valid semver
-	createToken('COERCE', `${'(^|[^\\d])' +
+	createToken('COERCEPLAIN', `${'(^|[^\\d])' +
 	              '(\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` +
 	              `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +
-	              `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +
+	              `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
+	createToken('COERCE', `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
+	createToken('COERCEFULL', src[t.COERCEPLAIN] +
+	              `(?:${src[t.PRERELEASE]})?` +
+	              `(?:${src[t.BUILD]})?` +
 	              `(?:$|[^\\d])`);
 	createToken('COERCERTL', src[t.COERCE], true);
+	createToken('COERCERTLFULL', src[t.COERCEFULL], true);
 
 	// Tilde ranges.
 	// Meaning is "reasonably at or greater than"
@@ -1367,35 +1376,43 @@ const coerce$1 = (version, options) => {
 
   let match = null;
   if (!options.rtl) {
-    match = version.match(re[t.COERCE]);
+    match = version.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE]);
   } else {
     // Find the right-most coercible string that does not share
     // a terminus with a more left-ward coercible string.
     // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'
+    // With includePrerelease option set, '1.2.3.4-rc' wants to coerce '2.3.4-rc', not '2.3.4'
     //
     // Walk through the string checking with a /g regexp
     // Manually set the index so as to pick up overlapping matches.
     // Stop when we get a match that ends at the string end, since no
     // coercible string can be more right-ward without the same terminus.
+    const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL];
     let next;
-    while ((next = re[t.COERCERTL].exec(version)) &&
+    while ((next = coerceRtlRegex.exec(version)) &&
         (!match || match.index + match[0].length !== version.length)
     ) {
       if (!match ||
             next.index + next[0].length !== match.index + match[0].length) {
         match = next;
       }
-      re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length;
+      coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
     }
     // leave it in a clean state
-    re[t.COERCERTL].lastIndex = -1;
+    coerceRtlRegex.lastIndex = -1;
   }
 
   if (match === null) {
     return null
   }
 
-  return parse$1(`${match[2]}.${match[3] || '0'}.${match[4] || '0'}`, options)
+  const major = match[2];
+  const minor = match[3] || '0';
+  const patch = match[4] || '0';
+  const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : '';
+  const build = options.includePrerelease && match[6] ? `+${match[6]}` : '';
+
+  return parse$1(`${major}.${minor}.${patch}${prerelease}${build}`, options)
 };
 var coerce_1 = coerce$1;
 
@@ -3805,7 +3822,7 @@ class EasyWorker {
         this.worker = new Worker(url, {...options});
       } else {
         return new Promise(async (resolve, reject) => {
-          const {fork} = await import('./_polyfill-node.child_process-rc1HO9Xs.js').then(function (n) { return n._; });  
+          const {fork} = await import('./_polyfill-node.child_process-BsjYmFff.js').then(function (n) { return n._; });  
           this.worker = fork(url, ['easy-worker-child'], options);
           resolve(this);
         })
@@ -3906,7 +3923,14 @@ class Machine {
             case 'transactionLoaded': {
                 const { from, nonce, hash } = data.result;
                 (await transactionPoolStore.has(hash)) && (await transactionPoolStore.delete(hash));
-                await accountsStore.put(from, nonce);
+                try {
+                    const _nonce = await accountsStore.get(from);
+                    if (nonce > _nonce)
+                        await accountsStore.put(from, nonce);
+                }
+                catch (error) {
+                    await accountsStore.put(from, nonce);
+                }
                 break;
             }
             case 'contractError': {
@@ -3955,7 +3979,7 @@ class Machine {
             pubsub.subscribe('machine.ready', machineReady);
             let pre;
             try {
-                const importee = await import('./_polyfill-node.url-1q06MepH.js');
+                const importee = await import('./_polyfill-node.url-Bp9XkJZf.js');
                 const url = importee.default;
                 if (url)
                     pre = url.fileURLToPath(new URL('.', import.meta.url));

package/exports/browser/{client-UOCjJBGl-pbv-pTHd.js → client-A009z8av-DQfd3vOY.js}

@@ -1,5 +1,5 @@
-import { L as LittlePubSub } from './node-browser-0Ly80awM.js';
-import './_polyfill-node.child_process-rc1HO9Xs.js';
+import { L as LittlePubSub } from './node-browser-DqIklEKv.js';
+import './_polyfill-node.child_process-BsjYmFff.js';
 
 class Api {
     _pubsub;
@@ -206,7 +206,7 @@ class SocketRequestClient {
             const init = async () => {
                 // @ts-ignore
                 if (!globalThis.WebSocket)
-                    globalThis.WebSocket = (await import('./browser-1GyRaZxg-C9SpI6hG.js').then(function (n) { return n.b; })).default.w3cwebsocket;
+                    globalThis.WebSocket = (await import('./browser-Ei0BXMlu-C1_XUL9Y.js').then(function (n) { return n.b; })).default.w3cwebsocket;
                 const client = new WebSocket(this.#url, this.#protocol);
                 client.onmessage = this.onmessage;
                 client.onerror = this.onerror;
@@ -280,7 +280,7 @@ const iceServers = [
         credential: 'openrelayproject'
     }
 ];
-const SimplePeer = (await import('./index-K4Kwju30-vS3fNpxy.js').then(function (n) { return n.i; })).default;
+const SimplePeer = (await import('./index-YQrIDBUQ-c7011Ab4.js').then(function (n) { return n.i; })).default;
 class Peer extends SimplePeer {
     peerId;
     channelName;
@@ -408,7 +408,7 @@ class Client {
     async _init() {
         // reconnectJob()
         if (!globalThis.RTCPeerConnection)
-            globalThis.wrtc = (await import('./browser-AyxSBUXj-AyxSBUXj.js').then(function (n) { return n.b; })).default;
+            globalThis.wrtc = (await import('./browser-AyxSBUXj-pguCHlVu.js').then(function (n) { return n.b; })).default;
         for (const star of this.starsConfig) {
             try {
                 const client = new SocketRequestClient(star, this.networkVersion);

package/exports/browser/{index-ub31QSed-EMPr2oeb.js → index-G74WLzL7-Dt2dwaXq.js}

@@ -1,5 +1,5 @@
-import { M as MultiWallet, e as encrypt, b as base58$1 } from './node-browser-0Ly80awM.js';
-import './_polyfill-node.child_process-rc1HO9Xs.js';
+import { M as MultiWallet, e as encrypt, b as base58$1 } from './node-browser-DqIklEKv.js';
+import './_polyfill-node.child_process-BsjYmFff.js';
 
 /**
  * @params {String} network

package/exports/browser/{index-K4Kwju30-vS3fNpxy.js → index-YQrIDBUQ-c7011Ab4.js}

@@ -1,5 +1,5 @@
-import { i as inherits_browserExports, c as commonjsGlobal, g as getDefaultExportFromCjs, r as require$$3 } from './node-browser-0Ly80awM.js';
-import './_polyfill-node.child_process-rc1HO9Xs.js';
+import { i as inherits_browserExports, c as commonjsGlobal, g as getDefaultExportFromCjs, r as require$$3 } from './node-browser-DqIklEKv.js';
+import './_polyfill-node.child_process-BsjYmFff.js';
 
 var browser$2 = {exports: {}};