@polkadot/extension-base 0.45.1 → 0.45.2

package/background/handlers/State.js

@@ -1,3 +1,5 @@
+var _State_authUrls, _State_authRequests, _State_metaStore, _State_injectedProviders, _State_metaRequests, _State_notification, _State_providers, _State_signRequests, _State_windows, _State_connectedTabsUrl;
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
 import { BehaviorSubject } from 'rxjs';
 import { getId } from '@polkadot/extension-base/utils/getId';
 import { addMetadata, knownMetadata } from '@polkadot/extension-chains';
@@ -61,29 +63,87 @@ function extractMetadata(store) {
     });
 }
 export default class State {
-    #authUrls = {};
-    #authRequests = {};
-    #metaStore = new MetadataStore();
-    // Map of providers currently injected in tabs
-    #injectedProviders = new Map();
-    #metaRequests = {};
-    #notification = settings.notification;
-    // Map of all providers exposed by the extension, they are retrievable by key
-    #providers;
-    #signRequests = {};
-    #windows = [];
-    #connectedTabsUrl = [];
-    authSubject = new BehaviorSubject([]);
-    metaSubject = new BehaviorSubject([]);
-    signSubject = new BehaviorSubject([]);
-    defaultAuthAccountSelection = [];
     constructor(providers = {}) {
-        this.#providers = providers;
-        extractMetadata(this.#metaStore);
+        _State_authUrls.set(this, {});
+        _State_authRequests.set(this, {});
+        _State_metaStore.set(this, new MetadataStore());
+        // Map of providers currently injected in tabs
+        _State_injectedProviders.set(this, new Map());
+        _State_metaRequests.set(this, {});
+        _State_notification.set(this, settings.notification);
+        // Map of all providers exposed by the extension, they are retrievable by key
+        _State_providers.set(this, void 0);
+        _State_signRequests.set(this, {});
+        _State_windows.set(this, []);
+        _State_connectedTabsUrl.set(this, []);
+        this.authSubject = new BehaviorSubject([]);
+        this.metaSubject = new BehaviorSubject([]);
+        this.signSubject = new BehaviorSubject([]);
+        this.defaultAuthAccountSelection = [];
+        this.authComplete = (id, resolve, reject) => {
+            const complete = (authorizedAccounts = []) => {
+                const { idStr, request: { origin }, url } = __classPrivateFieldGet(this, _State_authRequests, "f")[id];
+                __classPrivateFieldGet(this, _State_authUrls, "f")[this.stripUrl(url)] = {
+                    authorizedAccounts,
+                    count: 0,
+                    id: idStr,
+                    origin,
+                    url
+                };
+                this.saveCurrentAuthList();
+                this.updateDefaultAuthAccounts(authorizedAccounts);
+                delete __classPrivateFieldGet(this, _State_authRequests, "f")[id];
+                this.updateIconAuth(true);
+            };
+            return {
+                reject: (error) => {
+                    complete();
+                    reject(error);
+                },
+                resolve: ({ authorizedAccounts, result }) => {
+                    complete(authorizedAccounts);
+                    resolve({ authorizedAccounts, result });
+                }
+            };
+        };
+        this.metaComplete = (id, resolve, reject) => {
+            const complete = () => {
+                delete __classPrivateFieldGet(this, _State_metaRequests, "f")[id];
+                this.updateIconMeta(true);
+            };
+            return {
+                reject: (error) => {
+                    complete();
+                    reject(error);
+                },
+                resolve: (result) => {
+                    complete();
+                    resolve(result);
+                }
+            };
+        };
+        this.signComplete = (id, resolve, reject) => {
+            const complete = () => {
+                delete __classPrivateFieldGet(this, _State_signRequests, "f")[id];
+                this.updateIconSign(true);
+            };
+            return {
+                reject: (error) => {
+                    complete();
+                    reject(error);
+                },
+                resolve: (result) => {
+                    complete();
+                    resolve(result);
+                }
+            };
+        };
+        __classPrivateFieldSet(this, _State_providers, providers, "f");
+        extractMetadata(__classPrivateFieldGet(this, _State_metaStore, "f"));
         // retrieve previously set authorizations
         const authString = localStorage.getItem(AUTH_URLS_KEY) || '{}';
         const previousAuth = JSON.parse(authString);
-        this.#authUrls = previousAuth;
+        __classPrivateFieldSet(this, _State_authUrls, previousAuth, "f");
         // retrieve previously set default auth accounts
         const defaultAuthString = localStorage.getItem(DEFAULT_AUTH_ACCOUNTS) || '[]';
         const previousDefaultAuth = JSON.parse(defaultAuthString);
@@ -93,72 +153,46 @@ export default class State {
         return knownMetadata();
     }
     get numAuthRequests() {
-        return Object.keys(this.#authRequests).length;
+        return Object.keys(__classPrivateFieldGet(this, _State_authRequests, "f")).length;
     }
     get numMetaRequests() {
-        return Object.keys(this.#metaRequests).length;
+        return Object.keys(__classPrivateFieldGet(this, _State_metaRequests, "f")).length;
     }
     get numSignRequests() {
-        return Object.keys(this.#signRequests).length;
+        return Object.keys(__classPrivateFieldGet(this, _State_signRequests, "f")).length;
     }
     get allAuthRequests() {
         return Object
-            .values(this.#authRequests)
+            .values(__classPrivateFieldGet(this, _State_authRequests, "f"))
             .map(({ id, request, url }) => ({ id, request, url }));
     }
     get allMetaRequests() {
         return Object
-            .values(this.#metaRequests)
+            .values(__classPrivateFieldGet(this, _State_metaRequests, "f"))
             .map(({ id, request, url }) => ({ id, request, url }));
     }
     get allSignRequests() {
         return Object
-            .values(this.#signRequests)
+            .values(__classPrivateFieldGet(this, _State_signRequests, "f"))
             .map(({ account, id, request, url }) => ({ account, id, request, url }));
     }
     get authUrls() {
-        return this.#authUrls;
+        return __classPrivateFieldGet(this, _State_authUrls, "f");
     }
     popupClose() {
-        this.#windows.forEach((id) => withErrorLog(() => chrome.windows.remove(id)));
-        this.#windows = [];
+        __classPrivateFieldGet(this, _State_windows, "f").forEach((id) => withErrorLog(() => chrome.windows.remove(id)));
+        __classPrivateFieldSet(this, _State_windows, [], "f");
     }
     popupOpen() {
-        this.#notification !== 'extension' &&
-            chrome.windows.create(this.#notification === 'window'
+        __classPrivateFieldGet(this, _State_notification, "f") !== 'extension' &&
+            chrome.windows.create(__classPrivateFieldGet(this, _State_notification, "f") === 'window'
                 ? NORMAL_WINDOW_OPTS
                 : POPUP_WINDOW_OPTS, (window) => {
                 if (window) {
-                    this.#windows.push(window.id || 0);
+                    __classPrivateFieldGet(this, _State_windows, "f").push(window.id || 0);
                 }
             });
     }
-    authComplete = (id, resolve, reject) => {
-        const complete = (authorizedAccounts = []) => {
-            const { idStr, request: { origin }, url } = this.#authRequests[id];
-            this.#authUrls[this.stripUrl(url)] = {
-                authorizedAccounts,
-                count: 0,
-                id: idStr,
-                origin,
-                url
-            };
-            this.saveCurrentAuthList();
-            this.updateDefaultAuthAccounts(authorizedAccounts);
-            delete this.#authRequests[id];
-            this.updateIconAuth(true);
-        };
-        return {
-            reject: (error) => {
-                complete();
-                reject(error);
-            },
-            resolve: ({ authorizedAccounts, result }) => {
-                complete(authorizedAccounts);
-                resolve({ authorizedAccounts, result });
-            }
-        };
-    };
     udateCurrentTabsUrl(urls) {
         const connectedTabs = urls.map((url) => {
             let strippedUrl = '';
@@ -175,17 +209,17 @@ export default class State {
                 : undefined;
         })
             .filter((value) => !!value);
-        this.#connectedTabsUrl = connectedTabs;
+        __classPrivateFieldSet(this, _State_connectedTabsUrl, connectedTabs, "f");
     }
     getConnectedTabsUrl() {
-        return this.#connectedTabsUrl;
+        return __classPrivateFieldGet(this, _State_connectedTabsUrl, "f");
     }
     deleteAuthRequest(requestId) {
-        delete this.#authRequests[requestId];
+        delete __classPrivateFieldGet(this, _State_authRequests, "f")[requestId];
         this.updateIconAuth(true);
     }
     saveCurrentAuthList() {
-        localStorage.setItem(AUTH_URLS_KEY, JSON.stringify(this.#authUrls));
+        localStorage.setItem(AUTH_URLS_KEY, JSON.stringify(__classPrivateFieldGet(this, _State_authUrls, "f")));
     }
     saveDefaultAuthAccounts() {
         localStorage.setItem(DEFAULT_AUTH_ACCOUNTS, JSON.stringify(this.defaultAuthAccountSelection));
@@ -194,38 +228,6 @@ export default class State {
         this.defaultAuthAccountSelection = newList;
         this.saveDefaultAuthAccounts();
     }
-    metaComplete = (id, resolve, reject) => {
-        const complete = () => {
-            delete this.#metaRequests[id];
-            this.updateIconMeta(true);
-        };
-        return {
-            reject: (error) => {
-                complete();
-                reject(error);
-            },
-            resolve: (result) => {
-                complete();
-                resolve(result);
-            }
-        };
-    };
-    signComplete = (id, resolve, reject) => {
-        const complete = () => {
-            delete this.#signRequests[id];
-            this.updateIconSign(true);
-        };
-        return {
-            reject: (error) => {
-                complete();
-                reject(error);
-            },
-            resolve: (result) => {
-                complete();
-                resolve(result);
-            }
-        };
-    };
     stripUrl(url) {
         assert(url && (url.startsWith('http:') || url.startsWith('https:') || url.startsWith('ipfs:') || url.startsWith('ipns:')), `Invalid url ${url}, expected to start with http: or https: or ipfs: or ipns:`);
         const parts = url.split('/');
@@ -246,11 +248,11 @@ export default class State {
         }
     }
     removeAuthorization(url) {
-        const entry = this.#authUrls[url];
+        const entry = __classPrivateFieldGet(this, _State_authUrls, "f")[url];
         assert(entry, `The source ${url} is not known`);
-        delete this.#authUrls[url];
+        delete __classPrivateFieldGet(this, _State_authUrls, "f")[url];
         this.saveCurrentAuthList();
-        return this.#authUrls;
+        return __classPrivateFieldGet(this, _State_authUrls, "f");
     }
     updateIconAuth(shouldClose) {
         this.authSubject.next(this.allAuthRequests);
@@ -266,7 +268,7 @@ export default class State {
     }
     updateAuthorizedAccounts(authorizedAccountDiff) {
         authorizedAccountDiff.forEach(([url, authorizedAccountDiff]) => {
-            this.#authUrls[url].authorizedAccounts = authorizedAccountDiff;
+            __classPrivateFieldGet(this, _State_authUrls, "f")[url].authorizedAccounts = authorizedAccountDiff;
         });
         this.saveCurrentAuthList();
     }
@@ -274,12 +276,12 @@ export default class State {
         const idStr = this.stripUrl(url);
         // Do not enqueue duplicate authorization requests.
         const isDuplicate = Object
-            .values(this.#authRequests)
+            .values(__classPrivateFieldGet(this, _State_authRequests, "f"))
             .some((request) => request.idStr === idStr);
         assert(!isDuplicate, `The source ${url} has a pending authorization request`);
-        if (this.#authUrls[idStr]) {
+        if (__classPrivateFieldGet(this, _State_authUrls, "f")[idStr]) {
             // this url was seen in the past
-            assert(this.#authUrls[idStr].authorizedAccounts || this.#authUrls[idStr].isAllowed, `The source ${url} is not allowed to interact with this extension`);
+            assert(__classPrivateFieldGet(this, _State_authUrls, "f")[idStr].authorizedAccounts || __classPrivateFieldGet(this, _State_authUrls, "f")[idStr].isAllowed, `The source ${url} is not allowed to interact with this extension`);
             return {
                 authorizedAccounts: [],
                 result: false
@@ -287,7 +289,7 @@ export default class State {
         }
         return new Promise((resolve, reject) => {
             const id = getId();
-            this.#authRequests[id] = {
+            __classPrivateFieldGet(this, _State_authRequests, "f")[id] = {
                 ...this.authComplete(id, resolve, reject),
                 id,
                 idStr,
@@ -299,14 +301,14 @@ export default class State {
         });
     }
     ensureUrlAuthorized(url) {
-        const entry = this.#authUrls[this.stripUrl(url)];
+        const entry = __classPrivateFieldGet(this, _State_authUrls, "f")[this.stripUrl(url)];
         assert(entry, `The source ${url} has not been enabled yet`);
         return true;
     }
     injectMetadata(url, request) {
         return new Promise((resolve, reject) => {
             const id = getId();
-            this.#metaRequests[id] = {
+            __classPrivateFieldGet(this, _State_metaRequests, "f")[id] = {
                 ...this.metaComplete(id, resolve, reject),
                 id,
                 request,
@@ -317,73 +319,73 @@ export default class State {
         });
     }
     getAuthRequest(id) {
-        return this.#authRequests[id];
+        return __classPrivateFieldGet(this, _State_authRequests, "f")[id];
     }
     getMetaRequest(id) {
-        return this.#metaRequests[id];
+        return __classPrivateFieldGet(this, _State_metaRequests, "f")[id];
     }
     getSignRequest(id) {
-        return this.#signRequests[id];
+        return __classPrivateFieldGet(this, _State_signRequests, "f")[id];
     }
     // List all providers the extension is exposing
     rpcListProviders() {
-        return Promise.resolve(Object.keys(this.#providers).reduce((acc, key) => {
-            acc[key] = this.#providers[key].meta;
+        return Promise.resolve(Object.keys(__classPrivateFieldGet(this, _State_providers, "f")).reduce((acc, key) => {
+            acc[key] = __classPrivateFieldGet(this, _State_providers, "f")[key].meta;
             return acc;
         }, {}));
     }
     rpcSend(request, port) {
-        const provider = this.#injectedProviders.get(port);
+        const provider = __classPrivateFieldGet(this, _State_injectedProviders, "f").get(port);
         assert(provider, 'Cannot call pub(rpc.subscribe) before provider is set');
         return provider.send(request.method, request.params);
     }
     // Start a provider, return its meta
     rpcStartProvider(key, port) {
-        assert(Object.keys(this.#providers).includes(key), `Provider ${key} is not exposed by extension`);
-        if (this.#injectedProviders.get(port)) {
-            return Promise.resolve(this.#providers[key].meta);
+        assert(Object.keys(__classPrivateFieldGet(this, _State_providers, "f")).includes(key), `Provider ${key} is not exposed by extension`);
+        if (__classPrivateFieldGet(this, _State_injectedProviders, "f").get(port)) {
+            return Promise.resolve(__classPrivateFieldGet(this, _State_providers, "f")[key].meta);
         }
         // Instantiate the provider
-        this.#injectedProviders.set(port, this.#providers[key].start());
+        __classPrivateFieldGet(this, _State_injectedProviders, "f").set(port, __classPrivateFieldGet(this, _State_providers, "f")[key].start());
         // Close provider connection when page is closed
         port.onDisconnect.addListener(() => {
-            const provider = this.#injectedProviders.get(port);
+            const provider = __classPrivateFieldGet(this, _State_injectedProviders, "f").get(port);
             if (provider) {
                 withErrorLog(() => provider.disconnect());
             }
-            this.#injectedProviders.delete(port);
+            __classPrivateFieldGet(this, _State_injectedProviders, "f").delete(port);
         });
-        return Promise.resolve(this.#providers[key].meta);
+        return Promise.resolve(__classPrivateFieldGet(this, _State_providers, "f")[key].meta);
     }
     rpcSubscribe({ method, params, type }, cb, port) {
-        const provider = this.#injectedProviders.get(port);
+        const provider = __classPrivateFieldGet(this, _State_injectedProviders, "f").get(port);
         assert(provider, 'Cannot call pub(rpc.subscribe) before provider is set');
         return provider.subscribe(type, method, params, cb);
     }
     rpcSubscribeConnected(_request, cb, port) {
-        const provider = this.#injectedProviders.get(port);
+        const provider = __classPrivateFieldGet(this, _State_injectedProviders, "f").get(port);
         assert(provider, 'Cannot call pub(rpc.subscribeConnected) before provider is set');
         cb(null, provider.isConnected); // Immediately send back current isConnected
         provider.on('connected', () => cb(null, true));
         provider.on('disconnected', () => cb(null, false));
     }
     rpcUnsubscribe(request, port) {
-        const provider = this.#injectedProviders.get(port);
+        const provider = __classPrivateFieldGet(this, _State_injectedProviders, "f").get(port);
         assert(provider, 'Cannot call pub(rpc.unsubscribe) before provider is set');
         return provider.unsubscribe(request.type, request.method, request.subscriptionId);
     }
     saveMetadata(meta) {
-        this.#metaStore.set(meta.genesisHash, meta);
+        __classPrivateFieldGet(this, _State_metaStore, "f").set(meta.genesisHash, meta);
         addMetadata(meta);
     }
     setNotification(notification) {
-        this.#notification = notification;
+        __classPrivateFieldSet(this, _State_notification, notification, "f");
         return true;
     }
     sign(url, request, account) {
         const id = getId();
         return new Promise((resolve, reject) => {
-            this.#signRequests[id] = {
+            __classPrivateFieldGet(this, _State_signRequests, "f")[id] = {
                 ...this.signComplete(id, resolve, reject),
                 account,
                 id,
@@ -394,4 +396,5 @@ export default class State {
             this.popupOpen();
         });
     }
-}
+}
+_State_authUrls = new WeakMap(), _State_authRequests = new WeakMap(), _State_metaStore = new WeakMap(), _State_injectedProviders = new WeakMap(), _State_metaRequests = new WeakMap(), _State_notification = new WeakMap(), _State_providers = new WeakMap(), _State_signRequests = new WeakMap(), _State_windows = new WeakMap(), _State_connectedTabsUrl = new WeakMap();

package/background/handlers/Tabs.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="chrome" />
-import type { MessageTypes, RequestTypes, ResponseTypes } from '../types';
-import State from './State';
+import type { MessageTypes, RequestTypes, ResponseTypes } from '../types.js';
+import State from './State.js';
 export default class Tabs {
     #private;
     constructor(state: State);

package/background/handlers/Tabs.js

@@ -1,3 +1,5 @@
+var _Tabs_accountSubs, _Tabs_state;
+import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
 import { PHISHING_PAGE_REDIRECT } from '@polkadot/extension-base/defaults';
 import { canDerive } from '@polkadot/extension-base/utils';
 import { checkIfDenied } from '@polkadot/phishing';
@@ -22,13 +24,13 @@ function transformAccounts(accounts, anyType = false) {
     }));
 }
 export default class Tabs {
-    #accountSubs = {};
-    #state;
     constructor(state) {
-        this.#state = state;
+        _Tabs_accountSubs.set(this, {});
+        _Tabs_state.set(this, void 0);
+        __classPrivateFieldSet(this, _Tabs_state, state, "f");
     }
     filterForAuthorizedAccounts(accounts, url) {
-        const auth = this.#state.authUrls[this.#state.stripUrl(url)];
+        const auth = __classPrivateFieldGet(this, _Tabs_state, "f").authUrls[__classPrivateFieldGet(this, _Tabs_state, "f").stripUrl(url)];
         return accounts.filter((allAcc) => auth.authorizedAccounts
             // we have a list, use it
             ? auth.authorizedAccounts.includes(allAcc.address)
@@ -36,7 +38,7 @@ export default class Tabs {
             : auth.isAllowed);
     }
     authorize(url, request) {
-        return this.#state.authorizeUrl(url, request);
+        return __classPrivateFieldGet(this, _Tabs_state, "f").authorizeUrl(url, request);
     }
     accountsListAuthorized(url, { anyType }) {
         const transformedAccounts = transformAccounts(accountsObservable.subject.getValue(), anyType);
@@ -44,7 +46,7 @@ export default class Tabs {
     }
     accountsSubscribeAuthorized(url, id, port) {
         const cb = createSubscription(id, port);
-        this.#accountSubs[id] = {
+        __classPrivateFieldGet(this, _Tabs_accountSubs, "f")[id] = {
             subscription: accountsObservable.subject.subscribe((accounts) => {
                 const transformedAccounts = transformAccounts(accounts);
                 cb(this.filterForAuthorizedAccounts(transformedAccounts, url));
@@ -57,11 +59,11 @@ export default class Tabs {
         return id;
     }
     accountsUnsubscribe(url, { id }) {
-        const sub = this.#accountSubs[id];
+        const sub = __classPrivateFieldGet(this, _Tabs_accountSubs, "f")[id];
         if (!sub || sub.url !== url) {
             return false;
         }
-        delete this.#accountSubs[id];
+        delete __classPrivateFieldGet(this, _Tabs_accountSubs, "f")[id];
         unsubscribe(id);
         sub.subscription.unsubscribe();
         return true;
@@ -74,36 +76,36 @@ export default class Tabs {
     bytesSign(url, request) {
         const address = request.address;
         const pair = this.getSigningPair(address);
-        return this.#state.sign(url, new RequestBytesSign(request), { address, ...pair.meta });
+        return __classPrivateFieldGet(this, _Tabs_state, "f").sign(url, new RequestBytesSign(request), { address, ...pair.meta });
     }
     extrinsicSign(url, request) {
         const address = request.address;
         const pair = this.getSigningPair(address);
-        return this.#state.sign(url, new RequestExtrinsicSign(request), { address, ...pair.meta });
+        return __classPrivateFieldGet(this, _Tabs_state, "f").sign(url, new RequestExtrinsicSign(request), { address, ...pair.meta });
     }
     metadataProvide(url, request) {
-        return this.#state.injectMetadata(url, request);
+        return __classPrivateFieldGet(this, _Tabs_state, "f").injectMetadata(url, request);
     }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     metadataList(url) {
-        return this.#state.knownMetadata.map(({ genesisHash, specVersion }) => ({
+        return __classPrivateFieldGet(this, _Tabs_state, "f").knownMetadata.map(({ genesisHash, specVersion }) => ({
             genesisHash,
             specVersion
         }));
     }
     rpcListProviders() {
-        return this.#state.rpcListProviders();
+        return __classPrivateFieldGet(this, _Tabs_state, "f").rpcListProviders();
     }
     rpcSend(request, port) {
-        return this.#state.rpcSend(request, port);
+        return __classPrivateFieldGet(this, _Tabs_state, "f").rpcSend(request, port);
     }
     rpcStartProvider(key, port) {
-        return this.#state.rpcStartProvider(key, port);
+        return __classPrivateFieldGet(this, _Tabs_state, "f").rpcStartProvider(key, port);
     }
     async rpcSubscribe(request, id, port) {
         const innerCb = createSubscription(id, port);
         const cb = (_error, data) => innerCb(data);
-        const subscriptionId = await this.#state.rpcSubscribe(request, cb, port);
+        const subscriptionId = await __classPrivateFieldGet(this, _Tabs_state, "f").rpcSubscribe(request, cb, port);
         port.onDisconnect.addListener(() => {
             unsubscribe(id);
             withErrorLog(() => this.rpcUnsubscribe({ ...request, subscriptionId }, port));
@@ -113,14 +115,14 @@ export default class Tabs {
     rpcSubscribeConnected(request, id, port) {
         const innerCb = createSubscription(id, port);
         const cb = (_error, data) => innerCb(data);
-        this.#state.rpcSubscribeConnected(request, cb, port);
+        __classPrivateFieldGet(this, _Tabs_state, "f").rpcSubscribeConnected(request, cb, port);
         port.onDisconnect.addListener(() => {
             unsubscribe(id);
         });
         return Promise.resolve(true);
     }
     async rpcUnsubscribe(request, port) {
-        return this.#state.rpcUnsubscribe(request, port);
+        return __classPrivateFieldGet(this, _Tabs_state, "f").rpcUnsubscribe(request, port);
     }
     redirectPhishingLanding(phishingWebsite) {
         const nonFragment = phishingWebsite.split('#')[0];
@@ -146,7 +148,7 @@ export default class Tabs {
             return this.redirectIfPhishing(url);
         }
         if (type !== 'pub(authorize.tab)') {
-            this.#state.ensureUrlAuthorized(url);
+            __classPrivateFieldGet(this, _Tabs_state, "f").ensureUrlAuthorized(url);
         }
         switch (type) {
             case 'pub(authorize.tab)':
@@ -183,4 +185,5 @@ export default class Tabs {
                 throw new Error(`Unable to handle message of type ${type}`);
         }
     }
-}
+}
+_Tabs_accountSubs = new WeakMap(), _Tabs_state = new WeakMap();

package/background/handlers/index.d.ts

@@ -1,3 +1,3 @@
 /// <reference types="chrome" />
-import type { MessageTypes, TransportRequestMessage } from '../types';
+import type { MessageTypes, TransportRequestMessage } from '../types.js';
 export default function handler<TMessageType extends MessageTypes>({ id, message, request }: TransportRequestMessage<TMessageType>, port?: chrome.runtime.Port, extensionPortName?: string): void;

package/background/handlers/subscriptions.d.ts

@@ -1,4 +1,4 @@
 /// <reference types="chrome" />
-import type { MessageTypesWithSubscriptions, SubscriptionMessageTypes } from '../types';
+import type { MessageTypesWithSubscriptions, SubscriptionMessageTypes } from '../types.js';
 export declare function createSubscription<TMessageType extends MessageTypesWithSubscriptions>(id: string, port: chrome.runtime.Port): (data: SubscriptionMessageTypes[TMessageType]) => void;
 export declare function unsubscribe(id: string): void;

package/background/types.d.ts

@@ -5,8 +5,8 @@ import type { Registry, SignerPayloadJSON, SignerPayloadRaw } from '@polkadot/ty
 import type { KeyringPairs$Json } from '@polkadot/ui-keyring/types';
 import type { HexString } from '@polkadot/util/types';
 import type { KeypairType } from '@polkadot/util-crypto/types';
-import { ALLOWED_PATH } from '../defaults';
-import { AuthResponse, AuthUrls } from './handlers/State';
+import { ALLOWED_PATH } from '../defaults.js';
+import { AuthResponse, AuthUrls } from './handlers/State.js';
 type KeysWithDefinedValues<T> = {
     [K in keyof T]: T[K] extends undefined ? never : K;
 }[keyof T];

package/bundle.d.ts

@@ -1 +1 @@
-export { packageInfo } from './packageInfo';
+export { packageInfo } from './packageInfo.js';

package/cjs/background/handlers/Extension.js

@@ -9,8 +9,8 @@ const ui_keyring_1 = tslib_1.__importDefault(require("@polkadot/ui-keyring"));
 const accounts_1 = require("@polkadot/ui-keyring/observable/accounts");
 const util_1 = require("@polkadot/util");
 const util_crypto_1 = require("@polkadot/util-crypto");
-const helpers_1 = require("./helpers");
-const subscriptions_1 = require("./subscriptions");
+const helpers_js_1 = require("./helpers.js");
+const subscriptions_js_1 = require("./subscriptions.js");
 const SEED_DEFAULT_LENGTH = 12;
 const SEED_LENGTHS = [12, 15, 18, 21, 24];
 const ETH_DERIVE_DEFAULT = "/m/44'/60'/0'/0/0";
@@ -127,10 +127,10 @@ class Extension {
         }
     }
     accountsSubscribe(id, port) {
-        const cb = (0, subscriptions_1.createSubscription)(id, port);
+        const cb = (0, subscriptions_js_1.createSubscription)(id, port);
         const subscription = accounts_1.accounts.subject.subscribe((accounts) => cb(this.transformAccounts(accounts)));
         port.onDisconnect.addListener(() => {
-            (0, subscriptions_1.unsubscribe)(id);
+            (0, subscriptions_js_1.unsubscribe)(id);
             subscription.unsubscribe();
         });
         return true;
@@ -150,10 +150,10 @@ class Extension {
     }
     // FIXME This looks very much like what we have in accounts
     authorizeSubscribe(id, port) {
-        const cb = (0, subscriptions_1.createSubscription)(id, port);
+        const cb = (0, subscriptions_js_1.createSubscription)(id, port);
         const subscription = tslib_1.__classPrivateFieldGet(this, _Extension_state, "f").authSubject.subscribe((requests) => cb(requests));
         port.onDisconnect.addListener(() => {
-            (0, subscriptions_1.unsubscribe)(id);
+            (0, subscriptions_js_1.unsubscribe)(id);
             subscription.unsubscribe();
         });
         return true;
@@ -180,10 +180,10 @@ class Extension {
         return true;
     }
     metadataSubscribe(id, port) {
-        const cb = (0, subscriptions_1.createSubscription)(id, port);
+        const cb = (0, subscriptions_js_1.createSubscription)(id, port);
         const subscription = tslib_1.__classPrivateFieldGet(this, _Extension_state, "f").metaSubject.subscribe((requests) => cb(requests));
         port.onDisconnect.addListener(() => {
-            (0, subscriptions_1.unsubscribe)(id);
+            (0, subscriptions_js_1.unsubscribe)(id);
             subscription.unsubscribe();
         });
         return true;
@@ -324,10 +324,10 @@ class Extension {
     }
     // FIXME This looks very much like what we have in authorization
     signingSubscribe(id, port) {
-        const cb = (0, subscriptions_1.createSubscription)(id, port);
+        const cb = (0, subscriptions_js_1.createSubscription)(id, port);
         const subscription = tslib_1.__classPrivateFieldGet(this, _Extension_state, "f").signSubject.subscribe((requests) => cb(requests));
         port.onDisconnect.addListener(() => {
-            (0, subscriptions_1.unsubscribe)(id);
+            (0, subscriptions_js_1.unsubscribe)(id);
             subscription.unsubscribe();
         });
         return true;
@@ -338,7 +338,7 @@ class Extension {
             console.error('Not allowed to open the url:', url);
             return false;
         }
-        (0, helpers_1.withErrorLog)(() => chrome.tabs.create({ url }));
+        (0, helpers_js_1.withErrorLog)(() => chrome.tabs.create({ url }));
         return true;
     }
     derive(parentAddress, suri, password, metadata) {