From 98489fc07698ed48a6cb92efb1efb3c0670a3ea1 Mon Sep 17 00:00:00 2001 From: vveerrgg Date: Fri, 12 Jun 2026 23:25:47 -0700 Subject: [PATCH 1/3] fix: prevent storage.sync data loss and harden key/backup flows Sync merge: - Match profiles by pubKey, not array index, so a reordered or partial sync can no longer overwrite one identity's key material with another's. - Treat bunker/remote-signer profiles (privKey:'' but a real identity) as identities in fresh-install detection, so they aren't wiped as blanks. - Stop syncing isEncrypted: the verifier is never synced, so adopting a remote isEncrypted=true permanently locked the second device out. - Add startup self-heal that clears a bogus isEncrypted flag when no password verifier and no encrypted blobs exist. - Extract pure computeMergeUpdates() so the merge rules are unit-testable. Key/backup flows: - savePrivateKey now replies via sendResponse + return true (MV3 does not deliver Promise returns), so imported keys can't silently fail. - Roll back the half-created profile when a key fails to persist. - Backup export encrypts with a supplied backup password instead of the session key, so users with no master password can export, even locked. Tests: add sync-merge and backup-password regression suites (+13). --- distros/safari/api-keys/api-keys.build.js | 797 +- distros/safari/background.build.js | 10695 +++++++++++++++- distros/safari/background.js | 41 +- distros/safari/content.build.js | 368 +- .../event_history/event_history.build.js | 5440 +++++++- .../safari/experimental/experimental.build.js | 252 +- distros/safari/nostr-keys/nostr-keys.build.js | 5584 +++++++- distros/safari/nostr.build.js | 114 +- distros/safari/options.build.css | 1908 ++- distros/safari/options.build.js | 8726 ++++++++++++- distros/safari/options.js | 17 +- distros/safari/permission/permission.build.js | 5013 +++++++- distros/safari/popup.build.js | 7272 ++++++++++- distros/safari/profiles/profiles.build.js | 5090 +++++++- distros/safari/security/security.build.js | 540 +- distros/safari/sidepanel.build.js | 8678 ++++++++++++- distros/safari/sidepanel.html | 13 +- distros/safari/vault/vault.build.js | 688 +- package-lock.json | 4 +- src/background.js | 41 +- src/nostr-keys/nostr-keys.js | 11 +- src/options.js | 17 +- src/sidepanel.html | 13 +- src/sidepanel.js | 59 +- src/utilities/sync-manager.js | 78 +- src/utilities/utils.js | 6 +- test/backup-password.test.js | 66 + test/sync-merge.test.js | 156 + 28 files changed, 61503 insertions(+), 184 deletions(-) create mode 100644 test/backup-password.test.js create mode 100644 test/sync-merge.test.js diff --git a/distros/safari/api-keys/api-keys.build.js b/distros/safari/api-keys/api-keys.build.js index 49aba0e..2089fa5 100644 --- a/distros/safari/api-keys/api-keys.build.js +++ b/distros/safari/api-keys/api-keys.build.js @@ -1,12 +1,493 @@ -(()=>{var r=typeof browser<"u"?browser:typeof chrome<"u"?chrome:null;if(!r)throw new Error("browser-polyfill: No extension API namespace found (neither browser nor chrome).");var d=typeof browser>"u"&&typeof chrome<"u";function y(e,t){return(...a)=>{try{let s=t.apply(e,a);if(s&&typeof s.then=="function")return s}catch{}return new Promise((s,o)=>{t.apply(e,[...a,(...c)=>{r.runtime&&r.runtime.lastError?o(new Error(r.runtime.lastError.message)):s(c.length<=1?c[0]:c)}])})}}var u={};u.runtime={sendMessage(...e){return d?y(r.runtime,r.runtime.sendMessage)(...e):r.runtime.sendMessage(...e)},onMessage:r.runtime.onMessage,getURL(e){return r.runtime.getURL(e)},openOptionsPage(){return d?y(r.runtime,r.runtime.openOptionsPage)():r.runtime.openOptionsPage()},get id(){return r.runtime.id}};u.storage={local:{get(...e){return d?y(r.storage.local,r.storage.local.get)(...e):r.storage.local.get(...e)},set(...e){return d?y(r.storage.local,r.storage.local.set)(...e):r.storage.local.set(...e)},clear(...e){return d?y(r.storage.local,r.storage.local.clear)(...e):r.storage.local.clear(...e)},remove(...e){return d?y(r.storage.local,r.storage.local.remove)(...e):r.storage.local.remove(...e)}},sync:r.storage?.sync?{get(...e){return d?y(r.storage.sync,r.storage.sync.get)(...e):r.storage.sync.get(...e)},set(...e){return d?y(r.storage.sync,r.storage.sync.set)(...e):r.storage.sync.set(...e)},remove(...e){return d?y(r.storage.sync,r.storage.sync.remove)(...e):r.storage.sync.remove(...e)},clear(...e){return d?y(r.storage.sync,r.storage.sync.clear)(...e):r.storage.sync.clear(...e)},getBytesInUse(...e){return r.storage.sync.getBytesInUse?d?y(r.storage.sync,r.storage.sync.getBytesInUse)(...e):r.storage.sync.getBytesInUse(...e):Promise.resolve(0)}}:null,onChanged:r.storage?.onChanged||null};u.tabs={create(...e){return d?y(r.tabs,r.tabs.create)(...e):r.tabs.create(...e)},query(...e){return d?y(r.tabs,r.tabs.query)(...e):r.tabs.query(...e)},remove(...e){return d?y(r.tabs,r.tabs.remove)(...e):r.tabs.remove(...e)},update(...e){return d?y(r.tabs,r.tabs.update)(...e):r.tabs.update(...e)},get(...e){return d?y(r.tabs,r.tabs.get)(...e):r.tabs.get(...e)},getCurrent(...e){return d?y(r.tabs,r.tabs.getCurrent)(...e):r.tabs.getCurrent(...e)},sendMessage(...e){return d?y(r.tabs,r.tabs.sendMessage)(...e):r.tabs.sendMessage(...e)}};u.alarms=r.alarms?{create(...e){let t=r.alarms.create(...e);return t&&typeof t.then=="function"?t:Promise.resolve()},clear(...e){return d?y(r.alarms,r.alarms.clear)(...e):r.alarms.clear(...e)},onAlarm:r.alarms.onAlarm}:null;var D=102400,J=8192,ee=512,te="_chunk:",V="_sync_meta",_="platformSyncEnabled";var E={P1_PROFILES:1,P2_SETTINGS:2,P3_APIKEYS:3,P4_VAULT:4},B=u.storage.local,K=null;function ne(e,t){let a=[];for(let o=0;o{let{hosts:k,...f}=c;return f}),o=JSON.stringify(s);t.push({key:"profiles",jsonString:o,priority:E.P1_PROFILES,size:o.length})}if(e.profileIndex!=null){let s=JSON.stringify(e.profileIndex);t.push({key:"profileIndex",jsonString:s,priority:E.P1_PROFILES,size:s.length})}if(e.isEncrypted!=null){let s=JSON.stringify(e.isEncrypted);t.push({key:"isEncrypted",jsonString:s,priority:E.P1_PROFILES,size:s.length})}let a=["autoLockMinutes","version","protocol_handler",_];for(let s of a)if(e[s]!=null){let o=JSON.stringify(e[s]);t.push({key:s,jsonString:o,priority:E.P2_SETTINGS,size:o.length})}for(let s of Object.keys(e))if(s.startsWith("feature:")){let o=JSON.stringify(e[s]);t.push({key:s,jsonString:o,priority:E.P2_SETTINGS,size:o.length})}if(e.apiKeyVault){let s=JSON.stringify(e.apiKeyVault);t.push({key:"apiKeyVault",jsonString:s,priority:E.P3_APIKEYS,size:s.length})}if(e.vaultDocs&&typeof e.vaultDocs=="object"){let s=Object.values(e.vaultDocs).sort((o,c)=>(c.updatedAt||0)-(o.updatedAt||0));for(let o of s){let c=`vaultDoc:${o.path}`,k=JSON.stringify(o);t.push({key:c,jsonString:k,priority:E.P4_VAULT,size:k.length})}}return t}async function se(){if(!(!u.storage.sync||!await ae()))try{let t=await re();t.sort((S,g)=>S.priority-g.priority);let a=0,s=0,o={},c=[],k=!1;for(let S of t){if(k)break;let g=ne(S.key,S.jsonString),m=0;for(let b of g)m+=b.key.length+(typeof b.value=="string"?b.value.length:JSON.stringify(b.value).length);if((a+m>D-500||s+g.length>ee-5)&&!(S.priority<=E.P3_APIKEYS)){k=!0;break}for(let b of g)o[b.key]=b.value,c.push(b.key);a+=m,s+=g.length}let f={lastWrittenAt:Date.now(),keys:c};o[V]=JSON.stringify(f),await u.storage.sync.set(o);try{let S=await u.storage.sync.get(null),g=Object.keys(S).filter(m=>m!==V&&!c.includes(m));g.length>0&&await u.storage.sync.remove(g)}catch{}}catch{}}function q(){u.storage.sync&&(K&&clearTimeout(K),K=setTimeout(()=>{K=null,se()},2e3))}async function ae(){return(await B.get({[_]:!0}))[_]}var Y=u.storage.local,P="apiKeyVault",F={keys:{},syncEnabled:!0,eventId:null,relayCreatedAt:null,syncStatus:"synced"};async function w(){let e=await Y.get({[P]:F});return{...F,...e[P]}}async function I(e){await Y.set({[P]:e}),q()}async function C(){return w()}async function j(e,t,a){let s=await w(),o=Math.floor(Date.now()/1e3),c=s.keys[e];return s.keys[e]={id:e,label:t,secret:a,createdAt:c?.createdAt||o,updatedAt:o,profileScope:c?.profileScope??null},await I(s),s.keys[e]}async function z(e){let t=await w();delete t.keys[e],await I(t)}async function x(){let e=await w();return Object.values(e.keys).sort((t,a)=>t.label.toLowerCase().localeCompare(a.label.toLowerCase()))}async function H(e){let t=await w();t.syncEnabled=e,await I(t)}async function G(){return(await w()).syncEnabled}async function A(e,t=null,a=null){let s=await w();s.syncStatus=e,t!==null&&(s.eventId=t),a!==null&&(s.relayCreatedAt=a),await I(s)}async function W(){return(await w()).keys}async function O(e){let t=await w();for(let[a,s]of Object.entries(e))t.keys[a]=s;await I(t)}var n={keys:[],newLabel:"",newSecret:"",editingId:null,editLabel:"",editSecret:"",copiedId:null,revealedId:null,syncEnabled:!0,globalSyncStatus:"idle",syncError:"",saving:!1,toast:"",relayInfo:{read:[],write:[]}};function l(e){return document.getElementById(e)}function L(){return n.relayInfo.read.length>0||n.relayInfo.write.length>0}function oe(){return[...n.keys].sort((e,t)=>e.label.toLowerCase().localeCompare(t.label.toLowerCase()))}function ie(e){return e?e.length<=8?"\u2022".repeat(e.length):e.slice(0,4)+"\u2022".repeat(4)+e.slice(-4):""}function v(e){n.toast=e,p(),setTimeout(()=>{n.toast="",p()},2e3)}function ce(e){return e==="idle"?"bg-green-500":e==="syncing"?"bg-yellow-500 animate-pulse":"bg-red-500"}function le(){return n.globalSyncStatus==="syncing"?"Syncing...":n.globalSyncStatus==="error"?n.syncError:n.syncEnabled?"Synced":"Local only"}function p(){let e=l("sync-dot"),t=l("sync-text"),a=l("sync-btn"),s=l("sync-toggle"),o=l("key-count");e&&(e.className=`inline-block w-3 h-3 rounded-full ${ce(n.globalSyncStatus)}`),t&&(t.textContent=le()),a&&(a.disabled=n.globalSyncStatus==="syncing"||!L()||!n.syncEnabled),s&&(s.checked=n.syncEnabled),o&&(o.textContent=n.keys.length+" key"+(n.keys.length!==1?"s":""));let c=l("key-table-container"),k=l("no-keys"),f=l("key-table-body");if(c&&(c.style.display=n.keys.length>0?"block":"none"),k&&(k.style.display=n.keys.length===0?"block":"none"),f){let Q=oe();f.innerHTML=Q.map(i=>{if(n.editingId===i.id)return` +(() => { + // src/utilities/browser-polyfill.js + var _browser = typeof browser !== "undefined" ? browser : typeof chrome !== "undefined" ? chrome : null; + if (!_browser) { + throw new Error("browser-polyfill: No extension API namespace found (neither browser nor chrome)."); + } + var isChrome = typeof browser === "undefined" && typeof chrome !== "undefined"; + function promisify(context, method) { + return (...args) => { + try { + const result = method.apply(context, args); + if (result && typeof result.then === "function") { + return result; + } + } catch (_) { + } + return new Promise((resolve, reject) => { + method.apply(context, [ + ...args, + (...cbArgs) => { + if (_browser.runtime && _browser.runtime.lastError) { + reject(new Error(_browser.runtime.lastError.message)); + } else { + resolve(cbArgs.length <= 1 ? cbArgs[0] : cbArgs); + } + } + ]); + }); + }; + } + var api = {}; + api.runtime = { + /** + * sendMessage – always returns a Promise. + */ + sendMessage(...args) { + if (!isChrome) { + return _browser.runtime.sendMessage(...args); + } + return promisify(_browser.runtime, _browser.runtime.sendMessage)(...args); + }, + /** + * onMessage – thin wrapper so callers use a consistent reference. + * The listener signature is (message, sender, sendResponse). + * On Chrome the listener can return `true` to keep the channel open, + * or return a Promise (MV3). Safari / Firefox expect a Promise return. + */ + onMessage: _browser.runtime.onMessage, + /** + * getURL – synchronous on all browsers. + */ + getURL(path) { + return _browser.runtime.getURL(path); + }, + /** + * openOptionsPage + */ + openOptionsPage() { + if (!isChrome) { + return _browser.runtime.openOptionsPage(); + } + return promisify(_browser.runtime, _browser.runtime.openOptionsPage)(); + }, + /** + * Expose the id for convenience. + */ + get id() { + return _browser.runtime.id; + } + }; + api.storage = { + local: { + get(...args) { + if (!isChrome) { + return _browser.storage.local.get(...args); + } + return promisify(_browser.storage.local, _browser.storage.local.get)(...args); + }, + set(...args) { + if (!isChrome) { + return _browser.storage.local.set(...args); + } + return promisify(_browser.storage.local, _browser.storage.local.set)(...args); + }, + clear(...args) { + if (!isChrome) { + return _browser.storage.local.clear(...args); + } + return promisify(_browser.storage.local, _browser.storage.local.clear)(...args); + }, + remove(...args) { + if (!isChrome) { + return _browser.storage.local.remove(...args); + } + return promisify(_browser.storage.local, _browser.storage.local.remove)(...args); + } + }, + // --- storage.sync ---------------------------------------------------------- + // Null when the browser doesn't support sync (older Safari, etc.) + sync: _browser.storage?.sync ? { + get(...args) { + if (!isChrome) { + return _browser.storage.sync.get(...args); + } + return promisify(_browser.storage.sync, _browser.storage.sync.get)(...args); + }, + set(...args) { + if (!isChrome) { + return _browser.storage.sync.set(...args); + } + return promisify(_browser.storage.sync, _browser.storage.sync.set)(...args); + }, + remove(...args) { + if (!isChrome) { + return _browser.storage.sync.remove(...args); + } + return promisify(_browser.storage.sync, _browser.storage.sync.remove)(...args); + }, + clear(...args) { + if (!isChrome) { + return _browser.storage.sync.clear(...args); + } + return promisify(_browser.storage.sync, _browser.storage.sync.clear)(...args); + }, + getBytesInUse(...args) { + if (!_browser.storage.sync.getBytesInUse) { + return Promise.resolve(0); + } + if (!isChrome) { + return _browser.storage.sync.getBytesInUse(...args); + } + return promisify(_browser.storage.sync, _browser.storage.sync.getBytesInUse)(...args); + } + } : null, + // --- storage.onChanged ----------------------------------------------------- + onChanged: _browser.storage?.onChanged || null + }; + api.tabs = { + create(...args) { + if (!isChrome) { + return _browser.tabs.create(...args); + } + return promisify(_browser.tabs, _browser.tabs.create)(...args); + }, + query(...args) { + if (!isChrome) { + return _browser.tabs.query(...args); + } + return promisify(_browser.tabs, _browser.tabs.query)(...args); + }, + remove(...args) { + if (!isChrome) { + return _browser.tabs.remove(...args); + } + return promisify(_browser.tabs, _browser.tabs.remove)(...args); + }, + update(...args) { + if (!isChrome) { + return _browser.tabs.update(...args); + } + return promisify(_browser.tabs, _browser.tabs.update)(...args); + }, + get(...args) { + if (!isChrome) { + return _browser.tabs.get(...args); + } + return promisify(_browser.tabs, _browser.tabs.get)(...args); + }, + getCurrent(...args) { + if (!isChrome) { + return _browser.tabs.getCurrent(...args); + } + return promisify(_browser.tabs, _browser.tabs.getCurrent)(...args); + }, + sendMessage(...args) { + if (!isChrome) { + return _browser.tabs.sendMessage(...args); + } + return promisify(_browser.tabs, _browser.tabs.sendMessage)(...args); + } + }; + api.alarms = _browser.alarms ? { + create(...args) { + const result = _browser.alarms.create(...args); + return result && typeof result.then === "function" ? result : Promise.resolve(); + }, + clear(...args) { + if (!isChrome) { + return _browser.alarms.clear(...args); + } + return promisify(_browser.alarms, _browser.alarms.clear)(...args); + }, + onAlarm: _browser.alarms.onAlarm + } : null; + + // src/utilities/sync-manager.js + var SYNC_QUOTA = 102400; + var MAX_ITEM = 8192; + var MAX_ITEMS = 512; + var CHUNK_PREFIX = "_chunk:"; + var SYNC_META_KEY = "_sync_meta"; + var LOCAL_ENABLED_KEY = "platformSyncEnabled"; + var PRIORITY = { + P1_PROFILES: 1, + P2_SETTINGS: 2, + P3_APIKEYS: 3, + P4_VAULT: 4 + }; + var storage = api.storage.local; + var pushTimer = null; + function chunkValue(key, jsonString) { + const chunks = []; + for (let i = 0; i < jsonString.length; i += MAX_ITEM - 100) { + chunks.push(jsonString.slice(i, i + MAX_ITEM - 100)); + } + if (chunks.length === 1) { + return [{ key, value: jsonString }]; + } + const entries = []; + for (let i = 0; i < chunks.length; i++) { + entries.push({ key: `${CHUNK_PREFIX}${key}:${i}`, value: chunks[i] }); + } + entries.push({ key, value: JSON.stringify({ __chunked: true, count: chunks.length }) }); + return entries; + } + async function buildSyncPayload() { + const all = await storage.get(null); + const entries = []; + if (all.profiles) { + const cleanProfiles = all.profiles.map((p) => { + const { hosts, ...rest } = p; + return rest; + }); + const json = JSON.stringify(cleanProfiles); + entries.push({ key: "profiles", jsonString: json, priority: PRIORITY.P1_PROFILES, size: json.length }); + } + if (all.profileIndex != null) { + const json = JSON.stringify(all.profileIndex); + entries.push({ key: "profileIndex", jsonString: json, priority: PRIORITY.P1_PROFILES, size: json.length }); + } + const settingsKeys = ["autoLockMinutes", "version", "protocol_handler", LOCAL_ENABLED_KEY]; + for (const k of settingsKeys) { + if (all[k] != null) { + const json = JSON.stringify(all[k]); + entries.push({ key: k, jsonString: json, priority: PRIORITY.P2_SETTINGS, size: json.length }); + } + } + for (const k of Object.keys(all)) { + if (k.startsWith("feature:")) { + const json = JSON.stringify(all[k]); + entries.push({ key: k, jsonString: json, priority: PRIORITY.P2_SETTINGS, size: json.length }); + } + } + if (all.apiKeyVault) { + const json = JSON.stringify(all.apiKeyVault); + entries.push({ key: "apiKeyVault", jsonString: json, priority: PRIORITY.P3_APIKEYS, size: json.length }); + } + if (all.vaultDocs && typeof all.vaultDocs === "object") { + const docs = Object.values(all.vaultDocs).sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0)); + for (const doc of docs) { + const docKey = `vaultDoc:${doc.path}`; + const json = JSON.stringify(doc); + entries.push({ key: docKey, jsonString: json, priority: PRIORITY.P4_VAULT, size: json.length }); + } + } + return entries; + } + async function pushToSync() { + if (!api.storage.sync) return; + const enabled = await isSyncEnabled(); + if (!enabled) return; + try { + const entries = await buildSyncPayload(); + entries.sort((a, b) => a.priority - b.priority); + let usedBytes = 0; + let usedItems = 0; + const syncPayload = {}; + const allSyncKeys = []; + let budgetExhausted = false; + for (const entry of entries) { + if (budgetExhausted) break; + const chunks = chunkValue(entry.key, entry.jsonString); + let entrySize = 0; + for (const c of chunks) { + entrySize += c.key.length + (typeof c.value === "string" ? c.value.length : JSON.stringify(c.value).length); + } + if (usedBytes + entrySize > SYNC_QUOTA - 500 || usedItems + chunks.length > MAX_ITEMS - 5) { + if (entry.priority <= PRIORITY.P3_APIKEYS) { + } else { + console.warn(`[SyncManager] Budget exhausted at priority ${entry.priority}, skipping remaining entries`); + budgetExhausted = true; + break; + } + } + for (const c of chunks) { + syncPayload[c.key] = c.value; + allSyncKeys.push(c.key); + } + usedBytes += entrySize; + usedItems += chunks.length; + } + const meta = { + lastWrittenAt: Date.now(), + keys: allSyncKeys + }; + syncPayload[SYNC_META_KEY] = JSON.stringify(meta); + await api.storage.sync.set(syncPayload); + try { + const existing = await api.storage.sync.get(null); + const orphanKeys = Object.keys(existing).filter( + (k) => k !== SYNC_META_KEY && !allSyncKeys.includes(k) + ); + if (orphanKeys.length > 0) { + await api.storage.sync.remove(orphanKeys); + } + } catch { + } + console.log(`[SyncManager] Pushed ${allSyncKeys.length} entries (${usedBytes} bytes) to sync storage`); + } catch (e) { + console.error("[SyncManager] pushToSync error:", e); + } + } + function scheduleSyncPush() { + if (!api.storage.sync) return; + if (pushTimer) clearTimeout(pushTimer); + pushTimer = setTimeout(() => { + pushTimer = null; + pushToSync(); + }, 2e3); + } + async function isSyncEnabled() { + const data = await storage.get({ [LOCAL_ENABLED_KEY]: true }); + return data[LOCAL_ENABLED_KEY]; + } + + // src/utilities/api-key-store.js + var storage2 = api.storage.local; + var STORAGE_KEY = "apiKeyVault"; + var DEFAULT_STORE = { + keys: {}, + syncEnabled: true, + eventId: null, + relayCreatedAt: null, + syncStatus: "synced" + }; + async function getStore() { + const data = await storage2.get({ [STORAGE_KEY]: DEFAULT_STORE }); + return { ...DEFAULT_STORE, ...data[STORAGE_KEY] }; + } + async function setStore(store) { + await storage2.set({ [STORAGE_KEY]: store }); + scheduleSyncPush(); + } + async function getApiKeyStore() { + return getStore(); + } + async function saveApiKey(id, label, secret) { + const store = await getStore(); + const now = Math.floor(Date.now() / 1e3); + const existing = store.keys[id]; + store.keys[id] = { + id, + label, + secret, + createdAt: existing?.createdAt || now, + updatedAt: now, + profileScope: existing?.profileScope ?? null + }; + await setStore(store); + return store.keys[id]; + } + async function deleteApiKey(id) { + const store = await getStore(); + delete store.keys[id]; + await setStore(store); + } + async function listApiKeys() { + const store = await getStore(); + return Object.values(store.keys).sort( + (a, b) => a.label.toLowerCase().localeCompare(b.label.toLowerCase()) + ); + } + async function setSyncEnabled(enabled) { + const store = await getStore(); + store.syncEnabled = enabled; + await setStore(store); + } + async function isSyncEnabled2() { + const store = await getStore(); + return store.syncEnabled; + } + async function updateStoreSyncState(syncStatus, eventId = null, relayCreatedAt = null) { + const store = await getStore(); + store.syncStatus = syncStatus; + if (eventId !== null) store.eventId = eventId; + if (relayCreatedAt !== null) store.relayCreatedAt = relayCreatedAt; + await setStore(store); + } + async function exportStore() { + const store = await getStore(); + return store.keys; + } + async function importStore(keys) { + const store = await getStore(); + for (const [id, key] of Object.entries(keys)) { + store.keys[id] = key; + } + await setStore(store); + } + + // src/api-keys/api-keys.js + var state = { + keys: [], + newLabel: "", + newSecret: "", + editingId: null, + editLabel: "", + editSecret: "", + copiedId: null, + revealedId: null, + syncEnabled: true, + globalSyncStatus: "idle", + syncError: "", + saving: false, + toast: "", + relayInfo: { read: [], write: [] } + }; + function $(id) { + return document.getElementById(id); + } + function hasRelays() { + return state.relayInfo.read.length > 0 || state.relayInfo.write.length > 0; + } + function sortedKeys() { + return [...state.keys].sort( + (a, b) => a.label.toLowerCase().localeCompare(b.label.toLowerCase()) + ); + } + function maskSecret(secret) { + if (!secret) return ""; + if (secret.length <= 8) return "\u2022".repeat(secret.length); + return secret.slice(0, 4) + "\u2022".repeat(4) + secret.slice(-4); + } + function showToast(msg) { + state.toast = msg; + render(); + setTimeout(() => { + state.toast = ""; + render(); + }, 2e3); + } + function syncStatusClass(status) { + if (status === "idle") return "bg-green-500"; + if (status === "syncing") return "bg-yellow-500 animate-pulse"; + return "bg-red-500"; + } + function syncStatusText() { + if (state.globalSyncStatus === "syncing") return "Syncing..."; + if (state.globalSyncStatus === "error") return state.syncError; + return state.syncEnabled ? "Synced" : "Local only"; + } + function render() { + const syncDot = $("sync-dot"); + const syncText = $("sync-text"); + const syncBtn = $("sync-btn"); + const syncToggle = $("sync-toggle"); + const keyCount = $("key-count"); + if (syncDot) syncDot.className = `inline-block w-3 h-3 rounded-full ${syncStatusClass(state.globalSyncStatus)}`; + if (syncText) syncText.textContent = syncStatusText(); + if (syncBtn) syncBtn.disabled = state.globalSyncStatus === "syncing" || !hasRelays() || !state.syncEnabled; + if (syncToggle) syncToggle.checked = state.syncEnabled; + if (keyCount) keyCount.textContent = state.keys.length + " key" + (state.keys.length !== 1 ? "s" : ""); + const keyTableContainer = $("key-table-container"); + const noKeysMsg = $("no-keys"); + const keyTableBody = $("key-table-body"); + if (keyTableContainer) keyTableContainer.style.display = state.keys.length > 0 ? "block" : "none"; + if (noKeysMsg) noKeysMsg.style.display = state.keys.length === 0 ? "block" : "none"; + if (keyTableBody) { + const sorted = sortedKeys(); + keyTableBody.innerHTML = sorted.map((key) => { + if (state.editingId === key.id) { + return ` @@ -15,8 +496,8 @@ class="input text-xs font-mono w-full" autocomplete="off" spellcheck="false" - data-edit-secret="${i.id}" - value="${X(n.editSecret)}" + data-edit-secret="${key.id}" + value="${escapeAttr(state.editSecret)}" /> @@ -24,17 +505,311 @@ - `;let h=n.revealedId===i.id?N(i.secret):N(ie(i.secret)),Z=n.copiedId===i.id?"Copied!":"Copy";return` + `; + } + const displaySecret = state.revealedId === key.id ? escapeHtml(key.secret) : escapeHtml(maskSecret(key.secret)); + const copyLabel = state.copiedId === key.id ? "Copied!" : "Copy"; + return ` - ${N(i.label)} + ${escapeHtml(key.label)} - ${h} + ${displaySecret} - - + + - `}).join(""),f.querySelectorAll('[data-action="start-edit"]').forEach(i=>{i.addEventListener("click",()=>de(i.dataset.keyId))}),f.querySelectorAll('[data-action="toggle-reveal"]').forEach(i=>{i.addEventListener("click",()=>{n.revealedId=n.revealedId===i.dataset.keyId?null:i.dataset.keyId,p()})}),f.querySelectorAll('[data-action="copy-secret"]').forEach(i=>{i.addEventListener("click",()=>fe(i.dataset.keyId))}),f.querySelectorAll('[data-action="delete-key"]').forEach(i=>{i.addEventListener("click",()=>ye(i.dataset.keyId))}),f.querySelectorAll('[data-action="save-edit"]').forEach(i=>{i.addEventListener("click",$)}),f.querySelectorAll('[data-action="cancel-edit"]').forEach(i=>{i.addEventListener("click",R)}),f.querySelectorAll("[data-edit-label]").forEach(i=>{i.addEventListener("input",h=>{n.editLabel=h.target.value}),i.addEventListener("keyup",h=>{h.key==="Enter"&&$(),h.key==="Escape"&&R()})}),f.querySelectorAll("[data-edit-secret]").forEach(i=>{i.addEventListener("input",h=>{n.editSecret=h.target.value}),i.addEventListener("keyup",h=>{h.key==="Enter"&&$(),h.key==="Escape"&&R()})})}let S=l("new-label"),g=l("new-secret"),m=l("add-key-btn");S&&document.activeElement!==S&&(S.value=n.newLabel),g&&document.activeElement!==g&&(g.value=n.newSecret),m&&(m.disabled=n.saving||n.newLabel.trim().length===0||n.newSecret.trim().length===0,m.textContent=n.saving?"Saving...":"Save");let b=l("toast");b&&(b.textContent=n.toast,b.style.display=n.toast?"block":"none")}function N(e){let t=document.createElement("div");return t.textContent=e,t.innerHTML}function X(e){return e.replace(/&/g,"&").replace(/"/g,""").replace(//g,">")}async function ue(){let e=n.newLabel.trim(),t=n.newSecret.trim();if(!e||!t)return;n.saving=!0,p();let a=crypto.randomUUID();await j(a,e,t),n.keys=await x(),n.newLabel="",n.newSecret="",n.syncEnabled&&L()&&await M(),n.saving=!1,v("Key added")}function de(e){let t=n.keys.find(a=>a.id===e);t&&(n.editingId=t.id,n.editLabel=t.label,n.editSecret=t.secret,p())}async function $(){if(!n.editingId)return;let e=n.editLabel.trim(),t=n.editSecret.trim();!e||!t||(await j(n.editingId,e,t),n.keys=await x(),n.editingId=null,n.editLabel="",n.editSecret="",n.syncEnabled&&L()&&await M(),v("Key updated"))}function R(){n.editingId=null,n.editLabel="",n.editSecret="",p()}async function ye(e){let t=n.keys.find(a=>a.id===e);t&&confirm(`Delete "${t.label}"?`)&&(await z(e),n.keys=await x(),n.syncEnabled&&L()&&await M(),v("Key deleted"))}async function fe(e){let t=n.keys.find(a=>a.id===e);t&&(await navigator.clipboard.writeText(t.secret),n.copiedId=e,p(),setTimeout(()=>{n.copiedId=null,p()},2e3),setTimeout(()=>{navigator.clipboard.writeText("").catch(()=>{})},3e4))}async function M(){try{let e=await C(),t=await u.runtime.sendMessage({kind:"apikeys.publish",payload:{keys:e.keys}});return t.success&&await A("synced",t.eventId,t.createdAt),t}catch(e){return await A("local-only"),{success:!1,error:e.message}}}async function U(){n.globalSyncStatus="syncing",n.syncError="",p();try{let e=await u.runtime.sendMessage({kind:"apikeys.fetch"});if(!e.success){n.globalSyncStatus="error",n.syncError=e.error||"Sync failed",p();return}if(e.keys){let t=await C(),a=t.keys;Object.keys(a).length===0?await O(e.keys):(!t.relayCreatedAt||e.createdAt>t.relayCreatedAt)&&await O(e.keys),await A("synced",e.eventId,e.createdAt),n.keys=await x()}n.globalSyncStatus="idle"}catch(e){n.globalSyncStatus="error",n.syncError=e.message||"Sync failed"}p()}async function pe(){await H(n.syncEnabled),n.syncEnabled&&L()&&await U()}async function ge(){let e=await W(),t=JSON.stringify(e,null,2),a=await u.runtime.sendMessage({kind:"apikeys.encrypt",payload:{plainText:t}});if(!a.success){v("Export failed: "+(a.error||"unknown"));return}let s=new Blob([JSON.stringify({encrypted:!0,data:a.cipherText})],{type:"application/json"}),o=URL.createObjectURL(s),c=document.createElement("a");c.href=o,c.download="nostrkey-api-keys-backup.json",c.click(),URL.revokeObjectURL(o),v("Exported")}async function be(e){let t=e.target.files?.[0];if(t){try{let a=await t.text(),s=JSON.parse(a),o;if(s.encrypted&&s.data){let c=await u.runtime.sendMessage({kind:"apikeys.decrypt",payload:{cipherText:s.data}});if(!c.success){v("Decrypt failed: "+(c.error||"unknown"));return}o=JSON.parse(c.plainText)}else o=s;await O(o),n.keys=await x(),n.syncEnabled&&L()&&await M(),v("Imported "+Object.keys(o).length+" keys")}catch(a){v("Import failed: "+a.message)}e.target.value=""}}function Se(){l("sync-btn")?.addEventListener("click",U),l("add-key-btn")?.addEventListener("click",ue),l("export-btn")?.addEventListener("click",ge),l("import-file")?.addEventListener("change",be),l("close-btn")?.addEventListener("click",()=>window.close()),l("sync-toggle")?.addEventListener("change",e=>{n.syncEnabled=e.target.checked,pe()}),l("new-label")?.addEventListener("input",e=>{n.newLabel=e.target.value,p()}),l("new-secret")?.addEventListener("input",e=>{n.newSecret=e.target.value,p()})}async function he(){let e=await u.runtime.sendMessage({kind:"isEncrypted"}),t=l("vault-locked-gate"),a=l("vault-main-content");if(!e){t&&(t.style.display="block"),a&&(a.style.display="none"),l("gate-security-btn")?.addEventListener("click",()=>{let o=u.runtime.getURL("security/security.html");window.open(o,"nostrkey-options")});return}t&&(t.style.display="none"),a&&(a.style.display="block");let s=await u.runtime.sendMessage({kind:"vault.getRelays"});n.relayInfo=s||{read:[],write:[]},n.syncEnabled=await G(),n.keys=await x(),Se(),p(),n.syncEnabled&&L()&&await U()}document.addEventListener("DOMContentLoaded",he);})(); + `; + }).join(""); + keyTableBody.querySelectorAll('[data-action="start-edit"]').forEach((el) => { + el.addEventListener("click", () => startEdit(el.dataset.keyId)); + }); + keyTableBody.querySelectorAll('[data-action="toggle-reveal"]').forEach((el) => { + el.addEventListener("click", () => { + state.revealedId = state.revealedId === el.dataset.keyId ? null : el.dataset.keyId; + render(); + }); + }); + keyTableBody.querySelectorAll('[data-action="copy-secret"]').forEach((el) => { + el.addEventListener("click", () => copySecret(el.dataset.keyId)); + }); + keyTableBody.querySelectorAll('[data-action="delete-key"]').forEach((el) => { + el.addEventListener("click", () => deleteKey(el.dataset.keyId)); + }); + keyTableBody.querySelectorAll('[data-action="save-edit"]').forEach((el) => { + el.addEventListener("click", saveEdit); + }); + keyTableBody.querySelectorAll('[data-action="cancel-edit"]').forEach((el) => { + el.addEventListener("click", cancelEdit); + }); + keyTableBody.querySelectorAll("[data-edit-label]").forEach((el) => { + el.addEventListener("input", (e) => { + state.editLabel = e.target.value; + }); + el.addEventListener("keyup", (e) => { + if (e.key === "Enter") saveEdit(); + if (e.key === "Escape") cancelEdit(); + }); + }); + keyTableBody.querySelectorAll("[data-edit-secret]").forEach((el) => { + el.addEventListener("input", (e) => { + state.editSecret = e.target.value; + }); + el.addEventListener("keyup", (e) => { + if (e.key === "Enter") saveEdit(); + if (e.key === "Escape") cancelEdit(); + }); + }); + } + const newLabelInput = $("new-label"); + const newSecretInput = $("new-secret"); + const addKeyBtn = $("add-key-btn"); + if (newLabelInput && document.activeElement !== newLabelInput) newLabelInput.value = state.newLabel; + if (newSecretInput && document.activeElement !== newSecretInput) newSecretInput.value = state.newSecret; + if (addKeyBtn) { + addKeyBtn.disabled = state.saving || state.newLabel.trim().length === 0 || state.newSecret.trim().length === 0; + addKeyBtn.textContent = state.saving ? "Saving..." : "Save"; + } + const toast = $("toast"); + if (toast) { + toast.textContent = state.toast; + toast.style.display = state.toast ? "block" : "none"; + } + } + function escapeHtml(str) { + const div = document.createElement("div"); + div.textContent = str; + return div.innerHTML; + } + function escapeAttr(str) { + return str.replace(/&/g, "&").replace(/"/g, """).replace(//g, ">"); + } + async function addKey() { + const label = state.newLabel.trim(); + const secret = state.newSecret.trim(); + if (!label || !secret) return; + state.saving = true; + render(); + const id = crypto.randomUUID(); + await saveApiKey(id, label, secret); + state.keys = await listApiKeys(); + state.newLabel = ""; + state.newSecret = ""; + if (state.syncEnabled && hasRelays()) { + await publishToRelay(); + } + state.saving = false; + showToast("Key added"); + } + function startEdit(id) { + const key = state.keys.find((k) => k.id === id); + if (!key) return; + state.editingId = key.id; + state.editLabel = key.label; + state.editSecret = key.secret; + render(); + } + async function saveEdit() { + if (!state.editingId) return; + const label = state.editLabel.trim(); + const secret = state.editSecret.trim(); + if (!label || !secret) return; + await saveApiKey(state.editingId, label, secret); + state.keys = await listApiKeys(); + state.editingId = null; + state.editLabel = ""; + state.editSecret = ""; + if (state.syncEnabled && hasRelays()) { + await publishToRelay(); + } + showToast("Key updated"); + } + function cancelEdit() { + state.editingId = null; + state.editLabel = ""; + state.editSecret = ""; + render(); + } + async function deleteKey(id) { + const key = state.keys.find((k) => k.id === id); + if (!key) return; + if (!confirm(`Delete "${key.label}"?`)) return; + await deleteApiKey(id); + state.keys = await listApiKeys(); + if (state.syncEnabled && hasRelays()) { + await publishToRelay(); + } + showToast("Key deleted"); + } + async function copySecret(id) { + const key = state.keys.find((k) => k.id === id); + if (!key) return; + await navigator.clipboard.writeText(key.secret); + state.copiedId = id; + render(); + setTimeout(() => { + state.copiedId = null; + render(); + }, 2e3); + setTimeout(() => { + navigator.clipboard.writeText("").catch(() => { + }); + }, 3e4); + } + async function publishToRelay() { + try { + const store = await getApiKeyStore(); + const result = await api.runtime.sendMessage({ + kind: "apikeys.publish", + payload: { keys: store.keys } + }); + if (result.success) { + await updateStoreSyncState("synced", result.eventId, result.createdAt); + } + return result; + } catch (e) { + await updateStoreSyncState("local-only"); + return { success: false, error: e.message }; + } + } + async function syncAll() { + state.globalSyncStatus = "syncing"; + state.syncError = ""; + render(); + try { + const result = await api.runtime.sendMessage({ kind: "apikeys.fetch" }); + if (!result.success) { + state.globalSyncStatus = "error"; + state.syncError = result.error || "Sync failed"; + render(); + return; + } + if (result.keys) { + const store = await getApiKeyStore(); + const localKeys = store.keys; + const localCount = Object.keys(localKeys).length; + if (localCount === 0) { + await importStore(result.keys); + } else if (!store.relayCreatedAt || result.createdAt > store.relayCreatedAt) { + await importStore(result.keys); + } + await updateStoreSyncState("synced", result.eventId, result.createdAt); + state.keys = await listApiKeys(); + } + state.globalSyncStatus = "idle"; + } catch (e) { + state.globalSyncStatus = "error"; + state.syncError = e.message || "Sync failed"; + } + render(); + } + async function toggleSync() { + await setSyncEnabled(state.syncEnabled); + if (state.syncEnabled && hasRelays()) { + await syncAll(); + } + } + async function exportKeys() { + const keys = await exportStore(); + const plainText = JSON.stringify(keys, null, 2); + const result = await api.runtime.sendMessage({ + kind: "apikeys.encrypt", + payload: { plainText } + }); + if (!result.success) { + showToast("Export failed: " + (result.error || "unknown")); + return; + } + const blob = new Blob( + [JSON.stringify({ encrypted: true, data: result.cipherText })], + { type: "application/json" } + ); + const url = URL.createObjectURL(blob); + const a = document.createElement("a"); + a.href = url; + a.download = "nostrkey-api-keys-backup.json"; + a.click(); + URL.revokeObjectURL(url); + showToast("Exported"); + } + async function importKeys(event) { + const file = event.target.files?.[0]; + if (!file) return; + try { + const text = await file.text(); + const parsed = JSON.parse(text); + let keys; + if (parsed.encrypted && parsed.data) { + const result = await api.runtime.sendMessage({ + kind: "apikeys.decrypt", + payload: { cipherText: parsed.data } + }); + if (!result.success) { + showToast("Decrypt failed: " + (result.error || "unknown")); + return; + } + keys = JSON.parse(result.plainText); + } else { + keys = parsed; + } + await importStore(keys); + state.keys = await listApiKeys(); + if (state.syncEnabled && hasRelays()) { + await publishToRelay(); + } + showToast("Imported " + Object.keys(keys).length + " keys"); + } catch (e) { + showToast("Import failed: " + e.message); + } + event.target.value = ""; + } + function bindEvents() { + $("sync-btn")?.addEventListener("click", syncAll); + $("add-key-btn")?.addEventListener("click", addKey); + $("export-btn")?.addEventListener("click", exportKeys); + $("import-file")?.addEventListener("change", importKeys); + $("close-btn")?.addEventListener("click", () => window.close()); + $("sync-toggle")?.addEventListener("change", (e) => { + state.syncEnabled = e.target.checked; + toggleSync(); + }); + $("new-label")?.addEventListener("input", (e) => { + state.newLabel = e.target.value; + render(); + }); + $("new-secret")?.addEventListener("input", (e) => { + state.newSecret = e.target.value; + render(); + }); + } + async function init() { + const isEncrypted = await api.runtime.sendMessage({ kind: "isEncrypted" }); + const gate = $("vault-locked-gate"); + const main = $("vault-main-content"); + if (!isEncrypted) { + if (gate) gate.style.display = "block"; + if (main) main.style.display = "none"; + $("gate-security-btn")?.addEventListener("click", () => { + const url = api.runtime.getURL("security/security.html"); + window.open(url, "nostrkey-options"); + }); + return; + } + if (gate) gate.style.display = "none"; + if (main) main.style.display = "block"; + const relays = await api.runtime.sendMessage({ kind: "vault.getRelays" }); + state.relayInfo = relays || { read: [], write: [] }; + state.syncEnabled = await isSyncEnabled2(); + state.keys = await listApiKeys(); + bindEvents(); + render(); + if (state.syncEnabled && hasRelays()) { + await syncAll(); + } + } + document.addEventListener("DOMContentLoaded", init); +})(); +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/utilities/browser-polyfill.js", "../../../src/utilities/sync-manager.js", "../../../src/utilities/api-key-store.js", "../../../src/api-keys/api-keys.js"],
  "sourcesContent": ["/**\n * Browser API compatibility layer for Chrome / Safari / Firefox.\n *\n * Safari and Firefox expose `browser.*` (Promise-based, WebExtension standard).\n * Chrome exposes `chrome.*` (callback-based historically, but MV3 supports\n * promises on most APIs). In a service-worker context `browser` is undefined\n * on Chrome, so we normalise everything here.\n *\n * Usage:  import { api } from './utilities/browser-polyfill';\n *         api.runtime.sendMessage(...)\n *\n * The exported `api` object mirrors the subset of the WebExtension API that\n * NostrKey actually uses, with every method returning a Promise.\n */\n\n// Detect which global namespace is available.\nconst _browser =\n    typeof browser !== 'undefined' ? browser :\n    typeof chrome  !== 'undefined' ? chrome  :\n    null;\n\nif (!_browser) {\n    throw new Error('browser-polyfill: No extension API namespace found (neither browser nor chrome).');\n}\n\n/**\n * True when running on Chrome (or any Chromium-based browser that only\n * exposes the `chrome` namespace).\n */\nconst isChrome = typeof browser === 'undefined' && typeof chrome !== 'undefined';\n\n/**\n * Wrap a Chrome callback-style method so it returns a Promise.\n * If the method already returns a promise (MV3) we just pass through.\n */\nfunction promisify(context, method) {\n    return (...args) => {\n        // MV3 Chrome APIs return promises when no callback is supplied.\n        // We try the promise path first; if the runtime signals an error\n        // via chrome.runtime.lastError inside a callback we catch that too.\n        try {\n            const result = method.apply(context, args);\n            if (result && typeof result.then === 'function') {\n                return result;\n            }\n        } catch (_) {\n            // fall through to callback wrapping\n        }\n\n        return new Promise((resolve, reject) => {\n            method.apply(context, [\n                ...args,\n                (...cbArgs) => {\n                    if (_browser.runtime && _browser.runtime.lastError) {\n                        reject(new Error(_browser.runtime.lastError.message));\n                    } else {\n                        resolve(cbArgs.length <= 1 ? cbArgs[0] : cbArgs);\n                    }\n                },\n            ]);\n        });\n    };\n}\n\n// ---------------------------------------------------------------------------\n// Build the unified `api` object\n// ---------------------------------------------------------------------------\n\nconst api = {};\n\n// --- runtime ---------------------------------------------------------------\napi.runtime = {\n    /**\n     * sendMessage \u2013 always returns a Promise.\n     */\n    sendMessage(...args) {\n        if (!isChrome) {\n            return _browser.runtime.sendMessage(...args);\n        }\n        return promisify(_browser.runtime, _browser.runtime.sendMessage)(...args);\n    },\n\n    /**\n     * onMessage \u2013 thin wrapper so callers use a consistent reference.\n     * The listener signature is (message, sender, sendResponse).\n     * On Chrome the listener can return `true` to keep the channel open,\n     * or return a Promise (MV3).  Safari / Firefox expect a Promise return.\n     */\n    onMessage: _browser.runtime.onMessage,\n\n    /**\n     * getURL \u2013 synchronous on all browsers.\n     */\n    getURL(path) {\n        return _browser.runtime.getURL(path);\n    },\n\n    /**\n     * openOptionsPage\n     */\n    openOptionsPage() {\n        if (!isChrome) {\n            return _browser.runtime.openOptionsPage();\n        }\n        return promisify(_browser.runtime, _browser.runtime.openOptionsPage)();\n    },\n\n    /**\n     * Expose the id for convenience.\n     */\n    get id() {\n        return _browser.runtime.id;\n    },\n};\n\n// --- storage.local ---------------------------------------------------------\napi.storage = {\n    local: {\n        get(...args) {\n            if (!isChrome) {\n                return _browser.storage.local.get(...args);\n            }\n            return promisify(_browser.storage.local, _browser.storage.local.get)(...args);\n        },\n        set(...args) {\n            if (!isChrome) {\n                return _browser.storage.local.set(...args);\n            }\n            return promisify(_browser.storage.local, _browser.storage.local.set)(...args);\n        },\n        clear(...args) {\n            if (!isChrome) {\n                return _browser.storage.local.clear(...args);\n            }\n            return promisify(_browser.storage.local, _browser.storage.local.clear)(...args);\n        },\n        remove(...args) {\n            if (!isChrome) {\n                return _browser.storage.local.remove(...args);\n            }\n            return promisify(_browser.storage.local, _browser.storage.local.remove)(...args);\n        },\n    },\n\n    // --- storage.sync ----------------------------------------------------------\n    // Null when the browser doesn't support sync (older Safari, etc.)\n    sync: _browser.storage?.sync ? {\n        get(...args) {\n            if (!isChrome) {\n                return _browser.storage.sync.get(...args);\n            }\n            return promisify(_browser.storage.sync, _browser.storage.sync.get)(...args);\n        },\n        set(...args) {\n            if (!isChrome) {\n                return _browser.storage.sync.set(...args);\n            }\n            return promisify(_browser.storage.sync, _browser.storage.sync.set)(...args);\n        },\n        remove(...args) {\n            if (!isChrome) {\n                return _browser.storage.sync.remove(...args);\n            }\n            return promisify(_browser.storage.sync, _browser.storage.sync.remove)(...args);\n        },\n        clear(...args) {\n            if (!isChrome) {\n                return _browser.storage.sync.clear(...args);\n            }\n            return promisify(_browser.storage.sync, _browser.storage.sync.clear)(...args);\n        },\n        getBytesInUse(...args) {\n            if (!_browser.storage.sync.getBytesInUse) {\n                // Safari doesn't support getBytesInUse \u2014 return 0\n                return Promise.resolve(0);\n            }\n            if (!isChrome) {\n                return _browser.storage.sync.getBytesInUse(...args);\n            }\n            return promisify(_browser.storage.sync, _browser.storage.sync.getBytesInUse)(...args);\n        },\n    } : null,\n\n    // --- storage.onChanged -----------------------------------------------------\n    onChanged: _browser.storage?.onChanged || null,\n};\n\n// --- tabs ------------------------------------------------------------------\napi.tabs = {\n    create(...args) {\n        if (!isChrome) {\n            return _browser.tabs.create(...args);\n        }\n        return promisify(_browser.tabs, _browser.tabs.create)(...args);\n    },\n    query(...args) {\n        if (!isChrome) {\n            return _browser.tabs.query(...args);\n        }\n        return promisify(_browser.tabs, _browser.tabs.query)(...args);\n    },\n    remove(...args) {\n        if (!isChrome) {\n            return _browser.tabs.remove(...args);\n        }\n        return promisify(_browser.tabs, _browser.tabs.remove)(...args);\n    },\n    update(...args) {\n        if (!isChrome) {\n            return _browser.tabs.update(...args);\n        }\n        return promisify(_browser.tabs, _browser.tabs.update)(...args);\n    },\n    get(...args) {\n        if (!isChrome) {\n            return _browser.tabs.get(...args);\n        }\n        return promisify(_browser.tabs, _browser.tabs.get)(...args);\n    },\n    getCurrent(...args) {\n        if (!isChrome) {\n            return _browser.tabs.getCurrent(...args);\n        }\n        return promisify(_browser.tabs, _browser.tabs.getCurrent)(...args);\n    },\n    sendMessage(...args) {\n        if (!isChrome) {\n            return _browser.tabs.sendMessage(...args);\n        }\n        return promisify(_browser.tabs, _browser.tabs.sendMessage)(...args);\n    },\n};\n\n// --- alarms ----------------------------------------------------------------\n// chrome.alarms survives MV3 service-worker eviction; setTimeout does not.\napi.alarms = _browser.alarms ? {\n    create(...args) {\n        // alarms.create is synchronous on Chrome, returns Promise on Firefox/Safari\n        const result = _browser.alarms.create(...args);\n        return result && typeof result.then === 'function' ? result : Promise.resolve();\n    },\n    clear(...args) {\n        if (!isChrome) {\n            return _browser.alarms.clear(...args);\n        }\n        return promisify(_browser.alarms, _browser.alarms.clear)(...args);\n    },\n    onAlarm: _browser.alarms.onAlarm,\n} : null;\n\nexport { api, isChrome };\n", "/**\n * Sync Manager \u2014 Platform sync via storage.sync (Chrome \u2192 Google, Safari \u2192 iCloud)\n *\n * Architecture:\n *   Write: app \u2192 storage.local \u2192 scheduleSyncPush() \u2192 storage.sync\n *   Read:  pullFromSync() on startup \u2192 merge into storage.local\n *   Listen: storage.onChanged(\"sync\") \u2192 merge remote changes into local\n *\n * storage.local remains the source of truth. storage.sync is a best-effort mirror.\n */\n\nimport { api } from './browser-polyfill';\n\n// ---------------------------------------------------------------------------\n// Constants\n// ---------------------------------------------------------------------------\nconst SYNC_QUOTA = 102_400;       // 100 KB total\nconst MAX_ITEM = 8_192;           // 8 KB per item\nconst MAX_ITEMS = 512;\nconst CHUNK_PREFIX = '_chunk:';\nconst SYNC_META_KEY = '_sync_meta';\nconst LOCAL_ENABLED_KEY = 'platformSyncEnabled';\n\n// Keys that should never be synced\nconst EXCLUDED_KEYS = [\n    'bunkerSessions',\n    'ignoreInstallHook',\n    'passwordHash',\n    'passwordSalt',\n];\n\n// Priority tiers for budget allocation\nconst PRIORITY = {\n    P1_PROFILES: 1,\n    P2_SETTINGS: 2,\n    P3_APIKEYS: 3,\n    P4_VAULT: 4,\n};\n\nconst storage = api.storage.local;\nlet pushTimer = null;\n\n// ---------------------------------------------------------------------------\n// Chunking helpers\n// ---------------------------------------------------------------------------\n\n/**\n * Split a JSON-serialised value into <=8KB chunks.\n * Returns an array of { key, value } pairs ready for storage.sync.set().\n */\nfunction chunkValue(key, jsonString) {\n    const chunks = [];\n    for (let i = 0; i < jsonString.length; i += MAX_ITEM - 100) {\n        // Reserve ~100 bytes for the key overhead in the stored item\n        chunks.push(jsonString.slice(i, i + MAX_ITEM - 100));\n    }\n    if (chunks.length === 1) {\n        // Fits in a single item \u2014 store directly\n        return [{ key, value: jsonString }];\n    }\n    // Multiple chunks\n    const entries = [];\n    for (let i = 0; i < chunks.length; i++) {\n        entries.push({ key: `${CHUNK_PREFIX}${key}:${i}`, value: chunks[i] });\n    }\n    // Store a metadata entry so we know how many chunks there are\n    entries.push({ key, value: JSON.stringify({ __chunked: true, count: chunks.length }) });\n    return entries;\n}\n\n/**\n * Reassemble chunked data from a sync data object.\n * Returns the parsed JSON value, or null on error.\n */\nfunction reassembleFromSyncData(key, syncData) {\n    try {\n        const meta = typeof syncData[key] === 'string' ? JSON.parse(syncData[key]) : syncData[key];\n        if (!meta || !meta.__chunked) {\n            // Not chunked \u2014 parse directly\n            return typeof syncData[key] === 'string' ? JSON.parse(syncData[key]) : syncData[key];\n        }\n        let combined = '';\n        for (let i = 0; i < meta.count; i++) {\n            const chunkKey = `${CHUNK_PREFIX}${key}:${i}`;\n            if (syncData[chunkKey] == null) return null;\n            combined += syncData[chunkKey];\n        }\n        return JSON.parse(combined);\n    } catch {\n        return null;\n    }\n}\n\n// ---------------------------------------------------------------------------\n// Build sync payload\n// ---------------------------------------------------------------------------\n\n/**\n * Read all local data and build a prioritised list of entries to sync.\n * Returns { entries: [{ key, jsonString, priority, size }], totalSize }\n */\nasync function buildSyncPayload() {\n    const all = await storage.get(null);\n    const entries = [];\n\n    // P1: Profiles (strip `hosts` to save space) + profileIndex\n    if (all.profiles) {\n        const cleanProfiles = all.profiles.map(p => {\n            const { hosts, ...rest } = p;\n            return rest;\n        });\n        const json = JSON.stringify(cleanProfiles);\n        entries.push({ key: 'profiles', jsonString: json, priority: PRIORITY.P1_PROFILES, size: json.length });\n    }\n    if (all.profileIndex != null) {\n        const json = JSON.stringify(all.profileIndex);\n        entries.push({ key: 'profileIndex', jsonString: json, priority: PRIORITY.P1_PROFILES, size: json.length });\n    }\n    // NOTE: `isEncrypted` is intentionally NOT synced. The password verifier\n    // (passwordHash/passwordSalt) is excluded from sync for security, so a device\n    // that received isEncrypted=true with no hash would be permanently locked out\n    // (checkPassword always fails). Encryption state is strictly device-local.\n\n    // P2: Settings\n    const settingsKeys = ['autoLockMinutes', 'version', 'protocol_handler', LOCAL_ENABLED_KEY];\n    for (const k of settingsKeys) {\n        if (all[k] != null) {\n            const json = JSON.stringify(all[k]);\n            entries.push({ key: k, jsonString: json, priority: PRIORITY.P2_SETTINGS, size: json.length });\n        }\n    }\n    // Feature flags\n    for (const k of Object.keys(all)) {\n        if (k.startsWith('feature:')) {\n            const json = JSON.stringify(all[k]);\n            entries.push({ key: k, jsonString: json, priority: PRIORITY.P2_SETTINGS, size: json.length });\n        }\n    }\n\n    // P3: API key vault\n    if (all.apiKeyVault) {\n        const json = JSON.stringify(all.apiKeyVault);\n        entries.push({ key: 'apiKeyVault', jsonString: json, priority: PRIORITY.P3_APIKEYS, size: json.length });\n    }\n\n    // P4: Vault docs (individually, newest first)\n    if (all.vaultDocs && typeof all.vaultDocs === 'object') {\n        const docs = Object.values(all.vaultDocs).sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0));\n        for (const doc of docs) {\n            const docKey = `vaultDoc:${doc.path}`;\n            const json = JSON.stringify(doc);\n            entries.push({ key: docKey, jsonString: json, priority: PRIORITY.P4_VAULT, size: json.length });\n        }\n    }\n\n    return entries;\n}\n\n// ---------------------------------------------------------------------------\n// Push to sync\n// ---------------------------------------------------------------------------\n\nasync function pushToSync() {\n    if (!api.storage.sync) return;\n\n    const enabled = await isSyncEnabled();\n    if (!enabled) return;\n\n    try {\n        const entries = await buildSyncPayload();\n\n        // Sort by priority (ascending = most important first)\n        entries.sort((a, b) => a.priority - b.priority);\n\n        // Build the sync payload respecting budget\n        let usedBytes = 0;\n        let usedItems = 0;\n        const syncPayload = {};\n        const allSyncKeys = [];\n        let budgetExhausted = false;\n\n        for (const entry of entries) {\n            if (budgetExhausted) break;\n\n            const chunks = chunkValue(entry.key, entry.jsonString);\n            let entrySize = 0;\n            for (const c of chunks) {\n                entrySize += c.key.length + (typeof c.value === 'string' ? c.value.length : JSON.stringify(c.value).length);\n            }\n\n            if (usedBytes + entrySize > SYNC_QUOTA - 500 || usedItems + chunks.length > MAX_ITEMS - 5) {\n                if (entry.priority <= PRIORITY.P3_APIKEYS) {\n                    // Critical data \u2014 try anyway, let the API throw if truly over\n                } else {\n                    console.warn(`[SyncManager] Budget exhausted at priority ${entry.priority}, skipping remaining entries`);\n                    budgetExhausted = true;\n                    break;\n                }\n            }\n\n            for (const c of chunks) {\n                syncPayload[c.key] = c.value;\n                allSyncKeys.push(c.key);\n            }\n            usedBytes += entrySize;\n            usedItems += chunks.length;\n        }\n\n        // Add sync metadata\n        const meta = {\n            lastWrittenAt: Date.now(),\n            keys: allSyncKeys,\n        };\n        syncPayload[SYNC_META_KEY] = JSON.stringify(meta);\n\n        // Write to sync storage\n        await api.storage.sync.set(syncPayload);\n\n        // Clean orphaned chunks: read existing sync keys and remove any not in our payload\n        try {\n            const existing = await api.storage.sync.get(null);\n            const orphanKeys = Object.keys(existing).filter(k =>\n                k !== SYNC_META_KEY && !allSyncKeys.includes(k)\n            );\n            if (orphanKeys.length > 0) {\n                await api.storage.sync.remove(orphanKeys);\n            }\n        } catch {\n            // Non-critical cleanup\n        }\n\n        console.log(`[SyncManager] Pushed ${allSyncKeys.length} entries (${usedBytes} bytes) to sync storage`);\n    } catch (e) {\n        console.error('[SyncManager] pushToSync error:', e);\n        // Local storage is unaffected \u2014 graceful degradation\n    }\n}\n\n// ---------------------------------------------------------------------------\n// Pull from sync\n// ---------------------------------------------------------------------------\n\n/**\n * Read all data from sync storage and return as a plain object with\n * reassembled chunked values.\n */\nasync function pullFromSync() {\n    if (!api.storage.sync) return null;\n\n    try {\n        const raw = await api.storage.sync.get(null);\n        if (!raw || Object.keys(raw).length === 0) return null;\n\n        const metaStr = raw[SYNC_META_KEY];\n        if (!metaStr) return null;\n\n        let meta;\n        try { meta = JSON.parse(metaStr); } catch { return null; }\n\n        const result = {};\n        // Collect the non-chunk, non-meta keys\n        const dataKeys = meta.keys.filter(k => !k.startsWith(CHUNK_PREFIX) && k !== SYNC_META_KEY);\n\n        for (const key of dataKeys) {\n            const value = reassembleFromSyncData(key, raw);\n            if (value != null) {\n                result[key] = value;\n            }\n        }\n\n        result._syncMeta = meta;\n        return result;\n    } catch (e) {\n        console.error('[SyncManager] pullFromSync error:', e);\n        return null;\n    }\n}\n\n// ---------------------------------------------------------------------------\n// Merge logic\n// ---------------------------------------------------------------------------\n\n/**\n * Merge sync data into local storage with conflict resolution.\n */\nasync function mergeIntoLocal(syncData) {\n    if (!syncData) return;\n\n    const local = await storage.get(null);\n    const { updates, changed } = computeMergeUpdates(local, syncData);\n\n    if (changed) {\n        await storage.set(updates);\n        console.log('[SyncManager] Merged sync data into local:', Object.keys(updates));\n    }\n}\n\n/**\n * Pure merge: given the current local state and an incoming sync payload,\n * compute the storage updates to apply. No I/O \u2014 exported so the merge rules\n * (fresh-install detection, pubkey-keyed profile matching, encryption-state\n * exclusion) can be regression-tested directly.\n *\n * @returns {{ updates: Object, changed: boolean }}\n */\nexport function computeMergeUpdates(local, syncData) {\n    const updates = {};\n    let changed = false;\n    if (!syncData) return { updates, changed };\n\n    // Detect fresh install: no profiles, or only profile(s) that carry no\n    // identity at all (no private key, no cached pubkey, not a bunker/remote\n    // signer). A bunker profile legitimately has privKey:'' but IS a real\n    // identity \u2014 it must not be treated as a blank install and wiped.\n    const hasIdentity = (p) =>\n        !!(p.privKey || p.pubKey || p.type === 'bunker' || p.bunkerUrl || p.remotePubkey);\n    const isFresh = !local.profiles ||\n        local.profiles.length === 0 ||\n        !local.profiles.some(hasIdentity);\n\n    // --- Profiles (P1) ---\n    if (syncData.profiles) {\n        if (isFresh) {\n            // Fresh install \u2014 adopt sync profiles entirely\n            updates.profiles = syncData.profiles;\n            changed = true;\n        } else if (local.profiles) {\n            // Match profiles by pubkey (stable identity), NOT array index \u2014\n            // reordering or inserting a profile on one device must never cause\n            // one identity's key material to overwrite an unrelated profile.\n            const merged = [...local.profiles];\n            const indexByPubkey = new Map();\n            merged.forEach((p, i) => { if (p.pubKey) indexByPubkey.set(p.pubKey, i); });\n\n            for (const syncProfile of syncData.profiles) {\n                const localIdx = syncProfile.pubKey != null\n                    ? indexByPubkey.get(syncProfile.pubKey)\n                    : undefined;\n\n                if (localIdx === undefined) {\n                    // No local profile with this pubkey \u2014 it's a new one from sync.\n                    // (Profiles without a pubkey can't be safely matched, so we add\n                    // rather than risk clobbering an unrelated local profile.)\n                    merged.push(syncProfile);\n                    if (syncProfile.pubKey) indexByPubkey.set(syncProfile.pubKey, merged.length - 1);\n                    changed = true;\n                } else {\n                    const localProfile = merged[localIdx];\n                    const syncTime = syncProfile.updatedAt || 0;\n                    const localTime = localProfile.updatedAt || 0;\n                    if (syncTime > localTime) {\n                        // Sync is newer \u2014 merge but preserve local hosts\n                        merged[localIdx] = { ...syncProfile, hosts: localProfile.hosts || {} };\n                        changed = true;\n                    }\n                }\n            }\n            if (changed) updates.profiles = merged;\n        }\n    }\n\n    // --- Profile index (P1) ---\n    if (syncData.profileIndex != null && isFresh) {\n        updates.profileIndex = syncData.profileIndex;\n        changed = true;\n    }\n\n    // --- Encryption state (P1) ---\n    // Intentionally NOT merged from sync. See buildSyncPayload(): the password\n    // verifier is never synced, so trusting a synced isEncrypted=true would lock\n    // the user out permanently. Encryption state stays device-local.\n\n    // --- Settings (P2) \u2014 last-write-wins ---\n    const syncMeta = syncData._syncMeta || {};\n    const settingsKeys = ['autoLockMinutes', 'version', 'protocol_handler', LOCAL_ENABLED_KEY];\n    for (const key of settingsKeys) {\n        if (syncData[key] != null && syncData[key] !== local[key]) {\n            // For version, only accept higher\n            if (key === 'version' && local.version && syncData.version <= local.version) continue;\n            updates[key] = syncData[key];\n            changed = true;\n        }\n    }\n    // Feature flags\n    for (const key of Object.keys(syncData)) {\n        if (key.startsWith('feature:') && syncData[key] !== local[key]) {\n            updates[key] = syncData[key];\n            changed = true;\n        }\n    }\n\n    // --- API Key Vault (P3) ---\n    if (syncData.apiKeyVault) {\n        if (!local.apiKeyVault || isFresh) {\n            updates.apiKeyVault = syncData.apiKeyVault;\n            changed = true;\n        } else {\n            // Merge individual keys by updatedAt\n            const localKeys = local.apiKeyVault.keys || {};\n            const syncKeys = syncData.apiKeyVault.keys || {};\n            const merged = { ...localKeys };\n            for (const [id, syncKey] of Object.entries(syncKeys)) {\n                const localKey = merged[id];\n                if (!localKey || (syncKey.updatedAt || 0) > (localKey.updatedAt || 0)) {\n                    merged[id] = syncKey;\n                    changed = true;\n                }\n            }\n            if (changed) {\n                updates.apiKeyVault = { ...local.apiKeyVault, keys: merged };\n            }\n        }\n    }\n\n    // --- Vault docs (P4) ---\n    const localDocs = local.vaultDocs || {};\n    let docsChanged = false;\n    const mergedDocs = { ...localDocs };\n    for (const key of Object.keys(syncData)) {\n        if (!key.startsWith('vaultDoc:')) continue;\n        const doc = syncData[key];\n        if (!doc || !doc.path) continue;\n        const localDoc = mergedDocs[doc.path];\n        if (!localDoc || (doc.updatedAt || 0) > (localDoc.updatedAt || 0)) {\n            mergedDocs[doc.path] = doc;\n            docsChanged = true;\n        }\n    }\n    if (docsChanged) {\n        updates.vaultDocs = mergedDocs;\n        changed = true;\n    }\n\n    return { updates, changed };\n}\n\n// ---------------------------------------------------------------------------\n// Debounced push\n// ---------------------------------------------------------------------------\n\n/**\n * Schedule a sync push with a 2-second debounce.\n * Exported for use by stores and the storage interceptor.\n */\nexport function scheduleSyncPush() {\n    if (!api.storage.sync) return;\n    if (pushTimer) clearTimeout(pushTimer);\n    pushTimer = setTimeout(() => {\n        pushTimer = null;\n        pushToSync();\n    }, 2000);\n}\n\n// ---------------------------------------------------------------------------\n// Enable / disable\n// ---------------------------------------------------------------------------\n\nexport async function isSyncEnabled() {\n    const data = await storage.get({ [LOCAL_ENABLED_KEY]: true });\n    return data[LOCAL_ENABLED_KEY];\n}\n\nexport async function setSyncEnabled(enabled) {\n    await storage.set({ [LOCAL_ENABLED_KEY]: enabled });\n    if (enabled) {\n        scheduleSyncPush();\n    }\n}\n\n// ---------------------------------------------------------------------------\n// Initialisation\n// ---------------------------------------------------------------------------\n\n/**\n * Called once on startup (from background.js).\n * Pulls from sync, merges, then listens for remote changes.\n */\nexport async function initSync() {\n    if (!api.storage.sync) {\n        console.log('[SyncManager] storage.sync not available \u2014 skipping');\n        return;\n    }\n\n    const enabled = await isSyncEnabled();\n    if (!enabled) {\n        console.log('[SyncManager] Platform sync disabled');\n        return;\n    }\n\n    // Pull + merge\n    try {\n        const syncData = await pullFromSync();\n        if (syncData) {\n            await mergeIntoLocal(syncData);\n            console.log('[SyncManager] Initial pull+merge complete');\n        } else {\n            console.log('[SyncManager] No sync data found \u2014 fresh sync');\n        }\n    } catch (e) {\n        console.error('[SyncManager] Initial pull failed:', e);\n    }\n\n    // Listen for remote changes\n    if (api.storage.onChanged) {\n        api.storage.onChanged.addListener((changes, areaName) => {\n            if (areaName !== 'sync') return;\n            console.log('[SyncManager] Remote sync change detected');\n            // Re-pull and merge the full sync data to handle chunked values correctly\n            pullFromSync().then(syncData => {\n                if (syncData) mergeIntoLocal(syncData);\n            }).catch(e => {\n                console.error('[SyncManager] Remote merge error:', e);\n            });\n        });\n    }\n\n    // Do an initial push so local data is mirrored\n    scheduleSyncPush();\n}\n", "/**\n * API Key Store \u2014 Local cache for encrypted API keys\n *\n * Storage schema in browser.storage.local:\n *   apiKeyVault: {\n *     keys: {\n *       \"<uuid>\": { id, label, secret, createdAt, updatedAt, profileScope }\n *     },\n *     syncEnabled: true,\n *     eventId: null,\n *     relayCreatedAt: null,\n *     syncStatus: \"synced\"    // synced | local-only | conflict\n *   }\n *\n * profileScope: null (all profiles) | number[] (specific profile indices)\n */\n\nimport { api } from './browser-polyfill';\nimport { scheduleSyncPush } from './sync-manager';\n\nconst storage = api.storage.local;\nconst STORAGE_KEY = 'apiKeyVault';\n\nconst DEFAULT_STORE = {\n    keys: {},\n    syncEnabled: true,\n    eventId: null,\n    relayCreatedAt: null,\n    syncStatus: 'synced',\n};\n\nasync function getStore() {\n    const data = await storage.get({ [STORAGE_KEY]: DEFAULT_STORE });\n    return { ...DEFAULT_STORE, ...data[STORAGE_KEY] };\n}\n\nasync function setStore(store) {\n    await storage.set({ [STORAGE_KEY]: store });\n    scheduleSyncPush();\n}\n\n/**\n * Get the full API key store object.\n */\nexport async function getApiKeyStore() {\n    return getStore();\n}\n\n/**\n * Get a single API key by id.\n * @param {string} id\n * @returns {Promise<Object|null>}\n */\nexport async function getApiKey(id) {\n    const store = await getStore();\n    return store.keys[id] || null;\n}\n\n/**\n * Upsert an API key. Creates if new, updates if existing.\n * @param {string} id - UUID\n * @param {string} label\n * @param {string} secret\n */\nexport async function saveApiKey(id, label, secret) {\n    const store = await getStore();\n    const now = Math.floor(Date.now() / 1000);\n    const existing = store.keys[id];\n    store.keys[id] = {\n        id,\n        label,\n        secret,\n        createdAt: existing?.createdAt || now,\n        updatedAt: now,\n        profileScope: existing?.profileScope ?? null,\n    };\n    await setStore(store);\n    return store.keys[id];\n}\n\n/**\n * Delete an API key by id.\n */\nexport async function deleteApiKey(id) {\n    const store = await getStore();\n    delete store.keys[id];\n    await setStore(store);\n}\n\n/**\n * List all API keys sorted by label (case-insensitive).\n * @returns {Promise<Array>}\n */\nexport async function listApiKeys() {\n    const store = await getStore();\n    return Object.values(store.keys).sort((a, b) =>\n        a.label.toLowerCase().localeCompare(b.label.toLowerCase()),\n    );\n}\n\n/**\n * Set the relay sync toggle.\n */\nexport async function setSyncEnabled(enabled) {\n    const store = await getStore();\n    store.syncEnabled = enabled;\n    await setStore(store);\n}\n\n/**\n * Check if relay sync is enabled.\n */\nexport async function isSyncEnabled() {\n    const store = await getStore();\n    return store.syncEnabled;\n}\n\n/**\n * Update sync state after a relay operation.\n */\nexport async function updateStoreSyncState(syncStatus, eventId = null, relayCreatedAt = null) {\n    const store = await getStore();\n    store.syncStatus = syncStatus;\n    if (eventId !== null) store.eventId = eventId;\n    if (relayCreatedAt !== null) store.relayCreatedAt = relayCreatedAt;\n    await setStore(store);\n}\n\n/**\n * Export the keys object (for encrypted backup).\n * @returns {Promise<Object>} Map of id -> key data\n */\nexport async function exportStore() {\n    const store = await getStore();\n    return store.keys;\n}\n\n/**\n * Import keys into the store (merge \u2014 existing keys with same id are overwritten).\n * @param {Object} keys - Map of id -> { id, label, secret, createdAt, updatedAt }\n */\nexport async function importStore(keys) {\n    const store = await getStore();\n    for (const [id, key] of Object.entries(keys)) {\n        store.keys[id] = key;\n    }\n    await setStore(store);\n}\n", "import { api } from '../utilities/browser-polyfill';\nimport {\n    getApiKeyStore,\n    saveApiKey,\n    deleteApiKey,\n    listApiKeys,\n    setSyncEnabled,\n    isSyncEnabled,\n    updateStoreSyncState,\n    exportStore,\n    importStore,\n} from '../utilities/api-key-store';\n\nconst state = {\n    keys: [],\n    newLabel: '',\n    newSecret: '',\n    editingId: null,\n    editLabel: '',\n    editSecret: '',\n    copiedId: null,\n    revealedId: null,\n    syncEnabled: true,\n    globalSyncStatus: 'idle',\n    syncError: '',\n    saving: false,\n    toast: '',\n    relayInfo: { read: [], write: [] },\n};\n\nfunction $(id) { return document.getElementById(id); }\n\nfunction hasRelays() {\n    return state.relayInfo.read.length > 0 || state.relayInfo.write.length > 0;\n}\n\nfunction sortedKeys() {\n    return [...state.keys].sort((a, b) =>\n        a.label.toLowerCase().localeCompare(b.label.toLowerCase()),\n    );\n}\n\nfunction maskSecret(secret) {\n    if (!secret) return '';\n    if (secret.length <= 8) return '\\u2022'.repeat(secret.length);\n    return secret.slice(0, 4) + '\\u2022'.repeat(4) + secret.slice(-4);\n}\n\nfunction showToast(msg) {\n    state.toast = msg;\n    render();\n    setTimeout(() => { state.toast = ''; render(); }, 2000);\n}\n\nfunction syncStatusClass(status) {\n    if (status === 'idle') return 'bg-green-500';\n    if (status === 'syncing') return 'bg-yellow-500 animate-pulse';\n    return 'bg-red-500';\n}\n\nfunction syncStatusText() {\n    if (state.globalSyncStatus === 'syncing') return 'Syncing...';\n    if (state.globalSyncStatus === 'error') return state.syncError;\n    return state.syncEnabled ? 'Synced' : 'Local only';\n}\n\n// --- Render ---\n\nfunction render() {\n    // Sync bar\n    const syncDot = $('sync-dot');\n    const syncText = $('sync-text');\n    const syncBtn = $('sync-btn');\n    const syncToggle = $('sync-toggle');\n    const keyCount = $('key-count');\n\n    if (syncDot) syncDot.className = `inline-block w-3 h-3 rounded-full ${syncStatusClass(state.globalSyncStatus)}`;\n    if (syncText) syncText.textContent = syncStatusText();\n    if (syncBtn) syncBtn.disabled = state.globalSyncStatus === 'syncing' || !hasRelays() || !state.syncEnabled;\n    if (syncToggle) syncToggle.checked = state.syncEnabled;\n    if (keyCount) keyCount.textContent = state.keys.length + ' key' + (state.keys.length !== 1 ? 's' : '');\n\n    // Key table\n    const keyTableContainer = $('key-table-container');\n    const noKeysMsg = $('no-keys');\n    const keyTableBody = $('key-table-body');\n\n    if (keyTableContainer) keyTableContainer.style.display = state.keys.length > 0 ? 'block' : 'none';\n    if (noKeysMsg) noKeysMsg.style.display = state.keys.length === 0 ? 'block' : 'none';\n\n    if (keyTableBody) {\n        const sorted = sortedKeys();\n        keyTableBody.innerHTML = sorted.map(key => {\n            if (state.editingId === key.id) {\n                return `\n                    <tr class=\"border-b border-monokai-bg-lighter hover:bg-monokai-bg-lighter\">\n                        <td class=\"p-2\">\n                            <input\n                                type=\"text\"\n                                class=\"input text-sm w-full\"\n                                autocomplete=\"off\"\n                                data-edit-label=\"${key.id}\"\n                                value=\"${escapeAttr(state.editLabel)}\"\n                            />\n                        </td>\n                        <td class=\"p-2 font-mono text-xs\">\n                            <input\n                                type=\"text\"\n                                class=\"input text-xs font-mono w-full\"\n                                autocomplete=\"off\"\n                                spellcheck=\"false\"\n                                data-edit-secret=\"${key.id}\"\n                                value=\"${escapeAttr(state.editSecret)}\"\n                            />\n                        </td>\n                        <td class=\"p-2 text-right whitespace-nowrap\">\n                            <button class=\"button text-xs\" data-action=\"save-edit\">Save</button>\n                            <button class=\"button text-xs\" data-action=\"cancel-edit\">Cancel</button>\n                        </td>\n                    </tr>\n                `;\n            }\n            const displaySecret = state.revealedId === key.id ? escapeHtml(key.secret) : escapeHtml(maskSecret(key.secret));\n            const copyLabel = state.copiedId === key.id ? 'Copied!' : 'Copy';\n            return `\n                <tr class=\"border-b border-monokai-bg-lighter hover:bg-monokai-bg-lighter\">\n                    <td class=\"p-2\">\n                        <span class=\"cursor-pointer hover:underline\" data-action=\"start-edit\" data-key-id=\"${key.id}\">${escapeHtml(key.label)}</span>\n                    </td>\n                    <td class=\"p-2 font-mono text-xs\">\n                        <span class=\"cursor-pointer\" data-action=\"toggle-reveal\" data-key-id=\"${key.id}\">${displaySecret}</span>\n                    </td>\n                    <td class=\"p-2 text-right whitespace-nowrap\">\n                        <button class=\"button text-xs\" data-action=\"copy-secret\" data-key-id=\"${key.id}\">${copyLabel}</button>\n                        <button class=\"button text-xs\" data-action=\"delete-key\" data-key-id=\"${key.id}\">Del</button>\n                    </td>\n                </tr>\n            `;\n        }).join('');\n\n        // Bind table events\n        keyTableBody.querySelectorAll('[data-action=\"start-edit\"]').forEach(el => {\n            el.addEventListener('click', () => startEdit(el.dataset.keyId));\n        });\n        keyTableBody.querySelectorAll('[data-action=\"toggle-reveal\"]').forEach(el => {\n            el.addEventListener('click', () => {\n                state.revealedId = state.revealedId === el.dataset.keyId ? null : el.dataset.keyId;\n                render();\n            });\n        });\n        keyTableBody.querySelectorAll('[data-action=\"copy-secret\"]').forEach(el => {\n            el.addEventListener('click', () => copySecret(el.dataset.keyId));\n        });\n        keyTableBody.querySelectorAll('[data-action=\"delete-key\"]').forEach(el => {\n            el.addEventListener('click', () => deleteKey(el.dataset.keyId));\n        });\n        keyTableBody.querySelectorAll('[data-action=\"save-edit\"]').forEach(el => {\n            el.addEventListener('click', saveEdit);\n        });\n        keyTableBody.querySelectorAll('[data-action=\"cancel-edit\"]').forEach(el => {\n            el.addEventListener('click', cancelEdit);\n        });\n\n        // Bind edit input events\n        keyTableBody.querySelectorAll('[data-edit-label]').forEach(el => {\n            el.addEventListener('input', (e) => { state.editLabel = e.target.value; });\n            el.addEventListener('keyup', (e) => {\n                if (e.key === 'Enter') saveEdit();\n                if (e.key === 'Escape') cancelEdit();\n            });\n        });\n        keyTableBody.querySelectorAll('[data-edit-secret]').forEach(el => {\n            el.addEventListener('input', (e) => { state.editSecret = e.target.value; });\n            el.addEventListener('keyup', (e) => {\n                if (e.key === 'Enter') saveEdit();\n                if (e.key === 'Escape') cancelEdit();\n            });\n        });\n    }\n\n    // Add key form\n    const newLabelInput = $('new-label');\n    const newSecretInput = $('new-secret');\n    const addKeyBtn = $('add-key-btn');\n\n    if (newLabelInput && document.activeElement !== newLabelInput) newLabelInput.value = state.newLabel;\n    if (newSecretInput && document.activeElement !== newSecretInput) newSecretInput.value = state.newSecret;\n    if (addKeyBtn) {\n        addKeyBtn.disabled = state.saving || state.newLabel.trim().length === 0 || state.newSecret.trim().length === 0;\n        addKeyBtn.textContent = state.saving ? 'Saving...' : 'Save';\n    }\n\n    // Toast\n    const toast = $('toast');\n    if (toast) {\n        toast.textContent = state.toast;\n        toast.style.display = state.toast ? 'block' : 'none';\n    }\n}\n\nfunction escapeHtml(str) {\n    const div = document.createElement('div');\n    div.textContent = str;\n    return div.innerHTML;\n}\n\nfunction escapeAttr(str) {\n    return str.replace(/&/g, '&amp;').replace(/\"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');\n}\n\n// --- CRUD ---\n\nasync function addKey() {\n    const label = state.newLabel.trim();\n    const secret = state.newSecret.trim();\n    if (!label || !secret) return;\n\n    state.saving = true;\n    render();\n\n    const id = crypto.randomUUID();\n    await saveApiKey(id, label, secret);\n    state.keys = await listApiKeys();\n    state.newLabel = '';\n    state.newSecret = '';\n\n    if (state.syncEnabled && hasRelays()) {\n        await publishToRelay();\n    }\n\n    state.saving = false;\n    showToast('Key added');\n}\n\nfunction startEdit(id) {\n    const key = state.keys.find(k => k.id === id);\n    if (!key) return;\n    state.editingId = key.id;\n    state.editLabel = key.label;\n    state.editSecret = key.secret;\n    render();\n}\n\nasync function saveEdit() {\n    if (!state.editingId) return;\n    const label = state.editLabel.trim();\n    const secret = state.editSecret.trim();\n    if (!label || !secret) return;\n\n    await saveApiKey(state.editingId, label, secret);\n    state.keys = await listApiKeys();\n    state.editingId = null;\n    state.editLabel = '';\n    state.editSecret = '';\n\n    if (state.syncEnabled && hasRelays()) {\n        await publishToRelay();\n    }\n\n    showToast('Key updated');\n}\n\nfunction cancelEdit() {\n    state.editingId = null;\n    state.editLabel = '';\n    state.editSecret = '';\n    render();\n}\n\nasync function deleteKey(id) {\n    const key = state.keys.find(k => k.id === id);\n    if (!key) return;\n    if (!confirm(`Delete \"${key.label}\"?`)) return;\n\n    await deleteApiKey(id);\n    state.keys = await listApiKeys();\n\n    if (state.syncEnabled && hasRelays()) {\n        await publishToRelay();\n    }\n\n    showToast('Key deleted');\n}\n\n// --- Clipboard ---\n\nasync function copySecret(id) {\n    const key = state.keys.find(k => k.id === id);\n    if (!key) return;\n    await navigator.clipboard.writeText(key.secret);\n    state.copiedId = id;\n    render();\n    setTimeout(() => { state.copiedId = null; render(); }, 2000);\n    setTimeout(() => {\n        navigator.clipboard.writeText('').catch(() => {});\n    }, 30000);\n}\n\n// --- Sync ---\n\nasync function publishToRelay() {\n    try {\n        const store = await getApiKeyStore();\n        const result = await api.runtime.sendMessage({\n            kind: 'apikeys.publish',\n            payload: { keys: store.keys },\n        });\n        if (result.success) {\n            await updateStoreSyncState('synced', result.eventId, result.createdAt);\n        }\n        return result;\n    } catch (e) {\n        await updateStoreSyncState('local-only');\n        return { success: false, error: e.message };\n    }\n}\n\nasync function syncAll() {\n    state.globalSyncStatus = 'syncing';\n    state.syncError = '';\n    render();\n\n    try {\n        const result = await api.runtime.sendMessage({ kind: 'apikeys.fetch' });\n\n        if (!result.success) {\n            state.globalSyncStatus = 'error';\n            state.syncError = result.error || 'Sync failed';\n            render();\n            return;\n        }\n\n        if (result.keys) {\n            const store = await getApiKeyStore();\n            const localKeys = store.keys;\n            const localCount = Object.keys(localKeys).length;\n\n            if (localCount === 0) {\n                await importStore(result.keys);\n            } else if (!store.relayCreatedAt || result.createdAt > store.relayCreatedAt) {\n                await importStore(result.keys);\n            }\n\n            await updateStoreSyncState('synced', result.eventId, result.createdAt);\n            state.keys = await listApiKeys();\n        }\n\n        state.globalSyncStatus = 'idle';\n    } catch (e) {\n        state.globalSyncStatus = 'error';\n        state.syncError = e.message || 'Sync failed';\n    }\n\n    render();\n}\n\nasync function toggleSync() {\n    await setSyncEnabled(state.syncEnabled);\n    if (state.syncEnabled && hasRelays()) {\n        await syncAll();\n    }\n}\n\n// --- Import / Export ---\n\nasync function exportKeys() {\n    const keys = await exportStore();\n    const plainText = JSON.stringify(keys, null, 2);\n\n    const result = await api.runtime.sendMessage({\n        kind: 'apikeys.encrypt',\n        payload: { plainText },\n    });\n\n    if (!result.success) {\n        showToast('Export failed: ' + (result.error || 'unknown'));\n        return;\n    }\n\n    const blob = new Blob(\n        [JSON.stringify({ encrypted: true, data: result.cipherText })],\n        { type: 'application/json' },\n    );\n    const url = URL.createObjectURL(blob);\n    const a = document.createElement('a');\n    a.href = url;\n    a.download = 'nostrkey-api-keys-backup.json';\n    a.click();\n    URL.revokeObjectURL(url);\n    showToast('Exported');\n}\n\nasync function importKeys(event) {\n    const file = event.target.files?.[0];\n    if (!file) return;\n\n    try {\n        const text = await file.text();\n        const parsed = JSON.parse(text);\n\n        let keys;\n        if (parsed.encrypted && parsed.data) {\n            const result = await api.runtime.sendMessage({\n                kind: 'apikeys.decrypt',\n                payload: { cipherText: parsed.data },\n            });\n            if (!result.success) {\n                showToast('Decrypt failed: ' + (result.error || 'unknown'));\n                return;\n            }\n            keys = JSON.parse(result.plainText);\n        } else {\n            keys = parsed;\n        }\n\n        await importStore(keys);\n        state.keys = await listApiKeys();\n\n        if (state.syncEnabled && hasRelays()) {\n            await publishToRelay();\n        }\n\n        showToast('Imported ' + Object.keys(keys).length + ' keys');\n    } catch (e) {\n        showToast('Import failed: ' + e.message);\n    }\n\n    event.target.value = '';\n}\n\n// --- Event binding ---\n\nfunction bindEvents() {\n    $('sync-btn')?.addEventListener('click', syncAll);\n    $('add-key-btn')?.addEventListener('click', addKey);\n    $('export-btn')?.addEventListener('click', exportKeys);\n    $('import-file')?.addEventListener('change', importKeys);\n    $('close-btn')?.addEventListener('click', () => window.close());\n\n    $('sync-toggle')?.addEventListener('change', (e) => {\n        state.syncEnabled = e.target.checked;\n        toggleSync();\n    });\n\n    $('new-label')?.addEventListener('input', (e) => {\n        state.newLabel = e.target.value;\n        render();\n    });\n\n    $('new-secret')?.addEventListener('input', (e) => {\n        state.newSecret = e.target.value;\n        render();\n    });\n}\n\nasync function init() {\n    // Gate: require master password before allowing access\n    const isEncrypted = await api.runtime.sendMessage({ kind: 'isEncrypted' });\n    const gate = $('vault-locked-gate');\n    const main = $('vault-main-content');\n\n    if (!isEncrypted) {\n        if (gate) gate.style.display = 'block';\n        if (main) main.style.display = 'none';\n        $('gate-security-btn')?.addEventListener('click', () => {\n            const url = api.runtime.getURL('security/security.html');\n            window.open(url, 'nostrkey-options');\n        });\n        return;\n    }\n\n    if (gate) gate.style.display = 'none';\n    if (main) main.style.display = 'block';\n\n    const relays = await api.runtime.sendMessage({ kind: 'vault.getRelays' });\n    state.relayInfo = relays || { read: [], write: [] };\n    state.syncEnabled = await isSyncEnabled();\n    state.keys = await listApiKeys();\n\n    bindEvents();\n    render();\n\n    if (state.syncEnabled && hasRelays()) {\n        await syncAll();\n    }\n}\n\ndocument.addEventListener('DOMContentLoaded', init);\n"],
  "mappings": "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",
  "names": ["storage", "isSyncEnabled", "isSyncEnabled"]
}
 diff --git a/distros/safari/background.build.js b/distros/safari/background.build.js index aff78a2..34d995b 100644 --- a/distros/safari/background.build.js +++ b/distros/safari/background.build.js @@ -1,5 +1,7172 @@ -(()=>{var Qa=Object.create;var kn=Object.defineProperty;var ec=Object.getOwnPropertyDescriptor;var tc=Object.getOwnPropertyNames;var rc=Object.getPrototypeOf,nc=Object.prototype.hasOwnProperty;var oc=(t,e)=>()=>(t&&(e=t(t=0)),e);var bt=(t,e)=>()=>(e||t((e={exports:{}}).exports,e),e.exports),An=(t,e)=>{for(var r in e)kn(t,r,{get:e[r],enumerable:!0})},ic=(t,e,r,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of tc(e))!nc.call(t,o)&&o!==r&&kn(t,o,{get:()=>e[o],enumerable:!(n=ec(e,o))||n.enumerable});return t};var er=(t,e,r)=>(r=t!=null?Qa(rc(t)):{},ic(e||!t||!t.__esModule?kn(r,"default",{value:t,enumerable:!0}):r,t));var R,b=oc(()=>{R={env:{NODE_ENV:"production",LOG_LEVEL:"warn"},browser:!0,version:"",stdout:null,stderr:null,nextTick:function(t){var e=Array.prototype.slice.call(arguments,1);Promise.resolve().then(function(){t.apply(null,e)})}}});var es=bt((kd,Qi)=>{"use strict";b();function _c(t){try{return JSON.stringify(t)}catch{return'"[Circular]"'}}Qi.exports=Lc;function Lc(t,e,r){var n=r&&r.stringify||_c,o=1;if(typeof t=="object"&&t!==null){var i=e.length+o;if(i===1)return t;var s=new Array(i);s[0]=n(t);for(var a=1;a-1?u:0,t.charCodeAt(d+1)){case 100:case 102:if(f>=c||e[f]==null)break;u=c||e[f]==null)break;u=c||e[f]===void 0)break;u",u=d+2,d++;break}l+=n(e[f]),u=d+2,d++;break;case 115:if(f>=c)break;u{"use strict";b();var ts=es();Mr.exports=rt;var cr=jc().console||{},Uc={mapHttpRequest:Dr,mapHttpResponse:Dr,wrapRequestSerializer:Jn,wrapResponseSerializer:Jn,wrapErrorSerializer:Jn,req:Dr,res:Dr,err:ns,errWithCause:ns};function ht(t,e){return t==="silent"?1/0:e.levels.values[t]}var eo=Symbol("pino.logFuncs"),Xn=Symbol("pino.hierarchy"),Pc={error:"log",fatal:"error",warn:"error",info:"log",debug:"log",trace:"log"};function rs(t,e){let r={logger:e,parent:t[Xn]};e[Xn]=r}function Rc(t,e,r){let n={};e.forEach(o=>{n[o]=r[o]?r[o]:cr[o]||cr[Pc[o]||"log"]||Vt}),t[eo]=n}function Cc(t,e){return Array.isArray(t)?t.filter(function(n){return n!=="!stdSerializers.err"}):t===!0?Object.keys(e):!1}function rt(t){t=t||{},t.browser=t.browser||{};let e=t.browser.transmit;if(e&&typeof e.send!="function")throw Error("pino: transmit option must have a send function");let r=t.browser.write||cr;t.browser.write&&(t.browser.asObject=!0);let n=t.serializers||{},o=Cc(t.browser.serialize,n),i=t.browser.serialize;Array.isArray(t.browser.serialize)&&t.browser.serialize.indexOf("!stdSerializers.err")>-1&&(i=!1);let s=Object.keys(t.customLevels||{}),a=["error","fatal","warn","info","debug","trace"].concat(s);typeof r=="function"&&a.forEach(function(p){r[p]=r}),(t.enabled===!1||t.browser.disabled)&&(t.level="silent");let c=t.level||"info",l=Object.create(r);l.log||(l.log=Vt),Rc(l,a,r),rs({},l),Object.defineProperty(l,"levelVal",{get:u}),Object.defineProperty(l,"level",{get:h,set:d});let f={transmit:e,serialize:o,asObject:t.browser.asObject,asObjectBindingsOnly:t.browser.asObjectBindingsOnly,formatters:t.browser.formatters,reportCaller:t.browser.reportCaller,levels:a,timestamp:Fc(t),messageKey:t.messageKey||"msg",onChild:t.onChild||Vt};l.levels=Oc(t),l.level=c,l.isLevelEnabled=function(p){return this.levels.values[p]?this.levels.values[p]>=this.levels.values[this.level]:!1},l.setMaxListeners=l.getMaxListeners=l.emit=l.addListener=l.on=l.prependListener=l.once=l.prependOnceListener=l.removeListener=l.removeAllListeners=l.listeners=l.listenerCount=l.eventNames=l.write=l.flush=Vt,l.serializers=n,l._serialize=o,l._stdErrSerialize=i,l.child=function(...p){return y.call(this,f,...p)},e&&(l._logEvent=Qn());function u(){return ht(this.level,this)}function h(){return this._level}function d(p){if(p!=="silent"&&!this.levels.values[p])throw Error("unknown level "+p);this._level=p,At(this,f,l,"error"),At(this,f,l,"fatal"),At(this,f,l,"warn"),At(this,f,l,"info"),At(this,f,l,"debug"),At(this,f,l,"trace"),s.forEach(w=>{At(this,f,l,w)})}function y(p,w,k){if(!w)throw new Error("missing bindings for child Pino");k=k||{},o&&w.serializers&&(k.serializers=w.serializers);let O=k.serializers;if(o&&O){var D=Object.assign({},n,O),H=t.browser.serialize===!0?Object.keys(D):o;delete w.serializers,to([w],H,D,this._stdErrSerialize)}function X(q){this._childLevel=(q._childLevel|0)+1,this.bindings=w,D&&(this.serializers=D,this._serialize=H),e&&(this._logEvent=Qn([].concat(q._logEvent.bindings,w)))}X.prototype=this;let M=new X(this);return rs(this,M),M.child=function(...q){return y.call(this,p,...q)},M.level=k.level||this.level,p.onChild(M),M}return l}function Oc(t){let e=t.customLevels||{},r=Object.assign({},rt.levels.values,e),n=Object.assign({},rt.levels.labels,Nc(e));return{values:r,labels:n}}function Nc(t){let e={};return Object.keys(t).forEach(function(r){e[t[r]]=r}),e}rt.levels={values:{fatal:60,error:50,warn:40,info:30,debug:20,trace:10},labels:{10:"trace",20:"debug",30:"info",40:"warn",50:"error",60:"fatal"}};rt.stdSerializers=Uc;rt.stdTimeFunctions=Object.assign({},{nullTime:is,epochTime:ss,unixTime:$c,isoTime:qc});function Dc(t){let e=[];t.bindings&&e.push(t.bindings);let r=t[Xn];for(;r.parent;)r=r.parent,r.logger.bindings&&e.push(r.logger.bindings);return e.reverse()}function At(t,e,r,n){if(Object.defineProperty(t,n,{value:ht(t.level,r)>ht(n,r)?Vt:r[eo][n],writable:!0,enumerable:!0,configurable:!0}),t[n]===Vt){if(!e.transmit)return;let i=e.transmit.level||t.level,s=ht(i,r);if(ht(n,r)0&&u[0]&&typeof u[0]=="object")try{let h=os();h&&(u[0].caller=h)}catch{}o.call(c,...u)}else{if(e.reportCaller)try{let u=os();u&&a.push(u)}catch{}o.apply(c,a)}if(e.transmit){let u=e.transmit.level||t._level,h=ht(u,r),d=ht(n,r);if(du}=o.formatters||{},a=r.slice(),c=a[0],l={},f=(t._childLevel|0)+1;if(f<1&&(f=1),n&&(l.time=n),i){let u=i(e,t.levels.values[e]);Object.assign(l,u)}else l.level=t.levels.values[e];if(o.asObjectBindingsOnly){if(c!==null&&typeof c=="object")for(;f--&&typeof a[0]=="object";)Object.assign(l,a.shift());return[s(l),...a]}else{if(c!==null&&typeof c=="object"){for(;f--&&typeof a[0]=="object";)Object.assign(l,a.shift());c=a.length?ts(a.shift(),a):void 0}else typeof c=="string"&&(c=ts(a.shift(),a));return c!==void 0&&(l[o.messageKey]=c),[s(l)]}}function to(t,e,r,n){for(let o in t)if(n&&t[o]instanceof Error)t[o]=rt.stdSerializers.err(t[o]);else if(typeof t[o]=="object"&&!Array.isArray(t[o])&&e)for(let i in t[o])e.indexOf(i)>-1&&i in r&&(t[o][i]=r[i](t[o][i]))}function Vc(t,e,r,n=!1){let o=e.send,i=e.ts,s=e.methodLevel,a=e.methodValue,c=e.val,l=t._logEvent.bindings;n||to(r,t._serialize||Object.keys(t.serializers),t.serializers,t._stdErrSerialize===void 0?!0:t._stdErrSerialize),t._logEvent.ts=i,t._logEvent.messages=r.filter(function(f){return l.indexOf(f)===-1}),t._logEvent.level.label=s,t._logEvent.level.value=a,o(s,t._logEvent,c),t._logEvent=Qn(l)}function Qn(t){return{ts:0,messages:[],bindings:t||[],level:{label:"",value:0}}}function ns(t){let e={type:t.constructor.name,msg:t.message,stack:t.stack};for(let r in t)e[r]===void 0&&(e[r]=t[r]);return e}function Fc(t){return typeof t.timestamp=="function"?t.timestamp:t.timestamp===!1?is:ss}function Dr(){return{}}function Jn(t){return t}function Vt(){}function is(){return!1}function ss(){return Date.now()}function $c(){return Math.round(Date.now()/1e3)}function qc(){return new Date(Date.now()).toISOString()}function jc(){function t(e){return typeof e<"u"&&e}try{return typeof globalThis<"u"||Object.defineProperty(Object.prototype,"globalThis",{get:function(){return delete Object.prototype.globalThis,this.globalThis=this},configurable:!0}),globalThis}catch{return t(self)||t(window)||t(this)||{}}}Mr.exports.default=rt;Mr.exports.pino=rt;function os(){let t=new Error().stack;if(!t)return null;let e=t.split(` -`);for(let r=1;r{b();us.exports={}});var bs=bt($t=>{"use strict";b();Object.defineProperty($t,"__esModule",{value:!0});$t.bech32m=$t.bech32=void 0;var Vr="qpzry9x8gf2tvdw0s3jn54khce6mua7l",ms={};for(let t=0;t>25;return(t&33554431)<<5^-(e>>0&1)&996825010^-(e>>1&1)&642813549^-(e>>2&1)&513874426^-(e>>3&1)&1027748829^-(e>>4&1)&705979059}function gs(t){let e=1;for(let r=0;r126)return"Invalid prefix ("+t+")";e=Ft(e)^n>>5}e=Ft(e);for(let r=0;r=r;)i-=r,a.push(o>>i&s);if(n)i>0&&a.push(o<=e)return"Excess padding";if(o<c)throw new TypeError("Exceeds length limit");s=s.toLowerCase();let l=gs(s);if(typeof l=="string")throw new Error(l);let f=s+"1";for(let u=0;u>5!==0)throw new Error("Non 5-bit word");l=Ft(l)^h,f+=Vr.charAt(h)}for(let u=0;u<6;++u)l=Ft(l);l^=e;for(let u=0;u<6;++u){let h=l>>(5-u)*5&31;f+=Vr.charAt(h)}return f}function n(s,a){if(a=a||90,s.length<8)return s+" too short";if(s.length>a)return"Exceeds length limit";let c=s.toLowerCase(),l=s.toUpperCase();if(s!==c&&s!==l)return"Mixed-case string "+s;s=c;let f=s.lastIndexOf("1");if(f===-1)return"No separator character for "+s;if(f===0)return"Missing prefix for "+s;let u=s.slice(0,f),h=s.slice(f+1);if(h.length<6)return"Data too short";let d=gs(u);if(typeof d=="string")return d;let y=[];for(let p=0;p=h.length)&&y.push(k)}return d!==e?"Invalid checksum for "+s:{prefix:u,words:y}}function o(s,a){let c=n(s,a);if(typeof c=="object")return c}function i(s,a){let c=n(s,a);if(typeof c=="object")return c;throw new Error(c)}return{decodeUnsafe:o,decode:i,encode:r,toWords:tl,fromWordsUnsafe:rl,fromWords:nl}}$t.bech32=ws("bech32");$t.bech32m=ws("bech32m")});var vs=bt(Fr=>{"use strict";b();Fr.byteLength=il;Fr.toByteArray=al;Fr.fromByteArray=ul;var ze=[],Ce=[],ol=typeof Uint8Array<"u"?Uint8Array:Array,ao="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";for(Bt=0,xs=ao.length;Bt0)throw new Error("Invalid string. Length must be a multiple of 4");var r=t.indexOf("=");r===-1&&(r=e);var n=r===e?0:4-r%4;return[r,n]}function il(t){var e=Es(t),r=e[0],n=e[1];return(r+n)*3/4-n}function sl(t,e,r){return(e+r)*3/4-r}function al(t){var e,r=Es(t),n=r[0],o=r[1],i=new ol(sl(t,n,o)),s=0,a=o>0?n-4:n,c;for(c=0;c>16&255,i[s++]=e>>8&255,i[s++]=e&255;return o===2&&(e=Ce[t.charCodeAt(c)]<<2|Ce[t.charCodeAt(c+1)]>>4,i[s++]=e&255),o===1&&(e=Ce[t.charCodeAt(c)]<<10|Ce[t.charCodeAt(c+1)]<<4|Ce[t.charCodeAt(c+2)]>>2,i[s++]=e>>8&255,i[s++]=e&255),i}function cl(t){return ze[t>>18&63]+ze[t>>12&63]+ze[t>>6&63]+ze[t&63]}function ll(t,e,r){for(var n,o=[],i=e;ia?a:s+i));return n===1?(e=t[r-1],o.push(ze[e>>2]+ze[e<<4&63]+"==")):n===2&&(e=(t[r-2]<<8)+t[r-1],o.push(ze[e>>10]+ze[e>>4&63]+ze[e<<2&63]+"=")),o.join("")}});var ks=bt(co=>{b();co.read=function(t,e,r,n,o){var i,s,a=o*8-n-1,c=(1<>1,f=-7,u=r?o-1:0,h=r?-1:1,d=t[e+u];for(u+=h,i=d&(1<<-f)-1,d>>=-f,f+=a;f>0;i=i*256+t[e+u],u+=h,f-=8);for(s=i&(1<<-f)-1,i>>=-f,f+=n;f>0;s=s*256+t[e+u],u+=h,f-=8);if(i===0)i=1-l;else{if(i===c)return s?NaN:(d?-1:1)*(1/0);s=s+Math.pow(2,n),i=i-l}return(d?-1:1)*s*Math.pow(2,i-n)};co.write=function(t,e,r,n,o,i){var s,a,c,l=i*8-o-1,f=(1<>1,h=o===23?Math.pow(2,-24)-Math.pow(2,-77):0,d=n?0:i-1,y=n?1:-1,p=e<0||e===0&&1/e<0?1:0;for(e=Math.abs(e),isNaN(e)||e===1/0?(a=isNaN(e)?1:0,s=f):(s=Math.floor(Math.log(e)/Math.LN2),e*(c=Math.pow(2,-s))<1&&(s--,c*=2),s+u>=1?e+=h/c:e+=h*Math.pow(2,1-u),e*c>=2&&(s++,c/=2),s+u>=f?(a=0,s=f):s+u>=1?(a=(e*c-1)*Math.pow(2,o),s=s+u):(a=e*Math.pow(2,u-1)*Math.pow(2,o),s=0));o>=8;t[r+d]=a&255,d+=y,a/=256,o-=8);for(s=s<0;t[r+d]=s&255,d+=y,s/=256,l-=8);t[r+d-y]|=p*128}});var Ks=bt(Wt=>{"use strict";b();var lo=vs(),jt=ks(),As=typeof Symbol=="function"&&typeof Symbol.for=="function"?Symbol.for("nodejs.util.inspect.custom"):null;Wt.Buffer=g;Wt.SlowBuffer=gl;Wt.INSPECT_MAX_BYTES=50;var $r=2147483647;Wt.kMaxLength=$r;g.TYPED_ARRAY_SUPPORT=fl();!g.TYPED_ARRAY_SUPPORT&&typeof console<"u";function fl(){try{let t=new Uint8Array(1),e={foo:function(){return 42}};return Object.setPrototypeOf(e,Uint8Array.prototype),Object.setPrototypeOf(t,e),t.foo()===42}catch{return!1}}Object.defineProperty(g.prototype,"parent",{enumerable:!0,get:function(){if(g.isBuffer(this))return this.buffer}});Object.defineProperty(g.prototype,"offset",{enumerable:!0,get:function(){if(g.isBuffer(this))return this.byteOffset}});function nt(t){if(t>$r)throw new RangeError('The value "'+t+'" is invalid for option "size"');let e=new Uint8Array(t);return Object.setPrototypeOf(e,g.prototype),e}function g(t,e,r){if(typeof t=="number"){if(typeof e=="string")throw new TypeError('The "string" argument must be of type string. Received type number');return po(t)}return Ts(t,e,r)}g.poolSize=8192;function Ts(t,e,r){if(typeof t=="string")return hl(t,e);if(ArrayBuffer.isView(t))return pl(t);if(t==null)throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type "+typeof t);if(We(t,ArrayBuffer)||t&&We(t.buffer,ArrayBuffer)||typeof SharedArrayBuffer<"u"&&(We(t,SharedArrayBuffer)||t&&We(t.buffer,SharedArrayBuffer)))return fo(t,e,r);if(typeof t=="number")throw new TypeError('The "value" argument must not be of type number. Received type number');let n=t.valueOf&&t.valueOf();if(n!=null&&n!==t)return g.from(n,e,r);let o=yl(t);if(o)return o;if(typeof Symbol<"u"&&Symbol.toPrimitive!=null&&typeof t[Symbol.toPrimitive]=="function")return g.from(t[Symbol.toPrimitive]("string"),e,r);throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type "+typeof t)}g.from=function(t,e,r){return Ts(t,e,r)};Object.setPrototypeOf(g.prototype,Uint8Array.prototype);Object.setPrototypeOf(g,Uint8Array);function _s(t){if(typeof t!="number")throw new TypeError('"size" argument must be of type number');if(t<0)throw new RangeError('The value "'+t+'" is invalid for option "size"')}function dl(t,e,r){return _s(t),t<=0?nt(t):e!==void 0?typeof r=="string"?nt(t).fill(e,r):nt(t).fill(e):nt(t)}g.alloc=function(t,e,r){return dl(t,e,r)};function po(t){return _s(t),nt(t<0?0:yo(t)|0)}g.allocUnsafe=function(t){return po(t)};g.allocUnsafeSlow=function(t){return po(t)};function hl(t,e){if((typeof e!="string"||e==="")&&(e="utf8"),!g.isEncoding(e))throw new TypeError("Unknown encoding: "+e);let r=Ls(t,e)|0,n=nt(r),o=n.write(t,e);return o!==r&&(n=n.slice(0,o)),n}function uo(t){let e=t.length<0?0:yo(t.length)|0,r=nt(e);for(let n=0;n=$r)throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+$r.toString(16)+" bytes");return t|0}function gl(t){return+t!=t&&(t=0),g.alloc(+t)}g.isBuffer=function(e){return e!=null&&e._isBuffer===!0&&e!==g.prototype};g.compare=function(e,r){if(We(e,Uint8Array)&&(e=g.from(e,e.offset,e.byteLength)),We(r,Uint8Array)&&(r=g.from(r,r.offset,r.byteLength)),!g.isBuffer(e)||!g.isBuffer(r))throw new TypeError('The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array');if(e===r)return 0;let n=e.length,o=r.length;for(let i=0,s=Math.min(n,o);io.length?(g.isBuffer(s)||(s=g.from(s)),s.copy(o,i)):Uint8Array.prototype.set.call(o,s,i);else if(g.isBuffer(s))s.copy(o,i);else throw new TypeError('"list" argument must be an Array of Buffers');i+=s.length}return o};function Ls(t,e){if(g.isBuffer(t))return t.length;if(ArrayBuffer.isView(t)||We(t,ArrayBuffer))return t.byteLength;if(typeof t!="string")throw new TypeError('The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type '+typeof t);let r=t.length,n=arguments.length>2&&arguments[2]===!0;if(!n&&r===0)return 0;let o=!1;for(;;)switch(e){case"ascii":case"latin1":case"binary":return r;case"utf8":case"utf-8":return ho(t).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return r*2;case"hex":return r>>>1;case"base64":return Hs(t).length;default:if(o)return n?-1:ho(t).length;e=(""+e).toLowerCase(),o=!0}}g.byteLength=Ls;function ml(t,e,r){let n=!1;if((e===void 0||e<0)&&(e=0),e>this.length||((r===void 0||r>this.length)&&(r=this.length),r<=0)||(r>>>=0,e>>>=0,r<=e))return"";for(t||(t="utf8");;)switch(t){case"hex":return Il(this,e,r);case"utf8":case"utf-8":return Ps(this,e,r);case"ascii":return Bl(this,e,r);case"latin1":case"binary":return Sl(this,e,r);case"base64":return kl(this,e,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return Tl(this,e,r);default:if(n)throw new TypeError("Unknown encoding: "+t);t=(t+"").toLowerCase(),n=!0}}g.prototype._isBuffer=!0;function St(t,e,r){let n=t[e];t[e]=t[r],t[r]=n}g.prototype.swap16=function(){let e=this.length;if(e%2!==0)throw new RangeError("Buffer size must be a multiple of 16-bits");for(let r=0;rr&&(e+=" ... "),""};As&&(g.prototype[As]=g.prototype.inspect);g.prototype.compare=function(e,r,n,o,i){if(We(e,Uint8Array)&&(e=g.from(e,e.offset,e.byteLength)),!g.isBuffer(e))throw new TypeError('The "target" argument must be one of type Buffer or Uint8Array. Received type '+typeof e);if(r===void 0&&(r=0),n===void 0&&(n=e?e.length:0),o===void 0&&(o=0),i===void 0&&(i=this.length),r<0||n>e.length||o<0||i>this.length)throw new RangeError("out of range index");if(o>=i&&r>=n)return 0;if(o>=i)return-1;if(r>=n)return 1;if(r>>>=0,n>>>=0,o>>>=0,i>>>=0,this===e)return 0;let s=i-o,a=n-r,c=Math.min(s,a),l=this.slice(o,i),f=e.slice(r,n);for(let u=0;u2147483647?r=2147483647:r<-2147483648&&(r=-2147483648),r=+r,mo(r)&&(r=o?0:t.length-1),r<0&&(r=t.length+r),r>=t.length){if(o)return-1;r=t.length-1}else if(r<0)if(o)r=0;else return-1;if(typeof e=="string"&&(e=g.from(e,n)),g.isBuffer(e))return e.length===0?-1:Bs(t,e,r,n,o);if(typeof e=="number")return e=e&255,typeof Uint8Array.prototype.indexOf=="function"?o?Uint8Array.prototype.indexOf.call(t,e,r):Uint8Array.prototype.lastIndexOf.call(t,e,r):Bs(t,[e],r,n,o);throw new TypeError("val must be string, number or Buffer")}function Bs(t,e,r,n,o){let i=1,s=t.length,a=e.length;if(n!==void 0&&(n=String(n).toLowerCase(),n==="ucs2"||n==="ucs-2"||n==="utf16le"||n==="utf-16le")){if(t.length<2||e.length<2)return-1;i=2,s/=2,a/=2,r/=2}function c(f,u){return i===1?f[u]:f.readUInt16BE(u*i)}let l;if(o){let f=-1;for(l=r;ls&&(r=s-a),l=r;l>=0;l--){let f=!0;for(let u=0;uo&&(n=o)):n=o;let i=e.length;n>i/2&&(n=i/2);let s;for(s=0;s>>0,isFinite(n)?(n=n>>>0,o===void 0&&(o="utf8")):(o=n,n=void 0);else throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");let i=this.length-r;if((n===void 0||n>i)&&(n=i),e.length>0&&(n<0||r<0)||r>this.length)throw new RangeError("Attempt to write outside buffer bounds");o||(o="utf8");let s=!1;for(;;)switch(o){case"hex":return wl(this,e,r,n);case"utf8":case"utf-8":return bl(this,e,r,n);case"ascii":case"latin1":case"binary":return xl(this,e,r,n);case"base64":return El(this,e,r,n);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return vl(this,e,r,n);default:if(s)throw new TypeError("Unknown encoding: "+o);o=(""+o).toLowerCase(),s=!0}};g.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};function kl(t,e,r){return e===0&&r===t.length?lo.fromByteArray(t):lo.fromByteArray(t.slice(e,r))}function Ps(t,e,r){r=Math.min(t.length,r);let n=[],o=e;for(;o239?4:i>223?3:i>191?2:1;if(o+a<=r){let c,l,f,u;switch(a){case 1:i<128&&(s=i);break;case 2:c=t[o+1],(c&192)===128&&(u=(i&31)<<6|c&63,u>127&&(s=u));break;case 3:c=t[o+1],l=t[o+2],(c&192)===128&&(l&192)===128&&(u=(i&15)<<12|(c&63)<<6|l&63,u>2047&&(u<55296||u>57343)&&(s=u));break;case 4:c=t[o+1],l=t[o+2],f=t[o+3],(c&192)===128&&(l&192)===128&&(f&192)===128&&(u=(i&15)<<18|(c&63)<<12|(l&63)<<6|f&63,u>65535&&u<1114112&&(s=u))}}s===null?(s=65533,a=1):s>65535&&(s-=65536,n.push(s>>>10&1023|55296),s=56320|s&1023),n.push(s),o+=a}return Al(n)}var Ss=4096;function Al(t){let e=t.length;if(e<=Ss)return String.fromCharCode.apply(String,t);let r="",n=0;for(;nn)&&(r=n);let o="";for(let i=e;in&&(e=n),r<0?(r+=n,r<0&&(r=0)):r>n&&(r=n),rr)throw new RangeError("Trying to access beyond buffer length")}g.prototype.readUintLE=g.prototype.readUIntLE=function(e,r,n){e=e>>>0,r=r>>>0,n||le(e,r,this.length);let o=this[e],i=1,s=0;for(;++s>>0,r=r>>>0,n||le(e,r,this.length);let o=this[e+--r],i=1;for(;r>0&&(i*=256);)o+=this[e+--r]*i;return o};g.prototype.readUint8=g.prototype.readUInt8=function(e,r){return e=e>>>0,r||le(e,1,this.length),this[e]};g.prototype.readUint16LE=g.prototype.readUInt16LE=function(e,r){return e=e>>>0,r||le(e,2,this.length),this[e]|this[e+1]<<8};g.prototype.readUint16BE=g.prototype.readUInt16BE=function(e,r){return e=e>>>0,r||le(e,2,this.length),this[e]<<8|this[e+1]};g.prototype.readUint32LE=g.prototype.readUInt32LE=function(e,r){return e=e>>>0,r||le(e,4,this.length),(this[e]|this[e+1]<<8|this[e+2]<<16)+this[e+3]*16777216};g.prototype.readUint32BE=g.prototype.readUInt32BE=function(e,r){return e=e>>>0,r||le(e,4,this.length),this[e]*16777216+(this[e+1]<<16|this[e+2]<<8|this[e+3])};g.prototype.readBigUInt64LE=yt(function(e){e=e>>>0,zt(e,"offset");let r=this[e],n=this[e+7];(r===void 0||n===void 0)&&ur(e,this.length-8);let o=r+this[++e]*2**8+this[++e]*2**16+this[++e]*2**24,i=this[++e]+this[++e]*2**8+this[++e]*2**16+n*2**24;return BigInt(o)+(BigInt(i)<>>0,zt(e,"offset");let r=this[e],n=this[e+7];(r===void 0||n===void 0)&&ur(e,this.length-8);let o=r*2**24+this[++e]*2**16+this[++e]*2**8+this[++e],i=this[++e]*2**24+this[++e]*2**16+this[++e]*2**8+n;return(BigInt(o)<>>0,r=r>>>0,n||le(e,r,this.length);let o=this[e],i=1,s=0;for(;++s=i&&(o-=Math.pow(2,8*r)),o};g.prototype.readIntBE=function(e,r,n){e=e>>>0,r=r>>>0,n||le(e,r,this.length);let o=r,i=1,s=this[e+--o];for(;o>0&&(i*=256);)s+=this[e+--o]*i;return i*=128,s>=i&&(s-=Math.pow(2,8*r)),s};g.prototype.readInt8=function(e,r){return e=e>>>0,r||le(e,1,this.length),this[e]&128?(255-this[e]+1)*-1:this[e]};g.prototype.readInt16LE=function(e,r){e=e>>>0,r||le(e,2,this.length);let n=this[e]|this[e+1]<<8;return n&32768?n|4294901760:n};g.prototype.readInt16BE=function(e,r){e=e>>>0,r||le(e,2,this.length);let n=this[e+1]|this[e]<<8;return n&32768?n|4294901760:n};g.prototype.readInt32LE=function(e,r){return e=e>>>0,r||le(e,4,this.length),this[e]|this[e+1]<<8|this[e+2]<<16|this[e+3]<<24};g.prototype.readInt32BE=function(e,r){return e=e>>>0,r||le(e,4,this.length),this[e]<<24|this[e+1]<<16|this[e+2]<<8|this[e+3]};g.prototype.readBigInt64LE=yt(function(e){e=e>>>0,zt(e,"offset");let r=this[e],n=this[e+7];(r===void 0||n===void 0)&&ur(e,this.length-8);let o=this[e+4]+this[e+5]*2**8+this[e+6]*2**16+(n<<24);return(BigInt(o)<>>0,zt(e,"offset");let r=this[e],n=this[e+7];(r===void 0||n===void 0)&&ur(e,this.length-8);let o=(r<<24)+this[++e]*2**16+this[++e]*2**8+this[++e];return(BigInt(o)<>>0,r||le(e,4,this.length),jt.read(this,e,!0,23,4)};g.prototype.readFloatBE=function(e,r){return e=e>>>0,r||le(e,4,this.length),jt.read(this,e,!1,23,4)};g.prototype.readDoubleLE=function(e,r){return e=e>>>0,r||le(e,8,this.length),jt.read(this,e,!0,52,8)};g.prototype.readDoubleBE=function(e,r){return e=e>>>0,r||le(e,8,this.length),jt.read(this,e,!1,52,8)};function ve(t,e,r,n,o,i){if(!g.isBuffer(t))throw new TypeError('"buffer" argument must be a Buffer instance');if(e>o||et.length)throw new RangeError("Index out of range")}g.prototype.writeUintLE=g.prototype.writeUIntLE=function(e,r,n,o){if(e=+e,r=r>>>0,n=n>>>0,!o){let a=Math.pow(2,8*n)-1;ve(this,e,r,n,a,0)}let i=1,s=0;for(this[r]=e&255;++s>>0,n=n>>>0,!o){let a=Math.pow(2,8*n)-1;ve(this,e,r,n,a,0)}let i=n-1,s=1;for(this[r+i]=e&255;--i>=0&&(s*=256);)this[r+i]=e/s&255;return r+n};g.prototype.writeUint8=g.prototype.writeUInt8=function(e,r,n){return e=+e,r=r>>>0,n||ve(this,e,r,1,255,0),this[r]=e&255,r+1};g.prototype.writeUint16LE=g.prototype.writeUInt16LE=function(e,r,n){return e=+e,r=r>>>0,n||ve(this,e,r,2,65535,0),this[r]=e&255,this[r+1]=e>>>8,r+2};g.prototype.writeUint16BE=g.prototype.writeUInt16BE=function(e,r,n){return e=+e,r=r>>>0,n||ve(this,e,r,2,65535,0),this[r]=e>>>8,this[r+1]=e&255,r+2};g.prototype.writeUint32LE=g.prototype.writeUInt32LE=function(e,r,n){return e=+e,r=r>>>0,n||ve(this,e,r,4,4294967295,0),this[r+3]=e>>>24,this[r+2]=e>>>16,this[r+1]=e>>>8,this[r]=e&255,r+4};g.prototype.writeUint32BE=g.prototype.writeUInt32BE=function(e,r,n){return e=+e,r=r>>>0,n||ve(this,e,r,4,4294967295,0),this[r]=e>>>24,this[r+1]=e>>>16,this[r+2]=e>>>8,this[r+3]=e&255,r+4};function Rs(t,e,r,n,o){Ms(e,n,o,t,r,7);let i=Number(e&BigInt(4294967295));t[r++]=i,i=i>>8,t[r++]=i,i=i>>8,t[r++]=i,i=i>>8,t[r++]=i;let s=Number(e>>BigInt(32)&BigInt(4294967295));return t[r++]=s,s=s>>8,t[r++]=s,s=s>>8,t[r++]=s,s=s>>8,t[r++]=s,r}function Cs(t,e,r,n,o){Ms(e,n,o,t,r,7);let i=Number(e&BigInt(4294967295));t[r+7]=i,i=i>>8,t[r+6]=i,i=i>>8,t[r+5]=i,i=i>>8,t[r+4]=i;let s=Number(e>>BigInt(32)&BigInt(4294967295));return t[r+3]=s,s=s>>8,t[r+2]=s,s=s>>8,t[r+1]=s,s=s>>8,t[r]=s,r+8}g.prototype.writeBigUInt64LE=yt(function(e,r=0){return Rs(this,e,r,BigInt(0),BigInt("0xffffffffffffffff"))});g.prototype.writeBigUInt64BE=yt(function(e,r=0){return Cs(this,e,r,BigInt(0),BigInt("0xffffffffffffffff"))});g.prototype.writeIntLE=function(e,r,n,o){if(e=+e,r=r>>>0,!o){let c=Math.pow(2,8*n-1);ve(this,e,r,n,c-1,-c)}let i=0,s=1,a=0;for(this[r]=e&255;++i>0)-a&255;return r+n};g.prototype.writeIntBE=function(e,r,n,o){if(e=+e,r=r>>>0,!o){let c=Math.pow(2,8*n-1);ve(this,e,r,n,c-1,-c)}let i=n-1,s=1,a=0;for(this[r+i]=e&255;--i>=0&&(s*=256);)e<0&&a===0&&this[r+i+1]!==0&&(a=1),this[r+i]=(e/s>>0)-a&255;return r+n};g.prototype.writeInt8=function(e,r,n){return e=+e,r=r>>>0,n||ve(this,e,r,1,127,-128),e<0&&(e=255+e+1),this[r]=e&255,r+1};g.prototype.writeInt16LE=function(e,r,n){return e=+e,r=r>>>0,n||ve(this,e,r,2,32767,-32768),this[r]=e&255,this[r+1]=e>>>8,r+2};g.prototype.writeInt16BE=function(e,r,n){return e=+e,r=r>>>0,n||ve(this,e,r,2,32767,-32768),this[r]=e>>>8,this[r+1]=e&255,r+2};g.prototype.writeInt32LE=function(e,r,n){return e=+e,r=r>>>0,n||ve(this,e,r,4,2147483647,-2147483648),this[r]=e&255,this[r+1]=e>>>8,this[r+2]=e>>>16,this[r+3]=e>>>24,r+4};g.prototype.writeInt32BE=function(e,r,n){return e=+e,r=r>>>0,n||ve(this,e,r,4,2147483647,-2147483648),e<0&&(e=4294967295+e+1),this[r]=e>>>24,this[r+1]=e>>>16,this[r+2]=e>>>8,this[r+3]=e&255,r+4};g.prototype.writeBigInt64LE=yt(function(e,r=0){return Rs(this,e,r,-BigInt("0x8000000000000000"),BigInt("0x7fffffffffffffff"))});g.prototype.writeBigInt64BE=yt(function(e,r=0){return Cs(this,e,r,-BigInt("0x8000000000000000"),BigInt("0x7fffffffffffffff"))});function Os(t,e,r,n,o,i){if(r+n>t.length)throw new RangeError("Index out of range");if(r<0)throw new RangeError("Index out of range")}function Ns(t,e,r,n,o){return e=+e,r=r>>>0,o||Os(t,e,r,4,34028234663852886e22,-34028234663852886e22),jt.write(t,e,r,n,23,4),r+4}g.prototype.writeFloatLE=function(e,r,n){return Ns(this,e,r,!0,n)};g.prototype.writeFloatBE=function(e,r,n){return Ns(this,e,r,!1,n)};function Ds(t,e,r,n,o){return e=+e,r=r>>>0,o||Os(t,e,r,8,17976931348623157e292,-17976931348623157e292),jt.write(t,e,r,n,52,8),r+8}g.prototype.writeDoubleLE=function(e,r,n){return Ds(this,e,r,!0,n)};g.prototype.writeDoubleBE=function(e,r,n){return Ds(this,e,r,!1,n)};g.prototype.copy=function(e,r,n,o){if(!g.isBuffer(e))throw new TypeError("argument should be a Buffer");if(n||(n=0),!o&&o!==0&&(o=this.length),r>=e.length&&(r=e.length),r||(r=0),o>0&&o=this.length)throw new RangeError("Index out of range");if(o<0)throw new RangeError("sourceEnd out of bounds");o>this.length&&(o=this.length),e.length-r>>0,n=n===void 0?this.length:n>>>0,e||(e=0);let i;if(typeof e=="number")for(i=r;i2**32?o=Is(String(r)):typeof r=="bigint"&&(o=String(r),(r>BigInt(2)**BigInt(32)||r<-(BigInt(2)**BigInt(32)))&&(o=Is(o)),o+="n"),n+=` It must be ${e}. Received ${o}`,n},RangeError);function Is(t){let e="",r=t.length,n=t[0]==="-"?1:0;for(;r>=n+4;r-=3)e=`_${t.slice(r-3,r)}${e}`;return`${t.slice(0,r)}${e}`}function _l(t,e,r){zt(e,"offset"),(t[e]===void 0||t[e+r]===void 0)&&ur(e,t.length-(r+1))}function Ms(t,e,r,n,o,i){if(t>r||t3?e===0||e===BigInt(0)?a=`>= 0${s} and < 2${s} ** ${(i+1)*8}${s}`:a=`>= -(2${s} ** ${(i+1)*8-1}${s}) and < 2 ** ${(i+1)*8-1}${s}`:a=`>= ${e}${s} and <= ${r}${s}`,new qt.ERR_OUT_OF_RANGE("value",a,t)}_l(n,o,i)}function zt(t,e){if(typeof t!="number")throw new qt.ERR_INVALID_ARG_TYPE(e,"number",t)}function ur(t,e,r){throw Math.floor(t)!==t?(zt(t,r),new qt.ERR_OUT_OF_RANGE(r||"offset","an integer",t)):e<0?new qt.ERR_BUFFER_OUT_OF_BOUNDS:new qt.ERR_OUT_OF_RANGE(r||"offset",`>= ${r?1:0} and <= ${e}`,t)}var Ll=/[^+/0-9A-Za-z-_]/g;function Ul(t){if(t=t.split("=")[0],t=t.trim().replace(Ll,""),t.length<2)return"";for(;t.length%4!==0;)t=t+"=";return t}function ho(t,e){e=e||1/0;let r,n=t.length,o=null,i=[];for(let s=0;s55295&&r<57344){if(!o){if(r>56319){(e-=3)>-1&&i.push(239,191,189);continue}else if(s+1===n){(e-=3)>-1&&i.push(239,191,189);continue}o=r;continue}if(r<56320){(e-=3)>-1&&i.push(239,191,189),o=r;continue}r=(o-55296<<10|r-56320)+65536}else o&&(e-=3)>-1&&i.push(239,191,189);if(o=null,r<128){if((e-=1)<0)break;i.push(r)}else if(r<2048){if((e-=2)<0)break;i.push(r>>6|192,r&63|128)}else if(r<65536){if((e-=3)<0)break;i.push(r>>12|224,r>>6&63|128,r&63|128)}else if(r<1114112){if((e-=4)<0)break;i.push(r>>18|240,r>>12&63|128,r>>6&63|128,r&63|128)}else throw new Error("Invalid code point")}return i}function Pl(t){let e=[];for(let r=0;r>8,o=r%256,i.push(o),i.push(n);return i}function Hs(t){return lo.toByteArray(Ul(t))}function qr(t,e,r,n){let o;for(o=0;o=e.length||o>=t.length);++o)e[o+r]=t[o];return o}function We(t,e){return t instanceof e||t!=null&&t.constructor!=null&&t.constructor.name!=null&&t.constructor.name===e.name}function mo(t){return t!==t}var Cl=(function(){let t="0123456789abcdef",e=new Array(256);for(let r=0;r<16;++r){let n=r*16;for(let o=0;o<16;++o)e[n+o]=t[r]+t[o]}return e})();function yt(t){return typeof BigInt>"u"?Ol:t}function Ol(){throw new Error("BigInt not supported")}});b();b();b();b();var di;(function(t){t[t.SET_METADATA=0]="SET_METADATA",t[t.TEXT_NOTE=1]="TEXT_NOTE",t[t.RECOMMEND_SERVER=2]="RECOMMEND_SERVER",t[t.CONTACTS=3]="CONTACTS",t[t.ENCRYPTED_DIRECT_MESSAGE=4]="ENCRYPTED_DIRECT_MESSAGE",t[t.EVENT_DELETION=5]="EVENT_DELETION",t[t.REPOST=6]="REPOST",t[t.REACTION=7]="REACTION",t[t.CHANNEL_CREATION=40]="CHANNEL_CREATION",t[t.CHANNEL_METADATA=41]="CHANNEL_METADATA",t[t.CHANNEL_MESSAGE=42]="CHANNEL_MESSAGE",t[t.CHANNEL_HIDE_MESSAGE=43]="CHANNEL_HIDE_MESSAGE",t[t.CHANNEL_MUTE_USER=44]="CHANNEL_MUTE_USER",t[t.AUTH=22242]="AUTH",t[t.AUTH_RESPONSE=22243]="AUTH_RESPONSE"})(di||(di={}));var Er;(function(t){t.EVENT="EVENT",t.NOTICE="NOTICE",t.OK="OK",t.EOSE="EOSE",t.REQ="REQ",t.CLOSE="CLOSE",t.AUTH="AUTH"})(Er||(Er={}));b();b();b();b();var vr;(function(t){t.CONNECT="connect",t.PING="ping",t.GET_PUBLIC_KEY="get_public_key",t.SIGN_EVENT="sign_event",t.NIP04_ENCRYPT="nip04_encrypt",t.NIP04_DECRYPT="nip04_decrypt",t.NIP44_ENCRYPT="nip44_encrypt",t.NIP44_DECRYPT="nip44_decrypt",t.GET_RELAYS="get_relays"})(vr||(vr={}));var Bn;(function(t){t[t.SET_METADATA=0]="SET_METADATA",t[t.TEXT_NOTE=1]="TEXT_NOTE",t[t.RECOMMEND_SERVER=2]="RECOMMEND_SERVER",t[t.CONTACT_LIST=3]="CONTACT_LIST",t[t.ENCRYPTED_DIRECT_MESSAGE=4]="ENCRYPTED_DIRECT_MESSAGE",t[t.DELETE=5]="DELETE",t[t.REPOST=6]="REPOST",t[t.REACTION=7]="REACTION",t[t.BADGE_AWARD=8]="BADGE_AWARD",t[t.CHANNEL_CREATE=40]="CHANNEL_CREATE",t[t.CHANNEL_METADATA=41]="CHANNEL_METADATA",t[t.CHANNEL_MESSAGE=42]="CHANNEL_MESSAGE",t[t.CHANNEL_HIDE_MESSAGE=43]="CHANNEL_HIDE_MESSAGE",t[t.CHANNEL_MUTE_USER=44]="CHANNEL_MUTE_USER",t[t.CHANNEL_RESERVE=45]="CHANNEL_RESERVE",t[t.REPORTING=1984]="REPORTING",t[t.ZAP_REQUEST=9734]="ZAP_REQUEST",t[t.ZAP=9735]="ZAP",t[t.MUTE_LIST=1e4]="MUTE_LIST",t[t.PIN_LIST=10001]="PIN_LIST",t[t.RELAY_LIST_METADATA=10002]="RELAY_LIST_METADATA",t[t.CLIENT_AUTH=22242]="CLIENT_AUTH",t[t.AUTH_RESPONSE=22243]="AUTH_RESPONSE",t[t.NOSTR_CONNECT=24133]="NOSTR_CONNECT",t[t.CATEGORIZED_PEOPLE=3e4]="CATEGORIZED_PEOPLE",t[t.CATEGORIZED_BOOKMARKS=30001]="CATEGORIZED_BOOKMARKS",t[t.PROFILE_BADGES=30008]="PROFILE_BADGES",t[t.BADGE_DEFINITION=30009]="BADGE_DEFINITION",t[t.LONG_FORM=30023]="LONG_FORM",t[t.APPLICATION_SPECIFIC=30078]="APPLICATION_SPECIFIC"})(Bn||(Bn={}));b();b();b();b();b();function tr(t){return t instanceof Uint8Array||ArrayBuffer.isView(t)&&t.constructor.name==="Uint8Array"}function te(t,e=""){if(!Number.isSafeInteger(t)||t<0){let r=e&&`"${e}" `;throw new Error(`${r}expected integer >= 0, got ${t}`)}}function F(t,e,r=""){let n=tr(t),o=t?.length,i=e!==void 0;if(!n||i&&o!==e){let s=r&&`"${r}" `,a=i?` of length ${e}`:"",c=n?`length=${o}`:`type=${typeof t}`;throw new Error(s+"expected Uint8Array"+a+", got "+c)}return t}function Qe(t){if(typeof t!="function"||typeof t.create!="function")throw new Error("Hash must wrapped by utils.createHasher");te(t.outputLen),te(t.blockLen)}function Ot(t,e=!0){if(t.destroyed)throw new Error("Hash instance has been destroyed");if(e&&t.finished)throw new Error("Hash#digest() has already been called")}function pi(t,e){F(t,void 0,"digestInto() output");let r=e.outputLen;if(t.length='+r)}function kr(t){return new Uint32Array(t.buffer,t.byteOffset,Math.floor(t.byteLength/4))}function Be(...t){for(let e=0;e>>e}function j(t,e){return t<>>32-e>>>0}var sc=new Uint8Array(new Uint32Array([287454020]).buffer)[0]===68;function ac(t){return t<<24&4278190080|t<<8&16711680|t>>>8&65280|t>>>24&255}function cc(t){for(let e=0;et:cc,yi=typeof Uint8Array.from([]).toHex=="function"&&typeof Uint8Array.fromHex=="function",lc=Array.from({length:256},(t,e)=>e.toString(16).padStart(2,"0"));function Ee(t){if(F(t),yi)return t.toHex();let e="";for(let r=0;r=Xe._0&&t<=Xe._9)return t-Xe._0;if(t>=Xe.A&&t<=Xe.F)return t-(Xe.A-10);if(t>=Xe.a&&t<=Xe.f)return t-(Xe.a-10)}function oe(t){if(typeof t!="string")throw new Error("hex string expected, got "+typeof t);if(yi)return Uint8Array.fromHex(t);let e=t.length,r=e/2;if(e%2)throw new Error("hex string expected, got unpadded hex of length "+e);let n=new Uint8Array(r);for(let o=0,i=0;ot(i).update(o).digest(),n=t(void 0);return r.outputLen=n.outputLen,r.blockLen=n.blockLen,r.create=o=>t(o),Object.assign(r,e),Object.freeze(r)}function ge(t=32){let e=typeof globalThis=="object"?globalThis.crypto:null;if(typeof e?.getRandomValues!="function")throw new Error("crypto.getRandomValues must be defined");return e.getRandomValues(new Uint8Array(t))}var mi=t=>({oid:Uint8Array.from([6,9,96,134,72,1,101,3,4,2,t])});function wi(t,e,r){return t&e^~t&r}function bi(t,e,r){return t&e^t&r^e&r}var Br=class{blockLen;outputLen;padOffset;isLE;buffer;view;finished=!1;length=0;pos=0;destroyed=!1;constructor(e,r,n,o){this.blockLen=e,this.outputLen=r,this.padOffset=n,this.isLE=o,this.buffer=new Uint8Array(e),this.view=Nt(this.buffer)}update(e){Ot(this),F(e);let{view:r,buffer:n,blockLen:o}=this,i=e.length;for(let s=0;so-s&&(this.process(n,0),s=0);for(let u=s;uf.length)throw new Error("_sha2: outputLen bigger than state");for(let u=0;u>>3,p=Ke(d,17)^Ke(d,19)^d>>>10;ut[u]=p+ut[u-7]+y+ut[u-16]|0}let{A:n,B:o,C:i,D:s,E:a,F:c,G:l,H:f}=this;for(let u=0;u<64;u++){let h=Ke(a,6)^Ke(a,11)^Ke(a,25),d=f+h+wi(a,c,l)+fc[u]+ut[u]|0,p=(Ke(n,2)^Ke(n,13)^Ke(n,22))+bi(n,o,i)|0;f=l,l=c,c=a,a=s+d|0,s=i,i=o,o=n,n=d+p|0}n=n+this.A|0,o=o+this.B|0,i=i+this.C|0,s=s+this.D|0,a=a+this.E|0,c=c+this.F|0,l=l+this.G|0,f=f+this.H|0,this.set(n,o,i,s,a,c,l,f)}roundClean(){Be(ut)}destroy(){this.set(0,0,0,0,0,0,0,0),Be(this.buffer)}},_n=class extends Tn{A=et[0]|0;B=et[1]|0;C=et[2]|0;D=et[3]|0;E=et[4]|0;F=et[5]|0;G=et[6]|0;H=et[7]|0;constructor(){super(32)}};var pe=gi(()=>new _n,mi(1));b();b();var Un=BigInt(0),Ln=BigInt(1);function rr(t,e=""){if(typeof t!="boolean"){let r=e&&`"${e}" `;throw new Error(r+"expected boolean, got type="+typeof t)}return t}function xi(t){if(typeof t=="bigint"){if(!Sr(t))throw new Error("positive bigint expected, got "+t)}else te(t);return t}function nr(t){let e=xi(t).toString(16);return e.length&1?"0"+e:e}function Ei(t){if(typeof t!="string")throw new Error("hex string expected, got "+typeof t);return t===""?Un:BigInt("0x"+t)}function ft(t){return Ei(Ee(t))}function Pn(t){return Ei(Ee(dc(F(t)).reverse()))}function Ir(t,e){te(e),t=xi(t);let r=oe(t.toString(16).padStart(e*2,"0"));if(r.length!==e)throw new Error("number too large");return r}function Rn(t,e){return Ir(t,e).reverse()}function dc(t){return Uint8Array.from(t)}function vi(t){return Uint8Array.from(t,(e,r)=>{let n=e.charCodeAt(0);if(e.length!==1||n>127)throw new Error(`string contains non-ASCII character "${t[r]}" with code ${n} at position ${r}`);return n})}var Sr=t=>typeof t=="bigint"&&Un<=t;function hc(t,e,r){return Sr(t)&&Sr(e)&&Sr(r)&&e<=t&&tUn;t>>=Ln,e+=1);return e}var or=t=>(Ln<new Uint8Array(w),o=Uint8Array.of(),i=Uint8Array.of(0),s=Uint8Array.of(1),a=1e3,c=n(t),l=n(t),f=0,u=()=>{c.fill(1),l.fill(0),f=0},h=(...w)=>r(l,ie(c,...w)),d=(w=o)=>{l=h(i,w),c=h(),w.length!==0&&(l=h(s,w),c=h())},y=()=>{if(f++>=a)throw new Error("drbg: tried max amount of iterations");let w=0,k=[];for(;w{u(),d(w);let O;for(;!(O=k(y()));)d();return u(),O}}function ir(t,e={},r={}){if(!t||typeof t!="object")throw new Error("expected valid options object");function n(i,s,a){let c=t[i];if(a&&c===void 0)return;let l=typeof c;if(l!==s||c===null)throw new Error(`param "${i}" is invalid: expected ${s}, got ${l}`)}let o=(i,s)=>Object.entries(i).forEach(([a,c])=>n(a,c,s));o(e,!1),o(r,!0)}function On(t){let e=new WeakMap;return(r,...n)=>{let o=e.get(r);if(o!==void 0)return o;let i=t(r,...n);return e.set(r,i),i}}b();var me=BigInt(0),ye=BigInt(1),xt=BigInt(2),Ii=BigInt(3),Ti=BigInt(4),_i=BigInt(5),pc=BigInt(7),Li=BigInt(8),yc=BigInt(9),Ui=BigInt(16);function Ve(t,e){let r=t%e;return r>=me?r:e+r}function Se(t,e,r){let n=t;for(;e-- >me;)n*=n,n%=r;return n}function Bi(t,e){if(t===me)throw new Error("invert: expected non-zero number");if(e<=me)throw new Error("invert: expected positive modulus, got "+e);let r=Ve(t,e),n=e,o=me,i=ye,s=ye,a=me;for(;r!==me;){let l=n/r,f=n%r,u=o-s*l,h=i-a*l;n=r,r=f,o=s,i=a,s=u,a=h}if(n!==ye)throw new Error("invert: does not exist");return Ve(o,e)}function Dn(t,e,r){if(!t.eql(t.sqr(e),r))throw new Error("Cannot find square root")}function Pi(t,e){let r=(t.ORDER+ye)/Ti,n=t.pow(e,r);return Dn(t,n,e),n}function gc(t,e){let r=(t.ORDER-_i)/Li,n=t.mul(e,xt),o=t.pow(n,r),i=t.mul(e,o),s=t.mul(t.mul(i,xt),o),a=t.mul(i,t.sub(s,t.ONE));return Dn(t,a,e),a}function mc(t){let e=Dt(t),r=Ri(t),n=r(e,e.neg(e.ONE)),o=r(e,n),i=r(e,e.neg(n)),s=(t+pc)/Ui;return(a,c)=>{let l=a.pow(c,s),f=a.mul(l,n),u=a.mul(l,o),h=a.mul(l,i),d=a.eql(a.sqr(f),c),y=a.eql(a.sqr(u),c);l=a.cmov(l,f,d),f=a.cmov(h,u,y);let p=a.eql(a.sqr(f),c),w=a.cmov(l,f,p);return Dn(a,w,c),w}}function Ri(t){if(t1e3)throw new Error("Cannot find square root: probably non-prime P");if(r===1)return Pi;let i=o.pow(n,e),s=(e+ye)/xt;return function(c,l){if(c.is0(l))return l;if(Si(c,l)!==1)throw new Error("Cannot find square root");let f=r,u=c.mul(c.ONE,i),h=c.pow(l,e),d=c.pow(l,s);for(;!c.eql(h,c.ONE);){if(c.is0(h))return c.ZERO;let y=1,p=c.sqr(h);for(;!c.eql(p,c.ONE);)if(y++,p=c.sqr(p),y===f)throw new Error("Cannot find square root");let w=ye<(n[o]="function",n),e);return ir(t,r),t}function xc(t,e,r){if(rme;)r&ye&&(n=t.mul(n,o)),o=t.sqr(o),r>>=ye;return n}function Tr(t,e,r=!1){let n=new Array(e.length).fill(r?t.ZERO:void 0),o=e.reduce((s,a,c)=>t.is0(a)?s:(n[c]=s,t.mul(s,a)),t.ONE),i=t.inv(o);return e.reduceRight((s,a,c)=>t.is0(a)?s:(n[c]=t.mul(s,n[c]),t.mul(s,a)),i),n}function Si(t,e){let r=(t.ORDER-ye)/xt,n=t.pow(e,r),o=t.eql(n,t.ONE),i=t.eql(n,t.ZERO),s=t.eql(n,t.neg(t.ONE));if(!o&&!i&&!s)throw new Error("invalid Legendre symbol result");return o?1:i?0:-1}function Ec(t,e){e!==void 0&&te(e);let r=e!==void 0?e:t.toString(2).length,n=Math.ceil(r/8);return{nBitLength:r,nByteLength:n}}var Nn=class{ORDER;BITS;BYTES;isLE;ZERO=me;ONE=ye;_lengths;_sqrt;_mod;constructor(e,r={}){if(e<=me)throw new Error("invalid field: expected ORDER > 0, got "+e);let n;this.isLE=!1,r!=null&&typeof r=="object"&&(typeof r.BITS=="number"&&(n=r.BITS),typeof r.sqrt=="function"&&(this.sqrt=r.sqrt),typeof r.isLE=="boolean"&&(this.isLE=r.isLE),r.allowedLengths&&(this._lengths=r.allowedLengths?.slice()),typeof r.modFromBytes=="boolean"&&(this._mod=r.modFromBytes));let{nBitLength:o,nByteLength:i}=Ec(e,n);if(i>2048)throw new Error("invalid field: expected ORDER of <= 2048 bytes");this.ORDER=e,this.BITS=o,this.BYTES=i,this._sqrt=void 0,Object.preventExtensions(this)}create(e){return Ve(e,this.ORDER)}isValid(e){if(typeof e!="bigint")throw new Error("invalid field element: expected bigint, got "+typeof e);return me<=e&&eo)throw new Error("Field.fromBytes: expected "+n+" bytes, got "+e.length);let l=new Uint8Array(o);l.set(e,i?0:l.length-e.length),e=l}if(e.length!==o)throw new Error("Field.fromBytes: expected "+o+" bytes, got "+e.length);let c=i?Pn(e):ft(e);if(a&&(c=Ve(c,s)),!r&&!this.isValid(c))throw new Error("invalid field element: outside of range 0..ORDER");return c}invertBatch(e){return Tr(this,e)}cmov(e,r,n){return n?r:e}};function Dt(t,e={}){return new Nn(t,e)}function Ci(t){if(typeof t!="bigint")throw new Error("field order must be bigint");let e=t.toString(2).length;return Math.ceil(e/8)}function Hn(t){let e=Ci(t);return e+Math.ceil(e/2)}function _r(t,e,r=!1){F(t);let n=t.length,o=Ci(e),i=Hn(e);if(n<16||n1024)throw new Error("expected "+i+"-1024 bytes of input, got "+n);let s=r?Pn(t):ft(t),a=Ve(s,e-ye)+ye;return r?Rn(a,o):Ir(a,o)}var Mt=BigInt(0),Et=BigInt(1);function sr(t,e){let r=e.negate();return t?r:e}function $n(t,e){let r=Tr(t.Fp,e.map(n=>n.Z));return e.map((n,o)=>t.fromAffine(n.toAffine(r[o])))}function Mi(t,e){if(!Number.isSafeInteger(t)||t<=0||t>e)throw new Error("invalid window size, expected [1.."+e+"], got W="+t)}function Kn(t,e){Mi(t,e);let r=Math.ceil(e/t)+1,n=2**(t-1),o=2**t,i=or(t),s=BigInt(t);return{windows:r,windowSize:n,mask:i,maxNumber:o,shiftBy:s}}function Oi(t,e,r){let{windowSize:n,mask:o,maxNumber:i,shiftBy:s}=r,a=Number(t&o),c=t>>s;a>n&&(a-=i,c+=Et);let l=e*n,f=l+Math.abs(a)-1,u=a===0,h=a<0,d=e%2!==0;return{nextN:c,offset:f,isZero:u,isNeg:h,isNegF:d,offsetF:l}}var Vn=new WeakMap,Hi=new WeakMap;function Fn(t){return Hi.get(t)||1}function Ni(t){if(t!==Mt)throw new Error("invalid wNAF")}var Lr=class{BASE;ZERO;Fn;bits;constructor(e,r){this.BASE=e.BASE,this.ZERO=e.ZERO,this.Fn=e.Fn,this.bits=r}_unsafeLadder(e,r,n=this.ZERO){let o=e;for(;r>Mt;)r&Et&&(n=n.add(o)),o=o.double(),r>>=Et;return n}precomputeWindow(e,r){let{windows:n,windowSize:o}=Kn(r,this.bits),i=[],s=e,a=s;for(let c=0;cMt||n>Mt;)r&Et&&(i=i.add(o)),n&Et&&(s=s.add(o)),o=o.double(),r>>=Et,n>>=Et;return{p1:i,p2:s}}function Di(t,e,r){if(e){if(e.ORDER!==t)throw new Error("Field.ORDER must match order: Fp == p, Fn == n");return Mn(e),e}else return Dt(t,{isLE:r})}function Vi(t,e,r={},n){if(n===void 0&&(n=t==="edwards"),!e||typeof e!="object")throw new Error(`expected valid ${t} CURVE object`);for(let c of["p","n","h"]){let l=e[c];if(!(typeof l=="bigint"&&l>Mt))throw new Error(`CURVE.${c} must be positive bigint`)}let o=Di(e.p,r.Fp,n),i=Di(e.n,r.Fn,n),a=["Gx","Gy","a",t==="weierstrass"?"b":"d"];for(let c of a)if(!o.isValid(e[c]))throw new Error(`CURVE.${c} must be valid field element of CURVE.Fp`);return e=Object.freeze(Object.assign({},e)),{CURVE:e,Fp:o,Fn:i}}function Ur(t,e){return function(n){let o=t(n);return{secretKey:o,publicKey:e(o)}}}b();b();var Pr=class{oHash;iHash;blockLen;outputLen;finished=!1;destroyed=!1;constructor(e,r){if(Qe(e),F(r,void 0,"key"),this.iHash=e.create(),typeof this.iHash.update!="function")throw new Error("Expected instance of class which extends utils.Hash");this.blockLen=this.iHash.blockLen,this.outputLen=this.iHash.outputLen;let n=this.blockLen,o=new Uint8Array(n);o.set(r.length>n?e.create().update(r).digest():r);for(let i=0;inew Pr(t,e).update(r).digest();Fe.create=(t,e)=>new Pr(t,e);var Fi=(t,e)=>(t+(t>=0?e:-e)/$i)/e;function vc(t,e,r){let[[n,o],[i,s]]=e,a=Fi(s*t,r),c=Fi(-o*t,r),l=t-a*n-c*i,f=-a*o-c*s,u=l=d||f=d)throw new Error("splitScalar (endomorphism): failed, k="+t);return{k1neg:u,k1:l,k2neg:h,k2:f}}function jn(t){if(!["compact","recovered","der"].includes(t))throw new Error('Signature format must be "compact", "recovered", or "der"');return t}function qn(t,e){let r={};for(let n of Object.keys(e))r[n]=t[n]===void 0?e[n]:t[n];return rr(r.lowS,"lowS"),rr(r.prehash,"prehash"),r.format!==void 0&&jn(r.format),r}var zn=class extends Error{constructor(e=""){super(e)}},dt={Err:zn,_tlv:{encode:(t,e)=>{let{Err:r}=dt;if(t<0||t>256)throw new r("tlv.encode: wrong tag");if(e.length&1)throw new r("tlv.encode: unpadded data");let n=e.length/2,o=nr(n);if(o.length/2&128)throw new r("tlv.encode: long form length too big");let i=n>127?nr(o.length/2|128):"";return nr(t)+i+o+e},decode(t,e){let{Err:r}=dt,n=0;if(t<0||t>256)throw new r("tlv.encode: wrong tag");if(e.length<2||e[n++]!==t)throw new r("tlv.decode: wrong tlv");let o=e[n++],i=!!(o&128),s=0;if(!i)s=o;else{let c=o&127;if(!c)throw new r("tlv.decode(long): indefinite length not supported");if(c>4)throw new r("tlv.decode(long): byte length is too big");let l=e.subarray(n,n+c);if(l.length!==c)throw new r("tlv.decode: length bytes not complete");if(l[0]===0)throw new r("tlv.decode(long): zero leftmost byte");for(let f of l)s=s<<8|f;if(n+=c,s<128)throw new r("tlv.decode(long): not minimal encoding")}let a=e.subarray(n,n+s);if(a.length!==s)throw new r("tlv.decode: wrong value length");return{v:a,l:e.subarray(n+s)}}},_int:{encode(t){let{Err:e}=dt;if(t{let{X:x,Y:m,Z:A}=P;if(n.eql(A,n.ONE))return{x,y:m};let S=P.is0();E==null&&(E=S?n.ONE:n.inv(A));let I=n.mul(x,E),v=n.mul(m,E),B=n.mul(A,E);if(S)return{x:n.ZERO,y:n.ZERO};if(!n.eql(B,n.ONE))throw new Error("invZ was invalid");return{x:I,y:v}}),q=On(P=>{if(P.is0()){if(e.allowInfinityPoint&&!n.is0(P.Y))return;throw new Error("bad point: ZERO")}let{x:E,y:x}=P.toAffine();if(!n.isValid(E)||!n.isValid(x))throw new Error("bad point: x or y not field elements");if(!w(E,x))throw new Error("bad point: equation left != right");if(!P.isTorsionFree())throw new Error("bad point: not in prime-order subgroup");return!0});function G(P,E,x,m,A){return x=new C(n.mul(x.X,P),x.Y,x.Z),E=sr(m,E),x=sr(A,x),E.add(x)}class C{static BASE=new C(i.Gx,i.Gy,n.ONE);static ZERO=new C(n.ZERO,n.ONE,n.ZERO);static Fp=n;static Fn=o;X;Y;Z;constructor(E,x,m){this.X=D("x",E),this.Y=D("y",x,!0),this.Z=D("z",m),Object.freeze(this)}static CURVE(){return i}static fromAffine(E){let{x,y:m}=E||{};if(!E||!n.isValid(x)||!n.isValid(m))throw new Error("invalid affine point");if(E instanceof C)throw new Error("projective point not allowed");return n.is0(x)&&n.is0(m)?C.ZERO:new C(x,m,n.ONE)}static fromBytes(E){let x=C.fromAffine(y(F(E,void 0,"point")));return x.assertValidity(),x}static fromHex(E){return C.fromBytes(oe(E))}get x(){return this.toAffine().x}get y(){return this.toAffine().y}precompute(E=8,x=!0){return K.createCache(this,E),x||this.multiply(Rr),this}assertValidity(){q(this)}hasEvenY(){let{y:E}=this.toAffine();if(!n.isOdd)throw new Error("Field doesn't support isOdd");return!n.isOdd(E)}equals(E){H(E);let{X:x,Y:m,Z:A}=this,{X:S,Y:I,Z:v}=E,B=n.eql(n.mul(x,v),n.mul(S,A)),T=n.eql(n.mul(m,v),n.mul(I,A));return B&&T}negate(){return new C(this.X,n.neg(this.Y),this.Z)}double(){let{a:E,b:x}=i,m=n.mul(x,Rr),{X:A,Y:S,Z:I}=this,v=n.ZERO,B=n.ZERO,T=n.ZERO,L=n.mul(A,A),Y=n.mul(S,S),z=n.mul(I,I),V=n.mul(A,S);return V=n.add(V,V),T=n.mul(A,I),T=n.add(T,T),v=n.mul(E,T),B=n.mul(m,z),B=n.add(v,B),v=n.sub(Y,B),B=n.add(Y,B),B=n.mul(v,B),v=n.mul(V,v),T=n.mul(m,T),z=n.mul(E,z),V=n.sub(L,z),V=n.mul(E,V),V=n.add(V,T),T=n.add(L,L),L=n.add(T,L),L=n.add(L,z),L=n.mul(L,V),B=n.add(B,L),z=n.mul(S,I),z=n.add(z,z),L=n.mul(z,V),v=n.sub(v,L),T=n.mul(z,Y),T=n.add(T,T),T=n.add(T,T),new C(v,B,T)}add(E){H(E);let{X:x,Y:m,Z:A}=this,{X:S,Y:I,Z:v}=E,B=n.ZERO,T=n.ZERO,L=n.ZERO,Y=i.a,z=n.mul(i.b,Rr),V=n.mul(x,S),Z=n.mul(m,I),ee=n.mul(A,v),fe=n.add(x,m),J=n.add(S,I);fe=n.mul(fe,J),J=n.add(V,Z),fe=n.sub(fe,J),J=n.add(x,A);let he=n.add(S,v);return J=n.mul(J,he),he=n.add(V,ee),J=n.sub(J,he),he=n.add(m,A),B=n.add(I,v),he=n.mul(he,B),B=n.add(Z,ee),he=n.sub(he,B),L=n.mul(Y,J),B=n.mul(z,ee),L=n.add(B,L),B=n.sub(Z,L),L=n.add(Z,L),T=n.mul(B,L),Z=n.add(V,V),Z=n.add(Z,V),ee=n.mul(Y,ee),J=n.mul(z,J),Z=n.add(Z,ee),ee=n.sub(V,ee),ee=n.mul(Y,ee),J=n.add(J,ee),V=n.mul(Z,J),T=n.add(T,V),V=n.mul(he,J),B=n.mul(fe,B),B=n.sub(B,V),V=n.mul(fe,Z),L=n.mul(he,L),L=n.add(L,V),new C(B,T,L)}subtract(E){return this.add(E.negate())}is0(){return this.equals(C.ZERO)}multiply(E){let{endo:x}=e;if(!o.isValidNot0(E))throw new Error("invalid scalar: out of range");let m,A,S=I=>K.cached(this,I,v=>$n(C,v));if(x){let{k1neg:I,k1:v,k2neg:B,k2:T}=X(E),{p:L,f:Y}=S(v),{p:z,f:V}=S(T);A=Y.add(V),m=G(x.beta,L,z,I,B)}else{let{p:I,f:v}=S(E);m=I,A=v}return $n(C,[m,A])[0]}multiplyUnsafe(E){let{endo:x}=e,m=this;if(!o.isValid(E))throw new Error("invalid scalar: out of range");if(E===tt||m.is0())return C.ZERO;if(E===Ht)return m;if(K.hasCache(this))return this.multiply(E);if(x){let{k1neg:A,k1:S,k2neg:I,k2:v}=X(E),{p1:B,p2:T}=Ki(C,m,S,v);return G(x.beta,B,T,A,I)}else return K.unsafe(m,E)}toAffine(E){return M(this,E)}isTorsionFree(){let{isTorsionFree:E}=e;return s===Ht?!0:E?E(C,this):K.unsafe(this,a).is0()}clearCofactor(){let{clearCofactor:E}=e;return s===Ht?this:E?E(C,this):this.multiplyUnsafe(s)}isSmallOrder(){return this.multiplyUnsafe(s).is0()}toBytes(E=!0){return rr(E,"isCompressed"),this.assertValidity(),d(C,this,E)}toHex(E=!0){return Ee(this.toBytes(E))}toString(){return``}}let $=o.BITS,K=new Lr(C,e.endo?Math.ceil($/2):$);return C.BASE.precompute(8),C}function ji(t){return Uint8Array.of(t?2:3)}function zi(t,e){return{secretKey:e.BYTES,publicKey:1+t.BYTES,publicKeyUncompressed:1+2*t.BYTES,publicKeyHasPrefix:!0,signature:2*e.BYTES}}function Ac(t,e={}){let{Fn:r}=t,n=e.randomBytes||ge,o=Object.assign(zi(t.Fp,r),{seed:Hn(r.ORDER)});function i(d){try{let y=r.fromBytes(d);return r.isValidNot0(y)}catch{return!1}}function s(d,y){let{publicKey:p,publicKeyUncompressed:w}=o;try{let k=d.length;return y===!0&&k!==p||y===!1&&k!==w?!1:!!t.fromBytes(d)}catch{return!1}}function a(d=n(o.seed)){return _r(F(d,o.seed,"seed"),r.ORDER)}function c(d,y=!0){return t.BASE.multiply(r.fromBytes(d)).toBytes(y)}function l(d){let{secretKey:y,publicKey:p,publicKeyUncompressed:w}=o;if(!tr(d)||"_lengths"in r&&r._lengths||y===p)return;let k=F(d,void 0,"key").length;return k===p||k===w}function f(d,y,p=!0){if(l(d)===!0)throw new Error("first arg must be private key");if(l(y)===!1)throw new Error("second arg must be public key");let w=r.fromBytes(d);return t.fromBytes(y).multiply(w).toBytes(p)}let u={isValidSecretKey:i,isValidPublicKey:s,randomSecretKey:a},h=Ur(a,c);return Object.freeze({getPublicKey:c,getSharedSecret:f,keygen:h,Point:t,utils:u,lengths:o})}function Wi(t,e,r={}){Qe(e),ir(r,{},{hmac:"function",lowS:"boolean",randomBytes:"function",bits2int:"function",bits2int_modN:"function"}),r=Object.assign({},r);let n=r.randomBytes||ge,o=r.hmac||((x,m)=>Fe(e,x,m)),{Fp:i,Fn:s}=t,{ORDER:a,BITS:c}=s,{keygen:l,getPublicKey:f,getSharedSecret:u,utils:h,lengths:d}=Ac(t,r),y={prehash:!0,lowS:typeof r.lowS=="boolean"?r.lowS:!0,format:"compact",extraEntropy:!1},p=a*$i>Ht;return x>m}function k(x,m){if(!s.isValidNot0(m))throw new Error(`invalid signature ${x}: out of range 1..Point.Fn.ORDER`);return m}function O(){if(p)throw new Error('"recovered" sig type is not supported for cofactor >2 curves')}function D(x,m){jn(m);let A=d.signature,S=m==="compact"?A:m==="recovered"?A+1:void 0;return F(x,S)}class H{r;s;recovery;constructor(m,A,S){if(this.r=k("r",m),this.s=k("s",A),S!=null){if(O(),![0,1,2,3].includes(S))throw new Error("invalid recovery id");this.recovery=S}Object.freeze(this)}static fromBytes(m,A=y.format){D(m,A);let S;if(A==="der"){let{r:T,s:L}=dt.toSig(F(m));return new H(T,L)}A==="recovered"&&(S=m[0],A="compact",m=m.subarray(1));let I=d.signature/2,v=m.subarray(0,I),B=m.subarray(I,I*2);return new H(s.fromBytes(v),s.fromBytes(B),S)}static fromHex(m,A){return this.fromBytes(oe(m),A)}assertRecovery(){let{recovery:m}=this;if(m==null)throw new Error("invalid recovery id: must be present");return m}addRecoveryBit(m){return new H(this.r,this.s,m)}recoverPublicKey(m){let{r:A,s:S}=this,I=this.assertRecovery(),v=I===2||I===3?A+a:A;if(!i.isValid(v))throw new Error("invalid recovery id: sig.r+curve.n != R.x");let B=i.toBytes(v),T=t.fromBytes(ie(ji((I&1)===0),B)),L=s.inv(v),Y=M(F(m,void 0,"msgHash")),z=s.create(-Y*L),V=s.create(S*L),Z=t.BASE.multiplyUnsafe(z).add(T.multiplyUnsafe(V));if(Z.is0())throw new Error("invalid recovery: point at infinify");return Z.assertValidity(),Z}hasHighS(){return w(this.s)}toBytes(m=y.format){if(jn(m),m==="der")return oe(dt.hexFromSig(this));let{r:A,s:S}=this,I=s.toBytes(A),v=s.toBytes(S);return m==="recovered"?(O(),ie(Uint8Array.of(this.assertRecovery()),I,v)):ie(I,v)}toHex(m){return Ee(this.toBytes(m))}}let X=r.bits2int||function(m){if(m.length>8192)throw new Error("input is too large");let A=ft(m),S=m.length*8-c;return S>0?A>>BigInt(S):A},M=r.bits2int_modN||function(m){return s.create(X(m))},q=or(c);function G(x){return ki("num < 2^"+c,x,tt,q),s.toBytes(x)}function C(x,m){return F(x,void 0,"message"),m?F(e(x),void 0,"prehashed message"):x}function $(x,m,A){let{lowS:S,prehash:I,extraEntropy:v}=qn(A,y);x=C(x,I);let B=M(x),T=s.fromBytes(m);if(!s.isValidNot0(T))throw new Error("invalid private key");let L=[G(T),G(B)];if(v!=null&&v!==!1){let Z=v===!0?n(d.secretKey):v;L.push(F(Z,void 0,"extraEntropy"))}let Y=ie(...L),z=B;function V(Z){let ee=X(Z);if(!s.isValidNot0(ee))return;let fe=s.inv(ee),J=t.BASE.multiply(ee).toAffine(),he=s.create(J.x);if(he===tt)return;let xr=s.create(fe*s.create(z+he*T));if(xr===tt)return;let ui=(J.x===he?0:2)|Number(J.y&Ht),fi=xr;return S&&w(xr)&&(fi=s.neg(xr),ui^=1),new H(he,fi,p?void 0:ui)}return{seed:Y,k2sig:V}}function K(x,m,A={}){let{seed:S,k2sig:I}=$(x,m,A);return Ai(e.outputLen,s.BYTES,o)(S,I).toBytes(A.format)}function P(x,m,A,S={}){let{lowS:I,prehash:v,format:B}=qn(S,y);if(A=F(A,void 0,"publicKey"),m=C(m,v),!tr(x)){let T=x instanceof H?", use sig.toBytes()":"";throw new Error("verify expects Uint8Array signature"+T)}D(x,B);try{let T=H.fromBytes(x,B),L=t.fromBytes(A);if(I&&T.hasHighS())return!1;let{r:Y,s:z}=T,V=M(m),Z=s.inv(z),ee=s.create(V*Z),fe=s.create(Y*Z),J=t.BASE.multiplyUnsafe(ee).add(L.multiplyUnsafe(fe));return J.is0()?!1:s.create(J.x)===Y}catch{return!1}}function E(x,m,A={}){let{prehash:S}=qn(A,y);return m=C(m,S),H.fromBytes(x,"recovered").recoverPublicKey(m).toBytes()}return Object.freeze({keygen:l,getPublicKey:f,getSharedSecret:u,utils:h,lengths:d,Point:t,sign:K,verify:P,recoverPublicKey:E,Signature:H,hash:e})}var Nr={p:BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"),n:BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"),h:BigInt(1),a:BigInt(0),b:BigInt(7),Gx:BigInt("0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"),Gy:BigInt("0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8")},Bc={beta:BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),basises:[[BigInt("0x3086d221a7d46bcde86c90e49284eb15"),-BigInt("0xe4437ed6010e88286f547fa90abfe4c3")],[BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8"),BigInt("0x3086d221a7d46bcde86c90e49284eb15")]]},Sc=BigInt(0),Wn=BigInt(2);function Ic(t){let e=Nr.p,r=BigInt(3),n=BigInt(6),o=BigInt(11),i=BigInt(22),s=BigInt(23),a=BigInt(44),c=BigInt(88),l=t*t*t%e,f=l*l*t%e,u=Se(f,r,e)*f%e,h=Se(u,r,e)*f%e,d=Se(h,Wn,e)*l%e,y=Se(d,o,e)*d%e,p=Se(y,i,e)*y%e,w=Se(p,a,e)*p%e,k=Se(w,c,e)*w%e,O=Se(k,a,e)*p%e,D=Se(O,r,e)*f%e,H=Se(D,s,e)*y%e,X=Se(H,n,e)*l%e,M=Se(X,Wn,e);if(!Cr.eql(Cr.sqr(M),t))throw new Error("Cannot find square root");return M}var Cr=Dt(Nr.p,{sqrt:Ic}),vt=qi(Nr,{Fp:Cr,endo:Bc}),kt=Wi(vt,pe),Gi={};function Or(t,...e){let r=Gi[t];if(r===void 0){let n=pe(vi(t));r=ie(n,n),Gi[t]=r}return pe(ie(r,...e))}var Yn=t=>t.toBytes(!0).slice(1),Zn=t=>t%Wn===Sc;function Gn(t){let{Fn:e,BASE:r}=vt,n=e.fromBytes(t),o=r.multiply(n);return{scalar:Zn(o.y)?n:e.neg(n),bytes:Yn(o)}}function Zi(t){let e=Cr;if(!e.isValidNot0(t))throw new Error("invalid x: Fail if x \u2265 p");let r=e.create(t*t),n=e.create(r*t+BigInt(7)),o=e.sqrt(n);Zn(o)||(o=e.neg(o));let i=vt.fromAffine({x:t,y:o});return i.assertValidity(),i}var ar=ft;function Ji(...t){return vt.Fn.create(ar(Or("BIP0340/challenge",...t)))}function Yi(t){return Gn(t).bytes}function Tc(t,e,r=ge(32)){let{Fn:n}=vt,o=F(t,void 0,"message"),{bytes:i,scalar:s}=Gn(e),a=F(r,32,"auxRand"),c=n.toBytes(s^ar(Or("BIP0340/aux",a))),l=Or("BIP0340/nonce",c,i,o),{bytes:f,scalar:u}=Gn(l),h=Ji(f,i,o),d=new Uint8Array(64);if(d.set(f,0),d.set(n.toBytes(n.create(u+h*s)),32),!Xi(d,o,i))throw new Error("sign: Invalid signature produced");return d}function Xi(t,e,r){let{Fp:n,Fn:o,BASE:i}=vt,s=F(t,64,"signature"),a=F(e,void 0,"message"),c=F(r,32,"publicKey");try{let l=Zi(ar(c)),f=ar(s.subarray(0,32));if(!n.isValidNot0(f))return!1;let u=ar(s.subarray(32,64));if(!o.isValidNot0(u))return!1;let h=Ji(o.toBytes(f),Yn(l),a),d=i.multiplyUnsafe(u).add(l.multiplyUnsafe(o.neg(h))),{x:y,y:p}=d.toAffine();return!(d.is0()||!Zn(p)||y!==f)}catch{return!1}}var Kt=(()=>{let r=(n=ge(48))=>_r(n,Nr.n);return{keygen:Ur(r,Yi),getPublicKey:Yi,sign:Tc,verify:Xi,Point:vt,utils:{randomSecretKey:r,taggedHash:Or,lift_x:Zi,pointToBytes:Yn},lengths:{secretKey:32,publicKey:32,publicKeyHasPrefix:!1,signature:64,seed:48}}})();b();var ls=er(as()),cs;(function(t){t[t.DEBUG=0]="DEBUG",t[t.INFO=1]="INFO",t[t.WARN=2]="WARN",t[t.ERROR=3]="ERROR"})(cs||(cs={}));var Ie=(0,ls.default)({name:"nostr-crypto-utils",level:R.env.LOG_LEVEL||"info",transport:void 0,formatters:{level:t=>({level:t.toUpperCase()}),log:t=>{if(t&&typeof t=="object"&&"err"in t){let e={...t};if(e.err instanceof Error){let r=e.err;e.err={message:r.message,stack:r.stack,name:r.name}}return e}return t}}});b();function zc(t){try{return!!t.match(/^[A-Za-z0-9+/]*={0,2}$/)}catch{return!1}}function Hr(t){let e="";for(let r=0;r{if(typeof window<"u"&&window.crypto)return window.crypto;if(typeof globalThis<"u"&&globalThis.crypto)return globalThis.crypto;try{let t=await Promise.resolve().then(()=>er(ro()));if(t.webcrypto)return t.webcrypto}catch{Ie.debug("Node crypto not available")}throw new Error("No WebCrypto implementation available")},no=class{cryptoInstance=null;initPromise;constructor(){this.initPromise=this.initialize()}async initialize(){this.cryptoInstance=await Wc()}async ensureInitialized(){if(await this.initPromise,!this.cryptoInstance)throw new Error("Crypto implementation not initialized");return this.cryptoInstance}async getSubtle(){return(await this.ensureInitialized()).subtle}async getRandomValues(e){return(await this.ensureInitialized()).getRandomValues(e)}},Md=new no,Gc=Kt.sign,Yc=Kt.verify;async function oo(){let t=ge(32),e=Ee(t);t.fill(0);let r=await fs(e);return{privateKey:e,publicKey:r}}async function fs(t){try{let e=oe(t),r=Kt.getPublicKey(e);return{hex:Ee(r),bytes:r}}catch(e){throw Ie.error({error:e},"Failed to get public key"),e}}function Zc(t){return t instanceof Uint8Array?Ee(t):t}async function ds(t,e){try{let r=Zc(e),n=JSON.stringify([0,t.pubkey,t.created_at,t.kind,t.tags,t.content]),o=pe(new TextEncoder().encode(n)),i=oe(r),s=Kt.sign(o,i);return{...t,id:Ee(o),sig:Ee(s)}}catch(r){throw Ie.error({error:r},"Failed to sign event"),r}}function Pe(t){let e=t instanceof Uint8Array?t:oe(t),r=Kt.getPublicKey(e);return Ee(r)}async function Re(t,e){let r=t.pubkey||Pe(e),n=t.created_at||Math.floor(Date.now()/1e3),o={kind:t.kind||1,created_at:n,tags:t.tags||[],content:t.content||"",pubkey:r};return ds(o,e)}b();b();b();b();var pt={};An(pt,{computeSharedSecret:()=>ys,decryptMessage:()=>ps,encryptMessage:()=>hs,generateSharedSecret:()=>ys});b();var Qc=async()=>{if(typeof window<"u"&&window.crypto)return window.crypto;if(typeof globalThis<"u"&&globalThis.crypto)return globalThis.crypto;try{let t=await Promise.resolve().then(()=>er(ro()));if(t.webcrypto)return t.webcrypto}catch{Ie.debug("Node crypto not available")}throw new Error("No WebCrypto implementation available")},io=class{cryptoInstance=null;initPromise;constructor(){this.initPromise=this.initialize()}async initialize(){this.cryptoInstance=await Qc()}async ensureInitialized(){if(await this.initPromise,!this.cryptoInstance)throw new Error("Crypto implementation not initialized");return this.cryptoInstance}async getSubtle(){return(await this.ensureInitialized()).subtle}async getRandomValues(e){return(await this.ensureInitialized()).getRandomValues(e)}},lr=new io;async function hs(t,e,r){try{if(!t||!e||!r)throw new Error("Invalid input parameters");if(!/^[0-9a-f]{64}$/i.test(e))throw new Error("Invalid private key format");let n=r.startsWith("02")||r.startsWith("03")?r:"02"+r,o=kt.getSharedSecret(oe(e),oe(n)),i=o.slice(1,33),s=await(await lr.getSubtle()).importKey("raw",i.buffer,{name:"AES-CBC",length:256},!1,["encrypt"]);i.fill(0),o.fill(0);let a=new Uint8Array(16);await lr.getRandomValues(a);let c=new TextEncoder().encode(t),l=await(await lr.getSubtle()).encrypt({name:"AES-CBC",iv:a},s,c.buffer),f=Hr(new Uint8Array(l)),u=Hr(a);return f+"?iv="+u}catch(n){throw Ie.error({error:n},"Failed to encrypt message"),n}}async function ps(t,e,r){try{if(!t||!e||!r)throw new Error("Invalid input parameters");if(!/^[0-9a-f]{64}$/i.test(e))throw new Error("Invalid private key format");let n=r.startsWith("02")||r.startsWith("03")?r:"02"+r,o=kt.getSharedSecret(oe(e),oe(n)),i=o.slice(1,33),s=await(await lr.getSubtle()).importKey("raw",i.buffer,{name:"AES-CBC",length:256},!1,["decrypt"]);i.fill(0),o.fill(0);let a,c;if(t.includes("?iv=")){let[f,u]=t.split("?iv=");c=Kr(f),a=Kr(u)}else{let f=oe(t);a=f.slice(0,16),c=f.slice(16)}let l=await(await lr.getSubtle()).decrypt({name:"AES-CBC",iv:a},s,c.buffer);return new TextDecoder().decode(l)}catch(n){throw Ie.error({error:n},"Failed to decrypt message"),n}}function ys(t,e){try{if(!t||!e)throw new Error("Invalid input parameters");if(!/^[0-9a-f]{64}$/i.test(t))throw new Error("Invalid private key format");let r=e.startsWith("02")||e.startsWith("03")?e:"02"+e;return{sharedSecret:kt.getSharedSecret(oe(t),oe(r)).slice(1,33)}}catch(r){throw Ie.error({error:r},"Failed to generate shared secret"),r}}b();var Te={};An(Te,{decode:()=>ql,naddrEncode:()=>Fl,neventEncode:()=>Vl,noteEncode:()=>Hl,nprofileEncode:()=>Kl,npubEncode:()=>Dl,nrelayEncode:()=>$l,nsecEncode:()=>Ml});b();var we=er(bs()),Oe=er(Ks()),Nl=["npub","nsec","note","nprofile","nevent","naddr","nrelay"],Ge={SPECIAL:0,RELAY:1,AUTHOR:2,KIND:3,IDENTIFIER:4};function Dl(t){Ye(t,64);let e=Oe.Buffer.from(t,"hex"),r=we.bech32.toWords(e);return we.bech32.encode("npub",r,1e3)}function Ml(t){Ye(t,64);let e=Oe.Buffer.from(t,"hex"),r=we.bech32.toWords(e);return we.bech32.encode("nsec",r,1e3)}function Hl(t){Ye(t,64);let e=Oe.Buffer.from(t,"hex"),r=we.bech32.toWords(e);return we.bech32.encode("note",r,1e3)}function Kl(t,e){Ye(t,64),e&&e.forEach(Gt);let r=wo({type:"nprofile",data:t,relays:e});return we.bech32.encode("nprofile",r,1e3)}function Vl(t,e,r,n){if(Ye(t,64),e&&e.forEach(Gt),r&&Ye(r,64),n!==void 0&&!Number.isInteger(n))throw new Error("Invalid event kind");let o=wo({type:"nevent",data:t,relays:e,author:r,kind:n});return we.bech32.encode("nevent",o,1e3)}function Fl(t,e,r,n){if(Ye(t,64),!Number.isInteger(e))throw new Error("Invalid event kind");if(!r)throw new Error("Identifier is required");n&&n.forEach(Gt);let o=wo({type:"naddr",data:t,kind:e,identifier:r,relays:n});return we.bech32.encode("naddr",o,1e3)}function $l(t){Gt(t);let e=Oe.Buffer.from(t,"utf8"),r=we.bech32.toWords(e);return we.bech32.encode("nrelay",r,1e3)}function ql(t){if(!t.includes("1"))throw new Error("Invalid bech32 string");let e=t.split("1")[0].toLowerCase();if(!Nl.includes(e))throw new Error("Unknown prefix");try{let r=we.bech32.decode(t,1e3),n=Oe.Buffer.from(we.bech32.fromWords(r.words)),o,i;switch(r.prefix){case"npub":case"nsec":case"note":return Ye(n.toString("hex"),64),{type:r.prefix,data:n.toString("hex")};case"nrelay":return o=n.toString("utf8"),Gt(o),{type:"nrelay",data:o};case"nprofile":case"nevent":case"naddr":return i=jl(r.prefix,n),i;default:throw new Error("Unknown prefix")}}catch(r){throw r instanceof Error?r:new Error("Invalid bech32 string")}}function Ye(t,e){if(!/^[0-9a-fA-F]+$/.test(t))throw new Error("Invalid hex string");if(e&&t.length!==e)throw new Error(`Invalid hex string length (expected ${e})`)}function Gt(t){try{let e=new URL(t);if(!["ws:","wss:"].includes(e.protocol))throw new Error("Invalid relay URL protocol")}catch{throw new Error("Invalid relay URL")}}function wo(t){let e=[],r=Oe.Buffer.from(t.data,"hex");if(e.push(Ge.SPECIAL,r.length),e.push(...r),t.relays?.length)for(let n of t.relays){let o=Oe.Buffer.from(n,"utf8");e.push(Ge.RELAY,o.length),e.push(...o)}if(t.author){let n=Oe.Buffer.from(t.author,"hex");e.push(Ge.AUTHOR,n.length),e.push(...n)}if(t.kind!==void 0){let n=Oe.Buffer.alloc(4);n.writeUInt32BE(t.kind),e.push(Ge.KIND,n.length),e.push(...n)}if(t.identifier){let n=Oe.Buffer.from(t.identifier,"utf8");e.push(Ge.IDENTIFIER,n.length),e.push(...n)}return we.bech32.toWords(Oe.Buffer.from(e))}function jl(t,e){let r={type:t,data:"",relays:[]},n=0,o;for(;ne.length)throw new Error("Invalid TLV data");let a=e.slice(n+2,n+2+s);switch(i){case Ge.SPECIAL:r.data=a.toString("hex"),Ye(r.data,64);break;case Ge.RELAY:o=a.toString("utf8"),Gt(o),r.relays=r.relays||[],r.relays.push(o);break;case Ge.AUTHOR:r.author=a.toString("hex"),Ye(r.author,64);break;case Ge.KIND:r.kind=a.readUInt32BE();break;case Ge.IDENTIFIER:r.identifier=a.toString("utf8");break;default:break}n+=2+s}return r}b();var st={};An(st,{calcPaddedLen:()=>tn,decrypt:()=>Do,encrypt:()=>No,getConversationKey:()=>Oo,v2:()=>ke});b();b();b();b();function Wl(t){return t instanceof Uint8Array||ArrayBuffer.isView(t)&&t.constructor.name==="Uint8Array"}function jr(t){if(typeof t!="boolean")throw new Error(`boolean expected, not ${t}`)}function zr(t){if(!Number.isSafeInteger(t)||t<0)throw new Error("positive integer expected, got "+t)}function ue(t,e,r=""){let n=Wl(t),o=t?.length,i=e!==void 0;if(!n||i&&o!==e){let s=r&&`"${r}" `,a=i?` of length ${e}`:"",c=n?`length=${o}`:`type=${typeof t}`;throw new Error(s+"expected Uint8Array"+a+", got "+c)}return t}function bo(t,e=!0){if(t.destroyed)throw new Error("Hash instance has been destroyed");if(e&&t.finished)throw new Error("Hash#digest() has already been called")}function Vs(t,e){ue(t,void 0,"output");let r=e.outputLen;if(t.length{function r(n,...o){if(ue(n,void 0,"key"),!Yl)throw new Error("Non little-endian hardware is not yet supported");if(t.nonceLength!==void 0){let f=o[0];ue(f,t.varSizeNonce?void 0:t.nonceLength,"nonce")}let i=t.tagLength;i&&o[1]!==void 0&&ue(o[1],void 0,"AAD");let s=e(n,...o),a=(f,u)=>{if(u!==void 0){if(f!==2)throw new Error("cipher output not supported");ue(u,void 0,"output")}},c=!1;return{encrypt(f,u){if(c)throw new Error("cannot encrypt() twice with same key + nonce");return c=!0,ue(f),a(s.encrypt.length,u),s.encrypt(f,u)},decrypt(f,u){if(ue(f),i&&f.lengthUint8Array.from(t.split(""),e=>e.charCodeAt(0)),Jl=js("expand 16-byte k"),Xl=js("expand 32-byte k"),Ql=ot(Jl),eu=ot(Xl);function U(t,e){return t<>>32-e}function vo(t){return t.byteOffset%4===0}var Gr=64,tu=16,zs=2**32-1,qs=Uint32Array.of();function ru(t,e,r,n,o,i,s,a){let c=o.length,l=new Uint8Array(Gr),f=ot(l),u=vo(o)&&vo(i),h=u?ot(o):qs,d=u?ot(i):qs;for(let y=0;y=zs)throw new Error("arx: counter overflow");let p=Math.min(Gr,c-y);if(u&&p===Gr){let w=y/4;if(y%4!==0)throw new Error("arx: invalid block position");for(let k=0,O;k{ue(a,void 0,"key"),ue(c,void 0,"nonce"),ue(l,void 0,"data");let h=l.length;if(f===void 0&&(f=new Uint8Array(h)),ue(f,void 0,"output"),zr(u),u<0||u>=zs)throw new Error("arx: counter overflow");if(f.length>>13|n<<3)&8191,this.r[2]=(n>>>10|o<<6)&7939,this.r[3]=(o>>>7|i<<9)&8191,this.r[4]=(i>>>4|s<<12)&255,this.r[5]=s>>>1&8190,this.r[6]=(s>>>14|a<<2)&8191,this.r[7]=(a>>>11|c<<5)&8065,this.r[8]=(c>>>8|l<<8)&8191,this.r[9]=l>>>5&127;for(let f=0;f<8;f++)this.pad[f]=de(e,16+2*f)}process(e,r,n=!1){let o=n?0:2048,{h:i,r:s}=this,a=s[0],c=s[1],l=s[2],f=s[3],u=s[4],h=s[5],d=s[6],y=s[7],p=s[8],w=s[9],k=de(e,r+0),O=de(e,r+2),D=de(e,r+4),H=de(e,r+6),X=de(e,r+8),M=de(e,r+10),q=de(e,r+12),G=de(e,r+14),C=i[0]+(k&8191),$=i[1]+((k>>>13|O<<3)&8191),K=i[2]+((O>>>10|D<<6)&8191),P=i[3]+((D>>>7|H<<9)&8191),E=i[4]+((H>>>4|X<<12)&8191),x=i[5]+(X>>>1&8191),m=i[6]+((X>>>14|M<<2)&8191),A=i[7]+((M>>>11|q<<5)&8191),S=i[8]+((q>>>8|G<<8)&8191),I=i[9]+(G>>>5|o),v=0,B=v+C*a+$*(5*w)+K*(5*p)+P*(5*y)+E*(5*d);v=B>>>13,B&=8191,B+=x*(5*h)+m*(5*u)+A*(5*f)+S*(5*l)+I*(5*c),v+=B>>>13,B&=8191;let T=v+C*c+$*a+K*(5*w)+P*(5*p)+E*(5*y);v=T>>>13,T&=8191,T+=x*(5*d)+m*(5*h)+A*(5*u)+S*(5*f)+I*(5*l),v+=T>>>13,T&=8191;let L=v+C*l+$*c+K*a+P*(5*w)+E*(5*p);v=L>>>13,L&=8191,L+=x*(5*y)+m*(5*d)+A*(5*h)+S*(5*u)+I*(5*f),v+=L>>>13,L&=8191;let Y=v+C*f+$*l+K*c+P*a+E*(5*w);v=Y>>>13,Y&=8191,Y+=x*(5*p)+m*(5*y)+A*(5*d)+S*(5*h)+I*(5*u),v+=Y>>>13,Y&=8191;let z=v+C*u+$*f+K*l+P*c+E*a;v=z>>>13,z&=8191,z+=x*(5*w)+m*(5*p)+A*(5*y)+S*(5*d)+I*(5*h),v+=z>>>13,z&=8191;let V=v+C*h+$*u+K*f+P*l+E*c;v=V>>>13,V&=8191,V+=x*a+m*(5*w)+A*(5*p)+S*(5*y)+I*(5*d),v+=V>>>13,V&=8191;let Z=v+C*d+$*h+K*u+P*f+E*l;v=Z>>>13,Z&=8191,Z+=x*c+m*a+A*(5*w)+S*(5*p)+I*(5*y),v+=Z>>>13,Z&=8191;let ee=v+C*y+$*d+K*h+P*u+E*f;v=ee>>>13,ee&=8191,ee+=x*l+m*c+A*a+S*(5*w)+I*(5*p),v+=ee>>>13,ee&=8191;let fe=v+C*p+$*y+K*d+P*h+E*u;v=fe>>>13,fe&=8191,fe+=x*f+m*l+A*c+S*a+I*(5*w),v+=fe>>>13,fe&=8191;let J=v+C*w+$*p+K*y+P*d+E*h;v=J>>>13,J&=8191,J+=x*u+m*f+A*l+S*c+I*a,v+=J>>>13,J&=8191,v=(v<<2)+v|0,v=v+B|0,B=v&8191,v=v>>>13,T+=v,i[0]=B,i[1]=T,i[2]=L,i[3]=Y,i[4]=z,i[5]=V,i[6]=Z,i[7]=ee,i[8]=fe,i[9]=J}finalize(){let{h:e,pad:r}=this,n=new Uint16Array(10),o=e[1]>>>13;e[1]&=8191;for(let a=2;a<10;a++)e[a]+=o,o=e[a]>>>13,e[a]&=8191;e[0]+=o*5,o=e[0]>>>13,e[0]&=8191,e[1]+=o,o=e[1]>>>13,e[1]&=8191,e[2]+=o,n[0]=e[0]+5,o=n[0]>>>13,n[0]&=8191;for(let a=1;a<10;a++)n[a]=e[a]+o,o=n[a]>>>13,n[a]&=8191;n[9]-=8192;let i=(o^1)-1;for(let a=0;a<10;a++)n[a]&=i;i=~i;for(let a=0;a<10;a++)e[a]=e[a]&i|n[a];e[0]=(e[0]|e[1]<<13)&65535,e[1]=(e[1]>>>3|e[2]<<10)&65535,e[2]=(e[2]>>>6|e[3]<<7)&65535,e[3]=(e[3]>>>9|e[4]<<4)&65535,e[4]=(e[4]>>>12|e[5]<<1|e[6]<<14)&65535,e[5]=(e[6]>>>2|e[7]<<11)&65535,e[6]=(e[7]>>>5|e[8]<<8)&65535,e[7]=(e[8]>>>8|e[9]<<5)&65535;let s=e[0]+r[0];e[0]=s&65535;for(let a=1;a<8;a++)s=(e[a]+r[a]|0)+(s>>>16)|0,e[a]=s&65535;it(n)}update(e){bo(this),ue(e),e=Yt(e);let{buffer:r,blockLen:n}=this,o=e.length;for(let i=0;i>>0,e[i++]=n[s]>>>8;return e}digest(){let{buffer:e,outputLen:r}=this;this.digestInto(e);let n=e.slice(0,r);return this.destroy(),n}};function nu(t){let e=(n,o)=>t(o).update(n).digest(),r=t(new Uint8Array(32));return e.outputLen=r.outputLen,e.blockLen=r.blockLen,e.create=n=>t(n),e}var Ws=nu(t=>new Ao(t));function Zs(t,e,r,n,o,i=20){let s=t[0],a=t[1],c=t[2],l=t[3],f=e[0],u=e[1],h=e[2],d=e[3],y=e[4],p=e[5],w=e[6],k=e[7],O=o,D=r[0],H=r[1],X=r[2],M=s,q=a,G=c,C=l,$=f,K=u,P=h,E=d,x=y,m=p,A=w,S=k,I=O,v=D,B=H,T=X;for(let Y=0;Y{t.update(e);let r=e.length%16;r&&t.update(su.subarray(r))},au=new Uint8Array(32);function Ys(t,e,r,n,o){o!==void 0&&ue(o,void 0,"AAD");let i=t(e,r,au),s=$s(n.length,o?o.length:0,!0),a=Ws.create(i);o&&Gs(a,o),Gs(a,n),a.update(s);let c=a.digest();return it(i,s),c}var Js=t=>(e,r,n)=>({encrypt(i,s){let a=i.length;s=Eo(a+16,s,!1),s.set(i);let c=s.subarray(0,-16);t(e,r,c,c,1);let l=Ys(t,e,r,c,n);return s.set(l,a),it(l),s},decrypt(i,s){s=Eo(i.length-16,s,!1);let a=i.subarray(0,-16),c=i.subarray(-16),l=Ys(t,e,r,a,n);if(!Wr(c,l))throw new Error("invalid tag");return s.set(i.subarray(0,-16)),t(e,r,s,s,1),it(l),s}}),Vh=xo({blockSize:64,nonceLength:12,tagLength:16},Js(Yr)),Bo=xo({blockSize:64,nonceLength:24,tagLength:16},Js(iu));b();function Qs(t,e,r){return Qe(t),r===void 0&&(r=new Uint8Array(t.outputLen)),Fe(t,r,e)}var So=Uint8Array.of(0),Xs=Uint8Array.of();function ea(t,e,r,n=32){Qe(t),te(n,"length");let o=t.outputLen;if(n>255*o)throw new Error("Length must be <= 255*HashLen");let i=Math.ceil(n/o);r===void 0?r=Xs:F(r,void 0,"info");let s=new Uint8Array(i*o),a=Fe.create(t,e),c=a._cloneInto(),l=new Uint8Array(a.outputLen);for(let f=0;ftypeof r=="string"):e.every(r=>Number.isSafeInteger(r)):!1}function ia(t){if(typeof t!="function")throw new Error("function expected");return!0}function It(t,e){if(typeof e!="string")throw new Error(`${t}: string expected`);return!0}function Jt(t){if(!Number.isSafeInteger(t))throw new Error(`invalid integer: ${t}`)}function Jr(t){if(!Array.isArray(t))throw new Error("array expected")}function Xr(t,e){if(!oa(!0,e))throw new Error(`${t}: array of strings expected`)}function _o(t,e){if(!oa(!1,e))throw new Error(`${t}: array of numbers expected`)}function Lo(...t){let e=i=>i,r=(i,s)=>a=>i(s(a)),n=t.map(i=>i.encode).reduceRight(r,e),o=t.map(i=>i.decode).reduce(r,e);return{encode:n,decode:o}}function Uo(t){let e=typeof t=="string"?t.split(""):t,r=e.length;Xr("alphabet",e);let n=new Map(e.map((o,i)=>[o,i]));return{encode:o=>(Jr(o),o.map(i=>{if(!Number.isSafeInteger(i)||i<0||i>=r)throw new Error(`alphabet.encode: digit index outside alphabet "${i}". Allowed: ${t}`);return e[i]})),decode:o=>(Jr(o),o.map(i=>{It("alphabet.decode",i);let s=n.get(i);if(s===void 0)throw new Error(`Unknown letter: "${i}". Allowed: ${t}`);return s}))}}function Po(t=""){return It("join",t),{encode:e=>(Xr("join.decode",e),e.join(t)),decode:e=>(It("join.decode",e),e.split(t))}}function sa(t,e="="){return Jt(t),It("padding",e),{encode(r){for(Xr("padding.encode",r);r.length*t%8;)r.push(e);return r},decode(r){Xr("padding.decode",r);let n=r.length;if(n*t%8)throw new Error("padding: invalid, string should have whole number of bytes");for(;n>0&&r[n-1]===e;n--)if((n-1)*t%8===0)throw new Error("padding: invalid, string has too much padding");return r.slice(0,n)}}}function Io(t,e,r){if(e<2)throw new Error(`convertRadix: invalid from=${e}, base cannot be less than 2`);if(r<2)throw new Error(`convertRadix: invalid to=${r}, base cannot be less than 2`);if(Jr(t),!t.length)return[];let n=0,o=[],i=Array.from(t,a=>{if(Jt(a),a<0||a>=e)throw new Error(`invalid integer: ${a}`);return a}),s=i.length;for(;;){let a=0,c=!0;for(let l=n;le===0?t:aa(e,t%e),Qr=(t,e)=>t+(e-aa(t,e)),Zr=(()=>{let t=[];for(let e=0;e<40;e++)t.push(2**e);return t})();function en(t,e,r,n){if(Jr(t),e<=0||e>32)throw new Error(`convertRadix2: wrong from=${e}`);if(r<=0||r>32)throw new Error(`convertRadix2: wrong to=${r}`);if(Qr(e,r)>32)throw new Error(`convertRadix2: carry overflow from=${e} to=${r} carryBits=${Qr(e,r)}`);let o=0,i=0,s=Zr[e],a=Zr[r]-1,c=[];for(let l of t){if(Jt(l),l>=s)throw new Error(`convertRadix2: invalid data word=${l} from=${e}`);if(o=o<32)throw new Error(`convertRadix2: carry overflow pos=${i} from=${e}`);for(i+=e;i>=r;i-=r)c.push((o>>i-r&a)>>>0);let f=Zr[i];if(f===void 0)throw new Error("invalid carry");o&=f-1}if(o=o<=e)throw new Error("Excess padding");if(!n&&o>0)throw new Error(`Non-zero padding: ${o}`);return n&&i>0&&c.push(o>>>0),c}function lu(t){Jt(t);let e=2**8;return{encode:r=>{if(!Zt(r))throw new Error("radix.encode input should be Uint8Array");return Io(Array.from(r),e,t)},decode:r=>(_o("radix.decode",r),Uint8Array.from(Io(r,t,e)))}}function Ro(t,e=!1){if(Jt(t),t<=0||t>32)throw new Error("radix2: bits should be in (0..32]");if(Qr(8,t)>32||Qr(t,8)>32)throw new Error("radix2: carry overflow");return{encode:r=>{if(!Zt(r))throw new Error("radix2.encode input should be Uint8Array");return en(Array.from(r),8,t,!e)},decode:r=>(_o("radix2.decode",r),Uint8Array.from(en(r,t,8,e)))}}function ta(t){return ia(t),function(...e){try{return t.apply(null,e)}catch{}}}function uu(t,e){return Jt(t),ia(e),{encode(r){if(!Zt(r))throw new Error("checksum.encode: input should be Uint8Array");let n=e(r).slice(0,t),o=new Uint8Array(r.length+t);return o.set(r),o.set(n,r.length),o},decode(r){if(!Zt(r))throw new Error("checksum.decode: input should be Uint8Array");let n=r.slice(0,-t),o=r.slice(-t),i=e(n).slice(0,t);for(let s=0;s{It("base64",t);let r=e?/^[A-Za-z0-9=_-]+$/:/^[A-Za-z0-9=+/]+$/,n=e?"base64url":"base64";if(t.length>0&&!r.test(t))throw new Error("invalid base64");return Uint8Array.fromBase64(t,{alphabet:n,lastChunkHandling:"strict"})},Co=fu?{encode(t){return cu(t),t.toBase64()},decode(t){return du(t,!1)}}:Lo(Ro(6),Uo("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"),sa(6),Po(""));var To=Lo(Uo("qpzry9x8gf2tvdw0s3jn54khce6mua7l"),Po("")),ra=[996825010,642813549,513874426,1027748829,705979059];function fr(t){let e=t>>25,r=(t&33554431)<<5;for(let n=0;n>n&1)===1&&(r^=ra[n]);return r}function na(t,e,r=1){let n=t.length,o=1;for(let i=0;i126)throw new Error(`Invalid prefix (${t})`);o=fr(o)^s>>5}o=fr(o);for(let i=0;id)throw new TypeError(`Length ${p} exceeds limit ${d}`);let w=u.toLowerCase(),k=na(w,h,e);return`${w}1${To.encode(h)}${k}`}function a(u,h=90){It("bech32.decode input",u);let d=u.length;if(d<8||h!==!1&&d>h)throw new TypeError(`invalid string length: ${d} (${u}). Expected (8..${h})`);let y=u.toLowerCase();if(u!==y&&u!==u.toUpperCase())throw new Error("String must be lowercase or uppercase");let p=y.lastIndexOf("1");if(p===0||p===-1)throw new Error('Letter "1" must be present between prefix and data only');let w=y.slice(0,p),k=y.slice(p+1);if(k.length<6)throw new Error("Data must be at least 6 characters long");let O=To.decode(k).slice(0,-6),D=na(w,O,e);if(!k.endsWith(D))throw new Error(`Invalid checksum in ${u}: expected "${D}"`);return{prefix:w,words:O}}let c=ta(a);function l(u){let{prefix:h,words:d}=a(u,!1);return{prefix:h,words:d,bytes:n(d)}}function f(u,h){return s(u,o(h))}return{encode:s,decode:a,encodeFromBytes:f,decodeToBytes:l,decodeUnsafe:c,fromWords:n,fromWordsUnsafe:i,toWords:o}}var hr=hu("bech32");var ca=new TextEncoder,pu=new TextDecoder,la=1,ua=65535;function tn(t){if(!Number.isSafeInteger(t)||t<1)throw new Error("expected positive integer");if(t<=32)return 32;let e=1<ua)throw new Error("invalid plaintext length: must be between 1 and 65535 bytes");let n=new Uint8Array(2);new DataView(n.buffer).setUint16(0,r,!1);let o=new Uint8Array(tn(r)-r);return ie(n,e,o)}function gu(t){let e=new DataView(t.buffer,t.byteOffset).getUint16(0,!1),r=t.subarray(2,2+e);if(eua||r.length!==e||t.length!==2+tn(e))throw new Error("invalid padding");return pu.decode(r)}function Oo(t,e){let n=kt.getSharedSecret(t,oe("02"+e)).subarray(1,33);return Qs(pe,n,ca.encode("nip44-v2"))}function fa(t,e){let r=ea(pe,t,e,76);return{chacha_key:r.subarray(0,32),chacha_nonce:r.subarray(32,44),hmac_key:r.subarray(44,76)}}function No(t,e,r=ge(32)){let{chacha_key:n,chacha_nonce:o,hmac_key:i}=fa(e,r),s=yu(t),a=Yr(n,o,s),c=Fe(pe,i,ie(r,a));return Co.encode(ie(new Uint8Array([2]),r,a,c))}function Do(t,e){let r=Co.decode(t),n=r[0];if(n!==2)throw new Error(`unknown encryption version: ${n}`);if(r.length<99||r.length>65603)throw new Error("invalid payload size");let o=r.subarray(1,33),i=r.subarray(33,r.length-32),s=r.subarray(r.length-32),{chacha_key:a,chacha_nonce:c,hmac_key:l}=fa(e,o),f=Fe(pe,l,ie(o,i));if(!Wr(s,f))throw new Error("invalid MAC");let u=Yr(a,c,i);return gu(u)}var ke={utils:{getConversationKey:Oo,calcPaddedLen:tn},encrypt:No,decrypt:Do};b();b();b();b();function bu(t,e,r,n){Qe(t);let o=Ar({dkLen:32,asyncTick:10},n),{c:i,dkLen:s,asyncTick:a}=o;if(te(i,"c"),te(s,"dkLen"),te(a,"asyncTick"),i<1)throw new Error("iterations (c) must be >= 1");let c=In(e,"password"),l=In(r,"salt"),f=new Uint8Array(s),u=Fe.create(t,c),h=u._cloneInto().update(l);return{c:i,dkLen:s,asyncTick:a,DK:f,PRF:u,PRFSalt:h}}function xu(t,e,r,n,o){return t.destroy(),e.destroy(),n&&n.destroy(),Be(o),r}function Mo(t,e,r,n){let{c:o,dkLen:i,DK:s,PRF:a,PRFSalt:c}=bu(t,e,r,n),l,f=new Uint8Array(4),u=Nt(f),h=new Uint8Array(a.outputLen);for(let d=1,y=0;y0&&(s+=16),da(r,i,t,e+=16,r,s)}function Eu(t,e,r){let n=Ar({dkLen:32,asyncTick:10,maxmem:1073742848},r),{N:o,r:i,p:s,dkLen:a,asyncTick:c,maxmem:l,onProgress:f}=n;if(te(o,"N"),te(i,"r"),te(s,"p"),te(a,"dkLen"),te(c,"asyncTick"),te(l,"maxmem"),f!==void 0&&typeof f!="function")throw new Error("progressCb must be a function");let u=128*i,h=u/4,d=Math.pow(2,32);if(o<=1||(o&o-1)!==0||o>d)throw new Error('"N" expected a power of 2, and 2^1 <= N <= 2^32');if(s<1||s>(d-1)*32/u)throw new Error('"p" expected integer 1..((2^32 - 1) * 32) / (128 * r)');if(a<1||a>(d-1)*32)throw new Error('"dkLen" expected integer 1..(2^32 - 1) * 32');if(u*(o+s)>l)throw new Error('"maxmem" limit was hit, expected 128*r*(N+p) <= "maxmem"='+l);let p=Mo(pe,t,e,{c:1,dkLen:u*s}),w=kr(p),k=kr(new Uint8Array(u*o)),O=kr(new Uint8Array(u)),D=()=>{};if(f){let H=2*o*s,X=Math.max(Math.floor(H/1e4),1),M=0;D=()=>{M++,f&&(!(M%X)||M===H)&&f(M/H)}}return{N:o,r:i,p:s,dkLen:a,blockSize32:h,V:k,B32:w,B:p,tmp:O,blockMixCb:D,asyncTick:c}}function vu(t,e,r,n,o){let i=Mo(pe,t,r,{c:1,dkLen:e});return Be(r,n,o),i}function Ko(t,e,r){let{N:n,r:o,p:i,dkLen:s,blockSize32:a,V:c,B32:l,B:f,tmp:u,blockMixCb:h}=Eu(t,e,r);Sn(l);for(let d=0;d>>0;for(let k=0;ke.toString(16).padStart(2,"0")).join("")}b();b();var Au=t=>t[0]==="\u3042\u3044\u3053\u304F\u3057\u3093";function Bu(t){if(typeof t!="string")throw new TypeError("invalid mnemonic type: "+typeof t);return t.normalize("NFKD")}function Su(t){let e=Bu(t),r=e.split(" ");if(![12,15,18,21,24].includes(r.length))throw new Error("Invalid mnemonic");return{nfkd:e,words:r}}function ya(t){if(F(t),![16,20,24,28,32].includes(t.length))throw new Error("invalid entropy length")}var Iu=t=>{let e=8-t.length/4;return new Uint8Array([pe(t)[0]>>e<{if(typeof e!="string")throw new Error("wordlist: non-string element: "+e)}),dr.chain(dr.checksum(1,Iu),dr.radix2(11,!0),dr.alphabet(t))}function Vo(t,e){let{words:r}=Su(t),n=ga(e).decode(r);return ya(n),n}function ma(t,e){return ya(t),ga(e).encode(t).join(Au(e)?"\u3000":" ")}function wa(t,e){try{Vo(t,e)}catch{return!1}return!0}b();var rn=`abandon +(() => { + var __create = Object.create; + var __defProp = Object.defineProperty; + var __getOwnPropDesc = Object.getOwnPropertyDescriptor; + var __getOwnPropNames = Object.getOwnPropertyNames; + var __getProtoOf = Object.getPrototypeOf; + var __hasOwnProp = Object.prototype.hasOwnProperty; + var __esm = (fn, res) => function __init() { + return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res; + }; + var __commonJS = (cb, mod2) => function __require() { + return mod2 || (0, cb[__getOwnPropNames(cb)[0]])((mod2 = { exports: {} }).exports, mod2), mod2.exports; + }; + var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); + }; + var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; + }; + var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target, + mod2 + )); + + // src/shims/process.js + var process; + var init_process = __esm({ + "src/shims/process.js"() { + process = { + env: { NODE_ENV: "production", LOG_LEVEL: "warn" }, + browser: true, + version: "", + stdout: null, + stderr: null, + nextTick: function(fn) { + var args = Array.prototype.slice.call(arguments, 1); + Promise.resolve().then(function() { + fn.apply(null, args); + }); + } + }; + } + }); + + // node_modules/quick-format-unescaped/index.js + var require_quick_format_unescaped = __commonJS({ + "node_modules/quick-format-unescaped/index.js"(exports, module) { + "use strict"; + init_process(); + function tryStringify(o) { + try { + return JSON.stringify(o); + } catch (e) { + return '"[Circular]"'; + } + } + module.exports = format; + function format(f, args, opts) { + var ss = opts && opts.stringify || tryStringify; + var offset = 1; + if (typeof f === "object" && f !== null) { + var len = args.length + offset; + if (len === 1) return f; + var objects = new Array(len); + objects[0] = ss(f); + for (var index = 1; index < len; index++) { + objects[index] = ss(args[index]); + } + return objects.join(" "); + } + if (typeof f !== "string") { + return f; + } + var argLen = args.length; + if (argLen === 0) return f; + var str = ""; + var a = 1 - offset; + var lastPos = -1; + var flen = f && f.length || 0; + for (var i = 0; i < flen; ) { + if (f.charCodeAt(i) === 37 && i + 1 < flen) { + lastPos = lastPos > -1 ? lastPos : 0; + switch (f.charCodeAt(i + 1)) { + case 100: + // 'd' + case 102: + if (a >= argLen) + break; + if (args[a] == null) break; + if (lastPos < i) + str += f.slice(lastPos, i); + str += Number(args[a]); + lastPos = i + 2; + i++; + break; + case 105: + if (a >= argLen) + break; + if (args[a] == null) break; + if (lastPos < i) + str += f.slice(lastPos, i); + str += Math.floor(Number(args[a])); + lastPos = i + 2; + i++; + break; + case 79: + // 'O' + case 111: + // 'o' + case 106: + if (a >= argLen) + break; + if (args[a] === void 0) break; + if (lastPos < i) + str += f.slice(lastPos, i); + var type = typeof args[a]; + if (type === "string") { + str += "'" + args[a] + "'"; + lastPos = i + 2; + i++; + break; + } + if (type === "function") { + str += args[a].name || ""; + lastPos = i + 2; + i++; + break; + } + str += ss(args[a]); + lastPos = i + 2; + i++; + break; + case 115: + if (a >= argLen) + break; + if (lastPos < i) + str += f.slice(lastPos, i); + str += String(args[a]); + lastPos = i + 2; + i++; + break; + case 37: + if (lastPos < i) + str += f.slice(lastPos, i); + str += "%"; + lastPos = i + 2; + i++; + a--; + break; + } + ++a; + } + ++i; + } + if (lastPos === -1) + return f; + else if (lastPos < flen) { + str += f.slice(lastPos); + } + return str; + } + } + }); + + // node_modules/pino/browser.js + var require_browser = __commonJS({ + "node_modules/pino/browser.js"(exports, module) { + "use strict"; + init_process(); + var format = require_quick_format_unescaped(); + module.exports = pino2; + var _console = pfGlobalThisOrFallback().console || {}; + var stdSerializers = { + mapHttpRequest: mock, + mapHttpResponse: mock, + wrapRequestSerializer: passthrough, + wrapResponseSerializer: passthrough, + wrapErrorSerializer: passthrough, + req: mock, + res: mock, + err: asErrValue, + errWithCause: asErrValue + }; + function levelToValue(level, logger2) { + return level === "silent" ? Infinity : logger2.levels.values[level]; + } + var baseLogFunctionSymbol = /* @__PURE__ */ Symbol("pino.logFuncs"); + var hierarchySymbol = /* @__PURE__ */ Symbol("pino.hierarchy"); + var logFallbackMap = { + error: "log", + fatal: "error", + warn: "error", + info: "log", + debug: "log", + trace: "log" + }; + function appendChildLogger(parentLogger, childLogger) { + const newEntry = { + logger: childLogger, + parent: parentLogger[hierarchySymbol] + }; + childLogger[hierarchySymbol] = newEntry; + } + function setupBaseLogFunctions(logger2, levels, proto) { + const logFunctions = {}; + levels.forEach((level) => { + logFunctions[level] = proto[level] ? proto[level] : _console[level] || _console[logFallbackMap[level] || "log"] || noop; + }); + logger2[baseLogFunctionSymbol] = logFunctions; + } + function shouldSerialize(serialize, serializers) { + if (Array.isArray(serialize)) { + const hasToFilter = serialize.filter(function(k) { + return k !== "!stdSerializers.err"; + }); + return hasToFilter; + } else if (serialize === true) { + return Object.keys(serializers); + } + return false; + } + function pino2(opts) { + opts = opts || {}; + opts.browser = opts.browser || {}; + const transmit2 = opts.browser.transmit; + if (transmit2 && typeof transmit2.send !== "function") { + throw Error("pino: transmit option must have a send function"); + } + const proto = opts.browser.write || _console; + if (opts.browser.write) opts.browser.asObject = true; + const serializers = opts.serializers || {}; + const serialize = shouldSerialize(opts.browser.serialize, serializers); + let stdErrSerialize = opts.browser.serialize; + if (Array.isArray(opts.browser.serialize) && opts.browser.serialize.indexOf("!stdSerializers.err") > -1) stdErrSerialize = false; + const customLevels = Object.keys(opts.customLevels || {}); + const levels = ["error", "fatal", "warn", "info", "debug", "trace"].concat(customLevels); + if (typeof proto === "function") { + levels.forEach(function(level2) { + proto[level2] = proto; + }); + } + if (opts.enabled === false || opts.browser.disabled) opts.level = "silent"; + const level = opts.level || "info"; + const logger2 = Object.create(proto); + if (!logger2.log) logger2.log = noop; + setupBaseLogFunctions(logger2, levels, proto); + appendChildLogger({}, logger2); + Object.defineProperty(logger2, "levelVal", { + get: getLevelVal + }); + Object.defineProperty(logger2, "level", { + get: getLevel, + set: setLevel + }); + const setOpts = { + transmit: transmit2, + serialize, + asObject: opts.browser.asObject, + asObjectBindingsOnly: opts.browser.asObjectBindingsOnly, + formatters: opts.browser.formatters, + reportCaller: opts.browser.reportCaller, + levels, + timestamp: getTimeFunction(opts), + messageKey: opts.messageKey || "msg", + onChild: opts.onChild || noop + }; + logger2.levels = getLevels(opts); + logger2.level = level; + logger2.isLevelEnabled = function(level2) { + if (!this.levels.values[level2]) { + return false; + } + return this.levels.values[level2] >= this.levels.values[this.level]; + }; + logger2.setMaxListeners = logger2.getMaxListeners = logger2.emit = logger2.addListener = logger2.on = logger2.prependListener = logger2.once = logger2.prependOnceListener = logger2.removeListener = logger2.removeAllListeners = logger2.listeners = logger2.listenerCount = logger2.eventNames = logger2.write = logger2.flush = noop; + logger2.serializers = serializers; + logger2._serialize = serialize; + logger2._stdErrSerialize = stdErrSerialize; + logger2.child = function(...args) { + return child.call(this, setOpts, ...args); + }; + if (transmit2) logger2._logEvent = createLogEventShape(); + function getLevelVal() { + return levelToValue(this.level, this); + } + function getLevel() { + return this._level; + } + function setLevel(level2) { + if (level2 !== "silent" && !this.levels.values[level2]) { + throw Error("unknown level " + level2); + } + this._level = level2; + set(this, setOpts, logger2, "error"); + set(this, setOpts, logger2, "fatal"); + set(this, setOpts, logger2, "warn"); + set(this, setOpts, logger2, "info"); + set(this, setOpts, logger2, "debug"); + set(this, setOpts, logger2, "trace"); + customLevels.forEach((level3) => { + set(this, setOpts, logger2, level3); + }); + } + function child(setOpts2, bindings, childOptions) { + if (!bindings) { + throw new Error("missing bindings for child Pino"); + } + childOptions = childOptions || {}; + if (serialize && bindings.serializers) { + childOptions.serializers = bindings.serializers; + } + const childOptionsSerializers = childOptions.serializers; + if (serialize && childOptionsSerializers) { + var childSerializers = Object.assign({}, serializers, childOptionsSerializers); + var childSerialize = opts.browser.serialize === true ? Object.keys(childSerializers) : serialize; + delete bindings.serializers; + applySerializers([bindings], childSerialize, childSerializers, this._stdErrSerialize); + } + function Child(parent) { + this._childLevel = (parent._childLevel | 0) + 1; + this.bindings = bindings; + if (childSerializers) { + this.serializers = childSerializers; + this._serialize = childSerialize; + } + if (transmit2) { + this._logEvent = createLogEventShape( + [].concat(parent._logEvent.bindings, bindings) + ); + } + } + Child.prototype = this; + const newLogger = new Child(this); + appendChildLogger(this, newLogger); + newLogger.child = function(...args) { + return child.call(this, setOpts2, ...args); + }; + newLogger.level = childOptions.level || this.level; + setOpts2.onChild(newLogger); + return newLogger; + } + return logger2; + } + function getLevels(opts) { + const customLevels = opts.customLevels || {}; + const values = Object.assign({}, pino2.levels.values, customLevels); + const labels = Object.assign({}, pino2.levels.labels, invertObject(customLevels)); + return { + values, + labels + }; + } + function invertObject(obj) { + const inverted = {}; + Object.keys(obj).forEach(function(key) { + inverted[obj[key]] = key; + }); + return inverted; + } + pino2.levels = { + values: { + fatal: 60, + error: 50, + warn: 40, + info: 30, + debug: 20, + trace: 10 + }, + labels: { + 10: "trace", + 20: "debug", + 30: "info", + 40: "warn", + 50: "error", + 60: "fatal" + } + }; + pino2.stdSerializers = stdSerializers; + pino2.stdTimeFunctions = Object.assign({}, { nullTime, epochTime, unixTime, isoTime }); + function getBindingChain(logger2) { + const bindings = []; + if (logger2.bindings) { + bindings.push(logger2.bindings); + } + let hierarchy = logger2[hierarchySymbol]; + while (hierarchy.parent) { + hierarchy = hierarchy.parent; + if (hierarchy.logger.bindings) { + bindings.push(hierarchy.logger.bindings); + } + } + return bindings.reverse(); + } + function set(self2, opts, rootLogger, level) { + Object.defineProperty(self2, level, { + value: levelToValue(self2.level, rootLogger) > levelToValue(level, rootLogger) ? noop : rootLogger[baseLogFunctionSymbol][level], + writable: true, + enumerable: true, + configurable: true + }); + if (self2[level] === noop) { + if (!opts.transmit) return; + const transmitLevel = opts.transmit.level || self2.level; + const transmitValue = levelToValue(transmitLevel, rootLogger); + const methodValue = levelToValue(level, rootLogger); + if (methodValue < transmitValue) return; + } + self2[level] = createWrap(self2, opts, rootLogger, level); + const bindings = getBindingChain(self2); + if (bindings.length === 0) { + return; + } + self2[level] = prependBindingsInArguments(bindings, self2[level]); + } + function prependBindingsInArguments(bindings, logFunc) { + return function() { + return logFunc.apply(this, [...bindings, ...arguments]); + }; + } + function createWrap(self2, opts, rootLogger, level) { + return /* @__PURE__ */ (function(write) { + return function LOG() { + const ts = opts.timestamp(); + const args = new Array(arguments.length); + const proto = Object.getPrototypeOf && Object.getPrototypeOf(this) === _console ? _console : this; + for (var i = 0; i < args.length; i++) args[i] = arguments[i]; + var argsIsSerialized = false; + if (opts.serialize) { + applySerializers(args, this._serialize, this.serializers, this._stdErrSerialize); + argsIsSerialized = true; + } + if (opts.asObject || opts.formatters) { + const out = asObject(this, level, args, ts, opts); + if (opts.reportCaller && out && out.length > 0 && out[0] && typeof out[0] === "object") { + try { + const caller = getCallerLocation(); + if (caller) out[0].caller = caller; + } catch (e) { + } + } + write.call(proto, ...out); + } else { + if (opts.reportCaller) { + try { + const caller = getCallerLocation(); + if (caller) args.push(caller); + } catch (e) { + } + } + write.apply(proto, args); + } + if (opts.transmit) { + const transmitLevel = opts.transmit.level || self2._level; + const transmitValue = levelToValue(transmitLevel, rootLogger); + const methodValue = levelToValue(level, rootLogger); + if (methodValue < transmitValue) return; + transmit(this, { + ts, + methodLevel: level, + methodValue, + transmitLevel, + transmitValue: rootLogger.levels.values[opts.transmit.level || self2._level], + send: opts.transmit.send, + val: levelToValue(self2._level, rootLogger) + }, args, argsIsSerialized); + } + }; + })(self2[baseLogFunctionSymbol][level]); + } + function asObject(logger2, level, args, ts, opts) { + const { + level: levelFormatter, + log: logObjectFormatter = (obj) => obj + } = opts.formatters || {}; + const argsCloned = args.slice(); + let msg = argsCloned[0]; + const logObject = {}; + let lvl = (logger2._childLevel | 0) + 1; + if (lvl < 1) lvl = 1; + if (ts) { + logObject.time = ts; + } + if (levelFormatter) { + const formattedLevel = levelFormatter(level, logger2.levels.values[level]); + Object.assign(logObject, formattedLevel); + } else { + logObject.level = logger2.levels.values[level]; + } + if (opts.asObjectBindingsOnly) { + if (msg !== null && typeof msg === "object") { + while (lvl-- && typeof argsCloned[0] === "object") { + Object.assign(logObject, argsCloned.shift()); + } + } + const formattedLogObject = logObjectFormatter(logObject); + return [formattedLogObject, ...argsCloned]; + } else { + if (msg !== null && typeof msg === "object") { + while (lvl-- && typeof argsCloned[0] === "object") { + Object.assign(logObject, argsCloned.shift()); + } + msg = argsCloned.length ? format(argsCloned.shift(), argsCloned) : void 0; + } else if (typeof msg === "string") msg = format(argsCloned.shift(), argsCloned); + if (msg !== void 0) logObject[opts.messageKey] = msg; + const formattedLogObject = logObjectFormatter(logObject); + return [formattedLogObject]; + } + } + function applySerializers(args, serialize, serializers, stdErrSerialize) { + for (const i in args) { + if (stdErrSerialize && args[i] instanceof Error) { + args[i] = pino2.stdSerializers.err(args[i]); + } else if (typeof args[i] === "object" && !Array.isArray(args[i]) && serialize) { + for (const k in args[i]) { + if (serialize.indexOf(k) > -1 && k in serializers) { + args[i][k] = serializers[k](args[i][k]); + } + } + } + } + } + function transmit(logger2, opts, args, argsIsSerialized = false) { + const send = opts.send; + const ts = opts.ts; + const methodLevel = opts.methodLevel; + const methodValue = opts.methodValue; + const val = opts.val; + const bindings = logger2._logEvent.bindings; + if (!argsIsSerialized) { + applySerializers( + args, + logger2._serialize || Object.keys(logger2.serializers), + logger2.serializers, + logger2._stdErrSerialize === void 0 ? true : logger2._stdErrSerialize + ); + } + logger2._logEvent.ts = ts; + logger2._logEvent.messages = args.filter(function(arg) { + return bindings.indexOf(arg) === -1; + }); + logger2._logEvent.level.label = methodLevel; + logger2._logEvent.level.value = methodValue; + send(methodLevel, logger2._logEvent, val); + logger2._logEvent = createLogEventShape(bindings); + } + function createLogEventShape(bindings) { + return { + ts: 0, + messages: [], + bindings: bindings || [], + level: { label: "", value: 0 } + }; + } + function asErrValue(err) { + const obj = { + type: err.constructor.name, + msg: err.message, + stack: err.stack + }; + for (const key in err) { + if (obj[key] === void 0) { + obj[key] = err[key]; + } + } + return obj; + } + function getTimeFunction(opts) { + if (typeof opts.timestamp === "function") { + return opts.timestamp; + } + if (opts.timestamp === false) { + return nullTime; + } + return epochTime; + } + function mock() { + return {}; + } + function passthrough(a) { + return a; + } + function noop() { + } + function nullTime() { + return false; + } + function epochTime() { + return Date.now(); + } + function unixTime() { + return Math.round(Date.now() / 1e3); + } + function isoTime() { + return new Date(Date.now()).toISOString(); + } + function pfGlobalThisOrFallback() { + function defd(o) { + return typeof o !== "undefined" && o; + } + try { + if (typeof globalThis !== "undefined") return globalThis; + Object.defineProperty(Object.prototype, "globalThis", { + get: function() { + delete Object.prototype.globalThis; + return this.globalThis = this; + }, + configurable: true + }); + return globalThis; + } catch (e) { + return defd(self) || defd(window) || defd(this) || {}; + } + } + module.exports.default = pino2; + module.exports.pino = pino2; + function getCallerLocation() { + const stack = new Error().stack; + if (!stack) return null; + const lines = stack.split("\n"); + for (let i = 1; i < lines.length; i++) { + const l = lines[i].trim(); + if (/(^at\s+)?(createWrap|LOG|set\s*\(|asObject|Object\.apply|Function\.apply)/.test(l)) continue; + if (l.indexOf("browser.js") !== -1) continue; + if (l.indexOf("node:internal") !== -1) continue; + if (l.indexOf("node_modules") !== -1) continue; + let m = l.match(/\((.*?):(\d+):(\d+)\)/); + if (!m) m = l.match(/at\s+(.*?):(\d+):(\d+)/); + if (m) { + const file = m[1]; + const line = m[2]; + const col = m[3]; + return file + ":" + line + ":" + col; + } + } + return null; + } + } + }); + + // node-stub:crypto + var require_crypto = __commonJS({ + "node-stub:crypto"(exports, module) { + init_process(); + module.exports = {}; + } + }); + + // node_modules/bech32/dist/index.js + var require_dist = __commonJS({ + "node_modules/bech32/dist/index.js"(exports) { + "use strict"; + init_process(); + Object.defineProperty(exports, "__esModule", { value: true }); + exports.bech32m = exports.bech32 = void 0; + var ALPHABET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l"; + var ALPHABET_MAP = {}; + for (let z = 0; z < ALPHABET.length; z++) { + const x = ALPHABET.charAt(z); + ALPHABET_MAP[x] = z; + } + function polymodStep(pre) { + const b = pre >> 25; + return (pre & 33554431) << 5 ^ -(b >> 0 & 1) & 996825010 ^ -(b >> 1 & 1) & 642813549 ^ -(b >> 2 & 1) & 513874426 ^ -(b >> 3 & 1) & 1027748829 ^ -(b >> 4 & 1) & 705979059; + } + function prefixChk(prefix) { + let chk = 1; + for (let i = 0; i < prefix.length; ++i) { + const c = prefix.charCodeAt(i); + if (c < 33 || c > 126) + return "Invalid prefix (" + prefix + ")"; + chk = polymodStep(chk) ^ c >> 5; + } + chk = polymodStep(chk); + for (let i = 0; i < prefix.length; ++i) { + const v = prefix.charCodeAt(i); + chk = polymodStep(chk) ^ v & 31; + } + return chk; + } + function convert(data, inBits, outBits, pad2) { + let value = 0; + let bits = 0; + const maxV = (1 << outBits) - 1; + const result = []; + for (let i = 0; i < data.length; ++i) { + value = value << inBits | data[i]; + bits += inBits; + while (bits >= outBits) { + bits -= outBits; + result.push(value >> bits & maxV); + } + } + if (pad2) { + if (bits > 0) { + result.push(value << outBits - bits & maxV); + } + } else { + if (bits >= inBits) + return "Excess padding"; + if (value << outBits - bits & maxV) + return "Non-zero padding"; + } + return result; + } + function toWords(bytes) { + return convert(bytes, 8, 5, true); + } + function fromWordsUnsafe(words) { + const res = convert(words, 5, 8, false); + if (Array.isArray(res)) + return res; + } + function fromWords(words) { + const res = convert(words, 5, 8, false); + if (Array.isArray(res)) + return res; + throw new Error(res); + } + function getLibraryFromEncoding(encoding) { + let ENCODING_CONST; + if (encoding === "bech32") { + ENCODING_CONST = 1; + } else { + ENCODING_CONST = 734539939; + } + function encode(prefix, words, LIMIT) { + LIMIT = LIMIT || 90; + if (prefix.length + 7 + words.length > LIMIT) + throw new TypeError("Exceeds length limit"); + prefix = prefix.toLowerCase(); + let chk = prefixChk(prefix); + if (typeof chk === "string") + throw new Error(chk); + let result = prefix + "1"; + for (let i = 0; i < words.length; ++i) { + const x = words[i]; + if (x >> 5 !== 0) + throw new Error("Non 5-bit word"); + chk = polymodStep(chk) ^ x; + result += ALPHABET.charAt(x); + } + for (let i = 0; i < 6; ++i) { + chk = polymodStep(chk); + } + chk ^= ENCODING_CONST; + for (let i = 0; i < 6; ++i) { + const v = chk >> (5 - i) * 5 & 31; + result += ALPHABET.charAt(v); + } + return result; + } + function __decode(str, LIMIT) { + LIMIT = LIMIT || 90; + if (str.length < 8) + return str + " too short"; + if (str.length > LIMIT) + return "Exceeds length limit"; + const lowered = str.toLowerCase(); + const uppered = str.toUpperCase(); + if (str !== lowered && str !== uppered) + return "Mixed-case string " + str; + str = lowered; + const split = str.lastIndexOf("1"); + if (split === -1) + return "No separator character for " + str; + if (split === 0) + return "Missing prefix for " + str; + const prefix = str.slice(0, split); + const wordChars = str.slice(split + 1); + if (wordChars.length < 6) + return "Data too short"; + let chk = prefixChk(prefix); + if (typeof chk === "string") + return chk; + const words = []; + for (let i = 0; i < wordChars.length; ++i) { + const c = wordChars.charAt(i); + const v = ALPHABET_MAP[c]; + if (v === void 0) + return "Unknown character " + c; + chk = polymodStep(chk) ^ v; + if (i + 6 >= wordChars.length) + continue; + words.push(v); + } + if (chk !== ENCODING_CONST) + return "Invalid checksum for " + str; + return { prefix, words }; + } + function decodeUnsafe(str, LIMIT) { + const res = __decode(str, LIMIT); + if (typeof res === "object") + return res; + } + function decode2(str, LIMIT) { + const res = __decode(str, LIMIT); + if (typeof res === "object") + return res; + throw new Error(res); + } + return { + decodeUnsafe, + decode: decode2, + encode, + toWords, + fromWordsUnsafe, + fromWords + }; + } + exports.bech32 = getLibraryFromEncoding("bech32"); + exports.bech32m = getLibraryFromEncoding("bech32m"); + } + }); + + // node_modules/base64-js/index.js + var require_base64_js = __commonJS({ + "node_modules/base64-js/index.js"(exports) { + "use strict"; + init_process(); + exports.byteLength = byteLength; + exports.toByteArray = toByteArray; + exports.fromByteArray = fromByteArray; + var lookup = []; + var revLookup = []; + var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array; + var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + for (i = 0, len = code.length; i < len; ++i) { + lookup[i] = code[i]; + revLookup[code.charCodeAt(i)] = i; + } + var i; + var len; + revLookup["-".charCodeAt(0)] = 62; + revLookup["_".charCodeAt(0)] = 63; + function getLens(b64) { + var len2 = b64.length; + if (len2 % 4 > 0) { + throw new Error("Invalid string. Length must be a multiple of 4"); + } + var validLen = b64.indexOf("="); + if (validLen === -1) validLen = len2; + var placeHoldersLen = validLen === len2 ? 0 : 4 - validLen % 4; + return [validLen, placeHoldersLen]; + } + function byteLength(b64) { + var lens = getLens(b64); + var validLen = lens[0]; + var placeHoldersLen = lens[1]; + return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen; + } + function _byteLength(b64, validLen, placeHoldersLen) { + return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen; + } + function toByteArray(b64) { + var tmp; + var lens = getLens(b64); + var validLen = lens[0]; + var placeHoldersLen = lens[1]; + var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen)); + var curByte = 0; + var len2 = placeHoldersLen > 0 ? validLen - 4 : validLen; + var i2; + for (i2 = 0; i2 < len2; i2 += 4) { + tmp = revLookup[b64.charCodeAt(i2)] << 18 | revLookup[b64.charCodeAt(i2 + 1)] << 12 | revLookup[b64.charCodeAt(i2 + 2)] << 6 | revLookup[b64.charCodeAt(i2 + 3)]; + arr[curByte++] = tmp >> 16 & 255; + arr[curByte++] = tmp >> 8 & 255; + arr[curByte++] = tmp & 255; + } + if (placeHoldersLen === 2) { + tmp = revLookup[b64.charCodeAt(i2)] << 2 | revLookup[b64.charCodeAt(i2 + 1)] >> 4; + arr[curByte++] = tmp & 255; + } + if (placeHoldersLen === 1) { + tmp = revLookup[b64.charCodeAt(i2)] << 10 | revLookup[b64.charCodeAt(i2 + 1)] << 4 | revLookup[b64.charCodeAt(i2 + 2)] >> 2; + arr[curByte++] = tmp >> 8 & 255; + arr[curByte++] = tmp & 255; + } + return arr; + } + function tripletToBase64(num2) { + return lookup[num2 >> 18 & 63] + lookup[num2 >> 12 & 63] + lookup[num2 >> 6 & 63] + lookup[num2 & 63]; + } + function encodeChunk(uint8, start, end) { + var tmp; + var output = []; + for (var i2 = start; i2 < end; i2 += 3) { + tmp = (uint8[i2] << 16 & 16711680) + (uint8[i2 + 1] << 8 & 65280) + (uint8[i2 + 2] & 255); + output.push(tripletToBase64(tmp)); + } + return output.join(""); + } + function fromByteArray(uint8) { + var tmp; + var len2 = uint8.length; + var extraBytes = len2 % 3; + var parts = []; + var maxChunkLength = 16383; + for (var i2 = 0, len22 = len2 - extraBytes; i2 < len22; i2 += maxChunkLength) { + parts.push(encodeChunk(uint8, i2, i2 + maxChunkLength > len22 ? len22 : i2 + maxChunkLength)); + } + if (extraBytes === 1) { + tmp = uint8[len2 - 1]; + parts.push( + lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "==" + ); + } else if (extraBytes === 2) { + tmp = (uint8[len2 - 2] << 8) + uint8[len2 - 1]; + parts.push( + lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "=" + ); + } + return parts.join(""); + } + } + }); + + // node_modules/ieee754/index.js + var require_ieee754 = __commonJS({ + "node_modules/ieee754/index.js"(exports) { + init_process(); + exports.read = function(buffer, offset, isLE3, mLen, nBytes) { + var e, m; + var eLen = nBytes * 8 - mLen - 1; + var eMax = (1 << eLen) - 1; + var eBias = eMax >> 1; + var nBits = -7; + var i = isLE3 ? nBytes - 1 : 0; + var d = isLE3 ? -1 : 1; + var s = buffer[offset + i]; + i += d; + e = s & (1 << -nBits) - 1; + s >>= -nBits; + nBits += eLen; + for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) { + } + m = e & (1 << -nBits) - 1; + e >>= -nBits; + nBits += mLen; + for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) { + } + if (e === 0) { + e = 1 - eBias; + } else if (e === eMax) { + return m ? NaN : (s ? -1 : 1) * Infinity; + } else { + m = m + Math.pow(2, mLen); + e = e - eBias; + } + return (s ? -1 : 1) * m * Math.pow(2, e - mLen); + }; + exports.write = function(buffer, value, offset, isLE3, mLen, nBytes) { + var e, m, c; + var eLen = nBytes * 8 - mLen - 1; + var eMax = (1 << eLen) - 1; + var eBias = eMax >> 1; + var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0; + var i = isLE3 ? 0 : nBytes - 1; + var d = isLE3 ? 1 : -1; + var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0; + value = Math.abs(value); + if (isNaN(value) || value === Infinity) { + m = isNaN(value) ? 1 : 0; + e = eMax; + } else { + e = Math.floor(Math.log(value) / Math.LN2); + if (value * (c = Math.pow(2, -e)) < 1) { + e--; + c *= 2; + } + if (e + eBias >= 1) { + value += rt / c; + } else { + value += rt * Math.pow(2, 1 - eBias); + } + if (value * c >= 2) { + e++; + c /= 2; + } + if (e + eBias >= eMax) { + m = 0; + e = eMax; + } else if (e + eBias >= 1) { + m = (value * c - 1) * Math.pow(2, mLen); + e = e + eBias; + } else { + m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen); + e = 0; + } + } + for (; mLen >= 8; buffer[offset + i] = m & 255, i += d, m /= 256, mLen -= 8) { + } + e = e << mLen | m; + eLen += mLen; + for (; eLen > 0; buffer[offset + i] = e & 255, i += d, e /= 256, eLen -= 8) { + } + buffer[offset + i - d] |= s * 128; + }; + } + }); + + // node_modules/buffer/index.js + var require_buffer = __commonJS({ + "node_modules/buffer/index.js"(exports) { + "use strict"; + init_process(); + var base642 = require_base64_js(); + var ieee754 = require_ieee754(); + var customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null; + exports.Buffer = Buffer3; + exports.SlowBuffer = SlowBuffer; + exports.INSPECT_MAX_BYTES = 50; + var K_MAX_LENGTH = 2147483647; + exports.kMaxLength = K_MAX_LENGTH; + Buffer3.TYPED_ARRAY_SUPPORT = typedArraySupport(); + if (!Buffer3.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") { + console.error( + "This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support." + ); + } + function typedArraySupport() { + try { + const arr = new Uint8Array(1); + const proto = { foo: function() { + return 42; + } }; + Object.setPrototypeOf(proto, Uint8Array.prototype); + Object.setPrototypeOf(arr, proto); + return arr.foo() === 42; + } catch (e) { + return false; + } + } + Object.defineProperty(Buffer3.prototype, "parent", { + enumerable: true, + get: function() { + if (!Buffer3.isBuffer(this)) return void 0; + return this.buffer; + } + }); + Object.defineProperty(Buffer3.prototype, "offset", { + enumerable: true, + get: function() { + if (!Buffer3.isBuffer(this)) return void 0; + return this.byteOffset; + } + }); + function createBuffer(length) { + if (length > K_MAX_LENGTH) { + throw new RangeError('The value "' + length + '" is invalid for option "size"'); + } + const buf = new Uint8Array(length); + Object.setPrototypeOf(buf, Buffer3.prototype); + return buf; + } + function Buffer3(arg, encodingOrOffset, length) { + if (typeof arg === "number") { + if (typeof encodingOrOffset === "string") { + throw new TypeError( + 'The "string" argument must be of type string. Received type number' + ); + } + return allocUnsafe(arg); + } + return from(arg, encodingOrOffset, length); + } + Buffer3.poolSize = 8192; + function from(value, encodingOrOffset, length) { + if (typeof value === "string") { + return fromString(value, encodingOrOffset); + } + if (ArrayBuffer.isView(value)) { + return fromArrayView(value); + } + if (value == null) { + throw new TypeError( + "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value + ); + } + if (isInstance(value, ArrayBuffer) || value && isInstance(value.buffer, ArrayBuffer)) { + return fromArrayBuffer(value, encodingOrOffset, length); + } + if (typeof SharedArrayBuffer !== "undefined" && (isInstance(value, SharedArrayBuffer) || value && isInstance(value.buffer, SharedArrayBuffer))) { + return fromArrayBuffer(value, encodingOrOffset, length); + } + if (typeof value === "number") { + throw new TypeError( + 'The "value" argument must not be of type number. Received type number' + ); + } + const valueOf = value.valueOf && value.valueOf(); + if (valueOf != null && valueOf !== value) { + return Buffer3.from(valueOf, encodingOrOffset, length); + } + const b = fromObject(value); + if (b) return b; + if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") { + return Buffer3.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length); + } + throw new TypeError( + "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value + ); + } + Buffer3.from = function(value, encodingOrOffset, length) { + return from(value, encodingOrOffset, length); + }; + Object.setPrototypeOf(Buffer3.prototype, Uint8Array.prototype); + Object.setPrototypeOf(Buffer3, Uint8Array); + function assertSize(size) { + if (typeof size !== "number") { + throw new TypeError('"size" argument must be of type number'); + } else if (size < 0) { + throw new RangeError('The value "' + size + '" is invalid for option "size"'); + } + } + function alloc(size, fill, encoding) { + assertSize(size); + if (size <= 0) { + return createBuffer(size); + } + if (fill !== void 0) { + return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill); + } + return createBuffer(size); + } + Buffer3.alloc = function(size, fill, encoding) { + return alloc(size, fill, encoding); + }; + function allocUnsafe(size) { + assertSize(size); + return createBuffer(size < 0 ? 0 : checked(size) | 0); + } + Buffer3.allocUnsafe = function(size) { + return allocUnsafe(size); + }; + Buffer3.allocUnsafeSlow = function(size) { + return allocUnsafe(size); + }; + function fromString(string, encoding) { + if (typeof encoding !== "string" || encoding === "") { + encoding = "utf8"; + } + if (!Buffer3.isEncoding(encoding)) { + throw new TypeError("Unknown encoding: " + encoding); + } + const length = byteLength(string, encoding) | 0; + let buf = createBuffer(length); + const actual = buf.write(string, encoding); + if (actual !== length) { + buf = buf.slice(0, actual); + } + return buf; + } + function fromArrayLike(array) { + const length = array.length < 0 ? 0 : checked(array.length) | 0; + const buf = createBuffer(length); + for (let i = 0; i < length; i += 1) { + buf[i] = array[i] & 255; + } + return buf; + } + function fromArrayView(arrayView) { + if (isInstance(arrayView, Uint8Array)) { + const copy = new Uint8Array(arrayView); + return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength); + } + return fromArrayLike(arrayView); + } + function fromArrayBuffer(array, byteOffset, length) { + if (byteOffset < 0 || array.byteLength < byteOffset) { + throw new RangeError('"offset" is outside of buffer bounds'); + } + if (array.byteLength < byteOffset + (length || 0)) { + throw new RangeError('"length" is outside of buffer bounds'); + } + let buf; + if (byteOffset === void 0 && length === void 0) { + buf = new Uint8Array(array); + } else if (length === void 0) { + buf = new Uint8Array(array, byteOffset); + } else { + buf = new Uint8Array(array, byteOffset, length); + } + Object.setPrototypeOf(buf, Buffer3.prototype); + return buf; + } + function fromObject(obj) { + if (Buffer3.isBuffer(obj)) { + const len = checked(obj.length) | 0; + const buf = createBuffer(len); + if (buf.length === 0) { + return buf; + } + obj.copy(buf, 0, 0, len); + return buf; + } + if (obj.length !== void 0) { + if (typeof obj.length !== "number" || numberIsNaN(obj.length)) { + return createBuffer(0); + } + return fromArrayLike(obj); + } + if (obj.type === "Buffer" && Array.isArray(obj.data)) { + return fromArrayLike(obj.data); + } + } + function checked(length) { + if (length >= K_MAX_LENGTH) { + throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + " bytes"); + } + return length | 0; + } + function SlowBuffer(length) { + if (+length != length) { + length = 0; + } + return Buffer3.alloc(+length); + } + Buffer3.isBuffer = function isBuffer(b) { + return b != null && b._isBuffer === true && b !== Buffer3.prototype; + }; + Buffer3.compare = function compare(a, b) { + if (isInstance(a, Uint8Array)) a = Buffer3.from(a, a.offset, a.byteLength); + if (isInstance(b, Uint8Array)) b = Buffer3.from(b, b.offset, b.byteLength); + if (!Buffer3.isBuffer(a) || !Buffer3.isBuffer(b)) { + throw new TypeError( + 'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array' + ); + } + if (a === b) return 0; + let x = a.length; + let y = b.length; + for (let i = 0, len = Math.min(x, y); i < len; ++i) { + if (a[i] !== b[i]) { + x = a[i]; + y = b[i]; + break; + } + } + if (x < y) return -1; + if (y < x) return 1; + return 0; + }; + Buffer3.isEncoding = function isEncoding(encoding) { + switch (String(encoding).toLowerCase()) { + case "hex": + case "utf8": + case "utf-8": + case "ascii": + case "latin1": + case "binary": + case "base64": + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + return true; + default: + return false; + } + }; + Buffer3.concat = function concat(list, length) { + if (!Array.isArray(list)) { + throw new TypeError('"list" argument must be an Array of Buffers'); + } + if (list.length === 0) { + return Buffer3.alloc(0); + } + let i; + if (length === void 0) { + length = 0; + for (i = 0; i < list.length; ++i) { + length += list[i].length; + } + } + const buffer = Buffer3.allocUnsafe(length); + let pos = 0; + for (i = 0; i < list.length; ++i) { + let buf = list[i]; + if (isInstance(buf, Uint8Array)) { + if (pos + buf.length > buffer.length) { + if (!Buffer3.isBuffer(buf)) buf = Buffer3.from(buf); + buf.copy(buffer, pos); + } else { + Uint8Array.prototype.set.call( + buffer, + buf, + pos + ); + } + } else if (!Buffer3.isBuffer(buf)) { + throw new TypeError('"list" argument must be an Array of Buffers'); + } else { + buf.copy(buffer, pos); + } + pos += buf.length; + } + return buffer; + }; + function byteLength(string, encoding) { + if (Buffer3.isBuffer(string)) { + return string.length; + } + if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) { + return string.byteLength; + } + if (typeof string !== "string") { + throw new TypeError( + 'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string + ); + } + const len = string.length; + const mustMatch = arguments.length > 2 && arguments[2] === true; + if (!mustMatch && len === 0) return 0; + let loweredCase = false; + for (; ; ) { + switch (encoding) { + case "ascii": + case "latin1": + case "binary": + return len; + case "utf8": + case "utf-8": + return utf8ToBytes3(string).length; + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + return len * 2; + case "hex": + return len >>> 1; + case "base64": + return base64ToBytes2(string).length; + default: + if (loweredCase) { + return mustMatch ? -1 : utf8ToBytes3(string).length; + } + encoding = ("" + encoding).toLowerCase(); + loweredCase = true; + } + } + } + Buffer3.byteLength = byteLength; + function slowToString(encoding, start, end) { + let loweredCase = false; + if (start === void 0 || start < 0) { + start = 0; + } + if (start > this.length) { + return ""; + } + if (end === void 0 || end > this.length) { + end = this.length; + } + if (end <= 0) { + return ""; + } + end >>>= 0; + start >>>= 0; + if (end <= start) { + return ""; + } + if (!encoding) encoding = "utf8"; + while (true) { + switch (encoding) { + case "hex": + return hexSlice(this, start, end); + case "utf8": + case "utf-8": + return utf8Slice(this, start, end); + case "ascii": + return asciiSlice(this, start, end); + case "latin1": + case "binary": + return latin1Slice(this, start, end); + case "base64": + return base64Slice(this, start, end); + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + return utf16leSlice(this, start, end); + default: + if (loweredCase) throw new TypeError("Unknown encoding: " + encoding); + encoding = (encoding + "").toLowerCase(); + loweredCase = true; + } + } + } + Buffer3.prototype._isBuffer = true; + function swap(b, n, m) { + const i = b[n]; + b[n] = b[m]; + b[m] = i; + } + Buffer3.prototype.swap16 = function swap16() { + const len = this.length; + if (len % 2 !== 0) { + throw new RangeError("Buffer size must be a multiple of 16-bits"); + } + for (let i = 0; i < len; i += 2) { + swap(this, i, i + 1); + } + return this; + }; + Buffer3.prototype.swap32 = function swap32() { + const len = this.length; + if (len % 4 !== 0) { + throw new RangeError("Buffer size must be a multiple of 32-bits"); + } + for (let i = 0; i < len; i += 4) { + swap(this, i, i + 3); + swap(this, i + 1, i + 2); + } + return this; + }; + Buffer3.prototype.swap64 = function swap64() { + const len = this.length; + if (len % 8 !== 0) { + throw new RangeError("Buffer size must be a multiple of 64-bits"); + } + for (let i = 0; i < len; i += 8) { + swap(this, i, i + 7); + swap(this, i + 1, i + 6); + swap(this, i + 2, i + 5); + swap(this, i + 3, i + 4); + } + return this; + }; + Buffer3.prototype.toString = function toString() { + const length = this.length; + if (length === 0) return ""; + if (arguments.length === 0) return utf8Slice(this, 0, length); + return slowToString.apply(this, arguments); + }; + Buffer3.prototype.toLocaleString = Buffer3.prototype.toString; + Buffer3.prototype.equals = function equals(b) { + if (!Buffer3.isBuffer(b)) throw new TypeError("Argument must be a Buffer"); + if (this === b) return true; + return Buffer3.compare(this, b) === 0; + }; + Buffer3.prototype.inspect = function inspect() { + let str = ""; + const max = exports.INSPECT_MAX_BYTES; + str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim(); + if (this.length > max) str += " ... "; + return ""; + }; + if (customInspectSymbol) { + Buffer3.prototype[customInspectSymbol] = Buffer3.prototype.inspect; + } + Buffer3.prototype.compare = function compare(target, start, end, thisStart, thisEnd) { + if (isInstance(target, Uint8Array)) { + target = Buffer3.from(target, target.offset, target.byteLength); + } + if (!Buffer3.isBuffer(target)) { + throw new TypeError( + 'The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof target + ); + } + if (start === void 0) { + start = 0; + } + if (end === void 0) { + end = target ? target.length : 0; + } + if (thisStart === void 0) { + thisStart = 0; + } + if (thisEnd === void 0) { + thisEnd = this.length; + } + if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) { + throw new RangeError("out of range index"); + } + if (thisStart >= thisEnd && start >= end) { + return 0; + } + if (thisStart >= thisEnd) { + return -1; + } + if (start >= end) { + return 1; + } + start >>>= 0; + end >>>= 0; + thisStart >>>= 0; + thisEnd >>>= 0; + if (this === target) return 0; + let x = thisEnd - thisStart; + let y = end - start; + const len = Math.min(x, y); + const thisCopy = this.slice(thisStart, thisEnd); + const targetCopy = target.slice(start, end); + for (let i = 0; i < len; ++i) { + if (thisCopy[i] !== targetCopy[i]) { + x = thisCopy[i]; + y = targetCopy[i]; + break; + } + } + if (x < y) return -1; + if (y < x) return 1; + return 0; + }; + function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) { + if (buffer.length === 0) return -1; + if (typeof byteOffset === "string") { + encoding = byteOffset; + byteOffset = 0; + } else if (byteOffset > 2147483647) { + byteOffset = 2147483647; + } else if (byteOffset < -2147483648) { + byteOffset = -2147483648; + } + byteOffset = +byteOffset; + if (numberIsNaN(byteOffset)) { + byteOffset = dir ? 0 : buffer.length - 1; + } + if (byteOffset < 0) byteOffset = buffer.length + byteOffset; + if (byteOffset >= buffer.length) { + if (dir) return -1; + else byteOffset = buffer.length - 1; + } else if (byteOffset < 0) { + if (dir) byteOffset = 0; + else return -1; + } + if (typeof val === "string") { + val = Buffer3.from(val, encoding); + } + if (Buffer3.isBuffer(val)) { + if (val.length === 0) { + return -1; + } + return arrayIndexOf(buffer, val, byteOffset, encoding, dir); + } else if (typeof val === "number") { + val = val & 255; + if (typeof Uint8Array.prototype.indexOf === "function") { + if (dir) { + return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset); + } else { + return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset); + } + } + return arrayIndexOf(buffer, [val], byteOffset, encoding, dir); + } + throw new TypeError("val must be string, number or Buffer"); + } + function arrayIndexOf(arr, val, byteOffset, encoding, dir) { + let indexSize = 1; + let arrLength = arr.length; + let valLength = val.length; + if (encoding !== void 0) { + encoding = String(encoding).toLowerCase(); + if (encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") { + if (arr.length < 2 || val.length < 2) { + return -1; + } + indexSize = 2; + arrLength /= 2; + valLength /= 2; + byteOffset /= 2; + } + } + function read(buf, i2) { + if (indexSize === 1) { + return buf[i2]; + } else { + return buf.readUInt16BE(i2 * indexSize); + } + } + let i; + if (dir) { + let foundIndex = -1; + for (i = byteOffset; i < arrLength; i++) { + if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) { + if (foundIndex === -1) foundIndex = i; + if (i - foundIndex + 1 === valLength) return foundIndex * indexSize; + } else { + if (foundIndex !== -1) i -= i - foundIndex; + foundIndex = -1; + } + } + } else { + if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength; + for (i = byteOffset; i >= 0; i--) { + let found = true; + for (let j = 0; j < valLength; j++) { + if (read(arr, i + j) !== read(val, j)) { + found = false; + break; + } + } + if (found) return i; + } + } + return -1; + } + Buffer3.prototype.includes = function includes(val, byteOffset, encoding) { + return this.indexOf(val, byteOffset, encoding) !== -1; + }; + Buffer3.prototype.indexOf = function indexOf(val, byteOffset, encoding) { + return bidirectionalIndexOf(this, val, byteOffset, encoding, true); + }; + Buffer3.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) { + return bidirectionalIndexOf(this, val, byteOffset, encoding, false); + }; + function hexWrite(buf, string, offset, length) { + offset = Number(offset) || 0; + const remaining = buf.length - offset; + if (!length) { + length = remaining; + } else { + length = Number(length); + if (length > remaining) { + length = remaining; + } + } + const strLen = string.length; + if (length > strLen / 2) { + length = strLen / 2; + } + let i; + for (i = 0; i < length; ++i) { + const parsed = parseInt(string.substr(i * 2, 2), 16); + if (numberIsNaN(parsed)) return i; + buf[offset + i] = parsed; + } + return i; + } + function utf8Write(buf, string, offset, length) { + return blitBuffer(utf8ToBytes3(string, buf.length - offset), buf, offset, length); + } + function asciiWrite(buf, string, offset, length) { + return blitBuffer(asciiToBytes2(string), buf, offset, length); + } + function base64Write(buf, string, offset, length) { + return blitBuffer(base64ToBytes2(string), buf, offset, length); + } + function ucs2Write(buf, string, offset, length) { + return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length); + } + Buffer3.prototype.write = function write(string, offset, length, encoding) { + if (offset === void 0) { + encoding = "utf8"; + length = this.length; + offset = 0; + } else if (length === void 0 && typeof offset === "string") { + encoding = offset; + length = this.length; + offset = 0; + } else if (isFinite(offset)) { + offset = offset >>> 0; + if (isFinite(length)) { + length = length >>> 0; + if (encoding === void 0) encoding = "utf8"; + } else { + encoding = length; + length = void 0; + } + } else { + throw new Error( + "Buffer.write(string, encoding, offset[, length]) is no longer supported" + ); + } + const remaining = this.length - offset; + if (length === void 0 || length > remaining) length = remaining; + if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) { + throw new RangeError("Attempt to write outside buffer bounds"); + } + if (!encoding) encoding = "utf8"; + let loweredCase = false; + for (; ; ) { + switch (encoding) { + case "hex": + return hexWrite(this, string, offset, length); + case "utf8": + case "utf-8": + return utf8Write(this, string, offset, length); + case "ascii": + case "latin1": + case "binary": + return asciiWrite(this, string, offset, length); + case "base64": + return base64Write(this, string, offset, length); + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + return ucs2Write(this, string, offset, length); + default: + if (loweredCase) throw new TypeError("Unknown encoding: " + encoding); + encoding = ("" + encoding).toLowerCase(); + loweredCase = true; + } + } + }; + Buffer3.prototype.toJSON = function toJSON() { + return { + type: "Buffer", + data: Array.prototype.slice.call(this._arr || this, 0) + }; + }; + function base64Slice(buf, start, end) { + if (start === 0 && end === buf.length) { + return base642.fromByteArray(buf); + } else { + return base642.fromByteArray(buf.slice(start, end)); + } + } + function utf8Slice(buf, start, end) { + end = Math.min(buf.length, end); + const res = []; + let i = start; + while (i < end) { + const firstByte = buf[i]; + let codePoint = null; + let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1; + if (i + bytesPerSequence <= end) { + let secondByte, thirdByte, fourthByte, tempCodePoint; + switch (bytesPerSequence) { + case 1: + if (firstByte < 128) { + codePoint = firstByte; + } + break; + case 2: + secondByte = buf[i + 1]; + if ((secondByte & 192) === 128) { + tempCodePoint = (firstByte & 31) << 6 | secondByte & 63; + if (tempCodePoint > 127) { + codePoint = tempCodePoint; + } + } + break; + case 3: + secondByte = buf[i + 1]; + thirdByte = buf[i + 2]; + if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) { + tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63; + if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) { + codePoint = tempCodePoint; + } + } + break; + case 4: + secondByte = buf[i + 1]; + thirdByte = buf[i + 2]; + fourthByte = buf[i + 3]; + if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) { + tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63; + if (tempCodePoint > 65535 && tempCodePoint < 1114112) { + codePoint = tempCodePoint; + } + } + } + } + if (codePoint === null) { + codePoint = 65533; + bytesPerSequence = 1; + } else if (codePoint > 65535) { + codePoint -= 65536; + res.push(codePoint >>> 10 & 1023 | 55296); + codePoint = 56320 | codePoint & 1023; + } + res.push(codePoint); + i += bytesPerSequence; + } + return decodeCodePointsArray(res); + } + var MAX_ARGUMENTS_LENGTH = 4096; + function decodeCodePointsArray(codePoints) { + const len = codePoints.length; + if (len <= MAX_ARGUMENTS_LENGTH) { + return String.fromCharCode.apply(String, codePoints); + } + let res = ""; + let i = 0; + while (i < len) { + res += String.fromCharCode.apply( + String, + codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH) + ); + } + return res; + } + function asciiSlice(buf, start, end) { + let ret = ""; + end = Math.min(buf.length, end); + for (let i = start; i < end; ++i) { + ret += String.fromCharCode(buf[i] & 127); + } + return ret; + } + function latin1Slice(buf, start, end) { + let ret = ""; + end = Math.min(buf.length, end); + for (let i = start; i < end; ++i) { + ret += String.fromCharCode(buf[i]); + } + return ret; + } + function hexSlice(buf, start, end) { + const len = buf.length; + if (!start || start < 0) start = 0; + if (!end || end < 0 || end > len) end = len; + let out = ""; + for (let i = start; i < end; ++i) { + out += hexSliceLookupTable[buf[i]]; + } + return out; + } + function utf16leSlice(buf, start, end) { + const bytes = buf.slice(start, end); + let res = ""; + for (let i = 0; i < bytes.length - 1; i += 2) { + res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256); + } + return res; + } + Buffer3.prototype.slice = function slice(start, end) { + const len = this.length; + start = ~~start; + end = end === void 0 ? len : ~~end; + if (start < 0) { + start += len; + if (start < 0) start = 0; + } else if (start > len) { + start = len; + } + if (end < 0) { + end += len; + if (end < 0) end = 0; + } else if (end > len) { + end = len; + } + if (end < start) end = start; + const newBuf = this.subarray(start, end); + Object.setPrototypeOf(newBuf, Buffer3.prototype); + return newBuf; + }; + function checkOffset(offset, ext, length) { + if (offset % 1 !== 0 || offset < 0) throw new RangeError("offset is not uint"); + if (offset + ext > length) throw new RangeError("Trying to access beyond buffer length"); + } + Buffer3.prototype.readUintLE = Buffer3.prototype.readUIntLE = function readUIntLE(offset, byteLength2, noAssert) { + offset = offset >>> 0; + byteLength2 = byteLength2 >>> 0; + if (!noAssert) checkOffset(offset, byteLength2, this.length); + let val = this[offset]; + let mul = 1; + let i = 0; + while (++i < byteLength2 && (mul *= 256)) { + val += this[offset + i] * mul; + } + return val; + }; + Buffer3.prototype.readUintBE = Buffer3.prototype.readUIntBE = function readUIntBE(offset, byteLength2, noAssert) { + offset = offset >>> 0; + byteLength2 = byteLength2 >>> 0; + if (!noAssert) { + checkOffset(offset, byteLength2, this.length); + } + let val = this[offset + --byteLength2]; + let mul = 1; + while (byteLength2 > 0 && (mul *= 256)) { + val += this[offset + --byteLength2] * mul; + } + return val; + }; + Buffer3.prototype.readUint8 = Buffer3.prototype.readUInt8 = function readUInt8(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 1, this.length); + return this[offset]; + }; + Buffer3.prototype.readUint16LE = Buffer3.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 2, this.length); + return this[offset] | this[offset + 1] << 8; + }; + Buffer3.prototype.readUint16BE = Buffer3.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 2, this.length); + return this[offset] << 8 | this[offset + 1]; + }; + Buffer3.prototype.readUint32LE = Buffer3.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 4, this.length); + return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216; + }; + Buffer3.prototype.readUint32BE = Buffer3.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 4, this.length); + return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]); + }; + Buffer3.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE(offset) { + offset = offset >>> 0; + validateNumber(offset, "offset"); + const first = this[offset]; + const last = this[offset + 7]; + if (first === void 0 || last === void 0) { + boundsError(offset, this.length - 8); + } + const lo = first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24; + const hi = this[++offset] + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + last * 2 ** 24; + return BigInt(lo) + (BigInt(hi) << BigInt(32)); + }); + Buffer3.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE(offset) { + offset = offset >>> 0; + validateNumber(offset, "offset"); + const first = this[offset]; + const last = this[offset + 7]; + if (first === void 0 || last === void 0) { + boundsError(offset, this.length - 8); + } + const hi = first * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset]; + const lo = this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last; + return (BigInt(hi) << BigInt(32)) + BigInt(lo); + }); + Buffer3.prototype.readIntLE = function readIntLE(offset, byteLength2, noAssert) { + offset = offset >>> 0; + byteLength2 = byteLength2 >>> 0; + if (!noAssert) checkOffset(offset, byteLength2, this.length); + let val = this[offset]; + let mul = 1; + let i = 0; + while (++i < byteLength2 && (mul *= 256)) { + val += this[offset + i] * mul; + } + mul *= 128; + if (val >= mul) val -= Math.pow(2, 8 * byteLength2); + return val; + }; + Buffer3.prototype.readIntBE = function readIntBE(offset, byteLength2, noAssert) { + offset = offset >>> 0; + byteLength2 = byteLength2 >>> 0; + if (!noAssert) checkOffset(offset, byteLength2, this.length); + let i = byteLength2; + let mul = 1; + let val = this[offset + --i]; + while (i > 0 && (mul *= 256)) { + val += this[offset + --i] * mul; + } + mul *= 128; + if (val >= mul) val -= Math.pow(2, 8 * byteLength2); + return val; + }; + Buffer3.prototype.readInt8 = function readInt8(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 1, this.length); + if (!(this[offset] & 128)) return this[offset]; + return (255 - this[offset] + 1) * -1; + }; + Buffer3.prototype.readInt16LE = function readInt16LE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 2, this.length); + const val = this[offset] | this[offset + 1] << 8; + return val & 32768 ? val | 4294901760 : val; + }; + Buffer3.prototype.readInt16BE = function readInt16BE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 2, this.length); + const val = this[offset + 1] | this[offset] << 8; + return val & 32768 ? val | 4294901760 : val; + }; + Buffer3.prototype.readInt32LE = function readInt32LE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 4, this.length); + return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24; + }; + Buffer3.prototype.readInt32BE = function readInt32BE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 4, this.length); + return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]; + }; + Buffer3.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE(offset) { + offset = offset >>> 0; + validateNumber(offset, "offset"); + const first = this[offset]; + const last = this[offset + 7]; + if (first === void 0 || last === void 0) { + boundsError(offset, this.length - 8); + } + const val = this[offset + 4] + this[offset + 5] * 2 ** 8 + this[offset + 6] * 2 ** 16 + (last << 24); + return (BigInt(val) << BigInt(32)) + BigInt(first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24); + }); + Buffer3.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE(offset) { + offset = offset >>> 0; + validateNumber(offset, "offset"); + const first = this[offset]; + const last = this[offset + 7]; + if (first === void 0 || last === void 0) { + boundsError(offset, this.length - 8); + } + const val = (first << 24) + // Overflow + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset]; + return (BigInt(val) << BigInt(32)) + BigInt(this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last); + }); + Buffer3.prototype.readFloatLE = function readFloatLE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 4, this.length); + return ieee754.read(this, offset, true, 23, 4); + }; + Buffer3.prototype.readFloatBE = function readFloatBE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 4, this.length); + return ieee754.read(this, offset, false, 23, 4); + }; + Buffer3.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 8, this.length); + return ieee754.read(this, offset, true, 52, 8); + }; + Buffer3.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 8, this.length); + return ieee754.read(this, offset, false, 52, 8); + }; + function checkInt(buf, value, offset, ext, max, min) { + if (!Buffer3.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance'); + if (value > max || value < min) throw new RangeError('"value" argument is out of bounds'); + if (offset + ext > buf.length) throw new RangeError("Index out of range"); + } + Buffer3.prototype.writeUintLE = Buffer3.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength2, noAssert) { + value = +value; + offset = offset >>> 0; + byteLength2 = byteLength2 >>> 0; + if (!noAssert) { + const maxBytes = Math.pow(2, 8 * byteLength2) - 1; + checkInt(this, value, offset, byteLength2, maxBytes, 0); + } + let mul = 1; + let i = 0; + this[offset] = value & 255; + while (++i < byteLength2 && (mul *= 256)) { + this[offset + i] = value / mul & 255; + } + return offset + byteLength2; + }; + Buffer3.prototype.writeUintBE = Buffer3.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength2, noAssert) { + value = +value; + offset = offset >>> 0; + byteLength2 = byteLength2 >>> 0; + if (!noAssert) { + const maxBytes = Math.pow(2, 8 * byteLength2) - 1; + checkInt(this, value, offset, byteLength2, maxBytes, 0); + } + let i = byteLength2 - 1; + let mul = 1; + this[offset + i] = value & 255; + while (--i >= 0 && (mul *= 256)) { + this[offset + i] = value / mul & 255; + } + return offset + byteLength2; + }; + Buffer3.prototype.writeUint8 = Buffer3.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) checkInt(this, value, offset, 1, 255, 0); + this[offset] = value & 255; + return offset + 1; + }; + Buffer3.prototype.writeUint16LE = Buffer3.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) checkInt(this, value, offset, 2, 65535, 0); + this[offset] = value & 255; + this[offset + 1] = value >>> 8; + return offset + 2; + }; + Buffer3.prototype.writeUint16BE = Buffer3.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) checkInt(this, value, offset, 2, 65535, 0); + this[offset] = value >>> 8; + this[offset + 1] = value & 255; + return offset + 2; + }; + Buffer3.prototype.writeUint32LE = Buffer3.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0); + this[offset + 3] = value >>> 24; + this[offset + 2] = value >>> 16; + this[offset + 1] = value >>> 8; + this[offset] = value & 255; + return offset + 4; + }; + Buffer3.prototype.writeUint32BE = Buffer3.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0); + this[offset] = value >>> 24; + this[offset + 1] = value >>> 16; + this[offset + 2] = value >>> 8; + this[offset + 3] = value & 255; + return offset + 4; + }; + function wrtBigUInt64LE(buf, value, offset, min, max) { + checkIntBI(value, min, max, buf, offset, 7); + let lo = Number(value & BigInt(4294967295)); + buf[offset++] = lo; + lo = lo >> 8; + buf[offset++] = lo; + lo = lo >> 8; + buf[offset++] = lo; + lo = lo >> 8; + buf[offset++] = lo; + let hi = Number(value >> BigInt(32) & BigInt(4294967295)); + buf[offset++] = hi; + hi = hi >> 8; + buf[offset++] = hi; + hi = hi >> 8; + buf[offset++] = hi; + hi = hi >> 8; + buf[offset++] = hi; + return offset; + } + function wrtBigUInt64BE(buf, value, offset, min, max) { + checkIntBI(value, min, max, buf, offset, 7); + let lo = Number(value & BigInt(4294967295)); + buf[offset + 7] = lo; + lo = lo >> 8; + buf[offset + 6] = lo; + lo = lo >> 8; + buf[offset + 5] = lo; + lo = lo >> 8; + buf[offset + 4] = lo; + let hi = Number(value >> BigInt(32) & BigInt(4294967295)); + buf[offset + 3] = hi; + hi = hi >> 8; + buf[offset + 2] = hi; + hi = hi >> 8; + buf[offset + 1] = hi; + hi = hi >> 8; + buf[offset] = hi; + return offset + 8; + } + Buffer3.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value, offset = 0) { + return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff")); + }); + Buffer3.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value, offset = 0) { + return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff")); + }); + Buffer3.prototype.writeIntLE = function writeIntLE(value, offset, byteLength2, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) { + const limit = Math.pow(2, 8 * byteLength2 - 1); + checkInt(this, value, offset, byteLength2, limit - 1, -limit); + } + let i = 0; + let mul = 1; + let sub = 0; + this[offset] = value & 255; + while (++i < byteLength2 && (mul *= 256)) { + if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) { + sub = 1; + } + this[offset + i] = (value / mul >> 0) - sub & 255; + } + return offset + byteLength2; + }; + Buffer3.prototype.writeIntBE = function writeIntBE(value, offset, byteLength2, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) { + const limit = Math.pow(2, 8 * byteLength2 - 1); + checkInt(this, value, offset, byteLength2, limit - 1, -limit); + } + let i = byteLength2 - 1; + let mul = 1; + let sub = 0; + this[offset + i] = value & 255; + while (--i >= 0 && (mul *= 256)) { + if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) { + sub = 1; + } + this[offset + i] = (value / mul >> 0) - sub & 255; + } + return offset + byteLength2; + }; + Buffer3.prototype.writeInt8 = function writeInt8(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) checkInt(this, value, offset, 1, 127, -128); + if (value < 0) value = 255 + value + 1; + this[offset] = value & 255; + return offset + 1; + }; + Buffer3.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768); + this[offset] = value & 255; + this[offset + 1] = value >>> 8; + return offset + 2; + }; + Buffer3.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768); + this[offset] = value >>> 8; + this[offset + 1] = value & 255; + return offset + 2; + }; + Buffer3.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648); + this[offset] = value & 255; + this[offset + 1] = value >>> 8; + this[offset + 2] = value >>> 16; + this[offset + 3] = value >>> 24; + return offset + 4; + }; + Buffer3.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648); + if (value < 0) value = 4294967295 + value + 1; + this[offset] = value >>> 24; + this[offset + 1] = value >>> 16; + this[offset + 2] = value >>> 8; + this[offset + 3] = value & 255; + return offset + 4; + }; + Buffer3.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value, offset = 0) { + return wrtBigUInt64LE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff")); + }); + Buffer3.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE(value, offset = 0) { + return wrtBigUInt64BE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff")); + }); + function checkIEEE754(buf, value, offset, ext, max, min) { + if (offset + ext > buf.length) throw new RangeError("Index out of range"); + if (offset < 0) throw new RangeError("Index out of range"); + } + function writeFloat(buf, value, offset, littleEndian, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) { + checkIEEE754(buf, value, offset, 4, 34028234663852886e22, -34028234663852886e22); + } + ieee754.write(buf, value, offset, littleEndian, 23, 4); + return offset + 4; + } + Buffer3.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) { + return writeFloat(this, value, offset, true, noAssert); + }; + Buffer3.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) { + return writeFloat(this, value, offset, false, noAssert); + }; + function writeDouble(buf, value, offset, littleEndian, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) { + checkIEEE754(buf, value, offset, 8, 17976931348623157e292, -17976931348623157e292); + } + ieee754.write(buf, value, offset, littleEndian, 52, 8); + return offset + 8; + } + Buffer3.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) { + return writeDouble(this, value, offset, true, noAssert); + }; + Buffer3.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) { + return writeDouble(this, value, offset, false, noAssert); + }; + Buffer3.prototype.copy = function copy(target, targetStart, start, end) { + if (!Buffer3.isBuffer(target)) throw new TypeError("argument should be a Buffer"); + if (!start) start = 0; + if (!end && end !== 0) end = this.length; + if (targetStart >= target.length) targetStart = target.length; + if (!targetStart) targetStart = 0; + if (end > 0 && end < start) end = start; + if (end === start) return 0; + if (target.length === 0 || this.length === 0) return 0; + if (targetStart < 0) { + throw new RangeError("targetStart out of bounds"); + } + if (start < 0 || start >= this.length) throw new RangeError("Index out of range"); + if (end < 0) throw new RangeError("sourceEnd out of bounds"); + if (end > this.length) end = this.length; + if (target.length - targetStart < end - start) { + end = target.length - targetStart + start; + } + const len = end - start; + if (this === target && typeof Uint8Array.prototype.copyWithin === "function") { + this.copyWithin(targetStart, start, end); + } else { + Uint8Array.prototype.set.call( + target, + this.subarray(start, end), + targetStart + ); + } + return len; + }; + Buffer3.prototype.fill = function fill(val, start, end, encoding) { + if (typeof val === "string") { + if (typeof start === "string") { + encoding = start; + start = 0; + end = this.length; + } else if (typeof end === "string") { + encoding = end; + end = this.length; + } + if (encoding !== void 0 && typeof encoding !== "string") { + throw new TypeError("encoding must be a string"); + } + if (typeof encoding === "string" && !Buffer3.isEncoding(encoding)) { + throw new TypeError("Unknown encoding: " + encoding); + } + if (val.length === 1) { + const code = val.charCodeAt(0); + if (encoding === "utf8" && code < 128 || encoding === "latin1") { + val = code; + } + } + } else if (typeof val === "number") { + val = val & 255; + } else if (typeof val === "boolean") { + val = Number(val); + } + if (start < 0 || this.length < start || this.length < end) { + throw new RangeError("Out of range index"); + } + if (end <= start) { + return this; + } + start = start >>> 0; + end = end === void 0 ? this.length : end >>> 0; + if (!val) val = 0; + let i; + if (typeof val === "number") { + for (i = start; i < end; ++i) { + this[i] = val; + } + } else { + const bytes = Buffer3.isBuffer(val) ? val : Buffer3.from(val, encoding); + const len = bytes.length; + if (len === 0) { + throw new TypeError('The value "' + val + '" is invalid for argument "value"'); + } + for (i = 0; i < end - start; ++i) { + this[i + start] = bytes[i % len]; + } + } + return this; + }; + var errors = {}; + function E(sym, getMessage, Base) { + errors[sym] = class NodeError extends Base { + constructor() { + super(); + Object.defineProperty(this, "message", { + value: getMessage.apply(this, arguments), + writable: true, + configurable: true + }); + this.name = `${this.name} [${sym}]`; + this.stack; + delete this.name; + } + get code() { + return sym; + } + set code(value) { + Object.defineProperty(this, "code", { + configurable: true, + enumerable: true, + value, + writable: true + }); + } + toString() { + return `${this.name} [${sym}]: ${this.message}`; + } + }; + } + E( + "ERR_BUFFER_OUT_OF_BOUNDS", + function(name) { + if (name) { + return `${name} is outside of buffer bounds`; + } + return "Attempt to access memory outside buffer bounds"; + }, + RangeError + ); + E( + "ERR_INVALID_ARG_TYPE", + function(name, actual) { + return `The "${name}" argument must be of type number. Received type ${typeof actual}`; + }, + TypeError + ); + E( + "ERR_OUT_OF_RANGE", + function(str, range, input) { + let msg = `The value of "${str}" is out of range.`; + let received = input; + if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) { + received = addNumericalSeparator(String(input)); + } else if (typeof input === "bigint") { + received = String(input); + if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) { + received = addNumericalSeparator(received); + } + received += "n"; + } + msg += ` It must be ${range}. Received ${received}`; + return msg; + }, + RangeError + ); + function addNumericalSeparator(val) { + let res = ""; + let i = val.length; + const start = val[0] === "-" ? 1 : 0; + for (; i >= start + 4; i -= 3) { + res = `_${val.slice(i - 3, i)}${res}`; + } + return `${val.slice(0, i)}${res}`; + } + function checkBounds(buf, offset, byteLength2) { + validateNumber(offset, "offset"); + if (buf[offset] === void 0 || buf[offset + byteLength2] === void 0) { + boundsError(offset, buf.length - (byteLength2 + 1)); + } + } + function checkIntBI(value, min, max, buf, offset, byteLength2) { + if (value > max || value < min) { + const n = typeof min === "bigint" ? "n" : ""; + let range; + if (byteLength2 > 3) { + if (min === 0 || min === BigInt(0)) { + range = `>= 0${n} and < 2${n} ** ${(byteLength2 + 1) * 8}${n}`; + } else { + range = `>= -(2${n} ** ${(byteLength2 + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength2 + 1) * 8 - 1}${n}`; + } + } else { + range = `>= ${min}${n} and <= ${max}${n}`; + } + throw new errors.ERR_OUT_OF_RANGE("value", range, value); + } + checkBounds(buf, offset, byteLength2); + } + function validateNumber(value, name) { + if (typeof value !== "number") { + throw new errors.ERR_INVALID_ARG_TYPE(name, "number", value); + } + } + function boundsError(value, length, type) { + if (Math.floor(value) !== value) { + validateNumber(value, type); + throw new errors.ERR_OUT_OF_RANGE(type || "offset", "an integer", value); + } + if (length < 0) { + throw new errors.ERR_BUFFER_OUT_OF_BOUNDS(); + } + throw new errors.ERR_OUT_OF_RANGE( + type || "offset", + `>= ${type ? 1 : 0} and <= ${length}`, + value + ); + } + var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g; + function base64clean(str) { + str = str.split("=")[0]; + str = str.trim().replace(INVALID_BASE64_RE, ""); + if (str.length < 2) return ""; + while (str.length % 4 !== 0) { + str = str + "="; + } + return str; + } + function utf8ToBytes3(string, units) { + units = units || Infinity; + let codePoint; + const length = string.length; + let leadSurrogate = null; + const bytes = []; + for (let i = 0; i < length; ++i) { + codePoint = string.charCodeAt(i); + if (codePoint > 55295 && codePoint < 57344) { + if (!leadSurrogate) { + if (codePoint > 56319) { + if ((units -= 3) > -1) bytes.push(239, 191, 189); + continue; + } else if (i + 1 === length) { + if ((units -= 3) > -1) bytes.push(239, 191, 189); + continue; + } + leadSurrogate = codePoint; + continue; + } + if (codePoint < 56320) { + if ((units -= 3) > -1) bytes.push(239, 191, 189); + leadSurrogate = codePoint; + continue; + } + codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536; + } else if (leadSurrogate) { + if ((units -= 3) > -1) bytes.push(239, 191, 189); + } + leadSurrogate = null; + if (codePoint < 128) { + if ((units -= 1) < 0) break; + bytes.push(codePoint); + } else if (codePoint < 2048) { + if ((units -= 2) < 0) break; + bytes.push( + codePoint >> 6 | 192, + codePoint & 63 | 128 + ); + } else if (codePoint < 65536) { + if ((units -= 3) < 0) break; + bytes.push( + codePoint >> 12 | 224, + codePoint >> 6 & 63 | 128, + codePoint & 63 | 128 + ); + } else if (codePoint < 1114112) { + if ((units -= 4) < 0) break; + bytes.push( + codePoint >> 18 | 240, + codePoint >> 12 & 63 | 128, + codePoint >> 6 & 63 | 128, + codePoint & 63 | 128 + ); + } else { + throw new Error("Invalid code point"); + } + } + return bytes; + } + function asciiToBytes2(str) { + const byteArray = []; + for (let i = 0; i < str.length; ++i) { + byteArray.push(str.charCodeAt(i) & 255); + } + return byteArray; + } + function utf16leToBytes(str, units) { + let c, hi, lo; + const byteArray = []; + for (let i = 0; i < str.length; ++i) { + if ((units -= 2) < 0) break; + c = str.charCodeAt(i); + hi = c >> 8; + lo = c % 256; + byteArray.push(lo); + byteArray.push(hi); + } + return byteArray; + } + function base64ToBytes2(str) { + return base642.toByteArray(base64clean(str)); + } + function blitBuffer(src, dst, offset, length) { + let i; + for (i = 0; i < length; ++i) { + if (i + offset >= dst.length || i >= src.length) break; + dst[i + offset] = src[i]; + } + return i; + } + function isInstance(obj, type) { + return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name; + } + function numberIsNaN(obj) { + return obj !== obj; + } + var hexSliceLookupTable = (function() { + const alphabet2 = "0123456789abcdef"; + const table = new Array(256); + for (let i = 0; i < 16; ++i) { + const i16 = i * 16; + for (let j = 0; j < 16; ++j) { + table[i16 + j] = alphabet2[i] + alphabet2[j]; + } + } + return table; + })(); + function defineBigIntMethod(fn) { + return typeof BigInt === "undefined" ? BufferBigIntNotDefined : fn; + } + function BufferBigIntNotDefined() { + throw new Error("BigInt not supported"); + } + } + }); + + // src/background.js + init_process(); + + // node_modules/nostr-crypto-utils/dist/esm/index.js + init_process(); + + // node_modules/nostr-crypto-utils/dist/esm/types/index.js + init_process(); + + // node_modules/nostr-crypto-utils/dist/esm/types/base.js + init_process(); + var NostrEventKind; + (function(NostrEventKind3) { + NostrEventKind3[NostrEventKind3["SET_METADATA"] = 0] = "SET_METADATA"; + NostrEventKind3[NostrEventKind3["TEXT_NOTE"] = 1] = "TEXT_NOTE"; + NostrEventKind3[NostrEventKind3["RECOMMEND_SERVER"] = 2] = "RECOMMEND_SERVER"; + NostrEventKind3[NostrEventKind3["CONTACTS"] = 3] = "CONTACTS"; + NostrEventKind3[NostrEventKind3["ENCRYPTED_DIRECT_MESSAGE"] = 4] = "ENCRYPTED_DIRECT_MESSAGE"; + NostrEventKind3[NostrEventKind3["EVENT_DELETION"] = 5] = "EVENT_DELETION"; + NostrEventKind3[NostrEventKind3["REPOST"] = 6] = "REPOST"; + NostrEventKind3[NostrEventKind3["REACTION"] = 7] = "REACTION"; + NostrEventKind3[NostrEventKind3["CHANNEL_CREATION"] = 40] = "CHANNEL_CREATION"; + NostrEventKind3[NostrEventKind3["CHANNEL_METADATA"] = 41] = "CHANNEL_METADATA"; + NostrEventKind3[NostrEventKind3["CHANNEL_MESSAGE"] = 42] = "CHANNEL_MESSAGE"; + NostrEventKind3[NostrEventKind3["CHANNEL_HIDE_MESSAGE"] = 43] = "CHANNEL_HIDE_MESSAGE"; + NostrEventKind3[NostrEventKind3["CHANNEL_MUTE_USER"] = 44] = "CHANNEL_MUTE_USER"; + NostrEventKind3[NostrEventKind3["AUTH"] = 22242] = "AUTH"; + NostrEventKind3[NostrEventKind3["AUTH_RESPONSE"] = 22243] = "AUTH_RESPONSE"; + })(NostrEventKind || (NostrEventKind = {})); + var NostrMessageType; + (function(NostrMessageType2) { + NostrMessageType2["EVENT"] = "EVENT"; + NostrMessageType2["NOTICE"] = "NOTICE"; + NostrMessageType2["OK"] = "OK"; + NostrMessageType2["EOSE"] = "EOSE"; + NostrMessageType2["REQ"] = "REQ"; + NostrMessageType2["CLOSE"] = "CLOSE"; + NostrMessageType2["AUTH"] = "AUTH"; + })(NostrMessageType || (NostrMessageType = {})); + + // node_modules/nostr-crypto-utils/dist/esm/types/protocol.js + init_process(); + + // node_modules/nostr-crypto-utils/dist/esm/types/messages.js + init_process(); + + // node_modules/nostr-crypto-utils/dist/esm/types/guards.js + init_process(); + + // node_modules/nostr-crypto-utils/dist/esm/types/nip46.js + init_process(); + var Nip46Method; + (function(Nip46Method2) { + Nip46Method2["CONNECT"] = "connect"; + Nip46Method2["PING"] = "ping"; + Nip46Method2["GET_PUBLIC_KEY"] = "get_public_key"; + Nip46Method2["SIGN_EVENT"] = "sign_event"; + Nip46Method2["NIP04_ENCRYPT"] = "nip04_encrypt"; + Nip46Method2["NIP04_DECRYPT"] = "nip04_decrypt"; + Nip46Method2["NIP44_ENCRYPT"] = "nip44_encrypt"; + Nip46Method2["NIP44_DECRYPT"] = "nip44_decrypt"; + Nip46Method2["GET_RELAYS"] = "get_relays"; + })(Nip46Method || (Nip46Method = {})); + + // node_modules/nostr-crypto-utils/dist/esm/types/index.js + var NostrEventKind2; + (function(NostrEventKind3) { + NostrEventKind3[NostrEventKind3["SET_METADATA"] = 0] = "SET_METADATA"; + NostrEventKind3[NostrEventKind3["TEXT_NOTE"] = 1] = "TEXT_NOTE"; + NostrEventKind3[NostrEventKind3["RECOMMEND_SERVER"] = 2] = "RECOMMEND_SERVER"; + NostrEventKind3[NostrEventKind3["CONTACT_LIST"] = 3] = "CONTACT_LIST"; + NostrEventKind3[NostrEventKind3["ENCRYPTED_DIRECT_MESSAGE"] = 4] = "ENCRYPTED_DIRECT_MESSAGE"; + NostrEventKind3[NostrEventKind3["DELETE"] = 5] = "DELETE"; + NostrEventKind3[NostrEventKind3["REPOST"] = 6] = "REPOST"; + NostrEventKind3[NostrEventKind3["REACTION"] = 7] = "REACTION"; + NostrEventKind3[NostrEventKind3["BADGE_AWARD"] = 8] = "BADGE_AWARD"; + NostrEventKind3[NostrEventKind3["CHANNEL_CREATE"] = 40] = "CHANNEL_CREATE"; + NostrEventKind3[NostrEventKind3["CHANNEL_METADATA"] = 41] = "CHANNEL_METADATA"; + NostrEventKind3[NostrEventKind3["CHANNEL_MESSAGE"] = 42] = "CHANNEL_MESSAGE"; + NostrEventKind3[NostrEventKind3["CHANNEL_HIDE_MESSAGE"] = 43] = "CHANNEL_HIDE_MESSAGE"; + NostrEventKind3[NostrEventKind3["CHANNEL_MUTE_USER"] = 44] = "CHANNEL_MUTE_USER"; + NostrEventKind3[NostrEventKind3["CHANNEL_RESERVE"] = 45] = "CHANNEL_RESERVE"; + NostrEventKind3[NostrEventKind3["REPORTING"] = 1984] = "REPORTING"; + NostrEventKind3[NostrEventKind3["ZAP_REQUEST"] = 9734] = "ZAP_REQUEST"; + NostrEventKind3[NostrEventKind3["ZAP"] = 9735] = "ZAP"; + NostrEventKind3[NostrEventKind3["MUTE_LIST"] = 1e4] = "MUTE_LIST"; + NostrEventKind3[NostrEventKind3["PIN_LIST"] = 10001] = "PIN_LIST"; + NostrEventKind3[NostrEventKind3["RELAY_LIST_METADATA"] = 10002] = "RELAY_LIST_METADATA"; + NostrEventKind3[NostrEventKind3["CLIENT_AUTH"] = 22242] = "CLIENT_AUTH"; + NostrEventKind3[NostrEventKind3["AUTH_RESPONSE"] = 22243] = "AUTH_RESPONSE"; + NostrEventKind3[NostrEventKind3["NOSTR_CONNECT"] = 24133] = "NOSTR_CONNECT"; + NostrEventKind3[NostrEventKind3["CATEGORIZED_PEOPLE"] = 3e4] = "CATEGORIZED_PEOPLE"; + NostrEventKind3[NostrEventKind3["CATEGORIZED_BOOKMARKS"] = 30001] = "CATEGORIZED_BOOKMARKS"; + NostrEventKind3[NostrEventKind3["PROFILE_BADGES"] = 30008] = "PROFILE_BADGES"; + NostrEventKind3[NostrEventKind3["BADGE_DEFINITION"] = 30009] = "BADGE_DEFINITION"; + NostrEventKind3[NostrEventKind3["LONG_FORM"] = 30023] = "LONG_FORM"; + NostrEventKind3[NostrEventKind3["APPLICATION_SPECIFIC"] = 30078] = "APPLICATION_SPECIFIC"; + })(NostrEventKind2 || (NostrEventKind2 = {})); + + // node_modules/nostr-crypto-utils/dist/esm/crypto.js + init_process(); + + // node_modules/@noble/curves/secp256k1.js + init_process(); + + // node_modules/@noble/hashes/sha2.js + init_process(); + + // node_modules/@noble/hashes/_md.js + init_process(); + + // node_modules/@noble/hashes/utils.js + init_process(); + function isBytes(a) { + return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array"; + } + function anumber(n, title = "") { + if (!Number.isSafeInteger(n) || n < 0) { + const prefix = title && `"${title}" `; + throw new Error(`${prefix}expected integer >= 0, got ${n}`); + } + } + function abytes(value, length, title = "") { + const bytes = isBytes(value); + const len = value?.length; + const needsLen = length !== void 0; + if (!bytes || needsLen && len !== length) { + const prefix = title && `"${title}" `; + const ofLen = needsLen ? ` of length ${length}` : ""; + const got = bytes ? `length=${len}` : `type=${typeof value}`; + throw new Error(prefix + "expected Uint8Array" + ofLen + ", got " + got); + } + return value; + } + function ahash(h) { + if (typeof h !== "function" || typeof h.create !== "function") + throw new Error("Hash must wrapped by utils.createHasher"); + anumber(h.outputLen); + anumber(h.blockLen); + } + function aexists(instance, checkFinished = true) { + if (instance.destroyed) + throw new Error("Hash instance has been destroyed"); + if (checkFinished && instance.finished) + throw new Error("Hash#digest() has already been called"); + } + function aoutput(out, instance) { + abytes(out, void 0, "digestInto() output"); + const min = instance.outputLen; + if (out.length < min) { + throw new Error('"digestInto() output" expected to be of length >=' + min); + } + } + function u32(arr) { + return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4)); + } + function clean(...arrays) { + for (let i = 0; i < arrays.length; i++) { + arrays[i].fill(0); + } + } + function createView(arr) { + return new DataView(arr.buffer, arr.byteOffset, arr.byteLength); + } + function rotr(word, shift) { + return word << 32 - shift | word >>> shift; + } + function rotl(word, shift) { + return word << shift | word >>> 32 - shift >>> 0; + } + var isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)(); + function byteSwap(word) { + return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255; + } + function byteSwap32(arr) { + for (let i = 0; i < arr.length; i++) { + arr[i] = byteSwap(arr[i]); + } + return arr; + } + var swap32IfBE = isLE ? (u) => u : byteSwap32; + var hasHexBuiltin = /* @__PURE__ */ (() => ( + // @ts-ignore + typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function" + ))(); + var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0")); + function bytesToHex(bytes) { + abytes(bytes); + if (hasHexBuiltin) + return bytes.toHex(); + let hex = ""; + for (let i = 0; i < bytes.length; i++) { + hex += hexes[bytes[i]]; + } + return hex; + } + var asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 }; + function asciiToBase16(ch) { + if (ch >= asciis._0 && ch <= asciis._9) + return ch - asciis._0; + if (ch >= asciis.A && ch <= asciis.F) + return ch - (asciis.A - 10); + if (ch >= asciis.a && ch <= asciis.f) + return ch - (asciis.a - 10); + return; + } + function hexToBytes(hex) { + if (typeof hex !== "string") + throw new Error("hex string expected, got " + typeof hex); + if (hasHexBuiltin) + return Uint8Array.fromHex(hex); + const hl = hex.length; + const al = hl / 2; + if (hl % 2) + throw new Error("hex string expected, got unpadded hex of length " + hl); + const array = new Uint8Array(al); + for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) { + const n1 = asciiToBase16(hex.charCodeAt(hi)); + const n2 = asciiToBase16(hex.charCodeAt(hi + 1)); + if (n1 === void 0 || n2 === void 0) { + const char = hex[hi] + hex[hi + 1]; + throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi); + } + array[ai] = n1 * 16 + n2; + } + return array; + } + function utf8ToBytes(str) { + if (typeof str !== "string") + throw new Error("string expected"); + return new Uint8Array(new TextEncoder().encode(str)); + } + function kdfInputToBytes(data, errorTitle = "") { + if (typeof data === "string") + return utf8ToBytes(data); + return abytes(data, void 0, errorTitle); + } + function concatBytes(...arrays) { + let sum = 0; + for (let i = 0; i < arrays.length; i++) { + const a = arrays[i]; + abytes(a); + sum += a.length; + } + const res = new Uint8Array(sum); + for (let i = 0, pad2 = 0; i < arrays.length; i++) { + const a = arrays[i]; + res.set(a, pad2); + pad2 += a.length; + } + return res; + } + function checkOpts(defaults, opts) { + if (opts !== void 0 && {}.toString.call(opts) !== "[object Object]") + throw new Error("options must be object or undefined"); + const merged = Object.assign(defaults, opts); + return merged; + } + function createHasher(hashCons, info = {}) { + const hashC = (msg, opts) => hashCons(opts).update(msg).digest(); + const tmp = hashCons(void 0); + hashC.outputLen = tmp.outputLen; + hashC.blockLen = tmp.blockLen; + hashC.create = (opts) => hashCons(opts); + Object.assign(hashC, info); + return Object.freeze(hashC); + } + function randomBytes(bytesLength = 32) { + const cr = typeof globalThis === "object" ? globalThis.crypto : null; + if (typeof cr?.getRandomValues !== "function") + throw new Error("crypto.getRandomValues must be defined"); + return cr.getRandomValues(new Uint8Array(bytesLength)); + } + var oidNist = (suffix) => ({ + oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, suffix]) + }); + + // node_modules/@noble/hashes/_md.js + function Chi(a, b, c) { + return a & b ^ ~a & c; + } + function Maj(a, b, c) { + return a & b ^ a & c ^ b & c; + } + var HashMD = class { + blockLen; + outputLen; + padOffset; + isLE; + // For partial updates less than block size + buffer; + view; + finished = false; + length = 0; + pos = 0; + destroyed = false; + constructor(blockLen, outputLen, padOffset, isLE3) { + this.blockLen = blockLen; + this.outputLen = outputLen; + this.padOffset = padOffset; + this.isLE = isLE3; + this.buffer = new Uint8Array(blockLen); + this.view = createView(this.buffer); + } + update(data) { + aexists(this); + abytes(data); + const { view, buffer, blockLen } = this; + const len = data.length; + for (let pos = 0; pos < len; ) { + const take = Math.min(blockLen - this.pos, len - pos); + if (take === blockLen) { + const dataView = createView(data); + for (; blockLen <= len - pos; pos += blockLen) + this.process(dataView, pos); + continue; + } + buffer.set(data.subarray(pos, pos + take), this.pos); + this.pos += take; + pos += take; + if (this.pos === blockLen) { + this.process(view, 0); + this.pos = 0; + } + } + this.length += data.length; + this.roundClean(); + return this; + } + digestInto(out) { + aexists(this); + aoutput(out, this); + this.finished = true; + const { buffer, view, blockLen, isLE: isLE3 } = this; + let { pos } = this; + buffer[pos++] = 128; + clean(this.buffer.subarray(pos)); + if (this.padOffset > blockLen - pos) { + this.process(view, 0); + pos = 0; + } + for (let i = pos; i < blockLen; i++) + buffer[i] = 0; + view.setBigUint64(blockLen - 8, BigInt(this.length * 8), isLE3); + this.process(view, 0); + const oview = createView(out); + const len = this.outputLen; + if (len % 4) + throw new Error("_sha2: outputLen must be aligned to 32bit"); + const outLen = len / 4; + const state = this.get(); + if (outLen > state.length) + throw new Error("_sha2: outputLen bigger than state"); + for (let i = 0; i < outLen; i++) + oview.setUint32(4 * i, state[i], isLE3); + } + digest() { + const { buffer, outputLen } = this; + this.digestInto(buffer); + const res = buffer.slice(0, outputLen); + this.destroy(); + return res; + } + _cloneInto(to) { + to ||= new this.constructor(); + to.set(...this.get()); + const { blockLen, buffer, length, finished, destroyed, pos } = this; + to.destroyed = destroyed; + to.finished = finished; + to.length = length; + to.pos = pos; + if (length % blockLen) + to.buffer.set(buffer); + return to; + } + clone() { + return this._cloneInto(); + } + }; + var SHA256_IV = /* @__PURE__ */ Uint32Array.from([ + 1779033703, + 3144134277, + 1013904242, + 2773480762, + 1359893119, + 2600822924, + 528734635, + 1541459225 + ]); + + // node_modules/@noble/hashes/sha2.js + var SHA256_K = /* @__PURE__ */ Uint32Array.from([ + 1116352408, + 1899447441, + 3049323471, + 3921009573, + 961987163, + 1508970993, + 2453635748, + 2870763221, + 3624381080, + 310598401, + 607225278, + 1426881987, + 1925078388, + 2162078206, + 2614888103, + 3248222580, + 3835390401, + 4022224774, + 264347078, + 604807628, + 770255983, + 1249150122, + 1555081692, + 1996064986, + 2554220882, + 2821834349, + 2952996808, + 3210313671, + 3336571891, + 3584528711, + 113926993, + 338241895, + 666307205, + 773529912, + 1294757372, + 1396182291, + 1695183700, + 1986661051, + 2177026350, + 2456956037, + 2730485921, + 2820302411, + 3259730800, + 3345764771, + 3516065817, + 3600352804, + 4094571909, + 275423344, + 430227734, + 506948616, + 659060556, + 883997877, + 958139571, + 1322822218, + 1537002063, + 1747873779, + 1955562222, + 2024104815, + 2227730452, + 2361852424, + 2428436474, + 2756734187, + 3204031479, + 3329325298 + ]); + var SHA256_W = /* @__PURE__ */ new Uint32Array(64); + var SHA2_32B = class extends HashMD { + constructor(outputLen) { + super(64, outputLen, 8, false); + } + get() { + const { A, B, C, D, E, F, G, H } = this; + return [A, B, C, D, E, F, G, H]; + } + // prettier-ignore + set(A, B, C, D, E, F, G, H) { + this.A = A | 0; + this.B = B | 0; + this.C = C | 0; + this.D = D | 0; + this.E = E | 0; + this.F = F | 0; + this.G = G | 0; + this.H = H | 0; + } + process(view, offset) { + for (let i = 0; i < 16; i++, offset += 4) + SHA256_W[i] = view.getUint32(offset, false); + for (let i = 16; i < 64; i++) { + const W15 = SHA256_W[i - 15]; + const W2 = SHA256_W[i - 2]; + const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3; + const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10; + SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0; + } + let { A, B, C, D, E, F, G, H } = this; + for (let i = 0; i < 64; i++) { + const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25); + const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0; + const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22); + const T2 = sigma0 + Maj(A, B, C) | 0; + H = G; + G = F; + F = E; + E = D + T1 | 0; + D = C; + C = B; + B = A; + A = T1 + T2 | 0; + } + A = A + this.A | 0; + B = B + this.B | 0; + C = C + this.C | 0; + D = D + this.D | 0; + E = E + this.E | 0; + F = F + this.F | 0; + G = G + this.G | 0; + H = H + this.H | 0; + this.set(A, B, C, D, E, F, G, H); + } + roundClean() { + clean(SHA256_W); + } + destroy() { + this.set(0, 0, 0, 0, 0, 0, 0, 0); + clean(this.buffer); + } + }; + var _SHA256 = class extends SHA2_32B { + // We cannot use array here since array allows indexing by variable + // which means optimizer/compiler cannot use registers. + A = SHA256_IV[0] | 0; + B = SHA256_IV[1] | 0; + C = SHA256_IV[2] | 0; + D = SHA256_IV[3] | 0; + E = SHA256_IV[4] | 0; + F = SHA256_IV[5] | 0; + G = SHA256_IV[6] | 0; + H = SHA256_IV[7] | 0; + constructor() { + super(32); + } + }; + var sha256 = /* @__PURE__ */ createHasher( + () => new _SHA256(), + /* @__PURE__ */ oidNist(1) + ); + + // node_modules/@noble/curves/abstract/curve.js + init_process(); + + // node_modules/@noble/curves/utils.js + init_process(); + var _0n = /* @__PURE__ */ BigInt(0); + var _1n = /* @__PURE__ */ BigInt(1); + function abool(value, title = "") { + if (typeof value !== "boolean") { + const prefix = title && `"${title}" `; + throw new Error(prefix + "expected boolean, got type=" + typeof value); + } + return value; + } + function abignumber(n) { + if (typeof n === "bigint") { + if (!isPosBig(n)) + throw new Error("positive bigint expected, got " + n); + } else + anumber(n); + return n; + } + function numberToHexUnpadded(num2) { + const hex = abignumber(num2).toString(16); + return hex.length & 1 ? "0" + hex : hex; + } + function hexToNumber(hex) { + if (typeof hex !== "string") + throw new Error("hex string expected, got " + typeof hex); + return hex === "" ? _0n : BigInt("0x" + hex); + } + function bytesToNumberBE(bytes) { + return hexToNumber(bytesToHex(bytes)); + } + function bytesToNumberLE(bytes) { + return hexToNumber(bytesToHex(copyBytes(abytes(bytes)).reverse())); + } + function numberToBytesBE(n, len) { + anumber(len); + n = abignumber(n); + const res = hexToBytes(n.toString(16).padStart(len * 2, "0")); + if (res.length !== len) + throw new Error("number too large"); + return res; + } + function numberToBytesLE(n, len) { + return numberToBytesBE(n, len).reverse(); + } + function copyBytes(bytes) { + return Uint8Array.from(bytes); + } + function asciiToBytes(ascii) { + return Uint8Array.from(ascii, (c, i) => { + const charCode = c.charCodeAt(0); + if (c.length !== 1 || charCode > 127) { + throw new Error(`string contains non-ASCII character "${ascii[i]}" with code ${charCode} at position ${i}`); + } + return charCode; + }); + } + var isPosBig = (n) => typeof n === "bigint" && _0n <= n; + function inRange(n, min, max) { + return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max; + } + function aInRange(title, n, min, max) { + if (!inRange(n, min, max)) + throw new Error("expected valid " + title + ": " + min + " <= n < " + max + ", got " + n); + } + function bitLen(n) { + let len; + for (len = 0; n > _0n; n >>= _1n, len += 1) + ; + return len; + } + var bitMask = (n) => (_1n << BigInt(n)) - _1n; + function createHmacDrbg(hashLen, qByteLen, hmacFn) { + anumber(hashLen, "hashLen"); + anumber(qByteLen, "qByteLen"); + if (typeof hmacFn !== "function") + throw new Error("hmacFn must be a function"); + const u8n = (len) => new Uint8Array(len); + const NULL = Uint8Array.of(); + const byte0 = Uint8Array.of(0); + const byte1 = Uint8Array.of(1); + const _maxDrbgIters = 1e3; + let v = u8n(hashLen); + let k = u8n(hashLen); + let i = 0; + const reset = () => { + v.fill(1); + k.fill(0); + i = 0; + }; + const h = (...msgs) => hmacFn(k, concatBytes(v, ...msgs)); + const reseed = (seed = NULL) => { + k = h(byte0, seed); + v = h(); + if (seed.length === 0) + return; + k = h(byte1, seed); + v = h(); + }; + const gen = () => { + if (i++ >= _maxDrbgIters) + throw new Error("drbg: tried max amount of iterations"); + let len = 0; + const out = []; + while (len < qByteLen) { + v = h(); + const sl = v.slice(); + out.push(sl); + len += v.length; + } + return concatBytes(...out); + }; + const genUntil = (seed, pred) => { + reset(); + reseed(seed); + let res = void 0; + while (!(res = pred(gen()))) + reseed(); + reset(); + return res; + }; + return genUntil; + } + function validateObject(object, fields = {}, optFields = {}) { + if (!object || typeof object !== "object") + throw new Error("expected valid options object"); + function checkField(fieldName, expectedType, isOpt) { + const val = object[fieldName]; + if (isOpt && val === void 0) + return; + const current = typeof val; + if (current !== expectedType || val === null) + throw new Error(`param "${fieldName}" is invalid: expected ${expectedType}, got ${current}`); + } + const iter = (f, isOpt) => Object.entries(f).forEach(([k, v]) => checkField(k, v, isOpt)); + iter(fields, false); + iter(optFields, true); + } + function memoized(fn) { + const map = /* @__PURE__ */ new WeakMap(); + return (arg, ...args) => { + const val = map.get(arg); + if (val !== void 0) + return val; + const computed = fn(arg, ...args); + map.set(arg, computed); + return computed; + }; + } + + // node_modules/@noble/curves/abstract/modular.js + init_process(); + var _0n2 = /* @__PURE__ */ BigInt(0); + var _1n2 = /* @__PURE__ */ BigInt(1); + var _2n = /* @__PURE__ */ BigInt(2); + var _3n = /* @__PURE__ */ BigInt(3); + var _4n = /* @__PURE__ */ BigInt(4); + var _5n = /* @__PURE__ */ BigInt(5); + var _7n = /* @__PURE__ */ BigInt(7); + var _8n = /* @__PURE__ */ BigInt(8); + var _9n = /* @__PURE__ */ BigInt(9); + var _16n = /* @__PURE__ */ BigInt(16); + function mod(a, b) { + const result = a % b; + return result >= _0n2 ? result : b + result; + } + function pow2(x, power, modulo) { + let res = x; + while (power-- > _0n2) { + res *= res; + res %= modulo; + } + return res; + } + function invert(number, modulo) { + if (number === _0n2) + throw new Error("invert: expected non-zero number"); + if (modulo <= _0n2) + throw new Error("invert: expected positive modulus, got " + modulo); + let a = mod(number, modulo); + let b = modulo; + let x = _0n2, y = _1n2, u = _1n2, v = _0n2; + while (a !== _0n2) { + const q = b / a; + const r = b % a; + const m = x - u * q; + const n = y - v * q; + b = a, a = r, x = u, y = v, u = m, v = n; + } + const gcd2 = b; + if (gcd2 !== _1n2) + throw new Error("invert: does not exist"); + return mod(x, modulo); + } + function assertIsSquare(Fp, root, n) { + if (!Fp.eql(Fp.sqr(root), n)) + throw new Error("Cannot find square root"); + } + function sqrt3mod4(Fp, n) { + const p1div4 = (Fp.ORDER + _1n2) / _4n; + const root = Fp.pow(n, p1div4); + assertIsSquare(Fp, root, n); + return root; + } + function sqrt5mod8(Fp, n) { + const p5div8 = (Fp.ORDER - _5n) / _8n; + const n2 = Fp.mul(n, _2n); + const v = Fp.pow(n2, p5div8); + const nv = Fp.mul(n, v); + const i = Fp.mul(Fp.mul(nv, _2n), v); + const root = Fp.mul(nv, Fp.sub(i, Fp.ONE)); + assertIsSquare(Fp, root, n); + return root; + } + function sqrt9mod16(P) { + const Fp_ = Field(P); + const tn = tonelliShanks(P); + const c1 = tn(Fp_, Fp_.neg(Fp_.ONE)); + const c2 = tn(Fp_, c1); + const c3 = tn(Fp_, Fp_.neg(c1)); + const c4 = (P + _7n) / _16n; + return (Fp, n) => { + let tv1 = Fp.pow(n, c4); + let tv2 = Fp.mul(tv1, c1); + const tv3 = Fp.mul(tv1, c2); + const tv4 = Fp.mul(tv1, c3); + const e1 = Fp.eql(Fp.sqr(tv2), n); + const e2 = Fp.eql(Fp.sqr(tv3), n); + tv1 = Fp.cmov(tv1, tv2, e1); + tv2 = Fp.cmov(tv4, tv3, e2); + const e3 = Fp.eql(Fp.sqr(tv2), n); + const root = Fp.cmov(tv1, tv2, e3); + assertIsSquare(Fp, root, n); + return root; + }; + } + function tonelliShanks(P) { + if (P < _3n) + throw new Error("sqrt is not defined for small field"); + let Q = P - _1n2; + let S = 0; + while (Q % _2n === _0n2) { + Q /= _2n; + S++; + } + let Z = _2n; + const _Fp = Field(P); + while (FpLegendre(_Fp, Z) === 1) { + if (Z++ > 1e3) + throw new Error("Cannot find square root: probably non-prime P"); + } + if (S === 1) + return sqrt3mod4; + let cc = _Fp.pow(Z, Q); + const Q1div2 = (Q + _1n2) / _2n; + return function tonelliSlow(Fp, n) { + if (Fp.is0(n)) + return n; + if (FpLegendre(Fp, n) !== 1) + throw new Error("Cannot find square root"); + let M = S; + let c = Fp.mul(Fp.ONE, cc); + let t = Fp.pow(n, Q); + let R = Fp.pow(n, Q1div2); + while (!Fp.eql(t, Fp.ONE)) { + if (Fp.is0(t)) + return Fp.ZERO; + let i = 1; + let t_tmp = Fp.sqr(t); + while (!Fp.eql(t_tmp, Fp.ONE)) { + i++; + t_tmp = Fp.sqr(t_tmp); + if (i === M) + throw new Error("Cannot find square root"); + } + const exponent = _1n2 << BigInt(M - i - 1); + const b = Fp.pow(c, exponent); + M = i; + c = Fp.sqr(b); + t = Fp.mul(t, c); + R = Fp.mul(R, b); + } + return R; + }; + } + function FpSqrt(P) { + if (P % _4n === _3n) + return sqrt3mod4; + if (P % _8n === _5n) + return sqrt5mod8; + if (P % _16n === _9n) + return sqrt9mod16(P); + return tonelliShanks(P); + } + var FIELD_FIELDS = [ + "create", + "isValid", + "is0", + "neg", + "inv", + "sqrt", + "sqr", + "eql", + "add", + "sub", + "mul", + "pow", + "div", + "addN", + "subN", + "mulN", + "sqrN" + ]; + function validateField(field) { + const initial = { + ORDER: "bigint", + BYTES: "number", + BITS: "number" + }; + const opts = FIELD_FIELDS.reduce((map, val) => { + map[val] = "function"; + return map; + }, initial); + validateObject(field, opts); + return field; + } + function FpPow(Fp, num2, power) { + if (power < _0n2) + throw new Error("invalid exponent, negatives unsupported"); + if (power === _0n2) + return Fp.ONE; + if (power === _1n2) + return num2; + let p = Fp.ONE; + let d = num2; + while (power > _0n2) { + if (power & _1n2) + p = Fp.mul(p, d); + d = Fp.sqr(d); + power >>= _1n2; + } + return p; + } + function FpInvertBatch(Fp, nums, passZero = false) { + const inverted = new Array(nums.length).fill(passZero ? Fp.ZERO : void 0); + const multipliedAcc = nums.reduce((acc, num2, i) => { + if (Fp.is0(num2)) + return acc; + inverted[i] = acc; + return Fp.mul(acc, num2); + }, Fp.ONE); + const invertedAcc = Fp.inv(multipliedAcc); + nums.reduceRight((acc, num2, i) => { + if (Fp.is0(num2)) + return acc; + inverted[i] = Fp.mul(acc, inverted[i]); + return Fp.mul(acc, num2); + }, invertedAcc); + return inverted; + } + function FpLegendre(Fp, n) { + const p1mod2 = (Fp.ORDER - _1n2) / _2n; + const powered = Fp.pow(n, p1mod2); + const yes = Fp.eql(powered, Fp.ONE); + const zero = Fp.eql(powered, Fp.ZERO); + const no = Fp.eql(powered, Fp.neg(Fp.ONE)); + if (!yes && !zero && !no) + throw new Error("invalid Legendre symbol result"); + return yes ? 1 : zero ? 0 : -1; + } + function nLength(n, nBitLength) { + if (nBitLength !== void 0) + anumber(nBitLength); + const _nBitLength = nBitLength !== void 0 ? nBitLength : n.toString(2).length; + const nByteLength = Math.ceil(_nBitLength / 8); + return { nBitLength: _nBitLength, nByteLength }; + } + var _Field = class { + ORDER; + BITS; + BYTES; + isLE; + ZERO = _0n2; + ONE = _1n2; + _lengths; + _sqrt; + // cached sqrt + _mod; + constructor(ORDER, opts = {}) { + if (ORDER <= _0n2) + throw new Error("invalid field: expected ORDER > 0, got " + ORDER); + let _nbitLength = void 0; + this.isLE = false; + if (opts != null && typeof opts === "object") { + if (typeof opts.BITS === "number") + _nbitLength = opts.BITS; + if (typeof opts.sqrt === "function") + this.sqrt = opts.sqrt; + if (typeof opts.isLE === "boolean") + this.isLE = opts.isLE; + if (opts.allowedLengths) + this._lengths = opts.allowedLengths?.slice(); + if (typeof opts.modFromBytes === "boolean") + this._mod = opts.modFromBytes; + } + const { nBitLength, nByteLength } = nLength(ORDER, _nbitLength); + if (nByteLength > 2048) + throw new Error("invalid field: expected ORDER of <= 2048 bytes"); + this.ORDER = ORDER; + this.BITS = nBitLength; + this.BYTES = nByteLength; + this._sqrt = void 0; + Object.preventExtensions(this); + } + create(num2) { + return mod(num2, this.ORDER); + } + isValid(num2) { + if (typeof num2 !== "bigint") + throw new Error("invalid field element: expected bigint, got " + typeof num2); + return _0n2 <= num2 && num2 < this.ORDER; + } + is0(num2) { + return num2 === _0n2; + } + // is valid and invertible + isValidNot0(num2) { + return !this.is0(num2) && this.isValid(num2); + } + isOdd(num2) { + return (num2 & _1n2) === _1n2; + } + neg(num2) { + return mod(-num2, this.ORDER); + } + eql(lhs, rhs) { + return lhs === rhs; + } + sqr(num2) { + return mod(num2 * num2, this.ORDER); + } + add(lhs, rhs) { + return mod(lhs + rhs, this.ORDER); + } + sub(lhs, rhs) { + return mod(lhs - rhs, this.ORDER); + } + mul(lhs, rhs) { + return mod(lhs * rhs, this.ORDER); + } + pow(num2, power) { + return FpPow(this, num2, power); + } + div(lhs, rhs) { + return mod(lhs * invert(rhs, this.ORDER), this.ORDER); + } + // Same as above, but doesn't normalize + sqrN(num2) { + return num2 * num2; + } + addN(lhs, rhs) { + return lhs + rhs; + } + subN(lhs, rhs) { + return lhs - rhs; + } + mulN(lhs, rhs) { + return lhs * rhs; + } + inv(num2) { + return invert(num2, this.ORDER); + } + sqrt(num2) { + if (!this._sqrt) + this._sqrt = FpSqrt(this.ORDER); + return this._sqrt(this, num2); + } + toBytes(num2) { + return this.isLE ? numberToBytesLE(num2, this.BYTES) : numberToBytesBE(num2, this.BYTES); + } + fromBytes(bytes, skipValidation = false) { + abytes(bytes); + const { _lengths: allowedLengths, BYTES, isLE: isLE3, ORDER, _mod: modFromBytes } = this; + if (allowedLengths) { + if (!allowedLengths.includes(bytes.length) || bytes.length > BYTES) { + throw new Error("Field.fromBytes: expected " + allowedLengths + " bytes, got " + bytes.length); + } + const padded = new Uint8Array(BYTES); + padded.set(bytes, isLE3 ? 0 : padded.length - bytes.length); + bytes = padded; + } + if (bytes.length !== BYTES) + throw new Error("Field.fromBytes: expected " + BYTES + " bytes, got " + bytes.length); + let scalar = isLE3 ? bytesToNumberLE(bytes) : bytesToNumberBE(bytes); + if (modFromBytes) + scalar = mod(scalar, ORDER); + if (!skipValidation) { + if (!this.isValid(scalar)) + throw new Error("invalid field element: outside of range 0..ORDER"); + } + return scalar; + } + // TODO: we don't need it here, move out to separate fn + invertBatch(lst) { + return FpInvertBatch(this, lst); + } + // We can't move this out because Fp6, Fp12 implement it + // and it's unclear what to return in there. + cmov(a, b, condition) { + return condition ? b : a; + } + }; + function Field(ORDER, opts = {}) { + return new _Field(ORDER, opts); + } + function getFieldBytesLength(fieldOrder) { + if (typeof fieldOrder !== "bigint") + throw new Error("field order must be bigint"); + const bitLength = fieldOrder.toString(2).length; + return Math.ceil(bitLength / 8); + } + function getMinHashLength(fieldOrder) { + const length = getFieldBytesLength(fieldOrder); + return length + Math.ceil(length / 2); + } + function mapHashToField(key, fieldOrder, isLE3 = false) { + abytes(key); + const len = key.length; + const fieldLen = getFieldBytesLength(fieldOrder); + const minLen = getMinHashLength(fieldOrder); + if (len < 16 || len < minLen || len > 1024) + throw new Error("expected " + minLen + "-1024 bytes of input, got " + len); + const num2 = isLE3 ? bytesToNumberLE(key) : bytesToNumberBE(key); + const reduced = mod(num2, fieldOrder - _1n2) + _1n2; + return isLE3 ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen); + } + + // node_modules/@noble/curves/abstract/curve.js + var _0n3 = /* @__PURE__ */ BigInt(0); + var _1n3 = /* @__PURE__ */ BigInt(1); + function negateCt(condition, item) { + const neg = item.negate(); + return condition ? neg : item; + } + function normalizeZ(c, points) { + const invertedZs = FpInvertBatch(c.Fp, points.map((p) => p.Z)); + return points.map((p, i) => c.fromAffine(p.toAffine(invertedZs[i]))); + } + function validateW(W, bits) { + if (!Number.isSafeInteger(W) || W <= 0 || W > bits) + throw new Error("invalid window size, expected [1.." + bits + "], got W=" + W); + } + function calcWOpts(W, scalarBits) { + validateW(W, scalarBits); + const windows = Math.ceil(scalarBits / W) + 1; + const windowSize = 2 ** (W - 1); + const maxNumber = 2 ** W; + const mask = bitMask(W); + const shiftBy = BigInt(W); + return { windows, windowSize, mask, maxNumber, shiftBy }; + } + function calcOffsets(n, window2, wOpts) { + const { windowSize, mask, maxNumber, shiftBy } = wOpts; + let wbits = Number(n & mask); + let nextN = n >> shiftBy; + if (wbits > windowSize) { + wbits -= maxNumber; + nextN += _1n3; + } + const offsetStart = window2 * windowSize; + const offset = offsetStart + Math.abs(wbits) - 1; + const isZero = wbits === 0; + const isNeg = wbits < 0; + const isNegF = window2 % 2 !== 0; + const offsetF = offsetStart; + return { nextN, offset, isZero, isNeg, isNegF, offsetF }; + } + var pointPrecomputes = /* @__PURE__ */ new WeakMap(); + var pointWindowSizes = /* @__PURE__ */ new WeakMap(); + function getW(P) { + return pointWindowSizes.get(P) || 1; + } + function assert0(n) { + if (n !== _0n3) + throw new Error("invalid wNAF"); + } + var wNAF = class { + BASE; + ZERO; + Fn; + bits; + // Parametrized with a given Point class (not individual point) + constructor(Point, bits) { + this.BASE = Point.BASE; + this.ZERO = Point.ZERO; + this.Fn = Point.Fn; + this.bits = bits; + } + // non-const time multiplication ladder + _unsafeLadder(elm, n, p = this.ZERO) { + let d = elm; + while (n > _0n3) { + if (n & _1n3) + p = p.add(d); + d = d.double(); + n >>= _1n3; + } + return p; + } + /** + * Creates a wNAF precomputation window. Used for caching. + * Default window size is set by `utils.precompute()` and is equal to 8. + * Number of precomputed points depends on the curve size: + * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where: + * - 𝑊 is the window size + * - 𝑛 is the bitlength of the curve order. + * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224. + * @param point Point instance + * @param W window size + * @returns precomputed point tables flattened to a single array + */ + precomputeWindow(point, W) { + const { windows, windowSize } = calcWOpts(W, this.bits); + const points = []; + let p = point; + let base = p; + for (let window2 = 0; window2 < windows; window2++) { + base = p; + points.push(base); + for (let i = 1; i < windowSize; i++) { + base = base.add(p); + points.push(base); + } + p = base.double(); + } + return points; + } + /** + * Implements ec multiplication using precomputed tables and w-ary non-adjacent form. + * More compact implementation: + * https://github.com/paulmillr/noble-secp256k1/blob/47cb1669b6e506ad66b35fe7d76132ae97465da2/index.ts#L502-L541 + * @returns real and fake (for const-time) points + */ + wNAF(W, precomputes, n) { + if (!this.Fn.isValid(n)) + throw new Error("invalid scalar"); + let p = this.ZERO; + let f = this.BASE; + const wo = calcWOpts(W, this.bits); + for (let window2 = 0; window2 < wo.windows; window2++) { + const { nextN, offset, isZero, isNeg, isNegF, offsetF } = calcOffsets(n, window2, wo); + n = nextN; + if (isZero) { + f = f.add(negateCt(isNegF, precomputes[offsetF])); + } else { + p = p.add(negateCt(isNeg, precomputes[offset])); + } + } + assert0(n); + return { p, f }; + } + /** + * Implements ec unsafe (non const-time) multiplication using precomputed tables and w-ary non-adjacent form. + * @param acc accumulator point to add result of multiplication + * @returns point + */ + wNAFUnsafe(W, precomputes, n, acc = this.ZERO) { + const wo = calcWOpts(W, this.bits); + for (let window2 = 0; window2 < wo.windows; window2++) { + if (n === _0n3) + break; + const { nextN, offset, isZero, isNeg } = calcOffsets(n, window2, wo); + n = nextN; + if (isZero) { + continue; + } else { + const item = precomputes[offset]; + acc = acc.add(isNeg ? item.negate() : item); + } + } + assert0(n); + return acc; + } + getPrecomputes(W, point, transform) { + let comp = pointPrecomputes.get(point); + if (!comp) { + comp = this.precomputeWindow(point, W); + if (W !== 1) { + if (typeof transform === "function") + comp = transform(comp); + pointPrecomputes.set(point, comp); + } + } + return comp; + } + cached(point, scalar, transform) { + const W = getW(point); + return this.wNAF(W, this.getPrecomputes(W, point, transform), scalar); + } + unsafe(point, scalar, transform, prev) { + const W = getW(point); + if (W === 1) + return this._unsafeLadder(point, scalar, prev); + return this.wNAFUnsafe(W, this.getPrecomputes(W, point, transform), scalar, prev); + } + // We calculate precomputes for elliptic curve point multiplication + // using windowed method. This specifies window size and + // stores precomputed values. Usually only base point would be precomputed. + createCache(P, W) { + validateW(W, this.bits); + pointWindowSizes.set(P, W); + pointPrecomputes.delete(P); + } + hasCache(elm) { + return getW(elm) !== 1; + } + }; + function mulEndoUnsafe(Point, point, k1, k2) { + let acc = point; + let p1 = Point.ZERO; + let p2 = Point.ZERO; + while (k1 > _0n3 || k2 > _0n3) { + if (k1 & _1n3) + p1 = p1.add(acc); + if (k2 & _1n3) + p2 = p2.add(acc); + acc = acc.double(); + k1 >>= _1n3; + k2 >>= _1n3; + } + return { p1, p2 }; + } + function createField(order, field, isLE3) { + if (field) { + if (field.ORDER !== order) + throw new Error("Field.ORDER must match order: Fp == p, Fn == n"); + validateField(field); + return field; + } else { + return Field(order, { isLE: isLE3 }); + } + } + function createCurveFields(type, CURVE, curveOpts = {}, FpFnLE) { + if (FpFnLE === void 0) + FpFnLE = type === "edwards"; + if (!CURVE || typeof CURVE !== "object") + throw new Error(`expected valid ${type} CURVE object`); + for (const p of ["p", "n", "h"]) { + const val = CURVE[p]; + if (!(typeof val === "bigint" && val > _0n3)) + throw new Error(`CURVE.${p} must be positive bigint`); + } + const Fp = createField(CURVE.p, curveOpts.Fp, FpFnLE); + const Fn = createField(CURVE.n, curveOpts.Fn, FpFnLE); + const _b = type === "weierstrass" ? "b" : "d"; + const params = ["Gx", "Gy", "a", _b]; + for (const p of params) { + if (!Fp.isValid(CURVE[p])) + throw new Error(`CURVE.${p} must be valid field element of CURVE.Fp`); + } + CURVE = Object.freeze(Object.assign({}, CURVE)); + return { CURVE, Fp, Fn }; + } + function createKeygen(randomSecretKey, getPublicKey2) { + return function keygen(seed) { + const secretKey = randomSecretKey(seed); + return { secretKey, publicKey: getPublicKey2(secretKey) }; + }; + } + + // node_modules/@noble/curves/abstract/weierstrass.js + init_process(); + + // node_modules/@noble/hashes/hmac.js + init_process(); + var _HMAC = class { + oHash; + iHash; + blockLen; + outputLen; + finished = false; + destroyed = false; + constructor(hash, key) { + ahash(hash); + abytes(key, void 0, "key"); + this.iHash = hash.create(); + if (typeof this.iHash.update !== "function") + throw new Error("Expected instance of class which extends utils.Hash"); + this.blockLen = this.iHash.blockLen; + this.outputLen = this.iHash.outputLen; + const blockLen = this.blockLen; + const pad2 = new Uint8Array(blockLen); + pad2.set(key.length > blockLen ? hash.create().update(key).digest() : key); + for (let i = 0; i < pad2.length; i++) + pad2[i] ^= 54; + this.iHash.update(pad2); + this.oHash = hash.create(); + for (let i = 0; i < pad2.length; i++) + pad2[i] ^= 54 ^ 92; + this.oHash.update(pad2); + clean(pad2); + } + update(buf) { + aexists(this); + this.iHash.update(buf); + return this; + } + digestInto(out) { + aexists(this); + abytes(out, this.outputLen, "output"); + this.finished = true; + this.iHash.digestInto(out); + this.oHash.update(out); + this.oHash.digestInto(out); + this.destroy(); + } + digest() { + const out = new Uint8Array(this.oHash.outputLen); + this.digestInto(out); + return out; + } + _cloneInto(to) { + to ||= Object.create(Object.getPrototypeOf(this), {}); + const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this; + to = to; + to.finished = finished; + to.destroyed = destroyed; + to.blockLen = blockLen; + to.outputLen = outputLen; + to.oHash = oHash._cloneInto(to.oHash); + to.iHash = iHash._cloneInto(to.iHash); + return to; + } + clone() { + return this._cloneInto(); + } + destroy() { + this.destroyed = true; + this.oHash.destroy(); + this.iHash.destroy(); + } + }; + var hmac = (hash, key, message) => new _HMAC(hash, key).update(message).digest(); + hmac.create = (hash, key) => new _HMAC(hash, key); + + // node_modules/@noble/curves/abstract/weierstrass.js + var divNearest = (num2, den) => (num2 + (num2 >= 0 ? den : -den) / _2n2) / den; + function _splitEndoScalar(k, basis, n) { + const [[a1, b1], [a2, b2]] = basis; + const c1 = divNearest(b2 * k, n); + const c2 = divNearest(-b1 * k, n); + let k1 = k - c1 * a1 - c2 * a2; + let k2 = -c1 * b1 - c2 * b2; + const k1neg = k1 < _0n4; + const k2neg = k2 < _0n4; + if (k1neg) + k1 = -k1; + if (k2neg) + k2 = -k2; + const MAX_NUM = bitMask(Math.ceil(bitLen(n) / 2)) + _1n4; + if (k1 < _0n4 || k1 >= MAX_NUM || k2 < _0n4 || k2 >= MAX_NUM) { + throw new Error("splitScalar (endomorphism): failed, k=" + k); + } + return { k1neg, k1, k2neg, k2 }; + } + function validateSigFormat(format) { + if (!["compact", "recovered", "der"].includes(format)) + throw new Error('Signature format must be "compact", "recovered", or "der"'); + return format; + } + function validateSigOpts(opts, def) { + const optsn = {}; + for (let optName of Object.keys(def)) { + optsn[optName] = opts[optName] === void 0 ? def[optName] : opts[optName]; + } + abool(optsn.lowS, "lowS"); + abool(optsn.prehash, "prehash"); + if (optsn.format !== void 0) + validateSigFormat(optsn.format); + return optsn; + } + var DERErr = class extends Error { + constructor(m = "") { + super(m); + } + }; + var DER = { + // asn.1 DER encoding utils + Err: DERErr, + // Basic building block is TLV (Tag-Length-Value) + _tlv: { + encode: (tag, data) => { + const { Err: E } = DER; + if (tag < 0 || tag > 256) + throw new E("tlv.encode: wrong tag"); + if (data.length & 1) + throw new E("tlv.encode: unpadded data"); + const dataLen = data.length / 2; + const len = numberToHexUnpadded(dataLen); + if (len.length / 2 & 128) + throw new E("tlv.encode: long form length too big"); + const lenLen = dataLen > 127 ? numberToHexUnpadded(len.length / 2 | 128) : ""; + const t = numberToHexUnpadded(tag); + return t + lenLen + len + data; + }, + // v - value, l - left bytes (unparsed) + decode(tag, data) { + const { Err: E } = DER; + let pos = 0; + if (tag < 0 || tag > 256) + throw new E("tlv.encode: wrong tag"); + if (data.length < 2 || data[pos++] !== tag) + throw new E("tlv.decode: wrong tlv"); + const first = data[pos++]; + const isLong = !!(first & 128); + let length = 0; + if (!isLong) + length = first; + else { + const lenLen = first & 127; + if (!lenLen) + throw new E("tlv.decode(long): indefinite length not supported"); + if (lenLen > 4) + throw new E("tlv.decode(long): byte length is too big"); + const lengthBytes = data.subarray(pos, pos + lenLen); + if (lengthBytes.length !== lenLen) + throw new E("tlv.decode: length bytes not complete"); + if (lengthBytes[0] === 0) + throw new E("tlv.decode(long): zero leftmost byte"); + for (const b of lengthBytes) + length = length << 8 | b; + pos += lenLen; + if (length < 128) + throw new E("tlv.decode(long): not minimal encoding"); + } + const v = data.subarray(pos, pos + length); + if (v.length !== length) + throw new E("tlv.decode: wrong value length"); + return { v, l: data.subarray(pos + length) }; + } + }, + // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag, + // since we always use positive integers here. It must always be empty: + // - add zero byte if exists + // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding) + _int: { + encode(num2) { + const { Err: E } = DER; + if (num2 < _0n4) + throw new E("integer: negative integers are not allowed"); + let hex = numberToHexUnpadded(num2); + if (Number.parseInt(hex[0], 16) & 8) + hex = "00" + hex; + if (hex.length & 1) + throw new E("unexpected DER parsing assertion: unpadded hex"); + return hex; + }, + decode(data) { + const { Err: E } = DER; + if (data[0] & 128) + throw new E("invalid signature integer: negative"); + if (data[0] === 0 && !(data[1] & 128)) + throw new E("invalid signature integer: unnecessary leading zero"); + return bytesToNumberBE(data); + } + }, + toSig(bytes) { + const { Err: E, _int: int, _tlv: tlv } = DER; + const data = abytes(bytes, void 0, "signature"); + const { v: seqBytes, l: seqLeftBytes } = tlv.decode(48, data); + if (seqLeftBytes.length) + throw new E("invalid signature: left bytes after parsing"); + const { v: rBytes, l: rLeftBytes } = tlv.decode(2, seqBytes); + const { v: sBytes, l: sLeftBytes } = tlv.decode(2, rLeftBytes); + if (sLeftBytes.length) + throw new E("invalid signature: left bytes after parsing"); + return { r: int.decode(rBytes), s: int.decode(sBytes) }; + }, + hexFromSig(sig) { + const { _tlv: tlv, _int: int } = DER; + const rs = tlv.encode(2, int.encode(sig.r)); + const ss = tlv.encode(2, int.encode(sig.s)); + const seq = rs + ss; + return tlv.encode(48, seq); + } + }; + var _0n4 = BigInt(0); + var _1n4 = BigInt(1); + var _2n2 = BigInt(2); + var _3n2 = BigInt(3); + var _4n2 = BigInt(4); + function weierstrass(params, extraOpts = {}) { + const validated = createCurveFields("weierstrass", params, extraOpts); + const { Fp, Fn } = validated; + let CURVE = validated.CURVE; + const { h: cofactor, n: CURVE_ORDER } = CURVE; + validateObject(extraOpts, {}, { + allowInfinityPoint: "boolean", + clearCofactor: "function", + isTorsionFree: "function", + fromBytes: "function", + toBytes: "function", + endo: "object" + }); + const { endo } = extraOpts; + if (endo) { + if (!Fp.is0(CURVE.a) || typeof endo.beta !== "bigint" || !Array.isArray(endo.basises)) { + throw new Error('invalid endo: expected "beta": bigint and "basises": array'); + } + } + const lengths = getWLengths(Fp, Fn); + function assertCompressionIsSupported() { + if (!Fp.isOdd) + throw new Error("compression is not supported: Field does not have .isOdd()"); + } + function pointToBytes2(_c, point, isCompressed) { + const { x, y } = point.toAffine(); + const bx = Fp.toBytes(x); + abool(isCompressed, "isCompressed"); + if (isCompressed) { + assertCompressionIsSupported(); + const hasEvenY = !Fp.isOdd(y); + return concatBytes(pprefix(hasEvenY), bx); + } else { + return concatBytes(Uint8Array.of(4), bx, Fp.toBytes(y)); + } + } + function pointFromBytes(bytes) { + abytes(bytes, void 0, "Point"); + const { publicKey: comp, publicKeyUncompressed: uncomp } = lengths; + const length = bytes.length; + const head = bytes[0]; + const tail = bytes.subarray(1); + if (length === comp && (head === 2 || head === 3)) { + const x = Fp.fromBytes(tail); + if (!Fp.isValid(x)) + throw new Error("bad point: is not on curve, wrong x"); + const y2 = weierstrassEquation(x); + let y; + try { + y = Fp.sqrt(y2); + } catch (sqrtError) { + const err = sqrtError instanceof Error ? ": " + sqrtError.message : ""; + throw new Error("bad point: is not on curve, sqrt error" + err); + } + assertCompressionIsSupported(); + const evenY = Fp.isOdd(y); + const evenH = (head & 1) === 1; + if (evenH !== evenY) + y = Fp.neg(y); + return { x, y }; + } else if (length === uncomp && head === 4) { + const L = Fp.BYTES; + const x = Fp.fromBytes(tail.subarray(0, L)); + const y = Fp.fromBytes(tail.subarray(L, L * 2)); + if (!isValidXY(x, y)) + throw new Error("bad point: is not on curve"); + return { x, y }; + } else { + throw new Error(`bad point: got length ${length}, expected compressed=${comp} or uncompressed=${uncomp}`); + } + } + const encodePoint = extraOpts.toBytes || pointToBytes2; + const decodePoint = extraOpts.fromBytes || pointFromBytes; + function weierstrassEquation(x) { + const x2 = Fp.sqr(x); + const x3 = Fp.mul(x2, x); + return Fp.add(Fp.add(x3, Fp.mul(x, CURVE.a)), CURVE.b); + } + function isValidXY(x, y) { + const left = Fp.sqr(y); + const right = weierstrassEquation(x); + return Fp.eql(left, right); + } + if (!isValidXY(CURVE.Gx, CURVE.Gy)) + throw new Error("bad curve params: generator point"); + const _4a3 = Fp.mul(Fp.pow(CURVE.a, _3n2), _4n2); + const _27b2 = Fp.mul(Fp.sqr(CURVE.b), BigInt(27)); + if (Fp.is0(Fp.add(_4a3, _27b2))) + throw new Error("bad curve params: a or b"); + function acoord(title, n, banZero = false) { + if (!Fp.isValid(n) || banZero && Fp.is0(n)) + throw new Error(`bad point coordinate ${title}`); + return n; + } + function aprjpoint(other) { + if (!(other instanceof Point)) + throw new Error("Weierstrass Point expected"); + } + function splitEndoScalarN(k) { + if (!endo || !endo.basises) + throw new Error("no endo"); + return _splitEndoScalar(k, endo.basises, Fn.ORDER); + } + const toAffineMemo = memoized((p, iz) => { + const { X, Y, Z } = p; + if (Fp.eql(Z, Fp.ONE)) + return { x: X, y: Y }; + const is0 = p.is0(); + if (iz == null) + iz = is0 ? Fp.ONE : Fp.inv(Z); + const x = Fp.mul(X, iz); + const y = Fp.mul(Y, iz); + const zz = Fp.mul(Z, iz); + if (is0) + return { x: Fp.ZERO, y: Fp.ZERO }; + if (!Fp.eql(zz, Fp.ONE)) + throw new Error("invZ was invalid"); + return { x, y }; + }); + const assertValidMemo = memoized((p) => { + if (p.is0()) { + if (extraOpts.allowInfinityPoint && !Fp.is0(p.Y)) + return; + throw new Error("bad point: ZERO"); + } + const { x, y } = p.toAffine(); + if (!Fp.isValid(x) || !Fp.isValid(y)) + throw new Error("bad point: x or y not field elements"); + if (!isValidXY(x, y)) + throw new Error("bad point: equation left != right"); + if (!p.isTorsionFree()) + throw new Error("bad point: not in prime-order subgroup"); + return true; + }); + function finishEndo(endoBeta, k1p, k2p, k1neg, k2neg) { + k2p = new Point(Fp.mul(k2p.X, endoBeta), k2p.Y, k2p.Z); + k1p = negateCt(k1neg, k1p); + k2p = negateCt(k2neg, k2p); + return k1p.add(k2p); + } + class Point { + // base / generator point + static BASE = new Point(CURVE.Gx, CURVE.Gy, Fp.ONE); + // zero / infinity / identity point + static ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ZERO); + // 0, 1, 0 + // math field + static Fp = Fp; + // scalar field + static Fn = Fn; + X; + Y; + Z; + /** Does NOT validate if the point is valid. Use `.assertValidity()`. */ + constructor(X, Y, Z) { + this.X = acoord("x", X); + this.Y = acoord("y", Y, true); + this.Z = acoord("z", Z); + Object.freeze(this); + } + static CURVE() { + return CURVE; + } + /** Does NOT validate if the point is valid. Use `.assertValidity()`. */ + static fromAffine(p) { + const { x, y } = p || {}; + if (!p || !Fp.isValid(x) || !Fp.isValid(y)) + throw new Error("invalid affine point"); + if (p instanceof Point) + throw new Error("projective point not allowed"); + if (Fp.is0(x) && Fp.is0(y)) + return Point.ZERO; + return new Point(x, y, Fp.ONE); + } + static fromBytes(bytes) { + const P = Point.fromAffine(decodePoint(abytes(bytes, void 0, "point"))); + P.assertValidity(); + return P; + } + static fromHex(hex) { + return Point.fromBytes(hexToBytes(hex)); + } + get x() { + return this.toAffine().x; + } + get y() { + return this.toAffine().y; + } + /** + * + * @param windowSize + * @param isLazy true will defer table computation until the first multiplication + * @returns + */ + precompute(windowSize = 8, isLazy = true) { + wnaf.createCache(this, windowSize); + if (!isLazy) + this.multiply(_3n2); + return this; + } + // TODO: return `this` + /** A point on curve is valid if it conforms to equation. */ + assertValidity() { + assertValidMemo(this); + } + hasEvenY() { + const { y } = this.toAffine(); + if (!Fp.isOdd) + throw new Error("Field doesn't support isOdd"); + return !Fp.isOdd(y); + } + /** Compare one point to another. */ + equals(other) { + aprjpoint(other); + const { X: X1, Y: Y1, Z: Z1 } = this; + const { X: X2, Y: Y2, Z: Z2 } = other; + const U1 = Fp.eql(Fp.mul(X1, Z2), Fp.mul(X2, Z1)); + const U2 = Fp.eql(Fp.mul(Y1, Z2), Fp.mul(Y2, Z1)); + return U1 && U2; + } + /** Flips point to one corresponding to (x, -y) in Affine coordinates. */ + negate() { + return new Point(this.X, Fp.neg(this.Y), this.Z); + } + // Renes-Costello-Batina exception-free doubling formula. + // There is 30% faster Jacobian formula, but it is not complete. + // https://eprint.iacr.org/2015/1060, algorithm 3 + // Cost: 8M + 3S + 3*a + 2*b3 + 15add. + double() { + const { a, b } = CURVE; + const b3 = Fp.mul(b, _3n2); + const { X: X1, Y: Y1, Z: Z1 } = this; + let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO; + let t0 = Fp.mul(X1, X1); + let t1 = Fp.mul(Y1, Y1); + let t2 = Fp.mul(Z1, Z1); + let t3 = Fp.mul(X1, Y1); + t3 = Fp.add(t3, t3); + Z3 = Fp.mul(X1, Z1); + Z3 = Fp.add(Z3, Z3); + X3 = Fp.mul(a, Z3); + Y3 = Fp.mul(b3, t2); + Y3 = Fp.add(X3, Y3); + X3 = Fp.sub(t1, Y3); + Y3 = Fp.add(t1, Y3); + Y3 = Fp.mul(X3, Y3); + X3 = Fp.mul(t3, X3); + Z3 = Fp.mul(b3, Z3); + t2 = Fp.mul(a, t2); + t3 = Fp.sub(t0, t2); + t3 = Fp.mul(a, t3); + t3 = Fp.add(t3, Z3); + Z3 = Fp.add(t0, t0); + t0 = Fp.add(Z3, t0); + t0 = Fp.add(t0, t2); + t0 = Fp.mul(t0, t3); + Y3 = Fp.add(Y3, t0); + t2 = Fp.mul(Y1, Z1); + t2 = Fp.add(t2, t2); + t0 = Fp.mul(t2, t3); + X3 = Fp.sub(X3, t0); + Z3 = Fp.mul(t2, t1); + Z3 = Fp.add(Z3, Z3); + Z3 = Fp.add(Z3, Z3); + return new Point(X3, Y3, Z3); + } + // Renes-Costello-Batina exception-free addition formula. + // There is 30% faster Jacobian formula, but it is not complete. + // https://eprint.iacr.org/2015/1060, algorithm 1 + // Cost: 12M + 0S + 3*a + 3*b3 + 23add. + add(other) { + aprjpoint(other); + const { X: X1, Y: Y1, Z: Z1 } = this; + const { X: X2, Y: Y2, Z: Z2 } = other; + let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO; + const a = CURVE.a; + const b3 = Fp.mul(CURVE.b, _3n2); + let t0 = Fp.mul(X1, X2); + let t1 = Fp.mul(Y1, Y2); + let t2 = Fp.mul(Z1, Z2); + let t3 = Fp.add(X1, Y1); + let t4 = Fp.add(X2, Y2); + t3 = Fp.mul(t3, t4); + t4 = Fp.add(t0, t1); + t3 = Fp.sub(t3, t4); + t4 = Fp.add(X1, Z1); + let t5 = Fp.add(X2, Z2); + t4 = Fp.mul(t4, t5); + t5 = Fp.add(t0, t2); + t4 = Fp.sub(t4, t5); + t5 = Fp.add(Y1, Z1); + X3 = Fp.add(Y2, Z2); + t5 = Fp.mul(t5, X3); + X3 = Fp.add(t1, t2); + t5 = Fp.sub(t5, X3); + Z3 = Fp.mul(a, t4); + X3 = Fp.mul(b3, t2); + Z3 = Fp.add(X3, Z3); + X3 = Fp.sub(t1, Z3); + Z3 = Fp.add(t1, Z3); + Y3 = Fp.mul(X3, Z3); + t1 = Fp.add(t0, t0); + t1 = Fp.add(t1, t0); + t2 = Fp.mul(a, t2); + t4 = Fp.mul(b3, t4); + t1 = Fp.add(t1, t2); + t2 = Fp.sub(t0, t2); + t2 = Fp.mul(a, t2); + t4 = Fp.add(t4, t2); + t0 = Fp.mul(t1, t4); + Y3 = Fp.add(Y3, t0); + t0 = Fp.mul(t5, t4); + X3 = Fp.mul(t3, X3); + X3 = Fp.sub(X3, t0); + t0 = Fp.mul(t3, t1); + Z3 = Fp.mul(t5, Z3); + Z3 = Fp.add(Z3, t0); + return new Point(X3, Y3, Z3); + } + subtract(other) { + return this.add(other.negate()); + } + is0() { + return this.equals(Point.ZERO); + } + /** + * Constant time multiplication. + * Uses wNAF method. Windowed method may be 10% faster, + * but takes 2x longer to generate and consumes 2x memory. + * Uses precomputes when available. + * Uses endomorphism for Koblitz curves. + * @param scalar by which the point would be multiplied + * @returns New point + */ + multiply(scalar) { + const { endo: endo2 } = extraOpts; + if (!Fn.isValidNot0(scalar)) + throw new Error("invalid scalar: out of range"); + let point, fake; + const mul = (n) => wnaf.cached(this, n, (p) => normalizeZ(Point, p)); + if (endo2) { + const { k1neg, k1, k2neg, k2 } = splitEndoScalarN(scalar); + const { p: k1p, f: k1f } = mul(k1); + const { p: k2p, f: k2f } = mul(k2); + fake = k1f.add(k2f); + point = finishEndo(endo2.beta, k1p, k2p, k1neg, k2neg); + } else { + const { p, f } = mul(scalar); + point = p; + fake = f; + } + return normalizeZ(Point, [point, fake])[0]; + } + /** + * Non-constant-time multiplication. Uses double-and-add algorithm. + * It's faster, but should only be used when you don't care about + * an exposed secret key e.g. sig verification, which works over *public* keys. + */ + multiplyUnsafe(sc) { + const { endo: endo2 } = extraOpts; + const p = this; + if (!Fn.isValid(sc)) + throw new Error("invalid scalar: out of range"); + if (sc === _0n4 || p.is0()) + return Point.ZERO; + if (sc === _1n4) + return p; + if (wnaf.hasCache(this)) + return this.multiply(sc); + if (endo2) { + const { k1neg, k1, k2neg, k2 } = splitEndoScalarN(sc); + const { p1, p2 } = mulEndoUnsafe(Point, p, k1, k2); + return finishEndo(endo2.beta, p1, p2, k1neg, k2neg); + } else { + return wnaf.unsafe(p, sc); + } + } + /** + * Converts Projective point to affine (x, y) coordinates. + * @param invertedZ Z^-1 (inverted zero) - optional, precomputation is useful for invertBatch + */ + toAffine(invertedZ) { + return toAffineMemo(this, invertedZ); + } + /** + * Checks whether Point is free of torsion elements (is in prime subgroup). + * Always torsion-free for cofactor=1 curves. + */ + isTorsionFree() { + const { isTorsionFree } = extraOpts; + if (cofactor === _1n4) + return true; + if (isTorsionFree) + return isTorsionFree(Point, this); + return wnaf.unsafe(this, CURVE_ORDER).is0(); + } + clearCofactor() { + const { clearCofactor } = extraOpts; + if (cofactor === _1n4) + return this; + if (clearCofactor) + return clearCofactor(Point, this); + return this.multiplyUnsafe(cofactor); + } + isSmallOrder() { + return this.multiplyUnsafe(cofactor).is0(); + } + toBytes(isCompressed = true) { + abool(isCompressed, "isCompressed"); + this.assertValidity(); + return encodePoint(Point, this, isCompressed); + } + toHex(isCompressed = true) { + return bytesToHex(this.toBytes(isCompressed)); + } + toString() { + return ``; + } + } + const bits = Fn.BITS; + const wnaf = new wNAF(Point, extraOpts.endo ? Math.ceil(bits / 2) : bits); + Point.BASE.precompute(8); + return Point; + } + function pprefix(hasEvenY) { + return Uint8Array.of(hasEvenY ? 2 : 3); + } + function getWLengths(Fp, Fn) { + return { + secretKey: Fn.BYTES, + publicKey: 1 + Fp.BYTES, + publicKeyUncompressed: 1 + 2 * Fp.BYTES, + publicKeyHasPrefix: true, + signature: 2 * Fn.BYTES + }; + } + function ecdh(Point, ecdhOpts = {}) { + const { Fn } = Point; + const randomBytes_ = ecdhOpts.randomBytes || randomBytes; + const lengths = Object.assign(getWLengths(Point.Fp, Fn), { seed: getMinHashLength(Fn.ORDER) }); + function isValidSecretKey(secretKey) { + try { + const num2 = Fn.fromBytes(secretKey); + return Fn.isValidNot0(num2); + } catch (error) { + return false; + } + } + function isValidPublicKey(publicKey, isCompressed) { + const { publicKey: comp, publicKeyUncompressed } = lengths; + try { + const l = publicKey.length; + if (isCompressed === true && l !== comp) + return false; + if (isCompressed === false && l !== publicKeyUncompressed) + return false; + return !!Point.fromBytes(publicKey); + } catch (error) { + return false; + } + } + function randomSecretKey(seed = randomBytes_(lengths.seed)) { + return mapHashToField(abytes(seed, lengths.seed, "seed"), Fn.ORDER); + } + function getPublicKey2(secretKey, isCompressed = true) { + return Point.BASE.multiply(Fn.fromBytes(secretKey)).toBytes(isCompressed); + } + function isProbPub(item) { + const { secretKey, publicKey, publicKeyUncompressed } = lengths; + if (!isBytes(item)) + return void 0; + if ("_lengths" in Fn && Fn._lengths || secretKey === publicKey) + return void 0; + const l = abytes(item, void 0, "key").length; + return l === publicKey || l === publicKeyUncompressed; + } + function getSharedSecret(secretKeyA, publicKeyB, isCompressed = true) { + if (isProbPub(secretKeyA) === true) + throw new Error("first arg must be private key"); + if (isProbPub(publicKeyB) === false) + throw new Error("second arg must be public key"); + const s = Fn.fromBytes(secretKeyA); + const b = Point.fromBytes(publicKeyB); + return b.multiply(s).toBytes(isCompressed); + } + const utils2 = { + isValidSecretKey, + isValidPublicKey, + randomSecretKey + }; + const keygen = createKeygen(randomSecretKey, getPublicKey2); + return Object.freeze({ getPublicKey: getPublicKey2, getSharedSecret, keygen, Point, utils: utils2, lengths }); + } + function ecdsa(Point, hash, ecdsaOpts = {}) { + ahash(hash); + validateObject(ecdsaOpts, {}, { + hmac: "function", + lowS: "boolean", + randomBytes: "function", + bits2int: "function", + bits2int_modN: "function" + }); + ecdsaOpts = Object.assign({}, ecdsaOpts); + const randomBytes3 = ecdsaOpts.randomBytes || randomBytes; + const hmac2 = ecdsaOpts.hmac || ((key, msg) => hmac(hash, key, msg)); + const { Fp, Fn } = Point; + const { ORDER: CURVE_ORDER, BITS: fnBits } = Fn; + const { keygen, getPublicKey: getPublicKey2, getSharedSecret, utils: utils2, lengths } = ecdh(Point, ecdsaOpts); + const defaultSigOpts = { + prehash: true, + lowS: typeof ecdsaOpts.lowS === "boolean" ? ecdsaOpts.lowS : true, + format: "compact", + extraEntropy: false + }; + const hasLargeCofactor = CURVE_ORDER * _2n2 < Fp.ORDER; + function isBiggerThanHalfOrder(number) { + const HALF = CURVE_ORDER >> _1n4; + return number > HALF; + } + function validateRS(title, num2) { + if (!Fn.isValidNot0(num2)) + throw new Error(`invalid signature ${title}: out of range 1..Point.Fn.ORDER`); + return num2; + } + function assertSmallCofactor() { + if (hasLargeCofactor) + throw new Error('"recovered" sig type is not supported for cofactor >2 curves'); + } + function validateSigLength(bytes, format) { + validateSigFormat(format); + const size = lengths.signature; + const sizer = format === "compact" ? size : format === "recovered" ? size + 1 : void 0; + return abytes(bytes, sizer); + } + class Signature { + r; + s; + recovery; + constructor(r, s, recovery) { + this.r = validateRS("r", r); + this.s = validateRS("s", s); + if (recovery != null) { + assertSmallCofactor(); + if (![0, 1, 2, 3].includes(recovery)) + throw new Error("invalid recovery id"); + this.recovery = recovery; + } + Object.freeze(this); + } + static fromBytes(bytes, format = defaultSigOpts.format) { + validateSigLength(bytes, format); + let recid; + if (format === "der") { + const { r: r2, s: s2 } = DER.toSig(abytes(bytes)); + return new Signature(r2, s2); + } + if (format === "recovered") { + recid = bytes[0]; + format = "compact"; + bytes = bytes.subarray(1); + } + const L = lengths.signature / 2; + const r = bytes.subarray(0, L); + const s = bytes.subarray(L, L * 2); + return new Signature(Fn.fromBytes(r), Fn.fromBytes(s), recid); + } + static fromHex(hex, format) { + return this.fromBytes(hexToBytes(hex), format); + } + assertRecovery() { + const { recovery } = this; + if (recovery == null) + throw new Error("invalid recovery id: must be present"); + return recovery; + } + addRecoveryBit(recovery) { + return new Signature(this.r, this.s, recovery); + } + recoverPublicKey(messageHash) { + const { r, s } = this; + const recovery = this.assertRecovery(); + const radj = recovery === 2 || recovery === 3 ? r + CURVE_ORDER : r; + if (!Fp.isValid(radj)) + throw new Error("invalid recovery id: sig.r+curve.n != R.x"); + const x = Fp.toBytes(radj); + const R = Point.fromBytes(concatBytes(pprefix((recovery & 1) === 0), x)); + const ir = Fn.inv(radj); + const h = bits2int_modN(abytes(messageHash, void 0, "msgHash")); + const u1 = Fn.create(-h * ir); + const u2 = Fn.create(s * ir); + const Q = Point.BASE.multiplyUnsafe(u1).add(R.multiplyUnsafe(u2)); + if (Q.is0()) + throw new Error("invalid recovery: point at infinify"); + Q.assertValidity(); + return Q; + } + // Signatures should be low-s, to prevent malleability. + hasHighS() { + return isBiggerThanHalfOrder(this.s); + } + toBytes(format = defaultSigOpts.format) { + validateSigFormat(format); + if (format === "der") + return hexToBytes(DER.hexFromSig(this)); + const { r, s } = this; + const rb = Fn.toBytes(r); + const sb = Fn.toBytes(s); + if (format === "recovered") { + assertSmallCofactor(); + return concatBytes(Uint8Array.of(this.assertRecovery()), rb, sb); + } + return concatBytes(rb, sb); + } + toHex(format) { + return bytesToHex(this.toBytes(format)); + } + } + const bits2int = ecdsaOpts.bits2int || function bits2int_def(bytes) { + if (bytes.length > 8192) + throw new Error("input is too large"); + const num2 = bytesToNumberBE(bytes); + const delta = bytes.length * 8 - fnBits; + return delta > 0 ? num2 >> BigInt(delta) : num2; + }; + const bits2int_modN = ecdsaOpts.bits2int_modN || function bits2int_modN_def(bytes) { + return Fn.create(bits2int(bytes)); + }; + const ORDER_MASK = bitMask(fnBits); + function int2octets(num2) { + aInRange("num < 2^" + fnBits, num2, _0n4, ORDER_MASK); + return Fn.toBytes(num2); + } + function validateMsgAndHash(message, prehash) { + abytes(message, void 0, "message"); + return prehash ? abytes(hash(message), void 0, "prehashed message") : message; + } + function prepSig(message, secretKey, opts) { + const { lowS, prehash, extraEntropy } = validateSigOpts(opts, defaultSigOpts); + message = validateMsgAndHash(message, prehash); + const h1int = bits2int_modN(message); + const d = Fn.fromBytes(secretKey); + if (!Fn.isValidNot0(d)) + throw new Error("invalid private key"); + const seedArgs = [int2octets(d), int2octets(h1int)]; + if (extraEntropy != null && extraEntropy !== false) { + const e = extraEntropy === true ? randomBytes3(lengths.secretKey) : extraEntropy; + seedArgs.push(abytes(e, void 0, "extraEntropy")); + } + const seed = concatBytes(...seedArgs); + const m = h1int; + function k2sig(kBytes) { + const k = bits2int(kBytes); + if (!Fn.isValidNot0(k)) + return; + const ik = Fn.inv(k); + const q = Point.BASE.multiply(k).toAffine(); + const r = Fn.create(q.x); + if (r === _0n4) + return; + const s = Fn.create(ik * Fn.create(m + r * d)); + if (s === _0n4) + return; + let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n4); + let normS = s; + if (lowS && isBiggerThanHalfOrder(s)) { + normS = Fn.neg(s); + recovery ^= 1; + } + return new Signature(r, normS, hasLargeCofactor ? void 0 : recovery); + } + return { seed, k2sig }; + } + function sign(message, secretKey, opts = {}) { + const { seed, k2sig } = prepSig(message, secretKey, opts); + const drbg = createHmacDrbg(hash.outputLen, Fn.BYTES, hmac2); + const sig = drbg(seed, k2sig); + return sig.toBytes(opts.format); + } + function verify(signature, message, publicKey, opts = {}) { + const { lowS, prehash, format } = validateSigOpts(opts, defaultSigOpts); + publicKey = abytes(publicKey, void 0, "publicKey"); + message = validateMsgAndHash(message, prehash); + if (!isBytes(signature)) { + const end = signature instanceof Signature ? ", use sig.toBytes()" : ""; + throw new Error("verify expects Uint8Array signature" + end); + } + validateSigLength(signature, format); + try { + const sig = Signature.fromBytes(signature, format); + const P = Point.fromBytes(publicKey); + if (lowS && sig.hasHighS()) + return false; + const { r, s } = sig; + const h = bits2int_modN(message); + const is = Fn.inv(s); + const u1 = Fn.create(h * is); + const u2 = Fn.create(r * is); + const R = Point.BASE.multiplyUnsafe(u1).add(P.multiplyUnsafe(u2)); + if (R.is0()) + return false; + const v = Fn.create(R.x); + return v === r; + } catch (e) { + return false; + } + } + function recoverPublicKey(signature, message, opts = {}) { + const { prehash } = validateSigOpts(opts, defaultSigOpts); + message = validateMsgAndHash(message, prehash); + return Signature.fromBytes(signature, "recovered").recoverPublicKey(message).toBytes(); + } + return Object.freeze({ + keygen, + getPublicKey: getPublicKey2, + getSharedSecret, + utils: utils2, + lengths, + Point, + sign, + verify, + recoverPublicKey, + Signature, + hash + }); + } + + // node_modules/@noble/curves/secp256k1.js + var secp256k1_CURVE = { + p: BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"), + n: BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"), + h: BigInt(1), + a: BigInt(0), + b: BigInt(7), + Gx: BigInt("0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"), + Gy: BigInt("0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8") + }; + var secp256k1_ENDO = { + beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"), + basises: [ + [BigInt("0x3086d221a7d46bcde86c90e49284eb15"), -BigInt("0xe4437ed6010e88286f547fa90abfe4c3")], + [BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8"), BigInt("0x3086d221a7d46bcde86c90e49284eb15")] + ] + }; + var _0n5 = /* @__PURE__ */ BigInt(0); + var _2n3 = /* @__PURE__ */ BigInt(2); + function sqrtMod(y) { + const P = secp256k1_CURVE.p; + const _3n3 = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22); + const _23n = BigInt(23), _44n = BigInt(44), _88n = BigInt(88); + const b2 = y * y * y % P; + const b3 = b2 * b2 * y % P; + const b6 = pow2(b3, _3n3, P) * b3 % P; + const b9 = pow2(b6, _3n3, P) * b3 % P; + const b11 = pow2(b9, _2n3, P) * b2 % P; + const b22 = pow2(b11, _11n, P) * b11 % P; + const b44 = pow2(b22, _22n, P) * b22 % P; + const b88 = pow2(b44, _44n, P) * b44 % P; + const b176 = pow2(b88, _88n, P) * b88 % P; + const b220 = pow2(b176, _44n, P) * b44 % P; + const b223 = pow2(b220, _3n3, P) * b3 % P; + const t1 = pow2(b223, _23n, P) * b22 % P; + const t2 = pow2(t1, _6n, P) * b2 % P; + const root = pow2(t2, _2n3, P); + if (!Fpk1.eql(Fpk1.sqr(root), y)) + throw new Error("Cannot find square root"); + return root; + } + var Fpk1 = Field(secp256k1_CURVE.p, { sqrt: sqrtMod }); + var Pointk1 = /* @__PURE__ */ weierstrass(secp256k1_CURVE, { + Fp: Fpk1, + endo: secp256k1_ENDO + }); + var secp256k1 = /* @__PURE__ */ ecdsa(Pointk1, sha256); + var TAGGED_HASH_PREFIXES = {}; + function taggedHash(tag, ...messages) { + let tagP = TAGGED_HASH_PREFIXES[tag]; + if (tagP === void 0) { + const tagH = sha256(asciiToBytes(tag)); + tagP = concatBytes(tagH, tagH); + TAGGED_HASH_PREFIXES[tag] = tagP; + } + return sha256(concatBytes(tagP, ...messages)); + } + var pointToBytes = (point) => point.toBytes(true).slice(1); + var hasEven = (y) => y % _2n3 === _0n5; + function schnorrGetExtPubKey(priv) { + const { Fn, BASE } = Pointk1; + const d_ = Fn.fromBytes(priv); + const p = BASE.multiply(d_); + const scalar = hasEven(p.y) ? d_ : Fn.neg(d_); + return { scalar, bytes: pointToBytes(p) }; + } + function lift_x(x) { + const Fp = Fpk1; + if (!Fp.isValidNot0(x)) + throw new Error("invalid x: Fail if x \u2265 p"); + const xx = Fp.create(x * x); + const c = Fp.create(xx * x + BigInt(7)); + let y = Fp.sqrt(c); + if (!hasEven(y)) + y = Fp.neg(y); + const p = Pointk1.fromAffine({ x, y }); + p.assertValidity(); + return p; + } + var num = bytesToNumberBE; + function challenge(...args) { + return Pointk1.Fn.create(num(taggedHash("BIP0340/challenge", ...args))); + } + function schnorrGetPublicKey(secretKey) { + return schnorrGetExtPubKey(secretKey).bytes; + } + function schnorrSign(message, secretKey, auxRand = randomBytes(32)) { + const { Fn } = Pointk1; + const m = abytes(message, void 0, "message"); + const { bytes: px, scalar: d } = schnorrGetExtPubKey(secretKey); + const a = abytes(auxRand, 32, "auxRand"); + const t = Fn.toBytes(d ^ num(taggedHash("BIP0340/aux", a))); + const rand = taggedHash("BIP0340/nonce", t, px, m); + const { bytes: rx, scalar: k } = schnorrGetExtPubKey(rand); + const e = challenge(rx, px, m); + const sig = new Uint8Array(64); + sig.set(rx, 0); + sig.set(Fn.toBytes(Fn.create(k + e * d)), 32); + if (!schnorrVerify(sig, m, px)) + throw new Error("sign: Invalid signature produced"); + return sig; + } + function schnorrVerify(signature, message, publicKey) { + const { Fp, Fn, BASE } = Pointk1; + const sig = abytes(signature, 64, "signature"); + const m = abytes(message, void 0, "message"); + const pub = abytes(publicKey, 32, "publicKey"); + try { + const P = lift_x(num(pub)); + const r = num(sig.subarray(0, 32)); + if (!Fp.isValidNot0(r)) + return false; + const s = num(sig.subarray(32, 64)); + if (!Fn.isValidNot0(s)) + return false; + const e = challenge(Fn.toBytes(r), pointToBytes(P), m); + const R = BASE.multiplyUnsafe(s).add(P.multiplyUnsafe(Fn.neg(e))); + const { x, y } = R.toAffine(); + if (R.is0() || !hasEven(y) || x !== r) + return false; + return true; + } catch (error) { + return false; + } + } + var schnorr = /* @__PURE__ */ (() => { + const size = 32; + const seedLength = 48; + const randomSecretKey = (seed = randomBytes(seedLength)) => { + return mapHashToField(seed, secp256k1_CURVE.n); + }; + return { + keygen: createKeygen(randomSecretKey, schnorrGetPublicKey), + getPublicKey: schnorrGetPublicKey, + sign: schnorrSign, + verify: schnorrVerify, + Point: Pointk1, + utils: { + randomSecretKey, + taggedHash, + lift_x, + pointToBytes + }, + lengths: { + secretKey: size, + publicKey: size, + publicKeyHasPrefix: false, + signature: size * 2, + seed: seedLength + } + }; + })(); + + // node_modules/nostr-crypto-utils/dist/esm/utils/logger.js + init_process(); + var import_pino = __toESM(require_browser()); + var LogLevel; + (function(LogLevel2) { + LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG"; + LogLevel2[LogLevel2["INFO"] = 1] = "INFO"; + LogLevel2[LogLevel2["WARN"] = 2] = "WARN"; + LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR"; + })(LogLevel || (LogLevel = {})); + var logger = (0, import_pino.default)({ + name: "nostr-crypto-utils", + level: process.env.LOG_LEVEL || "info", + transport: true ? { + target: "pino-pretty", + options: { + colorize: true, + translateTime: "HH:MM:ss", + ignore: "pid,hostname" + } + } : void 0, + formatters: { + level: (label) => { + return { level: label.toUpperCase() }; + }, + log: (obj) => { + if (obj && typeof obj === "object" && "err" in obj) { + const newObj = { ...obj }; + if (newObj.err instanceof Error) { + const err = newObj.err; + newObj.err = { + message: err.message, + stack: err.stack, + name: err.name + }; + } + return newObj; + } + return obj; + } + } + }); + + // node_modules/nostr-crypto-utils/dist/esm/encoding/base64.js + init_process(); + function isValidBase64(base642) { + try { + return Boolean(base642.match(/^[A-Za-z0-9+/]*={0,2}$/)); + } catch { + return false; + } + } + function bytesToBase64(bytes) { + let binary = ""; + for (let i = 0; i < bytes.length; i++) { + binary += String.fromCharCode(bytes[i]); + } + return btoa(binary); + } + function base64ToBytes(base642) { + if (!isValidBase64(base642)) { + throw new Error("Invalid base64 string"); + } + const binary = atob(base642); + const bytes = new Uint8Array(binary.length); + for (let i = 0; i < binary.length; i++) { + bytes[i] = binary.charCodeAt(i); + } + return bytes; + } + + // node_modules/nostr-crypto-utils/dist/esm/crypto.js + var getCrypto = async () => { + if (typeof window !== "undefined" && window.crypto) { + return window.crypto; + } + if (typeof globalThis !== "undefined" && globalThis.crypto) { + return globalThis.crypto; + } + try { + const cryptoModule = await Promise.resolve().then(() => __toESM(require_crypto())); + if (cryptoModule.webcrypto) { + return cryptoModule.webcrypto; + } + } catch { + logger.debug("Node crypto not available"); + } + throw new Error("No WebCrypto implementation available"); + }; + var CustomCrypto = class { + cryptoInstance = null; + initPromise; + constructor() { + this.initPromise = this.initialize(); + } + async initialize() { + this.cryptoInstance = await getCrypto(); + } + async ensureInitialized() { + await this.initPromise; + if (!this.cryptoInstance) { + throw new Error("Crypto implementation not initialized"); + } + return this.cryptoInstance; + } + async getSubtle() { + const crypto2 = await this.ensureInitialized(); + return crypto2.subtle; + } + async getRandomValues(array) { + const crypto2 = await this.ensureInitialized(); + return crypto2.getRandomValues(array); + } + }; + var customCrypto = new CustomCrypto(); + var signSchnorr = schnorr.sign; + var verifySchnorrSignature = schnorr.verify; + async function generateKeyPair() { + const privateKeyBytes = randomBytes(32); + const privateKey = bytesToHex(privateKeyBytes); + privateKeyBytes.fill(0); + const publicKey = await getPublicKey(privateKey); + return { + privateKey, + publicKey + }; + } + async function getPublicKey(privateKey) { + try { + const privateKeyBytes = hexToBytes(privateKey); + const publicKeyBytes = schnorr.getPublicKey(privateKeyBytes); + return { + hex: bytesToHex(publicKeyBytes), + bytes: publicKeyBytes + }; + } catch (error) { + logger.error({ error }, "Failed to get public key"); + throw error; + } + } + function normalizePrivateKey(privateKey) { + if (privateKey instanceof Uint8Array) { + return bytesToHex(privateKey); + } + return privateKey; + } + async function signEvent(event, privateKey) { + try { + const privateKeyHex = normalizePrivateKey(privateKey); + const serialized = JSON.stringify([ + 0, + event.pubkey, + event.created_at, + event.kind, + event.tags, + event.content + ]); + const eventHash = sha256(new TextEncoder().encode(serialized)); + const privateKeyBytes = hexToBytes(privateKeyHex); + const signatureBytes = schnorr.sign(eventHash, privateKeyBytes); + return { + ...event, + id: bytesToHex(eventHash), + sig: bytesToHex(signatureBytes) + }; + } catch (error) { + logger.error({ error }, "Failed to sign event"); + throw error; + } + } + function getPublicKeySync(privateKey) { + const privateKeyBytes = privateKey instanceof Uint8Array ? privateKey : hexToBytes(privateKey); + const publicKeyBytes = schnorr.getPublicKey(privateKeyBytes); + return bytesToHex(publicKeyBytes); + } + async function finalizeEvent(event, privateKey) { + const pubkey = event.pubkey || getPublicKeySync(privateKey); + const timestamp = event.created_at || Math.floor(Date.now() / 1e3); + const fullEvent = { + kind: event.kind || 1, + created_at: timestamp, + tags: event.tags || [], + content: event.content || "", + pubkey + }; + return signEvent(fullEvent, privateKey); + } + + // node_modules/nostr-crypto-utils/dist/esm/validation/index.js + init_process(); + + // node_modules/nostr-crypto-utils/dist/esm/event/index.js + init_process(); + + // node_modules/nostr-crypto-utils/dist/esm/event/creation.js + init_process(); + + // node_modules/nostr-crypto-utils/dist/esm/event/signing.js + init_process(); + + // node_modules/nostr-crypto-utils/dist/esm/nips/nip-04.js + var nip_04_exports = {}; + __export(nip_04_exports, { + computeSharedSecret: () => generateSharedSecret, + decryptMessage: () => decryptMessage, + encryptMessage: () => encryptMessage, + generateSharedSecret: () => generateSharedSecret + }); + init_process(); + var getCrypto2 = async () => { + if (typeof window !== "undefined" && window.crypto) { + return window.crypto; + } + if (typeof globalThis !== "undefined" && globalThis.crypto) { + return globalThis.crypto; + } + try { + const cryptoModule = await Promise.resolve().then(() => __toESM(require_crypto())); + if (cryptoModule.webcrypto) { + return cryptoModule.webcrypto; + } + } catch { + logger.debug("Node crypto not available"); + } + throw new Error("No WebCrypto implementation available"); + }; + var CryptoImplementation = class { + cryptoInstance = null; + initPromise; + constructor() { + this.initPromise = this.initialize(); + } + async initialize() { + this.cryptoInstance = await getCrypto2(); + } + async ensureInitialized() { + await this.initPromise; + if (!this.cryptoInstance) { + throw new Error("Crypto implementation not initialized"); + } + return this.cryptoInstance; + } + async getSubtle() { + const crypto2 = await this.ensureInitialized(); + return crypto2.subtle; + } + async getRandomValues(array) { + const crypto2 = await this.ensureInitialized(); + return crypto2.getRandomValues(array); + } + }; + var cryptoImpl = new CryptoImplementation(); + async function encryptMessage(message, senderPrivKey, recipientPubKey) { + try { + if (!message || !senderPrivKey || !recipientPubKey) { + throw new Error("Invalid input parameters"); + } + if (!/^[0-9a-f]{64}$/i.test(senderPrivKey)) { + throw new Error("Invalid private key format"); + } + const pubKeyHex = recipientPubKey.startsWith("02") || recipientPubKey.startsWith("03") ? recipientPubKey : "02" + recipientPubKey; + const sharedPoint = secp256k1.getSharedSecret(hexToBytes(senderPrivKey), hexToBytes(pubKeyHex)); + const sharedX = sharedPoint.slice(1, 33); + const sharedKey = await (await cryptoImpl.getSubtle()).importKey("raw", sharedX.buffer, { name: "AES-CBC", length: 256 }, false, ["encrypt"]); + sharedX.fill(0); + sharedPoint.fill(0); + const iv = new Uint8Array(16); + await cryptoImpl.getRandomValues(iv); + const encoded = new TextEncoder().encode(message); + const encrypted = await (await cryptoImpl.getSubtle()).encrypt({ name: "AES-CBC", iv }, sharedKey, encoded.buffer); + const ciphertextBase64 = bytesToBase64(new Uint8Array(encrypted)); + const ivBase64 = bytesToBase64(iv); + return ciphertextBase64 + "?iv=" + ivBase64; + } catch (error) { + logger.error({ error }, "Failed to encrypt message"); + throw error; + } + } + async function decryptMessage(encryptedMessage, recipientPrivKey, senderPubKey) { + try { + if (!encryptedMessage || !recipientPrivKey || !senderPubKey) { + throw new Error("Invalid input parameters"); + } + if (!/^[0-9a-f]{64}$/i.test(recipientPrivKey)) { + throw new Error("Invalid private key format"); + } + const pubKeyHex = senderPubKey.startsWith("02") || senderPubKey.startsWith("03") ? senderPubKey : "02" + senderPubKey; + const sharedPoint = secp256k1.getSharedSecret(hexToBytes(recipientPrivKey), hexToBytes(pubKeyHex)); + const sharedX = sharedPoint.slice(1, 33); + const sharedKey = await (await cryptoImpl.getSubtle()).importKey("raw", sharedX.buffer, { name: "AES-CBC", length: 256 }, false, ["decrypt"]); + sharedX.fill(0); + sharedPoint.fill(0); + let iv; + let ciphertext; + if (encryptedMessage.includes("?iv=")) { + const [ciphertextBase64, ivBase64] = encryptedMessage.split("?iv="); + ciphertext = base64ToBytes(ciphertextBase64); + iv = base64ToBytes(ivBase64); + } else { + const encrypted = hexToBytes(encryptedMessage); + iv = encrypted.slice(0, 16); + ciphertext = encrypted.slice(16); + } + const decrypted = await (await cryptoImpl.getSubtle()).decrypt({ name: "AES-CBC", iv }, sharedKey, ciphertext.buffer); + return new TextDecoder().decode(decrypted); + } catch (error) { + logger.error({ error }, "Failed to decrypt message"); + throw error; + } + } + function generateSharedSecret(privateKey, publicKey) { + try { + if (!privateKey || !publicKey) { + throw new Error("Invalid input parameters"); + } + if (!/^[0-9a-f]{64}$/i.test(privateKey)) { + throw new Error("Invalid private key format"); + } + const pubKeyHex = publicKey.startsWith("02") || publicKey.startsWith("03") ? publicKey : "02" + publicKey; + const sharedPoint = secp256k1.getSharedSecret(hexToBytes(privateKey), hexToBytes(pubKeyHex)); + return { sharedSecret: sharedPoint.slice(1, 33) }; + } catch (error) { + logger.error({ error }, "Failed to generate shared secret"); + throw error; + } + } + + // node_modules/nostr-crypto-utils/dist/esm/nips/nip-01.js + init_process(); + + // node_modules/nostr-crypto-utils/dist/esm/nips/nip-19.js + var nip_19_exports = {}; + __export(nip_19_exports, { + decode: () => decode, + naddrEncode: () => naddrEncode, + neventEncode: () => neventEncode, + noteEncode: () => noteEncode, + nprofileEncode: () => nprofileEncode, + npubEncode: () => npubEncode, + nrelayEncode: () => nrelayEncode, + nsecEncode: () => nsecEncode + }); + init_process(); + var import_bech32 = __toESM(require_dist()); + var import_buffer = __toESM(require_buffer()); + var VALID_PREFIXES = ["npub", "nsec", "note", "nprofile", "nevent", "naddr", "nrelay"]; + var TLV_TYPES = { + SPECIAL: 0, + // Main data (hex) + RELAY: 1, + // Relay URL (utf8) + AUTHOR: 2, + // Author pubkey (hex) + KIND: 3, + // Event kind (uint8) + IDENTIFIER: 4 + // Identifier (utf8) + }; + function npubEncode(pubkey) { + validateHexString(pubkey, 64); + const data = import_buffer.Buffer.from(pubkey, "hex"); + const words = import_bech32.bech32.toWords(data); + return import_bech32.bech32.encode("npub", words, 1e3); + } + function nsecEncode(privkey) { + validateHexString(privkey, 64); + const data = import_buffer.Buffer.from(privkey, "hex"); + const words = import_bech32.bech32.toWords(data); + return import_bech32.bech32.encode("nsec", words, 1e3); + } + function noteEncode(eventId) { + validateHexString(eventId, 64); + const data = import_buffer.Buffer.from(eventId, "hex"); + const words = import_bech32.bech32.toWords(data); + return import_bech32.bech32.encode("note", words, 1e3); + } + function nprofileEncode(pubkey, relays) { + validateHexString(pubkey, 64); + if (relays) { + relays.forEach(validateRelayUrl); + } + const data = encodeTLV({ + type: "nprofile", + data: pubkey, + relays + }); + return import_bech32.bech32.encode("nprofile", data, 1e3); + } + function neventEncode(eventId, relays, author, kind) { + validateHexString(eventId, 64); + if (relays) { + relays.forEach(validateRelayUrl); + } + if (author) { + validateHexString(author, 64); + } + if (kind !== void 0 && !Number.isInteger(kind)) { + throw new Error("Invalid event kind"); + } + const data = encodeTLV({ + type: "nevent", + data: eventId, + relays, + author, + kind + }); + return import_bech32.bech32.encode("nevent", data, 1e3); + } + function naddrEncode(pubkey, kind, identifier, relays) { + validateHexString(pubkey, 64); + if (!Number.isInteger(kind)) { + throw new Error("Invalid event kind"); + } + if (!identifier) { + throw new Error("Identifier is required"); + } + if (relays) { + relays.forEach(validateRelayUrl); + } + const data = encodeTLV({ + type: "naddr", + data: pubkey, + kind, + identifier, + relays + }); + return import_bech32.bech32.encode("naddr", data, 1e3); + } + function nrelayEncode(url) { + validateRelayUrl(url); + const data = import_buffer.Buffer.from(url, "utf8"); + const words = import_bech32.bech32.toWords(data); + return import_bech32.bech32.encode("nrelay", words, 1e3); + } + function decode(str) { + if (!str.includes("1")) { + throw new Error("Invalid bech32 string"); + } + const prefix = str.split("1")[0].toLowerCase(); + if (!VALID_PREFIXES.includes(prefix)) { + throw new Error("Unknown prefix"); + } + try { + const decoded = import_bech32.bech32.decode(str, 1e3); + const data = import_buffer.Buffer.from(import_bech32.bech32.fromWords(decoded.words)); + let url; + let decodedData; + switch (decoded.prefix) { + case "npub": + case "nsec": + case "note": + validateHexString(data.toString("hex"), 64); + return { + type: decoded.prefix, + data: data.toString("hex") + }; + case "nrelay": + url = data.toString("utf8"); + validateRelayUrl(url); + return { + type: "nrelay", + data: url + }; + case "nprofile": + case "nevent": + case "naddr": + decodedData = decodeTLV(decoded.prefix, data); + return decodedData; + default: + throw new Error("Unknown prefix"); + } + } catch (error) { + if (error instanceof Error) { + throw error; + } + throw new Error("Invalid bech32 string"); + } + } + function validateHexString(str, length) { + if (!/^[0-9a-fA-F]+$/.test(str)) { + throw new Error("Invalid hex string"); + } + if (length && str.length !== length) { + throw new Error(`Invalid hex string length (expected ${length})`); + } + } + function validateRelayUrl(url) { + try { + const parsed = new URL(url); + if (!["ws:", "wss:"].includes(parsed.protocol)) { + throw new Error("Invalid relay URL protocol"); + } + } catch { + throw new Error("Invalid relay URL"); + } + } + function encodeTLV(data) { + const result = []; + const bytes = import_buffer.Buffer.from(data.data, "hex"); + result.push(TLV_TYPES.SPECIAL, bytes.length); + result.push(...bytes); + if (data.relays?.length) { + for (const relay of data.relays) { + const relayBytes = import_buffer.Buffer.from(relay, "utf8"); + result.push(TLV_TYPES.RELAY, relayBytes.length); + result.push(...relayBytes); + } + } + if (data.author) { + const authorBytes = import_buffer.Buffer.from(data.author, "hex"); + result.push(TLV_TYPES.AUTHOR, authorBytes.length); + result.push(...authorBytes); + } + if (data.kind !== void 0) { + const kindBytes = import_buffer.Buffer.alloc(4); + kindBytes.writeUInt32BE(data.kind); + result.push(TLV_TYPES.KIND, kindBytes.length); + result.push(...kindBytes); + } + if (data.identifier) { + const identifierBytes = import_buffer.Buffer.from(data.identifier, "utf8"); + result.push(TLV_TYPES.IDENTIFIER, identifierBytes.length); + result.push(...identifierBytes); + } + return import_bech32.bech32.toWords(import_buffer.Buffer.from(result)); + } + function decodeTLV(prefix, data) { + const result = { + type: prefix, + data: "", + relays: [] + }; + let i = 0; + let relay; + while (i < data.length) { + const type = data[i]; + const length = data[i + 1]; + if (i + 2 + length > data.length) { + throw new Error("Invalid TLV data"); + } + const value = data.slice(i + 2, i + 2 + length); + switch (type) { + case TLV_TYPES.SPECIAL: + result.data = value.toString("hex"); + validateHexString(result.data, 64); + break; + case TLV_TYPES.RELAY: + relay = value.toString("utf8"); + validateRelayUrl(relay); + result.relays = result.relays || []; + result.relays.push(relay); + break; + case TLV_TYPES.AUTHOR: + result.author = value.toString("hex"); + validateHexString(result.author, 64); + break; + case TLV_TYPES.KIND: + result.kind = value.readUInt32BE(); + break; + case TLV_TYPES.IDENTIFIER: + result.identifier = value.toString("utf8"); + break; + default: + break; + } + i += 2 + length; + } + return result; + } + + // node_modules/nostr-crypto-utils/dist/esm/nips/nip-26.js + init_process(); + + // node_modules/nostr-crypto-utils/dist/esm/nips/nip-44.js + var nip_44_exports = {}; + __export(nip_44_exports, { + calcPaddedLen: () => calcPaddedLen, + decrypt: () => decrypt, + encrypt: () => encrypt, + getConversationKey: () => getConversationKey, + v2: () => v2 + }); + init_process(); + + // node_modules/@noble/ciphers/chacha.js + init_process(); + + // node_modules/@noble/ciphers/_arx.js + init_process(); + + // node_modules/@noble/ciphers/utils.js + init_process(); + function isBytes2(a) { + return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array"; + } + function abool2(b) { + if (typeof b !== "boolean") + throw new Error(`boolean expected, not ${b}`); + } + function anumber2(n) { + if (!Number.isSafeInteger(n) || n < 0) + throw new Error("positive integer expected, got " + n); + } + function abytes2(value, length, title = "") { + const bytes = isBytes2(value); + const len = value?.length; + const needsLen = length !== void 0; + if (!bytes || needsLen && len !== length) { + const prefix = title && `"${title}" `; + const ofLen = needsLen ? ` of length ${length}` : ""; + const got = bytes ? `length=${len}` : `type=${typeof value}`; + throw new Error(prefix + "expected Uint8Array" + ofLen + ", got " + got); + } + return value; + } + function aexists2(instance, checkFinished = true) { + if (instance.destroyed) + throw new Error("Hash instance has been destroyed"); + if (checkFinished && instance.finished) + throw new Error("Hash#digest() has already been called"); + } + function aoutput2(out, instance) { + abytes2(out, void 0, "output"); + const min = instance.outputLen; + if (out.length < min) { + throw new Error("digestInto() expects output buffer of length at least " + min); + } + } + function u322(arr) { + return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4)); + } + function clean2(...arrays) { + for (let i = 0; i < arrays.length; i++) { + arrays[i].fill(0); + } + } + function createView2(arr) { + return new DataView(arr.buffer, arr.byteOffset, arr.byteLength); + } + var isLE2 = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)(); + function checkOpts2(defaults, opts) { + if (opts == null || typeof opts !== "object") + throw new Error("options must be defined"); + const merged = Object.assign(defaults, opts); + return merged; + } + function equalBytes(a, b) { + if (a.length !== b.length) + return false; + let diff = 0; + for (let i = 0; i < a.length; i++) + diff |= a[i] ^ b[i]; + return diff === 0; + } + var wrapCipher = /* @__NO_SIDE_EFFECTS__ */ (params, constructor) => { + function wrappedCipher(key, ...args) { + abytes2(key, void 0, "key"); + if (!isLE2) + throw new Error("Non little-endian hardware is not yet supported"); + if (params.nonceLength !== void 0) { + const nonce = args[0]; + abytes2(nonce, params.varSizeNonce ? void 0 : params.nonceLength, "nonce"); + } + const tagl = params.tagLength; + if (tagl && args[1] !== void 0) + abytes2(args[1], void 0, "AAD"); + const cipher = constructor(key, ...args); + const checkOutput = (fnLength, output) => { + if (output !== void 0) { + if (fnLength !== 2) + throw new Error("cipher output not supported"); + abytes2(output, void 0, "output"); + } + }; + let called = false; + const wrCipher = { + encrypt(data, output) { + if (called) + throw new Error("cannot encrypt() twice with same key + nonce"); + called = true; + abytes2(data); + checkOutput(cipher.encrypt.length, output); + return cipher.encrypt(data, output); + }, + decrypt(data, output) { + abytes2(data); + if (tagl && data.length < tagl) + throw new Error('"ciphertext" expected length bigger than tagLength=' + tagl); + checkOutput(cipher.decrypt.length, output); + return cipher.decrypt(data, output); + } + }; + return wrCipher; + } + Object.assign(wrappedCipher, params); + return wrappedCipher; + }; + function getOutput(expectedLength, out, onlyAligned = true) { + if (out === void 0) + return new Uint8Array(expectedLength); + if (out.length !== expectedLength) + throw new Error('"output" expected Uint8Array of length ' + expectedLength + ", got: " + out.length); + if (onlyAligned && !isAligned32(out)) + throw new Error("invalid output, must be aligned"); + return out; + } + function u64Lengths(dataLength, aadLength, isLE3) { + abool2(isLE3); + const num2 = new Uint8Array(16); + const view = createView2(num2); + view.setBigUint64(0, BigInt(aadLength), isLE3); + view.setBigUint64(8, BigInt(dataLength), isLE3); + return num2; + } + function isAligned32(bytes) { + return bytes.byteOffset % 4 === 0; + } + function copyBytes2(bytes) { + return Uint8Array.from(bytes); + } + + // node_modules/@noble/ciphers/_arx.js + var encodeStr = (str) => Uint8Array.from(str.split(""), (c) => c.charCodeAt(0)); + var sigma16 = encodeStr("expand 16-byte k"); + var sigma32 = encodeStr("expand 32-byte k"); + var sigma16_32 = u322(sigma16); + var sigma32_32 = u322(sigma32); + function rotl2(a, b) { + return a << b | a >>> 32 - b; + } + function isAligned322(b) { + return b.byteOffset % 4 === 0; + } + var BLOCK_LEN = 64; + var BLOCK_LEN32 = 16; + var MAX_COUNTER = 2 ** 32 - 1; + var U32_EMPTY = Uint32Array.of(); + function runCipher(core, sigma, key, nonce, data, output, counter, rounds) { + const len = data.length; + const block = new Uint8Array(BLOCK_LEN); + const b32 = u322(block); + const isAligned = isAligned322(data) && isAligned322(output); + const d32 = isAligned ? u322(data) : U32_EMPTY; + const o32 = isAligned ? u322(output) : U32_EMPTY; + for (let pos = 0; pos < len; counter++) { + core(sigma, key, nonce, b32, counter, rounds); + if (counter >= MAX_COUNTER) + throw new Error("arx: counter overflow"); + const take = Math.min(BLOCK_LEN, len - pos); + if (isAligned && take === BLOCK_LEN) { + const pos32 = pos / 4; + if (pos % 4 !== 0) + throw new Error("arx: invalid block position"); + for (let j = 0, posj; j < BLOCK_LEN32; j++) { + posj = pos32 + j; + o32[posj] = d32[posj] ^ b32[j]; + } + pos += BLOCK_LEN; + continue; + } + for (let j = 0, posj; j < take; j++) { + posj = pos + j; + output[posj] = data[posj] ^ block[j]; + } + pos += take; + } + } + function createCipher(core, opts) { + const { allowShortKeys, extendNonceFn, counterLength, counterRight, rounds } = checkOpts2({ allowShortKeys: false, counterLength: 8, counterRight: false, rounds: 20 }, opts); + if (typeof core !== "function") + throw new Error("core must be a function"); + anumber2(counterLength); + anumber2(rounds); + abool2(counterRight); + abool2(allowShortKeys); + return (key, nonce, data, output, counter = 0) => { + abytes2(key, void 0, "key"); + abytes2(nonce, void 0, "nonce"); + abytes2(data, void 0, "data"); + const len = data.length; + if (output === void 0) + output = new Uint8Array(len); + abytes2(output, void 0, "output"); + anumber2(counter); + if (counter < 0 || counter >= MAX_COUNTER) + throw new Error("arx: counter overflow"); + if (output.length < len) + throw new Error(`arx: output (${output.length}) is shorter than data (${len})`); + const toClean = []; + let l = key.length; + let k; + let sigma; + if (l === 32) { + toClean.push(k = copyBytes2(key)); + sigma = sigma32_32; + } else if (l === 16 && allowShortKeys) { + k = new Uint8Array(32); + k.set(key); + k.set(key, 16); + sigma = sigma16_32; + toClean.push(k); + } else { + abytes2(key, 32, "arx key"); + throw new Error("invalid key size"); + } + if (!isAligned322(nonce)) + toClean.push(nonce = copyBytes2(nonce)); + const k32 = u322(k); + if (extendNonceFn) { + if (nonce.length !== 24) + throw new Error(`arx: extended nonce must be 24 bytes`); + extendNonceFn(sigma, k32, u322(nonce.subarray(0, 16)), k32); + nonce = nonce.subarray(16); + } + const nonceNcLen = 16 - counterLength; + if (nonceNcLen !== nonce.length) + throw new Error(`arx: nonce must be ${nonceNcLen} or 16 bytes`); + if (nonceNcLen !== 12) { + const nc = new Uint8Array(12); + nc.set(nonce, counterRight ? 0 : 12 - nonce.length); + nonce = nc; + toClean.push(nonce); + } + const n32 = u322(nonce); + runCipher(core, sigma, k32, n32, data, output, counter, rounds); + clean2(...toClean); + return output; + }; + } + + // node_modules/@noble/ciphers/_poly1305.js + init_process(); + function u8to16(a, i) { + return a[i++] & 255 | (a[i++] & 255) << 8; + } + var Poly1305 = class { + blockLen = 16; + outputLen = 16; + buffer = new Uint8Array(16); + r = new Uint16Array(10); + // Allocating 1 array with .subarray() here is slower than 3 + h = new Uint16Array(10); + pad = new Uint16Array(8); + pos = 0; + finished = false; + // Can be speed-up using BigUint64Array, at the cost of complexity + constructor(key) { + key = copyBytes2(abytes2(key, 32, "key")); + const t0 = u8to16(key, 0); + const t1 = u8to16(key, 2); + const t2 = u8to16(key, 4); + const t3 = u8to16(key, 6); + const t4 = u8to16(key, 8); + const t5 = u8to16(key, 10); + const t6 = u8to16(key, 12); + const t7 = u8to16(key, 14); + this.r[0] = t0 & 8191; + this.r[1] = (t0 >>> 13 | t1 << 3) & 8191; + this.r[2] = (t1 >>> 10 | t2 << 6) & 7939; + this.r[3] = (t2 >>> 7 | t3 << 9) & 8191; + this.r[4] = (t3 >>> 4 | t4 << 12) & 255; + this.r[5] = t4 >>> 1 & 8190; + this.r[6] = (t4 >>> 14 | t5 << 2) & 8191; + this.r[7] = (t5 >>> 11 | t6 << 5) & 8065; + this.r[8] = (t6 >>> 8 | t7 << 8) & 8191; + this.r[9] = t7 >>> 5 & 127; + for (let i = 0; i < 8; i++) + this.pad[i] = u8to16(key, 16 + 2 * i); + } + process(data, offset, isLast = false) { + const hibit = isLast ? 0 : 1 << 11; + const { h, r } = this; + const r0 = r[0]; + const r1 = r[1]; + const r2 = r[2]; + const r3 = r[3]; + const r4 = r[4]; + const r5 = r[5]; + const r6 = r[6]; + const r7 = r[7]; + const r8 = r[8]; + const r9 = r[9]; + const t0 = u8to16(data, offset + 0); + const t1 = u8to16(data, offset + 2); + const t2 = u8to16(data, offset + 4); + const t3 = u8to16(data, offset + 6); + const t4 = u8to16(data, offset + 8); + const t5 = u8to16(data, offset + 10); + const t6 = u8to16(data, offset + 12); + const t7 = u8to16(data, offset + 14); + let h0 = h[0] + (t0 & 8191); + let h1 = h[1] + ((t0 >>> 13 | t1 << 3) & 8191); + let h2 = h[2] + ((t1 >>> 10 | t2 << 6) & 8191); + let h3 = h[3] + ((t2 >>> 7 | t3 << 9) & 8191); + let h4 = h[4] + ((t3 >>> 4 | t4 << 12) & 8191); + let h5 = h[5] + (t4 >>> 1 & 8191); + let h6 = h[6] + ((t4 >>> 14 | t5 << 2) & 8191); + let h7 = h[7] + ((t5 >>> 11 | t6 << 5) & 8191); + let h8 = h[8] + ((t6 >>> 8 | t7 << 8) & 8191); + let h9 = h[9] + (t7 >>> 5 | hibit); + let c = 0; + let d0 = c + h0 * r0 + h1 * (5 * r9) + h2 * (5 * r8) + h3 * (5 * r7) + h4 * (5 * r6); + c = d0 >>> 13; + d0 &= 8191; + d0 += h5 * (5 * r5) + h6 * (5 * r4) + h7 * (5 * r3) + h8 * (5 * r2) + h9 * (5 * r1); + c += d0 >>> 13; + d0 &= 8191; + let d1 = c + h0 * r1 + h1 * r0 + h2 * (5 * r9) + h3 * (5 * r8) + h4 * (5 * r7); + c = d1 >>> 13; + d1 &= 8191; + d1 += h5 * (5 * r6) + h6 * (5 * r5) + h7 * (5 * r4) + h8 * (5 * r3) + h9 * (5 * r2); + c += d1 >>> 13; + d1 &= 8191; + let d2 = c + h0 * r2 + h1 * r1 + h2 * r0 + h3 * (5 * r9) + h4 * (5 * r8); + c = d2 >>> 13; + d2 &= 8191; + d2 += h5 * (5 * r7) + h6 * (5 * r6) + h7 * (5 * r5) + h8 * (5 * r4) + h9 * (5 * r3); + c += d2 >>> 13; + d2 &= 8191; + let d3 = c + h0 * r3 + h1 * r2 + h2 * r1 + h3 * r0 + h4 * (5 * r9); + c = d3 >>> 13; + d3 &= 8191; + d3 += h5 * (5 * r8) + h6 * (5 * r7) + h7 * (5 * r6) + h8 * (5 * r5) + h9 * (5 * r4); + c += d3 >>> 13; + d3 &= 8191; + let d4 = c + h0 * r4 + h1 * r3 + h2 * r2 + h3 * r1 + h4 * r0; + c = d4 >>> 13; + d4 &= 8191; + d4 += h5 * (5 * r9) + h6 * (5 * r8) + h7 * (5 * r7) + h8 * (5 * r6) + h9 * (5 * r5); + c += d4 >>> 13; + d4 &= 8191; + let d5 = c + h0 * r5 + h1 * r4 + h2 * r3 + h3 * r2 + h4 * r1; + c = d5 >>> 13; + d5 &= 8191; + d5 += h5 * r0 + h6 * (5 * r9) + h7 * (5 * r8) + h8 * (5 * r7) + h9 * (5 * r6); + c += d5 >>> 13; + d5 &= 8191; + let d6 = c + h0 * r6 + h1 * r5 + h2 * r4 + h3 * r3 + h4 * r2; + c = d6 >>> 13; + d6 &= 8191; + d6 += h5 * r1 + h6 * r0 + h7 * (5 * r9) + h8 * (5 * r8) + h9 * (5 * r7); + c += d6 >>> 13; + d6 &= 8191; + let d7 = c + h0 * r7 + h1 * r6 + h2 * r5 + h3 * r4 + h4 * r3; + c = d7 >>> 13; + d7 &= 8191; + d7 += h5 * r2 + h6 * r1 + h7 * r0 + h8 * (5 * r9) + h9 * (5 * r8); + c += d7 >>> 13; + d7 &= 8191; + let d8 = c + h0 * r8 + h1 * r7 + h2 * r6 + h3 * r5 + h4 * r4; + c = d8 >>> 13; + d8 &= 8191; + d8 += h5 * r3 + h6 * r2 + h7 * r1 + h8 * r0 + h9 * (5 * r9); + c += d8 >>> 13; + d8 &= 8191; + let d9 = c + h0 * r9 + h1 * r8 + h2 * r7 + h3 * r6 + h4 * r5; + c = d9 >>> 13; + d9 &= 8191; + d9 += h5 * r4 + h6 * r3 + h7 * r2 + h8 * r1 + h9 * r0; + c += d9 >>> 13; + d9 &= 8191; + c = (c << 2) + c | 0; + c = c + d0 | 0; + d0 = c & 8191; + c = c >>> 13; + d1 += c; + h[0] = d0; + h[1] = d1; + h[2] = d2; + h[3] = d3; + h[4] = d4; + h[5] = d5; + h[6] = d6; + h[7] = d7; + h[8] = d8; + h[9] = d9; + } + finalize() { + const { h, pad: pad2 } = this; + const g = new Uint16Array(10); + let c = h[1] >>> 13; + h[1] &= 8191; + for (let i = 2; i < 10; i++) { + h[i] += c; + c = h[i] >>> 13; + h[i] &= 8191; + } + h[0] += c * 5; + c = h[0] >>> 13; + h[0] &= 8191; + h[1] += c; + c = h[1] >>> 13; + h[1] &= 8191; + h[2] += c; + g[0] = h[0] + 5; + c = g[0] >>> 13; + g[0] &= 8191; + for (let i = 1; i < 10; i++) { + g[i] = h[i] + c; + c = g[i] >>> 13; + g[i] &= 8191; + } + g[9] -= 1 << 13; + let mask = (c ^ 1) - 1; + for (let i = 0; i < 10; i++) + g[i] &= mask; + mask = ~mask; + for (let i = 0; i < 10; i++) + h[i] = h[i] & mask | g[i]; + h[0] = (h[0] | h[1] << 13) & 65535; + h[1] = (h[1] >>> 3 | h[2] << 10) & 65535; + h[2] = (h[2] >>> 6 | h[3] << 7) & 65535; + h[3] = (h[3] >>> 9 | h[4] << 4) & 65535; + h[4] = (h[4] >>> 12 | h[5] << 1 | h[6] << 14) & 65535; + h[5] = (h[6] >>> 2 | h[7] << 11) & 65535; + h[6] = (h[7] >>> 5 | h[8] << 8) & 65535; + h[7] = (h[8] >>> 8 | h[9] << 5) & 65535; + let f = h[0] + pad2[0]; + h[0] = f & 65535; + for (let i = 1; i < 8; i++) { + f = (h[i] + pad2[i] | 0) + (f >>> 16) | 0; + h[i] = f & 65535; + } + clean2(g); + } + update(data) { + aexists2(this); + abytes2(data); + data = copyBytes2(data); + const { buffer, blockLen } = this; + const len = data.length; + for (let pos = 0; pos < len; ) { + const take = Math.min(blockLen - this.pos, len - pos); + if (take === blockLen) { + for (; blockLen <= len - pos; pos += blockLen) + this.process(data, pos); + continue; + } + buffer.set(data.subarray(pos, pos + take), this.pos); + this.pos += take; + pos += take; + if (this.pos === blockLen) { + this.process(buffer, 0, false); + this.pos = 0; + } + } + return this; + } + destroy() { + clean2(this.h, this.r, this.buffer, this.pad); + } + digestInto(out) { + aexists2(this); + aoutput2(out, this); + this.finished = true; + const { buffer, h } = this; + let { pos } = this; + if (pos) { + buffer[pos++] = 1; + for (; pos < 16; pos++) + buffer[pos] = 0; + this.process(buffer, 0, true); + } + this.finalize(); + let opos = 0; + for (let i = 0; i < 8; i++) { + out[opos++] = h[i] >>> 0; + out[opos++] = h[i] >>> 8; + } + return out; + } + digest() { + const { buffer, outputLen } = this; + this.digestInto(buffer); + const res = buffer.slice(0, outputLen); + this.destroy(); + return res; + } + }; + function wrapConstructorWithKey(hashCons) { + const hashC = (msg, key) => hashCons(key).update(msg).digest(); + const tmp = hashCons(new Uint8Array(32)); + hashC.outputLen = tmp.outputLen; + hashC.blockLen = tmp.blockLen; + hashC.create = (key) => hashCons(key); + return hashC; + } + var poly1305 = /* @__PURE__ */ (() => wrapConstructorWithKey((key) => new Poly1305(key)))(); + + // node_modules/@noble/ciphers/chacha.js + function chachaCore(s, k, n, out, cnt, rounds = 20) { + let y00 = s[0], y01 = s[1], y02 = s[2], y03 = s[3], y04 = k[0], y05 = k[1], y06 = k[2], y07 = k[3], y08 = k[4], y09 = k[5], y10 = k[6], y11 = k[7], y12 = cnt, y13 = n[0], y14 = n[1], y15 = n[2]; + let x00 = y00, x01 = y01, x02 = y02, x03 = y03, x04 = y04, x05 = y05, x06 = y06, x07 = y07, x08 = y08, x09 = y09, x10 = y10, x11 = y11, x12 = y12, x13 = y13, x14 = y14, x15 = y15; + for (let r = 0; r < rounds; r += 2) { + x00 = x00 + x04 | 0; + x12 = rotl2(x12 ^ x00, 16); + x08 = x08 + x12 | 0; + x04 = rotl2(x04 ^ x08, 12); + x00 = x00 + x04 | 0; + x12 = rotl2(x12 ^ x00, 8); + x08 = x08 + x12 | 0; + x04 = rotl2(x04 ^ x08, 7); + x01 = x01 + x05 | 0; + x13 = rotl2(x13 ^ x01, 16); + x09 = x09 + x13 | 0; + x05 = rotl2(x05 ^ x09, 12); + x01 = x01 + x05 | 0; + x13 = rotl2(x13 ^ x01, 8); + x09 = x09 + x13 | 0; + x05 = rotl2(x05 ^ x09, 7); + x02 = x02 + x06 | 0; + x14 = rotl2(x14 ^ x02, 16); + x10 = x10 + x14 | 0; + x06 = rotl2(x06 ^ x10, 12); + x02 = x02 + x06 | 0; + x14 = rotl2(x14 ^ x02, 8); + x10 = x10 + x14 | 0; + x06 = rotl2(x06 ^ x10, 7); + x03 = x03 + x07 | 0; + x15 = rotl2(x15 ^ x03, 16); + x11 = x11 + x15 | 0; + x07 = rotl2(x07 ^ x11, 12); + x03 = x03 + x07 | 0; + x15 = rotl2(x15 ^ x03, 8); + x11 = x11 + x15 | 0; + x07 = rotl2(x07 ^ x11, 7); + x00 = x00 + x05 | 0; + x15 = rotl2(x15 ^ x00, 16); + x10 = x10 + x15 | 0; + x05 = rotl2(x05 ^ x10, 12); + x00 = x00 + x05 | 0; + x15 = rotl2(x15 ^ x00, 8); + x10 = x10 + x15 | 0; + x05 = rotl2(x05 ^ x10, 7); + x01 = x01 + x06 | 0; + x12 = rotl2(x12 ^ x01, 16); + x11 = x11 + x12 | 0; + x06 = rotl2(x06 ^ x11, 12); + x01 = x01 + x06 | 0; + x12 = rotl2(x12 ^ x01, 8); + x11 = x11 + x12 | 0; + x06 = rotl2(x06 ^ x11, 7); + x02 = x02 + x07 | 0; + x13 = rotl2(x13 ^ x02, 16); + x08 = x08 + x13 | 0; + x07 = rotl2(x07 ^ x08, 12); + x02 = x02 + x07 | 0; + x13 = rotl2(x13 ^ x02, 8); + x08 = x08 + x13 | 0; + x07 = rotl2(x07 ^ x08, 7); + x03 = x03 + x04 | 0; + x14 = rotl2(x14 ^ x03, 16); + x09 = x09 + x14 | 0; + x04 = rotl2(x04 ^ x09, 12); + x03 = x03 + x04 | 0; + x14 = rotl2(x14 ^ x03, 8); + x09 = x09 + x14 | 0; + x04 = rotl2(x04 ^ x09, 7); + } + let oi = 0; + out[oi++] = y00 + x00 | 0; + out[oi++] = y01 + x01 | 0; + out[oi++] = y02 + x02 | 0; + out[oi++] = y03 + x03 | 0; + out[oi++] = y04 + x04 | 0; + out[oi++] = y05 + x05 | 0; + out[oi++] = y06 + x06 | 0; + out[oi++] = y07 + x07 | 0; + out[oi++] = y08 + x08 | 0; + out[oi++] = y09 + x09 | 0; + out[oi++] = y10 + x10 | 0; + out[oi++] = y11 + x11 | 0; + out[oi++] = y12 + x12 | 0; + out[oi++] = y13 + x13 | 0; + out[oi++] = y14 + x14 | 0; + out[oi++] = y15 + x15 | 0; + } + function hchacha(s, k, i, out) { + let x00 = s[0], x01 = s[1], x02 = s[2], x03 = s[3], x04 = k[0], x05 = k[1], x06 = k[2], x07 = k[3], x08 = k[4], x09 = k[5], x10 = k[6], x11 = k[7], x12 = i[0], x13 = i[1], x14 = i[2], x15 = i[3]; + for (let r = 0; r < 20; r += 2) { + x00 = x00 + x04 | 0; + x12 = rotl2(x12 ^ x00, 16); + x08 = x08 + x12 | 0; + x04 = rotl2(x04 ^ x08, 12); + x00 = x00 + x04 | 0; + x12 = rotl2(x12 ^ x00, 8); + x08 = x08 + x12 | 0; + x04 = rotl2(x04 ^ x08, 7); + x01 = x01 + x05 | 0; + x13 = rotl2(x13 ^ x01, 16); + x09 = x09 + x13 | 0; + x05 = rotl2(x05 ^ x09, 12); + x01 = x01 + x05 | 0; + x13 = rotl2(x13 ^ x01, 8); + x09 = x09 + x13 | 0; + x05 = rotl2(x05 ^ x09, 7); + x02 = x02 + x06 | 0; + x14 = rotl2(x14 ^ x02, 16); + x10 = x10 + x14 | 0; + x06 = rotl2(x06 ^ x10, 12); + x02 = x02 + x06 | 0; + x14 = rotl2(x14 ^ x02, 8); + x10 = x10 + x14 | 0; + x06 = rotl2(x06 ^ x10, 7); + x03 = x03 + x07 | 0; + x15 = rotl2(x15 ^ x03, 16); + x11 = x11 + x15 | 0; + x07 = rotl2(x07 ^ x11, 12); + x03 = x03 + x07 | 0; + x15 = rotl2(x15 ^ x03, 8); + x11 = x11 + x15 | 0; + x07 = rotl2(x07 ^ x11, 7); + x00 = x00 + x05 | 0; + x15 = rotl2(x15 ^ x00, 16); + x10 = x10 + x15 | 0; + x05 = rotl2(x05 ^ x10, 12); + x00 = x00 + x05 | 0; + x15 = rotl2(x15 ^ x00, 8); + x10 = x10 + x15 | 0; + x05 = rotl2(x05 ^ x10, 7); + x01 = x01 + x06 | 0; + x12 = rotl2(x12 ^ x01, 16); + x11 = x11 + x12 | 0; + x06 = rotl2(x06 ^ x11, 12); + x01 = x01 + x06 | 0; + x12 = rotl2(x12 ^ x01, 8); + x11 = x11 + x12 | 0; + x06 = rotl2(x06 ^ x11, 7); + x02 = x02 + x07 | 0; + x13 = rotl2(x13 ^ x02, 16); + x08 = x08 + x13 | 0; + x07 = rotl2(x07 ^ x08, 12); + x02 = x02 + x07 | 0; + x13 = rotl2(x13 ^ x02, 8); + x08 = x08 + x13 | 0; + x07 = rotl2(x07 ^ x08, 7); + x03 = x03 + x04 | 0; + x14 = rotl2(x14 ^ x03, 16); + x09 = x09 + x14 | 0; + x04 = rotl2(x04 ^ x09, 12); + x03 = x03 + x04 | 0; + x14 = rotl2(x14 ^ x03, 8); + x09 = x09 + x14 | 0; + x04 = rotl2(x04 ^ x09, 7); + } + let oi = 0; + out[oi++] = x00; + out[oi++] = x01; + out[oi++] = x02; + out[oi++] = x03; + out[oi++] = x12; + out[oi++] = x13; + out[oi++] = x14; + out[oi++] = x15; + } + var chacha20 = /* @__PURE__ */ createCipher(chachaCore, { + counterRight: false, + counterLength: 4, + allowShortKeys: false + }); + var xchacha20 = /* @__PURE__ */ createCipher(chachaCore, { + counterRight: false, + counterLength: 8, + extendNonceFn: hchacha, + allowShortKeys: false + }); + var ZEROS16 = /* @__PURE__ */ new Uint8Array(16); + var updatePadded = (h, msg) => { + h.update(msg); + const leftover = msg.length % 16; + if (leftover) + h.update(ZEROS16.subarray(leftover)); + }; + var ZEROS32 = /* @__PURE__ */ new Uint8Array(32); + function computeTag(fn, key, nonce, ciphertext, AAD) { + if (AAD !== void 0) + abytes2(AAD, void 0, "AAD"); + const authKey = fn(key, nonce, ZEROS32); + const lengths = u64Lengths(ciphertext.length, AAD ? AAD.length : 0, true); + const h = poly1305.create(authKey); + if (AAD) + updatePadded(h, AAD); + updatePadded(h, ciphertext); + h.update(lengths); + const res = h.digest(); + clean2(authKey, lengths); + return res; + } + var _poly1305_aead = (xorStream) => (key, nonce, AAD) => { + const tagLength = 16; + return { + encrypt(plaintext, output) { + const plength = plaintext.length; + output = getOutput(plength + tagLength, output, false); + output.set(plaintext); + const oPlain = output.subarray(0, -tagLength); + xorStream(key, nonce, oPlain, oPlain, 1); + const tag = computeTag(xorStream, key, nonce, oPlain, AAD); + output.set(tag, plength); + clean2(tag); + return output; + }, + decrypt(ciphertext, output) { + output = getOutput(ciphertext.length - tagLength, output, false); + const data = ciphertext.subarray(0, -tagLength); + const passedTag = ciphertext.subarray(-tagLength); + const tag = computeTag(xorStream, key, nonce, data, AAD); + if (!equalBytes(passedTag, tag)) + throw new Error("invalid tag"); + output.set(ciphertext.subarray(0, -tagLength)); + xorStream(key, nonce, output, output, 1); + clean2(tag); + return output; + } + }; + }; + var chacha20poly1305 = /* @__PURE__ */ wrapCipher({ blockSize: 64, nonceLength: 12, tagLength: 16 }, _poly1305_aead(chacha20)); + var xchacha20poly1305 = /* @__PURE__ */ wrapCipher({ blockSize: 64, nonceLength: 24, tagLength: 16 }, _poly1305_aead(xchacha20)); + + // node_modules/@noble/hashes/hkdf.js + init_process(); + function extract(hash, ikm, salt) { + ahash(hash); + if (salt === void 0) + salt = new Uint8Array(hash.outputLen); + return hmac(hash, salt, ikm); + } + var HKDF_COUNTER = /* @__PURE__ */ Uint8Array.of(0); + var EMPTY_BUFFER = /* @__PURE__ */ Uint8Array.of(); + function expand(hash, prk, info, length = 32) { + ahash(hash); + anumber(length, "length"); + const olen = hash.outputLen; + if (length > 255 * olen) + throw new Error("Length must be <= 255*HashLen"); + const blocks = Math.ceil(length / olen); + if (info === void 0) + info = EMPTY_BUFFER; + else + abytes(info, void 0, "info"); + const okm = new Uint8Array(blocks * olen); + const HMAC = hmac.create(hash, prk); + const HMACTmp = HMAC._cloneInto(); + const T = new Uint8Array(HMAC.outputLen); + for (let counter = 0; counter < blocks; counter++) { + HKDF_COUNTER[0] = counter + 1; + HMACTmp.update(counter === 0 ? EMPTY_BUFFER : T).update(info).update(HKDF_COUNTER).digestInto(T); + okm.set(T, olen * counter); + HMAC._cloneInto(HMACTmp); + } + HMAC.destroy(); + HMACTmp.destroy(); + clean(T, HKDF_COUNTER); + return okm.slice(0, length); + } + + // node_modules/@scure/base/index.js + init_process(); + function isBytes3(a) { + return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array"; + } + function abytes3(b) { + if (!isBytes3(b)) + throw new Error("Uint8Array expected"); + } + function isArrayOf(isString, arr) { + if (!Array.isArray(arr)) + return false; + if (arr.length === 0) + return true; + if (isString) { + return arr.every((item) => typeof item === "string"); + } else { + return arr.every((item) => Number.isSafeInteger(item)); + } + } + function afn(input) { + if (typeof input !== "function") + throw new Error("function expected"); + return true; + } + function astr(label, input) { + if (typeof input !== "string") + throw new Error(`${label}: string expected`); + return true; + } + function anumber3(n) { + if (!Number.isSafeInteger(n)) + throw new Error(`invalid integer: ${n}`); + } + function aArr(input) { + if (!Array.isArray(input)) + throw new Error("array expected"); + } + function astrArr(label, input) { + if (!isArrayOf(true, input)) + throw new Error(`${label}: array of strings expected`); + } + function anumArr(label, input) { + if (!isArrayOf(false, input)) + throw new Error(`${label}: array of numbers expected`); + } + // @__NO_SIDE_EFFECTS__ + function chain(...args) { + const id = (a) => a; + const wrap2 = (a, b) => (c) => a(b(c)); + const encode = args.map((x) => x.encode).reduceRight(wrap2, id); + const decode2 = args.map((x) => x.decode).reduce(wrap2, id); + return { encode, decode: decode2 }; + } + // @__NO_SIDE_EFFECTS__ + function alphabet(letters) { + const lettersA = typeof letters === "string" ? letters.split("") : letters; + const len = lettersA.length; + astrArr("alphabet", lettersA); + const indexes = new Map(lettersA.map((l, i) => [l, i])); + return { + encode: (digits) => { + aArr(digits); + return digits.map((i) => { + if (!Number.isSafeInteger(i) || i < 0 || i >= len) + throw new Error(`alphabet.encode: digit index outside alphabet "${i}". Allowed: ${letters}`); + return lettersA[i]; + }); + }, + decode: (input) => { + aArr(input); + return input.map((letter) => { + astr("alphabet.decode", letter); + const i = indexes.get(letter); + if (i === void 0) + throw new Error(`Unknown letter: "${letter}". Allowed: ${letters}`); + return i; + }); + } + }; + } + // @__NO_SIDE_EFFECTS__ + function join(separator = "") { + astr("join", separator); + return { + encode: (from) => { + astrArr("join.decode", from); + return from.join(separator); + }, + decode: (to) => { + astr("join.decode", to); + return to.split(separator); + } + }; + } + // @__NO_SIDE_EFFECTS__ + function padding(bits, chr = "=") { + anumber3(bits); + astr("padding", chr); + return { + encode(data) { + astrArr("padding.encode", data); + while (data.length * bits % 8) + data.push(chr); + return data; + }, + decode(input) { + astrArr("padding.decode", input); + let end = input.length; + if (end * bits % 8) + throw new Error("padding: invalid, string should have whole number of bytes"); + for (; end > 0 && input[end - 1] === chr; end--) { + const last = end - 1; + const byte = last * bits; + if (byte % 8 === 0) + throw new Error("padding: invalid, string has too much padding"); + } + return input.slice(0, end); + } + }; + } + function convertRadix(data, from, to) { + if (from < 2) + throw new Error(`convertRadix: invalid from=${from}, base cannot be less than 2`); + if (to < 2) + throw new Error(`convertRadix: invalid to=${to}, base cannot be less than 2`); + aArr(data); + if (!data.length) + return []; + let pos = 0; + const res = []; + const digits = Array.from(data, (d) => { + anumber3(d); + if (d < 0 || d >= from) + throw new Error(`invalid integer: ${d}`); + return d; + }); + const dlen = digits.length; + while (true) { + let carry = 0; + let done = true; + for (let i = pos; i < dlen; i++) { + const digit = digits[i]; + const fromCarry = from * carry; + const digitBase = fromCarry + digit; + if (!Number.isSafeInteger(digitBase) || fromCarry / from !== carry || digitBase - digit !== fromCarry) { + throw new Error("convertRadix: carry overflow"); + } + const div = digitBase / to; + carry = digitBase % to; + const rounded = Math.floor(div); + digits[i] = rounded; + if (!Number.isSafeInteger(rounded) || rounded * to + carry !== digitBase) + throw new Error("convertRadix: carry overflow"); + if (!done) + continue; + else if (!rounded) + pos = i; + else + done = false; + } + res.push(carry); + if (done) + break; + } + for (let i = 0; i < data.length - 1 && data[i] === 0; i++) + res.push(0); + return res.reverse(); + } + var gcd = (a, b) => b === 0 ? a : gcd(b, a % b); + var radix2carry = /* @__NO_SIDE_EFFECTS__ */ (from, to) => from + (to - gcd(from, to)); + var powers = /* @__PURE__ */ (() => { + let res = []; + for (let i = 0; i < 40; i++) + res.push(2 ** i); + return res; + })(); + function convertRadix2(data, from, to, padding2) { + aArr(data); + if (from <= 0 || from > 32) + throw new Error(`convertRadix2: wrong from=${from}`); + if (to <= 0 || to > 32) + throw new Error(`convertRadix2: wrong to=${to}`); + if (/* @__PURE__ */ radix2carry(from, to) > 32) { + throw new Error(`convertRadix2: carry overflow from=${from} to=${to} carryBits=${/* @__PURE__ */ radix2carry(from, to)}`); + } + let carry = 0; + let pos = 0; + const max = powers[from]; + const mask = powers[to] - 1; + const res = []; + for (const n of data) { + anumber3(n); + if (n >= max) + throw new Error(`convertRadix2: invalid data word=${n} from=${from}`); + carry = carry << from | n; + if (pos + from > 32) + throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from}`); + pos += from; + for (; pos >= to; pos -= to) + res.push((carry >> pos - to & mask) >>> 0); + const pow = powers[pos]; + if (pow === void 0) + throw new Error("invalid carry"); + carry &= pow - 1; + } + carry = carry << to - pos & mask; + if (!padding2 && pos >= from) + throw new Error("Excess padding"); + if (!padding2 && carry > 0) + throw new Error(`Non-zero padding: ${carry}`); + if (padding2 && pos > 0) + res.push(carry >>> 0); + return res; + } + // @__NO_SIDE_EFFECTS__ + function radix(num2) { + anumber3(num2); + const _256 = 2 ** 8; + return { + encode: (bytes) => { + if (!isBytes3(bytes)) + throw new Error("radix.encode input should be Uint8Array"); + return convertRadix(Array.from(bytes), _256, num2); + }, + decode: (digits) => { + anumArr("radix.decode", digits); + return Uint8Array.from(convertRadix(digits, num2, _256)); + } + }; + } + // @__NO_SIDE_EFFECTS__ + function radix2(bits, revPadding = false) { + anumber3(bits); + if (bits <= 0 || bits > 32) + throw new Error("radix2: bits should be in (0..32]"); + if (/* @__PURE__ */ radix2carry(8, bits) > 32 || /* @__PURE__ */ radix2carry(bits, 8) > 32) + throw new Error("radix2: carry overflow"); + return { + encode: (bytes) => { + if (!isBytes3(bytes)) + throw new Error("radix2.encode input should be Uint8Array"); + return convertRadix2(Array.from(bytes), 8, bits, !revPadding); + }, + decode: (digits) => { + anumArr("radix2.decode", digits); + return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding)); + } + }; + } + function unsafeWrapper(fn) { + afn(fn); + return function(...args) { + try { + return fn.apply(null, args); + } catch (e) { + } + }; + } + function checksum(len, fn) { + anumber3(len); + afn(fn); + return { + encode(data) { + if (!isBytes3(data)) + throw new Error("checksum.encode: input should be Uint8Array"); + const sum = fn(data).slice(0, len); + const res = new Uint8Array(data.length + len); + res.set(data); + res.set(sum, data.length); + return res; + }, + decode(data) { + if (!isBytes3(data)) + throw new Error("checksum.decode: input should be Uint8Array"); + const payload = data.slice(0, -len); + const oldChecksum = data.slice(-len); + const newChecksum = fn(payload).slice(0, len); + for (let i = 0; i < len; i++) + if (newChecksum[i] !== oldChecksum[i]) + throw new Error("Invalid checksum"); + return payload; + } + }; + } + var utils = { + alphabet, + chain, + checksum, + convertRadix, + convertRadix2, + radix, + radix2, + join, + padding + }; + var hasBase64Builtin = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toBase64 === "function" && typeof Uint8Array.fromBase64 === "function")(); + var decodeBase64Builtin = (s, isUrl) => { + astr("base64", s); + const re = isUrl ? /^[A-Za-z0-9=_-]+$/ : /^[A-Za-z0-9=+/]+$/; + const alphabet2 = isUrl ? "base64url" : "base64"; + if (s.length > 0 && !re.test(s)) + throw new Error("invalid base64"); + return Uint8Array.fromBase64(s, { alphabet: alphabet2, lastChunkHandling: "strict" }); + }; + var base64 = hasBase64Builtin ? { + encode(b) { + abytes3(b); + return b.toBase64(); + }, + decode(s) { + return decodeBase64Builtin(s, false); + } + } : /* @__PURE__ */ chain(/* @__PURE__ */ radix2(6), /* @__PURE__ */ alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), /* @__PURE__ */ padding(6), /* @__PURE__ */ join("")); + var BECH_ALPHABET = /* @__PURE__ */ chain(/* @__PURE__ */ alphabet("qpzry9x8gf2tvdw0s3jn54khce6mua7l"), /* @__PURE__ */ join("")); + var POLYMOD_GENERATORS = [996825010, 642813549, 513874426, 1027748829, 705979059]; + function bech32Polymod(pre) { + const b = pre >> 25; + let chk = (pre & 33554431) << 5; + for (let i = 0; i < POLYMOD_GENERATORS.length; i++) { + if ((b >> i & 1) === 1) + chk ^= POLYMOD_GENERATORS[i]; + } + return chk; + } + function bechChecksum(prefix, words, encodingConst = 1) { + const len = prefix.length; + let chk = 1; + for (let i = 0; i < len; i++) { + const c = prefix.charCodeAt(i); + if (c < 33 || c > 126) + throw new Error(`Invalid prefix (${prefix})`); + chk = bech32Polymod(chk) ^ c >> 5; + } + chk = bech32Polymod(chk); + for (let i = 0; i < len; i++) + chk = bech32Polymod(chk) ^ prefix.charCodeAt(i) & 31; + for (let v of words) + chk = bech32Polymod(chk) ^ v; + for (let i = 0; i < 6; i++) + chk = bech32Polymod(chk); + chk ^= encodingConst; + return BECH_ALPHABET.encode(convertRadix2([chk % powers[30]], 30, 5, false)); + } + // @__NO_SIDE_EFFECTS__ + function genBech32(encoding) { + const ENCODING_CONST = encoding === "bech32" ? 1 : 734539939; + const _words = /* @__PURE__ */ radix2(5); + const fromWords = _words.decode; + const toWords = _words.encode; + const fromWordsUnsafe = unsafeWrapper(fromWords); + function encode(prefix, words, limit = 90) { + astr("bech32.encode prefix", prefix); + if (isBytes3(words)) + words = Array.from(words); + anumArr("bech32.encode", words); + const plen = prefix.length; + if (plen === 0) + throw new TypeError(`Invalid prefix length ${plen}`); + const actualLength = plen + 7 + words.length; + if (limit !== false && actualLength > limit) + throw new TypeError(`Length ${actualLength} exceeds limit ${limit}`); + const lowered = prefix.toLowerCase(); + const sum = bechChecksum(lowered, words, ENCODING_CONST); + return `${lowered}1${BECH_ALPHABET.encode(words)}${sum}`; + } + function decode2(str, limit = 90) { + astr("bech32.decode input", str); + const slen = str.length; + if (slen < 8 || limit !== false && slen > limit) + throw new TypeError(`invalid string length: ${slen} (${str}). Expected (8..${limit})`); + const lowered = str.toLowerCase(); + if (str !== lowered && str !== str.toUpperCase()) + throw new Error(`String must be lowercase or uppercase`); + const sepIndex = lowered.lastIndexOf("1"); + if (sepIndex === 0 || sepIndex === -1) + throw new Error(`Letter "1" must be present between prefix and data only`); + const prefix = lowered.slice(0, sepIndex); + const data = lowered.slice(sepIndex + 1); + if (data.length < 6) + throw new Error("Data must be at least 6 characters long"); + const words = BECH_ALPHABET.decode(data).slice(0, -6); + const sum = bechChecksum(prefix, words, ENCODING_CONST); + if (!data.endsWith(sum)) + throw new Error(`Invalid checksum in ${str}: expected "${sum}"`); + return { prefix, words }; + } + const decodeUnsafe = unsafeWrapper(decode2); + function decodeToBytes(str) { + const { prefix, words } = decode2(str, false); + return { prefix, words, bytes: fromWords(words) }; + } + function encodeFromBytes(prefix, bytes) { + return encode(prefix, toWords(bytes)); + } + return { + encode, + decode: decode2, + encodeFromBytes, + decodeToBytes, + decodeUnsafe, + fromWords, + fromWordsUnsafe, + toWords + }; + } + var bech322 = /* @__PURE__ */ genBech32("bech32"); + + // node_modules/nostr-crypto-utils/dist/esm/nips/nip-44.js + var utf8Encoder = new TextEncoder(); + var utf8Decoder = new TextDecoder(); + var minPlaintextSize = 1; + var maxPlaintextSize = 65535; + function calcPaddedLen(len) { + if (!Number.isSafeInteger(len) || len < 1) + throw new Error("expected positive integer"); + if (len <= 32) + return 32; + const nextPower = 1 << Math.floor(Math.log2(len - 1)) + 1; + const chunk = nextPower <= 256 ? 32 : nextPower / 8; + return chunk * (Math.floor((len - 1) / chunk) + 1); + } + function pad(plaintext) { + const unpadded = utf8Encoder.encode(plaintext); + const unpaddedLen = unpadded.length; + if (unpaddedLen < minPlaintextSize || unpaddedLen > maxPlaintextSize) + throw new Error("invalid plaintext length: must be between 1 and 65535 bytes"); + const prefix = new Uint8Array(2); + new DataView(prefix.buffer).setUint16(0, unpaddedLen, false); + const suffix = new Uint8Array(calcPaddedLen(unpaddedLen) - unpaddedLen); + return concatBytes(prefix, unpadded, suffix); + } + function unpad(padded) { + const unpaddedLen = new DataView(padded.buffer, padded.byteOffset).getUint16(0, false); + const unpadded = padded.subarray(2, 2 + unpaddedLen); + if (unpaddedLen < minPlaintextSize || unpaddedLen > maxPlaintextSize || unpadded.length !== unpaddedLen || padded.length !== 2 + calcPaddedLen(unpaddedLen)) { + throw new Error("invalid padding"); + } + return utf8Decoder.decode(unpadded); + } + function getConversationKey(privkeyA, pubkeyB) { + const sharedPoint = secp256k1.getSharedSecret(privkeyA, hexToBytes("02" + pubkeyB)); + const sharedX = sharedPoint.subarray(1, 33); + return extract(sha256, sharedX, utf8Encoder.encode("nip44-v2")); + } + function getMessageKeys(conversationKey, nonce) { + const keys = expand(sha256, conversationKey, nonce, 76); + return { + chacha_key: keys.subarray(0, 32), + chacha_nonce: keys.subarray(32, 44), + hmac_key: keys.subarray(44, 76) + }; + } + function encrypt(plaintext, conversationKey, nonce = randomBytes(32)) { + const { chacha_key, chacha_nonce, hmac_key } = getMessageKeys(conversationKey, nonce); + const padded = pad(plaintext); + const ciphertext = chacha20(chacha_key, chacha_nonce, padded); + const mac = hmac(sha256, hmac_key, concatBytes(nonce, ciphertext)); + return base64.encode(concatBytes(new Uint8Array([2]), nonce, ciphertext, mac)); + } + function decrypt(payload, conversationKey) { + const data = base64.decode(payload); + const version = data[0]; + if (version !== 2) + throw new Error(`unknown encryption version: ${version}`); + if (data.length < 99 || data.length > 65603) + throw new Error("invalid payload size"); + const nonce = data.subarray(1, 33); + const ciphertext = data.subarray(33, data.length - 32); + const mac = data.subarray(data.length - 32); + const { chacha_key, chacha_nonce, hmac_key } = getMessageKeys(conversationKey, nonce); + const expectedMac = hmac(sha256, hmac_key, concatBytes(nonce, ciphertext)); + if (!equalBytes(mac, expectedMac)) + throw new Error("invalid MAC"); + const padded = chacha20(chacha_key, chacha_nonce, ciphertext); + return unpad(padded); + } + var v2 = { + utils: { + getConversationKey, + calcPaddedLen + }, + encrypt, + decrypt + }; + + // node_modules/nostr-crypto-utils/dist/esm/nips/nip-46.js + init_process(); + + // node_modules/nostr-crypto-utils/dist/esm/nips/nip-49.js + init_process(); + + // node_modules/@noble/hashes/scrypt.js + init_process(); + + // node_modules/@noble/hashes/pbkdf2.js + init_process(); + function pbkdf2Init(hash, _password, _salt, _opts) { + ahash(hash); + const opts = checkOpts({ dkLen: 32, asyncTick: 10 }, _opts); + const { c, dkLen, asyncTick } = opts; + anumber(c, "c"); + anumber(dkLen, "dkLen"); + anumber(asyncTick, "asyncTick"); + if (c < 1) + throw new Error("iterations (c) must be >= 1"); + const password = kdfInputToBytes(_password, "password"); + const salt = kdfInputToBytes(_salt, "salt"); + const DK = new Uint8Array(dkLen); + const PRF = hmac.create(hash, password); + const PRFSalt = PRF._cloneInto().update(salt); + return { c, dkLen, asyncTick, DK, PRF, PRFSalt }; + } + function pbkdf2Output(PRF, PRFSalt, DK, prfW, u) { + PRF.destroy(); + PRFSalt.destroy(); + if (prfW) + prfW.destroy(); + clean(u); + return DK; + } + function pbkdf2(hash, password, salt, opts) { + const { c, dkLen, DK, PRF, PRFSalt } = pbkdf2Init(hash, password, salt, opts); + let prfW; + const arr = new Uint8Array(4); + const view = createView(arr); + const u = new Uint8Array(PRF.outputLen); + for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) { + const Ti = DK.subarray(pos, pos + PRF.outputLen); + view.setInt32(0, ti, false); + (prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u); + Ti.set(u.subarray(0, Ti.length)); + for (let ui = 1; ui < c; ui++) { + PRF._cloneInto(prfW).update(u).digestInto(u); + for (let i = 0; i < Ti.length; i++) + Ti[i] ^= u[i]; + } + } + return pbkdf2Output(PRF, PRFSalt, DK, prfW, u); + } + + // node_modules/@noble/hashes/scrypt.js + function XorAndSalsa(prev, pi, input, ii, out, oi) { + let y00 = prev[pi++] ^ input[ii++], y01 = prev[pi++] ^ input[ii++]; + let y02 = prev[pi++] ^ input[ii++], y03 = prev[pi++] ^ input[ii++]; + let y04 = prev[pi++] ^ input[ii++], y05 = prev[pi++] ^ input[ii++]; + let y06 = prev[pi++] ^ input[ii++], y07 = prev[pi++] ^ input[ii++]; + let y08 = prev[pi++] ^ input[ii++], y09 = prev[pi++] ^ input[ii++]; + let y10 = prev[pi++] ^ input[ii++], y11 = prev[pi++] ^ input[ii++]; + let y12 = prev[pi++] ^ input[ii++], y13 = prev[pi++] ^ input[ii++]; + let y14 = prev[pi++] ^ input[ii++], y15 = prev[pi++] ^ input[ii++]; + let x00 = y00, x01 = y01, x02 = y02, x03 = y03, x04 = y04, x05 = y05, x06 = y06, x07 = y07, x08 = y08, x09 = y09, x10 = y10, x11 = y11, x12 = y12, x13 = y13, x14 = y14, x15 = y15; + for (let i = 0; i < 8; i += 2) { + x04 ^= rotl(x00 + x12 | 0, 7); + x08 ^= rotl(x04 + x00 | 0, 9); + x12 ^= rotl(x08 + x04 | 0, 13); + x00 ^= rotl(x12 + x08 | 0, 18); + x09 ^= rotl(x05 + x01 | 0, 7); + x13 ^= rotl(x09 + x05 | 0, 9); + x01 ^= rotl(x13 + x09 | 0, 13); + x05 ^= rotl(x01 + x13 | 0, 18); + x14 ^= rotl(x10 + x06 | 0, 7); + x02 ^= rotl(x14 + x10 | 0, 9); + x06 ^= rotl(x02 + x14 | 0, 13); + x10 ^= rotl(x06 + x02 | 0, 18); + x03 ^= rotl(x15 + x11 | 0, 7); + x07 ^= rotl(x03 + x15 | 0, 9); + x11 ^= rotl(x07 + x03 | 0, 13); + x15 ^= rotl(x11 + x07 | 0, 18); + x01 ^= rotl(x00 + x03 | 0, 7); + x02 ^= rotl(x01 + x00 | 0, 9); + x03 ^= rotl(x02 + x01 | 0, 13); + x00 ^= rotl(x03 + x02 | 0, 18); + x06 ^= rotl(x05 + x04 | 0, 7); + x07 ^= rotl(x06 + x05 | 0, 9); + x04 ^= rotl(x07 + x06 | 0, 13); + x05 ^= rotl(x04 + x07 | 0, 18); + x11 ^= rotl(x10 + x09 | 0, 7); + x08 ^= rotl(x11 + x10 | 0, 9); + x09 ^= rotl(x08 + x11 | 0, 13); + x10 ^= rotl(x09 + x08 | 0, 18); + x12 ^= rotl(x15 + x14 | 0, 7); + x13 ^= rotl(x12 + x15 | 0, 9); + x14 ^= rotl(x13 + x12 | 0, 13); + x15 ^= rotl(x14 + x13 | 0, 18); + } + out[oi++] = y00 + x00 | 0; + out[oi++] = y01 + x01 | 0; + out[oi++] = y02 + x02 | 0; + out[oi++] = y03 + x03 | 0; + out[oi++] = y04 + x04 | 0; + out[oi++] = y05 + x05 | 0; + out[oi++] = y06 + x06 | 0; + out[oi++] = y07 + x07 | 0; + out[oi++] = y08 + x08 | 0; + out[oi++] = y09 + x09 | 0; + out[oi++] = y10 + x10 | 0; + out[oi++] = y11 + x11 | 0; + out[oi++] = y12 + x12 | 0; + out[oi++] = y13 + x13 | 0; + out[oi++] = y14 + x14 | 0; + out[oi++] = y15 + x15 | 0; + } + function BlockMix(input, ii, out, oi, r) { + let head = oi + 0; + let tail = oi + 16 * r; + for (let i = 0; i < 16; i++) + out[tail + i] = input[ii + (2 * r - 1) * 16 + i]; + for (let i = 0; i < r; i++, head += 16, ii += 16) { + XorAndSalsa(out, tail, input, ii, out, head); + if (i > 0) + tail += 16; + XorAndSalsa(out, head, input, ii += 16, out, tail); + } + } + function scryptInit(password, salt, _opts) { + const opts = checkOpts({ + dkLen: 32, + asyncTick: 10, + maxmem: 1024 ** 3 + 1024 + }, _opts); + const { N, r, p, dkLen, asyncTick, maxmem, onProgress } = opts; + anumber(N, "N"); + anumber(r, "r"); + anumber(p, "p"); + anumber(dkLen, "dkLen"); + anumber(asyncTick, "asyncTick"); + anumber(maxmem, "maxmem"); + if (onProgress !== void 0 && typeof onProgress !== "function") + throw new Error("progressCb must be a function"); + const blockSize = 128 * r; + const blockSize32 = blockSize / 4; + const pow32 = Math.pow(2, 32); + if (N <= 1 || (N & N - 1) !== 0 || N > pow32) + throw new Error('"N" expected a power of 2, and 2^1 <= N <= 2^32'); + if (p < 1 || p > (pow32 - 1) * 32 / blockSize) + throw new Error('"p" expected integer 1..((2^32 - 1) * 32) / (128 * r)'); + if (dkLen < 1 || dkLen > (pow32 - 1) * 32) + throw new Error('"dkLen" expected integer 1..(2^32 - 1) * 32'); + const memUsed = blockSize * (N + p); + if (memUsed > maxmem) + throw new Error('"maxmem" limit was hit, expected 128*r*(N+p) <= "maxmem"=' + maxmem); + const B = pbkdf2(sha256, password, salt, { c: 1, dkLen: blockSize * p }); + const B32 = u32(B); + const V = u32(new Uint8Array(blockSize * N)); + const tmp = u32(new Uint8Array(blockSize)); + let blockMixCb = () => { + }; + if (onProgress) { + const totalBlockMix = 2 * N * p; + const callbackPer = Math.max(Math.floor(totalBlockMix / 1e4), 1); + let blockMixCnt = 0; + blockMixCb = () => { + blockMixCnt++; + if (onProgress && (!(blockMixCnt % callbackPer) || blockMixCnt === totalBlockMix)) + onProgress(blockMixCnt / totalBlockMix); + }; + } + return { N, r, p, dkLen, blockSize32, V, B32, B, tmp, blockMixCb, asyncTick }; + } + function scryptOutput(password, dkLen, B, V, tmp) { + const res = pbkdf2(sha256, password, B, { c: 1, dkLen }); + clean(B, V, tmp); + return res; + } + function scrypt(password, salt, opts) { + const { N, r, p, dkLen, blockSize32, V, B32, B, tmp, blockMixCb } = scryptInit(password, salt, opts); + swap32IfBE(B32); + for (let pi = 0; pi < p; pi++) { + const Pi = blockSize32 * pi; + for (let i = 0; i < blockSize32; i++) + V[i] = B32[Pi + i]; + for (let i = 0, pos = 0; i < N - 1; i++) { + BlockMix(V, pos, V, pos += blockSize32, r); + blockMixCb(); + } + BlockMix(V, (N - 1) * blockSize32, B32, Pi, r); + blockMixCb(); + for (let i = 0; i < N; i++) { + const j = (B32[Pi + blockSize32 - 16] & N - 1) >>> 0; + for (let k = 0; k < blockSize32; k++) + tmp[k] = B32[Pi + k] ^ V[j * blockSize32 + k]; + BlockMix(tmp, 0, B32, Pi, r); + blockMixCb(); + } + } + swap32IfBE(B32); + return scryptOutput(password, dkLen, B, V, tmp); + } + + // node_modules/nostr-crypto-utils/dist/esm/nips/nip-49.js + function encrypt2(sec, password, logn = 16, ksb = 2) { + const salt = randomBytes(16); + const n = 2 ** logn; + const normalizedPassword = password.normalize("NFKC"); + const key = scrypt(normalizedPassword, salt, { N: n, r: 8, p: 1, dkLen: 32 }); + const nonce = randomBytes(24); + const aad = Uint8Array.from([ksb]); + const cipher = xchacha20poly1305(key, nonce, aad); + const ciphertext = cipher.encrypt(sec); + const payload = concatBytes(Uint8Array.from([2]), Uint8Array.from([logn]), salt, nonce, aad, ciphertext); + const words = bech322.toWords(payload); + return bech322.encode("ncryptsec", words, 200); + } + function decrypt2(ncryptsec, password) { + const { prefix, words } = bech322.decode(ncryptsec, 200); + if (prefix !== "ncryptsec") + throw new Error("invalid ncryptsec prefix"); + const data = new Uint8Array(bech322.fromWords(words)); + const version = data[0]; + if (version !== 2) + throw new Error(`unknown ncryptsec version: ${version}`); + const logn = data[1]; + const salt = data.subarray(2, 18); + const nonce = data.subarray(18, 42); + const ksb = data[42]; + const ciphertext = data.subarray(43); + const n = 2 ** logn; + const normalizedPassword = password.normalize("NFKC"); + const key = scrypt(normalizedPassword, salt, { N: n, r: 8, p: 1, dkLen: 32 }); + const aad = Uint8Array.from([ksb]); + const cipher = xchacha20poly1305(key, nonce, aad); + return cipher.decrypt(ciphertext); + } + + // node_modules/nostr-crypto-utils/dist/esm/utils/encoding.js + init_process(); + function hexToBytes2(hex) { + const bytes = new Uint8Array(hex.length / 2); + for (let i = 0; i < hex.length; i += 2) { + bytes[i / 2] = parseInt(hex.slice(i, i + 2), 16); + } + return bytes; + } + function bytesToHex3(bytes) { + return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join(""); + } + + // src/utilities/seedphrase.js + init_process(); + + // node_modules/@scure/bip39/index.js + init_process(); + var isJapanese = (wordlist2) => wordlist2[0] === "\u3042\u3044\u3053\u304F\u3057\u3093"; + function nfkd(str) { + if (typeof str !== "string") + throw new TypeError("invalid mnemonic type: " + typeof str); + return str.normalize("NFKD"); + } + function normalize(str) { + const norm = nfkd(str); + const words = norm.split(" "); + if (![12, 15, 18, 21, 24].includes(words.length)) + throw new Error("Invalid mnemonic"); + return { nfkd: norm, words }; + } + function aentropy(ent) { + abytes(ent); + if (![16, 20, 24, 28, 32].includes(ent.length)) + throw new Error("invalid entropy length"); + } + var calcChecksum = (entropy) => { + const bitsLeft = 8 - entropy.length / 4; + return new Uint8Array([sha256(entropy)[0] >> bitsLeft << bitsLeft]); + }; + function getCoder(wordlist2) { + if (!Array.isArray(wordlist2) || wordlist2.length !== 2048 || typeof wordlist2[0] !== "string") + throw new Error("Wordlist: expected array of 2048 strings"); + wordlist2.forEach((i) => { + if (typeof i !== "string") + throw new Error("wordlist: non-string element: " + i); + }); + return utils.chain(utils.checksum(1, calcChecksum), utils.radix2(11, true), utils.alphabet(wordlist2)); + } + function mnemonicToEntropy(mnemonic, wordlist2) { + const { words } = normalize(mnemonic); + const entropy = getCoder(wordlist2).decode(words); + aentropy(entropy); + return entropy; + } + function entropyToMnemonic(entropy, wordlist2) { + aentropy(entropy); + const words = getCoder(wordlist2).encode(entropy); + return words.join(isJapanese(wordlist2) ? "\u3000" : " "); + } + function validateMnemonic(mnemonic, wordlist2) { + try { + mnemonicToEntropy(mnemonic, wordlist2); + } catch (e) { + return false; + } + return true; + } + + // node_modules/@scure/bip39/wordlists/english.js + init_process(); + var wordlist = `abandon ability able about @@ -2046,8 +9213,3527 @@ youth zebra zero zone -zoo`.split(` -`);function ba(t){let e=at(t);return ma(e,rn)}function xa(t){let e=Vo(t.trim().toLowerCase(),rn),r=Ae(e),n=Pe(r);return{hexKey:r,pubKey:n}}function Fo(t){try{return wa(t.trim().toLowerCase(),rn)}catch{return!1}}b();async function nn(){let t=await oo();return{privateKey:t.privateKey,publicKey:t.publicKey.hex}}b();var ly=new Error("timeout while waiting for mutex to become available"),uy=new Error("mutex already locked"),Tu=new Error("request for lock canceled"),_u=function(t,e,r,n){function o(i){return i instanceof r?i:new r(function(s){s(i)})}return new(r||(r=Promise))(function(i,s){function a(f){try{l(n.next(f))}catch(u){s(u)}}function c(f){try{l(n.throw(f))}catch(u){s(u)}}function l(f){f.done?i(f.value):o(f.value).then(a,c)}l((n=n.apply(t,e||[])).next())})},$o=class{constructor(e,r=Tu){this._value=e,this._cancelError=r,this._queue=[],this._weightedWaiters=[]}acquire(e=1,r=0){if(e<=0)throw new Error(`invalid weight ${e}: must be positive`);return new Promise((n,o)=>{let i={resolve:n,reject:o,weight:e,priority:r},s=Ea(this._queue,a=>r<=a.priority);s===-1&&e<=this._value?this._dispatchItem(i):this._queue.splice(s+1,0,i)})}runExclusive(e){return _u(this,arguments,void 0,function*(r,n=1,o=0){let[i,s]=yield this.acquire(n,o);try{return yield r(i)}finally{s()}})}waitForUnlock(e=1,r=0){if(e<=0)throw new Error(`invalid weight ${e}: must be positive`);return this._couldLockImmediately(e,r)?Promise.resolve():new Promise(n=>{this._weightedWaiters[e-1]||(this._weightedWaiters[e-1]=[]),Lu(this._weightedWaiters[e-1],{resolve:n,priority:r})})}isLocked(){return this._value<=0}getValue(){return this._value}setValue(e){this._value=e,this._dispatchQueue()}release(e=1){if(e<=0)throw new Error(`invalid weight ${e}: must be positive`);this._value+=e,this._dispatchQueue()}cancel(){this._queue.forEach(e=>e.reject(this._cancelError)),this._queue=[]}_dispatchQueue(){for(this._drainUnlockWaiters();this._queue.length>0&&this._queue[0].weight<=this._value;)this._dispatchItem(this._queue.shift()),this._drainUnlockWaiters()}_dispatchItem(e){let r=this._value;this._value-=e.weight,e.resolve([r,this._newReleaser(e.weight)])}_newReleaser(e){let r=!1;return()=>{r||(r=!0,this.release(e))}}_drainUnlockWaiters(){if(this._queue.length===0)for(let e=this._value;e>0;e--){let r=this._weightedWaiters[e-1];r&&(r.forEach(n=>n.resolve()),this._weightedWaiters[e-1]=[])}else{let e=this._queue[0].priority;for(let r=this._value;r>0;r--){let n=this._weightedWaiters[r-1];if(!n)continue;let o=n.findIndex(i=>i.priority<=e);(o===-1?n:n.splice(0,o)).forEach((i=>i.resolve()))}}}_couldLockImmediately(e,r){return(this._queue.length===0||this._queue[0].prioritye.priority<=n.priority);t.splice(r+1,0,e)}function Ea(t,e){for(let r=t.length-1;r>=0;r--)if(e(t[r]))return r;return-1}var Uu=function(t,e,r,n){function o(i){return i instanceof r?i:new r(function(s){s(i)})}return new(r||(r=Promise))(function(i,s){function a(f){try{l(n.next(f))}catch(u){s(u)}}function c(f){try{l(n.throw(f))}catch(u){s(u)}}function l(f){f.done?i(f.value):o(f.value).then(a,c)}l((n=n.apply(t,e||[])).next())})},pr=class{constructor(e){this._semaphore=new $o(1,e)}acquire(){return Uu(this,arguments,void 0,function*(e=0){let[,r]=yield this._semaphore.acquire(1,e);return r})}runExclusive(e,r=0){return this._semaphore.runExclusive(()=>e(),1,r)}isLocked(){return this._semaphore.isLocked()}waitForUnlock(e=0){return this._semaphore.waitForUnlock(1,e)}release(){this._semaphore.isLocked()&&this._semaphore.release()}cancel(){return this._semaphore.cancel()}};b();b();var _=typeof browser<"u"?browser:typeof chrome<"u"?chrome:null;if(!_)throw new Error("browser-polyfill: No extension API namespace found (neither browser nor chrome).");var ae=typeof browser>"u"&&typeof chrome<"u";function ce(t,e){return(...r)=>{try{let n=e.apply(t,r);if(n&&typeof n.then=="function")return n}catch{}return new Promise((n,o)=>{e.apply(t,[...r,(...i)=>{_.runtime&&_.runtime.lastError?o(new Error(_.runtime.lastError.message)):n(i.length<=1?i[0]:i)}])})}}var N={};N.runtime={sendMessage(...t){return ae?ce(_.runtime,_.runtime.sendMessage)(...t):_.runtime.sendMessage(...t)},onMessage:_.runtime.onMessage,getURL(t){return _.runtime.getURL(t)},openOptionsPage(){return ae?ce(_.runtime,_.runtime.openOptionsPage)():_.runtime.openOptionsPage()},get id(){return _.runtime.id}};N.storage={local:{get(...t){return ae?ce(_.storage.local,_.storage.local.get)(...t):_.storage.local.get(...t)},set(...t){return ae?ce(_.storage.local,_.storage.local.set)(...t):_.storage.local.set(...t)},clear(...t){return ae?ce(_.storage.local,_.storage.local.clear)(...t):_.storage.local.clear(...t)},remove(...t){return ae?ce(_.storage.local,_.storage.local.remove)(...t):_.storage.local.remove(...t)}},sync:_.storage?.sync?{get(...t){return ae?ce(_.storage.sync,_.storage.sync.get)(...t):_.storage.sync.get(...t)},set(...t){return ae?ce(_.storage.sync,_.storage.sync.set)(...t):_.storage.sync.set(...t)},remove(...t){return ae?ce(_.storage.sync,_.storage.sync.remove)(...t):_.storage.sync.remove(...t)},clear(...t){return ae?ce(_.storage.sync,_.storage.sync.clear)(...t):_.storage.sync.clear(...t)},getBytesInUse(...t){return _.storage.sync.getBytesInUse?ae?ce(_.storage.sync,_.storage.sync.getBytesInUse)(...t):_.storage.sync.getBytesInUse(...t):Promise.resolve(0)}}:null,onChanged:_.storage?.onChanged||null};N.tabs={create(...t){return ae?ce(_.tabs,_.tabs.create)(...t):_.tabs.create(...t)},query(...t){return ae?ce(_.tabs,_.tabs.query)(...t):_.tabs.query(...t)},remove(...t){return ae?ce(_.tabs,_.tabs.remove)(...t):_.tabs.remove(...t)},update(...t){return ae?ce(_.tabs,_.tabs.update)(...t):_.tabs.update(...t)},get(...t){return ae?ce(_.tabs,_.tabs.get)(...t):_.tabs.get(...t)},getCurrent(...t){return ae?ce(_.tabs,_.tabs.getCurrent)(...t):_.tabs.getCurrent(...t)},sendMessage(...t){return ae?ce(_.tabs,_.tabs.sendMessage)(...t):_.tabs.sendMessage(...t)}};N.alarms=_.alarms?{create(...t){let e=_.alarms.create(...t);return e&&typeof e.then=="function"?e:Promise.resolve()},clear(...t){return ae?ce(_.alarms,_.alarms.clear)(...t):_.alarms.clear(...t)},onAlarm:_.alarms.onAlarm}:null;b();function gt(t){let e=new Uint8Array(t),r="";for(let n=0;ne.some(r=>t instanceof r),Ta,_a;function Ru(){return Ta||(Ta=[IDBDatabase,IDBObjectStore,IDBIndex,IDBCursor,IDBTransaction])}function Cu(){return _a||(_a=[IDBCursor.prototype.advance,IDBCursor.prototype.continue,IDBCursor.prototype.continuePrimaryKey])}var Jo=new WeakMap,Go=new WeakMap,ln=new WeakMap;function Ou(t){let e=new Promise((r,n)=>{let o=()=>{t.removeEventListener("success",i),t.removeEventListener("error",s)},i=()=>{r(_t(t.result)),o()},s=()=>{n(t.error),o()};t.addEventListener("success",i),t.addEventListener("error",s)});return ln.set(e,t),e}function Nu(t){if(Jo.has(t))return;let e=new Promise((r,n)=>{let o=()=>{t.removeEventListener("complete",i),t.removeEventListener("error",s),t.removeEventListener("abort",s)},i=()=>{r(),o()},s=()=>{n(t.error||new DOMException("AbortError","AbortError")),o()};t.addEventListener("complete",i),t.addEventListener("error",s),t.addEventListener("abort",s)});Jo.set(t,e)}var Xo={get(t,e,r){if(t instanceof IDBTransaction){if(e==="done")return Jo.get(t);if(e==="store")return r.objectStoreNames[1]?void 0:r.objectStore(r.objectStoreNames[0])}return _t(t[e])},set(t,e,r){return t[e]=r,!0},has(t,e){return t instanceof IDBTransaction&&(e==="done"||e==="store")?!0:e in t}};function Ra(t){Xo=t(Xo)}function Du(t){return Cu().includes(t)?function(...e){return t.apply(Qo(this),e),_t(this.request)}:function(...e){return _t(t.apply(Qo(this),e))}}function Mu(t){return typeof t=="function"?Du(t):(t instanceof IDBTransaction&&Nu(t),Zo(t,Ru())?new Proxy(t,Xo):t)}function _t(t){if(t instanceof IDBRequest)return Ou(t);if(Go.has(t))return Go.get(t);let e=Mu(t);return e!==t&&(Go.set(t,e),ln.set(e,t)),e}var Qo=t=>ln.get(t);function Ca(t,e,{blocked:r,upgrade:n,blocking:o,terminated:i}={}){let s=indexedDB.open(t,e),a=_t(s);return n&&s.addEventListener("upgradeneeded",c=>{n(_t(s.result),c.oldVersion,c.newVersion,_t(s.transaction),c)}),r&&s.addEventListener("blocked",c=>r(c.oldVersion,c.newVersion,c)),a.then(c=>{i&&c.addEventListener("close",()=>i()),o&&c.addEventListener("versionchange",l=>o(l.oldVersion,l.newVersion,l))}).catch(()=>{}),a}var Hu=["get","getKey","getAll","getAllKeys","count"],Ku=["put","add","delete","clear"],Yo=new Map;function La(t,e){if(!(t instanceof IDBDatabase&&!(e in t)&&typeof e=="string"))return;if(Yo.get(e))return Yo.get(e);let r=e.replace(/FromIndex$/,""),n=e!==r,o=Ku.includes(r);if(!(r in(n?IDBIndex:IDBObjectStore).prototype)||!(o||Hu.includes(r)))return;let i=async function(s,...a){let c=this.transaction(s,o?"readwrite":"readonly"),l=c.store;return n&&(l=l.index(a.shift())),(await Promise.all([l[r](...a),o&&c.done]))[0]};return Yo.set(e,i),i}Ra(t=>({...t,get:(e,r,n)=>La(e,r)||t.get(e,r,n),has:(e,r)=>!!La(e,r)||t.has(e,r)}));var Vu=["continue","continuePrimaryKey","advance"],Ua={},ei=new WeakMap,Oa=new WeakMap,Fu={get(t,e){if(!Vu.includes(e))return t[e];let r=Ua[e];return r||(r=Ua[e]=function(...n){ei.set(this,Oa.get(this)[e](...n))}),r}};async function*$u(...t){let e=this;if(e instanceof IDBCursor||(e=await e.openCursor(...t)),!e)return;e=e;let r=new Proxy(e,Fu);for(Oa.set(r,e),ln.set(r,Qo(e));e;)yield r,e=await(ei.get(r)||e.continue()),ei.delete(r)}function Pa(t,e){return e===Symbol.asyncIterator&&Zo(t,[IDBIndex,IDBObjectStore,IDBCursor])||e==="iterate"&&Zo(t,[IDBIndex,IDBObjectStore])}Ra(t=>({...t,get(e,r,n){return Pa(e,r)?$u:t.get(e,r,n)},has(e,r){return Pa(e,r)||t.has(e,r)}}));async function qu(){return await Ca("events",1,{upgrade(t){let e=t.createObjectStore("events",{keyPath:"event.id"});e.createIndex("pubkey","event.pubkey"),e.createIndex("created_at","event.created_at"),e.createIndex("kind","event.kind"),e.createIndex("host","metadata.host")}})}async function Na(t){return(await qu()).put("events",t)}b();var ju=102400,Da=8192,zu=512,ti="_chunk:",fn="_sync_meta",dn="platformSyncEnabled";var mt={P1_PROFILES:1,P2_SETTINGS:2,P3_APIKEYS:3,P4_VAULT:4},hn=N.storage.local,un=null;function Wu(t,e){let r=[];for(let o=0;o{let{hosts:s,...a}=i;return a}),o=JSON.stringify(n);e.push({key:"profiles",jsonString:o,priority:mt.P1_PROFILES,size:o.length})}if(t.profileIndex!=null){let n=JSON.stringify(t.profileIndex);e.push({key:"profileIndex",jsonString:n,priority:mt.P1_PROFILES,size:n.length})}if(t.isEncrypted!=null){let n=JSON.stringify(t.isEncrypted);e.push({key:"isEncrypted",jsonString:n,priority:mt.P1_PROFILES,size:n.length})}let r=["autoLockMinutes","version","protocol_handler",dn];for(let n of r)if(t[n]!=null){let o=JSON.stringify(t[n]);e.push({key:n,jsonString:o,priority:mt.P2_SETTINGS,size:o.length})}for(let n of Object.keys(t))if(n.startsWith("feature:")){let o=JSON.stringify(t[n]);e.push({key:n,jsonString:o,priority:mt.P2_SETTINGS,size:o.length})}if(t.apiKeyVault){let n=JSON.stringify(t.apiKeyVault);e.push({key:"apiKeyVault",jsonString:n,priority:mt.P3_APIKEYS,size:n.length})}if(t.vaultDocs&&typeof t.vaultDocs=="object"){let n=Object.values(t.vaultDocs).sort((o,i)=>(i.updatedAt||0)-(o.updatedAt||0));for(let o of n){let i=`vaultDoc:${o.path}`,s=JSON.stringify(o);e.push({key:i,jsonString:s,priority:mt.P4_VAULT,size:s.length})}}return e}async function Zu(){if(!(!N.storage.sync||!await Ka()))try{let e=await Yu();e.sort((c,l)=>c.priority-l.priority);let r=0,n=0,o={},i=[],s=!1;for(let c of e){if(s)break;let l=Wu(c.key,c.jsonString),f=0;for(let u of l)f+=u.key.length+(typeof u.value=="string"?u.value.length:JSON.stringify(u.value).length);if((r+f>ju-500||n+l.length>zu-5)&&!(c.priority<=mt.P3_APIKEYS)){s=!0;break}for(let u of l)o[u.key]=u.value,i.push(u.key);r+=f,n+=l.length}let a={lastWrittenAt:Date.now(),keys:i};o[fn]=JSON.stringify(a),await N.storage.sync.set(o);try{let c=await N.storage.sync.get(null),l=Object.keys(c).filter(f=>f!==fn&&!i.includes(f));l.length>0&&await N.storage.sync.remove(l)}catch{}}catch{}}async function Ma(){if(!N.storage.sync)return null;try{let t=await N.storage.sync.get(null);if(!t||Object.keys(t).length===0)return null;let e=t[fn];if(!e)return null;let r;try{r=JSON.parse(e)}catch{return null}let n={},o=r.keys.filter(i=>!i.startsWith(ti)&&i!==fn);for(let i of o){let s=Gu(i,t);s!=null&&(n[i]=s)}return n._syncMeta=r,n}catch{return null}}async function Ha(t){if(!t)return;let e=await hn.get(null),r={},n=!1,o=!e.profiles||e.profiles.length===0||e.profiles.length===1&&!e.profiles[0].privKey;if(t.profiles){if(o)r.profiles=t.profiles,n=!0;else if(e.profiles){let f=[...e.profiles];for(let u=0;u=f.length)f.push(h),n=!0;else{let d=f[u],y=h.updatedAt||0,p=d.updatedAt||0;y>p&&(f[u]={...h,hosts:d.hosts||{}},n=!0)}}n&&(r.profiles=f)}}t.profileIndex!=null&&o&&(r.profileIndex=t.profileIndex,n=!0),t.isEncrypted===!0&&!e.isEncrypted&&(r.isEncrypted=!0,n=!0);let i=t._syncMeta||{},s=["autoLockMinutes","version","protocol_handler",dn];for(let f of s)if(t[f]!=null&&t[f]!==e[f]){if(f==="version"&&e.version&&t.version<=e.version)continue;r[f]=t[f],n=!0}for(let f of Object.keys(t))f.startsWith("feature:")&&t[f]!==e[f]&&(r[f]=t[f],n=!0);if(t.apiKeyVault)if(!e.apiKeyVault||o)r.apiKeyVault=t.apiKeyVault,n=!0;else{let f=e.apiKeyVault.keys||{},u=t.apiKeyVault.keys||{},h={...f};for(let[d,y]of Object.entries(u)){let p=h[d];(!p||(y.updatedAt||0)>(p.updatedAt||0))&&(h[d]=y,n=!0)}n&&(r.apiKeyVault={...e.apiKeyVault,keys:h})}let a=e.vaultDocs||{},c=!1,l={...a};for(let f of Object.keys(t)){if(!f.startsWith("vaultDoc:"))continue;let u=t[f];if(!u||!u.path)continue;let h=l[u.path];(!h||(u.updatedAt||0)>(h.updatedAt||0))&&(l[u.path]=u,c=!0)}c&&(r.vaultDocs=l,n=!0),n&&await hn.set(r)}function ri(){N.storage.sync&&(un&&clearTimeout(un),un=setTimeout(()=>{un=null,Zu()},2e3))}async function Ka(){return(await hn.get({[dn]:!0}))[dn]}async function Va(){if(!(!N.storage.sync||!await Ka())){try{let e=await Ma();e&&await Ha(e)}catch{}N.storage.onChanged&&N.storage.onChanged.addListener((e,r)=>{r==="sync"&&Ma().then(n=>{n&&Ha(n)}).catch(n=>{})}),ri()}}b();var gr=N.storage.local,_e=t=>{},Le=new Map;function Fa(t){if(!t.startsWith("bunker://"))throw new Error("Invalid bunker URL: must start with bunker://");let e=new URL(t),r=e.hostname||e.pathname.replace("//","");if(!/^[0-9a-f]{64}$/i.test(r))throw new Error("Invalid bunker URL: pubkey must be 64 hex characters");let n=e.searchParams.getAll("relay");if(n.length===0)throw new Error("Invalid bunker URL: at least one relay is required");for(let i of n)try{let s=new URL(i);if(s.protocol!=="wss:"&&s.protocol!=="ws:")throw new Error(`Invalid relay protocol: ${s.protocol}`)}catch{throw new Error(`Invalid relay URL: ${i}`)}let o=e.searchParams.get("secret")||null;return{remotePubkey:r,relays:n,secret:o}}var Lt=class{constructor(e){this.url=e,this.ws=null,this.subscriptions=new Map,this.eoseCallbacks=new Map,this.connected=!1,this.reconnectTimer=null,this.reconnectAttempts=0,this.maxReconnectAttempts=5}connect(){return new Promise((e,r)=>{try{this.ws=new WebSocket(this.url)}catch(o){r(new Error(`Failed to create WebSocket: ${o.message}`));return}let n=setTimeout(()=>{this.ws?.close(),r(new Error(`Connection timeout: ${this.url}`))},1e4);this.ws.onopen=()=>{clearTimeout(n),this.connected=!0,this.reconnectAttempts=0,_e(`Connected to ${this.url}`),e()},this.ws.onerror=o=>{clearTimeout(n),_e(`WebSocket error: ${this.url}`),r(new Error(`WebSocket error: ${this.url}`))},this.ws.onclose=()=>{this.connected=!1,_e(`Disconnected from ${this.url}`),this.scheduleReconnect()},this.ws.onmessage=o=>{try{let i=JSON.parse(o.data);this.handleMessage(i)}catch(i){_e(`Failed to parse message: ${i.message}`)}}})}handleMessage(e){let[r,n,...o]=e;if(r==="EVENT"&&n&&o[0]){let i=o[0],s=this.subscriptions.get(n);s&&s(i)}else if(r==="EOSE"&&n){let i=this.eoseCallbacks.get(n);i&&(this.eoseCallbacks.delete(n),i())}else r==="OK"||r==="NOTICE"&&_e(`Relay notice: ${o[0]}`)}subscribe(e,r,n,o=null){if(!this.connected||!this.ws)throw new Error("Not connected");this.subscriptions.set(e,n),o&&this.eoseCallbacks.set(e,o),this.ws.send(JSON.stringify(["REQ",e,...r]))}unsubscribe(e){this.ws&&this.connected&&this.ws.send(JSON.stringify(["CLOSE",e])),this.subscriptions.delete(e),this.eoseCallbacks.delete(e)}publish(e){if(!this.connected||!this.ws)throw new Error("Not connected");this.ws.send(JSON.stringify(["EVENT",e]))}scheduleReconnect(){if(this.reconnectAttempts>=this.maxReconnectAttempts){_e(`Max reconnect attempts reached for ${this.url}`);return}let e=Math.min(1e3*Math.pow(2,this.reconnectAttempts),3e4);this.reconnectAttempts++,this.reconnectTimer=setTimeout(()=>{_e(`Reconnecting to ${this.url} (attempt ${this.reconnectAttempts})`),this.connect().catch(()=>{})},e)}close(){clearTimeout(this.reconnectTimer),this.maxReconnectAttempts=0,this.subscriptions.clear(),this.eoseCallbacks.clear(),this.ws&&(this.ws.close(),this.ws=null),this.connected=!1}},pn=class{constructor({remotePubkey:e,relays:r,secret:n}){this.remotePubkey=e,this.relayUrls=r,this.secret=n,this.sessionPrivkey=null,this.sessionPubkey=null,this.conversationKey=null,this.relays=[],this.pendingRequests=new Map,this.connected=!1,this.subId=`nostrkey-${crypto.randomUUID().slice(0,8)}`}async init(){if(this.sessionPrivkey)return;let e=await nn();this.sessionPrivkey=at(e.privateKey),this.sessionPubkey=e.publicKey,this.conversationKey=ke.utils.getConversationKey(this.sessionPrivkey,this.remotePubkey)}async connect(){await this.init();let e=this.relayUrls.map(o=>{let i=new Lt(o);return i.connect().then(()=>(this.relays.push(i),i))}),n=(await Promise.allSettled(e)).filter(o=>o.status==="fulfilled");if(n.length===0)throw new Error("Failed to connect to any relay");_e(`Connected to ${n.length}/${this.relayUrls.length} relays`);for(let o of this.relays)o.subscribe(this.subId,[{kinds:[24133],"#p":[this.sessionPubkey]}],i=>this.handleResponse(i));this.connected=!0,this.secret?await this.sendRequest("connect",[this.remotePubkey,this.secret]):await this.sendRequest("connect",[this.remotePubkey])}handleResponse(e){if(e.pubkey!==this.remotePubkey){_e(`Ignoring event from unknown pubkey: ${e.pubkey}`);return}try{let r=ke.decrypt(e.content,this.conversationKey),n=JSON.parse(r);_e(`Response: ${n.id} -> ${n.result?"ok":n.error}`);let o=this.pendingRequests.get(n.id);o&&(this.pendingRequests.delete(n.id),n.error?o.reject(new Error(n.error)):o.resolve(n.result))}catch(r){_e(`Failed to handle response: ${r.message}`)}}async sendRequest(e,r=[]){if(!this.connected&&e!=="connect")throw new Error("Not connected to bunker");let n=crypto.randomUUID(),o=JSON.stringify({id:n,method:e,params:r}),i=ke.encrypt(o,this.conversationKey),s=await Re({kind:24133,content:i,tags:[["p",this.remotePubkey]],created_at:Math.floor(Date.now()/1e3)},this.sessionPrivkey);for(let a of this.relays)try{a.publish(s)}catch(c){_e(`Failed to publish to ${a.url}: ${c.message}`)}return new Promise((a,c)=>{let l=setTimeout(()=>{this.pendingRequests.delete(n),c(new Error(`Request timeout: ${e}`))},3e4);this.pendingRequests.set(n,{resolve:f=>{clearTimeout(l),a(f)},reject:f=>{clearTimeout(l),c(f)}})})}async getPublicKey(){return await this.sendRequest("get_public_key")}async signEvent(e){let r=await this.sendRequest("sign_event",[JSON.stringify(e)]);return JSON.parse(r)}async nip04Encrypt(e,r){return await this.sendRequest("nip04_encrypt",[e,r])}async nip04Decrypt(e,r){return await this.sendRequest("nip04_decrypt",[e,r])}async nip44Encrypt(e,r){return await this.sendRequest("nip44_encrypt",[e,r])}async nip44Decrypt(e,r){return await this.sendRequest("nip44_decrypt",[e,r])}async ping(){return await this.sendRequest("ping")}getSessionInfo(){return{remotePubkey:this.remotePubkey,relayUrls:this.relayUrls,secret:this.secret,sessionPrivkey:Ae(this.sessionPrivkey),sessionPubkey:this.sessionPubkey}}disconnect(){for(let e of this.relays)e.unsubscribe(this.subId),e.close();this.relays=[],this.pendingRequests.clear(),this.connected=!1,_e("Disconnected from bunker")}};function Ju(t){let e=new pn({remotePubkey:t.remotePubkey,relays:t.relayUrls,secret:t.secret});return e.sessionPrivkey=at(t.sessionPrivkey),e.sessionPubkey=t.sessionPubkey,e.conversationKey=ke.utils.getConversationKey(e.sessionPrivkey,e.remotePubkey),e}async function De(t){if(Le.has(t)){let o=Le.get(t);if(o.connected)return o;o.disconnect(),Le.delete(t)}let r=(await gr.get({bunkerSessions:{}})).bunkerSessions?.[t];if(!r)throw new Error("No bunker session configured for this profile");let n=Ju(r);return await n.connect(),Le.set(t,n),n}async function $a(t,e){Le.has(t)&&(Le.get(t).disconnect(),Le.delete(t));let r=Fa(e),n=new pn(r);await n.connect();let i=(await gr.get({bunkerSessions:{}})).bunkerSessions||{};return i[t]=n.getSessionInfo(),await gr.set({bunkerSessions:i}),Le.set(t,n),n}async function qa(t){Le.has(t)&&(Le.get(t).disconnect(),Le.delete(t));let r=(await gr.get({bunkerSessions:{}})).bunkerSessions||{};delete r[t],await gr.set({bunkerSessions:r})}function ja(t){return Le.has(t)&&Le.get(t).connected}function za(t){try{return Fa(t),{valid:!0,error:null}}catch(e){return{valid:!1,error:e.message}}}b();var qe=t=>{},yn=class{constructor({relayUrls:e,userPubkey:r,secret:n}){this.relayUrls=e,this.userPubkey=r,this.secret=n,this.relays=[],this.authenticatedClients=new Set,this.subId=`bunker-srv-${crypto.randomUUID().slice(0,8)}`,this.active=!1,this._getPrivKey=null}async start({getPrivKey:e}){this._getPrivKey=e;let r=this.relayUrls.map(i=>{let s=new Lt(i);return s.connect().then(()=>(this.relays.push(s),s))}),o=(await Promise.allSettled(r)).filter(i=>i.status==="fulfilled");if(o.length===0)throw new Error("Failed to connect to any relay");qe(`Connected to ${o.length}/${this.relayUrls.length} relays`);for(let i of this.relays)i.subscribe(this.subId,[{kinds:[24133],"#p":[this.userPubkey],since:Math.floor(Date.now()/1e3)-5}],s=>this._handleRequest(s));this.active=!0,qe("Bunker server started")}stop(){for(let e of this.relays)e.unsubscribe(this.subId),e.close();this.relays=[],this.authenticatedClients.clear(),this.active=!1,this._getPrivKey=null,qe("Bunker server stopped")}getConnectionString(){let e=this.relayUrls.map(r=>`relay=${encodeURIComponent(r)}`).join("&");return`bunker://${this.userPubkey}?${e}&secret=${this.secret}`}async _handleRequest(e){let r=e.pubkey,n;try{n=await this._getPrivKey()}catch(u){qe(`Cannot get private key (locked?): ${u.message}`);return}let o;try{o=ke.utils.getConversationKey(n,r)}catch(u){qe(`Failed to derive conversation key: ${u.message}`);return}let i;try{let u=ke.decrypt(e.content,o);i=JSON.parse(u)}catch(u){qe(`Failed to decrypt request: ${u.message}`);return}let{id:s,method:a,params:c}=i;if(qe(`Request: ${a} (id=${s}) from ${r.slice(0,8)}...`),a!=="connect"&&!this.authenticatedClients.has(r)){await this._sendResponse(n,r,o,{id:s,result:null,error:"Unauthorized: send connect first"});return}let l=null,f=null;try{switch(a){case"connect":{let u=c[1];this.secret&&u!==this.secret?f="Invalid secret":(this.authenticatedClients.add(r),l="ack",qe(`Client authenticated: ${r.slice(0,8)}...`));break}case"get_public_key":l=this.userPubkey;break;case"sign_event":{let u=JSON.parse(c[0]),h=await Re(u,n);l=JSON.stringify(h);break}case"nip44_encrypt":{let u=c[0],h=c[1],d=ke.utils.getConversationKey(n,u);l=ke.encrypt(h,d);break}case"nip44_decrypt":{let u=c[0],h=c[1],d=ke.utils.getConversationKey(n,u);l=ke.decrypt(h,d);break}case"nip04_encrypt":{let u=c[0],h=c[1];l=await pt.encryptMessage(h,Ae(n),u);break}case"nip04_decrypt":{let u=c[0],h=c[1];l=await pt.decryptMessage(h,Ae(n),u);break}case"ping":l="pong";break;default:f=`Unsupported method: ${a}`}}catch(u){f=u.message,qe(`Error handling ${a}: ${u.message}`)}await this._sendResponse(n,r,o,{id:s,result:l,error:f})}async _sendResponse(e,r,n,o){let i=ke.encrypt(JSON.stringify(o),n),s=await Re({kind:24133,content:i,tags:[["p",r]],created_at:Math.floor(Date.now()/1e3)},e);for(let a of this.relays)try{a.publish(s)}catch(c){qe(`Failed to publish response to ${a.url}: ${c.message}`)}qe(`Response sent: ${o.id} ${o.error?"ERROR":"OK"}`)}};b();var gn="nostrkey:",Xu="nostrkey";function ni(t,e){return{kind:30078,content:e,tags:[["d",`${gn}${t}`],["client",Xu]],created_at:Math.floor(Date.now()/1e3)}}function oi(t,e){return{kind:5,content:"vault document deleted",tags:[["e",t],["a",`30078::${gn}${e}`]],created_at:Math.floor(Date.now()/1e3)}}function Wa(t){return{kinds:[30078],authors:[t]}}function Ga(t){if(t.kind!==30078)return null;let e=t.tags?.find(n=>n[0]==="d");if(!e||!e[1]?.startsWith(gn))return null;let r=e[1].slice(gn.length);return r?{path:r,content:t.content,createdAt:t.created_at,eventId:t.id}:null}var mn=N.storage.local,re={get:(...t)=>mn.get(...t),set:(...t)=>{let e=mn.set(...t);return e.then(()=>ri()).catch(()=>{}),e},clear:(...t)=>mn.clear(...t),remove:(...t)=>mn.remove(...t)},W=t=>{},xe={},He={mutex:new pr,release:null,tabId:null},Ct={total:0,processed:0},Je=null;function Q(t,e){e().then(r=>t(r)).catch(r=>{t(void 0)})}var ii=new Map,Qu=5,ef=1e4;function tf(t){let e=Date.now(),r=ii.get(t)||[];return r=r.filter(n=>e-n=Qu?(ii.set(t,r),!0):(r.push(e),ii.set(t,r),!1)}var be=new Map,lt=null,Pt=null,Ue=!0,Me=!1,Qt=900*1e3,Rt=null,wt=!1,wr=!0,mr=0,wn=0,Ya=new Map;(async()=>{W("[STARTUP] Reading persisted state...");let t=await re.get({autoLockMinutes:15,isEncrypted:!1,passwordHash:null,nostrAccessWhileLocked:!1,blockCrossOriginFrames:!0});W(`[STARTUP] isEncrypted=${t.isEncrypted}, passwordHash=${t.passwordHash?"EXISTS":"null"}, autoLockMinutes=${t.autoLockMinutes}`),Qt=t.autoLockMinutes*60*1e3,!t.isEncrypted&&t.passwordHash&&(W("[STARTUP] Self-healing: passwordHash exists but isEncrypted=false \u2192 fixing"),await re.set({isEncrypted:!0}),t.isEncrypted=!0),Me=t.isEncrypted,wt=!!t.nostrAccessWhileLocked,wr=t.blockCrossOriginFrames!==!1,Ue=Me,W(`[STARTUP] Final state: encryptionEnabled=${Me}, locked=${Ue}`);try{await Va(),W("[STARTUP] Platform sync initialized")}catch(e){W(`[STARTUP] Platform sync init error (non-fatal): ${e.message}`)}try{if(typeof browser<"u"&&browser.runtime.sendNativeMessage){let e=await browser.runtime.sendNativeMessage("com.nostrkey.Extension",{action:"getSharedProfiles"});if(e&&e.profiles&&e.profiles.length>0){let r=await re.get({profiles:[]}),n=rf(r.profiles,e.profiles);n.changed&&(await re.set({profiles:n.profiles}),W(`[STARTUP] Merged ${e.profiles.length} shared profile(s) from iOS app`))}}}catch(e){W(`[STARTUP] Shared profiles check skipped: ${e.message}`)}})();function rf(t,e){let r=!1,n=[...t];for(let o of e){if(!o.pubKey)continue;let i=n.findIndex(s=>s.pubKey===o.pubKey);if(i===-1)n.push({name:o.name||"Shared Profile",privKey:o.privKey||"",pubKey:o.pubKey,hosts:{},relays:o.relays||[],type:"local",updatedAt:o.lastSyncedAt?new Date(o.lastSyncedAt).getTime():Date.now()}),r=!0;else{let s=n[i],a=s.updatedAt||0,c=o.lastSyncedAt?new Date(o.lastSyncedAt).getTime():0;c>a&&o.privKey&&!s.privKey&&(n[i]={...s,privKey:o.privKey,name:o.name||s.name,relays:o.relays||s.relays,updatedAt:c},r=!0)}}return{profiles:n,changed:r}}var ai="nostrkey-auto-lock";function Ut(){if(Rt&&(clearTimeout(Rt),Rt=null),Ue||Qt<=0){N.alarms?.clear(ai).catch(()=>{});return}N.alarms?N.alarms.create(ai,{delayInMinutes:Qt/6e4}):Rt=setTimeout(()=>{li()},Qt)}N.alarms?.onAlarm&&N.alarms.onAlarm.addListener(t=>{t.name===ai&&li()});var Za=new pr;async function li(){let t=await Za.acquire();try{wt||be.clear(),lt=null,Pt=null,Ue=!0,Rt&&(clearTimeout(Rt),Rt=null),W(`Session locked. Keys retained: ${wt&&be.size>0}`)}finally{t()}}async function si(t){let e=await Za.acquire();try{let r=Date.now();if(r=3){let a=3e4*Math.pow(2,Math.floor((mr-3)/3));wn=Date.now()+a,W(`[SECURITY] ${mr} failed attempts. Cooldown: ${a/1e3}s`)}return{success:!1,error:"Invalid password"}}mr=0,wn=0;let o=await $e(),i=!1;for(let a=0;a{if(W(t),nf.has(t.kind)&&!of(e))return W(`[SECURITY] Blocked ${t.kind} from non-extension sender`),r({success:!1,error:"Unauthorized sender"}),!0;let n=crypto.randomUUID(),o;switch(t.kind){case"closePrompt":return He.release?.(),r(!0),!0;case"allowed":return Ut(),ci(t),r(!0),!0;case"denied":return En(t),r(!0),!0;case"generatePrivateKey":return(async()=>{try{let i=await af();r(i)}catch{r(null)}})(),!0;case"savePrivateKey":return Ut(),uf(t.payload);case"getNpub":return(async()=>{try{let i=await ff(t.payload);r(i)}catch{r(null)}})(),!0;case"getNsec":return Ut(),(async()=>{try{let i=await Xa(t.payload);r(i)}catch{r(null)}})(),!0;case"calcPubKey":return r(Pe(t.payload)),!0;case"npubEncode":return r(Te.npubEncode(t.payload)),!0;case"copy":return typeof navigator<"u"&&navigator.clipboard?.writeText?navigator.clipboard.writeText(t.payload).then(()=>r(!0)).catch(()=>r(!1)):r(!1),!0;case"isLocked":return(async()=>{try{let i=await Ja();W(`[isLocked] Sending response: ${i}`),r(i)}catch(i){W(`[isLocked] Error: ${i.message}`),r(!1)}})(),!0;case"isEncrypted":return(async()=>{try{let i=await re.get({isEncrypted:!1,passwordHash:null});W(`[isEncrypted] storage: isEncrypted=${i.isEncrypted}, passwordHash=${i.passwordHash?"EXISTS":"null"}`),!i.isEncrypted&&i.passwordHash&&(W("[isEncrypted] Self-healing: passwordHash exists but flag=false"),await re.set({isEncrypted:!0}),i.isEncrypted=!0),Me=i.isEncrypted,W(`[isEncrypted] Sending response: ${Me}`),r(Me)}catch(i){W(`[isEncrypted] Error: ${i.message}`),r(!1)}})(),!0;case"hasEncryptedData":return(async()=>{try{let i=await re.get({passwordHash:null,profiles:[]}),s=!!i.passwordHash,a=0;if(W(`[hasEncryptedData] passwordHash=${s}, profiles=${Array.isArray(i.profiles)?i.profiles.length:"not-array"}`),Array.isArray(i.profiles))for(let l=0;l0;W(`[hasEncryptedData] Result: found=${c}, hasPasswordHash=${s}, encryptedProfiles=${a}`),c&&!Me&&(W("[hasEncryptedData] Self-healing: setting isEncrypted=true, locked=true"),await re.set({isEncrypted:!0}),Me=!0,Ue=!0),r({found:c,hasPasswordHash:s,encryptedProfiles:a})}catch{r({found:!1,hasPasswordHash:!1,encryptedProfiles:0})}})(),!0;case"unlock":return Q(r,()=>si(t.payload)),!0;case"lock":return li().then(()=>r(!0)),!0;case"setPassword":return(async()=>{try{await lf(),await Ba(t.payload),Me=!0;let i=await si(t.payload);N.runtime.sendMessage({kind:"passwordStateChanged",hasPassword:!0}).catch(()=>{}),N.runtime.sendMessage({kind:"backupNeeded"}).catch(()=>{}),r(i)}catch(i){r({success:!1,error:i.message})}})(),!0;case"changePassword":return(async()=>{try{let{oldPassword:i,newPassword:s}=t.payload;if(!await cn(i)){r({success:!1,error:"Invalid current password"});return}await Sa(i,s);let c=await si(s);N.runtime.sendMessage({kind:"passwordStateChanged",hasPassword:!0}).catch(()=>{}),N.runtime.sendMessage({kind:"backupNeeded"}).catch(()=>{}),r(c)}catch(i){r({success:!1,error:i.message})}})(),!0;case"removePassword":return(async()=>{try{await Aa(t.payload),be.clear(),lt=null,Pt=null,Ue=!1,Me=!1,N.runtime.sendMessage({kind:"passwordStateChanged",hasPassword:!1}).catch(()=>{}),r({success:!0})}catch(i){r({success:!1,error:i.message})}})(),!0;case"resetAllData":return(async()=>{try{await re.clear(),be.clear(),lt=null,Pt=null,Ue=!1,Me=!1,wt=!1,wr=!0,await re.set({profiles:[{name:"Default Nostr Profile",privKey:"",pubKey:""}],profileIndex:0,isEncrypted:!1,passwordHash:null,passwordSalt:null}),N.runtime.sendMessage({kind:"dataReset"}).catch(()=>{}),r({success:!0})}catch(i){r({success:!1,error:i.message})}})(),!0;case"setAutoLockTimeout":{let i=[0,5,15,30,60,90,180],s=Number(t.payload);return i.includes(s)?(Qt=s*60*1e3,re.set({autoLockMinutes:s}),Ut(),r(!0),!0):(r(!1),!0)}case"getAutoLockTimeout":return Q(r,async()=>{let{autoLockMinutes:i}=await re.get({autoLockMinutes:15});return i}),!0;case"resetAutoLock":return Ut(),r(!0),!0;case"getNostrAccessWhileLocked":return r(wt),!0;case"setNostrAccessWhileLocked":return wt=!!t.payload,re.set({nostrAccessWhileLocked:!!t.payload}),!t.payload&&Ue&&be.clear(),r(!0),!0;case"getBlockCrossOriginFrames":return r(wr),!0;case"setBlockCrossOriginFrames":return wr=!!t.payload,re.set({blockCrossOriginFrames:!!t.payload}),r(!0),!0;case"getActiveProfileInfo":return(async()=>{try{let i=await ne(),a=(await $e())[i];if(!a){W("[getActiveProfileInfo] No profile found at index "+i),r({name:"Unknown",npub:"",hasKeys:!1});return}let c="";a.type==="bunker"&&a.remotePubkey?c=Te.npubEncode(a.remotePubkey):a.pubKey&&(c=Te.npubEncode(a.pubKey));let l={name:a.name||"Unnamed Profile",npub:c,hasKeys:be.has(i),isBunker:a.type==="bunker"};W("[getActiveProfileInfo] Sending: "+JSON.stringify(l)),r(l)}catch(i){W("[getActiveProfileInfo] Error: "+i.message),r({name:"Error",npub:"",hasKeys:!1})}})(),!0;case"ncryptsec.decrypt":return Q(r,async()=>{try{let{ncryptsec:i,password:s}=t.payload;return{success:!0,hexKey:Ae(pa(i,s))}}catch(i){return{success:!1,error:i.message||"Decryption failed"}}}),!0;case"ncryptsec.encrypt":return Q(r,async()=>{try{let{profileIndex:i,password:s}=t.payload,a=await se(i);if(a?.type==="bunker")return{success:!1,error:"Cannot export bunker profile as ncryptsec"};let c=await br(i,a);return{success:!0,ncryptsec:ha(at(c),s)}}catch(i){return{success:!1,error:i.message||"Encryption failed"}}}),!0;case"seedPhrase.fromKey":return Q(r,async()=>{try{let i=t.payload,s=await se(i);if(s?.type==="bunker")return{success:!1,error:"Cannot export bunker profile as seed phrase"};let a=await br(i,s);return{success:!0,seedPhrase:ba(a)}}catch(i){return{success:!1,error:i.message||"Failed to generate seed phrase"}}}),!0;case"seedPhrase.toKey":return Q(r,async()=>{try{let{hexKey:i,pubKey:s}=xa(t.payload);return{success:!0,hexKey:i,pubKey:s}}catch(i){return{success:!1,error:i.message||"Invalid seed phrase"}}}),!0;case"seedPhrase.validate":return r(Fo(t.payload)),!0;case"getProfileType":return Q(r,async()=>{let i=t.payload??await ne();return(await se(i))?.type||"local"}),!0;case"bunker.connect":return Q(r,async()=>{try{let{profileIndex:i,bunkerUrl:s}=t.payload,c=await(await $a(i,s)).getPublicKey(),l=await $e();return l[i].remotePubkey=c,l[i].bunkerUrl=s,await re.set({profiles:l}),{success:!0,remotePubkey:c}}catch(i){return{success:!1,error:i.message}}}),!0;case"bunker.disconnect":return Q(r,async()=>{try{let i=t.payload;return await qa(i),{success:!0}}catch(i){return{success:!1,error:i.message}}}),!0;case"bunker.status":return Q(r,async()=>{let i=t.payload??await ne();return{connected:ja(i)}}),!0;case"bunker.ping":return Q(r,async()=>{try{let i=t.payload??await ne();return{success:!0,result:await(await De(i)).ping()}}catch(i){return{success:!1,error:i.message}}}),!0;case"bunker.validateUrl":return r(za(t.payload)),!0;case"bunkerServer.start":return Q(r,async()=>{try{Je&&(Je.stop(),Je=null);let i=await ct(),s=t.payload?.relayUrls||["wss://relay.nostrkey.com"],a=crypto.randomUUID().replace(/-/g,"").slice(0,16),c=new yn({relayUrls:s,userPubkey:i,secret:a});return await c.start({getPrivKey:je}),Je=c,{success:!0,uri:c.getConnectionString()}}catch(i){return{success:!1,error:i.message}}}),!0;case"bunkerServer.stop":return Q(r,async()=>(Je&&(Je.stop(),Je=null),{success:!0})),!0;case"bunkerServer.status":return r({active:!!Je?.active,uri:Je?.getConnectionString()||null,clientCount:Je?.authenticatedClients.size||0}),!0;case"vault.publish":return Q(r,async()=>{try{let{path:i,content:s}=t.payload,a=await ct(),c=await bn({pubKey:a,plainText:s}),l=ni(i,c),f=await ne(),u=await se(f),h;if(u.type==="bunker")h=await(await De(f)).signEvent(l);else{let d=await je();h=await Re(l,d)}return await Xt("write",async d=>{for(let y of d)try{y.publish(h)}catch{}}),{success:!0,eventId:h.id,createdAt:h.created_at}}catch(i){return{success:!1,error:i.message}}}),!0;case"vault.fetch":return Q(r,async()=>{try{let i=await ct(),s=Wa(i),a=[];await Xt("read",async u=>{let h=u.map(d=>new Promise(y=>{let p=`vault-${crypto.randomUUID().slice(0,8)}`,w=setTimeout(()=>{try{d.unsubscribe(p)}catch{}y()},15e3);d.subscribe(p,[s],k=>{a.push(k)},()=>{clearTimeout(w);try{d.unsubscribe(p)}catch{}y()})}));await Promise.all(h)});let c=new Map;for(let u of a){let h=Ga(u);if(!h)continue;let d=c.get(h.path);(!d||h.createdAt>d.createdAt)&&c.set(h.path,{event:u,parsed:h})}let l=[],f=await ct();for(let{event:u,parsed:h}of c.values())try{let d=await xn({pubKey:f,cipherText:u.content});l.push({path:h.path,content:d,createdAt:h.createdAt,eventId:h.eventId})}catch{}return{success:!0,documents:l}}catch(i){return{success:!1,error:i.message}}}),!0;case"vault.delete":return Q(r,async()=>{try{let{path:i,eventId:s}=t.payload,a=oi(s,i),c=await ne(),l=await se(c),f;if(l.type==="bunker")f=await(await De(c)).signEvent(a);else{let u=await je();f=await Re(a,u)}return await Xt("write",async u=>{for(let h of u)try{h.publish(f)}catch{}}),{success:!0}}catch(i){return{success:!1,error:i.message}}}),!0;case"vault.getRelays":return Q(r,async()=>{try{let s=(await vn()).relays||[],a=s.filter(l=>l.read).map(l=>l.url),c=s.filter(l=>l.write).map(l=>l.url);return{read:a,write:c}}catch{return{read:[],write:[]}}}),!0;case"apikeys.publish":return Q(r,async()=>{try{let{keys:i}=t.payload,s=await ct(),a=JSON.stringify(i),c=await bn({pubKey:s,plainText:a}),l=ni("vault/api-keys",c),f=await ne(),u=await se(f),h;if(u.type==="bunker")h=await(await De(f)).signEvent(l);else{let d=await je();h=await Re(l,d)}return await Xt("write",async d=>{for(let y of d)try{y.publish(h)}catch{}}),{success:!0,eventId:h.id,createdAt:h.created_at}}catch(i){return{success:!1,error:i.message}}}),!0;case"apikeys.fetch":return Q(r,async()=>{try{let i=await ct(),s={kinds:[30078],authors:[i],"#d":["nostrkey:vault/api-keys"]},a=[];await Xt("read",async u=>{let h=u.map(d=>new Promise(y=>{let p=`apikeys-${crypto.randomUUID().slice(0,8)}`,w=setTimeout(()=>{try{d.unsubscribe(p)}catch{}y()},15e3);d.subscribe(p,[s],k=>{a.push(k)},()=>{clearTimeout(w);try{d.unsubscribe(p)}catch{}y()})}));await Promise.all(h)});let c=null;for(let u of a)(!c||u.created_at>c.created_at)&&(c=u);if(!c)return{success:!0,keys:null,eventId:null,createdAt:null};let l=await xn({pubKey:i,cipherText:c.content});return{success:!0,keys:JSON.parse(l),eventId:c.id,createdAt:c.created_at}}catch(i){return{success:!1,error:i.message}}}),!0;case"apikeys.delete":return Q(r,async()=>{try{let{eventId:i}=t.payload,s=oi(i,"vault/api-keys"),a=await ne(),c=await se(a),l;if(c.type==="bunker")l=await(await De(a)).signEvent(s);else{let f=await je();l=await Re(s,f)}return await Xt("write",async f=>{for(let u of f)try{u.publish(l)}catch{}}),{success:!0}}catch(i){return{success:!1,error:i.message}}}),!0;case"apikeys.encrypt":return Q(r,async()=>{try{let{plainText:i}=t.payload,s=await ct();return{success:!0,cipherText:await bn({pubKey:s,plainText:i})}}catch(i){return{success:!1,error:i.message}}}),!0;case"apikeys.decrypt":return Q(r,async()=>{try{let{cipherText:i}=t.payload,s=await ct();return{success:!0,plainText:await xn({pubKey:s,cipherText:i})}}catch(i){return{success:!1,error:i.message}}}),!0;case"backup.export":return Q(r,async()=>{if(!lt)return{success:!1,error:"Extension must be unlocked to create a backup"};let i=await re.get({profiles:[],profileIndex:0,isEncrypted:!1,passwordHash:null,passwordSalt:null,apiKeyVault:null,vaultDocs:null,nostrAccessWhileLocked:!1,blockCrossOriginFrames:!0,autoLockMinutes:15,version:null}),s=JSON.stringify(i),a=await qo(s,lt,Pt),c=N.runtime.getManifest?.()?.version||"unknown";return{success:!0,envelope:{format:"nostrkey-backup",version:1,createdAt:new Date().toISOString(),extensionVersion:c,profileCount:Array.isArray(i.profiles)?i.profiles.length:0,payload:JSON.parse(a)}}}),!0;case"backup.import":return Q(r,async()=>{try{let{envelope:i,password:s}=t.payload;if(!i||i.format!=="nostrkey-backup")return{success:!1,error:"Not a valid NostrKey backup file"};if(typeof i.version!="number"||i.version>1)return{success:!1,error:"Backup version not supported. Update NostrKey and try again."};let a=JSON.stringify(i.payload),c;try{c=await Tt(a,s)}catch{return{success:!1,error:"Wrong password \u2014 could not decrypt backup"}}let l=JSON.parse(c);await re.set(l),Me=!!l.isEncrypted,Ue=!1;let f=crypto.getRandomValues(new Uint8Array(16));if(lt=await yr(s,f),Pt=f,wt=l.nostrAccessWhileLocked!==!1,wr=l.blockCrossOriginFrames!==!1,typeof l.autoLockMinutes=="number"&&(Qt=l.autoLockMinutes*60*1e3),be.clear(),Array.isArray(l.profiles))for(let h=0;h{let{protocol_handler:i}=await re.get(["protocol_handler"]);if(!i)return!1;let{url:s}=t.payload,a=s.split("nostr:")[1];if(!a)return!1;try{let c=Te.decode(a),{type:l,data:f}=c,u={raw:a,hrp:l,hex:l==="naddr"?c.author||a:f||a,p_or_e:{npub:"p",note:"e",nprofile:"p",nevent:"e",naddr:"a"}[l]||"",u_or_n:{npub:"u",note:"n",nprofile:"u",nevent:"n",naddr:"n"}[l]||"",relay0:c.relays?.[0]||"",relay1:c.relays?.[1]||"",relay2:c.relays?.[2]||""},h=i;for(let[d,y]of Object.entries(u))h=h.replace(new RegExp(`\\{ *${d} *\\}`,"g"),y);return h}catch{return!1}}),!0;case"getPubKey":case"signEvent":case"nip04.encrypt":case"nip04.decrypt":case"nip44.encrypt":case"nip44.decrypt":case"getRelays":case"addRelay":case"exportProfile":return xe[n]=r,Object.keys(xe).length===1&&(Ct={total:0,processed:0}),Ct.total++,cf(n,t),setTimeout(()=>{xe[n]&&En({payload:n,origKind:t.kind,host:t.host}),He.release?.()},1e4),!0;default:return!1}});async function sf(){if(He.tabId!==null)try{await N.tabs.get(He.tabId)}catch{He.release?.(),He.tabId=null}}async function af(){return(await nn()).privateKey}async function cf(t,{kind:e,host:r,payload:n}){if(r){let p=Date.now(),w=Ya.get(r)||{count:0,resetAt:p+6e4};if(p>w.resetAt&&(w.count=0,w.resetAt=p+6e4),w.count++,Ya.set(r,w),w.count>5){W(`[SECURITY] Rate limited ${r} \u2014 ${w.count} requests in 60s`);let k=xe[t];delete xe[t],k?.({error:"rate_limited",message:"Too many requests. Please wait a moment."});return}}let o=await ne();if(!((await se(o))?.type==="bunker")&&(e!=="getPubKey"&&e!=="getRelays"&&e!=="addRelay"&&e!=="exportProfile")&&await Ja()&&!(wt&&be.has(o))){let w=be.size===0;try{let[O]=await N.tabs.query({active:!0,currentWindow:!0});O?.id&&N.tabs.sendMessage(O.id,{kind:"showLockedSheet",firstUnlock:w}).catch(()=>{})}catch{}let k=xe[t];delete xe[t],k?.({error:"locked",message:"Extension is locked. Please unlock with your master password."});return}if(tf(r)){let p=xe[t];delete xe[t],p?.({error:"rate_limited",message:"Too many requests. Please wait."}),W(`Rate limited: ${r}`);return}await sf(),He.release=await He.mutex.acquire(),Ct.processed++;let c=Ct.processed,l=Ct.total,f=e==="signEvent"?`signEvent:${n.kind}`:e,u=await ka(r,f);if(u==="allow"){ci({payload:t,origKind:e,event:n,remember:!1,host:r}),He.release();return}if(u==="deny"){En({payload:t,origKind:e,host:r}),He.release();return}try{let[p]=await N.tabs.query({active:!0,currentWindow:!0});if(p?.id){let w=await N.tabs.sendMessage(p.id,{kind:"showPermissionSheet",host:r,permissionKind:e,queuePosition:c,queueTotal:l});if(w){w.allowed?ci({payload:t,origKind:e,event:n,remember:w.remember,host:r}):En({payload:t,origKind:e,event:n,remember:w.remember,host:r}),He.release();return}}}catch(p){W("Bottom sheet unavailable, falling back to tab:",p.message)}let h=new URLSearchParams({uuid:t,kind:e,host:r,payload:JSON.stringify(n||!1),queuePosition:c,queueTotal:l}),d=await N.tabs.getCurrent(),y=await N.tabs.create({url:N.runtime.getURL(`permission/permission.html?${h.toString()}`),openerTabId:d?.id});return He.tabId=y.id,!0}function ci({payload:t,origKind:e,event:r,remember:n,host:o}){let i=xe[t];if(delete xe[t],Object.keys(xe).length===0&&(Ct={total:0,processed:0}),n){let s=e==="signEvent"?`signEvent:${r.kind}`:e;zo(o,s,"allow")}if(i){let s=a=>{W(`Error in ${e}: ${a.message}`),i({error:"bunker_error",message:a.message})};switch(e){case"getPubKey":ct().then(a=>i(a)).catch(s);break;case"signEvent":df(r,o).then(a=>i(a)).catch(s);break;case"nip04.encrypt":hf(r).then(a=>i(a)).catch(s);break;case"nip04.decrypt":pf(r).then(a=>i(a)).catch(s);break;case"nip44.encrypt":bn(r).then(a=>i(a)).catch(s);break;case"nip44.decrypt":xn(r).then(a=>i(a)).catch(s);break;case"getRelays":yf().then(a=>i(a)).catch(s);break;case"addRelay":gf(r.url).then(a=>i(a)).catch(s);break;case"exportProfile":mf().then(a=>i(a)).catch(s);break}}}function En({origKind:t,host:e,payload:r,remember:n,event:o}){let i=xe[r];if(delete xe[r],Object.keys(xe).length===0&&(Ct={total:0,processed:0}),n){let s=t==="signEvent"?`signEvent:${o.kind}`:t;zo(e,s,"deny")}return i?.(void 0),!1}async function lf(){let t=await $e(),e=!1;for(let r=0;r=o.length)throw new Error("Invalid profile index");let i=Pe(n);return o[t].pubKey=i,await Wo()&<?(o[t].privKey=await qo(n,lt,Pt),be.set(t,n)):o[t].privKey=n,await re.set({profiles:o}),!0}async function Xa(t){let e=await se(t);if(e.type==="bunker")return null;let r=await br(t,e);return Te.nsecEncode(r)}async function ff(t){let e=await se(t);if(!e)return null;if(e.type==="bunker")return e.remotePubkey?Te.npubEncode(e.remotePubkey):null;if(e.pubKey)return Te.npubEncode(e.pubKey);try{let r=await br(t,e);if(!r||typeof r!="string"||r.length!==64)return null;let n=Pe(r);return Te.npubEncode(n)}catch{return null}}async function br(t,e){if(Ze(e.privKey)){if(be.has(t))return be.get(t);throw new Error("Extension is locked \u2014 cannot access private key")}return e.privKey}async function je(){let t=await ne(),e=await vn(),r=await br(t,e);return at(r)}async function ct(){let t=await ne(),e=await se(t);if(e.type==="bunker"){if(e.remotePubkey)return e.remotePubkey;let i=await(await De(t)).getPublicKey(),s=await an("profiles");return s[t].remotePubkey=i,await re.set({profiles:s}),i}if(e.pubKey)return e.pubKey;let r=await je();return Pe(Ae(r))}async function vn(){let t=await ne();return(await an("profiles"))[t]}async function df(t,e){t=JSON.parse(JSON.stringify(t));let r=await ne();if((await se(r)).type==="bunker")t=await(await De(r)).signEvent(t);else{let o=await je();t=await Re(t,o)}return Na({event:t,metadata:{host:e,signed_at:Math.round(Date.now()/1e3)}}),t}async function hf({pubKey:t,plainText:e}){let r=await ne();if((await se(r)).type==="bunker")return(await De(r)).nip04Encrypt(t,e);let o=await je();return pt.encryptMessage(e,Ae(o),t)}async function pf({pubKey:t,cipherText:e}){let r=await ne();if((await se(r)).type==="bunker")return(await De(r)).nip04Decrypt(t,e);let o=await je();return pt.decryptMessage(e,Ae(o),t)}async function bn({pubKey:t,plainText:e}){let r=await ne();if((await se(r)).type==="bunker")return(await De(r)).nip44Encrypt(t,e);let o=await je(),i=st.v2.utils.getConversationKey(o,t);return st.v2.encrypt(e,i)}async function xn({pubKey:t,cipherText:e}){let r=await ne();if((await se(r)).type==="bunker")return(await De(r)).nip44Decrypt(t,e);let o=await je(),i=st.v2.utils.getConversationKey(o,t);return st.v2.decrypt(e,i)}async function yf(){let e=(await vn()).relays,r={};return e.forEach(n=>{let{url:o,read:i,write:s}=n;r[o]={read:i,write:s}}),r}async function gf(t){let e;try{e=new URL(t)}catch{throw new Error("Invalid URL")}if(e.protocol!=="wss:")throw new Error("Must be a wss:// URL");let r=await $e(),n=await ne(),o=r[n];return o.relays||(o.relays=[]),o.relays.some(i=>i.url===e.href)?{success:!0,message:"Relay already exists"}:(o.relays.push({url:e.href,read:!0,write:!0}),o.updatedAt=Math.floor(Date.now()/1e3),await re.set({profiles:r}),{success:!0,message:"Relay added"})}async function mf(){let t=await ne(),e=await se(t);if(!e)throw new Error("No active profile");if(e.type==="bunker")return{name:e.name,type:"bunker",bunkerUrl:e.bunkerUrl||"",exportedAt:new Date().toISOString(),source:"NostrKey"};let r="";e.pubKey&&(r=Te.npubEncode(e.pubKey));let n="";try{n=await Xa(t)}catch{throw new Error("Cannot export while locked. Please unlock first.")}return{name:e.name,npub:r,nsec:n,relays:(e.relays||[]).map(o=>o.url),exportedAt:new Date().toISOString(),source:"NostrKey"}}async function Xt(t,e){let o=((await vn()).relays||[]).filter(a=>t==="read"?a.read:a.write).map(a=>a.url);if(o.length===0)throw new Error("No relays configured");let i=[],s=o.map(async a=>{let c=new Lt(a);try{await c.connect(),i.push(c)}catch{}});if(await Promise.allSettled(s),i.length===0)throw new Error("Failed to connect to any relay");try{await e(i)}finally{for(let a of i)a.close()}}})(); +zoo`.split("\n"); + + // src/utilities/seedphrase.js + function keyToSeedPhrase(hexKey) { + const bytes = hexToBytes2(hexKey); + return entropyToMnemonic(bytes, wordlist); + } + function seedPhraseToKey(phrase) { + const entropy = mnemonicToEntropy(phrase.trim().toLowerCase(), wordlist); + const hexKey = bytesToHex3(entropy); + const pubKey = getPublicKeySync(hexKey); + return { hexKey, pubKey }; + } + function isValidSeedPhrase(phrase) { + try { + return validateMnemonic(phrase.trim().toLowerCase(), wordlist); + } catch { + return false; + } + } + + // src/utilities/keys.js + init_process(); + async function generateKeyPair2() { + const keyPair = await generateKeyPair(); + return { + privateKey: keyPair.privateKey, + publicKey: keyPair.publicKey.hex + }; + } + + // node_modules/async-mutex/index.mjs + init_process(); + var E_TIMEOUT = new Error("timeout while waiting for mutex to become available"); + var E_ALREADY_LOCKED = new Error("mutex already locked"); + var E_CANCELED = new Error("request for lock canceled"); + var __awaiter$2 = function(thisArg, _arguments, P, generator) { + function adopt(value) { + return value instanceof P ? value : new P(function(resolve) { + resolve(value); + }); + } + return new (P || (P = Promise))(function(resolve, reject) { + function fulfilled(value) { + try { + step(generator.next(value)); + } catch (e) { + reject(e); + } + } + function rejected(value) { + try { + step(generator["throw"](value)); + } catch (e) { + reject(e); + } + } + function step(result) { + result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); + } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); + }; + var Semaphore = class { + constructor(_value, _cancelError = E_CANCELED) { + this._value = _value; + this._cancelError = _cancelError; + this._queue = []; + this._weightedWaiters = []; + } + acquire(weight = 1, priority = 0) { + if (weight <= 0) + throw new Error(`invalid weight ${weight}: must be positive`); + return new Promise((resolve, reject) => { + const task = { resolve, reject, weight, priority }; + const i = findIndexFromEnd(this._queue, (other) => priority <= other.priority); + if (i === -1 && weight <= this._value) { + this._dispatchItem(task); + } else { + this._queue.splice(i + 1, 0, task); + } + }); + } + runExclusive(callback_1) { + return __awaiter$2(this, arguments, void 0, function* (callback, weight = 1, priority = 0) { + const [value, release] = yield this.acquire(weight, priority); + try { + return yield callback(value); + } finally { + release(); + } + }); + } + waitForUnlock(weight = 1, priority = 0) { + if (weight <= 0) + throw new Error(`invalid weight ${weight}: must be positive`); + if (this._couldLockImmediately(weight, priority)) { + return Promise.resolve(); + } else { + return new Promise((resolve) => { + if (!this._weightedWaiters[weight - 1]) + this._weightedWaiters[weight - 1] = []; + insertSorted(this._weightedWaiters[weight - 1], { resolve, priority }); + }); + } + } + isLocked() { + return this._value <= 0; + } + getValue() { + return this._value; + } + setValue(value) { + this._value = value; + this._dispatchQueue(); + } + release(weight = 1) { + if (weight <= 0) + throw new Error(`invalid weight ${weight}: must be positive`); + this._value += weight; + this._dispatchQueue(); + } + cancel() { + this._queue.forEach((entry) => entry.reject(this._cancelError)); + this._queue = []; + } + _dispatchQueue() { + this._drainUnlockWaiters(); + while (this._queue.length > 0 && this._queue[0].weight <= this._value) { + this._dispatchItem(this._queue.shift()); + this._drainUnlockWaiters(); + } + } + _dispatchItem(item) { + const previousValue = this._value; + this._value -= item.weight; + item.resolve([previousValue, this._newReleaser(item.weight)]); + } + _newReleaser(weight) { + let called = false; + return () => { + if (called) + return; + called = true; + this.release(weight); + }; + } + _drainUnlockWaiters() { + if (this._queue.length === 0) { + for (let weight = this._value; weight > 0; weight--) { + const waiters = this._weightedWaiters[weight - 1]; + if (!waiters) + continue; + waiters.forEach((waiter) => waiter.resolve()); + this._weightedWaiters[weight - 1] = []; + } + } else { + const queuedPriority = this._queue[0].priority; + for (let weight = this._value; weight > 0; weight--) { + const waiters = this._weightedWaiters[weight - 1]; + if (!waiters) + continue; + const i = waiters.findIndex((waiter) => waiter.priority <= queuedPriority); + (i === -1 ? waiters : waiters.splice(0, i)).forEach(((waiter) => waiter.resolve())); + } + } + } + _couldLockImmediately(weight, priority) { + return (this._queue.length === 0 || this._queue[0].priority < priority) && weight <= this._value; + } + }; + function insertSorted(a, v) { + const i = findIndexFromEnd(a, (other) => v.priority <= other.priority); + a.splice(i + 1, 0, v); + } + function findIndexFromEnd(a, predicate) { + for (let i = a.length - 1; i >= 0; i--) { + if (predicate(a[i])) { + return i; + } + } + return -1; + } + var __awaiter$1 = function(thisArg, _arguments, P, generator) { + function adopt(value) { + return value instanceof P ? value : new P(function(resolve) { + resolve(value); + }); + } + return new (P || (P = Promise))(function(resolve, reject) { + function fulfilled(value) { + try { + step(generator.next(value)); + } catch (e) { + reject(e); + } + } + function rejected(value) { + try { + step(generator["throw"](value)); + } catch (e) { + reject(e); + } + } + function step(result) { + result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); + } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); + }; + var Mutex = class { + constructor(cancelError) { + this._semaphore = new Semaphore(1, cancelError); + } + acquire() { + return __awaiter$1(this, arguments, void 0, function* (priority = 0) { + const [, releaser] = yield this._semaphore.acquire(1, priority); + return releaser; + }); + } + runExclusive(callback, priority = 0) { + return this._semaphore.runExclusive(() => callback(), 1, priority); + } + isLocked() { + return this._semaphore.isLocked(); + } + waitForUnlock(priority = 0) { + return this._semaphore.waitForUnlock(1, priority); + } + release() { + if (this._semaphore.isLocked()) + this._semaphore.release(); + } + cancel() { + return this._semaphore.cancel(); + } + }; + + // src/utilities/utils.js + init_process(); + + // src/utilities/browser-polyfill.js + init_process(); + var _browser = typeof browser !== "undefined" ? browser : typeof chrome !== "undefined" ? chrome : null; + if (!_browser) { + throw new Error("browser-polyfill: No extension API namespace found (neither browser nor chrome)."); + } + var isChrome = typeof browser === "undefined" && typeof chrome !== "undefined"; + function promisify(context, method) { + return (...args) => { + try { + const result = method.apply(context, args); + if (result && typeof result.then === "function") { + return result; + } + } catch (_) { + } + return new Promise((resolve, reject) => { + method.apply(context, [ + ...args, + (...cbArgs) => { + if (_browser.runtime && _browser.runtime.lastError) { + reject(new Error(_browser.runtime.lastError.message)); + } else { + resolve(cbArgs.length <= 1 ? cbArgs[0] : cbArgs); + } + } + ]); + }); + }; + } + var api = {}; + api.runtime = { + /** + * sendMessage – always returns a Promise. + */ + sendMessage(...args) { + if (!isChrome) { + return _browser.runtime.sendMessage(...args); + } + return promisify(_browser.runtime, _browser.runtime.sendMessage)(...args); + }, + /** + * onMessage – thin wrapper so callers use a consistent reference. + * The listener signature is (message, sender, sendResponse). + * On Chrome the listener can return `true` to keep the channel open, + * or return a Promise (MV3). Safari / Firefox expect a Promise return. + */ + onMessage: _browser.runtime.onMessage, + /** + * getURL – synchronous on all browsers. + */ + getURL(path) { + return _browser.runtime.getURL(path); + }, + /** + * openOptionsPage + */ + openOptionsPage() { + if (!isChrome) { + return _browser.runtime.openOptionsPage(); + } + return promisify(_browser.runtime, _browser.runtime.openOptionsPage)(); + }, + /** + * Expose the id for convenience. + */ + get id() { + return _browser.runtime.id; + } + }; + api.storage = { + local: { + get(...args) { + if (!isChrome) { + return _browser.storage.local.get(...args); + } + return promisify(_browser.storage.local, _browser.storage.local.get)(...args); + }, + set(...args) { + if (!isChrome) { + return _browser.storage.local.set(...args); + } + return promisify(_browser.storage.local, _browser.storage.local.set)(...args); + }, + clear(...args) { + if (!isChrome) { + return _browser.storage.local.clear(...args); + } + return promisify(_browser.storage.local, _browser.storage.local.clear)(...args); + }, + remove(...args) { + if (!isChrome) { + return _browser.storage.local.remove(...args); + } + return promisify(_browser.storage.local, _browser.storage.local.remove)(...args); + } + }, + // --- storage.sync ---------------------------------------------------------- + // Null when the browser doesn't support sync (older Safari, etc.) + sync: _browser.storage?.sync ? { + get(...args) { + if (!isChrome) { + return _browser.storage.sync.get(...args); + } + return promisify(_browser.storage.sync, _browser.storage.sync.get)(...args); + }, + set(...args) { + if (!isChrome) { + return _browser.storage.sync.set(...args); + } + return promisify(_browser.storage.sync, _browser.storage.sync.set)(...args); + }, + remove(...args) { + if (!isChrome) { + return _browser.storage.sync.remove(...args); + } + return promisify(_browser.storage.sync, _browser.storage.sync.remove)(...args); + }, + clear(...args) { + if (!isChrome) { + return _browser.storage.sync.clear(...args); + } + return promisify(_browser.storage.sync, _browser.storage.sync.clear)(...args); + }, + getBytesInUse(...args) { + if (!_browser.storage.sync.getBytesInUse) { + return Promise.resolve(0); + } + if (!isChrome) { + return _browser.storage.sync.getBytesInUse(...args); + } + return promisify(_browser.storage.sync, _browser.storage.sync.getBytesInUse)(...args); + } + } : null, + // --- storage.onChanged ----------------------------------------------------- + onChanged: _browser.storage?.onChanged || null + }; + api.tabs = { + create(...args) { + if (!isChrome) { + return _browser.tabs.create(...args); + } + return promisify(_browser.tabs, _browser.tabs.create)(...args); + }, + query(...args) { + if (!isChrome) { + return _browser.tabs.query(...args); + } + return promisify(_browser.tabs, _browser.tabs.query)(...args); + }, + remove(...args) { + if (!isChrome) { + return _browser.tabs.remove(...args); + } + return promisify(_browser.tabs, _browser.tabs.remove)(...args); + }, + update(...args) { + if (!isChrome) { + return _browser.tabs.update(...args); + } + return promisify(_browser.tabs, _browser.tabs.update)(...args); + }, + get(...args) { + if (!isChrome) { + return _browser.tabs.get(...args); + } + return promisify(_browser.tabs, _browser.tabs.get)(...args); + }, + getCurrent(...args) { + if (!isChrome) { + return _browser.tabs.getCurrent(...args); + } + return promisify(_browser.tabs, _browser.tabs.getCurrent)(...args); + }, + sendMessage(...args) { + if (!isChrome) { + return _browser.tabs.sendMessage(...args); + } + return promisify(_browser.tabs, _browser.tabs.sendMessage)(...args); + } + }; + api.alarms = _browser.alarms ? { + create(...args) { + const result = _browser.alarms.create(...args); + return result && typeof result.then === "function" ? result : Promise.resolve(); + }, + clear(...args) { + if (!isChrome) { + return _browser.alarms.clear(...args); + } + return promisify(_browser.alarms, _browser.alarms.clear)(...args); + }, + onAlarm: _browser.alarms.onAlarm + } : null; + + // src/utilities/crypto.js + init_process(); + var PBKDF2_ITERATIONS = 6e5; + var SALT_BYTES = 16; + var IV_BYTES = 12; + function arrayBufferToBase64(buffer) { + const bytes = new Uint8Array(buffer); + let binary = ""; + for (let i = 0; i < bytes.length; i++) { + binary += String.fromCharCode(bytes[i]); + } + return btoa(binary); + } + function base64ToArrayBuffer(base642) { + const binary = atob(base642); + const bytes = new Uint8Array(binary.length); + for (let i = 0; i < binary.length; i++) { + bytes[i] = binary.charCodeAt(i); + } + return bytes.buffer; + } + async function deriveKey(password, salt) { + const enc = new TextEncoder(); + const keyMaterial = await crypto.subtle.importKey( + "raw", + enc.encode(password), + "PBKDF2", + false, + ["deriveKey"] + ); + return crypto.subtle.deriveKey( + { + name: "PBKDF2", + salt: salt instanceof Uint8Array ? salt : new Uint8Array(salt), + iterations: PBKDF2_ITERATIONS, + hash: "SHA-256" + }, + keyMaterial, + { name: "AES-GCM", length: 256 }, + false, + ["encrypt", "decrypt"] + ); + } + async function encryptWithKey(plaintext, key, salt) { + const iv = crypto.getRandomValues(new Uint8Array(IV_BYTES)); + const enc = new TextEncoder(); + const ciphertext = await crypto.subtle.encrypt( + { name: "AES-GCM", iv }, + key, + enc.encode(plaintext) + ); + return JSON.stringify({ + salt: arrayBufferToBase64(salt), + iv: arrayBufferToBase64(iv), + ciphertext: arrayBufferToBase64(ciphertext) + }); + } + async function encrypt4(plaintext, password) { + const salt = crypto.getRandomValues(new Uint8Array(SALT_BYTES)); + const iv = crypto.getRandomValues(new Uint8Array(IV_BYTES)); + const key = await deriveKey(password, salt); + const enc = new TextEncoder(); + const ciphertext = await crypto.subtle.encrypt( + { name: "AES-GCM", iv }, + key, + enc.encode(plaintext) + ); + return JSON.stringify({ + salt: arrayBufferToBase64(salt), + iv: arrayBufferToBase64(iv), + ciphertext: arrayBufferToBase64(ciphertext) + }); + } + async function decrypt4(encryptedData, password) { + const { salt, iv, ciphertext } = JSON.parse(encryptedData); + const saltBuf = new Uint8Array(base64ToArrayBuffer(salt)); + const ivBuf = new Uint8Array(base64ToArrayBuffer(iv)); + const ctBuf = base64ToArrayBuffer(ciphertext); + const key = await deriveKey(password, saltBuf); + const plainBuf = await crypto.subtle.decrypt( + { name: "AES-GCM", iv: ivBuf }, + key, + ctBuf + ); + const dec = new TextDecoder(); + return dec.decode(plainBuf); + } + async function hashPassword(password, salt) { + if (!salt) { + salt = crypto.getRandomValues(new Uint8Array(SALT_BYTES)); + } else if (typeof salt === "string") { + salt = new Uint8Array(base64ToArrayBuffer(salt)); + } + const enc = new TextEncoder(); + const keyMaterial = await crypto.subtle.importKey( + "raw", + enc.encode(password), + "PBKDF2", + false, + ["deriveBits"] + ); + const hashBits = await crypto.subtle.deriveBits( + { + name: "PBKDF2", + salt, + iterations: PBKDF2_ITERATIONS, + hash: "SHA-256" + }, + keyMaterial, + 256 + ); + return { + hash: arrayBufferToBase64(hashBits), + salt: arrayBufferToBase64(salt) + }; + } + async function verifyPassword(password, storedHash, storedSalt) { + const { hash } = await hashPassword(password, storedSalt); + return hash === storedHash; + } + + // src/utilities/utils.js + var storage = api.storage.local; + var RECOMMENDED_RELAYS = [ + new URL("wss://relay.damus.io"), + new URL("wss://relay.primal.net"), + new URL("wss://relay.snort.social"), + new URL("wss://relay.getalby.com/v1"), + new URL("wss://nos.lol") + ]; + async function getProfiles() { + let profiles = await storage.get({ profiles: [] }); + return profiles.profiles; + } + async function getProfile(index) { + let profiles = await getProfiles(); + return profiles[index]; + } + async function getProfileIndex() { + const index = await storage.get({ profileIndex: 0 }); + return index.profileIndex; + } + async function get(item) { + return (await storage.get(item))[item]; + } + async function getPermission(host, action) { + let index = await getProfileIndex(); + let profile = await getProfile(index); + return profile?.hosts?.[host]?.[action] || "ask"; + } + async function setPermission(host, action, perm, index = null) { + let profiles = await getProfiles(); + if (!index) { + index = await getProfileIndex(); + } + let profile = profiles[index]; + let newPerms = profile.hosts[host] || {}; + newPerms = { ...newPerms, [action]: perm }; + profile.hosts[host] = newPerms; + profile.updatedAt = Math.floor(Date.now() / 1e3); + profiles[index] = profile; + await storage.set({ profiles }); + } + async function isEncrypted() { + const data = await storage.get({ isEncrypted: false, passwordHash: null, profiles: [] }); + if (data.isEncrypted) return true; + if (data.passwordHash) { + await storage.set({ isEncrypted: true }); + return true; + } + for (const profile of data.profiles) { + if (isEncryptedBlob(profile.privKey)) { + await storage.set({ isEncrypted: true }); + return true; + } + } + return false; + } + async function setPasswordHash(password) { + const { hash, salt } = await hashPassword(password); + await storage.set({ + passwordHash: hash, + passwordSalt: salt, + isEncrypted: true + }); + } + async function checkPassword(password) { + const data = await storage.get({ + passwordHash: null, + passwordSalt: null + }); + if (!data.passwordHash || !data.passwordSalt) return false; + return verifyPassword(password, data.passwordHash, data.passwordSalt); + } + async function removePasswordProtection(password) { + const valid = await checkPassword(password); + if (!valid) throw new Error("Invalid password"); + let profiles = await getProfiles(); + for (let i = 0; i < profiles.length; i++) { + if (profiles[i].type === "bunker") continue; + if (isEncryptedBlob(profiles[i].privKey)) { + profiles[i].privKey = await decrypt4(profiles[i].privKey, password); + } + } + await storage.set({ + profiles, + isEncrypted: false, + passwordHash: null, + passwordSalt: null + }); + } + async function encryptAllKeys(password) { + let profiles = await getProfiles(); + for (let i = 0; i < profiles.length; i++) { + if (profiles[i].type === "bunker") continue; + if (!isEncryptedBlob(profiles[i].privKey)) { + profiles[i].privKey = await encrypt4(profiles[i].privKey, password); + } + } + await setPasswordHash(password); + await storage.set({ profiles }); + } + async function changePasswordForKeys(oldPassword, newPassword) { + let profiles = await getProfiles(); + for (let i = 0; i < profiles.length; i++) { + if (profiles[i].type === "bunker") continue; + let hex = profiles[i].privKey; + if (isEncryptedBlob(hex)) { + hex = await decrypt4(hex, oldPassword); + } + profiles[i].privKey = await encrypt4(hex, newPassword); + } + const { hash, salt } = await hashPassword(newPassword); + await storage.set({ + profiles, + passwordHash: hash, + passwordSalt: salt, + isEncrypted: true + }); + } + async function getDecryptedPrivKey(profile, password) { + if (profile.type === "bunker") return ""; + if (isEncryptedBlob(profile.privKey)) { + return decrypt4(profile.privKey, password); + } + return profile.privKey; + } + function isEncryptedBlob(value) { + if (typeof value !== "string") return false; + try { + const parsed = JSON.parse(value); + return !!(parsed.salt && parsed.iv && parsed.ciphertext); + } catch { + return false; + } + } + + // src/utilities/db.js + init_process(); + + // node_modules/idb/build/index.js + init_process(); + var instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c); + var idbProxyableTypes; + var cursorAdvanceMethods; + function getIdbProxyableTypes() { + return idbProxyableTypes || (idbProxyableTypes = [ + IDBDatabase, + IDBObjectStore, + IDBIndex, + IDBCursor, + IDBTransaction + ]); + } + function getCursorAdvanceMethods() { + return cursorAdvanceMethods || (cursorAdvanceMethods = [ + IDBCursor.prototype.advance, + IDBCursor.prototype.continue, + IDBCursor.prototype.continuePrimaryKey + ]); + } + var transactionDoneMap = /* @__PURE__ */ new WeakMap(); + var transformCache = /* @__PURE__ */ new WeakMap(); + var reverseTransformCache = /* @__PURE__ */ 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); + }); + reverseTransformCache.set(promise, request); + return promise; + } + function cacheDonePromiseForTransaction(tx) { + if (transactionDoneMap.has(tx)) + return; + const done = new Promise((resolve, reject) => { + const unlisten = () => { + tx.removeEventListener("complete", complete2); + tx.removeEventListener("error", error); + tx.removeEventListener("abort", error); + }; + const complete2 = () => { + resolve(); + unlisten(); + }; + const error = () => { + reject(tx.error || new DOMException("AbortError", "AbortError")); + unlisten(); + }; + tx.addEventListener("complete", complete2); + tx.addEventListener("error", error); + tx.addEventListener("abort", error); + }); + transactionDoneMap.set(tx, done); + } + var idbProxyTraps = { + get(target, prop, receiver) { + if (target instanceof IDBTransaction) { + if (prop === "done") + return transactionDoneMap.get(target); + if (prop === "store") { + return receiver.objectStoreNames[1] ? void 0 : receiver.objectStore(receiver.objectStoreNames[0]); + } + } + 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) { + if (getCursorAdvanceMethods().includes(func)) { + return function(...args) { + func.apply(unwrap(this), args); + return wrap(this.request); + }; + } + return function(...args) { + return wrap(func.apply(unwrap(this), args)); + }; + } + function transformCachableValue(value) { + if (typeof value === "function") + return wrapFunction(value); + if (value instanceof IDBTransaction) + cacheDonePromiseForTransaction(value); + if (instanceOfAny(value, getIdbProxyableTypes())) + return new Proxy(value, idbProxyTraps); + return value; + } + function wrap(value) { + if (value instanceof IDBRequest) + return promisifyRequest(value); + if (transformCache.has(value)) + return transformCache.get(value); + const newValue = transformCachableValue(value); + if (newValue !== value) { + transformCache.set(value, newValue); + reverseTransformCache.set(newValue, value); + } + return newValue; + } + var unwrap = (value) => reverseTransformCache.get(value); + 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; + } + var readMethods = ["get", "getKey", "getAll", "getAllKeys", "count"]; + var writeMethods = ["put", "add", "delete", "clear"]; + var cachedMethods = /* @__PURE__ */ 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) { + const tx = this.transaction(storeName, isWrite ? "readwrite" : "readonly"); + let target2 = tx.store; + if (useIndex) + target2 = target2.index(args.shift()); + return (await Promise.all([ + target2[targetFuncName](...args), + isWrite && tx.done + ]))[0]; + }; + cachedMethods.set(prop, method); + return method; + } + 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) + })); + var advanceMethodProps = ["continue", "continuePrimaryKey", "advance"]; + var methodMap = {}; + var advanceResults = /* @__PURE__ */ new WeakMap(); + var ittrProxiedCursorToOriginalProxy = /* @__PURE__ */ new WeakMap(); + var 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) { + 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); + reverseTransformCache.set(proxiedCursor, unwrap(cursor)); + while (cursor) { + yield proxiedCursor; + 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); + } + })); + + // src/utilities/db.js + async function openEventsDb() { + return await openDB("events", 1, { + upgrade(db) { + const events = db.createObjectStore("events", { + keyPath: "event.id" + }); + events.createIndex("pubkey", "event.pubkey"); + events.createIndex("created_at", "event.created_at"); + events.createIndex("kind", "event.kind"); + events.createIndex("host", "metadata.host"); + } + }); + } + async function saveEvent(event) { + let db = await openEventsDb(); + return db.put("events", event); + } + + // src/utilities/sync-manager.js + init_process(); + var SYNC_QUOTA = 102400; + var MAX_ITEM = 8192; + var MAX_ITEMS = 512; + var CHUNK_PREFIX = "_chunk:"; + var SYNC_META_KEY = "_sync_meta"; + var LOCAL_ENABLED_KEY = "platformSyncEnabled"; + var PRIORITY = { + P1_PROFILES: 1, + P2_SETTINGS: 2, + P3_APIKEYS: 3, + P4_VAULT: 4 + }; + var storage2 = api.storage.local; + var pushTimer = null; + function chunkValue(key, jsonString) { + const chunks = []; + for (let i = 0; i < jsonString.length; i += MAX_ITEM - 100) { + chunks.push(jsonString.slice(i, i + MAX_ITEM - 100)); + } + if (chunks.length === 1) { + return [{ key, value: jsonString }]; + } + const entries = []; + for (let i = 0; i < chunks.length; i++) { + entries.push({ key: `${CHUNK_PREFIX}${key}:${i}`, value: chunks[i] }); + } + entries.push({ key, value: JSON.stringify({ __chunked: true, count: chunks.length }) }); + return entries; + } + function reassembleFromSyncData(key, syncData) { + try { + const meta = typeof syncData[key] === "string" ? JSON.parse(syncData[key]) : syncData[key]; + if (!meta || !meta.__chunked) { + return typeof syncData[key] === "string" ? JSON.parse(syncData[key]) : syncData[key]; + } + let combined = ""; + for (let i = 0; i < meta.count; i++) { + const chunkKey = `${CHUNK_PREFIX}${key}:${i}`; + if (syncData[chunkKey] == null) return null; + combined += syncData[chunkKey]; + } + return JSON.parse(combined); + } catch { + return null; + } + } + async function buildSyncPayload() { + const all = await storage2.get(null); + const entries = []; + if (all.profiles) { + const cleanProfiles = all.profiles.map((p) => { + const { hosts, ...rest } = p; + return rest; + }); + const json = JSON.stringify(cleanProfiles); + entries.push({ key: "profiles", jsonString: json, priority: PRIORITY.P1_PROFILES, size: json.length }); + } + if (all.profileIndex != null) { + const json = JSON.stringify(all.profileIndex); + entries.push({ key: "profileIndex", jsonString: json, priority: PRIORITY.P1_PROFILES, size: json.length }); + } + const settingsKeys = ["autoLockMinutes", "version", "protocol_handler", LOCAL_ENABLED_KEY]; + for (const k of settingsKeys) { + if (all[k] != null) { + const json = JSON.stringify(all[k]); + entries.push({ key: k, jsonString: json, priority: PRIORITY.P2_SETTINGS, size: json.length }); + } + } + for (const k of Object.keys(all)) { + if (k.startsWith("feature:")) { + const json = JSON.stringify(all[k]); + entries.push({ key: k, jsonString: json, priority: PRIORITY.P2_SETTINGS, size: json.length }); + } + } + if (all.apiKeyVault) { + const json = JSON.stringify(all.apiKeyVault); + entries.push({ key: "apiKeyVault", jsonString: json, priority: PRIORITY.P3_APIKEYS, size: json.length }); + } + if (all.vaultDocs && typeof all.vaultDocs === "object") { + const docs = Object.values(all.vaultDocs).sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0)); + for (const doc of docs) { + const docKey = `vaultDoc:${doc.path}`; + const json = JSON.stringify(doc); + entries.push({ key: docKey, jsonString: json, priority: PRIORITY.P4_VAULT, size: json.length }); + } + } + return entries; + } + async function pushToSync() { + if (!api.storage.sync) return; + const enabled = await isSyncEnabled(); + if (!enabled) return; + try { + const entries = await buildSyncPayload(); + entries.sort((a, b) => a.priority - b.priority); + let usedBytes = 0; + let usedItems = 0; + const syncPayload = {}; + const allSyncKeys = []; + let budgetExhausted = false; + for (const entry of entries) { + if (budgetExhausted) break; + const chunks = chunkValue(entry.key, entry.jsonString); + let entrySize = 0; + for (const c of chunks) { + entrySize += c.key.length + (typeof c.value === "string" ? c.value.length : JSON.stringify(c.value).length); + } + if (usedBytes + entrySize > SYNC_QUOTA - 500 || usedItems + chunks.length > MAX_ITEMS - 5) { + if (entry.priority <= PRIORITY.P3_APIKEYS) { + } else { + console.warn(`[SyncManager] Budget exhausted at priority ${entry.priority}, skipping remaining entries`); + budgetExhausted = true; + break; + } + } + for (const c of chunks) { + syncPayload[c.key] = c.value; + allSyncKeys.push(c.key); + } + usedBytes += entrySize; + usedItems += chunks.length; + } + const meta = { + lastWrittenAt: Date.now(), + keys: allSyncKeys + }; + syncPayload[SYNC_META_KEY] = JSON.stringify(meta); + await api.storage.sync.set(syncPayload); + try { + const existing = await api.storage.sync.get(null); + const orphanKeys = Object.keys(existing).filter( + (k) => k !== SYNC_META_KEY && !allSyncKeys.includes(k) + ); + if (orphanKeys.length > 0) { + await api.storage.sync.remove(orphanKeys); + } + } catch { + } + console.log(`[SyncManager] Pushed ${allSyncKeys.length} entries (${usedBytes} bytes) to sync storage`); + } catch (e) { + console.error("[SyncManager] pushToSync error:", e); + } + } + async function pullFromSync() { + if (!api.storage.sync) return null; + try { + const raw = await api.storage.sync.get(null); + if (!raw || Object.keys(raw).length === 0) return null; + const metaStr = raw[SYNC_META_KEY]; + if (!metaStr) return null; + let meta; + try { + meta = JSON.parse(metaStr); + } catch { + return null; + } + const result = {}; + const dataKeys = meta.keys.filter((k) => !k.startsWith(CHUNK_PREFIX) && k !== SYNC_META_KEY); + for (const key of dataKeys) { + const value = reassembleFromSyncData(key, raw); + if (value != null) { + result[key] = value; + } + } + result._syncMeta = meta; + return result; + } catch (e) { + console.error("[SyncManager] pullFromSync error:", e); + return null; + } + } + async function mergeIntoLocal(syncData) { + if (!syncData) return; + const local = await storage2.get(null); + const { updates, changed } = computeMergeUpdates(local, syncData); + if (changed) { + await storage2.set(updates); + console.log("[SyncManager] Merged sync data into local:", Object.keys(updates)); + } + } + function computeMergeUpdates(local, syncData) { + const updates = {}; + let changed = false; + if (!syncData) return { updates, changed }; + const hasIdentity = (p) => !!(p.privKey || p.pubKey || p.type === "bunker" || p.bunkerUrl || p.remotePubkey); + const isFresh = !local.profiles || local.profiles.length === 0 || !local.profiles.some(hasIdentity); + if (syncData.profiles) { + if (isFresh) { + updates.profiles = syncData.profiles; + changed = true; + } else if (local.profiles) { + const merged = [...local.profiles]; + const indexByPubkey = /* @__PURE__ */ new Map(); + merged.forEach((p, i) => { + if (p.pubKey) indexByPubkey.set(p.pubKey, i); + }); + for (const syncProfile of syncData.profiles) { + const localIdx = syncProfile.pubKey != null ? indexByPubkey.get(syncProfile.pubKey) : void 0; + if (localIdx === void 0) { + merged.push(syncProfile); + if (syncProfile.pubKey) indexByPubkey.set(syncProfile.pubKey, merged.length - 1); + changed = true; + } else { + const localProfile = merged[localIdx]; + const syncTime = syncProfile.updatedAt || 0; + const localTime = localProfile.updatedAt || 0; + if (syncTime > localTime) { + merged[localIdx] = { ...syncProfile, hosts: localProfile.hosts || {} }; + changed = true; + } + } + } + if (changed) updates.profiles = merged; + } + } + if (syncData.profileIndex != null && isFresh) { + updates.profileIndex = syncData.profileIndex; + changed = true; + } + const syncMeta = syncData._syncMeta || {}; + const settingsKeys = ["autoLockMinutes", "version", "protocol_handler", LOCAL_ENABLED_KEY]; + for (const key of settingsKeys) { + if (syncData[key] != null && syncData[key] !== local[key]) { + if (key === "version" && local.version && syncData.version <= local.version) continue; + updates[key] = syncData[key]; + changed = true; + } + } + for (const key of Object.keys(syncData)) { + if (key.startsWith("feature:") && syncData[key] !== local[key]) { + updates[key] = syncData[key]; + changed = true; + } + } + if (syncData.apiKeyVault) { + if (!local.apiKeyVault || isFresh) { + updates.apiKeyVault = syncData.apiKeyVault; + changed = true; + } else { + const localKeys = local.apiKeyVault.keys || {}; + const syncKeys = syncData.apiKeyVault.keys || {}; + const merged = { ...localKeys }; + for (const [id, syncKey] of Object.entries(syncKeys)) { + const localKey = merged[id]; + if (!localKey || (syncKey.updatedAt || 0) > (localKey.updatedAt || 0)) { + merged[id] = syncKey; + changed = true; + } + } + if (changed) { + updates.apiKeyVault = { ...local.apiKeyVault, keys: merged }; + } + } + } + const localDocs = local.vaultDocs || {}; + let docsChanged = false; + const mergedDocs = { ...localDocs }; + for (const key of Object.keys(syncData)) { + if (!key.startsWith("vaultDoc:")) continue; + const doc = syncData[key]; + if (!doc || !doc.path) continue; + const localDoc = mergedDocs[doc.path]; + if (!localDoc || (doc.updatedAt || 0) > (localDoc.updatedAt || 0)) { + mergedDocs[doc.path] = doc; + docsChanged = true; + } + } + if (docsChanged) { + updates.vaultDocs = mergedDocs; + changed = true; + } + return { updates, changed }; + } + function scheduleSyncPush() { + if (!api.storage.sync) return; + if (pushTimer) clearTimeout(pushTimer); + pushTimer = setTimeout(() => { + pushTimer = null; + pushToSync(); + }, 2e3); + } + async function isSyncEnabled() { + const data = await storage2.get({ [LOCAL_ENABLED_KEY]: true }); + return data[LOCAL_ENABLED_KEY]; + } + async function initSync() { + if (!api.storage.sync) { + console.log("[SyncManager] storage.sync not available \u2014 skipping"); + return; + } + const enabled = await isSyncEnabled(); + if (!enabled) { + console.log("[SyncManager] Platform sync disabled"); + return; + } + try { + const syncData = await pullFromSync(); + if (syncData) { + await mergeIntoLocal(syncData); + console.log("[SyncManager] Initial pull+merge complete"); + } else { + console.log("[SyncManager] No sync data found \u2014 fresh sync"); + } + } catch (e) { + console.error("[SyncManager] Initial pull failed:", e); + } + if (api.storage.onChanged) { + api.storage.onChanged.addListener((changes, areaName) => { + if (areaName !== "sync") return; + console.log("[SyncManager] Remote sync change detected"); + pullFromSync().then((syncData) => { + if (syncData) mergeIntoLocal(syncData); + }).catch((e) => { + console.error("[SyncManager] Remote merge error:", e); + }); + }); + } + scheduleSyncPush(); + } + + // src/utilities/nip46.js + init_process(); + var storage3 = api.storage.local; + var log = (msg) => console.log("NIP-46: ", msg); + var sessions = /* @__PURE__ */ new Map(); + function parseBunkerUrl(url) { + if (!url.startsWith("bunker://")) { + throw new Error("Invalid bunker URL: must start with bunker://"); + } + const parsed = new URL(url); + const remotePubkey = parsed.hostname || parsed.pathname.replace("//", ""); + if (!/^[0-9a-f]{64}$/i.test(remotePubkey)) { + throw new Error("Invalid bunker URL: pubkey must be 64 hex characters"); + } + const relays = parsed.searchParams.getAll("relay"); + if (relays.length === 0) { + throw new Error("Invalid bunker URL: at least one relay is required"); + } + for (const relay of relays) { + try { + const r = new URL(relay); + if (r.protocol !== "wss:" && r.protocol !== "ws:") { + throw new Error(`Invalid relay protocol: ${r.protocol}`); + } + } catch (e) { + throw new Error(`Invalid relay URL: ${relay}`); + } + } + const secret = parsed.searchParams.get("secret") || null; + return { remotePubkey, relays, secret }; + } + var RelayConnection = class { + constructor(url) { + this.url = url; + this.ws = null; + this.subscriptions = /* @__PURE__ */ new Map(); + this.eoseCallbacks = /* @__PURE__ */ new Map(); + this.connected = false; + this.reconnectTimer = null; + this.reconnectAttempts = 0; + this.maxReconnectAttempts = 5; + } + connect() { + return new Promise((resolve, reject) => { + try { + this.ws = new WebSocket(this.url); + } catch (e) { + reject(new Error(`Failed to create WebSocket: ${e.message}`)); + return; + } + const timeout = setTimeout(() => { + this.ws?.close(); + reject(new Error(`Connection timeout: ${this.url}`)); + }, 1e4); + this.ws.onopen = () => { + clearTimeout(timeout); + this.connected = true; + this.reconnectAttempts = 0; + log(`Connected to ${this.url}`); + resolve(); + }; + this.ws.onerror = (err) => { + clearTimeout(timeout); + log(`WebSocket error: ${this.url}`); + reject(new Error(`WebSocket error: ${this.url}`)); + }; + this.ws.onclose = () => { + this.connected = false; + log(`Disconnected from ${this.url}`); + this.scheduleReconnect(); + }; + this.ws.onmessage = (msg) => { + try { + const data = JSON.parse(msg.data); + this.handleMessage(data); + } catch (e) { + log(`Failed to parse message: ${e.message}`); + } + }; + }); + } + handleMessage(data) { + const [type, subId, ...rest] = data; + if (type === "EVENT" && subId && rest[0]) { + const event = rest[0]; + const handler = this.subscriptions.get(subId); + if (handler) { + handler(event); + } + } else if (type === "EOSE" && subId) { + const eoseHandler = this.eoseCallbacks.get(subId); + if (eoseHandler) { + this.eoseCallbacks.delete(subId); + eoseHandler(); + } + } else if (type === "OK") { + } else if (type === "NOTICE") { + log(`Relay notice: ${rest[0]}`); + } + } + subscribe(subId, filters, onEvent, onEose = null) { + if (!this.connected || !this.ws) { + throw new Error("Not connected"); + } + this.subscriptions.set(subId, onEvent); + if (onEose) { + this.eoseCallbacks.set(subId, onEose); + } + this.ws.send(JSON.stringify(["REQ", subId, ...filters])); + } + unsubscribe(subId) { + if (this.ws && this.connected) { + this.ws.send(JSON.stringify(["CLOSE", subId])); + } + this.subscriptions.delete(subId); + this.eoseCallbacks.delete(subId); + } + publish(event) { + if (!this.connected || !this.ws) { + throw new Error("Not connected"); + } + this.ws.send(JSON.stringify(["EVENT", event])); + } + scheduleReconnect() { + if (this.reconnectAttempts >= this.maxReconnectAttempts) { + log(`Max reconnect attempts reached for ${this.url}`); + return; + } + const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), 3e4); + this.reconnectAttempts++; + this.reconnectTimer = setTimeout(() => { + log(`Reconnecting to ${this.url} (attempt ${this.reconnectAttempts})`); + this.connect().catch(() => { + }); + }, delay); + } + close() { + clearTimeout(this.reconnectTimer); + this.maxReconnectAttempts = 0; + this.subscriptions.clear(); + this.eoseCallbacks.clear(); + if (this.ws) { + this.ws.close(); + this.ws = null; + } + this.connected = false; + } + }; + var BunkerSession = class { + constructor({ remotePubkey, relays, secret }) { + this.remotePubkey = remotePubkey; + this.relayUrls = relays; + this.secret = secret; + this.sessionPrivkey = null; + this.sessionPubkey = null; + this.conversationKey = null; + this.relays = []; + this.pendingRequests = /* @__PURE__ */ new Map(); + this.connected = false; + this.subId = `nostrkey-${crypto.randomUUID().slice(0, 8)}`; + } + /** + * Initialize the ephemeral session keypair (async) + */ + async init() { + if (this.sessionPrivkey) return; + const keyPair = await generateKeyPair2(); + this.sessionPrivkey = hexToBytes2(keyPair.privateKey); + this.sessionPubkey = keyPair.publicKey; + this.conversationKey = v2.utils.getConversationKey( + this.sessionPrivkey, + this.remotePubkey + ); + } + /** + * Connect to all relays and subscribe for responses + */ + async connect() { + await this.init(); + const connections = this.relayUrls.map((url) => { + const relay = new RelayConnection(url); + return relay.connect().then(() => { + this.relays.push(relay); + return relay; + }); + }); + const results = await Promise.allSettled(connections); + const connected = results.filter((r) => r.status === "fulfilled"); + if (connected.length === 0) { + throw new Error("Failed to connect to any relay"); + } + log(`Connected to ${connected.length}/${this.relayUrls.length} relays`); + for (const relay of this.relays) { + relay.subscribe( + this.subId, + [{ kinds: [24133], "#p": [this.sessionPubkey] }], + (event) => this.handleResponse(event) + ); + } + this.connected = true; + if (this.secret) { + await this.sendRequest("connect", [this.remotePubkey, this.secret]); + } else { + await this.sendRequest("connect", [this.remotePubkey]); + } + } + /** + * Handle an incoming NIP-46 response event + */ + handleResponse(event) { + if (event.pubkey !== this.remotePubkey) { + log(`Ignoring event from unknown pubkey: ${event.pubkey}`); + return; + } + try { + const plaintext = v2.decrypt(event.content, this.conversationKey); + const response = JSON.parse(plaintext); + log(`Response: ${response.id} -> ${response.result ? "ok" : response.error}`); + const pending = this.pendingRequests.get(response.id); + if (pending) { + this.pendingRequests.delete(response.id); + if (response.error) { + pending.reject(new Error(response.error)); + } else { + pending.resolve(response.result); + } + } + } catch (e) { + log(`Failed to handle response: ${e.message}`); + } + } + /** + * Send an encrypted NIP-46 request to the bunker + */ + async sendRequest(method, params = []) { + if (!this.connected && method !== "connect") { + throw new Error("Not connected to bunker"); + } + const id = crypto.randomUUID(); + const request = JSON.stringify({ id, method, params }); + const encrypted = v2.encrypt(request, this.conversationKey); + const event = await finalizeEvent({ + kind: 24133, + content: encrypted, + tags: [["p", this.remotePubkey]], + created_at: Math.floor(Date.now() / 1e3) + }, this.sessionPrivkey); + for (const relay of this.relays) { + try { + relay.publish(event); + } catch (e) { + log(`Failed to publish to ${relay.url}: ${e.message}`); + } + } + return new Promise((resolve, reject) => { + const timeout = setTimeout(() => { + this.pendingRequests.delete(id); + reject(new Error(`Request timeout: ${method}`)); + }, 3e4); + this.pendingRequests.set(id, { + resolve: (result) => { + clearTimeout(timeout); + resolve(result); + }, + reject: (error) => { + clearTimeout(timeout); + reject(error); + } + }); + }); + } + /** + * NIP-46 Methods + */ + async getPublicKey() { + return await this.sendRequest("get_public_key"); + } + async signEvent(event) { + const result = await this.sendRequest("sign_event", [JSON.stringify(event)]); + return JSON.parse(result); + } + async nip04Encrypt(thirdPartyPubkey, plaintext) { + return await this.sendRequest("nip04_encrypt", [thirdPartyPubkey, plaintext]); + } + async nip04Decrypt(thirdPartyPubkey, ciphertext) { + return await this.sendRequest("nip04_decrypt", [thirdPartyPubkey, ciphertext]); + } + async nip44Encrypt(thirdPartyPubkey, plaintext) { + return await this.sendRequest("nip44_encrypt", [thirdPartyPubkey, plaintext]); + } + async nip44Decrypt(thirdPartyPubkey, ciphertext) { + return await this.sendRequest("nip44_decrypt", [thirdPartyPubkey, ciphertext]); + } + async ping() { + return await this.sendRequest("ping"); + } + /** + * Get session info for persistence + */ + getSessionInfo() { + return { + remotePubkey: this.remotePubkey, + relayUrls: this.relayUrls, + secret: this.secret, + sessionPrivkey: bytesToHex3(this.sessionPrivkey), + sessionPubkey: this.sessionPubkey + }; + } + /** + * Disconnect from all relays + */ + disconnect() { + for (const relay of this.relays) { + relay.unsubscribe(this.subId); + relay.close(); + } + this.relays = []; + this.pendingRequests.clear(); + this.connected = false; + log("Disconnected from bunker"); + } + }; + function restoreSession(sessionInfo) { + const session = new BunkerSession({ + remotePubkey: sessionInfo.remotePubkey, + relays: sessionInfo.relayUrls, + secret: sessionInfo.secret + }); + session.sessionPrivkey = hexToBytes2(sessionInfo.sessionPrivkey); + session.sessionPubkey = sessionInfo.sessionPubkey; + session.conversationKey = v2.utils.getConversationKey( + session.sessionPrivkey, + session.remotePubkey + ); + return session; + } + async function getOrCreateSession(profileIndex) { + if (sessions.has(profileIndex)) { + const session2 = sessions.get(profileIndex); + if (session2.connected) { + return session2; + } + session2.disconnect(); + sessions.delete(profileIndex); + } + const data = await storage3.get({ bunkerSessions: {} }); + const sessionInfo = data.bunkerSessions?.[profileIndex]; + if (!sessionInfo) { + throw new Error("No bunker session configured for this profile"); + } + const session = restoreSession(sessionInfo); + await session.connect(); + sessions.set(profileIndex, session); + return session; + } + async function createSession(profileIndex, bunkerUrl) { + if (sessions.has(profileIndex)) { + sessions.get(profileIndex).disconnect(); + sessions.delete(profileIndex); + } + const config = parseBunkerUrl(bunkerUrl); + const session = new BunkerSession(config); + await session.connect(); + const data = await storage3.get({ bunkerSessions: {} }); + const bunkerSessions = data.bunkerSessions || {}; + bunkerSessions[profileIndex] = session.getSessionInfo(); + await storage3.set({ bunkerSessions }); + sessions.set(profileIndex, session); + return session; + } + async function disconnectSession(profileIndex) { + if (sessions.has(profileIndex)) { + sessions.get(profileIndex).disconnect(); + sessions.delete(profileIndex); + } + const data = await storage3.get({ bunkerSessions: {} }); + const bunkerSessions = data.bunkerSessions || {}; + delete bunkerSessions[profileIndex]; + await storage3.set({ bunkerSessions }); + } + function isSessionActive(profileIndex) { + return sessions.has(profileIndex) && sessions.get(profileIndex).connected; + } + function validateBunkerUrl(url) { + try { + parseBunkerUrl(url); + return { valid: true, error: null }; + } catch (e) { + return { valid: false, error: e.message }; + } + } + + // src/utilities/bunker-server.js + init_process(); + var log2 = (msg) => console.log("BunkerServer: ", msg); + var BunkerServer = class { + /** + * @param {Object} opts + * @param {string[]} opts.relayUrls - relay URLs to connect to + * @param {string} opts.userPubkey - hex pubkey of the local user + * @param {string} opts.secret - shared secret for connect handshake + */ + constructor({ relayUrls, userPubkey, secret }) { + this.relayUrls = relayUrls; + this.userPubkey = userPubkey; + this.secret = secret; + this.relays = []; + this.authenticatedClients = /* @__PURE__ */ new Set(); + this.subId = `bunker-srv-${crypto.randomUUID().slice(0, 8)}`; + this.active = false; + this._getPrivKey = null; + } + /** + * Start the bunker server. + * @param {Object} opts + * @param {Function} opts.getPrivKey - async () => Uint8Array (user's private key) + */ + async start({ getPrivKey: getPrivKey2 }) { + this._getPrivKey = getPrivKey2; + const connections = this.relayUrls.map((url) => { + const relay = new RelayConnection(url); + return relay.connect().then(() => { + this.relays.push(relay); + return relay; + }); + }); + const results = await Promise.allSettled(connections); + const connected = results.filter((r) => r.status === "fulfilled"); + if (connected.length === 0) { + throw new Error("Failed to connect to any relay"); + } + log2(`Connected to ${connected.length}/${this.relayUrls.length} relays`); + for (const relay of this.relays) { + relay.subscribe( + this.subId, + [{ kinds: [24133], "#p": [this.userPubkey], since: Math.floor(Date.now() / 1e3) - 5 }], + (event) => this._handleRequest(event) + ); + } + this.active = true; + log2("Bunker server started"); + } + /** + * Stop the bunker server. + */ + stop() { + for (const relay of this.relays) { + relay.unsubscribe(this.subId); + relay.close(); + } + this.relays = []; + this.authenticatedClients.clear(); + this.active = false; + this._getPrivKey = null; + log2("Bunker server stopped"); + } + /** + * Generate the bunker:// connection string. + */ + getConnectionString() { + const relayParams = this.relayUrls.map((u) => `relay=${encodeURIComponent(u)}`).join("&"); + return `bunker://${this.userPubkey}?${relayParams}&secret=${this.secret}`; + } + /** + * Handle an incoming NIP-46 request event. + */ + async _handleRequest(event) { + const clientPubkey = event.pubkey; + let privKey; + try { + privKey = await this._getPrivKey(); + } catch (e) { + log2(`Cannot get private key (locked?): ${e.message}`); + return; + } + let conversationKey; + try { + conversationKey = v2.utils.getConversationKey(privKey, clientPubkey); + } catch (e) { + log2(`Failed to derive conversation key: ${e.message}`); + return; + } + let request; + try { + const plaintext = v2.decrypt(event.content, conversationKey); + request = JSON.parse(plaintext); + } catch (e) { + log2(`Failed to decrypt request: ${e.message}`); + return; + } + const { id, method, params } = request; + log2(`Request: ${method} (id=${id}) from ${clientPubkey.slice(0, 8)}...`); + if (method !== "connect" && !this.authenticatedClients.has(clientPubkey)) { + await this._sendResponse(privKey, clientPubkey, conversationKey, { + id, + result: null, + error: "Unauthorized: send connect first" + }); + return; + } + let result = null; + let error = null; + try { + switch (method) { + case "connect": { + const clientSecret = params[1]; + if (this.secret && clientSecret !== this.secret) { + error = "Invalid secret"; + } else { + this.authenticatedClients.add(clientPubkey); + result = "ack"; + log2(`Client authenticated: ${clientPubkey.slice(0, 8)}...`); + } + break; + } + case "get_public_key": + result = this.userPubkey; + break; + case "sign_event": { + const unsigned = JSON.parse(params[0]); + const signed = await finalizeEvent(unsigned, privKey); + result = JSON.stringify(signed); + break; + } + case "nip44_encrypt": { + const thirdPartyPubkey = params[0]; + const plaintext = params[1]; + const ck = v2.utils.getConversationKey(privKey, thirdPartyPubkey); + result = v2.encrypt(plaintext, ck); + break; + } + case "nip44_decrypt": { + const thirdPartyPubkey = params[0]; + const ciphertext = params[1]; + const ck = v2.utils.getConversationKey(privKey, thirdPartyPubkey); + result = v2.decrypt(ciphertext, ck); + break; + } + case "nip04_encrypt": { + const thirdPartyPubkey = params[0]; + const plaintext = params[1]; + result = await nip_04_exports.encryptMessage(plaintext, bytesToHex3(privKey), thirdPartyPubkey); + break; + } + case "nip04_decrypt": { + const thirdPartyPubkey = params[0]; + const ciphertext = params[1]; + result = await nip_04_exports.decryptMessage(ciphertext, bytesToHex3(privKey), thirdPartyPubkey); + break; + } + case "ping": + result = "pong"; + break; + default: + error = `Unsupported method: ${method}`; + } + } catch (e) { + error = e.message; + log2(`Error handling ${method}: ${e.message}`); + } + await this._sendResponse(privKey, clientPubkey, conversationKey, { id, result, error }); + } + /** + * Encrypt and publish a NIP-46 response. + */ + async _sendResponse(privKey, clientPubkey, conversationKey, response) { + const encrypted = v2.encrypt(JSON.stringify(response), conversationKey); + const event = await finalizeEvent({ + kind: 24133, + content: encrypted, + tags: [["p", clientPubkey]], + created_at: Math.floor(Date.now() / 1e3) + }, privKey); + for (const relay of this.relays) { + try { + relay.publish(event); + } catch (e) { + log2(`Failed to publish response to ${relay.url}: ${e.message}`); + } + } + log2(`Response sent: ${response.id} ${response.error ? "ERROR" : "OK"}`); + } + }; + + // src/utilities/nip78.js + init_process(); + var KIND_APP_DATA = 30078; + var KIND_DELETION = 5; + var DTAG_PREFIX = "nostrkey:"; + var CLIENT_TAG = "nostrkey"; + function buildVaultEvent(path, encryptedContent) { + return { + kind: KIND_APP_DATA, + content: encryptedContent, + tags: [ + ["d", `${DTAG_PREFIX}${path}`], + ["client", CLIENT_TAG] + ], + created_at: Math.floor(Date.now() / 1e3) + }; + } + function buildVaultDeletion(eventId, path) { + return { + kind: KIND_DELETION, + content: "vault document deleted", + tags: [ + ["e", eventId], + ["a", `${KIND_APP_DATA}::${DTAG_PREFIX}${path}`] + ], + created_at: Math.floor(Date.now() / 1e3) + }; + } + function buildVaultFilter(pubkey) { + return { + kinds: [KIND_APP_DATA], + authors: [pubkey] + }; + } + function parseVaultEvent(event) { + if (event.kind !== KIND_APP_DATA) return null; + const dTag = event.tags?.find((t) => t[0] === "d"); + if (!dTag || !dTag[1]?.startsWith(DTAG_PREFIX)) return null; + const path = dTag[1].slice(DTAG_PREFIX.length); + if (!path) return null; + return { + path, + content: event.content, + createdAt: event.created_at, + eventId: event.id + }; + } + + // src/background.js + var _rawStorage = api.storage.local; + var storage4 = { + get: (...args) => _rawStorage.get(...args), + set: (...args) => { + const result = _rawStorage.set(...args); + result.then(() => scheduleSyncPush()).catch(() => { + }); + return result; + }, + clear: (...args) => _rawStorage.clear(...args), + remove: (...args) => _rawStorage.remove(...args) + }; + var log3 = (msg) => console.log("Background: ", msg); + var validations = {}; + var prompt = { mutex: new Mutex(), release: null, tabId: null }; + var pendingQueue = { total: 0, processed: 0 }; + var activeBunkerServer = null; + function reply(sendResponse, fn) { + fn().then((r) => sendResponse(r)).catch((e) => { + console.error("reply() error:", e); + sendResponse(void 0); + }); + } + var rateLimits = /* @__PURE__ */ new Map(); + var RATE_LIMIT_MAX = 5; + var RATE_LIMIT_WINDOW = 1e4; + function isRateLimited(host) { + const now = Date.now(); + let timestamps = rateLimits.get(host) || []; + timestamps = timestamps.filter((t) => now - t < RATE_LIMIT_WINDOW); + if (timestamps.length >= RATE_LIMIT_MAX) { + rateLimits.set(host, timestamps); + return true; + } + timestamps.push(now); + rateLimits.set(host, timestamps); + return false; + } + var sessionKeys = /* @__PURE__ */ new Map(); + var sessionCryptoKey = null; + var sessionKeySalt = null; + var locked = true; + var encryptionEnabled = false; + var autoLockTimeout = 15 * 60 * 1e3; + var autoLockTimer = null; + var nostrAccessWhileLocked = false; + var blockCrossOriginFrames = true; + var unlockAttempts = 0; + var unlockCooldownUntil = 0; + var permissionRateMap = /* @__PURE__ */ new Map(); + (async () => { + log3("[STARTUP] Reading persisted state..."); + const data = await storage4.get({ autoLockMinutes: 15, isEncrypted: false, passwordHash: null, nostrAccessWhileLocked: false, blockCrossOriginFrames: true }); + log3(`[STARTUP] isEncrypted=${data.isEncrypted}, passwordHash=${data.passwordHash ? "EXISTS" : "null"}, autoLockMinutes=${data.autoLockMinutes}`); + autoLockTimeout = data.autoLockMinutes * 60 * 1e3; + if (!data.isEncrypted && data.passwordHash) { + log3("[STARTUP] Self-healing: passwordHash exists but isEncrypted=false \u2192 fixing"); + await storage4.set({ isEncrypted: true }); + data.isEncrypted = true; + } + if (data.isEncrypted && !data.passwordHash) { + const { profiles = [] } = await storage4.get({ profiles: [] }); + const hasEncryptedBlob = profiles.some((p) => isEncryptedBlob(p.privKey)); + if (!hasEncryptedBlob) { + log3("[STARTUP] Lockout recovery: isEncrypted=true with no passwordHash and no encrypted blobs \u2192 clearing bogus encryption flag"); + await storage4.set({ isEncrypted: false }); + data.isEncrypted = false; + } + } + encryptionEnabled = data.isEncrypted; + nostrAccessWhileLocked = !!data.nostrAccessWhileLocked; + blockCrossOriginFrames = data.blockCrossOriginFrames !== false; + locked = encryptionEnabled; + log3(`[STARTUP] Final state: encryptionEnabled=${encryptionEnabled}, locked=${locked}`); + try { + await initSync(); + log3("[STARTUP] Platform sync initialized"); + } catch (e) { + log3(`[STARTUP] Platform sync init error (non-fatal): ${e.message}`); + } + try { + if (typeof browser !== "undefined" && browser.runtime.sendNativeMessage) { + const response = await browser.runtime.sendNativeMessage( + "com.nostrkey.Extension", + { action: "getSharedProfiles" } + ); + if (response && response.profiles && response.profiles.length > 0) { + const local = await storage4.get({ profiles: [] }); + const merged = mergeSharedProfiles(local.profiles, response.profiles); + if (merged.changed) { + await storage4.set({ profiles: merged.profiles }); + log3(`[STARTUP] Merged ${response.profiles.length} shared profile(s) from iOS app`); + } + } + } + } catch (e) { + log3(`[STARTUP] Shared profiles check skipped: ${e.message}`); + } + })(); + function mergeSharedProfiles(localProfiles, sharedProfiles) { + let changed = false; + const profiles = [...localProfiles]; + for (const shared of sharedProfiles) { + if (!shared.pubKey) continue; + const localIndex = profiles.findIndex((p) => p.pubKey === shared.pubKey); + if (localIndex === -1) { + profiles.push({ + name: shared.name || "Shared Profile", + privKey: shared.privKey || "", + pubKey: shared.pubKey, + hosts: {}, + relays: shared.relays || [], + type: "local", + updatedAt: shared.lastSyncedAt ? new Date(shared.lastSyncedAt).getTime() : Date.now() + }); + changed = true; + } else { + const local = profiles[localIndex]; + const localTime = local.updatedAt || 0; + const sharedTime = shared.lastSyncedAt ? new Date(shared.lastSyncedAt).getTime() : 0; + if (sharedTime > localTime && shared.privKey && !local.privKey) { + profiles[localIndex] = { + ...local, + privKey: shared.privKey, + name: shared.name || local.name, + relays: shared.relays || local.relays, + updatedAt: sharedTime + }; + changed = true; + } + } + } + return { profiles, changed }; + } + var AUTO_LOCK_ALARM = "nostrkey-auto-lock"; + function resetAutoLock() { + if (autoLockTimer) { + clearTimeout(autoLockTimer); + autoLockTimer = null; + } + if (locked || autoLockTimeout <= 0) { + api.alarms?.clear(AUTO_LOCK_ALARM).catch(() => { + }); + return; + } + if (api.alarms) { + api.alarms.create(AUTO_LOCK_ALARM, { delayInMinutes: autoLockTimeout / 6e4 }); + } else { + autoLockTimer = setTimeout(() => { + lockSession(); + }, autoLockTimeout); + } + } + if (api.alarms?.onAlarm) { + api.alarms.onAlarm.addListener((alarm) => { + if (alarm.name === AUTO_LOCK_ALARM) { + lockSession(); + } + }); + } + var sessionMutex = new Mutex(); + async function lockSession() { + const release = await sessionMutex.acquire(); + try { + if (!nostrAccessWhileLocked) { + sessionKeys.clear(); + } + sessionCryptoKey = null; + sessionKeySalt = null; + locked = true; + if (autoLockTimer) { + clearTimeout(autoLockTimer); + autoLockTimer = null; + } + log3(`Session locked. Keys retained: ${nostrAccessWhileLocked && sessionKeys.size > 0}`); + } finally { + release(); + } + } + async function unlockSession(password) { + const release = await sessionMutex.acquire(); + try { + const now = Date.now(); + if (now < unlockCooldownUntil) { + const waitSec = Math.ceil((unlockCooldownUntil - now) / 1e3); + return { success: false, error: `Too many attempts. Try again in ${waitSec} seconds.` }; + } + const valid = await checkPassword(password); + if (!valid) { + unlockAttempts++; + if (unlockAttempts >= 3) { + const cooldownMs = 3e4 * Math.pow(2, Math.floor((unlockAttempts - 3) / 3)); + unlockCooldownUntil = Date.now() + cooldownMs; + log3(`[SECURITY] ${unlockAttempts} failed attempts. Cooldown: ${cooldownMs / 1e3}s`); + } + return { success: false, error: "Invalid password" }; + } + unlockAttempts = 0; + unlockCooldownUntil = 0; + const profiles = await getProfiles(); + let needsSave = false; + for (let i = 0; i < profiles.length; i++) { + if (profiles[i].type === "bunker") continue; + const hex = await getDecryptedPrivKey(profiles[i], password); + sessionKeys.set(i, hex); + if (!profiles[i].pubKey && hex) { + try { + profiles[i].pubKey = getPublicKeySync(hex); + needsSave = true; + } catch (e) { + console.error(`Failed to cache pubKey for profile ${i}:`, e); + } + } + } + if (needsSave) { + await storage4.set({ profiles }); + } + const salt = crypto.getRandomValues(new Uint8Array(16)); + sessionCryptoKey = await deriveKey(password, salt); + sessionKeySalt = salt; + locked = false; + resetAutoLock(); + log3("Session unlocked."); + return { success: true }; + } finally { + release(); + } + } + async function checkLockState() { + const encrypted = await isEncrypted(); + log3(`[checkLockState] isEncrypted()=${encrypted}, locked=${locked}`); + if (!encrypted) { + locked = false; + return false; + } + return locked; + } + var SENSITIVE_KINDS = /* @__PURE__ */ new Set([ + "setPassword", + "changePassword", + "removePassword", + "resetAllData", + "setAutoLockTimeout", + "setNostrAccessWhileLocked", + "setBlockCrossOriginFrames", + "backup.export", + "backup.import", + "unlock" + ]); + function isExtensionSender(sender) { + if (sender.id !== api.runtime.id) return false; + if (sender.tab) { + const extOrigin = `chrome-extension://${api.runtime.id}`; + const url = sender.tab.url || sender.url || ""; + return url.startsWith(extOrigin) || url.startsWith("moz-extension://"); + } + return true; + } + api.runtime.onMessage.addListener((message, _sender, sendResponse) => { + log3(message); + if (SENSITIVE_KINDS.has(message.kind) && !isExtensionSender(_sender)) { + log3(`[SECURITY] Blocked ${message.kind} from non-extension sender`); + sendResponse({ success: false, error: "Unauthorized sender" }); + return true; + } + let uuid = crypto.randomUUID(); + let sr; + switch (message.kind) { + // General + case "closePrompt": + prompt.release?.(); + sendResponse(true); + return true; + case "allowed": + resetAutoLock(); + complete(message); + sendResponse(true); + return true; + case "denied": + deny(message); + sendResponse(true); + return true; + case "generatePrivateKey": + (async () => { + try { + const result = await generatePrivateKey_(); + sendResponse(result); + } catch (e) { + console.error("generatePrivateKey error:", e); + sendResponse(null); + } + })(); + return true; + // Keep message channel open for async sendResponse + case "savePrivateKey": + resetAutoLock(); + (async () => { + try { + await savePrivateKey(message.payload); + sendResponse({ success: true }); + } catch (e) { + console.error("savePrivateKey error:", e); + sendResponse({ success: false, error: e.message || "Failed to save key" }); + } + })(); + return true; + case "getNpub": + (async () => { + try { + const result = await getNpub(message.payload); + sendResponse(result); + } catch (e) { + console.error("getNpub error:", e); + sendResponse(null); + } + })(); + return true; + case "getNsec": + resetAutoLock(); + (async () => { + try { + const result = await getNsec(message.payload); + sendResponse(result); + } catch (e) { + console.error("getNsec error:", e); + sendResponse(null); + } + })(); + return true; + case "calcPubKey": + sendResponse(getPublicKeySync(message.payload)); + return true; + case "npubEncode": + sendResponse(nip_19_exports.npubEncode(message.payload)); + return true; + case "copy": + if (typeof navigator !== "undefined" && navigator.clipboard?.writeText) { + navigator.clipboard.writeText(message.payload).then(() => sendResponse(true)).catch(() => sendResponse(false)); + } else { + sendResponse(false); + } + return true; + // --- Master password / lock handlers --- + // NOTE: These use sendResponse + return true (callback pattern) because + // Chrome MV3 does not reliably deliver Promise-return values from + // onMessage listeners to sendMessage callers. + case "isLocked": + (async () => { + try { + const result = await checkLockState(); + log3(`[isLocked] Sending response: ${result}`); + sendResponse(result); + } catch (e) { + log3(`[isLocked] Error: ${e.message}`); + sendResponse(false); + } + })(); + return true; + case "isEncrypted": + (async () => { + try { + const data = await storage4.get({ isEncrypted: false, passwordHash: null }); + log3(`[isEncrypted] storage: isEncrypted=${data.isEncrypted}, passwordHash=${data.passwordHash ? "EXISTS" : "null"}`); + if (!data.isEncrypted && data.passwordHash) { + log3("[isEncrypted] Self-healing: passwordHash exists but flag=false"); + await storage4.set({ isEncrypted: true }); + data.isEncrypted = true; + } + encryptionEnabled = data.isEncrypted; + log3(`[isEncrypted] Sending response: ${encryptionEnabled}`); + sendResponse(encryptionEnabled); + } catch (e) { + log3(`[isEncrypted] Error: ${e.message}`); + sendResponse(false); + } + })(); + return true; + case "hasEncryptedData": + (async () => { + try { + const data = await storage4.get({ passwordHash: null, profiles: [] }); + const hasPasswordHash = !!data.passwordHash; + let encryptedProfiles = 0; + log3(`[hasEncryptedData] passwordHash=${hasPasswordHash}, profiles=${Array.isArray(data.profiles) ? data.profiles.length : "not-array"}`); + if (Array.isArray(data.profiles)) { + for (let i = 0; i < data.profiles.length; i++) { + const p = data.profiles[i]; + const isEnc = p.privKey ? isEncryptedBlob(p.privKey) : false; + log3(`[hasEncryptedData] profile[${i}] name="${p.name}" privKey=${p.privKey ? isEnc ? "ENCRYPTED" : "PLAINTEXT" : "EMPTY"}`); + if (isEnc) encryptedProfiles++; + } + } + const found = hasPasswordHash || encryptedProfiles > 0; + log3(`[hasEncryptedData] Result: found=${found}, hasPasswordHash=${hasPasswordHash}, encryptedProfiles=${encryptedProfiles}`); + if (found && !encryptionEnabled) { + log3("[hasEncryptedData] Self-healing: setting isEncrypted=true, locked=true"); + await storage4.set({ isEncrypted: true }); + encryptionEnabled = true; + locked = true; + } + sendResponse({ found, hasPasswordHash, encryptedProfiles }); + } catch (e) { + console.error("hasEncryptedData error:", e); + sendResponse({ found: false, hasPasswordHash: false, encryptedProfiles: 0 }); + } + })(); + return true; + case "unlock": + reply(sendResponse, () => unlockSession(message.payload)); + return true; + case "lock": + lockSession().then(() => sendResponse(true)); + return true; + case "setPassword": + (async () => { + try { + await cachePubKeysForAllProfiles(); + await encryptAllKeys(message.payload); + encryptionEnabled = true; + const result = await unlockSession(message.payload); + api.runtime.sendMessage({ kind: "passwordStateChanged", hasPassword: true }).catch(() => { + }); + api.runtime.sendMessage({ kind: "backupNeeded" }).catch(() => { + }); + sendResponse(result); + } catch (e) { + sendResponse({ success: false, error: e.message }); + } + })(); + return true; + case "changePassword": + (async () => { + try { + const { oldPassword, newPassword } = message.payload; + const valid = await checkPassword(oldPassword); + if (!valid) { + sendResponse({ success: false, error: "Invalid current password" }); + return; + } + await changePasswordForKeys(oldPassword, newPassword); + const result = await unlockSession(newPassword); + api.runtime.sendMessage({ kind: "passwordStateChanged", hasPassword: true }).catch(() => { + }); + api.runtime.sendMessage({ kind: "backupNeeded" }).catch(() => { + }); + sendResponse(result); + } catch (e) { + sendResponse({ success: false, error: e.message }); + } + })(); + return true; + case "removePassword": + (async () => { + try { + await removePasswordProtection(message.payload); + sessionKeys.clear(); + sessionCryptoKey = null; + sessionKeySalt = null; + locked = false; + encryptionEnabled = false; + api.runtime.sendMessage({ kind: "passwordStateChanged", hasPassword: false }).catch(() => { + }); + sendResponse({ success: true }); + } catch (e) { + sendResponse({ success: false, error: e.message }); + } + })(); + return true; + case "resetAllData": + (async () => { + try { + await storage4.clear(); + sessionKeys.clear(); + sessionCryptoKey = null; + sessionKeySalt = null; + locked = false; + encryptionEnabled = false; + nostrAccessWhileLocked = false; + blockCrossOriginFrames = true; + await storage4.set({ + profiles: [{ name: "Default Nostr Profile", privKey: "", pubKey: "" }], + profileIndex: 0, + isEncrypted: false, + passwordHash: null, + passwordSalt: null + }); + api.runtime.sendMessage({ kind: "dataReset" }).catch(() => { + }); + sendResponse({ success: true }); + } catch (e) { + sendResponse({ success: false, error: e.message }); + } + })(); + return true; + case "setAutoLockTimeout": { + const ALLOWED_LOCK_MINUTES = [0, 5, 15, 30, 60, 90, 180]; + const mins = Number(message.payload); + if (!ALLOWED_LOCK_MINUTES.includes(mins)) { + sendResponse(false); + return true; + } + autoLockTimeout = mins * 60 * 1e3; + storage4.set({ autoLockMinutes: mins }); + resetAutoLock(); + sendResponse(true); + return true; + } + case "getAutoLockTimeout": + reply(sendResponse, async () => { + const { autoLockMinutes } = await storage4.get({ autoLockMinutes: 15 }); + return autoLockMinutes; + }); + return true; + case "resetAutoLock": + resetAutoLock(); + sendResponse(true); + return true; + // --- Nostr access while locked --- + case "getNostrAccessWhileLocked": + sendResponse(nostrAccessWhileLocked); + return true; + case "setNostrAccessWhileLocked": + nostrAccessWhileLocked = !!message.payload; + storage4.set({ nostrAccessWhileLocked: !!message.payload }); + if (!message.payload && locked) { + sessionKeys.clear(); + } + sendResponse(true); + return true; + case "getBlockCrossOriginFrames": + sendResponse(blockCrossOriginFrames); + return true; + case "setBlockCrossOriginFrames": + blockCrossOriginFrames = !!message.payload; + storage4.set({ blockCrossOriginFrames: !!message.payload }); + sendResponse(true); + return true; + case "getActiveProfileInfo": + (async () => { + try { + const pi = await getProfileIndex(); + const profiles = await getProfiles(); + const profile = profiles[pi]; + if (!profile) { + log3("[getActiveProfileInfo] No profile found at index " + pi); + sendResponse({ name: "Unknown", npub: "", hasKeys: false }); + return; + } + let npub = ""; + if (profile.type === "bunker" && profile.remotePubkey) { + npub = nip_19_exports.npubEncode(profile.remotePubkey); + } else if (profile.pubKey) { + npub = nip_19_exports.npubEncode(profile.pubKey); + } + const result = { + name: profile.name || "Unnamed Profile", + npub, + hasKeys: sessionKeys.has(pi), + isBunker: profile.type === "bunker" + }; + log3("[getActiveProfileInfo] Sending: " + JSON.stringify(result)); + sendResponse(result); + } catch (e) { + log3("[getActiveProfileInfo] Error: " + e.message); + sendResponse({ name: "Error", npub: "", hasKeys: false }); + } + })(); + return true; + // --- NIP-49 ncryptsec handlers --- + case "ncryptsec.decrypt": + reply(sendResponse, async () => { + try { + const { ncryptsec, password } = message.payload; + const hexKey = bytesToHex3(decrypt2(ncryptsec, password)); + return { success: true, hexKey }; + } catch (e) { + return { success: false, error: e.message || "Decryption failed" }; + } + }); + return true; + case "ncryptsec.encrypt": + reply(sendResponse, async () => { + try { + const { profileIndex: ei, password } = message.payload; + const profile = await getProfile(ei); + if (profile?.type === "bunker") { + return { success: false, error: "Cannot export bunker profile as ncryptsec" }; + } + const hexKey = await getPlaintextPrivKey(ei, profile); + const ncryptsec = encrypt2(hexToBytes2(hexKey), password); + return { success: true, ncryptsec }; + } catch (e) { + return { success: false, error: e.message || "Encryption failed" }; + } + }); + return true; + // --- BIP39 Seed Phrase handlers --- + case "seedPhrase.fromKey": + reply(sendResponse, async () => { + try { + const ei = message.payload; + const profile = await getProfile(ei); + if (profile?.type === "bunker") { + return { success: false, error: "Cannot export bunker profile as seed phrase" }; + } + const hexKey = await getPlaintextPrivKey(ei, profile); + const seedPhrase = keyToSeedPhrase(hexKey); + return { success: true, seedPhrase }; + } catch (e) { + return { success: false, error: e.message || "Failed to generate seed phrase" }; + } + }); + return true; + case "seedPhrase.toKey": + reply(sendResponse, async () => { + try { + const { hexKey, pubKey } = seedPhraseToKey(message.payload); + return { success: true, hexKey, pubKey }; + } catch (e) { + return { success: false, error: e.message || "Invalid seed phrase" }; + } + }); + return true; + case "seedPhrase.validate": + sendResponse(isValidSeedPhrase(message.payload)); + return true; + // --- NIP-46 Bunker handlers --- + case "getProfileType": + reply(sendResponse, async () => { + const pi = message.payload ?? await getProfileIndex(); + const profile = await getProfile(pi); + return profile?.type || "local"; + }); + return true; + case "bunker.connect": + reply(sendResponse, async () => { + try { + const { profileIndex: bi, bunkerUrl } = message.payload; + const session = await createSession(bi, bunkerUrl); + const remotePubkey = await session.getPublicKey(); + const profiles = await getProfiles(); + profiles[bi].remotePubkey = remotePubkey; + profiles[bi].bunkerUrl = bunkerUrl; + await storage4.set({ profiles }); + return { success: true, remotePubkey }; + } catch (e) { + return { success: false, error: e.message }; + } + }); + return true; + case "bunker.disconnect": + reply(sendResponse, async () => { + try { + const bi = message.payload; + await disconnectSession(bi); + return { success: true }; + } catch (e) { + return { success: false, error: e.message }; + } + }); + return true; + case "bunker.status": + reply(sendResponse, async () => { + const bi = message.payload ?? await getProfileIndex(); + return { connected: isSessionActive(bi) }; + }); + return true; + case "bunker.ping": + reply(sendResponse, async () => { + try { + const bi = message.payload ?? await getProfileIndex(); + const session = await getOrCreateSession(bi); + const result = await session.ping(); + return { success: true, result }; + } catch (e) { + return { success: false, error: e.message }; + } + }); + return true; + case "bunker.validateUrl": + sendResponse(validateBunkerUrl(message.payload)); + return true; + // --- Bunker Server handlers (extension acts as NIP-46 signer) --- + case "bunkerServer.start": + reply(sendResponse, async () => { + try { + if (activeBunkerServer) { + activeBunkerServer.stop(); + activeBunkerServer = null; + } + const pubkey = await getPubKey(); + const relayUrls = message.payload?.relayUrls || ["wss://relay.nostrkey.com"]; + const secret = crypto.randomUUID().replace(/-/g, "").slice(0, 16); + const server = new BunkerServer({ relayUrls, userPubkey: pubkey, secret }); + await server.start({ getPrivKey }); + activeBunkerServer = server; + return { success: true, uri: server.getConnectionString() }; + } catch (e) { + return { success: false, error: e.message }; + } + }); + return true; + case "bunkerServer.stop": + reply(sendResponse, async () => { + if (activeBunkerServer) { + activeBunkerServer.stop(); + activeBunkerServer = null; + } + return { success: true }; + }); + return true; + case "bunkerServer.status": + sendResponse({ + active: !!activeBunkerServer?.active, + uri: activeBunkerServer?.getConnectionString() || null, + clientCount: activeBunkerServer?.authenticatedClients.size || 0 + }); + return true; + // --- Vault handlers --- + case "vault.publish": + reply(sendResponse, async () => { + try { + const { path, content } = message.payload; + const pubkey = await getPubKey(); + const encrypted = await nip44Encrypt({ pubKey: pubkey, plainText: content }); + const unsigned = buildVaultEvent(path, encrypted); + const pi = await getProfileIndex(); + const profile = await getProfile(pi); + let signed; + if (profile.type === "bunker") { + const session = await getOrCreateSession(pi); + signed = await session.signEvent(unsigned); + } else { + const sk = await getPrivKey(); + signed = await finalizeEvent(unsigned, sk); + } + await withRelays("write", async (relays) => { + for (const relay of relays) { + try { + relay.publish(signed); + } catch (_) { + } + } + }); + return { success: true, eventId: signed.id, createdAt: signed.created_at }; + } catch (e) { + return { success: false, error: e.message }; + } + }); + return true; + case "vault.fetch": + reply(sendResponse, async () => { + try { + const pubkey = await getPubKey(); + const filter = buildVaultFilter(pubkey); + const allEvents = []; + await withRelays("read", async (relays) => { + const perRelay = relays.map((relay) => new Promise((resolve) => { + const subId = `vault-${crypto.randomUUID().slice(0, 8)}`; + const timeout = setTimeout(() => { + try { + relay.unsubscribe(subId); + } catch (_) { + } + resolve(); + }, 15e3); + relay.subscribe( + subId, + [filter], + (event) => { + allEvents.push(event); + }, + () => { + clearTimeout(timeout); + try { + relay.unsubscribe(subId); + } catch (_) { + } + resolve(); + } + ); + })); + await Promise.all(perRelay); + }); + const byDtag = /* @__PURE__ */ new Map(); + for (const event of allEvents) { + const parsed = parseVaultEvent(event); + if (!parsed) continue; + const existing = byDtag.get(parsed.path); + if (!existing || parsed.createdAt > existing.createdAt) { + byDtag.set(parsed.path, { event, parsed }); + } + } + const documents = []; + const pubkey_ = await getPubKey(); + for (const { event, parsed } of byDtag.values()) { + try { + const decrypted = await nip44Decrypt({ pubKey: pubkey_, cipherText: event.content }); + documents.push({ + path: parsed.path, + content: decrypted, + createdAt: parsed.createdAt, + eventId: parsed.eventId + }); + } catch (_) { + } + } + return { success: true, documents }; + } catch (e) { + return { success: false, error: e.message }; + } + }); + return true; + case "vault.delete": + reply(sendResponse, async () => { + try { + const { path, eventId } = message.payload; + const unsigned = buildVaultDeletion(eventId, path); + const pi = await getProfileIndex(); + const profile = await getProfile(pi); + let signed; + if (profile.type === "bunker") { + const session = await getOrCreateSession(pi); + signed = await session.signEvent(unsigned); + } else { + const sk = await getPrivKey(); + signed = await finalizeEvent(unsigned, sk); + } + await withRelays("write", async (relays) => { + for (const relay of relays) { + try { + relay.publish(signed); + } catch (_) { + } + } + }); + return { success: true }; + } catch (e) { + return { success: false, error: e.message }; + } + }); + return true; + case "vault.getRelays": + reply(sendResponse, async () => { + try { + const profile = await currentProfile(); + const relays = profile.relays || []; + const read = relays.filter((r) => r.read).map((r) => r.url); + const write = relays.filter((r) => r.write).map((r) => r.url); + return { read, write }; + } catch (e) { + return { read: [], write: [] }; + } + }); + return true; + // --- API Key Vault handlers --- + case "apikeys.publish": + reply(sendResponse, async () => { + try { + const { keys } = message.payload; + const pubkey = await getPubKey(); + const plainText = JSON.stringify(keys); + const encrypted = await nip44Encrypt({ pubKey: pubkey, plainText }); + const unsigned = buildVaultEvent("vault/api-keys", encrypted); + const pi = await getProfileIndex(); + const profile = await getProfile(pi); + let signed; + if (profile.type === "bunker") { + const session = await getOrCreateSession(pi); + signed = await session.signEvent(unsigned); + } else { + const sk = await getPrivKey(); + signed = await finalizeEvent(unsigned, sk); + } + await withRelays("write", async (relays) => { + for (const relay of relays) { + try { + relay.publish(signed); + } catch (_) { + } + } + }); + return { success: true, eventId: signed.id, createdAt: signed.created_at }; + } catch (e) { + return { success: false, error: e.message }; + } + }); + return true; + case "apikeys.fetch": + reply(sendResponse, async () => { + try { + const pubkey = await getPubKey(); + const filter = { + kinds: [30078], + authors: [pubkey], + "#d": ["nostrkey:vault/api-keys"] + }; + const allEvents = []; + await withRelays("read", async (relays) => { + const perRelay = relays.map((relay) => new Promise((resolve) => { + const subId = `apikeys-${crypto.randomUUID().slice(0, 8)}`; + const timeout = setTimeout(() => { + try { + relay.unsubscribe(subId); + } catch (_) { + } + resolve(); + }, 15e3); + relay.subscribe( + subId, + [filter], + (event) => { + allEvents.push(event); + }, + () => { + clearTimeout(timeout); + try { + relay.unsubscribe(subId); + } catch (_) { + } + resolve(); + } + ); + })); + await Promise.all(perRelay); + }); + let latest = null; + for (const event of allEvents) { + if (!latest || event.created_at > latest.created_at) { + latest = event; + } + } + if (!latest) { + return { success: true, keys: null, eventId: null, createdAt: null }; + } + const decrypted = await nip44Decrypt({ pubKey: pubkey, cipherText: latest.content }); + const keys = JSON.parse(decrypted); + return { success: true, keys, eventId: latest.id, createdAt: latest.created_at }; + } catch (e) { + return { success: false, error: e.message }; + } + }); + return true; + case "apikeys.delete": + reply(sendResponse, async () => { + try { + const { eventId } = message.payload; + const unsigned = buildVaultDeletion(eventId, "vault/api-keys"); + const pi = await getProfileIndex(); + const profile = await getProfile(pi); + let signed; + if (profile.type === "bunker") { + const session = await getOrCreateSession(pi); + signed = await session.signEvent(unsigned); + } else { + const sk = await getPrivKey(); + signed = await finalizeEvent(unsigned, sk); + } + await withRelays("write", async (relays) => { + for (const relay of relays) { + try { + relay.publish(signed); + } catch (_) { + } + } + }); + return { success: true }; + } catch (e) { + return { success: false, error: e.message }; + } + }); + return true; + case "apikeys.encrypt": + reply(sendResponse, async () => { + try { + const { plainText } = message.payload; + const pubkey = await getPubKey(); + const cipherText = await nip44Encrypt({ pubKey: pubkey, plainText }); + return { success: true, cipherText }; + } catch (e) { + return { success: false, error: e.message }; + } + }); + return true; + case "apikeys.decrypt": + reply(sendResponse, async () => { + try { + const { cipherText } = message.payload; + const pubkey = await getPubKey(); + const plainText = await nip44Decrypt({ pubKey: pubkey, cipherText }); + return { success: true, plainText }; + } catch (e) { + return { success: false, error: e.message }; + } + }); + return true; + // --- Encrypted vault backup / restore --- + case "backup.export": + reply(sendResponse, async () => { + const password = message.payload?.password; + if (typeof password !== "string" || password.length < 8) { + return { success: false, error: "A backup password of at least 8 characters is required" }; + } + const data = await storage4.get({ + profiles: [], + profileIndex: 0, + isEncrypted: false, + passwordHash: null, + passwordSalt: null, + apiKeyVault: null, + vaultDocs: null, + nostrAccessWhileLocked: false, + blockCrossOriginFrames: true, + autoLockMinutes: 15, + version: null + }); + const plaintext = JSON.stringify(data); + const encrypted = await encrypt4(plaintext, password); + const version = api.runtime.getManifest?.()?.version || "unknown"; + return { + success: true, + envelope: { + format: "nostrkey-backup", + version: 1, + createdAt: (/* @__PURE__ */ new Date()).toISOString(), + extensionVersion: version, + profileCount: Array.isArray(data.profiles) ? data.profiles.length : 0, + payload: JSON.parse(encrypted) + } + }; + }); + return true; + case "backup.import": + reply(sendResponse, async () => { + try { + const { envelope, password } = message.payload; + if (!envelope || envelope.format !== "nostrkey-backup") { + return { success: false, error: "Not a valid NostrKey backup file" }; + } + if (typeof envelope.version !== "number" || envelope.version > 1) { + return { success: false, error: "Backup version not supported. Update NostrKey and try again." }; + } + const payloadStr = JSON.stringify(envelope.payload); + let plaintext; + try { + plaintext = await decrypt4(payloadStr, password); + } catch (_) { + return { success: false, error: "Wrong password \u2014 could not decrypt backup" }; + } + const data = JSON.parse(plaintext); + await storage4.set(data); + encryptionEnabled = !!data.isEncrypted; + locked = false; + const importSalt = crypto.getRandomValues(new Uint8Array(16)); + sessionCryptoKey = await deriveKey(password, importSalt); + sessionKeySalt = importSalt; + nostrAccessWhileLocked = data.nostrAccessWhileLocked !== false; + blockCrossOriginFrames = data.blockCrossOriginFrames !== false; + if (typeof data.autoLockMinutes === "number") { + autoLockTimeout = data.autoLockMinutes * 60 * 1e3; + } + sessionKeys.clear(); + if (Array.isArray(data.profiles)) { + for (let i = 0; i < data.profiles.length; i++) { + const p = data.profiles[i]; + if (p.type === "bunker" || !p.privKey) continue; + if (isEncryptedBlob(p.privKey)) { + try { + const hex = await decrypt4(p.privKey, password); + sessionKeys.set(i, hex); + } catch (_) { + } + } else { + sessionKeys.set(i, p.privKey); + } + } + } + resetAutoLock(); + const profileCount = Array.isArray(data.profiles) ? data.profiles.length : 0; + return { success: true, profileCount }; + } catch (e) { + return { success: false, error: e.message || "Restore failed" }; + } + }); + return true; + // nostr: protocol URL handler — no key access needed, no permission prompt + case "replaceURL": + reply(sendResponse, async () => { + const { protocol_handler } = await storage4.get(["protocol_handler"]); + if (!protocol_handler) return false; + const { url } = message.payload; + const raw = url.split("nostr:")[1]; + if (!raw) return false; + try { + const decoded = nip_19_exports.decode(raw); + const { type, data } = decoded; + const replacements = { + raw, + hrp: type, + hex: type === "naddr" ? decoded.author || raw : data || raw, + p_or_e: { npub: "p", note: "e", nprofile: "p", nevent: "e", naddr: "a" }[type] || "", + u_or_n: { npub: "u", note: "n", nprofile: "u", nevent: "n", naddr: "n" }[type] || "", + relay0: decoded.relays?.[0] || "", + relay1: decoded.relays?.[1] || "", + relay2: decoded.relays?.[2] || "" + }; + let result = protocol_handler; + for (const [pattern, value] of Object.entries(replacements)) { + result = result.replace(new RegExp(`\\{ *${pattern} *\\}`, "g"), value); + } + return result; + } catch { + return false; + } + }); + return true; + // window.nostr + case "getPubKey": + case "signEvent": + case "nip04.encrypt": + case "nip04.decrypt": + case "nip44.encrypt": + case "nip44.decrypt": + case "getRelays": + case "addRelay": + case "exportProfile": + validations[uuid] = sendResponse; + if (Object.keys(validations).length === 1) { + pendingQueue = { total: 0, processed: 0 }; + } + pendingQueue.total++; + ask(uuid, message); + setTimeout(() => { + if (validations[uuid]) { + deny({ payload: uuid, origKind: message.kind, host: message.host }); + } + prompt.release?.(); + }, 1e4); + return true; + default: + return false; + } + }); + async function forceRelease() { + if (prompt.tabId !== null) { + try { + await api.tabs.get(prompt.tabId); + } catch (error) { + prompt.release?.(); + prompt.tabId = null; + } + } + } + async function generatePrivateKey_() { + const keyPair = await generateKeyPair2(); + return keyPair.privateKey; + } + async function ask(uuid, { kind, host, payload }) { + if (host) { + const now = Date.now(); + const rateEntry = permissionRateMap.get(host) || { count: 0, resetAt: now + 6e4 }; + if (now > rateEntry.resetAt) { + rateEntry.count = 0; + rateEntry.resetAt = now + 6e4; + } + rateEntry.count++; + permissionRateMap.set(host, rateEntry); + if (rateEntry.count > 5) { + log3(`[SECURITY] Rate limited ${host} \u2014 ${rateEntry.count} requests in 60s`); + const sendResponse = validations[uuid]; + delete validations[uuid]; + sendResponse?.({ error: "rate_limited", message: "Too many requests. Please wait a moment." }); + return; + } + } + const pi = await getProfileIndex(); + const profile = await getProfile(pi); + const isBunker = profile?.type === "bunker"; + const needsPrivateKey = kind !== "getPubKey" && kind !== "getRelays" && kind !== "addRelay" && kind !== "exportProfile"; + if (!isBunker && needsPrivateKey) { + const isLocked = await checkLockState(); + if (isLocked) { + if (!(nostrAccessWhileLocked && sessionKeys.has(pi))) { + const isFirstUnlock = sessionKeys.size === 0; + try { + const [activeTab] = await api.tabs.query({ active: true, currentWindow: true }); + if (activeTab?.id) { + api.tabs.sendMessage(activeTab.id, { kind: "showLockedSheet", firstUnlock: isFirstUnlock }).catch(() => { + }); + } + } catch (_) { + } + const sendResponse = validations[uuid]; + delete validations[uuid]; + sendResponse?.({ error: "locked", message: "Extension is locked. Please unlock with your master password." }); + return; + } + } + } + if (isRateLimited(host)) { + const sendResponse = validations[uuid]; + delete validations[uuid]; + sendResponse?.({ error: "rate_limited", message: "Too many requests. Please wait." }); + log3(`Rate limited: ${host}`); + return; + } + await forceRelease(); + prompt.release = await prompt.mutex.acquire(); + pendingQueue.processed++; + const queuePosition = pendingQueue.processed; + const queueTotal = pendingQueue.total; + let mKind = kind === "signEvent" ? `signEvent:${payload.kind}` : kind; + let permission = await getPermission(host, mKind); + if (permission === "allow") { + complete({ + payload: uuid, + origKind: kind, + event: payload, + remember: false, + host + }); + prompt.release(); + return; + } + if (permission === "deny") { + deny({ payload: uuid, origKind: kind, host }); + prompt.release(); + return; + } + try { + const [activeTab] = await api.tabs.query({ active: true, currentWindow: true }); + if (activeTab?.id) { + const result = await api.tabs.sendMessage(activeTab.id, { + kind: "showPermissionSheet", + host, + permissionKind: kind, + queuePosition, + queueTotal + }); + if (result) { + if (result.allowed) { + complete({ + payload: uuid, + origKind: kind, + event: payload, + remember: result.remember, + host + }); + } else { + deny({ + payload: uuid, + origKind: kind, + event: payload, + remember: result.remember, + host + }); + } + prompt.release(); + return; + } + } + } catch (e) { + log3("Bottom sheet unavailable, falling back to tab:", e.message); + } + let qs = new URLSearchParams({ + uuid, + kind, + host, + payload: JSON.stringify(payload || false), + queuePosition, + queueTotal + }); + let tab = await api.tabs.getCurrent(); + let p = await api.tabs.create({ + url: api.runtime.getURL(`permission/permission.html?${qs.toString()}`), + openerTabId: tab?.id + }); + prompt.tabId = p.id; + return true; + } + function complete({ payload, origKind, event, remember, host }) { + const sendResponse = validations[payload]; + delete validations[payload]; + if (Object.keys(validations).length === 0) { + pendingQueue = { total: 0, processed: 0 }; + } + if (remember) { + let mKind = origKind === "signEvent" ? `signEvent:${event.kind}` : origKind; + setPermission(host, mKind, "allow"); + } + if (sendResponse) { + const onError = (e) => { + log3(`Error in ${origKind}: ${e.message}`); + sendResponse({ error: "bunker_error", message: e.message }); + }; + switch (origKind) { + case "getPubKey": + getPubKey().then((pk) => sendResponse(pk)).catch(onError); + break; + case "signEvent": + signEvent_(event, host).then((e) => sendResponse(e)).catch(onError); + break; + case "nip04.encrypt": + nip04Encrypt(event).then((e) => sendResponse(e)).catch(onError); + break; + case "nip04.decrypt": + nip04Decrypt(event).then((e) => sendResponse(e)).catch(onError); + break; + case "nip44.encrypt": + nip44Encrypt(event).then((e) => sendResponse(e)).catch(onError); + break; + case "nip44.decrypt": + nip44Decrypt(event).then((e) => sendResponse(e)).catch(onError); + break; + case "getRelays": + getRelays().then((e) => sendResponse(e)).catch(onError); + break; + case "addRelay": + addRelay(event.url).then((e) => sendResponse(e)).catch(onError); + break; + case "exportProfile": + exportProfileData().then((e) => sendResponse(e)).catch(onError); + break; + } + } + } + function deny({ origKind, host, payload, remember, event }) { + const sendResponse = validations[payload]; + delete validations[payload]; + if (Object.keys(validations).length === 0) { + pendingQueue = { total: 0, processed: 0 }; + } + if (remember) { + let mKind = origKind === "signEvent" ? `signEvent:${event.kind}` : origKind; + setPermission(host, mKind, "deny"); + } + sendResponse?.(void 0); + return false; + } + async function cachePubKeysForAllProfiles() { + const profiles = await getProfiles(); + let updated = false; + for (let i = 0; i < profiles.length; i++) { + const profile = profiles[i]; + if (profile.type === "bunker") continue; + if (profile.pubKey) continue; + if (!profile.privKey || isEncryptedBlob(profile.privKey)) continue; + try { + const pubKey = getPublicKeySync(profile.privKey); + profiles[i].pubKey = pubKey; + updated = true; + } catch (e) { + console.error(`Failed to cache pubKey for profile ${i}:`, e); + } + } + if (updated) { + await storage4.set({ profiles }); + } + } + async function savePrivateKey([index, privKey]) { + const profile = await getProfile(index); + if (profile?.type === "bunker") { + throw new Error("Cannot set private key on a bunker profile"); + } + if (typeof privKey !== "string" || privKey.length === 0) { + throw new Error("Invalid private key: must be a non-empty string"); + } + let hexKey; + if (privKey.startsWith("nsec")) { + try { + hexKey = nip_19_exports.decode(privKey).data; + } catch (e) { + throw new Error("Invalid nsec key"); + } + } else { + hexKey = privKey; + } + if (!/^[0-9a-f]{64}$/i.test(hexKey)) { + throw new Error("Invalid private key: must be 64 hex characters or valid nsec"); + } + let profiles = await get("profiles"); + if (!profiles || index < 0 || index >= profiles.length) { + throw new Error("Invalid profile index"); + } + const pubKey = getPublicKeySync(hexKey); + profiles[index].pubKey = pubKey; + const encrypted = await isEncrypted(); + if (encrypted && sessionCryptoKey) { + profiles[index].privKey = await encryptWithKey(hexKey, sessionCryptoKey, sessionKeySalt); + sessionKeys.set(index, hexKey); + } else { + profiles[index].privKey = hexKey; + } + await storage4.set({ profiles }); + return true; + } + async function getNsec(index) { + let profile = await getProfile(index); + if (profile.type === "bunker") return null; + let hexKey = await getPlaintextPrivKey(index, profile); + let nsec = nip_19_exports.nsecEncode(hexKey); + return nsec; + } + async function getNpub(index) { + let profile = await getProfile(index); + if (!profile) return null; + if (profile.type === "bunker") { + if (profile.remotePubkey) return nip_19_exports.npubEncode(profile.remotePubkey); + return null; + } + if (profile.pubKey) { + return nip_19_exports.npubEncode(profile.pubKey); + } + try { + let hexKey = await getPlaintextPrivKey(index, profile); + if (!hexKey || typeof hexKey !== "string" || hexKey.length !== 64) { + return null; + } + let pubKey = getPublicKeySync(hexKey); + let npub = nip_19_exports.npubEncode(pubKey); + return npub; + } catch (e) { + console.error("getNpub error:", e); + return null; + } + } + async function getPlaintextPrivKey(index, profile) { + if (isEncryptedBlob(profile.privKey)) { + if (sessionKeys.has(index)) { + return sessionKeys.get(index); + } + throw new Error("Extension is locked \u2014 cannot access private key"); + } + return profile.privKey; + } + async function getPrivKey() { + let index = await getProfileIndex(); + let profile = await currentProfile(); + let hexKey = await getPlaintextPrivKey(index, profile); + return hexToBytes2(hexKey); + } + async function getPubKey() { + let pi = await getProfileIndex(); + let profile = await getProfile(pi); + if (profile.type === "bunker") { + if (profile.remotePubkey) return profile.remotePubkey; + const session = await getOrCreateSession(pi); + const pubkey = await session.getPublicKey(); + const profiles = await get("profiles"); + profiles[pi].remotePubkey = pubkey; + await storage4.set({ profiles }); + return pubkey; + } + if (profile.pubKey) return profile.pubKey; + let privKey = await getPrivKey(); + let pubKey = getPublicKeySync(bytesToHex3(privKey)); + return pubKey; + } + async function currentProfile() { + let index = await getProfileIndex(); + let profiles = await get("profiles"); + return profiles[index]; + } + async function signEvent_(event, host) { + event = JSON.parse(JSON.stringify(event)); + const pi = await getProfileIndex(); + const profile = await getProfile(pi); + if (profile.type === "bunker") { + const session = await getOrCreateSession(pi); + event = await session.signEvent(event); + } else { + let sk = await getPrivKey(); + event = await finalizeEvent(event, sk); + } + saveEvent({ + event, + metadata: { host, signed_at: Math.round(Date.now() / 1e3) } + }); + return event; + } + async function nip04Encrypt({ pubKey, plainText }) { + const pi = await getProfileIndex(); + const profile = await getProfile(pi); + if (profile.type === "bunker") { + const session = await getOrCreateSession(pi); + return session.nip04Encrypt(pubKey, plainText); + } + let privKey = await getPrivKey(); + return nip_04_exports.encryptMessage(plainText, bytesToHex3(privKey), pubKey); + } + async function nip04Decrypt({ pubKey, cipherText }) { + const pi = await getProfileIndex(); + const profile = await getProfile(pi); + if (profile.type === "bunker") { + const session = await getOrCreateSession(pi); + return session.nip04Decrypt(pubKey, cipherText); + } + let privKey = await getPrivKey(); + return nip_04_exports.decryptMessage(cipherText, bytesToHex3(privKey), pubKey); + } + async function nip44Encrypt({ pubKey, plainText }) { + const pi = await getProfileIndex(); + const profile = await getProfile(pi); + if (profile.type === "bunker") { + const session = await getOrCreateSession(pi); + return session.nip44Encrypt(pubKey, plainText); + } + let privKey = await getPrivKey(); + let conversationKey = nip_44_exports.v2.utils.getConversationKey(privKey, pubKey); + return nip_44_exports.v2.encrypt(plainText, conversationKey); + } + async function nip44Decrypt({ pubKey, cipherText }) { + const pi = await getProfileIndex(); + const profile = await getProfile(pi); + if (profile.type === "bunker") { + const session = await getOrCreateSession(pi); + return session.nip44Decrypt(pubKey, cipherText); + } + let privKey = await getPrivKey(); + let conversationKey = nip_44_exports.v2.utils.getConversationKey(privKey, pubKey); + return nip_44_exports.v2.decrypt(cipherText, conversationKey); + } + async function getRelays() { + let profile = await currentProfile(); + let relays = profile.relays; + let relayObj = {}; + relays.forEach((relay) => { + let { url, read, write } = relay; + relayObj[url] = { read, write }; + }); + return relayObj; + } + async function addRelay(url) { + let parsed; + try { + parsed = new URL(url); + } catch { + throw new Error("Invalid URL"); + } + if (parsed.protocol !== "wss:") { + throw new Error("Must be a wss:// URL"); + } + let profiles = await getProfiles(); + let pi = await getProfileIndex(); + let profile = profiles[pi]; + if (!profile.relays) profile.relays = []; + if (profile.relays.some((r) => r.url === parsed.href)) { + return { success: true, message: "Relay already exists" }; + } + profile.relays.push({ url: parsed.href, read: true, write: true }); + profile.updatedAt = Math.floor(Date.now() / 1e3); + await storage4.set({ profiles }); + return { success: true, message: "Relay added" }; + } + async function exportProfileData() { + let pi = await getProfileIndex(); + let profile = await getProfile(pi); + if (!profile) throw new Error("No active profile"); + if (profile.type === "bunker") { + return { + name: profile.name, + type: "bunker", + bunkerUrl: profile.bunkerUrl || "", + exportedAt: (/* @__PURE__ */ new Date()).toISOString(), + source: "NostrKey" + }; + } + let npub = ""; + if (profile.pubKey) { + npub = nip_19_exports.npubEncode(profile.pubKey); + } + let nsec = ""; + try { + nsec = await getNsec(pi); + } catch { + throw new Error("Cannot export while locked. Please unlock first."); + } + return { + name: profile.name, + npub, + nsec, + relays: (profile.relays || []).map((r) => r.url), + exportedAt: (/* @__PURE__ */ new Date()).toISOString(), + source: "NostrKey" + }; + } + async function withRelays(mode, callback) { + const profile = await currentProfile(); + const relayList = profile.relays || []; + const urls = relayList.filter((r) => mode === "read" ? r.read : r.write).map((r) => r.url); + if (urls.length === 0) { + throw new Error("No relays configured"); + } + const connections = []; + const connectPromises = urls.map(async (url) => { + const relay = new RelayConnection(url); + try { + await relay.connect(); + connections.push(relay); + } catch (_) { + } + }); + await Promise.allSettled(connectPromises); + if (connections.length === 0) { + throw new Error("Failed to connect to any relay"); + } + try { + await callback(connections); + } finally { + for (const relay of connections) { + relay.close(); + } + } + } +})(); /*! Bundled license information: ieee754/index.js: @@ -2080,3 +12766,4 @@ buffer/index.js: @scure/bip39/index.js: (*! scure-bip39 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) *) */ +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/shims/process.js", "../../node_modules/quick-format-unescaped/index.js", "../../node_modules/pino/browser.js", "node-stub:crypto", "../../node_modules/bech32/dist/index.js", "../../node_modules/base64-js/index.js", "../../node_modules/ieee754/index.js", "../../node_modules/buffer/index.js", "../../src/background.js", "../../node_modules/nostr-crypto-utils/src/index.ts", "../../node_modules/nostr-crypto-utils/src/types/index.ts", "../../node_modules/nostr-crypto-utils/src/types/base.ts", "../../node_modules/nostr-crypto-utils/src/types/protocol.ts", "../../node_modules/nostr-crypto-utils/dist/esm/types/messages.js", "../../node_modules/nostr-crypto-utils/src/types/guards.ts", "../../node_modules/nostr-crypto-utils/src/types/nip46.ts", "../../node_modules/nostr-crypto-utils/src/crypto.ts", "../../node_modules/@noble/curves/src/secp256k1.ts", "../../node_modules/@noble/hashes/src/sha2.ts", "../../node_modules/@noble/hashes/src/_md.ts", "../../node_modules/@noble/hashes/src/utils.ts", "../../node_modules/@noble/curves/src/abstract/curve.ts", "../../node_modules/@noble/curves/src/utils.ts", "../../node_modules/@noble/curves/src/abstract/modular.ts", "../../node_modules/@noble/curves/src/abstract/weierstrass.ts", "../../node_modules/@noble/hashes/src/hmac.ts", "../../node_modules/nostr-crypto-utils/src/utils/logger.ts", "../../node_modules/nostr-crypto-utils/src/encoding/base64.ts", "../../node_modules/nostr-crypto-utils/src/validation/index.ts", "../../node_modules/nostr-crypto-utils/src/event/index.ts", "../../node_modules/nostr-crypto-utils/src/event/creation.ts", "../../node_modules/nostr-crypto-utils/src/event/signing.ts", "../../node_modules/nostr-crypto-utils/src/nips/nip-04.ts", "../../node_modules/nostr-crypto-utils/src/nips/nip-01.ts", "../../node_modules/nostr-crypto-utils/src/nips/nip-19.ts", "../../node_modules/nostr-crypto-utils/src/nips/nip-26.ts", "../../node_modules/nostr-crypto-utils/src/nips/nip-44.ts", "../../node_modules/@noble/ciphers/src/chacha.ts", "../../node_modules/@noble/ciphers/src/_arx.ts", "../../node_modules/@noble/ciphers/src/utils.ts", "../../node_modules/@noble/ciphers/src/_poly1305.ts", "../../node_modules/@noble/hashes/src/hkdf.ts", "../../node_modules/@scure/base/index.ts", "../../node_modules/nostr-crypto-utils/src/nips/nip-46.ts", "../../node_modules/nostr-crypto-utils/src/nips/nip-49.ts", "../../node_modules/@noble/hashes/src/scrypt.ts", "../../node_modules/@noble/hashes/src/pbkdf2.ts", "../../node_modules/nostr-crypto-utils/src/utils/encoding.ts", "../../src/utilities/seedphrase.js", "../../node_modules/@scure/bip39/index.js", "../../node_modules/@scure/bip39/wordlists/english.js", "../../src/utilities/keys.js", "../../node_modules/async-mutex/index.mjs", "../../src/utilities/utils.js", "../../src/utilities/browser-polyfill.js", "../../src/utilities/crypto.js", "../../src/utilities/db.js", "../../node_modules/idb/build/index.js", "../../src/utilities/sync-manager.js", "../../src/utilities/nip46.js", "../../src/utilities/bunker-server.js", "../../src/utilities/nip78.js"],
  "sourcesContent": ["/**\n * Minimal process shim for browser context.\n * Node.js libraries bundled via nostr-crypto-utils (crypto-browserify,\n * readable-stream, etc.) reference the global `process` object.\n * This provides just enough for them to work in a browser extension.\n */\nexport var process = {\n    env: { NODE_ENV: 'production', LOG_LEVEL: 'warn' },\n    browser: true,\n    version: '',\n    stdout: null,\n    stderr: null,\n    nextTick: function (fn) {\n        var args = Array.prototype.slice.call(arguments, 1);\n        Promise.resolve().then(function () { fn.apply(null, args); });\n    },\n};\n", "'use strict'\nfunction tryStringify (o) {\n  try { return JSON.stringify(o) } catch(e) { return '\"[Circular]\"' }\n}\n\nmodule.exports = format\n\nfunction format(f, args, opts) {\n  var ss = (opts && opts.stringify) || tryStringify\n  var offset = 1\n  if (typeof f === 'object' && f !== null) {\n    var len = args.length + offset\n    if (len === 1) return f\n    var objects = new Array(len)\n    objects[0] = ss(f)\n    for (var index = 1; index < len; index++) {\n      objects[index] = ss(args[index])\n    }\n    return objects.join(' ')\n  }\n  if (typeof f !== 'string') {\n    return f\n  }\n  var argLen = args.length\n  if (argLen === 0) return f\n  var str = ''\n  var a = 1 - offset\n  var lastPos = -1\n  var flen = (f && f.length) || 0\n  for (var i = 0; i < flen;) {\n    if (f.charCodeAt(i) === 37 && i + 1 < flen) {\n      lastPos = lastPos > -1 ? lastPos : 0\n      switch (f.charCodeAt(i + 1)) {\n        case 100: // 'd'\n        case 102: // 'f'\n          if (a >= argLen)\n            break\n          if (args[a] == null)  break\n          if (lastPos < i)\n            str += f.slice(lastPos, i)\n          str += Number(args[a])\n          lastPos = i + 2\n          i++\n          break\n        case 105: // 'i'\n          if (a >= argLen)\n            break\n          if (args[a] == null)  break\n          if (lastPos < i)\n            str += f.slice(lastPos, i)\n          str += Math.floor(Number(args[a]))\n          lastPos = i + 2\n          i++\n          break\n        case 79: // 'O'\n        case 111: // 'o'\n        case 106: // 'j'\n          if (a >= argLen)\n            break\n          if (args[a] === undefined) break\n          if (lastPos < i)\n            str += f.slice(lastPos, i)\n          var type = typeof args[a]\n          if (type === 'string') {\n            str += '\\'' + args[a] + '\\''\n            lastPos = i + 2\n            i++\n            break\n          }\n          if (type === 'function') {\n            str += args[a].name || '<anonymous>'\n            lastPos = i + 2\n            i++\n            break\n          }\n          str += ss(args[a])\n          lastPos = i + 2\n          i++\n          break\n        case 115: // 's'\n          if (a >= argLen)\n            break\n          if (lastPos < i)\n            str += f.slice(lastPos, i)\n          str += String(args[a])\n          lastPos = i + 2\n          i++\n          break\n        case 37: // '%'\n          if (lastPos < i)\n            str += f.slice(lastPos, i)\n          str += '%'\n          lastPos = i + 2\n          i++\n          a--\n          break\n      }\n      ++a\n    }\n    ++i\n  }\n  if (lastPos === -1)\n    return f\n  else if (lastPos < flen) {\n    str += f.slice(lastPos)\n  }\n\n  return str\n}\n", "'use strict'\n\nconst format = require('quick-format-unescaped')\n\nmodule.exports = pino\n\nconst _console = pfGlobalThisOrFallback().console || {}\nconst stdSerializers = {\n  mapHttpRequest: mock,\n  mapHttpResponse: mock,\n  wrapRequestSerializer: passthrough,\n  wrapResponseSerializer: passthrough,\n  wrapErrorSerializer: passthrough,\n  req: mock,\n  res: mock,\n  err: asErrValue,\n  errWithCause: asErrValue\n}\nfunction levelToValue (level, logger) {\n  return level === 'silent'\n    ? Infinity\n    : logger.levels.values[level]\n}\nconst baseLogFunctionSymbol = Symbol('pino.logFuncs')\nconst hierarchySymbol = Symbol('pino.hierarchy')\n\nconst logFallbackMap = {\n  error: 'log',\n  fatal: 'error',\n  warn: 'error',\n  info: 'log',\n  debug: 'log',\n  trace: 'log'\n}\n\nfunction appendChildLogger (parentLogger, childLogger) {\n  const newEntry = {\n    logger: childLogger,\n    parent: parentLogger[hierarchySymbol]\n  }\n  childLogger[hierarchySymbol] = newEntry\n}\n\nfunction setupBaseLogFunctions (logger, levels, proto) {\n  const logFunctions = {}\n  levels.forEach(level => {\n    logFunctions[level] = proto[level] ? proto[level] : (_console[level] || _console[logFallbackMap[level] || 'log'] || noop)\n  })\n  logger[baseLogFunctionSymbol] = logFunctions\n}\n\nfunction shouldSerialize (serialize, serializers) {\n  if (Array.isArray(serialize)) {\n    const hasToFilter = serialize.filter(function (k) {\n      return k !== '!stdSerializers.err'\n    })\n    return hasToFilter\n  } else if (serialize === true) {\n    return Object.keys(serializers)\n  }\n\n  return false\n}\n\nfunction pino (opts) {\n  opts = opts || {}\n  opts.browser = opts.browser || {}\n\n  const transmit = opts.browser.transmit\n  if (transmit && typeof transmit.send !== 'function') { throw Error('pino: transmit option must have a send function') }\n\n  const proto = opts.browser.write || _console\n  if (opts.browser.write) opts.browser.asObject = true\n  const serializers = opts.serializers || {}\n  const serialize = shouldSerialize(opts.browser.serialize, serializers)\n  let stdErrSerialize = opts.browser.serialize\n\n  if (\n    Array.isArray(opts.browser.serialize) &&\n    opts.browser.serialize.indexOf('!stdSerializers.err') > -1\n  ) stdErrSerialize = false\n\n  const customLevels = Object.keys(opts.customLevels || {})\n  const levels = ['error', 'fatal', 'warn', 'info', 'debug', 'trace'].concat(customLevels)\n\n  if (typeof proto === 'function') {\n    levels.forEach(function (level) {\n      proto[level] = proto\n    })\n  }\n  if (opts.enabled === false || opts.browser.disabled) opts.level = 'silent'\n  const level = opts.level || 'info'\n  const logger = Object.create(proto)\n  if (!logger.log) logger.log = noop\n\n  setupBaseLogFunctions(logger, levels, proto)\n  // setup root hierarchy entry\n  appendChildLogger({}, logger)\n\n  Object.defineProperty(logger, 'levelVal', {\n    get: getLevelVal\n  })\n  Object.defineProperty(logger, 'level', {\n    get: getLevel,\n    set: setLevel\n  })\n\n  const setOpts = {\n    transmit,\n    serialize,\n    asObject: opts.browser.asObject,\n    asObjectBindingsOnly: opts.browser.asObjectBindingsOnly,\n    formatters: opts.browser.formatters,\n    reportCaller: opts.browser.reportCaller,\n    levels,\n    timestamp: getTimeFunction(opts),\n    messageKey: opts.messageKey || 'msg',\n    onChild: opts.onChild || noop\n  }\n  logger.levels = getLevels(opts)\n  logger.level = level\n\n  logger.isLevelEnabled = function (level) {\n    if (!this.levels.values[level]) {\n      return false\n    }\n\n    return this.levels.values[level] >= this.levels.values[this.level]\n  }\n  logger.setMaxListeners = logger.getMaxListeners =\n  logger.emit = logger.addListener = logger.on =\n  logger.prependListener = logger.once =\n  logger.prependOnceListener = logger.removeListener =\n  logger.removeAllListeners = logger.listeners =\n  logger.listenerCount = logger.eventNames =\n  logger.write = logger.flush = noop\n  logger.serializers = serializers\n  logger._serialize = serialize\n  logger._stdErrSerialize = stdErrSerialize\n  logger.child = function (...args) { return child.call(this, setOpts, ...args) }\n\n  if (transmit) logger._logEvent = createLogEventShape()\n\n  function getLevelVal () {\n    return levelToValue(this.level, this)\n  }\n\n  function getLevel () {\n    return this._level\n  }\n  function setLevel (level) {\n    if (level !== 'silent' && !this.levels.values[level]) {\n      throw Error('unknown level ' + level)\n    }\n    this._level = level\n\n    set(this, setOpts, logger, 'error') // <-- must stay first\n    set(this, setOpts, logger, 'fatal')\n    set(this, setOpts, logger, 'warn')\n    set(this, setOpts, logger, 'info')\n    set(this, setOpts, logger, 'debug')\n    set(this, setOpts, logger, 'trace')\n\n    customLevels.forEach((level) => {\n      set(this, setOpts, logger, level)\n    })\n  }\n\n  function child (setOpts, bindings, childOptions) {\n    if (!bindings) {\n      throw new Error('missing bindings for child Pino')\n    }\n    childOptions = childOptions || {}\n    if (serialize && bindings.serializers) {\n      childOptions.serializers = bindings.serializers\n    }\n    const childOptionsSerializers = childOptions.serializers\n    if (serialize && childOptionsSerializers) {\n      var childSerializers = Object.assign({}, serializers, childOptionsSerializers)\n      var childSerialize = opts.browser.serialize === true\n        ? Object.keys(childSerializers)\n        : serialize\n      delete bindings.serializers\n      applySerializers([bindings], childSerialize, childSerializers, this._stdErrSerialize)\n    }\n    function Child (parent) {\n      this._childLevel = (parent._childLevel | 0) + 1\n\n      // make sure bindings are available in the `set` function\n      this.bindings = bindings\n\n      if (childSerializers) {\n        this.serializers = childSerializers\n        this._serialize = childSerialize\n      }\n      if (transmit) {\n        this._logEvent = createLogEventShape(\n          [].concat(parent._logEvent.bindings, bindings)\n        )\n      }\n    }\n    Child.prototype = this\n    const newLogger = new Child(this)\n\n    // must happen before the level is assigned\n    appendChildLogger(this, newLogger)\n    newLogger.child = function (...args) { return child.call(this, setOpts, ...args) }\n    // required to actually initialize the logger functions for any given child\n    newLogger.level = childOptions.level || this.level // allow level to be set by childOptions\n    setOpts.onChild(newLogger)\n\n    return newLogger\n  }\n  return logger\n}\n\nfunction getLevels (opts) {\n  const customLevels = opts.customLevels || {}\n\n  const values = Object.assign({}, pino.levels.values, customLevels)\n  const labels = Object.assign({}, pino.levels.labels, invertObject(customLevels))\n\n  return {\n    values,\n    labels\n  }\n}\n\nfunction invertObject (obj) {\n  const inverted = {}\n  Object.keys(obj).forEach(function (key) {\n    inverted[obj[key]] = key\n  })\n  return inverted\n}\n\npino.levels = {\n  values: {\n    fatal: 60,\n    error: 50,\n    warn: 40,\n    info: 30,\n    debug: 20,\n    trace: 10\n  },\n  labels: {\n    10: 'trace',\n    20: 'debug',\n    30: 'info',\n    40: 'warn',\n    50: 'error',\n    60: 'fatal'\n  }\n}\n\npino.stdSerializers = stdSerializers\npino.stdTimeFunctions = Object.assign({}, { nullTime, epochTime, unixTime, isoTime })\n\nfunction getBindingChain (logger) {\n  const bindings = []\n  if (logger.bindings) {\n    bindings.push(logger.bindings)\n  }\n\n  // traverse up the tree to get all bindings\n  let hierarchy = logger[hierarchySymbol]\n  while (hierarchy.parent) {\n    hierarchy = hierarchy.parent\n    if (hierarchy.logger.bindings) {\n      bindings.push(hierarchy.logger.bindings)\n    }\n  }\n\n  return bindings.reverse()\n}\n\nfunction set (self, opts, rootLogger, level) {\n  // override the current log functions with either `noop` or the base log function\n  Object.defineProperty(self, level, {\n    value: (levelToValue(self.level, rootLogger) > levelToValue(level, rootLogger)\n      ? noop\n      : rootLogger[baseLogFunctionSymbol][level]),\n    writable: true,\n    enumerable: true,\n    configurable: true\n  })\n\n  if (self[level] === noop) {\n    if (!opts.transmit) return\n\n    const transmitLevel = opts.transmit.level || self.level\n    const transmitValue = levelToValue(transmitLevel, rootLogger)\n    const methodValue = levelToValue(level, rootLogger)\n    if (methodValue < transmitValue) return\n  }\n\n  // make sure the log format is correct\n  self[level] = createWrap(self, opts, rootLogger, level)\n\n  // prepend bindings if it is not the root logger\n  const bindings = getBindingChain(self)\n  if (bindings.length === 0) {\n    // early exit in case for rootLogger\n    return\n  }\n  self[level] = prependBindingsInArguments(bindings, self[level])\n}\n\nfunction prependBindingsInArguments (bindings, logFunc) {\n  return function () {\n    return logFunc.apply(this, [...bindings, ...arguments])\n  }\n}\n\nfunction createWrap (self, opts, rootLogger, level) {\n  return (function (write) {\n    return function LOG () {\n      const ts = opts.timestamp()\n      const args = new Array(arguments.length)\n      const proto = (Object.getPrototypeOf && Object.getPrototypeOf(this) === _console) ? _console : this\n      for (var i = 0; i < args.length; i++) args[i] = arguments[i]\n\n      var argsIsSerialized = false\n      if (opts.serialize) {\n        applySerializers(args, this._serialize, this.serializers, this._stdErrSerialize)\n        argsIsSerialized = true\n      }\n      if (opts.asObject || opts.formatters) {\n        const out = asObject(this, level, args, ts, opts)\n        if (opts.reportCaller && out && out.length > 0 && out[0] && typeof out[0] === 'object') {\n          try {\n            const caller = getCallerLocation()\n            if (caller) out[0].caller = caller\n          } catch (e) {}\n        }\n        write.call(proto, ...out)\n      } else {\n        if (opts.reportCaller) {\n          try {\n            const caller = getCallerLocation()\n            if (caller) args.push(caller)\n          } catch (e) {}\n        }\n        write.apply(proto, args)\n      }\n\n      if (opts.transmit) {\n        const transmitLevel = opts.transmit.level || self._level\n        const transmitValue = levelToValue(transmitLevel, rootLogger)\n        const methodValue = levelToValue(level, rootLogger)\n        if (methodValue < transmitValue) return\n        transmit(this, {\n          ts,\n          methodLevel: level,\n          methodValue,\n          transmitLevel,\n          transmitValue: rootLogger.levels.values[opts.transmit.level || self._level],\n          send: opts.transmit.send,\n          val: levelToValue(self._level, rootLogger)\n        }, args, argsIsSerialized)\n      }\n    }\n  })(self[baseLogFunctionSymbol][level])\n}\n\nfunction asObject (logger, level, args, ts, opts) {\n  const {\n    level: levelFormatter,\n    log: logObjectFormatter = (obj) => obj\n  } = opts.formatters || {}\n  const argsCloned = args.slice()\n  let msg = argsCloned[0]\n  const logObject = {}\n\n  let lvl = (logger._childLevel | 0) + 1\n  if (lvl < 1) lvl = 1\n\n  if (ts) {\n    logObject.time = ts\n  }\n\n  if (levelFormatter) {\n    const formattedLevel = levelFormatter(level, logger.levels.values[level])\n    Object.assign(logObject, formattedLevel)\n  } else {\n    logObject.level = logger.levels.values[level]\n  }\n\n  if (opts.asObjectBindingsOnly) {\n    if (msg !== null && typeof msg === 'object') {\n      while (lvl-- && typeof argsCloned[0] === 'object') {\n        Object.assign(logObject, argsCloned.shift())\n      }\n    }\n\n    const formattedLogObject = logObjectFormatter(logObject)\n    return [formattedLogObject, ...argsCloned]\n  } else {\n    // deliberate, catching objects, arrays\n    if (msg !== null && typeof msg === 'object') {\n      while (lvl-- && typeof argsCloned[0] === 'object') {\n        Object.assign(logObject, argsCloned.shift())\n      }\n      msg = argsCloned.length ? format(argsCloned.shift(), argsCloned) : undefined\n    } else if (typeof msg === 'string') msg = format(argsCloned.shift(), argsCloned)\n    if (msg !== undefined) logObject[opts.messageKey] = msg\n\n    const formattedLogObject = logObjectFormatter(logObject)\n    return [formattedLogObject]\n  }\n}\n\nfunction applySerializers (args, serialize, serializers, stdErrSerialize) {\n  for (const i in args) {\n    if (stdErrSerialize && args[i] instanceof Error) {\n      args[i] = pino.stdSerializers.err(args[i])\n    } else if (typeof args[i] === 'object' && !Array.isArray(args[i]) && serialize) {\n      for (const k in args[i]) {\n        if (serialize.indexOf(k) > -1 && k in serializers) {\n          args[i][k] = serializers[k](args[i][k])\n        }\n      }\n    }\n  }\n}\n\nfunction transmit (logger, opts, args, argsIsSerialized = false) {\n  const send = opts.send\n  const ts = opts.ts\n  const methodLevel = opts.methodLevel\n  const methodValue = opts.methodValue\n  const val = opts.val\n  const bindings = logger._logEvent.bindings\n\n  if (!argsIsSerialized) {\n    applySerializers(\n      args,\n      logger._serialize || Object.keys(logger.serializers),\n      logger.serializers,\n      logger._stdErrSerialize === undefined ? true : logger._stdErrSerialize\n    )\n  }\n\n  logger._logEvent.ts = ts\n  logger._logEvent.messages = args.filter(function (arg) {\n    // bindings can only be objects, so reference equality check via indexOf is fine\n    return bindings.indexOf(arg) === -1\n  })\n\n  logger._logEvent.level.label = methodLevel\n  logger._logEvent.level.value = methodValue\n\n  send(methodLevel, logger._logEvent, val)\n\n  logger._logEvent = createLogEventShape(bindings)\n}\n\nfunction createLogEventShape (bindings) {\n  return {\n    ts: 0,\n    messages: [],\n    bindings: bindings || [],\n    level: { label: '', value: 0 }\n  }\n}\n\nfunction asErrValue (err) {\n  const obj = {\n    type: err.constructor.name,\n    msg: err.message,\n    stack: err.stack\n  }\n  for (const key in err) {\n    if (obj[key] === undefined) {\n      obj[key] = err[key]\n    }\n  }\n  return obj\n}\n\nfunction getTimeFunction (opts) {\n  if (typeof opts.timestamp === 'function') {\n    return opts.timestamp\n  }\n  if (opts.timestamp === false) {\n    return nullTime\n  }\n  return epochTime\n}\n\nfunction mock () { return {} }\nfunction passthrough (a) { return a }\nfunction noop () {}\n\nfunction nullTime () { return false }\nfunction epochTime () { return Date.now() }\nfunction unixTime () { return Math.round(Date.now() / 1000.0) }\nfunction isoTime () { return new Date(Date.now()).toISOString() } // using Date.now() for testability\n\n/* eslint-disable */\n/* istanbul ignore next */\nfunction pfGlobalThisOrFallback () {\n  function defd (o) { return typeof o !== 'undefined' && o }\n  try {\n    if (typeof globalThis !== 'undefined') return globalThis\n    Object.defineProperty(Object.prototype, 'globalThis', {\n      get: function () {\n        delete Object.prototype.globalThis\n        return (this.globalThis = this)\n      },\n      configurable: true\n    })\n    return globalThis\n  } catch (e) {\n    return defd(self) || defd(window) || defd(this) || {}\n  }\n}\n/* eslint-enable */\n\nmodule.exports.default = pino\nmodule.exports.pino = pino\n\n// Attempt to extract the user callsite (file:line:column)\n/* istanbul ignore next */\nfunction getCallerLocation () {\n  const stack = (new Error()).stack\n  if (!stack) return null\n  const lines = stack.split('\\n')\n  for (let i = 1; i < lines.length; i++) {\n    const l = lines[i].trim()\n    // skip frames from this file and internals\n    if (/(^at\\s+)?(createWrap|LOG|set\\s*\\(|asObject|Object\\.apply|Function\\.apply)/.test(l)) continue\n    if (l.indexOf('browser.js') !== -1) continue\n    if (l.indexOf('node:internal') !== -1) continue\n    if (l.indexOf('node_modules') !== -1) continue\n    // try formats like: at func (file:line:col) or at file:line:col\n    let m = l.match(/\\((.*?):(\\d+):(\\d+)\\)/)\n    if (!m) m = l.match(/at\\s+(.*?):(\\d+):(\\d+)/)\n    if (m) {\n      const file = m[1]\n      const line = m[2]\n      const col = m[3]\n      return file + ':' + line + ':' + col\n    }\n  }\n  return null\n}\n", "module.exports = {};", "'use strict';\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.bech32m = exports.bech32 = void 0;\nconst ALPHABET = 'qpzry9x8gf2tvdw0s3jn54khce6mua7l';\nconst ALPHABET_MAP = {};\nfor (let z = 0; z < ALPHABET.length; z++) {\n    const x = ALPHABET.charAt(z);\n    ALPHABET_MAP[x] = z;\n}\nfunction polymodStep(pre) {\n    const b = pre >> 25;\n    return (((pre & 0x1ffffff) << 5) ^\n        (-((b >> 0) & 1) & 0x3b6a57b2) ^\n        (-((b >> 1) & 1) & 0x26508e6d) ^\n        (-((b >> 2) & 1) & 0x1ea119fa) ^\n        (-((b >> 3) & 1) & 0x3d4233dd) ^\n        (-((b >> 4) & 1) & 0x2a1462b3));\n}\nfunction prefixChk(prefix) {\n    let chk = 1;\n    for (let i = 0; i < prefix.length; ++i) {\n        const c = prefix.charCodeAt(i);\n        if (c < 33 || c > 126)\n            return 'Invalid prefix (' + prefix + ')';\n        chk = polymodStep(chk) ^ (c >> 5);\n    }\n    chk = polymodStep(chk);\n    for (let i = 0; i < prefix.length; ++i) {\n        const v = prefix.charCodeAt(i);\n        chk = polymodStep(chk) ^ (v & 0x1f);\n    }\n    return chk;\n}\nfunction convert(data, inBits, outBits, pad) {\n    let value = 0;\n    let bits = 0;\n    const maxV = (1 << outBits) - 1;\n    const result = [];\n    for (let i = 0; i < data.length; ++i) {\n        value = (value << inBits) | data[i];\n        bits += inBits;\n        while (bits >= outBits) {\n            bits -= outBits;\n            result.push((value >> bits) & maxV);\n        }\n    }\n    if (pad) {\n        if (bits > 0) {\n            result.push((value << (outBits - bits)) & maxV);\n        }\n    }\n    else {\n        if (bits >= inBits)\n            return 'Excess padding';\n        if ((value << (outBits - bits)) & maxV)\n            return 'Non-zero padding';\n    }\n    return result;\n}\nfunction toWords(bytes) {\n    return convert(bytes, 8, 5, true);\n}\nfunction fromWordsUnsafe(words) {\n    const res = convert(words, 5, 8, false);\n    if (Array.isArray(res))\n        return res;\n}\nfunction fromWords(words) {\n    const res = convert(words, 5, 8, false);\n    if (Array.isArray(res))\n        return res;\n    throw new Error(res);\n}\nfunction getLibraryFromEncoding(encoding) {\n    let ENCODING_CONST;\n    if (encoding === 'bech32') {\n        ENCODING_CONST = 1;\n    }\n    else {\n        ENCODING_CONST = 0x2bc830a3;\n    }\n    function encode(prefix, words, LIMIT) {\n        LIMIT = LIMIT || 90;\n        if (prefix.length + 7 + words.length > LIMIT)\n            throw new TypeError('Exceeds length limit');\n        prefix = prefix.toLowerCase();\n        // determine chk mod\n        let chk = prefixChk(prefix);\n        if (typeof chk === 'string')\n            throw new Error(chk);\n        let result = prefix + '1';\n        for (let i = 0; i < words.length; ++i) {\n            const x = words[i];\n            if (x >> 5 !== 0)\n                throw new Error('Non 5-bit word');\n            chk = polymodStep(chk) ^ x;\n            result += ALPHABET.charAt(x);\n        }\n        for (let i = 0; i < 6; ++i) {\n            chk = polymodStep(chk);\n        }\n        chk ^= ENCODING_CONST;\n        for (let i = 0; i < 6; ++i) {\n            const v = (chk >> ((5 - i) * 5)) & 0x1f;\n            result += ALPHABET.charAt(v);\n        }\n        return result;\n    }\n    function __decode(str, LIMIT) {\n        LIMIT = LIMIT || 90;\n        if (str.length < 8)\n            return str + ' too short';\n        if (str.length > LIMIT)\n            return 'Exceeds length limit';\n        // don't allow mixed case\n        const lowered = str.toLowerCase();\n        const uppered = str.toUpperCase();\n        if (str !== lowered && str !== uppered)\n            return 'Mixed-case string ' + str;\n        str = lowered;\n        const split = str.lastIndexOf('1');\n        if (split === -1)\n            return 'No separator character for ' + str;\n        if (split === 0)\n            return 'Missing prefix for ' + str;\n        const prefix = str.slice(0, split);\n        const wordChars = str.slice(split + 1);\n        if (wordChars.length < 6)\n            return 'Data too short';\n        let chk = prefixChk(prefix);\n        if (typeof chk === 'string')\n            return chk;\n        const words = [];\n        for (let i = 0; i < wordChars.length; ++i) {\n            const c = wordChars.charAt(i);\n            const v = ALPHABET_MAP[c];\n            if (v === undefined)\n                return 'Unknown character ' + c;\n            chk = polymodStep(chk) ^ v;\n            // not in the checksum?\n            if (i + 6 >= wordChars.length)\n                continue;\n            words.push(v);\n        }\n        if (chk !== ENCODING_CONST)\n            return 'Invalid checksum for ' + str;\n        return { prefix, words };\n    }\n    function decodeUnsafe(str, LIMIT) {\n        const res = __decode(str, LIMIT);\n        if (typeof res === 'object')\n            return res;\n    }\n    function decode(str, LIMIT) {\n        const res = __decode(str, LIMIT);\n        if (typeof res === 'object')\n            return res;\n        throw new Error(res);\n    }\n    return {\n        decodeUnsafe,\n        decode,\n        encode,\n        toWords,\n        fromWordsUnsafe,\n        fromWords,\n    };\n}\nexports.bech32 = getLibraryFromEncoding('bech32');\nexports.bech32m = getLibraryFromEncoding('bech32m');\n", "'use strict'\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", "/*! 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 * 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'use strict'\n\nconst base64 = require('base64-js')\nconst ieee754 = require('ieee754')\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", "import {\n    nip04,\n    nip44,\n    nip19,\n    getPublicKeySync,\n    finalizeEvent,\n    bytesToHex,\n    hexToBytes,\n} from 'nostr-crypto-utils';\nimport { encrypt as nip49Encrypt, decrypt as nip49Decrypt } from 'nostr-crypto-utils/nip49';\nimport { keyToSeedPhrase, seedPhraseToKey, isValidSeedPhrase } from './utilities/seedphrase.js';\nimport { generateKeyPair } from './utilities/keys.js';\nimport { Mutex } from 'async-mutex';\nimport {\n    getProfileIndex,\n    get,\n    getProfile,\n    getProfiles,\n    getPermission,\n    setPermission,\n    isEncrypted,\n    checkPassword,\n    encryptAllKeys,\n    changePasswordForKeys,\n    removePasswordProtection,\n    getDecryptedPrivKey,\n    isEncryptedBlob,\n} from './utilities/utils';\nimport { encrypt as encryptBlob, decrypt as decryptBlob, encryptWithKey, deriveKey } from './utilities/crypto';\nimport { saveEvent } from './utilities/db';\nimport { api } from './utilities/browser-polyfill';\nimport { initSync, scheduleSyncPush } from './utilities/sync-manager';\nimport {\n    RelayConnection,\n    getOrCreateSession,\n    createSession,\n    disconnectSession,\n    isSessionActive,\n    validateBunkerUrl,\n} from './utilities/nip46';\nimport { BunkerServer } from './utilities/bunker-server';\nimport {\n    buildVaultEvent,\n    buildVaultDeletion,\n    buildVaultFilter,\n    parseVaultEvent,\n} from './utilities/nip78';\n\n// Wrap storage.local with an interceptor that auto-triggers sync push on writes\nconst _rawStorage = api.storage.local;\nconst storage = {\n    get: (...args) => _rawStorage.get(...args),\n    set: (...args) => {\n        const result = _rawStorage.set(...args);\n        result.then(() => scheduleSyncPush()).catch(() => {});\n        return result;\n    },\n    clear: (...args) => _rawStorage.clear(...args),\n    remove: (...args) => _rawStorage.remove(...args),\n};\nconst log = msg => console.log('Background: ', msg);\nconst validations = {};\nlet prompt = { mutex: new Mutex(), release: null, tabId: null };\nlet pendingQueue = { total: 0, processed: 0 };\nlet activeBunkerServer = null;\n\n/**\n * Helper: run an async function and deliver the result via sendResponse.\n * Chrome MV3 does not reliably deliver Promise-return values from onMessage\n * listeners \u2014 only the sendResponse callback pattern works.  Use this with\n * `return true;` in the switch case to keep the message channel open.\n */\nfunction reply(sendResponse, fn) {\n    fn().then(r => sendResponse(r)).catch(e => {\n        console.error('reply() error:', e);\n        sendResponse(undefined);\n    });\n}\n\n// Rate limiter: max 5 permission prompts per host per 10-second window\nconst rateLimits = new Map();\nconst RATE_LIMIT_MAX = 5;\nconst RATE_LIMIT_WINDOW = 10000;\n\nfunction isRateLimited(host) {\n    const now = Date.now();\n    let timestamps = rateLimits.get(host) || [];\n    timestamps = timestamps.filter(t => now - t < RATE_LIMIT_WINDOW);\n    if (timestamps.length >= RATE_LIMIT_MAX) {\n        rateLimits.set(host, timestamps);\n        return true;\n    }\n    timestamps.push(now);\n    rateLimits.set(host, timestamps);\n    return false;\n}\n\n// --- Session state for master password encryption ---------------------------\n// Decrypted keys are held in memory only while unlocked.\n// Map of profileIndex -> hex private key string\nconst sessionKeys = new Map();\nlet sessionCryptoKey = null; // derived AES-256-GCM key (opaque CryptoKey, not raw password)\nlet sessionKeySalt = null;   // salt used to derive sessionCryptoKey\nlet locked = true; // start locked; determined on first isLocked check\nlet encryptionEnabled = false; // cached encryption state for fast lookups\nlet autoLockTimeout = 15 * 60 * 1000; // 15 minutes default\nlet autoLockTimer = null;\nlet nostrAccessWhileLocked = false;\n\nlet blockCrossOriginFrames = true;\n\n// Brute-force protection for unlock attempts\nlet unlockAttempts = 0;\nlet unlockCooldownUntil = 0;\n\n// Permission request rate limiting per origin\nconst permissionRateMap = new Map(); // host \u2192 { count, resetAt }\n\n// Load persisted state on startup\n(async () => {\n    log('[STARTUP] Reading persisted state...');\n    const data = await storage.get({ autoLockMinutes: 15, isEncrypted: false, passwordHash: null, nostrAccessWhileLocked: false, blockCrossOriginFrames: true });\n    log(`[STARTUP] isEncrypted=${data.isEncrypted}, passwordHash=${data.passwordHash ? 'EXISTS' : 'null'}, autoLockMinutes=${data.autoLockMinutes}`);\n    autoLockTimeout = data.autoLockMinutes * 60 * 1000;\n    // Defensive: if passwordHash exists but flag is stale, self-heal\n    if (!data.isEncrypted && data.passwordHash) {\n        log('[STARTUP] Self-healing: passwordHash exists but isEncrypted=false \u2192 fixing');\n        await storage.set({ isEncrypted: true });\n        data.isEncrypted = true;\n    }\n    // Lockout recovery: if isEncrypted=true but there is NO password verifier AND\n    // no actually-encrypted key blobs, encryption is bogus (e.g. a stale flag\n    // received from an older buggy sync). Clearing it prevents a permanent lockout\n    // where the user can never unlock because checkPassword() always fails.\n    // We ONLY clear when no encrypted blobs exist \u2014 never when real ciphertext is\n    // present (that would corrupt encrypted keys into \"plaintext\").\n    if (data.isEncrypted && !data.passwordHash) {\n        const { profiles = [] } = await storage.get({ profiles: [] });\n        const hasEncryptedBlob = profiles.some(p => isEncryptedBlob(p.privKey));\n        if (!hasEncryptedBlob) {\n            log('[STARTUP] Lockout recovery: isEncrypted=true with no passwordHash and no encrypted blobs \u2192 clearing bogus encryption flag');\n            await storage.set({ isEncrypted: false });\n            data.isEncrypted = false;\n        }\n    }\n    encryptionEnabled = data.isEncrypted;\n    nostrAccessWhileLocked = !!data.nostrAccessWhileLocked;\n    blockCrossOriginFrames = data.blockCrossOriginFrames !== false;\n    // If encryption is enabled, we start locked\n    locked = encryptionEnabled;\n    log(`[STARTUP] Final state: encryptionEnabled=${encryptionEnabled}, locked=${locked}`);\n\n    // Initialize platform sync (pull from sync, register listener)\n    try {\n        await initSync();\n        log('[STARTUP] Platform sync initialized');\n    } catch (e) {\n        log(`[STARTUP] Platform sync init error (non-fatal): ${e.message}`);\n    }\n\n    // Check for profiles shared from the iOS app via App Groups (Safari only)\n    try {\n        if (typeof browser !== 'undefined' && browser.runtime.sendNativeMessage) {\n            const response = await browser.runtime.sendNativeMessage(\n                'com.nostrkey.Extension',\n                { action: 'getSharedProfiles' }\n            );\n            if (response && response.profiles && response.profiles.length > 0) {\n                const local = await storage.get({ profiles: [] });\n                const merged = mergeSharedProfiles(local.profiles, response.profiles);\n                if (merged.changed) {\n                    await storage.set({ profiles: merged.profiles });\n                    log(`[STARTUP] Merged ${response.profiles.length} shared profile(s) from iOS app`);\n                }\n            }\n        }\n    } catch (e) {\n        // Not Safari, or shared storage unavailable \u2014 ignore\n        log(`[STARTUP] Shared profiles check skipped: ${e.message}`);\n    }\n})();\n\n/**\n * Merge profiles shared from the iOS app into the local profile list.\n * For each shared profile, if no local profile has the same pubKey, add it.\n * If a local profile has the same pubKey, keep the one with the newer updatedAt.\n * @returns {{ profiles: Array, changed: boolean }}\n */\nfunction mergeSharedProfiles(localProfiles, sharedProfiles) {\n    let changed = false;\n    const profiles = [...localProfiles];\n\n    for (const shared of sharedProfiles) {\n        if (!shared.pubKey) continue;\n\n        const localIndex = profiles.findIndex(p => p.pubKey === shared.pubKey);\n\n        if (localIndex === -1) {\n            // New profile from app \u2014 add it\n            profiles.push({\n                name: shared.name || 'Shared Profile',\n                privKey: shared.privKey || '',\n                pubKey: shared.pubKey,\n                hosts: {},\n                relays: shared.relays || [],\n                type: 'local',\n                updatedAt: shared.lastSyncedAt ? new Date(shared.lastSyncedAt).getTime() : Date.now(),\n            });\n            changed = true;\n        } else {\n            // Existing profile \u2014 update if shared is newer and has a key we don't\n            const local = profiles[localIndex];\n            const localTime = local.updatedAt || 0;\n            const sharedTime = shared.lastSyncedAt ? new Date(shared.lastSyncedAt).getTime() : 0;\n\n            if (sharedTime > localTime && shared.privKey && !local.privKey) {\n                profiles[localIndex] = {\n                    ...local,\n                    privKey: shared.privKey,\n                    name: shared.name || local.name,\n                    relays: shared.relays || local.relays,\n                    updatedAt: sharedTime,\n                };\n                changed = true;\n            }\n        }\n    }\n\n    return { profiles, changed };\n}\n\n/**\n * Reset the auto-lock inactivity timer.\n */\nconst AUTO_LOCK_ALARM = 'nostrkey-auto-lock';\n\nfunction resetAutoLock() {\n    // Clear any existing timer (setTimeout fallback)\n    if (autoLockTimer) { clearTimeout(autoLockTimer); autoLockTimer = null; }\n\n    if (locked || autoLockTimeout <= 0) {\n        // No timer needed \u2014 also clear any pending alarm\n        api.alarms?.clear(AUTO_LOCK_ALARM).catch(() => {});\n        return;\n    }\n\n    // Prefer chrome.alarms (survives MV3 service-worker eviction)\n    if (api.alarms) {\n        api.alarms.create(AUTO_LOCK_ALARM, { delayInMinutes: autoLockTimeout / 60000 });\n    } else {\n        // Fallback for environments without alarms API (Safari background page)\n        autoLockTimer = setTimeout(() => { lockSession(); }, autoLockTimeout);\n    }\n}\n\n// Listen for the alarm to fire\nif (api.alarms?.onAlarm) {\n    api.alarms.onAlarm.addListener((alarm) => {\n        if (alarm.name === AUTO_LOCK_ALARM) {\n            lockSession();\n        }\n    });\n}\n\n/**\n * Mutex that serializes lockSession / unlockSession so the auto-lock\n * timer callback cannot interleave with an in-progress unlock.\n */\nconst sessionMutex = new Mutex();\n\n/**\n * Lock the session \u2014 clear all decrypted keys from memory.\n */\nasync function lockSession() {\n    const release = await sessionMutex.acquire();\n    try {\n        if (!nostrAccessWhileLocked) {\n            sessionKeys.clear();\n        }\n        sessionCryptoKey = null;\n        sessionKeySalt = null;\n        locked = true;\n        if (autoLockTimer) {\n            clearTimeout(autoLockTimer);\n            autoLockTimer = null;\n        }\n        log(`Session locked. Keys retained: ${nostrAccessWhileLocked && sessionKeys.size > 0}`);\n    } finally {\n        release();\n    }\n}\n\n/**\n * Unlock the session \u2014 verify password and decrypt all keys into memory.\n */\nasync function unlockSession(password) {\n    const release = await sessionMutex.acquire();\n    try {\n        // Brute-force protection: cooldown after 3 failed attempts\n        const now = Date.now();\n        if (now < unlockCooldownUntil) {\n            const waitSec = Math.ceil((unlockCooldownUntil - now) / 1000);\n            return { success: false, error: `Too many attempts. Try again in ${waitSec} seconds.` };\n        }\n\n        const valid = await checkPassword(password);\n        if (!valid) {\n            unlockAttempts++;\n            if (unlockAttempts >= 3) {\n                // Cooldown: 30s after 3, 60s after 6, 120s after 9, etc.\n                const cooldownMs = 30000 * Math.pow(2, Math.floor((unlockAttempts - 3) / 3));\n                unlockCooldownUntil = Date.now() + cooldownMs;\n                log(`[SECURITY] ${unlockAttempts} failed attempts. Cooldown: ${cooldownMs / 1000}s`);\n            }\n            return { success: false, error: 'Invalid password' };\n        }\n\n        // Reset on successful unlock\n        unlockAttempts = 0;\n        unlockCooldownUntil = 0;\n\n        const profiles = await getProfiles();\n        let needsSave = false;\n        for (let i = 0; i < profiles.length; i++) {\n            if (profiles[i].type === 'bunker') continue;\n            const hex = await getDecryptedPrivKey(profiles[i], password);\n            sessionKeys.set(i, hex);\n            // Cache pubKey if not already cached (for profiles encrypted before this fix)\n            if (!profiles[i].pubKey && hex) {\n                try {\n                    profiles[i].pubKey = getPublicKeySync(hex);\n                    needsSave = true;\n                } catch (e) {\n                    console.error(`Failed to cache pubKey for profile ${i}:`, e);\n                }\n            }\n        }\n        if (needsSave) {\n            await storage.set({ profiles });\n        }\n        // Derive a session CryptoKey so we never hold the raw password in memory.\n        // The salt is random per session; decrypt() still uses the password at\n        // next unlock to re-derive from whatever salt was stored in each blob.\n        const salt = crypto.getRandomValues(new Uint8Array(16));\n        sessionCryptoKey = await deriveKey(password, salt);\n        sessionKeySalt = salt;\n        // password is now only on the call stack and will be GC'd\n        locked = false;\n        resetAutoLock();\n        log('Session unlocked.');\n        return { success: true };\n    } finally {\n        release();\n    }\n}\n\n/**\n * Check whether the extension is currently in a locked state.\n * If no password is set, we are never locked.\n */\nasync function checkLockState() {\n    const encrypted = await isEncrypted();\n    log(`[checkLockState] isEncrypted()=${encrypted}, locked=${locked}`);\n    if (!encrypted) {\n        locked = false;\n        return false;\n    }\n    return locked;\n}\n\n// --- Sender validation -------------------------------------------------------\n\nconst SENSITIVE_KINDS = new Set([\n    'setPassword', 'changePassword', 'removePassword', 'resetAllData',\n    'setAutoLockTimeout', 'setNostrAccessWhileLocked', 'setBlockCrossOriginFrames',\n    'backup.export', 'backup.import', 'unlock',\n]);\n\nfunction isExtensionSender(sender) {\n    // Messages from extension pages (popup, sidepanel, options, vault) have our ID.\n    // Content scripts inject into web pages \u2014 they have sender.tab but their URL\n    // is the web page URL, not our extension URL. Extension pages opened in tabs\n    // (like vault.html) also have sender.tab but their URL starts with our origin.\n    if (sender.id !== api.runtime.id) return false;\n    // If opened in a tab, check the URL is actually our extension (not a content script)\n    if (sender.tab) {\n        const extOrigin = `chrome-extension://${api.runtime.id}`;\n        const url = sender.tab.url || sender.url || '';\n        return url.startsWith(extOrigin) || url.startsWith('moz-extension://');\n    }\n    return true;\n}\n\n// --- Message handler --------------------------------------------------------\n\napi.runtime.onMessage.addListener((message, _sender, sendResponse) => {\n    log(message);\n\n    // Block sensitive operations from non-extension contexts\n    if (SENSITIVE_KINDS.has(message.kind) && !isExtensionSender(_sender)) {\n        log(`[SECURITY] Blocked ${message.kind} from non-extension sender`);\n        sendResponse({ success: false, error: 'Unauthorized sender' });\n        return true;\n    }\n\n    let uuid = crypto.randomUUID();\n    let sr;\n\n    switch (message.kind) {\n        // General\n        case 'closePrompt':\n            prompt.release?.();\n            sendResponse(true);\n            return true;\n        case 'allowed':\n            resetAutoLock();\n            complete(message);\n            sendResponse(true);\n            return true;\n        case 'denied':\n            deny(message);\n            sendResponse(true);\n            return true;\n        case 'generatePrivateKey':\n            (async () => {\n                try {\n                    const result = await generatePrivateKey_();\n                    sendResponse(result);\n                } catch (e) {\n                    console.error('generatePrivateKey error:', e);\n                    sendResponse(null);\n                }\n            })();\n            return true; // Keep message channel open for async sendResponse\n        case 'savePrivateKey':\n            resetAutoLock();\n            // Must use sendResponse + return true (not a Promise return): Chrome MV3\n            // does not deliver Promise-return values to sendMessage callers, so the\n            // caller could not tell whether the key was actually saved (or whether it\n            // threw). That made imported keys silently fail while the UI showed success.\n            (async () => {\n                try {\n                    await savePrivateKey(message.payload);\n                    sendResponse({ success: true });\n                } catch (e) {\n                    console.error('savePrivateKey error:', e);\n                    sendResponse({ success: false, error: e.message || 'Failed to save key' });\n                }\n            })();\n            return true;\n        case 'getNpub':\n            (async () => {\n                try {\n                    const result = await getNpub(message.payload);\n                    sendResponse(result);\n                } catch (e) {\n                    console.error('getNpub error:', e);\n                    sendResponse(null);\n                }\n            })();\n            return true;\n        case 'getNsec':\n            resetAutoLock();\n            (async () => {\n                try {\n                    const result = await getNsec(message.payload);\n                    sendResponse(result);\n                } catch (e) {\n                    console.error('getNsec error:', e);\n                    sendResponse(null);\n                }\n            })();\n            return true;\n        case 'calcPubKey':\n            sendResponse(getPublicKeySync(message.payload));\n            return true;\n        case 'npubEncode':\n            sendResponse(nip19.npubEncode(message.payload));\n            return true;\n        case 'copy':\n            // navigator.clipboard is unavailable in Chrome service workers.\n            // The caller (popup/options) should handle clipboard directly when\n            // possible; this path is kept for Safari background-page compat.\n            if (typeof navigator !== 'undefined' && navigator.clipboard?.writeText) {\n                navigator.clipboard.writeText(message.payload).then(() => sendResponse(true)).catch(() => sendResponse(false));\n            } else {\n                sendResponse(false);\n            }\n            return true;\n\n        // --- Master password / lock handlers ---\n        // NOTE: These use sendResponse + return true (callback pattern) because\n        // Chrome MV3 does not reliably deliver Promise-return values from\n        // onMessage listeners to sendMessage callers.\n        case 'isLocked':\n            (async () => {\n                try {\n                    const result = await checkLockState();\n                    log(`[isLocked] Sending response: ${result}`);\n                    sendResponse(result);\n                } catch (e) {\n                    log(`[isLocked] Error: ${e.message}`);\n                    sendResponse(false);\n                }\n            })();\n            return true;\n        case 'isEncrypted':\n            (async () => {\n                try {\n                    const data = await storage.get({ isEncrypted: false, passwordHash: null });\n                    log(`[isEncrypted] storage: isEncrypted=${data.isEncrypted}, passwordHash=${data.passwordHash ? 'EXISTS' : 'null'}`);\n                    if (!data.isEncrypted && data.passwordHash) {\n                        log('[isEncrypted] Self-healing: passwordHash exists but flag=false');\n                        await storage.set({ isEncrypted: true });\n                        data.isEncrypted = true;\n                    }\n                    encryptionEnabled = data.isEncrypted;\n                    log(`[isEncrypted] Sending response: ${encryptionEnabled}`);\n                    sendResponse(encryptionEnabled);\n                } catch (e) {\n                    log(`[isEncrypted] Error: ${e.message}`);\n                    sendResponse(false);\n                }\n            })();\n            return true;\n        case 'hasEncryptedData':\n            (async () => {\n                try {\n                    const data = await storage.get({ passwordHash: null, profiles: [] });\n                    const hasPasswordHash = !!data.passwordHash;\n                    let encryptedProfiles = 0;\n                    log(`[hasEncryptedData] passwordHash=${hasPasswordHash}, profiles=${Array.isArray(data.profiles) ? data.profiles.length : 'not-array'}`);\n                    if (Array.isArray(data.profiles)) {\n                        for (let i = 0; i < data.profiles.length; i++) {\n                            const p = data.profiles[i];\n                            const isEnc = p.privKey ? isEncryptedBlob(p.privKey) : false;\n                            log(`[hasEncryptedData] profile[${i}] name=\"${p.name}\" privKey=${p.privKey ? (isEnc ? 'ENCRYPTED' : 'PLAINTEXT') : 'EMPTY'}`);\n                            if (isEnc) encryptedProfiles++;\n                        }\n                    }\n                    const found = hasPasswordHash || encryptedProfiles > 0;\n                    log(`[hasEncryptedData] Result: found=${found}, hasPasswordHash=${hasPasswordHash}, encryptedProfiles=${encryptedProfiles}`);\n                    if (found && !encryptionEnabled) {\n                        log('[hasEncryptedData] Self-healing: setting isEncrypted=true, locked=true');\n                        await storage.set({ isEncrypted: true });\n                        encryptionEnabled = true;\n                        locked = true;\n                    }\n                    sendResponse({ found, hasPasswordHash, encryptedProfiles });\n                } catch (e) {\n                    console.error('hasEncryptedData error:', e);\n                    sendResponse({ found: false, hasPasswordHash: false, encryptedProfiles: 0 });\n                }\n            })();\n            return true;\n        case 'unlock':\n            reply(sendResponse, () => unlockSession(message.payload));\n            return true;\n        case 'lock':\n            lockSession().then(() => sendResponse(true));\n            return true;\n        case 'setPassword':\n            (async () => {\n                try {\n                    // Cache pubKeys before encryption (need plaintext keys)\n                    await cachePubKeysForAllProfiles();\n                    await encryptAllKeys(message.payload);\n                    encryptionEnabled = true;\n                    const result = await unlockSession(message.payload);\n                    // Broadcast password state change to all views\n                    api.runtime.sendMessage({ kind: 'passwordStateChanged', hasPassword: true }).catch(() => {});\n                    api.runtime.sendMessage({ kind: 'backupNeeded' }).catch(() => {});\n                    sendResponse(result);\n                } catch (e) {\n                    sendResponse({ success: false, error: e.message });\n                }\n            })();\n            return true;\n        case 'changePassword':\n            (async () => {\n                try {\n                    const { oldPassword, newPassword } = message.payload;\n                    const valid = await checkPassword(oldPassword);\n                    if (!valid) {\n                        sendResponse({ success: false, error: 'Invalid current password' });\n                        return;\n                    }\n                    await changePasswordForKeys(oldPassword, newPassword);\n                    const result = await unlockSession(newPassword);\n                    // Broadcast password state change to all views\n                    api.runtime.sendMessage({ kind: 'passwordStateChanged', hasPassword: true }).catch(() => {});\n                    api.runtime.sendMessage({ kind: 'backupNeeded' }).catch(() => {});\n                    sendResponse(result);\n                } catch (e) {\n                    sendResponse({ success: false, error: e.message });\n                }\n            })();\n            return true;\n        case 'removePassword':\n            (async () => {\n                try {\n                    await removePasswordProtection(message.payload);\n                    sessionKeys.clear();\n                    sessionCryptoKey = null;\n                    sessionKeySalt = null;\n                    locked = false;\n                    encryptionEnabled = false;\n                    // Broadcast password state change to all views\n                    api.runtime.sendMessage({ kind: 'passwordStateChanged', hasPassword: false }).catch(() => {});\n                    sendResponse({ success: true });\n                } catch (e) {\n                    sendResponse({ success: false, error: e.message });\n                }\n            })();\n            return true;\n        case 'resetAllData':\n            (async () => {\n                try {\n                    // Clear all extension data and reset to fresh state\n                    await storage.clear();\n                    sessionKeys.clear();\n                    sessionCryptoKey = null;\n                    sessionKeySalt = null;\n                    locked = false;\n                    encryptionEnabled = false;\n                    nostrAccessWhileLocked = false;\n                    blockCrossOriginFrames = true;\n                    // Re-initialize with default profile\n                    await storage.set({\n                        profiles: [{ name: 'Default Nostr Profile', privKey: '', pubKey: '' }],\n                        profileIndex: 0,\n                        isEncrypted: false,\n                        passwordHash: null,\n                        passwordSalt: null,\n                    });\n                    api.runtime.sendMessage({ kind: 'dataReset' }).catch(() => {});\n                    sendResponse({ success: true });\n                } catch (e) {\n                    sendResponse({ success: false, error: e.message });\n                }\n            })();\n            return true;\n        case 'setAutoLockTimeout': {\n            const ALLOWED_LOCK_MINUTES = [0, 5, 15, 30, 60, 90, 180];\n            const mins = Number(message.payload);\n            if (!ALLOWED_LOCK_MINUTES.includes(mins)) {\n                sendResponse(false);\n                return true;\n            }\n            autoLockTimeout = mins * 60 * 1000;\n            storage.set({ autoLockMinutes: mins });\n            resetAutoLock();\n            sendResponse(true);\n            return true;\n        }\n        case 'getAutoLockTimeout':\n            reply(sendResponse, async () => {\n                const { autoLockMinutes } = await storage.get({ autoLockMinutes: 15 });\n                return autoLockMinutes;\n            });\n            return true;\n        case 'resetAutoLock':\n            resetAutoLock();\n            sendResponse(true);\n            return true;\n\n        // --- Nostr access while locked ---\n        case 'getNostrAccessWhileLocked':\n            sendResponse(nostrAccessWhileLocked);\n            return true;\n        case 'setNostrAccessWhileLocked':\n            nostrAccessWhileLocked = !!message.payload;\n            storage.set({ nostrAccessWhileLocked: !!message.payload });\n            if (!message.payload && locked) {\n                sessionKeys.clear();  // Turning OFF while locked = clear keys immediately\n            }\n            sendResponse(true);\n            return true;\n        case 'getBlockCrossOriginFrames':\n            sendResponse(blockCrossOriginFrames);\n            return true;\n        case 'setBlockCrossOriginFrames':\n            blockCrossOriginFrames = !!message.payload;\n            storage.set({ blockCrossOriginFrames: !!message.payload });\n            sendResponse(true);\n            return true;\n        case 'getActiveProfileInfo':\n            (async () => {\n                try {\n                    const pi = await getProfileIndex();\n                    const profiles = await getProfiles();\n                    const profile = profiles[pi];\n                    if (!profile) {\n                        log('[getActiveProfileInfo] No profile found at index ' + pi);\n                        sendResponse({ name: 'Unknown', npub: '', hasKeys: false });\n                        return;\n                    }\n                    let npub = '';\n                    if (profile.type === 'bunker' && profile.remotePubkey) {\n                        npub = nip19.npubEncode(profile.remotePubkey);\n                    } else if (profile.pubKey) {\n                        npub = nip19.npubEncode(profile.pubKey);\n                    }\n                    const result = {\n                        name: profile.name || 'Unnamed Profile',\n                        npub,\n                        hasKeys: sessionKeys.has(pi),\n                        isBunker: profile.type === 'bunker',\n                    };\n                    log('[getActiveProfileInfo] Sending: ' + JSON.stringify(result));\n                    sendResponse(result);\n                } catch (e) {\n                    log('[getActiveProfileInfo] Error: ' + e.message);\n                    sendResponse({ name: 'Error', npub: '', hasKeys: false });\n                }\n            })();\n            return true;\n\n        // --- NIP-49 ncryptsec handlers ---\n        case 'ncryptsec.decrypt':\n            reply(sendResponse, async () => {\n                try {\n                    const { ncryptsec, password } = message.payload;\n                    const hexKey = bytesToHex(nip49Decrypt(ncryptsec, password));\n                    return { success: true, hexKey };\n                } catch (e) {\n                    return { success: false, error: e.message || 'Decryption failed' };\n                }\n            });\n            return true;\n        case 'ncryptsec.encrypt':\n            reply(sendResponse, async () => {\n                try {\n                    const { profileIndex: ei, password } = message.payload;\n                    const profile = await getProfile(ei);\n                    if (profile?.type === 'bunker') {\n                        return { success: false, error: 'Cannot export bunker profile as ncryptsec' };\n                    }\n                    const hexKey = await getPlaintextPrivKey(ei, profile);\n                    const ncryptsec = nip49Encrypt(hexToBytes(hexKey), password);\n                    return { success: true, ncryptsec };\n                } catch (e) {\n                    return { success: false, error: e.message || 'Encryption failed' };\n                }\n            });\n            return true;\n\n        // --- BIP39 Seed Phrase handlers ---\n        case 'seedPhrase.fromKey':\n            reply(sendResponse, async () => {\n                try {\n                    const ei = message.payload;\n                    const profile = await getProfile(ei);\n                    if (profile?.type === 'bunker') {\n                        return { success: false, error: 'Cannot export bunker profile as seed phrase' };\n                    }\n                    const hexKey = await getPlaintextPrivKey(ei, profile);\n                    const seedPhrase = keyToSeedPhrase(hexKey);\n                    return { success: true, seedPhrase };\n                } catch (e) {\n                    return { success: false, error: e.message || 'Failed to generate seed phrase' };\n                }\n            });\n            return true;\n        case 'seedPhrase.toKey':\n            reply(sendResponse, async () => {\n                try {\n                    const { hexKey, pubKey } = seedPhraseToKey(message.payload);\n                    return { success: true, hexKey, pubKey };\n                } catch (e) {\n                    return { success: false, error: e.message || 'Invalid seed phrase' };\n                }\n            });\n            return true;\n        case 'seedPhrase.validate':\n            sendResponse(isValidSeedPhrase(message.payload));\n            return true;\n\n        // --- NIP-46 Bunker handlers ---\n        case 'getProfileType':\n            reply(sendResponse, async () => {\n                const pi = message.payload ?? await getProfileIndex();\n                const profile = await getProfile(pi);\n                return profile?.type || 'local';\n            });\n            return true;\n        case 'bunker.connect':\n            reply(sendResponse, async () => {\n                try {\n                    const { profileIndex: bi, bunkerUrl } = message.payload;\n                    const session = await createSession(bi, bunkerUrl);\n                    const remotePubkey = await session.getPublicKey();\n                    const profiles = await getProfiles();\n                    profiles[bi].remotePubkey = remotePubkey;\n                    profiles[bi].bunkerUrl = bunkerUrl;\n                    await storage.set({ profiles });\n                    return { success: true, remotePubkey };\n                } catch (e) {\n                    return { success: false, error: e.message };\n                }\n            });\n            return true;\n        case 'bunker.disconnect':\n            reply(sendResponse, async () => {\n                try {\n                    const bi = message.payload;\n                    await disconnectSession(bi);\n                    return { success: true };\n                } catch (e) {\n                    return { success: false, error: e.message };\n                }\n            });\n            return true;\n        case 'bunker.status':\n            reply(sendResponse, async () => {\n                const bi = message.payload ?? await getProfileIndex();\n                return { connected: isSessionActive(bi) };\n            });\n            return true;\n        case 'bunker.ping':\n            reply(sendResponse, async () => {\n                try {\n                    const bi = message.payload ?? await getProfileIndex();\n                    const session = await getOrCreateSession(bi);\n                    const result = await session.ping();\n                    return { success: true, result };\n                } catch (e) {\n                    return { success: false, error: e.message };\n                }\n            });\n            return true;\n        case 'bunker.validateUrl':\n            sendResponse(validateBunkerUrl(message.payload));\n            return true;\n\n        // --- Bunker Server handlers (extension acts as NIP-46 signer) ---\n        case 'bunkerServer.start':\n            reply(sendResponse, async () => {\n                try {\n                    if (activeBunkerServer) {\n                        activeBunkerServer.stop();\n                        activeBunkerServer = null;\n                    }\n                    const pubkey = await getPubKey();\n                    const relayUrls = message.payload?.relayUrls || ['wss://relay.nostrkey.com'];\n                    const secret = crypto.randomUUID().replace(/-/g, '').slice(0, 16);\n                    const server = new BunkerServer({ relayUrls, userPubkey: pubkey, secret });\n                    await server.start({ getPrivKey });\n                    activeBunkerServer = server;\n                    return { success: true, uri: server.getConnectionString() };\n                } catch (e) {\n                    return { success: false, error: e.message };\n                }\n            });\n            return true;\n        case 'bunkerServer.stop':\n            reply(sendResponse, async () => {\n                if (activeBunkerServer) {\n                    activeBunkerServer.stop();\n                    activeBunkerServer = null;\n                }\n                return { success: true };\n            });\n            return true;\n        case 'bunkerServer.status':\n            sendResponse({\n                active: !!activeBunkerServer?.active,\n                uri: activeBunkerServer?.getConnectionString() || null,\n                clientCount: activeBunkerServer?.authenticatedClients.size || 0,\n            });\n            return true;\n\n        // --- Vault handlers ---\n        case 'vault.publish':\n            reply(sendResponse, async () => {\n                try {\n                    const { path, content } = message.payload;\n                    const pubkey = await getPubKey();\n                    const encrypted = await nip44Encrypt({ pubKey: pubkey, plainText: content });\n                    const unsigned = buildVaultEvent(path, encrypted);\n\n                    const pi = await getProfileIndex();\n                    const profile = await getProfile(pi);\n                    let signed;\n                    if (profile.type === 'bunker') {\n                        const session = await getOrCreateSession(pi);\n                        signed = await session.signEvent(unsigned);\n                    } else {\n                        const sk = await getPrivKey();\n                        signed = await finalizeEvent(unsigned, sk);\n                    }\n\n                    await withRelays('write', async (relays) => {\n                        for (const relay of relays) {\n                            try { relay.publish(signed); } catch (_) {}\n                        }\n                    });\n                    return { success: true, eventId: signed.id, createdAt: signed.created_at };\n                } catch (e) {\n                    return { success: false, error: e.message };\n                }\n            });\n            return true;\n        case 'vault.fetch':\n            reply(sendResponse, async () => {\n                try {\n                    const pubkey = await getPubKey();\n                    const filter = buildVaultFilter(pubkey);\n                    const allEvents = [];\n\n                    await withRelays('read', async (relays) => {\n                        const perRelay = relays.map(relay => new Promise((resolve) => {\n                            const subId = `vault-${crypto.randomUUID().slice(0, 8)}`;\n                            const timeout = setTimeout(() => {\n                                try { relay.unsubscribe(subId); } catch (_) {}\n                                resolve();\n                            }, 15000);\n\n                            relay.subscribe(\n                                subId,\n                                [filter],\n                                (event) => { allEvents.push(event); },\n                                () => {\n                                    clearTimeout(timeout);\n                                    try { relay.unsubscribe(subId); } catch (_) {}\n                                    resolve();\n                                }\n                            );\n                        }));\n                        await Promise.all(perRelay);\n                    });\n\n                    // Deduplicate by d-tag \u2014 latest created_at wins (NIP-33)\n                    const byDtag = new Map();\n                    for (const event of allEvents) {\n                        const parsed = parseVaultEvent(event);\n                        if (!parsed) continue;\n                        const existing = byDtag.get(parsed.path);\n                        if (!existing || parsed.createdAt > existing.createdAt) {\n                            byDtag.set(parsed.path, { event, parsed });\n                        }\n                    }\n\n                    // Decrypt each document\n                    const documents = [];\n                    const pubkey_ = await getPubKey();\n                    for (const { event, parsed } of byDtag.values()) {\n                        try {\n                            const decrypted = await nip44Decrypt({ pubKey: pubkey_, cipherText: event.content });\n                            documents.push({\n                                path: parsed.path,\n                                content: decrypted,\n                                createdAt: parsed.createdAt,\n                                eventId: parsed.eventId,\n                            });\n                        } catch (_) {\n                            // Skip documents we can't decrypt\n                        }\n                    }\n                    return { success: true, documents };\n                } catch (e) {\n                    return { success: false, error: e.message };\n                }\n            });\n            return true;\n        case 'vault.delete':\n            reply(sendResponse, async () => {\n                try {\n                    const { path, eventId } = message.payload;\n                    const unsigned = buildVaultDeletion(eventId, path);\n\n                    const pi = await getProfileIndex();\n                    const profile = await getProfile(pi);\n                    let signed;\n                    if (profile.type === 'bunker') {\n                        const session = await getOrCreateSession(pi);\n                        signed = await session.signEvent(unsigned);\n                    } else {\n                        const sk = await getPrivKey();\n                        signed = await finalizeEvent(unsigned, sk);\n                    }\n\n                    await withRelays('write', async (relays) => {\n                        for (const relay of relays) {\n                            try { relay.publish(signed); } catch (_) {}\n                        }\n                    });\n                    return { success: true };\n                } catch (e) {\n                    return { success: false, error: e.message };\n                }\n            });\n            return true;\n        case 'vault.getRelays':\n            reply(sendResponse, async () => {\n                try {\n                    const profile = await currentProfile();\n                    const relays = profile.relays || [];\n                    const read = relays.filter(r => r.read).map(r => r.url);\n                    const write = relays.filter(r => r.write).map(r => r.url);\n                    return { read, write };\n                } catch (e) {\n                    return { read: [], write: [] };\n                }\n            });\n            return true;\n\n        // --- API Key Vault handlers ---\n        case 'apikeys.publish':\n            reply(sendResponse, async () => {\n                try {\n                    const { keys } = message.payload;\n                    const pubkey = await getPubKey();\n                    const plainText = JSON.stringify(keys);\n                    const encrypted = await nip44Encrypt({ pubKey: pubkey, plainText });\n                    const unsigned = buildVaultEvent('vault/api-keys', encrypted);\n\n                    const pi = await getProfileIndex();\n                    const profile = await getProfile(pi);\n                    let signed;\n                    if (profile.type === 'bunker') {\n                        const session = await getOrCreateSession(pi);\n                        signed = await session.signEvent(unsigned);\n                    } else {\n                        const sk = await getPrivKey();\n                        signed = await finalizeEvent(unsigned, sk);\n                    }\n\n                    await withRelays('write', async (relays) => {\n                        for (const relay of relays) {\n                            try { relay.publish(signed); } catch (_) {}\n                        }\n                    });\n                    return { success: true, eventId: signed.id, createdAt: signed.created_at };\n                } catch (e) {\n                    return { success: false, error: e.message };\n                }\n            });\n            return true;\n        case 'apikeys.fetch':\n            reply(sendResponse, async () => {\n                try {\n                    const pubkey = await getPubKey();\n                    const filter = {\n                        kinds: [30078],\n                        authors: [pubkey],\n                        '#d': ['nostrkey:vault/api-keys'],\n                    };\n                    const allEvents = [];\n\n                    await withRelays('read', async (relays) => {\n                        const perRelay = relays.map(relay => new Promise((resolve) => {\n                            const subId = `apikeys-${crypto.randomUUID().slice(0, 8)}`;\n                            const timeout = setTimeout(() => {\n                                try { relay.unsubscribe(subId); } catch (_) {}\n                                resolve();\n                            }, 15000);\n\n                            relay.subscribe(\n                                subId,\n                                [filter],\n                                (event) => { allEvents.push(event); },\n                                () => {\n                                    clearTimeout(timeout);\n                                    try { relay.unsubscribe(subId); } catch (_) {}\n                                    resolve();\n                                }\n                            );\n                        }));\n                        await Promise.all(perRelay);\n                    });\n\n                    // Take latest by created_at (single d-tag, NIP-33 dedup)\n                    let latest = null;\n                    for (const event of allEvents) {\n                        if (!latest || event.created_at > latest.created_at) {\n                            latest = event;\n                        }\n                    }\n\n                    if (!latest) {\n                        return { success: true, keys: null, eventId: null, createdAt: null };\n                    }\n\n                    const decrypted = await nip44Decrypt({ pubKey: pubkey, cipherText: latest.content });\n                    const keys = JSON.parse(decrypted);\n                    return { success: true, keys, eventId: latest.id, createdAt: latest.created_at };\n                } catch (e) {\n                    return { success: false, error: e.message };\n                }\n            });\n            return true;\n        case 'apikeys.delete':\n            reply(sendResponse, async () => {\n                try {\n                    const { eventId } = message.payload;\n                    const unsigned = buildVaultDeletion(eventId, 'vault/api-keys');\n\n                    const pi = await getProfileIndex();\n                    const profile = await getProfile(pi);\n                    let signed;\n                    if (profile.type === 'bunker') {\n                        const session = await getOrCreateSession(pi);\n                        signed = await session.signEvent(unsigned);\n                    } else {\n                        const sk = await getPrivKey();\n                        signed = await finalizeEvent(unsigned, sk);\n                    }\n\n                    await withRelays('write', async (relays) => {\n                        for (const relay of relays) {\n                            try { relay.publish(signed); } catch (_) {}\n                        }\n                    });\n                    return { success: true };\n                } catch (e) {\n                    return { success: false, error: e.message };\n                }\n            });\n            return true;\n        case 'apikeys.encrypt':\n            reply(sendResponse, async () => {\n                try {\n                    const { plainText } = message.payload;\n                    const pubkey = await getPubKey();\n                    const cipherText = await nip44Encrypt({ pubKey: pubkey, plainText });\n                    return { success: true, cipherText };\n                } catch (e) {\n                    return { success: false, error: e.message };\n                }\n            });\n            return true;\n        case 'apikeys.decrypt':\n            reply(sendResponse, async () => {\n                try {\n                    const { cipherText } = message.payload;\n                    const pubkey = await getPubKey();\n                    const plainText = await nip44Decrypt({ pubKey: pubkey, cipherText });\n                    return { success: true, plainText };\n                } catch (e) {\n                    return { success: false, error: e.message };\n                }\n            });\n            return true;\n\n        // --- Encrypted vault backup / restore ---\n        case 'backup.export':\n            reply(sendResponse, async () => {\n                // Backups are encrypted with a dedicated backup password supplied at\n                // export time \u2014 NOT the in-memory session key. This lets users with no\n                // master password create backups, and works even while locked (the\n                // stored key blobs stay encrypted and get wrapped again here).\n                const password = message.payload?.password;\n                if (typeof password !== 'string' || password.length < 8) {\n                    return { success: false, error: 'A backup password of at least 8 characters is required' };\n                }\n                const data = await storage.get({\n                    profiles: [],\n                    profileIndex: 0,\n                    isEncrypted: false,\n                    passwordHash: null,\n                    passwordSalt: null,\n                    apiKeyVault: null,\n                    vaultDocs: null,\n                    nostrAccessWhileLocked: false,\n                    blockCrossOriginFrames: true,\n                    autoLockMinutes: 15,\n                    version: null,\n                });\n                const plaintext = JSON.stringify(data);\n                const encrypted = await encryptBlob(plaintext, password);\n                const version = api.runtime.getManifest?.()?.version || 'unknown';\n                return {\n                    success: true,\n                    envelope: {\n                        format: 'nostrkey-backup',\n                        version: 1,\n                        createdAt: new Date().toISOString(),\n                        extensionVersion: version,\n                        profileCount: Array.isArray(data.profiles) ? data.profiles.length : 0,\n                        payload: JSON.parse(encrypted),\n                    },\n                };\n            });\n            return true;\n        case 'backup.import':\n            reply(sendResponse, async () => {\n                try {\n                    const { envelope, password } = message.payload;\n                    if (!envelope || envelope.format !== 'nostrkey-backup') {\n                        return { success: false, error: 'Not a valid NostrKey backup file' };\n                    }\n                    if (typeof envelope.version !== 'number' || envelope.version > 1) {\n                        return { success: false, error: 'Backup version not supported. Update NostrKey and try again.' };\n                    }\n                    const payloadStr = JSON.stringify(envelope.payload);\n                    let plaintext;\n                    try {\n                        plaintext = await decryptBlob(payloadStr, password);\n                    } catch (_) {\n                        return { success: false, error: 'Wrong password \u2014 could not decrypt backup' };\n                    }\n                    const data = JSON.parse(plaintext);\n                    // Write all backed-up keys to storage\n                    await storage.set(data);\n                    // Update in-memory state\n                    encryptionEnabled = !!data.isEncrypted;\n                    locked = false;\n                    // Derive session key from password, then let password fall out of scope\n                    const importSalt = crypto.getRandomValues(new Uint8Array(16));\n                    sessionCryptoKey = await deriveKey(password, importSalt);\n                    sessionKeySalt = importSalt;\n                    nostrAccessWhileLocked = data.nostrAccessWhileLocked !== false;\n                    blockCrossOriginFrames = data.blockCrossOriginFrames !== false;\n                    if (typeof data.autoLockMinutes === 'number') {\n                        autoLockTimeout = data.autoLockMinutes * 60 * 1000;\n                    }\n                    // Populate session key cache\n                    sessionKeys.clear();\n                    if (Array.isArray(data.profiles)) {\n                        for (let i = 0; i < data.profiles.length; i++) {\n                            const p = data.profiles[i];\n                            if (p.type === 'bunker' || !p.privKey) continue;\n                            if (isEncryptedBlob(p.privKey)) {\n                                try {\n                                    const hex = await decryptBlob(p.privKey, password);\n                                    sessionKeys.set(i, hex);\n                                } catch (_) {}\n                            } else {\n                                sessionKeys.set(i, p.privKey);\n                            }\n                        }\n                    }\n                    resetAutoLock();\n                    const profileCount = Array.isArray(data.profiles) ? data.profiles.length : 0;\n                    return { success: true, profileCount };\n                } catch (e) {\n                    return { success: false, error: e.message || 'Restore failed' };\n                }\n            });\n            return true;\n\n        // nostr: protocol URL handler \u2014 no key access needed, no permission prompt\n        case 'replaceURL':\n            reply(sendResponse, async () => {\n                const { protocol_handler } = await storage.get(['protocol_handler']);\n                if (!protocol_handler) return false;\n                const { url } = message.payload;\n                const raw = url.split('nostr:')[1];\n                if (!raw) return false;\n                try {\n                    const decoded = nip19.decode(raw);\n                    const { type, data } = decoded;\n                    const replacements = {\n                        raw,\n                        hrp: type,\n                        hex:\n                            type === 'naddr'\n                                ? (decoded.author || raw)\n                                : (data || raw),\n                        p_or_e: { npub: 'p', note: 'e', nprofile: 'p', nevent: 'e', naddr: 'a' }[type] || '',\n                        u_or_n: { npub: 'u', note: 'n', nprofile: 'u', nevent: 'n', naddr: 'n' }[type] || '',\n                        relay0: decoded.relays?.[0] || '',\n                        relay1: decoded.relays?.[1] || '',\n                        relay2: decoded.relays?.[2] || '',\n                    };\n                    let result = protocol_handler;\n                    for (const [pattern, value] of Object.entries(replacements)) {\n                        result = result.replace(new RegExp(`\\\\{ *${pattern} *\\\\}`, 'g'), value);\n                    }\n                    return result;\n                } catch {\n                    return false;\n                }\n            });\n            return true;\n\n        // window.nostr\n        case 'getPubKey':\n        case 'signEvent':\n        case 'nip04.encrypt':\n        case 'nip04.decrypt':\n        case 'nip44.encrypt':\n        case 'nip44.decrypt':\n        case 'getRelays':\n        case 'addRelay':\n        case 'exportProfile':\n            validations[uuid] = sendResponse;\n            if (Object.keys(validations).length === 1) {\n                pendingQueue = { total: 0, processed: 0 };\n            }\n            pendingQueue.total++;\n            ask(uuid, message);\n            setTimeout(() => {\n                // H4 fix: deny pending request on timeout instead of silently releasing\n                if (validations[uuid]) {\n                    deny({ payload: uuid, origKind: message.kind, host: message.host });\n                }\n                prompt.release?.();\n            }, 10_000);\n            return true;\n        default:\n            return false;\n    }\n});\n\nasync function forceRelease() {\n    if (prompt.tabId !== null) {\n        try {\n            // If the previous prompt is still open, then this won't do anything.\n            // If it's not open, it will throw an error and get caught.\n            await api.tabs.get(prompt.tabId);\n        } catch (error) {\n            // If the tab is closed, but somehow escaped our event handling, we can clean it up here\n            // before attempting to open the next tab.\n            prompt.release?.();\n            prompt.tabId = null;\n        }\n    }\n}\n\nasync function generatePrivateKey_() {\n    const keyPair = await generateKeyPair();\n    return keyPair.privateKey;\n}\n\nasync function ask(uuid, { kind, host, payload }) {\n    // Rate limit permission requests per origin \u2014 prevent spam from malicious pages\n    if (host) {\n        const now = Date.now();\n        const rateEntry = permissionRateMap.get(host) || { count: 0, resetAt: now + 60000 };\n        if (now > rateEntry.resetAt) {\n            rateEntry.count = 0;\n            rateEntry.resetAt = now + 60000;\n        }\n        rateEntry.count++;\n        permissionRateMap.set(host, rateEntry);\n\n        if (rateEntry.count > 5) {\n            log(`[SECURITY] Rate limited ${host} \u2014 ${rateEntry.count} requests in 60s`);\n            const sendResponse = validations[uuid];\n            delete validations[uuid];\n            sendResponse?.({ error: 'rate_limited', message: 'Too many requests. Please wait a moment.' });\n            return;\n        }\n    }\n\n    // Bunker profiles don't need local key decryption \u2014 skip lock check\n    const pi = await getProfileIndex();\n    const profile = await getProfile(pi);\n    const isBunker = profile?.type === 'bunker';\n\n    // Read-only operations (getPubKey, getRelays) work from cached data and\n    // don't need the private key, so they bypass the lock check entirely.\n    // This also fixes Safari's non-persistent background page losing session\n    // keys on reload \u2014 these operations still work without re-unlocking.\n    const needsPrivateKey = kind !== 'getPubKey' && kind !== 'getRelays' && kind !== 'addRelay' && kind !== 'exportProfile';\n\n    // If the extension is locked, reject signing/encryption requests (local profiles only)\n    if (!isBunker && needsPrivateKey) {\n        const isLocked = await checkLockState();\n        if (isLocked) {\n            if (!(nostrAccessWhileLocked && sessionKeys.has(pi))) {\n                // No keys available \u2014 show locked notification and reject\n                const isFirstUnlock = sessionKeys.size === 0;\n                try {\n                    const [activeTab] = await api.tabs.query({ active: true, currentWindow: true });\n                    if (activeTab?.id) {\n                        api.tabs.sendMessage(activeTab.id, { kind: 'showLockedSheet', firstUnlock: isFirstUnlock }).catch(() => {});\n                    }\n                } catch (_) {}\n                const sendResponse = validations[uuid];\n                delete validations[uuid];\n                sendResponse?.({ error: 'locked', message: 'Extension is locked. Please unlock with your master password.' });\n                return;\n            }\n            // Keys available despite lock \u2014 proceed with permission check\n        }\n    }\n\n    // Rate limit permission prompts per host\n    if (isRateLimited(host)) {\n        const sendResponse = validations[uuid];\n        delete validations[uuid];\n        sendResponse?.({ error: 'rate_limited', message: 'Too many requests. Please wait.' });\n        log(`Rate limited: ${host}`);\n        return;\n    }\n\n    await forceRelease(); // Clean up previous tab if it closed without cleaning itself up\n    prompt.release = await prompt.mutex.acquire();\n\n    pendingQueue.processed++;\n    const queuePosition = pendingQueue.processed;\n    const queueTotal = pendingQueue.total;\n\n    let mKind = kind === 'signEvent' ? `signEvent:${payload.kind}` : kind;\n    let permission = await getPermission(host, mKind);\n    if (permission === 'allow') {\n        complete({\n            payload: uuid,\n            origKind: kind,\n            event: payload,\n            remember: false,\n            host,\n        });\n        prompt.release();\n        return;\n    }\n\n    if (permission === 'deny') {\n        deny({ payload: uuid, origKind: kind, host });\n        prompt.release();\n        return;\n    }\n\n    // Try to show bottom sheet in the active tab's content script\n    try {\n        const [activeTab] = await api.tabs.query({ active: true, currentWindow: true });\n        if (activeTab?.id) {\n            const result = await api.tabs.sendMessage(activeTab.id, {\n                kind: 'showPermissionSheet',\n                host,\n                permissionKind: kind,\n                queuePosition,\n                queueTotal,\n            });\n            \n            if (result) {\n                if (result.allowed) {\n                    complete({\n                        payload: uuid,\n                        origKind: kind,\n                        event: payload,\n                        remember: result.remember,\n                        host,\n                    });\n                } else {\n                    deny({\n                        payload: uuid,\n                        origKind: kind,\n                        event: payload,\n                        remember: result.remember,\n                        host,\n                    });\n                }\n                prompt.release();\n                return;\n            }\n        }\n    } catch (e) {\n        // Content script not available, fall back to tab\n        log('Bottom sheet unavailable, falling back to tab:', e.message);\n    }\n\n    // Fallback to permission tab\n    let qs = new URLSearchParams({\n        uuid,\n        kind,\n        host,\n        payload: JSON.stringify(payload || false),\n        queuePosition,\n        queueTotal,\n    });\n    let tab = await api.tabs.getCurrent();\n    let p = await api.tabs.create({\n        url: api.runtime.getURL(`permission/permission.html?${qs.toString()}`),\n        openerTabId: tab?.id,\n    });\n    prompt.tabId = p.id;\n    return true;\n}\n\nfunction complete({ payload, origKind, event, remember, host }) {\n    const sendResponse = validations[payload];\n    delete validations[payload];\n    if (Object.keys(validations).length === 0) {\n        pendingQueue = { total: 0, processed: 0 };\n    }\n\n    if (remember) {\n        let mKind =\n            origKind === 'signEvent' ? `signEvent:${event.kind}` : origKind;\n        setPermission(host, mKind, 'allow');\n    }\n\n    if (sendResponse) {\n        const onError = (e) => {\n            log(`Error in ${origKind}: ${e.message}`);\n            sendResponse({ error: 'bunker_error', message: e.message });\n        };\n\n        switch (origKind) {\n            case 'getPubKey':\n                getPubKey().then(pk => sendResponse(pk)).catch(onError);\n                break;\n            case 'signEvent':\n                signEvent_(event, host).then(e => sendResponse(e)).catch(onError);\n                break;\n            case 'nip04.encrypt':\n                nip04Encrypt(event).then(e => sendResponse(e)).catch(onError);\n                break;\n            case 'nip04.decrypt':\n                nip04Decrypt(event).then(e => sendResponse(e)).catch(onError);\n                break;\n            case 'nip44.encrypt':\n                nip44Encrypt(event).then(e => sendResponse(e)).catch(onError);\n                break;\n            case 'nip44.decrypt':\n                nip44Decrypt(event).then(e => sendResponse(e)).catch(onError);\n                break;\n            case 'getRelays':\n                getRelays().then(e => sendResponse(e)).catch(onError);\n                break;\n            case 'addRelay':\n                addRelay(event.url).then(e => sendResponse(e)).catch(onError);\n                break;\n            case 'exportProfile':\n                exportProfileData().then(e => sendResponse(e)).catch(onError);\n                break;\n        }\n    }\n}\n\nfunction deny({ origKind, host, payload, remember, event }) {\n    const sendResponse = validations[payload];\n    delete validations[payload];\n    if (Object.keys(validations).length === 0) {\n        pendingQueue = { total: 0, processed: 0 };\n    }\n\n    if (remember) {\n        let mKind =\n            origKind === 'signEvent' ? `signEvent:${event.kind}` : origKind;\n        setPermission(host, mKind, 'deny');\n    }\n\n    sendResponse?.(undefined);\n    return false;\n}\n\n/**\n * Cache pubKeys for all local profiles (call before encrypting keys).\n * This ensures npub is available even when the extension is locked.\n */\nasync function cachePubKeysForAllProfiles() {\n    const profiles = await getProfiles();\n    let updated = false;\n    for (let i = 0; i < profiles.length; i++) {\n        const profile = profiles[i];\n        if (profile.type === 'bunker') continue;\n        if (profile.pubKey) continue; // Already cached\n        if (!profile.privKey || isEncryptedBlob(profile.privKey)) continue;\n        try {\n            const pubKey = getPublicKeySync(profile.privKey);\n            profiles[i].pubKey = pubKey;\n            updated = true;\n        } catch (e) {\n            console.error(`Failed to cache pubKey for profile ${i}:`, e);\n        }\n    }\n    if (updated) {\n        await storage.set({ profiles });\n    }\n}\n\n// Options\nasync function savePrivateKey([index, privKey]) {\n    const profile = await getProfile(index);\n    if (profile?.type === 'bunker') {\n        throw new Error('Cannot set private key on a bunker profile');\n    }\n\n    if (typeof privKey !== 'string' || privKey.length === 0) {\n        throw new Error('Invalid private key: must be a non-empty string');\n    }\n\n    let hexKey;\n    if (privKey.startsWith('nsec')) {\n        try {\n            hexKey = nip19.decode(privKey).data;\n        } catch (e) {\n            throw new Error('Invalid nsec key');\n        }\n    } else {\n        // Already a hex string\n        hexKey = privKey;\n    }\n\n    if (!/^[0-9a-f]{64}$/i.test(hexKey)) {\n        throw new Error('Invalid private key: must be 64 hex characters or valid nsec');\n    }\n\n    let profiles = await get('profiles');\n\n    if (!profiles || index < 0 || index >= profiles.length) {\n        throw new Error('Invalid profile index');\n    }\n\n    // Cache the public key so it's available even when locked\n    const pubKey = getPublicKeySync(hexKey);\n    profiles[index].pubKey = pubKey;\n\n    // If encryption is active, re-encrypt the new key using the session key\n    const encrypted = await isEncrypted();\n    if (encrypted && sessionCryptoKey) {\n        profiles[index].privKey = await encryptWithKey(hexKey, sessionCryptoKey, sessionKeySalt);\n        sessionKeys.set(index, hexKey);\n    } else {\n        profiles[index].privKey = hexKey;\n    }\n\n    await storage.set({ profiles });\n    return true;\n}\n\nasync function getNsec(index) {\n    let profile = await getProfile(index);\n\n    if (profile.type === 'bunker') return null;\n\n    let hexKey = await getPlaintextPrivKey(index, profile);\n    let nsec = nip19.nsecEncode(hexKey);\n    return nsec;\n}\n\nasync function getNpub(index) {\n    let profile = await getProfile(index);\n\n    if (!profile) return null;\n\n    if (profile.type === 'bunker') {\n        if (profile.remotePubkey) return nip19.npubEncode(profile.remotePubkey);\n        return null;\n    }\n\n    // Use cached pubKey if available (works even when locked)\n    if (profile.pubKey) {\n        return nip19.npubEncode(profile.pubKey);\n    }\n\n    // Fallback: derive from private key (requires unlocked state)\n    try {\n        let hexKey = await getPlaintextPrivKey(index, profile);\n        if (!hexKey || typeof hexKey !== 'string' || hexKey.length !== 64) {\n            return null;\n        }\n        let pubKey = getPublicKeySync(hexKey);\n        let npub = nip19.npubEncode(pubKey);\n        return npub;\n    } catch (e) {\n        console.error('getNpub error:', e);\n        return null;\n    }\n}\n\n/**\n * Get the plaintext hex private key for a profile.\n * Uses session cache if encryption is active, otherwise reads from storage directly.\n */\nasync function getPlaintextPrivKey(index, profile) {\n    if (isEncryptedBlob(profile.privKey)) {\n        // Key is encrypted \u2014 must use session cache\n        if (sessionKeys.has(index)) {\n            return sessionKeys.get(index);\n        }\n        throw new Error('Extension is locked \u2014 cannot access private key');\n    }\n    return profile.privKey;\n}\n\nasync function getPrivKey() {\n    let index = await getProfileIndex();\n    let profile = await currentProfile();\n    let hexKey = await getPlaintextPrivKey(index, profile);\n    return hexToBytes(hexKey);\n}\n\nasync function getPubKey() {\n    let pi = await getProfileIndex();\n    let profile = await getProfile(pi);\n\n    if (profile.type === 'bunker') {\n        // Return cached remotePubkey, or live-query and cache\n        if (profile.remotePubkey) return profile.remotePubkey;\n        const session = await getOrCreateSession(pi);\n        const pubkey = await session.getPublicKey();\n        const profiles = await get('profiles');\n        profiles[pi].remotePubkey = pubkey;\n        await storage.set({ profiles });\n        return pubkey;\n    }\n\n    // Use cached pubKey if available (works even when locked)\n    if (profile.pubKey) return profile.pubKey;\n\n    // Fallback: derive from private key (requires unlocked state)\n    let privKey = await getPrivKey();\n    let pubKey = getPublicKeySync(bytesToHex(privKey));\n    return pubKey;\n}\n\nasync function currentProfile() {\n    let index = await getProfileIndex();\n    let profiles = await get('profiles');\n    return profiles[index];\n}\n\nasync function signEvent_(event, host) {\n    event = JSON.parse(JSON.stringify(event));\n\n    const pi = await getProfileIndex();\n    const profile = await getProfile(pi);\n\n    if (profile.type === 'bunker') {\n        const session = await getOrCreateSession(pi);\n        event = await session.signEvent(event);\n    } else {\n        let sk = await getPrivKey();\n        event = await finalizeEvent(event, sk);\n    }\n\n    saveEvent({\n        event,\n        metadata: { host, signed_at: Math.round(Date.now() / 1000) },\n    });\n    return event;\n}\n\nasync function nip04Encrypt({ pubKey, plainText }) {\n    const pi = await getProfileIndex();\n    const profile = await getProfile(pi);\n\n    if (profile.type === 'bunker') {\n        const session = await getOrCreateSession(pi);\n        return session.nip04Encrypt(pubKey, plainText);\n    }\n\n    let privKey = await getPrivKey();\n    return nip04.encryptMessage(plainText, bytesToHex(privKey), pubKey);\n}\n\nasync function nip04Decrypt({ pubKey, cipherText }) {\n    const pi = await getProfileIndex();\n    const profile = await getProfile(pi);\n\n    if (profile.type === 'bunker') {\n        const session = await getOrCreateSession(pi);\n        return session.nip04Decrypt(pubKey, cipherText);\n    }\n\n    let privKey = await getPrivKey();\n    return nip04.decryptMessage(cipherText, bytesToHex(privKey), pubKey);\n}\n\nasync function nip44Encrypt({ pubKey, plainText }) {\n    const pi = await getProfileIndex();\n    const profile = await getProfile(pi);\n\n    if (profile.type === 'bunker') {\n        const session = await getOrCreateSession(pi);\n        return session.nip44Encrypt(pubKey, plainText);\n    }\n\n    let privKey = await getPrivKey();\n    let conversationKey = nip44.v2.utils.getConversationKey(privKey, pubKey);\n    return nip44.v2.encrypt(plainText, conversationKey);\n}\n\nasync function nip44Decrypt({ pubKey, cipherText }) {\n    const pi = await getProfileIndex();\n    const profile = await getProfile(pi);\n\n    if (profile.type === 'bunker') {\n        const session = await getOrCreateSession(pi);\n        return session.nip44Decrypt(pubKey, cipherText);\n    }\n\n    let privKey = await getPrivKey();\n    let conversationKey = nip44.v2.utils.getConversationKey(privKey, pubKey);\n    return nip44.v2.decrypt(cipherText, conversationKey);\n}\n\nasync function getRelays() {\n    let profile = await currentProfile();\n    let relays = profile.relays;\n    let relayObj = {};\n    // The getRelays call expects this to be returned as an object, not array\n    relays.forEach(relay => {\n        let { url, read, write } = relay;\n        relayObj[url] = { read, write };\n    });\n    return relayObj;\n}\n\nasync function addRelay(url) {\n    // Validate URL\n    let parsed;\n    try {\n        parsed = new URL(url);\n    } catch {\n        throw new Error('Invalid URL');\n    }\n    if (parsed.protocol !== 'wss:') {\n        throw new Error('Must be a wss:// URL');\n    }\n\n    let profiles = await getProfiles();\n    let pi = await getProfileIndex();\n    let profile = profiles[pi];\n    if (!profile.relays) profile.relays = [];\n\n    // Check for duplicates\n    if (profile.relays.some(r => r.url === parsed.href)) {\n        return { success: true, message: 'Relay already exists' };\n    }\n\n    profile.relays.push({ url: parsed.href, read: true, write: true });\n    profile.updatedAt = Math.floor(Date.now() / 1000);\n    await storage.set({ profiles });\n\n    return { success: true, message: 'Relay added' };\n}\n\nasync function exportProfileData() {\n    let pi = await getProfileIndex();\n    let profile = await getProfile(pi);\n\n    if (!profile) throw new Error('No active profile');\n    if (profile.type === 'bunker') {\n        // Bunker profiles don't have local keys to export\n        return {\n            name: profile.name,\n            type: 'bunker',\n            bunkerUrl: profile.bunkerUrl || '',\n            exportedAt: new Date().toISOString(),\n            source: 'NostrKey',\n        };\n    }\n\n    let npub = '';\n    if (profile.pubKey) {\n        npub = nip19.npubEncode(profile.pubKey);\n    }\n\n    let nsec = '';\n    try {\n        nsec = await getNsec(pi);\n    } catch {\n        // Key may be encrypted and locked\n        throw new Error('Cannot export while locked. Please unlock first.');\n    }\n\n    return {\n        name: profile.name,\n        npub,\n        nsec,\n        relays: (profile.relays || []).map(r => r.url),\n        exportedAt: new Date().toISOString(),\n        source: 'NostrKey',\n    };\n}\n\n/**\n * Open ephemeral relay connections, execute callback, then disconnect.\n * Correct for Chrome MV3 service worker lifecycle (no persistent pool).\n *\n * @param {'read'|'write'} mode - Which relay subset to connect to\n * @param {function(RelayConnection[]): Promise} callback\n */\nasync function withRelays(mode, callback) {\n    const profile = await currentProfile();\n    const relayList = profile.relays || [];\n    const urls = relayList\n        .filter(r => mode === 'read' ? r.read : r.write)\n        .map(r => r.url);\n\n    if (urls.length === 0) {\n        throw new Error('No relays configured');\n    }\n\n    const connections = [];\n    const connectPromises = urls.map(async (url) => {\n        const relay = new RelayConnection(url);\n        try {\n            await relay.connect();\n            connections.push(relay);\n        } catch (_) {\n            // Skip relays that fail to connect\n        }\n    });\n\n    await Promise.allSettled(connectPromises);\n\n    if (connections.length === 0) {\n        throw new Error('Failed to connect to any relay');\n    }\n\n    try {\n        await callback(connections);\n    } finally {\n        for (const relay of connections) {\n            relay.close();\n        }\n    }\n}\n", "/**\n * @module nostr-crypto-utils\n * @description Core cryptographic utilities for Nostr protocol\n */\n\n// Core types\nexport type {\n  NostrEvent,\n  UnsignedNostrEvent,\n  SignedNostrEvent,\n  NostrFilter,\n  NostrSubscription,\n  PublicKey,\n  KeyPair,\n  NostrMessageTuple,\n} from './types';\n\n// Event kinds, message types, and NIP-46 types\nexport { NostrEventKind, NostrMessageType, Nip46Method } from './types';\nexport type {\n  Nip46Request,\n  Nip46Response,\n  Nip46Session,\n  Nip46SessionInfo,\n  BunkerURI,\n  BunkerValidationResult,\n} from './types';\n\n// Core crypto functions\nexport {\n  generateKeyPair,\n  getPublicKey,\n  getPublicKeySync,\n  validateKeyPair,\n  createEvent,\n  signEvent,\n  finalizeEvent,\n  verifySignature,\n  encrypt,\n  decrypt,\n} from './crypto';\n\n// Validation functions\nexport {\n  validateEvent,\n  validateEventId,\n  validateEventSignature,\n  validateSignedEvent,\n  validateEventBase,\n  validateFilter,\n  validateSubscription,\n  validateResponse,\n} from './validation';\n\n// Event functions\nexport {\n  calculateEventId,\n} from './event';\n\n// NIP-04 encryption\nexport {\n  computeSharedSecret,\n  encryptMessage,\n  decryptMessage,\n} from './nips/nip-04';\n\n// Re-export NIPs\nexport * as nip01 from './nips/nip-01';\nexport * as nip04 from './nips/nip-04';\nexport * as nip19 from './nips/nip-19';\nexport * as nip26 from './nips/nip-26';\nexport * as nip44 from './nips/nip-44';\nexport * as nip46 from './nips/nip-46';\nexport * as nip49 from './nips/nip-49';\n\n// Utils\nexport {\n  hexToBytes,\n  bytesToHex,\n  utf8ToBytes,\n  bytesToUtf8,\n} from './utils/encoding';\n", "/**\n * @module types\n * @description Type definitions for Nostr\n */\n\nexport interface PublicKeyDetails {\n  hex: string;\n  bytes: Uint8Array;\n}\n\nexport interface KeyPair {\n  privateKey: string;\n  publicKey: PublicKeyDetails;\n}\n\nexport interface NostrEvent {\n  kind: number;\n  created_at: number;\n  tags: string[][];\n  content: string;\n  pubkey: string;\n}\n\nexport interface SignedNostrEvent extends NostrEvent {\n  id: string;\n  sig: string;\n}\n\nexport interface PublicKey {\n  hex: string;\n  bytes?: Uint8Array;\n}\n\nexport interface ValidationResult {\n  isValid: boolean;\n  error?: string;\n}\n\nexport enum NostrEventKind {\n  SET_METADATA = 0,\n  TEXT_NOTE = 1,\n  RECOMMEND_SERVER = 2,\n  CONTACT_LIST = 3,\n  ENCRYPTED_DIRECT_MESSAGE = 4,\n  DELETE = 5,\n  REPOST = 6,\n  REACTION = 7,\n  BADGE_AWARD = 8,\n  CHANNEL_CREATE = 40,\n  CHANNEL_METADATA = 41,\n  CHANNEL_MESSAGE = 42,\n  CHANNEL_HIDE_MESSAGE = 43,\n  CHANNEL_MUTE_USER = 44,\n  CHANNEL_RESERVE = 45,\n  REPORTING = 1984,\n  ZAP_REQUEST = 9734,\n  ZAP = 9735,\n  MUTE_LIST = 10000,\n  PIN_LIST = 10001,\n  RELAY_LIST_METADATA = 10002,\n  CLIENT_AUTH = 22242,\n  AUTH_RESPONSE = 22243,\n  NOSTR_CONNECT = 24133,\n  CATEGORIZED_PEOPLE = 30000,\n  CATEGORIZED_BOOKMARKS = 30001,\n  PROFILE_BADGES = 30008,\n  BADGE_DEFINITION = 30009,\n  LONG_FORM = 30023,\n  APPLICATION_SPECIFIC = 30078\n}\n\n/**\n * Re-export all types from base module\n * @packageDocumentation\n */\nexport * from './base';\n\n/** Re-export protocol types */\nexport * from './protocol';\n\n/** Re-export message types */\nexport * from './messages';\n\n/** Re-export type guards */\nexport * from './guards';\n\n// Re-export NIP-19 types\nexport type {\n  Nip19DataType\n} from '../nips/nip-19';\n\n/** Re-export NIP-46 types */\nexport * from './nip46';\n", "/**\n * @module types/base\n * @description Core type definitions for Nostr protocol\n */\n\n// Key Types\nexport type PublicKeyHex = string;\nexport type PrivateKeyHex = string;\n\nexport interface PublicKeyDetails {\n  /** Public key in hex format */\n  hex: string;\n  /** NIP-05 identifier */\n  nip05: string;\n  /** Public key in bytes format */\n  bytes: Uint8Array;\n}\n\nexport type PublicKey = PublicKeyHex | PublicKeyDetails;\n\nexport interface KeyPair {\n  /** Private key in hex format */\n  privateKey: PrivateKeyHex;\n  /** Public key details */\n  publicKey: PublicKeyDetails;\n}\n\n// Event Types\nexport enum NostrEventKind {\n  // NIP-01: Core Protocol\n  SET_METADATA = 0,\n  TEXT_NOTE = 1,\n  RECOMMEND_SERVER = 2,\n  CONTACTS = 3,\n  ENCRYPTED_DIRECT_MESSAGE = 4,\n  EVENT_DELETION = 5,\n  REPOST = 6,\n  REACTION = 7,\n\n  // NIP-28: Public Chat\n  CHANNEL_CREATION = 40,\n  CHANNEL_METADATA = 41,\n  CHANNEL_MESSAGE = 42,\n  CHANNEL_HIDE_MESSAGE = 43,\n  CHANNEL_MUTE_USER = 44,\n\n  // NIP-42: Authentication\n  AUTH = 22242,\n  AUTH_RESPONSE = 22243\n}\n\n/** Base interface for all Nostr events */\nexport interface BaseNostrEvent {\n  /** Event kind as defined in NIPs */\n  kind: number;\n  /** Content of the event */\n  content: string;\n  /** Array of tags */\n  tags: string[][];\n  /** Unix timestamp in seconds */\n  created_at: number;\n}\n\n/** Interface for events that haven't been signed yet */\nexport interface UnsignedNostrEvent extends BaseNostrEvent {\n  /** Optional public key */\n  pubkey?: string;\n}\n\n/** Interface for signed events */\nexport interface SignedNostrEvent extends BaseNostrEvent {\n  /** Public key of the event creator */\n  pubkey: string;\n  /** Event ID (sha256 of the serialized event) */\n  id: string;\n  /** Schnorr signature of the event ID */\n  sig: string;\n}\n\n/** Alias for backward compatibility */\nexport type NostrEvent = SignedNostrEvent;\n\n/** Type for creating new events */\nexport type UnsignedEvent = Omit<NostrEvent, 'id' | 'sig'>;\n\n// Filter Types\nexport interface NostrFilter {\n  ids?: string[];\n  authors?: string[];\n  kinds?: NostrEventKind[];\n  since?: number;\n  until?: number;\n  limit?: number;\n  '#e'?: string[];\n  '#p'?: string[];\n  search?: string;\n  /** Support for arbitrary tags (NIP-12) */\n  [key: `#${string}`]: string[] | undefined;\n}\n\nexport interface NostrSubscription {\n  id: string;\n  filters: NostrFilter[];\n}\n\n// Message Types\nexport enum NostrMessageType {\n  EVENT = 'EVENT',\n  NOTICE = 'NOTICE',\n  OK = 'OK',\n  EOSE = 'EOSE',\n  REQ = 'REQ',\n  CLOSE = 'CLOSE',\n  AUTH = 'AUTH'\n}\n\nexport interface NostrMessage {\n  type: NostrMessageType;\n  event?: SignedNostrEvent;\n  subscriptionId?: string;\n  filters?: NostrFilter[];\n  eventId?: string;\n  accepted?: boolean;\n  message?: string;\n  count?: number;\n  payload?: string | (string | boolean)[];  \n}\n\nexport interface NostrResponse {\n  type: NostrMessageType;\n  event?: SignedNostrEvent;\n  subscriptionId?: string;\n  filters?: NostrFilter[];\n  eventId?: string;\n  accepted?: boolean;\n  message?: string;\n  count?: number;\n}\n\n// Utility Types\nexport interface ValidationResult {\n  isValid: boolean;\n  error?: string;\n}\n\nexport interface NostrError {\n  code: string;\n  message: string;\n  details?: Record<string, unknown>;\n}\n", "/**\n * @module types/protocol\n * @description Nostr protocol types\n */\n\nimport type { \n  NostrFilter, \n  PublicKey,\n  NostrMessageType,\n  NostrSubscription,\n  NostrResponse,\n  NostrError\n} from './base.js';\n\n// Re-export types from base that are used in this module\nexport type { \n  NostrFilter, \n  PublicKey,\n  NostrMessageType,\n  NostrSubscription,\n  NostrResponse,\n  NostrError\n};\n", "export {};\n//# sourceMappingURL=messages.js.map", "/**\n * @module types/guards\n * @description Type guard functions for Nostr types\n */\n\nimport { NostrEvent, SignedNostrEvent, NostrFilter, NostrSubscription, NostrResponse, NostrError } from './base';\n\n/**\n * Type guard for NostrEvent\n */\nexport function isNostrEvent(event: unknown): event is NostrEvent {\n  if (typeof event !== 'object' || event === null) {\n    return false;\n  }\n\n  const validEvent = event as Record<string, unknown>;\n\n  // Required fields\n  if (typeof validEvent.kind !== 'number' || !Number.isInteger(validEvent.kind) || validEvent.kind < 0) {\n    return false;\n  }\n\n  if (typeof validEvent.content !== 'string') {\n    return false;\n  }\n\n  if (typeof validEvent.created_at !== 'number' || !Number.isInteger(validEvent.created_at)) {\n    return false;\n  }\n\n  // Check pubkey structure\n  if (validEvent.pubkey !== undefined) {\n    if (typeof validEvent.pubkey === 'string') {\n      if (!validEvent.pubkey) {\n        return false;\n      }\n    } else if (typeof validEvent.pubkey === 'object' && validEvent.pubkey !== null) {\n      const pubkey = validEvent.pubkey as Record<string, unknown>;\n      if (typeof pubkey.hex !== 'string' || !pubkey.hex) {\n        return false;\n      }\n    } else {\n      return false;\n    }\n  }\n\n  // Check tags array\n  if (!Array.isArray(validEvent.tags)) {\n    return false;\n  }\n\n  // Check tag array elements\n  if (!validEvent.tags.every(tag => Array.isArray(tag) && tag.every(item => typeof item === 'string'))) {\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Type guard for SignedNostrEvent\n */\nexport function isSignedNostrEvent(event: unknown): event is SignedNostrEvent {\n  if (!event || typeof event !== 'object') {\n    return false;\n  }\n\n  const signedEvent = event as Record<string, unknown>;\n\n  // Check required fields from NostrEvent\n  if (!isNostrEvent(event)) {\n    return false;\n  }\n\n  // Check pubkey is present and valid\n  if (typeof signedEvent.pubkey === 'string') {\n    if (!signedEvent.pubkey) {\n      return false;\n    }\n  } else if (typeof signedEvent.pubkey === 'object' && signedEvent.pubkey !== null) {\n    const pubkey = signedEvent.pubkey as Record<string, unknown>;\n    if (typeof pubkey.hex !== 'string' || !pubkey.hex) {\n      return false;\n    }\n  } else {\n    return false;\n  }\n\n  // Check id field\n  if (typeof signedEvent.id !== 'string' || !signedEvent.id) {\n    return false;\n  }\n\n  // Check sig field\n  if (typeof signedEvent.sig !== 'string' || !signedEvent.sig) {\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Type guard for NostrFilter\n */\nexport function isNostrFilter(filter: unknown): filter is NostrFilter {\n  if (typeof filter !== 'object' || filter === null) {\n    return false;\n  }\n\n  const validFilter = filter as Record<string, unknown>;\n  const validKeys = ['ids', 'authors', 'kinds', 'since', 'until', 'limit', '#e', '#p', '#t'];\n  const filterKeys = Object.keys(validFilter);\n\n  // Check if all keys in the filter are valid\n  if (!filterKeys.every(key => validKeys.includes(key))) {\n    return false;\n  }\n\n  // Validate array fields\n  if (validFilter.ids !== undefined && (!Array.isArray(validFilter.ids) || !validFilter.ids.every(id => typeof id === 'string'))) {\n    return false;\n  }\n  if (validFilter.authors !== undefined && (!Array.isArray(validFilter.authors) || !validFilter.authors.every(author => typeof author === 'string'))) {\n    return false;\n  }\n  if (validFilter.kinds !== undefined && (!Array.isArray(validFilter.kinds) || !validFilter.kinds.every(kind => typeof kind === 'number' && Number.isInteger(kind) && kind >= 0))) {\n    return false;\n  }\n  if (validFilter['#e'] !== undefined && (!Array.isArray(validFilter['#e']) || !validFilter['#e'].every(e => typeof e === 'string'))) {\n    return false;\n  }\n  if (validFilter['#p'] !== undefined && (!Array.isArray(validFilter['#p']) || !validFilter['#p'].every(p => typeof p === 'string'))) {\n    return false;\n  }\n  if (validFilter['#t'] !== undefined && (!Array.isArray(validFilter['#t']) || !validFilter['#t'].every(t => typeof t === 'string'))) {\n    return false;\n  }\n\n  // Validate number fields\n  if (validFilter.since !== undefined && typeof validFilter.since !== 'number') return false;\n  if (validFilter.until !== undefined && typeof validFilter.until !== 'number') return false;\n  if (validFilter.limit !== undefined && typeof validFilter.limit !== 'number') return false;\n\n  return true;\n}\n\n/**\n * Type guard for NostrSubscription\n */\nexport function isNostrSubscription(sub: unknown): sub is NostrSubscription {\n  if (typeof sub !== 'object' || sub === null) {\n    return false;\n  }\n\n  const validSub = sub as Record<string, unknown>;\n\n  if (typeof validSub.id !== 'string') {\n    return false;\n  }\n\n  if (!Array.isArray(validSub.filters)) {\n    return false;\n  }\n\n  if (!validSub.filters.every(filter => isNostrFilter(filter))) {\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Type guard for NostrResponse\n */\nexport function isNostrResponse(response: unknown): response is NostrResponse {\n  if (typeof response !== 'object' || response === null) {\n    return false;\n  }\n\n  const validResponse = response as Record<string, unknown>;\n\n  if (typeof validResponse.type !== 'string') {\n    return false;\n  }\n\n  if (validResponse.subscriptionId !== undefined && typeof validResponse.subscriptionId !== 'string') {\n    return false;\n  }\n\n  if (validResponse.event !== undefined && !isSignedNostrEvent(validResponse.event)) {\n    return false;\n  }\n\n  if (validResponse.message !== undefined && typeof validResponse.message !== 'string') {\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Type guard for NostrError\n */\nexport function isNostrError(error: unknown): error is NostrError {\n  if (typeof error !== 'object' || error === null) {\n    return false;\n  }\n\n  const validError = error as Record<string, unknown>;\n\n  return (\n    typeof validError.type === 'string' &&\n    typeof validError.message === 'string'\n  );\n}\n", "/**\n * @module types/nip46\n * @description Type definitions for NIP-46 (Nostr Connect / Remote Signing)\n * @see https://github.com/nostr-protocol/nips/blob/master/46.md\n */\n\n/**\n * NIP-46 remote signing methods\n */\nexport enum Nip46Method {\n  CONNECT = 'connect',\n  PING = 'ping',\n  GET_PUBLIC_KEY = 'get_public_key',\n  SIGN_EVENT = 'sign_event',\n  NIP04_ENCRYPT = 'nip04_encrypt',\n  NIP04_DECRYPT = 'nip04_decrypt',\n  NIP44_ENCRYPT = 'nip44_encrypt',\n  NIP44_DECRYPT = 'nip44_decrypt',\n  GET_RELAYS = 'get_relays',\n}\n\n/**\n * Parsed bunker:// URI\n */\nexport interface BunkerURI {\n  /** Remote signer's public key (hex) */\n  remotePubkey: string;\n  /** Relay URLs for communication */\n  relays: string[];\n  /** Optional secret for initial connection */\n  secret?: string;\n}\n\n/**\n * NIP-46 JSON-RPC request (client -> signer)\n */\nexport interface Nip46Request {\n  id: string;\n  method: Nip46Method | string;\n  params: string[];\n}\n\n/**\n * NIP-46 JSON-RPC response (signer -> client)\n */\nexport interface Nip46Response {\n  id: string;\n  result?: string;\n  error?: string;\n}\n\n/**\n * A NIP-46 session containing the ephemeral keypair and conversation key\n */\nexport interface Nip46Session {\n  /** Client's ephemeral private key (hex) */\n  clientSecretKey: string;\n  /** Client's ephemeral public key (hex) */\n  clientPubkey: string;\n  /** Remote signer's public key (hex) */\n  remotePubkey: string;\n  /** NIP-44 conversation key (derived from ECDH) */\n  conversationKey: Uint8Array;\n}\n\n/**\n * Public session info (safe to expose; excludes private key and conversation key)\n */\nexport interface Nip46SessionInfo {\n  clientPubkey: string;\n  remotePubkey: string;\n}\n\n/**\n * Result of validating a bunker:// URI\n */\nexport interface BunkerValidationResult {\n  isValid: boolean;\n  error?: string;\n  uri?: BunkerURI;\n}\n", "/**\n * @module crypto\n * @description Cryptographic utilities for Nostr\n * \n * IMPORTANT: Nostr Protocol Cryptographic Requirements\n * While secp256k1 is the underlying elliptic curve used by Nostr, the protocol specifically\n * requires schnorr signatures as defined in NIP-01. This means:\n * \n * 1. Always use schnorr-specific functions:\n *    - schnorr.getPublicKey() for public key generation\n *    - schnorr.sign() for signing\n *    - schnorr.verify() for verification\n * \n * 2. Avoid using secp256k1 functions directly:\n *    - DON'T use secp256k1.getPublicKey()\n *    - DON'T use secp256k1.sign()\n *    - DON'T use secp256k1.verify()\n * \n * While both might work in some cases (as they use the same curve), the schnorr signature\n * scheme has specific requirements for key and signature formats that aren't guaranteed\n * when using the lower-level secp256k1 functions directly.\n */\n\nimport { schnorr, secp256k1 } from '@noble/curves/secp256k1.js';\nimport { bytesToHex, hexToBytes, randomBytes } from '@noble/hashes/utils.js';\nimport { sha256 } from '@noble/hashes/sha2.js';\nimport { KeyPair, PublicKeyDetails, NostrEvent, SignedNostrEvent, PublicKey } from './types/index';\nimport { logger } from './utils/logger';\nimport { bytesToBase64, base64ToBytes } from './encoding/base64';\n\n\n/**\n * Custom crypto interface for cross-platform compatibility\n */\nexport interface CryptoSubtle {\n  subtle: {\n    generateKey(\n      algorithm: RsaHashedKeyGenParams | EcKeyGenParams,\n      extractable: boolean,\n      keyUsages: readonly KeyUsage[]\n    ): Promise<CryptoKeyPair>;\n    importKey(\n      format: 'raw' | 'pkcs8' | 'spki',\n      keyData: ArrayBuffer,\n      algorithm: RsaHashedImportParams | EcKeyImportParams | AesKeyAlgorithm,\n      extractable: boolean,\n      keyUsages: readonly KeyUsage[]\n    ): Promise<CryptoKey>;\n    encrypt(\n      algorithm: { name: string; iv: Uint8Array },\n      key: CryptoKey,\n      data: ArrayBuffer\n    ): Promise<ArrayBuffer>;\n    decrypt(\n      algorithm: { name: string; iv: Uint8Array },\n      key: CryptoKey,\n      data: ArrayBuffer\n    ): Promise<ArrayBuffer>;\n  };\n  getRandomValues<T extends Uint8Array | Int8Array | Uint16Array | Int16Array | Uint32Array | Int32Array>(array: T): T;\n}\n\ndeclare global {\n  interface Window {\n    crypto: CryptoSubtle;\n  }\n  interface Global {\n    crypto: CryptoSubtle;\n  }\n}\n\n// Get the appropriate crypto implementation\nconst getCrypto = async (): Promise<CryptoSubtle> => {\n  if (typeof window !== 'undefined' && window.crypto) {\n    return window.crypto;\n  }\n  if (typeof global !== 'undefined' && (global as Global).crypto) {\n    return (global as Global).crypto;\n  }\n  try {\n    const cryptoModule = await import('crypto');\n    if (cryptoModule.webcrypto) {\n      return cryptoModule.webcrypto as CryptoSubtle;\n    }\n  } catch {\n    logger.debug('Node crypto not available');\n  }\n\n  throw new Error('No WebCrypto implementation available');\n};\n\n/**\n * Crypto implementation that works in both Node.js and browser environments\n */\nclass CustomCrypto {\n  private cryptoInstance: CryptoSubtle | null = null;\n  private initPromise: Promise<void>;\n\n  constructor() {\n    this.initPromise = this.initialize();\n  }\n\n  private async initialize(): Promise<void> {\n    this.cryptoInstance = await getCrypto();\n  }\n\n  private async ensureInitialized(): Promise<CryptoSubtle> {\n    await this.initPromise;\n    if (!this.cryptoInstance) {\n      throw new Error('Crypto implementation not initialized');\n    }\n    return this.cryptoInstance;\n  }\n\n  async getSubtle(): Promise<CryptoSubtle['subtle']> {\n    const crypto = await this.ensureInitialized();\n    return crypto.subtle;\n  }\n\n  async getRandomValues<T extends Uint8Array | Int8Array | Uint16Array | Int16Array | Uint32Array | Int32Array>(array: T): Promise<T> {\n    const crypto = await this.ensureInitialized();\n    return crypto.getRandomValues(array);\n  }\n}\n\n// Create and export default instance\nexport const customCrypto = new CustomCrypto();\n\n// Export schnorr functions\nexport const signSchnorr = schnorr.sign;\nexport const verifySchnorrSignature = schnorr.verify;\n\n/**\n * Gets the compressed public key (33 bytes with prefix)\n */\nexport function getCompressedPublicKey(privateKeyBytes: Uint8Array): Uint8Array {\n  return secp256k1.getPublicKey(privateKeyBytes, true);\n}\n\n/**\n * Gets the schnorr public key (32 bytes x-coordinate) as per BIP340\n */\nexport function getSchnorrPublicKey(privateKeyBytes: Uint8Array): Uint8Array {\n  return schnorr.getPublicKey(privateKeyBytes);\n}\n\n/**\n * Generates a new key pair\n */\nexport async function generateKeyPair(): Promise<KeyPair> {\n  const privateKeyBytes = randomBytes(32);\n  const privateKey = bytesToHex(privateKeyBytes);\n  privateKeyBytes.fill(0); // zero source material\n  const publicKey = await getPublicKey(privateKey);\n\n  return {\n    privateKey,\n    publicKey\n  };\n}\n\n/**\n * Gets a public key from a private key\n */\nexport async function getPublicKey(privateKey: string): Promise<PublicKeyDetails> {\n  try {\n    const privateKeyBytes = hexToBytes(privateKey);\n    const publicKeyBytes = schnorr.getPublicKey(privateKeyBytes);\n    return {\n      hex: bytesToHex(publicKeyBytes),\n      bytes: publicKeyBytes\n    };\n  } catch (error) {\n    logger.error({ error }, 'Failed to get public key');\n    throw error;\n  }\n}\n\n/**\n * Validates a key pair\n */\nexport async function validateKeyPair(keyPair: KeyPair): Promise<boolean> {\n  try {\n    const derivedPubKey = await getPublicKey(keyPair.privateKey);\n    return derivedPubKey.hex === keyPair.publicKey.hex;\n  } catch (error) {\n    logger.error({ error }, 'Failed to validate key pair');\n    return false;\n  }\n}\n\n/**\n * Creates a new event\n */\nexport function createEvent(event: Partial<NostrEvent>): NostrEvent {\n  const timestamp = Math.floor(Date.now() / 1000);\n\n  return {\n    ...event,\n    created_at: event.created_at || timestamp,\n    tags: event.tags || [],\n    content: event.content || '',\n    kind: event.kind || 1\n  } as NostrEvent;\n}\n\n/**\n * Normalize a private key to hex string (accepts both hex string and Uint8Array)\n */\nfunction normalizePrivateKey(privateKey: string | Uint8Array): string {\n  if (privateKey instanceof Uint8Array) {\n    return bytesToHex(privateKey);\n  }\n  return privateKey;\n}\n\n/**\n * Signs an event\n * @param event - Event to sign\n * @param privateKey - Private key as hex string or Uint8Array\n */\nexport async function signEvent(event: NostrEvent, privateKey: string | Uint8Array): Promise<SignedNostrEvent> {\n  try {\n    const privateKeyHex = normalizePrivateKey(privateKey);\n\n    // Serialize event for signing (NIP-01 format)\n    const serialized = JSON.stringify([\n      0,\n      event.pubkey,\n      event.created_at,\n      event.kind,\n      event.tags,\n      event.content\n    ]);\n\n    // Calculate event hash\n    const eventHash = sha256(new TextEncoder().encode(serialized));\n\n    // Convert private key to bytes and sign\n    const privateKeyBytes = hexToBytes(privateKeyHex);\n    const signatureBytes = schnorr.sign(eventHash, privateKeyBytes);\n\n    // Create signed event\n    return {\n      ...event,\n      id: bytesToHex(eventHash),\n      sig: bytesToHex(signatureBytes)\n    };\n  } catch (error) {\n    logger.error({ error }, 'Failed to sign event');\n    throw error;\n  }\n}\n\n/**\n * Gets a public key hex string from a private key (synchronous)\n * @param privateKey - Private key as hex string or Uint8Array\n * @returns Hex-encoded public key (32-byte x-only schnorr key)\n */\nexport function getPublicKeySync(privateKey: string | Uint8Array): string {\n  const privateKeyBytes = privateKey instanceof Uint8Array\n    ? privateKey\n    : hexToBytes(privateKey);\n  const publicKeyBytes = schnorr.getPublicKey(privateKeyBytes);\n  return bytesToHex(publicKeyBytes);\n}\n\n/**\n * Creates, hashes, and signs a Nostr event in one step\n * @param event - Partial event (kind, content, tags required; pubkey derived if missing)\n * @param privateKey - Private key as hex string or Uint8Array\n * @returns Fully signed event with id, pubkey, and sig\n */\nexport async function finalizeEvent(\n  event: Partial<NostrEvent>,\n  privateKey: string | Uint8Array\n): Promise<SignedNostrEvent> {\n  const pubkey = event.pubkey || getPublicKeySync(privateKey);\n  const timestamp = event.created_at || Math.floor(Date.now() / 1000);\n\n  const fullEvent: NostrEvent = {\n    kind: event.kind || 1,\n    created_at: timestamp,\n    tags: event.tags || [],\n    content: event.content || '',\n    pubkey,\n  };\n\n  return signEvent(fullEvent, privateKey);\n}\n\n/**\n * Verifies an event signature\n */\nexport async function verifySignature(event: SignedNostrEvent): Promise<boolean> {\n  try {\n    // Serialize event for verification (NIP-01 format)\n    const serialized = JSON.stringify([\n      0,\n      event.pubkey,\n      event.created_at,\n      event.kind,\n      event.tags,\n      event.content\n    ]);\n\n    // Calculate event hash\n    const eventHash = sha256(new TextEncoder().encode(serialized));\n\n    // Verify event ID\n    const calculatedId = bytesToHex(eventHash);\n    if (calculatedId !== event.id) {\n      logger.error('Event ID mismatch');\n      return false;\n    }\n\n    // Convert hex strings to bytes\n    const signatureBytes = hexToBytes(event.sig);\n    const pubkeyBytes = hexToBytes(event.pubkey);\n\n    // Verify signature\n    return schnorr.verify(signatureBytes, eventHash, pubkeyBytes);\n  } catch (error) {\n    logger.error({ error }, 'Failed to verify signature');\n    return false;\n  }\n}\n\n/**\n * Encrypts a message using NIP-04\n */\nexport async function encrypt(\n  message: string,\n  recipientPubKey: PublicKey | string,\n  senderPrivKey: string\n): Promise<string> {\n  try {\n    const recipientPubKeyHex = typeof recipientPubKey === 'string' ? recipientPubKey : recipientPubKey.hex;\n    const sharedPoint = secp256k1.getSharedSecret(hexToBytes(senderPrivKey), hexToBytes(recipientPubKeyHex));\n    const sharedX = sharedPoint.slice(1, 33);\n\n    // Generate random IV\n    const iv = randomBytes(16);\n    const key = await customCrypto.getSubtle().then((subtle) => subtle.importKey(\n      'raw',\n      sharedX.buffer,\n      { name: 'AES-CBC', length: 256 },\n      false,\n      ['encrypt']\n    ));\n\n    // Zero shared secret material now that AES key is imported\n    sharedX.fill(0);\n    sharedPoint.fill(0);\n\n    // Encrypt the message\n    const data = new TextEncoder().encode(message);\n    const encrypted = await customCrypto.getSubtle().then((subtle) => subtle.encrypt(\n      { name: 'AES-CBC', iv },\n      key,\n      data.buffer\n    ));\n\n    // NIP-04 standard format: base64(ciphertext) + \"?iv=\" + base64(iv)\n    const ciphertextBase64 = bytesToBase64(new Uint8Array(encrypted));\n    const ivBase64 = bytesToBase64(iv);\n\n    return ciphertextBase64 + '?iv=' + ivBase64;\n  } catch (error) {\n    logger.error({ error }, 'Failed to encrypt message');\n    throw error;\n  }\n}\n\n/**\n * Decrypts a message using NIP-04\n */\nexport async function decrypt(\n  encryptedMessage: string,\n  senderPubKey: PublicKey | string,\n  recipientPrivKey: string\n): Promise<string> {\n  try {\n    const senderPubKeyHex = typeof senderPubKey === 'string' ? senderPubKey : senderPubKey.hex;\n    const sharedPoint = secp256k1.getSharedSecret(hexToBytes(recipientPrivKey), hexToBytes(senderPubKeyHex));\n    const sharedX = sharedPoint.slice(1, 33);\n\n    // Parse NIP-04 standard format: base64(ciphertext) + \"?iv=\" + base64(iv)\n    // Also support legacy hex format (iv + ciphertext concatenated) as fallback\n    let iv: Uint8Array;\n    let ciphertext: Uint8Array;\n\n    if (encryptedMessage.includes('?iv=')) {\n      // NIP-04 standard format\n      const [ciphertextBase64, ivBase64] = encryptedMessage.split('?iv=');\n      ciphertext = base64ToBytes(ciphertextBase64);\n      iv = base64ToBytes(ivBase64);\n    } else {\n      // Legacy hex format fallback: first 16 bytes are IV, rest is ciphertext\n      const encrypted = hexToBytes(encryptedMessage);\n      iv = encrypted.slice(0, 16);\n      ciphertext = encrypted.slice(16);\n    }\n\n    const key = await customCrypto.getSubtle().then((subtle) => subtle.importKey(\n      'raw',\n      sharedX.buffer,\n      { name: 'AES-CBC', length: 256 },\n      false,\n      ['decrypt']\n    ));\n\n    // Zero shared secret material now that AES key is imported\n    sharedX.fill(0);\n    sharedPoint.fill(0);\n\n    const decrypted = await customCrypto.getSubtle().then((subtle) => subtle.decrypt(\n      { name: 'AES-CBC', iv },\n      key,\n      ciphertext.buffer as ArrayBuffer\n    ));\n\n    return new TextDecoder().decode(decrypted);\n  } catch (error) {\n    logger.error({ error }, 'Failed to decrypt message');\n    throw error;\n  }\n}\n", "/**\n * SECG secp256k1. See [pdf](https://www.secg.org/sec2-v2.pdf).\n *\n * Belongs to Koblitz curves: it has efficiently-computable GLV endomorphism \u03C8,\n * check out {@link EndomorphismOpts}. Seems to be rigid (not backdoored).\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { sha256 } from '@noble/hashes/sha2.js';\nimport { randomBytes } from '@noble/hashes/utils.js';\nimport { createKeygen, type CurveLengths } from './abstract/curve.ts';\nimport { createHasher, type H2CHasher, isogenyMap } from './abstract/hash-to-curve.ts';\nimport { Field, mapHashToField, pow2 } from './abstract/modular.ts';\nimport {\n  type ECDSA,\n  ecdsa,\n  type EndomorphismOpts,\n  mapToCurveSimpleSWU,\n  type WeierstrassPoint as PointType,\n  weierstrass,\n  type WeierstrassOpts,\n  type WeierstrassPointCons,\n} from './abstract/weierstrass.ts';\nimport { abytes, asciiToBytes, bytesToNumberBE, concatBytes } from './utils.ts';\n\n// Seems like generator was produced from some seed:\n// `Pointk1.BASE.multiply(Pointk1.Fn.inv(2n, N)).toAffine().x`\n// // gives short x 0x3b78ce563f89a0ed9414f5aa28ad0d96d6795f9c63n\nconst secp256k1_CURVE: WeierstrassOpts<bigint> = {\n  p: BigInt('0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f'),\n  n: BigInt('0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141'),\n  h: BigInt(1),\n  a: BigInt(0),\n  b: BigInt(7),\n  Gx: BigInt('0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'),\n  Gy: BigInt('0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8'),\n};\n\nconst secp256k1_ENDO: EndomorphismOpts = {\n  beta: BigInt('0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee'),\n  basises: [\n    [BigInt('0x3086d221a7d46bcde86c90e49284eb15'), -BigInt('0xe4437ed6010e88286f547fa90abfe4c3')],\n    [BigInt('0x114ca50f7a8e2f3f657c1108d9d44cfd8'), BigInt('0x3086d221a7d46bcde86c90e49284eb15')],\n  ],\n};\n\nconst _0n = /* @__PURE__ */ BigInt(0);\nconst _2n = /* @__PURE__ */ BigInt(2);\n\n/**\n * \u221An = n^((p+1)/4) for fields p = 3 mod 4. We unwrap the loop and multiply bit-by-bit.\n * (P+1n/4n).toString(2) would produce bits [223x 1, 0, 22x 1, 4x 0, 11, 00]\n */\nfunction sqrtMod(y: bigint): bigint {\n  const P = secp256k1_CURVE.p;\n  // prettier-ignore\n  const _3n = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);\n  // prettier-ignore\n  const _23n = BigInt(23), _44n = BigInt(44), _88n = BigInt(88);\n  const b2 = (y * y * y) % P; // x^3, 11\n  const b3 = (b2 * b2 * y) % P; // x^7\n  const b6 = (pow2(b3, _3n, P) * b3) % P;\n  const b9 = (pow2(b6, _3n, P) * b3) % P;\n  const b11 = (pow2(b9, _2n, P) * b2) % P;\n  const b22 = (pow2(b11, _11n, P) * b11) % P;\n  const b44 = (pow2(b22, _22n, P) * b22) % P;\n  const b88 = (pow2(b44, _44n, P) * b44) % P;\n  const b176 = (pow2(b88, _88n, P) * b88) % P;\n  const b220 = (pow2(b176, _44n, P) * b44) % P;\n  const b223 = (pow2(b220, _3n, P) * b3) % P;\n  const t1 = (pow2(b223, _23n, P) * b22) % P;\n  const t2 = (pow2(t1, _6n, P) * b2) % P;\n  const root = pow2(t2, _2n, P);\n  if (!Fpk1.eql(Fpk1.sqr(root), y)) throw new Error('Cannot find square root');\n  return root;\n}\n\nconst Fpk1 = Field(secp256k1_CURVE.p, { sqrt: sqrtMod });\nconst Pointk1 = /* @__PURE__ */ weierstrass(secp256k1_CURVE, {\n  Fp: Fpk1,\n  endo: secp256k1_ENDO,\n});\n\n/**\n * secp256k1 curve: ECDSA and ECDH methods.\n *\n * Uses sha256 to hash messages. To use a different hash,\n * pass `{ prehash: false }` to sign / verify.\n *\n * @example\n * ```js\n * import { secp256k1 } from '@noble/curves/secp256k1.js';\n * const { secretKey, publicKey } = secp256k1.keygen();\n * // const publicKey = secp256k1.getPublicKey(secretKey);\n * const msg = new TextEncoder().encode('hello noble');\n * const sig = secp256k1.sign(msg, secretKey);\n * const isValid = secp256k1.verify(sig, msg, publicKey);\n * // const sigKeccak = secp256k1.sign(keccak256(msg), secretKey, { prehash: false });\n * ```\n */\nexport const secp256k1: ECDSA = /* @__PURE__ */ ecdsa(Pointk1, sha256);\n\n// Schnorr signatures are superior to ECDSA from above. Below is Schnorr-specific BIP0340 code.\n// https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki\n/** An object mapping tags to their tagged hash prefix of [SHA256(tag) | SHA256(tag)] */\nconst TAGGED_HASH_PREFIXES: { [tag: string]: Uint8Array } = {};\nfunction taggedHash(tag: string, ...messages: Uint8Array[]): Uint8Array {\n  let tagP = TAGGED_HASH_PREFIXES[tag];\n  if (tagP === undefined) {\n    const tagH = sha256(asciiToBytes(tag));\n    tagP = concatBytes(tagH, tagH);\n    TAGGED_HASH_PREFIXES[tag] = tagP;\n  }\n  return sha256(concatBytes(tagP, ...messages));\n}\n\n// ECDSA compact points are 33-byte. Schnorr is 32: we strip first byte 0x02 or 0x03\nconst pointToBytes = (point: PointType<bigint>) => point.toBytes(true).slice(1);\nconst hasEven = (y: bigint) => y % _2n === _0n;\n\n// Calculate point, scalar and bytes\nfunction schnorrGetExtPubKey(priv: Uint8Array) {\n  const { Fn, BASE } = Pointk1;\n  const d_ = Fn.fromBytes(priv);\n  const p = BASE.multiply(d_); // P = d'\u22C5G; 0 < d' < n check is done inside\n  const scalar = hasEven(p.y) ? d_ : Fn.neg(d_);\n  return { scalar, bytes: pointToBytes(p) };\n}\n/**\n * lift_x from BIP340. Convert 32-byte x coordinate to elliptic curve point.\n * @returns valid point checked for being on-curve\n */\nfunction lift_x(x: bigint): PointType<bigint> {\n  const Fp = Fpk1;\n  if (!Fp.isValidNot0(x)) throw new Error('invalid x: Fail if x \u2265 p');\n  const xx = Fp.create(x * x);\n  const c = Fp.create(xx * x + BigInt(7)); // Let c = x\u00B3 + 7 mod p.\n  let y = Fp.sqrt(c); // Let y = c^(p+1)/4 mod p. Same as sqrt().\n  // Return the unique point P such that x(P) = x and\n  // y(P) = y if y mod 2 = 0 or y(P) = p-y otherwise.\n  if (!hasEven(y)) y = Fp.neg(y);\n  const p = Pointk1.fromAffine({ x, y });\n  p.assertValidity();\n  return p;\n}\nconst num = bytesToNumberBE;\n/**\n * Create tagged hash, convert it to bigint, reduce modulo-n.\n */\nfunction challenge(...args: Uint8Array[]): bigint {\n  return Pointk1.Fn.create(num(taggedHash('BIP0340/challenge', ...args)));\n}\n\n/**\n * Schnorr public key is just `x` coordinate of Point as per BIP340.\n */\nfunction schnorrGetPublicKey(secretKey: Uint8Array): Uint8Array {\n  return schnorrGetExtPubKey(secretKey).bytes; // d'=int(sk). Fail if d'=0 or d'\u2265n. Ret bytes(d'\u22C5G)\n}\n\n/**\n * Creates Schnorr signature as per BIP340. Verifies itself before returning anything.\n * auxRand is optional and is not the sole source of k generation: bad CSPRNG won't be dangerous.\n */\nfunction schnorrSign(\n  message: Uint8Array,\n  secretKey: Uint8Array,\n  auxRand: Uint8Array = randomBytes(32)\n): Uint8Array {\n  const { Fn } = Pointk1;\n  const m = abytes(message, undefined, 'message');\n  const { bytes: px, scalar: d } = schnorrGetExtPubKey(secretKey); // checks for isWithinCurveOrder\n  const a = abytes(auxRand, 32, 'auxRand'); // Auxiliary random data a: a 32-byte array\n  const t = Fn.toBytes(d ^ num(taggedHash('BIP0340/aux', a))); // Let t be the byte-wise xor of bytes(d) and hash/aux(a)\n  const rand = taggedHash('BIP0340/nonce', t, px, m); // Let rand = hash/nonce(t || bytes(P) || m)\n  // Let k' = int(rand) mod n. Fail if k' = 0. Let R = k'\u22C5G\n  const { bytes: rx, scalar: k } = schnorrGetExtPubKey(rand);\n  const e = challenge(rx, px, m); // Let e = int(hash/challenge(bytes(R) || bytes(P) || m)) mod n.\n  const sig = new Uint8Array(64); // Let sig = bytes(R) || bytes((k + ed) mod n).\n  sig.set(rx, 0);\n  sig.set(Fn.toBytes(Fn.create(k + e * d)), 32);\n  // If Verify(bytes(P), m, sig) (see below) returns failure, abort\n  if (!schnorrVerify(sig, m, px)) throw new Error('sign: Invalid signature produced');\n  return sig;\n}\n\n/**\n * Verifies Schnorr signature.\n * Will swallow errors & return false except for initial type validation of arguments.\n */\nfunction schnorrVerify(signature: Uint8Array, message: Uint8Array, publicKey: Uint8Array): boolean {\n  const { Fp, Fn, BASE } = Pointk1;\n  const sig = abytes(signature, 64, 'signature');\n  const m = abytes(message, undefined, 'message');\n  const pub = abytes(publicKey, 32, 'publicKey');\n  try {\n    const P = lift_x(num(pub)); // P = lift_x(int(pk)); fail if that fails\n    const r = num(sig.subarray(0, 32)); // Let r = int(sig[0:32]); fail if r \u2265 p.\n    if (!Fp.isValidNot0(r)) return false;\n    const s = num(sig.subarray(32, 64)); // Let s = int(sig[32:64]); fail if s \u2265 n.\n    if (!Fn.isValidNot0(s)) return false;\n\n    const e = challenge(Fn.toBytes(r), pointToBytes(P), m); // int(challenge(bytes(r)||bytes(P)||m))%n\n    // R = s\u22C5G - e\u22C5P, where -eP == (n-e)P\n    const R = BASE.multiplyUnsafe(s).add(P.multiplyUnsafe(Fn.neg(e)));\n    const { x, y } = R.toAffine();\n    // Fail if is_infinite(R) / not has_even_y(R) / x(R) \u2260 r.\n    if (R.is0() || !hasEven(y) || x !== r) return false;\n    return true;\n  } catch (error) {\n    return false;\n  }\n}\n\nexport type SecpSchnorr = {\n  keygen: (seed?: Uint8Array) => { secretKey: Uint8Array; publicKey: Uint8Array };\n  getPublicKey: typeof schnorrGetPublicKey;\n  sign: typeof schnorrSign;\n  verify: typeof schnorrVerify;\n  Point: WeierstrassPointCons<bigint>;\n  utils: {\n    randomSecretKey: (seed?: Uint8Array) => Uint8Array;\n    pointToBytes: (point: PointType<bigint>) => Uint8Array;\n    lift_x: typeof lift_x;\n    taggedHash: typeof taggedHash;\n  };\n  lengths: CurveLengths;\n};\n/**\n * Schnorr signatures over secp256k1.\n * https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki\n * @example\n * ```js\n * import { schnorr } from '@noble/curves/secp256k1.js';\n * const { secretKey, publicKey } = schnorr.keygen();\n * // const publicKey = schnorr.getPublicKey(secretKey);\n * const msg = new TextEncoder().encode('hello');\n * const sig = schnorr.sign(msg, secretKey);\n * const isValid = schnorr.verify(sig, msg, publicKey);\n * ```\n */\nexport const schnorr: SecpSchnorr = /* @__PURE__ */ (() => {\n  const size = 32;\n  const seedLength = 48;\n  const randomSecretKey = (seed = randomBytes(seedLength)): Uint8Array => {\n    return mapHashToField(seed, secp256k1_CURVE.n);\n  };\n  return {\n    keygen: createKeygen(randomSecretKey, schnorrGetPublicKey),\n    getPublicKey: schnorrGetPublicKey,\n    sign: schnorrSign,\n    verify: schnorrVerify,\n    Point: Pointk1,\n    utils: {\n      randomSecretKey,\n      taggedHash,\n      lift_x,\n      pointToBytes,\n    },\n    lengths: {\n      secretKey: size,\n      publicKey: size,\n      publicKeyHasPrefix: false,\n      signature: size * 2,\n      seed: seedLength,\n    },\n  };\n})();\n\nconst isoMap = /* @__PURE__ */ (() =>\n  isogenyMap(\n    Fpk1,\n    [\n      // xNum\n      [\n        '0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa8c7',\n        '0x7d3d4c80bc321d5b9f315cea7fd44c5d595d2fc0bf63b92dfff1044f17c6581',\n        '0x534c328d23f234e6e2a413deca25caece4506144037c40314ecbd0b53d9dd262',\n        '0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa88c',\n      ],\n      // xDen\n      [\n        '0xd35771193d94918a9ca34ccbb7b640dd86cd409542f8487d9fe6b745781eb49b',\n        '0xedadc6f64383dc1df7c4b2d51b54225406d36b641f5e41bbc52a56612a8c6d14',\n        '0x0000000000000000000000000000000000000000000000000000000000000001', // LAST 1\n      ],\n      // yNum\n      [\n        '0x4bda12f684bda12f684bda12f684bda12f684bda12f684bda12f684b8e38e23c',\n        '0xc75e0c32d5cb7c0fa9d0a54b12a0a6d5647ab046d686da6fdffc90fc201d71a3',\n        '0x29a6194691f91a73715209ef6512e576722830a201be2018a765e85a9ecee931',\n        '0x2f684bda12f684bda12f684bda12f684bda12f684bda12f684bda12f38e38d84',\n      ],\n      // yDen\n      [\n        '0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffff93b',\n        '0x7a06534bb8bdb49fd5e9e6632722c2989467c1bfc8e8d978dfb425d2685c2573',\n        '0x6484aa716545ca2cf3a70c3fa8fe337e0a3d21162f0d6299a7bf8192bfd2a76f',\n        '0x0000000000000000000000000000000000000000000000000000000000000001', // LAST 1\n      ],\n    ].map((i) => i.map((j) => BigInt(j))) as [bigint[], bigint[], bigint[], bigint[]]\n  ))();\nconst mapSWU = /* @__PURE__ */ (() =>\n  mapToCurveSimpleSWU(Fpk1, {\n    A: BigInt('0x3f8731abdd661adca08a5558f0f5d272e953d363cb6f0e5d405447c01a444533'),\n    B: BigInt('1771'),\n    Z: Fpk1.create(BigInt('-11')),\n  }))();\n\n/** Hashing / encoding to secp256k1 points / field. RFC 9380 methods. */\nexport const secp256k1_hasher: H2CHasher<WeierstrassPointCons<bigint>> = /* @__PURE__ */ (() =>\n  createHasher(\n    Pointk1,\n    (scalars: bigint[]) => {\n      const { x, y } = mapSWU(Fpk1.create(scalars[0]));\n      return isoMap(x, y);\n    },\n    {\n      DST: 'secp256k1_XMD:SHA-256_SSWU_RO_',\n      encodeDST: 'secp256k1_XMD:SHA-256_SSWU_NU_',\n      p: Fpk1.ORDER,\n      m: 1,\n      k: 128,\n      expand: 'xmd',\n      hash: sha256,\n    }\n  ))();\n", "/**\n * SHA2 hash function. A.k.a. sha256, sha384, sha512, sha512_224, sha512_256.\n * SHA256 is the fastest hash implementable in JS, even faster than Blake3.\n * Check out [RFC 4634](https://www.rfc-editor.org/rfc/rfc4634) and\n * [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).\n * @module\n */\nimport { Chi, HashMD, Maj, SHA224_IV, SHA256_IV, SHA384_IV, SHA512_IV } from './_md.ts';\nimport * as u64 from './_u64.ts';\nimport { type CHash, clean, createHasher, oidNist, rotr } from './utils.ts';\n\n/**\n * Round constants:\n * First 32 bits of fractional parts of the cube roots of the first 64 primes 2..311)\n */\n// prettier-ignore\nconst SHA256_K = /* @__PURE__ */ Uint32Array.from([\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\n/** Reusable temporary buffer. \"W\" comes straight from spec. */\nconst SHA256_W = /* @__PURE__ */ new Uint32Array(64);\n\n/** Internal 32-byte base SHA2 hash class. */\nabstract class SHA2_32B<T extends SHA2_32B<T>> extends HashMD<T> {\n  // We cannot use array here since array allows indexing by variable\n  // which means optimizer/compiler cannot use registers.\n  protected abstract A: number;\n  protected abstract B: number;\n  protected abstract C: number;\n  protected abstract D: number;\n  protected abstract E: number;\n  protected abstract F: number;\n  protected abstract G: number;\n  protected abstract H: number;\n\n  constructor(outputLen: number) {\n    super(64, outputLen, 8, false);\n  }\n  protected get(): [number, number, number, number, number, number, number, number] {\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  protected set(\n    A: number, B: number, C: number, D: number, E: number, F: number, G: number, H: number\n  ): void {\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  protected process(view: DataView, offset: number): void {\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) 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 = rotr(W15, 7) ^ rotr(W15, 18) ^ (W15 >>> 3);\n      const s1 = rotr(W2, 17) ^ 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 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);\n      const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;\n      const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ 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  protected roundClean(): void {\n    clean(SHA256_W);\n  }\n  destroy(): void {\n    this.set(0, 0, 0, 0, 0, 0, 0, 0);\n    clean(this.buffer);\n  }\n}\n\n/** Internal SHA2-256 hash class. */\nexport class _SHA256 extends SHA2_32B<_SHA256> {\n  // We cannot use array here since array allows indexing by variable\n  // which means optimizer/compiler cannot use registers.\n  protected A: number = SHA256_IV[0] | 0;\n  protected B: number = SHA256_IV[1] | 0;\n  protected C: number = SHA256_IV[2] | 0;\n  protected D: number = SHA256_IV[3] | 0;\n  protected E: number = SHA256_IV[4] | 0;\n  protected F: number = SHA256_IV[5] | 0;\n  protected G: number = SHA256_IV[6] | 0;\n  protected H: number = SHA256_IV[7] | 0;\n  constructor() {\n    super(32);\n  }\n}\n\n/** Internal SHA2-224 hash class. */\nexport class _SHA224 extends SHA2_32B<_SHA224> {\n  protected A: number = SHA224_IV[0] | 0;\n  protected B: number = SHA224_IV[1] | 0;\n  protected C: number = SHA224_IV[2] | 0;\n  protected D: number = SHA224_IV[3] | 0;\n  protected E: number = SHA224_IV[4] | 0;\n  protected F: number = SHA224_IV[5] | 0;\n  protected G: number = SHA224_IV[6] | 0;\n  protected H: number = SHA224_IV[7] | 0;\n  constructor() {\n    super(28);\n  }\n}\n\n// SHA2-512 is slower than sha256 in js because u64 operations are slow.\n\n// Round contants\n// First 32 bits of the fractional parts of the cube roots of the first 80 primes 2..409\n// prettier-ignore\nconst K512 = /* @__PURE__ */ (() => u64.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))))();\nconst SHA512_Kh = /* @__PURE__ */ (() => K512[0])();\nconst SHA512_Kl = /* @__PURE__ */ (() => K512[1])();\n\n// Reusable temporary buffers\nconst SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);\nconst SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);\n\n/** Internal 64-byte base SHA2 hash class. */\nabstract class SHA2_64B<T extends SHA2_64B<T>> extends HashMD<T> {\n  // We cannot use array here since array allows indexing by variable\n  // which means optimizer/compiler cannot use registers.\n  // h -- high 32 bits, l -- low 32 bits\n  protected abstract Ah: number;\n  protected abstract Al: number;\n  protected abstract Bh: number;\n  protected abstract Bl: number;\n  protected abstract Ch: number;\n  protected abstract Cl: number;\n  protected abstract Dh: number;\n  protected abstract Dl: number;\n  protected abstract Eh: number;\n  protected abstract El: number;\n  protected abstract Fh: number;\n  protected abstract Fl: number;\n  protected abstract Gh: number;\n  protected abstract Gl: number;\n  protected abstract Hh: number;\n  protected abstract Hl: number;\n\n  constructor(outputLen: number) {\n    super(128, outputLen, 16, false);\n  }\n  // prettier-ignore\n  protected get(): [\n    number, number, number, number, number, number, number, number,\n    number, number, number, number, number, number, number, number\n  ] {\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  protected set(\n    Ah: number, Al: number, Bh: number, Bl: number, Ch: number, Cl: number, Dh: number, Dl: number,\n    Eh: number, El: number, Fh: number, Fl: number, Gh: number, Gl: number, Hh: number, Hl: number\n  ): void {\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  protected process(view: DataView, offset: number): void {\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.rotrSH(W15h, W15l, 1) ^ u64.rotrSH(W15h, W15l, 8) ^ u64.shrSH(W15h, W15l, 7);\n      const s0l = u64.rotrSL(W15h, W15l, 1) ^ u64.rotrSL(W15h, W15l, 8) ^ u64.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.rotrSH(W2h, W2l, 19) ^ u64.rotrBH(W2h, W2l, 61) ^ u64.shrSH(W2h, W2l, 6);\n      const s1l = u64.rotrSL(W2h, W2l, 19) ^ u64.rotrBL(W2h, W2l, 61) ^ u64.shrSL(W2h, W2l, 6);\n      // SHA256_W[i] = s0 + s1 + SHA256_W[i - 7] + SHA256_W[i - 16];\n      const SUMl = u64.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);\n      const SUMh = u64.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.rotrSH(Eh, El, 14) ^ u64.rotrSH(Eh, El, 18) ^ u64.rotrBH(Eh, El, 41);\n      const sigma1l = u64.rotrSL(Eh, El, 14) ^ u64.rotrSL(Eh, El, 18) ^ u64.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.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);\n      const T1h = u64.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.rotrSH(Ah, Al, 28) ^ u64.rotrBH(Ah, Al, 34) ^ u64.rotrBH(Ah, Al, 39);\n      const sigma0l = u64.rotrSL(Ah, Al, 28) ^ u64.rotrBL(Ah, Al, 34) ^ u64.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.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.add3L(T1l, sigma0l, MAJl);\n      Ah = u64.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.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));\n    ({ h: Bh, l: Bl } = u64.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));\n    ({ h: Ch, l: Cl } = u64.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));\n    ({ h: Dh, l: Dl } = u64.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));\n    ({ h: Eh, l: El } = u64.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));\n    ({ h: Fh, l: Fl } = u64.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));\n    ({ h: Gh, l: Gl } = u64.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));\n    ({ h: Hh, l: Hl } = u64.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  protected roundClean(): void {\n    clean(SHA512_W_H, SHA512_W_L);\n  }\n  destroy(): void {\n    clean(this.buffer);\n    this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);\n  }\n}\n\n/** Internal SHA2-512 hash class. */\nexport class _SHA512 extends SHA2_64B<_SHA512> {\n  protected Ah: number = SHA512_IV[0] | 0;\n  protected Al: number = SHA512_IV[1] | 0;\n  protected Bh: number = SHA512_IV[2] | 0;\n  protected Bl: number = SHA512_IV[3] | 0;\n  protected Ch: number = SHA512_IV[4] | 0;\n  protected Cl: number = SHA512_IV[5] | 0;\n  protected Dh: number = SHA512_IV[6] | 0;\n  protected Dl: number = SHA512_IV[7] | 0;\n  protected Eh: number = SHA512_IV[8] | 0;\n  protected El: number = SHA512_IV[9] | 0;\n  protected Fh: number = SHA512_IV[10] | 0;\n  protected Fl: number = SHA512_IV[11] | 0;\n  protected Gh: number = SHA512_IV[12] | 0;\n  protected Gl: number = SHA512_IV[13] | 0;\n  protected Hh: number = SHA512_IV[14] | 0;\n  protected Hl: number = SHA512_IV[15] | 0;\n\n  constructor() {\n    super(64);\n  }\n}\n\n/** Internal SHA2-384 hash class. */\nexport class _SHA384 extends SHA2_64B<_SHA384> {\n  protected Ah: number = SHA384_IV[0] | 0;\n  protected Al: number = SHA384_IV[1] | 0;\n  protected Bh: number = SHA384_IV[2] | 0;\n  protected Bl: number = SHA384_IV[3] | 0;\n  protected Ch: number = SHA384_IV[4] | 0;\n  protected Cl: number = SHA384_IV[5] | 0;\n  protected Dh: number = SHA384_IV[6] | 0;\n  protected Dl: number = SHA384_IV[7] | 0;\n  protected Eh: number = SHA384_IV[8] | 0;\n  protected El: number = SHA384_IV[9] | 0;\n  protected Fh: number = SHA384_IV[10] | 0;\n  protected Fl: number = SHA384_IV[11] | 0;\n  protected Gh: number = SHA384_IV[12] | 0;\n  protected Gl: number = SHA384_IV[13] | 0;\n  protected Hh: number = SHA384_IV[14] | 0;\n  protected Hl: number = SHA384_IV[15] | 0;\n\n  constructor() {\n    super(48);\n  }\n}\n\n/**\n * Truncated SHA512/256 and SHA512/224.\n * SHA512_IV is XORed with 0xa5a5a5a5a5a5a5a5, then used as \"intermediary\" IV of SHA512/t.\n * Then t hashes string to produce result IV.\n * See `test/misc/sha2-gen-iv.js`.\n */\n\n/** SHA512/224 IV */\nconst T224_IV = /* @__PURE__ */ Uint32Array.from([\n  0x8c3d37c8, 0x19544da2, 0x73e19966, 0x89dcd4d6, 0x1dfab7ae, 0x32ff9c82, 0x679dd514, 0x582f9fcf,\n  0x0f6d2b69, 0x7bd44da8, 0x77e36f73, 0x04c48942, 0x3f9d85a8, 0x6a1d36c8, 0x1112e6ad, 0x91d692a1,\n]);\n\n/** SHA512/256 IV */\nconst T256_IV = /* @__PURE__ */ Uint32Array.from([\n  0x22312194, 0xfc2bf72c, 0x9f555fa3, 0xc84c64c2, 0x2393b86b, 0x6f53b151, 0x96387719, 0x5940eabd,\n  0x96283ee2, 0xa88effe3, 0xbe5e1e25, 0x53863992, 0x2b0199fc, 0x2c85b8aa, 0x0eb72ddc, 0x81c52ca2,\n]);\n\n/** Internal SHA2-512/224 hash class. */\nexport class _SHA512_224 extends SHA2_64B<_SHA512_224> {\n  protected Ah: number = T224_IV[0] | 0;\n  protected Al: number = T224_IV[1] | 0;\n  protected Bh: number = T224_IV[2] | 0;\n  protected Bl: number = T224_IV[3] | 0;\n  protected Ch: number = T224_IV[4] | 0;\n  protected Cl: number = T224_IV[5] | 0;\n  protected Dh: number = T224_IV[6] | 0;\n  protected Dl: number = T224_IV[7] | 0;\n  protected Eh: number = T224_IV[8] | 0;\n  protected El: number = T224_IV[9] | 0;\n  protected Fh: number = T224_IV[10] | 0;\n  protected Fl: number = T224_IV[11] | 0;\n  protected Gh: number = T224_IV[12] | 0;\n  protected Gl: number = T224_IV[13] | 0;\n  protected Hh: number = T224_IV[14] | 0;\n  protected Hl: number = T224_IV[15] | 0;\n\n  constructor() {\n    super(28);\n  }\n}\n\n/** Internal SHA2-512/256 hash class. */\nexport class _SHA512_256 extends SHA2_64B<_SHA512_256> {\n  protected Ah: number = T256_IV[0] | 0;\n  protected Al: number = T256_IV[1] | 0;\n  protected Bh: number = T256_IV[2] | 0;\n  protected Bl: number = T256_IV[3] | 0;\n  protected Ch: number = T256_IV[4] | 0;\n  protected Cl: number = T256_IV[5] | 0;\n  protected Dh: number = T256_IV[6] | 0;\n  protected Dl: number = T256_IV[7] | 0;\n  protected Eh: number = T256_IV[8] | 0;\n  protected El: number = T256_IV[9] | 0;\n  protected Fh: number = T256_IV[10] | 0;\n  protected Fl: number = T256_IV[11] | 0;\n  protected Gh: number = T256_IV[12] | 0;\n  protected Gl: number = T256_IV[13] | 0;\n  protected Hh: number = T256_IV[14] | 0;\n  protected Hl: number = T256_IV[15] | 0;\n\n  constructor() {\n    super(32);\n  }\n}\n\n/**\n * SHA2-256 hash function from RFC 4634. In JS it's the fastest: even faster than Blake3. Some info:\n *\n * - Trying 2^128 hashes would get 50% chance of collision, using birthday attack.\n * - BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.\n * - Each sha256 hash is executing 2^18 bit operations.\n * - Good 2024 ASICs can do 200Th/sec with 3500 watts of power, corresponding to 2^36 hashes/joule.\n */\nexport const sha256: CHash<_SHA256> = /* @__PURE__ */ createHasher(\n  () => new _SHA256(),\n  /* @__PURE__ */ oidNist(0x01)\n);\n/** SHA2-224 hash function from RFC 4634 */\nexport const sha224: CHash<_SHA224> = /* @__PURE__ */ createHasher(\n  () => new _SHA224(),\n  /* @__PURE__ */ oidNist(0x04)\n);\n\n/** SHA2-512 hash function from RFC 4634. */\nexport const sha512: CHash<_SHA512> = /* @__PURE__ */ createHasher(\n  () => new _SHA512(),\n  /* @__PURE__ */ oidNist(0x03)\n);\n/** SHA2-384 hash function from RFC 4634. */\nexport const sha384: CHash<_SHA384> = /* @__PURE__ */ createHasher(\n  () => new _SHA384(),\n  /* @__PURE__ */ oidNist(0x02)\n);\n\n/**\n * SHA2-512/256 \"truncated\" hash function, with improved resistance to length extension attacks.\n * See the paper on [truncated SHA512](https://eprint.iacr.org/2010/548.pdf).\n */\nexport const sha512_256: CHash<_SHA512_256> = /* @__PURE__ */ createHasher(\n  () => new _SHA512_256(),\n  /* @__PURE__ */ oidNist(0x06)\n);\n/**\n * SHA2-512/224 \"truncated\" hash function, with improved resistance to length extension attacks.\n * See the paper on [truncated SHA512](https://eprint.iacr.org/2010/548.pdf).\n */\nexport const sha512_224: CHash<_SHA512_224> = /* @__PURE__ */ createHasher(\n  () => new _SHA512_224(),\n  /* @__PURE__ */ oidNist(0x05)\n);\n", "/**\n * Internal Merkle-Damgard hash utils.\n * @module\n */\nimport { abytes, aexists, aoutput, clean, createView, type Hash } from './utils.ts';\n\n/** Choice: a ? b : c */\nexport function Chi(a: number, b: number, c: number): number {\n  return (a & b) ^ (~a & c);\n}\n\n/** Majority function, true if any two inputs is true. */\nexport function Maj(a: number, b: number, c: number): number {\n  return (a & b) ^ (a & c) ^ (b & c);\n}\n\n/**\n * Merkle-Damgard hash construction base class.\n * Could be used to create MD5, RIPEMD, SHA1, SHA2.\n */\nexport abstract class HashMD<T extends HashMD<T>> implements Hash<T> {\n  protected abstract process(buf: DataView, offset: number): void;\n  protected abstract get(): number[];\n  protected abstract set(...args: number[]): void;\n  abstract destroy(): void;\n  protected abstract roundClean(): void;\n\n  readonly blockLen: number;\n  readonly outputLen: number;\n  readonly padOffset: number;\n  readonly isLE: boolean;\n\n  // For partial updates less than block size\n  protected buffer: Uint8Array;\n  protected view: DataView;\n  protected finished = false;\n  protected length = 0;\n  protected pos = 0;\n  protected destroyed = false;\n\n  constructor(blockLen: number, outputLen: number, padOffset: number, isLE: boolean) {\n    this.blockLen = blockLen;\n    this.outputLen = outputLen;\n    this.padOffset = padOffset;\n    this.isLE = isLE;\n    this.buffer = new Uint8Array(blockLen);\n    this.view = createView(this.buffer);\n  }\n  update(data: Uint8Array): this {\n    aexists(this);\n    abytes(data);\n    const { view, buffer, blockLen } = this;\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 = createView(data);\n        for (; blockLen <= len - pos; pos += blockLen) 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: Uint8Array): void {\n    aexists(this);\n    aoutput(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    clean(this.buffer.subarray(pos));\n    // we have less than padOffset left in buffer, so we cannot put length in\n    // 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++) 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    view.setBigUint64(blockLen - 8, BigInt(this.length * 8), isLE);\n    this.process(view, 0);\n    const oview = createView(out);\n    const len = this.outputLen;\n    // NOTE: we do division by 4 later, which must be fused in single op with modulo by JIT\n    if (len % 4) throw new Error('_sha2: outputLen must be aligned to 32bit');\n    const outLen = len / 4;\n    const state = this.get();\n    if (outLen > state.length) throw new Error('_sha2: outputLen bigger than state');\n    for (let i = 0; i < outLen; i++) oview.setUint32(4 * i, state[i], isLE);\n  }\n  digest(): Uint8Array {\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?: T): T {\n    to ||= new (this.constructor as any)() as T;\n    to.set(...this.get());\n    const { blockLen, buffer, length, finished, destroyed, pos } = this;\n    to.destroyed = destroyed;\n    to.finished = finished;\n    to.length = length;\n    to.pos = pos;\n    if (length % blockLen) to.buffer.set(buffer);\n    return to as unknown as any;\n  }\n  clone(): T {\n    return this._cloneInto();\n  }\n}\n\n/**\n * Initial SHA-2 state: fractional parts of square roots of first 16 primes 2..53.\n * Check out `test/misc/sha2-gen-iv.js` for recomputation guide.\n */\n\n/** Initial SHA256 state. Bits 0..32 of frac part of sqrt of primes 2..19 */\nexport const SHA256_IV: Uint32Array = /* @__PURE__ */ Uint32Array.from([\n  0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,\n]);\n\n/** Initial SHA224 state. Bits 32..64 of frac part of sqrt of primes 23..53 */\nexport const SHA224_IV: Uint32Array = /* @__PURE__ */ Uint32Array.from([\n  0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4,\n]);\n\n/** Initial SHA384 state. Bits 0..64 of frac part of sqrt of primes 23..53 */\nexport const SHA384_IV: Uint32Array = /* @__PURE__ */ Uint32Array.from([\n  0xcbbb9d5d, 0xc1059ed8, 0x629a292a, 0x367cd507, 0x9159015a, 0x3070dd17, 0x152fecd8, 0xf70e5939,\n  0x67332667, 0xffc00b31, 0x8eb44a87, 0x68581511, 0xdb0c2e0d, 0x64f98fa7, 0x47b5481d, 0xbefa4fa4,\n]);\n\n/** Initial SHA512 state. Bits 0..64 of frac part of sqrt of primes 2..19 */\nexport const SHA512_IV: Uint32Array = /* @__PURE__ */ Uint32Array.from([\n  0x6a09e667, 0xf3bcc908, 0xbb67ae85, 0x84caa73b, 0x3c6ef372, 0xfe94f82b, 0xa54ff53a, 0x5f1d36f1,\n  0x510e527f, 0xade682d1, 0x9b05688c, 0x2b3e6c1f, 0x1f83d9ab, 0xfb41bd6b, 0x5be0cd19, 0x137e2179,\n]);\n", "/**\n * Utilities for hex, bytes, CSPRNG.\n * @module\n */\n/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */\nexport function isBytes(a: unknown): a is Uint8Array {\n  return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');\n}\n\n/** Asserts something is positive integer. */\nexport function anumber(n: number, title: string = ''): void {\n  if (!Number.isSafeInteger(n) || n < 0) {\n    const prefix = title && `\"${title}\" `;\n    throw new Error(`${prefix}expected integer >= 0, got ${n}`);\n  }\n}\n\n/** Asserts something is Uint8Array. */\nexport function abytes(value: Uint8Array, length?: number, title: string = ''): Uint8Array {\n  const bytes = isBytes(value);\n  const len = value?.length;\n  const needsLen = length !== undefined;\n  if (!bytes || (needsLen && len !== length)) {\n    const prefix = title && `\"${title}\" `;\n    const ofLen = needsLen ? ` of length ${length}` : '';\n    const got = bytes ? `length=${len}` : `type=${typeof value}`;\n    throw new Error(prefix + 'expected Uint8Array' + ofLen + ', got ' + got);\n  }\n  return value;\n}\n\n/** Asserts something is hash */\nexport function ahash(h: CHash): void {\n  if (typeof h !== 'function' || typeof h.create !== 'function')\n    throw new Error('Hash must wrapped by utils.createHasher');\n  anumber(h.outputLen);\n  anumber(h.blockLen);\n}\n\n/** Asserts a hash instance has not been destroyed / finished */\nexport function aexists(instance: any, checkFinished = true): void {\n  if (instance.destroyed) throw new Error('Hash instance has been destroyed');\n  if (checkFinished && instance.finished) throw new Error('Hash#digest() has already been called');\n}\n\n/** Asserts output is properly-sized byte array */\nexport function aoutput(out: any, instance: any): void {\n  abytes(out, undefined, 'digestInto() output');\n  const min = instance.outputLen;\n  if (out.length < min) {\n    throw new Error('\"digestInto() output\" expected to be of length >=' + min);\n  }\n}\n\n/** Generic type encompassing 8/16/32-byte arrays - but not 64-byte. */\n// prettier-ignore\nexport type TypedArray = Int8Array | Uint8ClampedArray | Uint8Array |\n  Uint16Array | Int16Array | Uint32Array | Int32Array;\n\n/** Cast u8 / u16 / u32 to u8. */\nexport function u8(arr: TypedArray): Uint8Array {\n  return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\n}\n\n/** Cast u8 / u16 / u32 to u32. */\nexport function u32(arr: TypedArray): Uint32Array {\n  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));\n}\n\n/** Zeroize a byte array. Warning: JS provides no guarantees. */\nexport function clean(...arrays: TypedArray[]): void {\n  for (let i = 0; i < arrays.length; i++) {\n    arrays[i].fill(0);\n  }\n}\n\n/** Create DataView of an array for easy byte-level manipulation. */\nexport function createView(arr: TypedArray): DataView {\n  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\n}\n\n/** The rotate right (circular right shift) operation for uint32 */\nexport function rotr(word: number, shift: number): number {\n  return (word << (32 - shift)) | (word >>> shift);\n}\n\n/** The rotate left (circular left shift) operation for uint32 */\nexport function rotl(word: number, shift: number): number {\n  return (word << shift) | ((word >>> (32 - shift)) >>> 0);\n}\n\n/** Is current platform little-endian? Most are. Big-Endian platform: IBM */\nexport const isLE: boolean = /* @__PURE__ */ (() =>\n  new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();\n\n/** The byte swap operation for uint32 */\nexport function byteSwap(word: number): number {\n  return (\n    ((word << 24) & 0xff000000) |\n    ((word << 8) & 0xff0000) |\n    ((word >>> 8) & 0xff00) |\n    ((word >>> 24) & 0xff)\n  );\n}\n/** Conditionally byte swap if on a big-endian platform */\nexport const swap8IfBE: (n: number) => number = isLE\n  ? (n: number) => n\n  : (n: number) => byteSwap(n);\n\n/** In place byte swap for Uint32Array */\nexport function byteSwap32(arr: Uint32Array): Uint32Array {\n  for (let i = 0; i < arr.length; i++) {\n    arr[i] = byteSwap(arr[i]);\n  }\n  return arr;\n}\n\nexport const swap32IfBE: (u: Uint32Array) => Uint32Array = isLE\n  ? (u: Uint32Array) => u\n  : byteSwap32;\n\n// Built-in hex conversion https://caniuse.com/mdn-javascript_builtins_uint8array_fromhex\nconst hasHexBuiltin: boolean = /* @__PURE__ */ (() =>\n  // @ts-ignore\n  typeof Uint8Array.from([]).toHex === 'function' && typeof Uint8Array.fromHex === 'function')();\n\n// Array where index 0xf0 (240) is mapped to string 'f0'\nconst hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) =>\n  i.toString(16).padStart(2, '0')\n);\n\n/**\n * Convert byte array to hex string. Uses built-in function, when available.\n * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'\n */\nexport function bytesToHex(bytes: Uint8Array): string {\n  abytes(bytes);\n  // @ts-ignore\n  if (hasHexBuiltin) return bytes.toHex();\n  // pre-caching improves the speed 6x\n  let hex = '';\n  for (let i = 0; i < bytes.length; i++) {\n    hex += hexes[bytes[i]];\n  }\n  return hex;\n}\n\n// We use optimized technique to convert hex string to byte array\nconst asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 } as const;\nfunction asciiToBase16(ch: number): number | undefined {\n  if (ch >= asciis._0 && ch <= asciis._9) return ch - asciis._0; // '2' => 50-48\n  if (ch >= asciis.A && ch <= asciis.F) return ch - (asciis.A - 10); // 'B' => 66-(65-10)\n  if (ch >= asciis.a && ch <= asciis.f) return ch - (asciis.a - 10); // 'b' => 98-(97-10)\n  return;\n}\n\n/**\n * Convert hex string to byte array. Uses built-in function, when available.\n * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])\n */\nexport function hexToBytes(hex: string): Uint8Array {\n  if (typeof hex !== 'string') throw new Error('hex string expected, got ' + typeof hex);\n  // @ts-ignore\n  if (hasHexBuiltin) return Uint8Array.fromHex(hex);\n  const hl = hex.length;\n  const al = hl / 2;\n  if (hl % 2) throw new Error('hex string expected, got unpadded hex of length ' + hl);\n  const array = new Uint8Array(al);\n  for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {\n    const n1 = asciiToBase16(hex.charCodeAt(hi));\n    const n2 = asciiToBase16(hex.charCodeAt(hi + 1));\n    if (n1 === undefined || n2 === undefined) {\n      const char = hex[hi] + hex[hi + 1];\n      throw new Error('hex string expected, got non-hex character \"' + char + '\" at index ' + hi);\n    }\n    array[ai] = n1 * 16 + n2; // multiply first octet, e.g. 'a3' => 10*16+3 => 160 + 3 => 163\n  }\n  return array;\n}\n\n/**\n * There is no setImmediate in browser and setTimeout is slow.\n * Call of async fn will return Promise, which will be fullfiled only on\n * next scheduler queue processing step and this is exactly what we need.\n */\nexport const nextTick = async (): Promise<void> => {};\n\n/** Returns control to thread each 'tick' ms to avoid blocking. */\nexport async function asyncLoop(\n  iters: number,\n  tick: number,\n  cb: (i: number) => void\n): Promise<void> {\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) continue;\n    await nextTick();\n    ts += diff;\n  }\n}\n\n// Global symbols, but ts doesn't see them: https://github.com/microsoft/TypeScript/issues/31535\ndeclare const TextEncoder: any;\n\n/**\n * Converts string to bytes using UTF8 encoding.\n * Built-in doesn't validate input to be string: we do the check.\n * @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])\n */\nexport function utf8ToBytes(str: string): Uint8Array {\n  if (typeof str !== 'string') throw new Error('string expected');\n  return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n\n/** KDFs can accept string or Uint8Array for user convenience. */\nexport type KDFInput = string | Uint8Array;\n\n/**\n * Helper for KDFs: consumes uint8array or string.\n * When string is passed, does utf8 decoding, using TextDecoder.\n */\nexport function kdfInputToBytes(data: KDFInput, errorTitle = ''): Uint8Array {\n  if (typeof data === 'string') return utf8ToBytes(data);\n  return abytes(data, undefined, errorTitle);\n}\n\n/** Copies several Uint8Arrays into one. */\nexport function concatBytes(...arrays: Uint8Array[]): Uint8Array {\n  let sum = 0;\n  for (let i = 0; i < arrays.length; i++) {\n    const a = arrays[i];\n    abytes(a);\n    sum += a.length;\n  }\n  const res = new Uint8Array(sum);\n  for (let i = 0, pad = 0; i < arrays.length; i++) {\n    const a = arrays[i];\n    res.set(a, pad);\n    pad += a.length;\n  }\n  return res;\n}\n\ntype EmptyObj = {};\n/** Merges default options and passed options. */\nexport function checkOpts<T1 extends EmptyObj, T2 extends EmptyObj>(\n  defaults: T1,\n  opts?: T2\n): T1 & T2 {\n  if (opts !== undefined && {}.toString.call(opts) !== '[object Object]')\n    throw new Error('options must be object or undefined');\n  const merged = Object.assign(defaults, opts);\n  return merged as T1 & T2;\n}\n\n/** Common interface for all hashes. */\nexport interface Hash<T> {\n  blockLen: number; // Bytes per block\n  outputLen: number; // Bytes in output\n  update(buf: Uint8Array): this;\n  digestInto(buf: Uint8Array): void;\n  digest(): Uint8Array;\n  destroy(): void;\n  _cloneInto(to?: T): T;\n  clone(): T;\n}\n\n/** PseudoRandom (number) Generator */\nexport interface PRG {\n  addEntropy(seed: Uint8Array): void;\n  randomBytes(length: number): Uint8Array;\n  clean(): void;\n}\n\n/**\n * XOF: streaming API to read digest in chunks.\n * Same as 'squeeze' in keccak/k12 and 'seek' in blake3, but more generic name.\n * When hash used in XOF mode it is up to user to call '.destroy' afterwards, since we cannot\n * destroy state, next call can require more bytes.\n */\nexport type HashXOF<T extends Hash<T>> = Hash<T> & {\n  xof(bytes: number): Uint8Array; // Read 'bytes' bytes from digest stream\n  xofInto(buf: Uint8Array): Uint8Array; // read buf.length bytes from digest stream into buf\n};\n\n/** Hash constructor */\nexport type HasherCons<T, Opts = undefined> = Opts extends undefined ? () => T : (opts?: Opts) => T;\n/** Optional hash params. */\nexport type HashInfo = {\n  oid?: Uint8Array; // DER encoded OID in bytes\n};\n/** Hash function */\nexport type CHash<T extends Hash<T> = Hash<any>, Opts = undefined> = {\n  outputLen: number;\n  blockLen: number;\n} & HashInfo &\n  (Opts extends undefined\n    ? {\n        (msg: Uint8Array): Uint8Array;\n        create(): T;\n      }\n    : {\n        (msg: Uint8Array, opts?: Opts): Uint8Array;\n        create(opts?: Opts): T;\n      });\n/** XOF with output */\nexport type CHashXOF<T extends HashXOF<T> = HashXOF<any>, Opts = undefined> = CHash<T, Opts>;\n\n/** Creates function with outputLen, blockLen, create properties from a class constructor. */\nexport function createHasher<T extends Hash<T>, Opts = undefined>(\n  hashCons: HasherCons<T, Opts>,\n  info: HashInfo = {}\n): CHash<T, Opts> {\n  const hashC: any = (msg: Uint8Array, opts?: Opts) => hashCons(opts).update(msg).digest();\n  const tmp = hashCons(undefined);\n  hashC.outputLen = tmp.outputLen;\n  hashC.blockLen = tmp.blockLen;\n  hashC.create = (opts?: Opts) => hashCons(opts);\n  Object.assign(hashC, info);\n  return Object.freeze(hashC);\n}\n\n/** Cryptographically secure PRNG. Uses internal OS-level `crypto.getRandomValues`. */\nexport function randomBytes(bytesLength = 32): Uint8Array {\n  const cr = typeof globalThis === 'object' ? (globalThis as any).crypto : null;\n  if (typeof cr?.getRandomValues !== 'function')\n    throw new Error('crypto.getRandomValues must be defined');\n  return cr.getRandomValues(new Uint8Array(bytesLength));\n}\n\n/** Creates OID opts for NIST hashes, with prefix 06 09 60 86 48 01 65 03 04 02. */\nexport const oidNist = (suffix: number): Required<HashInfo> => ({\n  oid: Uint8Array.from([0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, suffix]),\n});\n", "/**\n * Methods for elliptic curve multiplication by scalars.\n * Contains wNAF, pippenger.\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { bitLen, bitMask, type Signer } from '../utils.ts';\nimport { Field, FpInvertBatch, validateField, type IField } from './modular.ts';\n\nconst _0n = /* @__PURE__ */ BigInt(0);\nconst _1n = /* @__PURE__ */ BigInt(1);\n\nexport type AffinePoint<T> = {\n  x: T;\n  y: T;\n} & { Z?: never };\n\n// We can't \"abstract out\" coordinates (X, Y, Z; and T in Edwards): argument names of constructor\n// are not accessible. See Typescript gh-56093, gh-41594.\n//\n// We have to use recursive types, so it will return actual point, not constained `CurvePoint`.\n// If, at any point, P is `any`, it will erase all types and replace it\n// with `any`, because of recursion, `any implements CurvePoint`,\n// but we lose all constrains on methods.\n\n/** Base interface for all elliptic curve Points. */\nexport interface CurvePoint<F, P extends CurvePoint<F, P>> {\n  /** Affine x coordinate. Different from projective / extended X coordinate. */\n  x: F;\n  /** Affine y coordinate. Different from projective / extended Y coordinate. */\n  y: F;\n  Z?: F;\n  double(): P;\n  negate(): P;\n  add(other: P): P;\n  subtract(other: P): P;\n  equals(other: P): boolean;\n  multiply(scalar: bigint): P;\n  assertValidity(): void;\n  clearCofactor(): P;\n  is0(): boolean;\n  isTorsionFree(): boolean;\n  isSmallOrder(): boolean;\n  multiplyUnsafe(scalar: bigint): P;\n  /**\n   * Massively speeds up `p.multiply(n)` by using precompute tables (caching). See {@link wNAF}.\n   * @param isLazy calculate cache now. Default (true) ensures it's deferred to first `multiply()`\n   */\n  precompute(windowSize?: number, isLazy?: boolean): P;\n  /** Converts point to 2D xy affine coordinates */\n  toAffine(invertedZ?: F): AffinePoint<F>;\n  toBytes(): Uint8Array;\n  toHex(): string;\n}\n\n/** Base interface for all elliptic curve Point constructors. */\nexport interface CurvePointCons<P extends CurvePoint<any, P>> {\n  [Symbol.hasInstance]: (item: unknown) => boolean;\n  BASE: P;\n  ZERO: P;\n  /** Field for basic curve math */\n  Fp: IField<P_F<P>>;\n  /** Scalar field, for scalars in multiply and others */\n  Fn: IField<bigint>;\n  /** Creates point from x, y. Does NOT validate if the point is valid. Use `.assertValidity()`. */\n  fromAffine(p: AffinePoint<P_F<P>>): P;\n  fromBytes(bytes: Uint8Array): P;\n  fromHex(hex: string): P;\n}\n\n// Type inference helpers: PC - PointConstructor, P - Point, Fp - Field element\n// Short names, because we use them a lot in result types:\n// * we can't do 'P = GetCurvePoint<PC>': this is default value and doesn't constrain anything\n// * we can't do 'type X = GetCurvePoint<PC>': it won't be accesible for arguments/return types\n// * `CurvePointCons<P extends CurvePoint<any, P>>` constraints from interface definition\n//   won't propagate, if `PC extends CurvePointCons<any>`: the P would be 'any', which is incorrect\n// * PC could be super specific with super specific P, which implements CurvePoint<any, P>.\n//   this means we need to do stuff like\n//   `function test<P extends CurvePoint<any, P>, PC extends CurvePointCons<P>>(`\n//   if we want type safety around P, otherwise PC_P<PC> will be any\n\n/** Returns Fp type from Point (P_F<P> == P.F) */\nexport type P_F<P extends CurvePoint<any, P>> = P extends CurvePoint<infer F, P> ? F : never;\n/** Returns Fp type from PointCons (PC_F<PC> == PC.P.F) */\nexport type PC_F<PC extends CurvePointCons<CurvePoint<any, any>>> = PC['Fp']['ZERO'];\n/** Returns Point type from PointCons (PC_P<PC> == PC.P) */\nexport type PC_P<PC extends CurvePointCons<CurvePoint<any, any>>> = PC['ZERO'];\n\n// Ugly hack to get proper type inference, because in typescript fails to infer resursively.\n// The hack allows to do up to 10 chained operations without applying type erasure.\n//\n// Types which won't work:\n// * `CurvePointCons<CurvePoint<any, any>>`, will return `any` after 1 operation\n// * `CurvePointCons<any>: WeierstrassPointCons<bigint> extends CurvePointCons<any> = false`\n// * `P extends CurvePoint, PC extends CurvePointCons<P>`\n//     * It can't infer P from PC alone\n//     * Too many relations between F, P & PC\n//     * It will infer P/F if `arg: CurvePointCons<F, P>`, but will fail if PC is generic\n//     * It will work correctly if there is an additional argument of type P\n//     * But generally, we don't want to parametrize `CurvePointCons` over `F`: it will complicate\n//       types, making them un-inferable\n// prettier-ignore\nexport type PC_ANY = CurvePointCons<\n  CurvePoint<any,\n  CurvePoint<any,\n  CurvePoint<any,\n  CurvePoint<any,\n  CurvePoint<any,\n  CurvePoint<any,\n  CurvePoint<any,\n  CurvePoint<any,\n  CurvePoint<any,\n  CurvePoint<any, any>\n  >>>>>>>>>\n>;\n\nexport interface CurveLengths {\n  secretKey?: number;\n  publicKey?: number;\n  publicKeyUncompressed?: number;\n  publicKeyHasPrefix?: boolean;\n  signature?: number;\n  seed?: number;\n}\n\nexport type Mapper<T> = (i: T[]) => T[];\n\nexport function negateCt<T extends { negate: () => T }>(condition: boolean, item: T): T {\n  const neg = item.negate();\n  return condition ? neg : item;\n}\n\n/**\n * Takes a bunch of Projective Points but executes only one\n * inversion on all of them. Inversion is very slow operation,\n * so this improves performance massively.\n * Optimization: converts a list of projective points to a list of identical points with Z=1.\n */\nexport function normalizeZ<P extends CurvePoint<any, P>, PC extends CurvePointCons<P>>(\n  c: PC,\n  points: P[]\n): P[] {\n  const invertedZs = FpInvertBatch(\n    c.Fp,\n    points.map((p) => p.Z!)\n  );\n  return points.map((p, i) => c.fromAffine(p.toAffine(invertedZs[i])));\n}\n\nfunction validateW(W: number, bits: number) {\n  if (!Number.isSafeInteger(W) || W <= 0 || W > bits)\n    throw new Error('invalid window size, expected [1..' + bits + '], got W=' + W);\n}\n\n/** Internal wNAF opts for specific W and scalarBits */\ntype WOpts = {\n  windows: number;\n  windowSize: number;\n  mask: bigint;\n  maxNumber: number;\n  shiftBy: bigint;\n};\n\nfunction calcWOpts(W: number, scalarBits: number): WOpts {\n  validateW(W, scalarBits);\n  const windows = Math.ceil(scalarBits / W) + 1; // W=8 33. Not 32, because we skip zero\n  const windowSize = 2 ** (W - 1); // W=8 128. Not 256, because we skip zero\n  const maxNumber = 2 ** W; // W=8 256\n  const mask = bitMask(W); // W=8 255 == mask 0b11111111\n  const shiftBy = BigInt(W); // W=8 8\n  return { windows, windowSize, mask, maxNumber, shiftBy };\n}\n\nfunction calcOffsets(n: bigint, window: number, wOpts: WOpts) {\n  const { windowSize, mask, maxNumber, shiftBy } = wOpts;\n  let wbits = Number(n & mask); // extract W bits.\n  let nextN = n >> shiftBy; // shift number by W bits.\n\n  // What actually happens here:\n  // const highestBit = Number(mask ^ (mask >> 1n));\n  // let wbits2 = wbits - 1; // skip zero\n  // if (wbits2 & highestBit) { wbits2 ^= Number(mask); // (~);\n\n  // split if bits > max: +224 => 256-32\n  if (wbits > windowSize) {\n    // we skip zero, which means instead of `>= size-1`, we do `> size`\n    wbits -= maxNumber; // -32, can be maxNumber - wbits, but then we need to set isNeg here.\n    nextN += _1n; // +256 (carry)\n  }\n  const offsetStart = window * windowSize;\n  const offset = offsetStart + Math.abs(wbits) - 1; // -1 because we skip zero\n  const isZero = wbits === 0; // is current window slice a 0?\n  const isNeg = wbits < 0; // is current window slice negative?\n  const isNegF = window % 2 !== 0; // fake random statement for noise\n  const offsetF = offsetStart; // fake offset for noise\n  return { nextN, offset, isZero, isNeg, isNegF, offsetF };\n}\n\nfunction validateMSMPoints(points: any[], c: any) {\n  if (!Array.isArray(points)) throw new Error('array expected');\n  points.forEach((p, i) => {\n    if (!(p instanceof c)) throw new Error('invalid point at index ' + i);\n  });\n}\nfunction validateMSMScalars(scalars: any[], field: any) {\n  if (!Array.isArray(scalars)) throw new Error('array of scalars expected');\n  scalars.forEach((s, i) => {\n    if (!field.isValid(s)) throw new Error('invalid scalar at index ' + i);\n  });\n}\n\n// Since points in different groups cannot be equal (different object constructor),\n// we can have single place to store precomputes.\n// Allows to make points frozen / immutable.\nconst pointPrecomputes = new WeakMap<any, any[]>();\nconst pointWindowSizes = new WeakMap<any, number>();\n\nfunction getW(P: any): number {\n  // To disable precomputes:\n  // return 1;\n  return pointWindowSizes.get(P) || 1;\n}\n\nfunction assert0(n: bigint): void {\n  if (n !== _0n) throw new Error('invalid wNAF');\n}\n\n/**\n * Elliptic curve multiplication of Point by scalar. Fragile.\n * Table generation takes **30MB of ram and 10ms on high-end CPU**,\n * but may take much longer on slow devices. Actual generation will happen on\n * first call of `multiply()`. By default, `BASE` point is precomputed.\n *\n * Scalars should always be less than curve order: this should be checked inside of a curve itself.\n * Creates precomputation tables for fast multiplication:\n * - private scalar is split by fixed size windows of W bits\n * - every window point is collected from window's table & added to accumulator\n * - since windows are different, same point inside tables won't be accessed more than once per calc\n * - each multiplication is 'Math.ceil(CURVE_ORDER / \uD835\uDC4A) + 1' point additions (fixed for any scalar)\n * - +1 window is neccessary for wNAF\n * - wNAF reduces table size: 2x less memory + 2x faster generation, but 10% slower multiplication\n *\n * @todo Research returning 2d JS array of windows, instead of a single window.\n * This would allow windows to be in different memory locations\n */\nexport class wNAF<PC extends PC_ANY> {\n  private readonly BASE: PC_P<PC>;\n  private readonly ZERO: PC_P<PC>;\n  private readonly Fn: PC['Fn'];\n  readonly bits: number;\n\n  // Parametrized with a given Point class (not individual point)\n  constructor(Point: PC, bits: number) {\n    this.BASE = Point.BASE;\n    this.ZERO = Point.ZERO;\n    this.Fn = Point.Fn;\n    this.bits = bits;\n  }\n\n  // non-const time multiplication ladder\n  _unsafeLadder(elm: PC_P<PC>, n: bigint, p: PC_P<PC> = this.ZERO): PC_P<PC> {\n    let d: PC_P<PC> = elm;\n    while (n > _0n) {\n      if (n & _1n) p = p.add(d);\n      d = d.double();\n      n >>= _1n;\n    }\n    return p;\n  }\n\n  /**\n   * Creates a wNAF precomputation window. Used for caching.\n   * Default window size is set by `utils.precompute()` and is equal to 8.\n   * Number of precomputed points depends on the curve size:\n   * 2^(\uD835\uDC4A\u22121) * (Math.ceil(\uD835\uDC5B / \uD835\uDC4A) + 1), where:\n   * - \uD835\uDC4A is the window size\n   * - \uD835\uDC5B is the bitlength of the curve order.\n   * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.\n   * @param point Point instance\n   * @param W window size\n   * @returns precomputed point tables flattened to a single array\n   */\n  private precomputeWindow(point: PC_P<PC>, W: number): PC_P<PC>[] {\n    const { windows, windowSize } = calcWOpts(W, this.bits);\n    const points: PC_P<PC>[] = [];\n    let p: PC_P<PC> = point;\n    let base = p;\n    for (let window = 0; window < windows; window++) {\n      base = p;\n      points.push(base);\n      // i=1, bc we skip 0\n      for (let i = 1; i < windowSize; i++) {\n        base = base.add(p);\n        points.push(base);\n      }\n      p = base.double();\n    }\n    return points;\n  }\n\n  /**\n   * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.\n   * More compact implementation:\n   * https://github.com/paulmillr/noble-secp256k1/blob/47cb1669b6e506ad66b35fe7d76132ae97465da2/index.ts#L502-L541\n   * @returns real and fake (for const-time) points\n   */\n  private wNAF(W: number, precomputes: PC_P<PC>[], n: bigint): { p: PC_P<PC>; f: PC_P<PC> } {\n    // Scalar should be smaller than field order\n    if (!this.Fn.isValid(n)) throw new Error('invalid scalar');\n    // Accumulators\n    let p = this.ZERO;\n    let f = this.BASE;\n    // This code was first written with assumption that 'f' and 'p' will never be infinity point:\n    // since each addition is multiplied by 2 ** W, it cannot cancel each other. However,\n    // there is negate now: it is possible that negated element from low value\n    // would be the same as high element, which will create carry into next window.\n    // It's not obvious how this can fail, but still worth investigating later.\n    const wo = calcWOpts(W, this.bits);\n    for (let window = 0; window < wo.windows; window++) {\n      // (n === _0n) is handled and not early-exited. isEven and offsetF are used for noise\n      const { nextN, offset, isZero, isNeg, isNegF, offsetF } = calcOffsets(n, window, wo);\n      n = nextN;\n      if (isZero) {\n        // bits are 0: add garbage to fake point\n        // Important part for const-time getPublicKey: add random \"noise\" point to f.\n        f = f.add(negateCt(isNegF, precomputes[offsetF]));\n      } else {\n        // bits are 1: add to result point\n        p = p.add(negateCt(isNeg, precomputes[offset]));\n      }\n    }\n    assert0(n);\n    // Return both real and fake points: JIT won't eliminate f.\n    // At this point there is a way to F be infinity-point even if p is not,\n    // which makes it less const-time: around 1 bigint multiply.\n    return { p, f };\n  }\n\n  /**\n   * Implements ec unsafe (non const-time) multiplication using precomputed tables and w-ary non-adjacent form.\n   * @param acc accumulator point to add result of multiplication\n   * @returns point\n   */\n  private wNAFUnsafe(\n    W: number,\n    precomputes: PC_P<PC>[],\n    n: bigint,\n    acc: PC_P<PC> = this.ZERO\n  ): PC_P<PC> {\n    const wo = calcWOpts(W, this.bits);\n    for (let window = 0; window < wo.windows; window++) {\n      if (n === _0n) break; // Early-exit, skip 0 value\n      const { nextN, offset, isZero, isNeg } = calcOffsets(n, window, wo);\n      n = nextN;\n      if (isZero) {\n        // Window bits are 0: skip processing.\n        // Move to next window.\n        continue;\n      } else {\n        const item = precomputes[offset];\n        acc = acc.add(isNeg ? item.negate() : item); // Re-using acc allows to save adds in MSM\n      }\n    }\n    assert0(n);\n    return acc;\n  }\n\n  private getPrecomputes(W: number, point: PC_P<PC>, transform?: Mapper<PC_P<PC>>): PC_P<PC>[] {\n    // Calculate precomputes on a first run, reuse them after\n    let comp = pointPrecomputes.get(point);\n    if (!comp) {\n      comp = this.precomputeWindow(point, W) as PC_P<PC>[];\n      if (W !== 1) {\n        // Doing transform outside of if brings 15% perf hit\n        if (typeof transform === 'function') comp = transform(comp);\n        pointPrecomputes.set(point, comp);\n      }\n    }\n    return comp;\n  }\n\n  cached(\n    point: PC_P<PC>,\n    scalar: bigint,\n    transform?: Mapper<PC_P<PC>>\n  ): { p: PC_P<PC>; f: PC_P<PC> } {\n    const W = getW(point);\n    return this.wNAF(W, this.getPrecomputes(W, point, transform), scalar);\n  }\n\n  unsafe(point: PC_P<PC>, scalar: bigint, transform?: Mapper<PC_P<PC>>, prev?: PC_P<PC>): PC_P<PC> {\n    const W = getW(point);\n    if (W === 1) return this._unsafeLadder(point, scalar, prev); // For W=1 ladder is ~x2 faster\n    return this.wNAFUnsafe(W, this.getPrecomputes(W, point, transform), scalar, prev);\n  }\n\n  // We calculate precomputes for elliptic curve point multiplication\n  // using windowed method. This specifies window size and\n  // stores precomputed values. Usually only base point would be precomputed.\n  createCache(P: PC_P<PC>, W: number): void {\n    validateW(W, this.bits);\n    pointWindowSizes.set(P, W);\n    pointPrecomputes.delete(P);\n  }\n\n  hasCache(elm: PC_P<PC>): boolean {\n    return getW(elm) !== 1;\n  }\n}\n\n/**\n * Endomorphism-specific multiplication for Koblitz curves.\n * Cost: 128 dbl, 0-256 adds.\n */\nexport function mulEndoUnsafe<P extends CurvePoint<any, P>, PC extends CurvePointCons<P>>(\n  Point: PC,\n  point: P,\n  k1: bigint,\n  k2: bigint\n): { p1: P; p2: P } {\n  let acc = point;\n  let p1 = Point.ZERO;\n  let p2 = Point.ZERO;\n  while (k1 > _0n || k2 > _0n) {\n    if (k1 & _1n) p1 = p1.add(acc);\n    if (k2 & _1n) p2 = p2.add(acc);\n    acc = acc.double();\n    k1 >>= _1n;\n    k2 >>= _1n;\n  }\n  return { p1, p2 };\n}\n\n/**\n * Pippenger algorithm for multi-scalar multiplication (MSM, Pa + Qb + Rc + ...).\n * 30x faster vs naive addition on L=4096, 10x faster than precomputes.\n * For N=254bit, L=1, it does: 1024 ADD + 254 DBL. For L=5: 1536 ADD + 254 DBL.\n * Algorithmically constant-time (for same L), even when 1 point + scalar, or when scalar = 0.\n * @param c Curve Point constructor\n * @param fieldN field over CURVE.N - important that it's not over CURVE.P\n * @param points array of L curve points\n * @param scalars array of L scalars (aka secret keys / bigints)\n */\nexport function pippenger<P extends CurvePoint<any, P>, PC extends CurvePointCons<P>>(\n  c: PC,\n  points: P[],\n  scalars: bigint[]\n): P {\n  // If we split scalars by some window (let's say 8 bits), every chunk will only\n  // take 256 buckets even if there are 4096 scalars, also re-uses double.\n  // TODO:\n  // - https://eprint.iacr.org/2024/750.pdf\n  // - https://tches.iacr.org/index.php/TCHES/article/view/10287\n  // 0 is accepted in scalars\n  const fieldN = c.Fn;\n  validateMSMPoints(points, c);\n  validateMSMScalars(scalars, fieldN);\n  const plength = points.length;\n  const slength = scalars.length;\n  if (plength !== slength) throw new Error('arrays of points and scalars must have equal length');\n  // if (plength === 0) throw new Error('array must be of length >= 2');\n  const zero = c.ZERO;\n  const wbits = bitLen(BigInt(plength));\n  let windowSize = 1; // bits\n  if (wbits > 12) windowSize = wbits - 3;\n  else if (wbits > 4) windowSize = wbits - 2;\n  else if (wbits > 0) windowSize = 2;\n  const MASK = bitMask(windowSize);\n  const buckets = new Array(Number(MASK) + 1).fill(zero); // +1 for zero array\n  const lastBits = Math.floor((fieldN.BITS - 1) / windowSize) * windowSize;\n  let sum = zero;\n  for (let i = lastBits; i >= 0; i -= windowSize) {\n    buckets.fill(zero);\n    for (let j = 0; j < slength; j++) {\n      const scalar = scalars[j];\n      const wbits = Number((scalar >> BigInt(i)) & MASK);\n      buckets[wbits] = buckets[wbits].add(points[j]);\n    }\n    let resI = zero; // not using this will do small speed-up, but will lose ct\n    // Skip first bucket, because it is zero\n    for (let j = buckets.length - 1, sumI = zero; j > 0; j--) {\n      sumI = sumI.add(buckets[j]);\n      resI = resI.add(sumI);\n    }\n    sum = sum.add(resI);\n    if (i !== 0) for (let j = 0; j < windowSize; j++) sum = sum.double();\n  }\n  return sum as P;\n}\n/**\n * Precomputed multi-scalar multiplication (MSM, Pa + Qb + Rc + ...).\n * @param c Curve Point constructor\n * @param fieldN field over CURVE.N - important that it's not over CURVE.P\n * @param points array of L curve points\n * @returns function which multiplies points with scaars\n */\nexport function precomputeMSMUnsafe<P extends CurvePoint<any, P>, PC extends CurvePointCons<P>>(\n  c: PC,\n  points: P[],\n  windowSize: number\n): (scalars: bigint[]) => P {\n  /**\n   * Performance Analysis of Window-based Precomputation\n   *\n   * Base Case (256-bit scalar, 8-bit window):\n   * - Standard precomputation requires:\n   *   - 31 additions per scalar \u00D7 256 scalars = 7,936 ops\n   *   - Plus 255 summary additions = 8,191 total ops\n   *   Note: Summary additions can be optimized via accumulator\n   *\n   * Chunked Precomputation Analysis:\n   * - Using 32 chunks requires:\n   *   - 255 additions per chunk\n   *   - 256 doublings\n   *   - Total: (255 \u00D7 32) + 256 = 8,416 ops\n   *\n   * Memory Usage Comparison:\n   * Window Size | Standard Points | Chunked Points\n   * ------------|-----------------|---------------\n   *     4-bit   |     520         |      15\n   *     8-bit   |    4,224        |     255\n   *    10-bit   |   13,824        |   1,023\n   *    16-bit   |  557,056        |  65,535\n   *\n   * Key Advantages:\n   * 1. Enables larger window sizes due to reduced memory overhead\n   * 2. More efficient for smaller scalar counts:\n   *    - 16 chunks: (16 \u00D7 255) + 256 = 4,336 ops\n   *    - ~2x faster than standard 8,191 ops\n   *\n   * Limitations:\n   * - Not suitable for plain precomputes (requires 256 constant doublings)\n   * - Performance degrades with larger scalar counts:\n   *   - Optimal for ~256 scalars\n   *   - Less efficient for 4096+ scalars (Pippenger preferred)\n   */\n  const fieldN = c.Fn;\n  validateW(windowSize, fieldN.BITS);\n  validateMSMPoints(points, c);\n  const zero = c.ZERO;\n  const tableSize = 2 ** windowSize - 1; // table size (without zero)\n  const chunks = Math.ceil(fieldN.BITS / windowSize); // chunks of item\n  const MASK = bitMask(windowSize);\n  const tables = points.map((p: P) => {\n    const res = [];\n    for (let i = 0, acc = p; i < tableSize; i++) {\n      res.push(acc);\n      acc = acc.add(p);\n    }\n    return res;\n  });\n  return (scalars: bigint[]): P => {\n    validateMSMScalars(scalars, fieldN);\n    if (scalars.length > points.length)\n      throw new Error('array of scalars must be smaller than array of points');\n    let res = zero;\n    for (let i = 0; i < chunks; i++) {\n      // No need to double if accumulator is still zero.\n      if (res !== zero) for (let j = 0; j < windowSize; j++) res = res.double();\n      const shiftBy = BigInt(chunks * windowSize - (i + 1) * windowSize);\n      for (let j = 0; j < scalars.length; j++) {\n        const n = scalars[j];\n        const curr = Number((n >> shiftBy) & MASK);\n        if (!curr) continue; // skip zero scalars chunks\n        res = res.add(tables[j][curr - 1]);\n      }\n    }\n    return res;\n  };\n}\n\nexport type ValidCurveParams<T> = {\n  p: bigint;\n  n: bigint;\n  h: bigint;\n  a: T;\n  b?: T;\n  d?: T;\n  Gx: T;\n  Gy: T;\n};\n\nfunction createField<T>(order: bigint, field?: IField<T>, isLE?: boolean): IField<T> {\n  if (field) {\n    if (field.ORDER !== order) throw new Error('Field.ORDER must match order: Fp == p, Fn == n');\n    validateField(field);\n    return field;\n  } else {\n    return Field(order, { isLE }) as unknown as IField<T>;\n  }\n}\nexport type FpFn<T> = { Fp: IField<T>; Fn: IField<bigint> };\n\n/** Validates CURVE opts and creates fields */\nexport function createCurveFields<T>(\n  type: 'weierstrass' | 'edwards',\n  CURVE: ValidCurveParams<T>,\n  curveOpts: Partial<FpFn<T>> = {},\n  FpFnLE?: boolean\n): FpFn<T> & { CURVE: ValidCurveParams<T> } {\n  if (FpFnLE === undefined) FpFnLE = type === 'edwards';\n  if (!CURVE || typeof CURVE !== 'object') throw new Error(`expected valid ${type} CURVE object`);\n  for (const p of ['p', 'n', 'h'] as const) {\n    const val = CURVE[p];\n    if (!(typeof val === 'bigint' && val > _0n))\n      throw new Error(`CURVE.${p} must be positive bigint`);\n  }\n  const Fp = createField(CURVE.p, curveOpts.Fp, FpFnLE);\n  const Fn = createField(CURVE.n, curveOpts.Fn, FpFnLE);\n  const _b: 'b' | 'd' = type === 'weierstrass' ? 'b' : 'd';\n  const params = ['Gx', 'Gy', 'a', _b] as const;\n  for (const p of params) {\n    // @ts-ignore\n    if (!Fp.isValid(CURVE[p]))\n      throw new Error(`CURVE.${p} must be valid field element of CURVE.Fp`);\n  }\n  CURVE = Object.freeze(Object.assign({}, CURVE));\n  return { CURVE, Fp, Fn };\n}\n\ntype KeygenFn = (\n  seed?: Uint8Array,\n  isCompressed?: boolean\n) => { secretKey: Uint8Array; publicKey: Uint8Array };\nexport function createKeygen(\n  randomSecretKey: Function,\n  getPublicKey: Signer['getPublicKey']\n): KeygenFn {\n  return function keygen(seed?: Uint8Array) {\n    const secretKey = randomSecretKey(seed);\n    return { secretKey, publicKey: getPublicKey(secretKey) };\n  };\n}\n", "/**\n * Hex, bytes and number utilities.\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport {\n  abytes as abytes_,\n  anumber,\n  bytesToHex as bytesToHex_,\n  concatBytes as concatBytes_,\n  hexToBytes as hexToBytes_,\n} from '@noble/hashes/utils.js';\nexport {\n  abytes,\n  anumber,\n  bytesToHex,\n  concatBytes,\n  hexToBytes,\n  isBytes,\n  randomBytes,\n} from '@noble/hashes/utils.js';\nconst _0n = /* @__PURE__ */ BigInt(0);\nconst _1n = /* @__PURE__ */ BigInt(1);\n\nexport type CHash = {\n  (message: Uint8Array): Uint8Array;\n  blockLen: number;\n  outputLen: number;\n  create(opts?: { dkLen?: number }): any; // For shake\n};\nexport type FHash = (message: Uint8Array) => Uint8Array;\nexport function abool(value: boolean, title: string = ''): boolean {\n  if (typeof value !== 'boolean') {\n    const prefix = title && `\"${title}\" `;\n    throw new Error(prefix + 'expected boolean, got type=' + typeof value);\n  }\n  return value;\n}\n\n// Used in weierstrass, der\nfunction abignumber(n: number | bigint) {\n  if (typeof n === 'bigint') {\n    if (!isPosBig(n)) throw new Error('positive bigint expected, got ' + n);\n  } else anumber(n);\n  return n;\n}\n\nexport function asafenumber(value: number, title: string = ''): void {\n  if (!Number.isSafeInteger(value)) {\n    const prefix = title && `\"${title}\" `;\n    throw new Error(prefix + 'expected safe integer, got type=' + typeof value);\n  }\n}\n\nexport function numberToHexUnpadded(num: number | bigint): string {\n  const hex = abignumber(num).toString(16);\n  return hex.length & 1 ? '0' + hex : hex;\n}\n\nexport function hexToNumber(hex: string): bigint {\n  if (typeof hex !== 'string') throw new Error('hex string expected, got ' + typeof hex);\n  return hex === '' ? _0n : BigInt('0x' + hex); // Big Endian\n}\n\n// BE: Big Endian, LE: Little Endian\nexport function bytesToNumberBE(bytes: Uint8Array): bigint {\n  return hexToNumber(bytesToHex_(bytes));\n}\nexport function bytesToNumberLE(bytes: Uint8Array): bigint {\n  return hexToNumber(bytesToHex_(copyBytes(abytes_(bytes)).reverse()));\n}\n\nexport function numberToBytesBE(n: number | bigint, len: number): Uint8Array {\n  anumber(len);\n  n = abignumber(n);\n  const res = hexToBytes_(n.toString(16).padStart(len * 2, '0'));\n  if (res.length !== len) throw new Error('number too large');\n  return res;\n}\nexport function numberToBytesLE(n: number | bigint, len: number): Uint8Array {\n  return numberToBytesBE(n, len).reverse();\n}\n// Unpadded, rarely used\nexport function numberToVarBytesBE(n: number | bigint): Uint8Array {\n  return hexToBytes_(numberToHexUnpadded(abignumber(n)));\n}\n\n// Compares 2 u8a-s in kinda constant time\nexport function equalBytes(a: Uint8Array, b: Uint8Array): boolean {\n  if (a.length !== b.length) return false;\n  let diff = 0;\n  for (let i = 0; i < a.length; i++) diff |= a[i] ^ b[i];\n  return diff === 0;\n}\n\n/**\n * Copies Uint8Array. We can't use u8a.slice(), because u8a can be Buffer,\n * and Buffer#slice creates mutable copy. Never use Buffers!\n */\nexport function copyBytes(bytes: Uint8Array): Uint8Array {\n  return Uint8Array.from(bytes);\n}\n\n/**\n * Decodes 7-bit ASCII string to Uint8Array, throws on non-ascii symbols\n * Should be safe to use for things expected to be ASCII.\n * Returns exact same result as `TextEncoder` for ASCII or throws.\n */\nexport function asciiToBytes(ascii: string): Uint8Array {\n  return Uint8Array.from(ascii, (c, i) => {\n    const charCode = c.charCodeAt(0);\n    if (c.length !== 1 || charCode > 127) {\n      throw new Error(\n        `string contains non-ASCII character \"${ascii[i]}\" with code ${charCode} at position ${i}`\n      );\n    }\n    return charCode;\n  });\n}\n\n// Is positive bigint\nconst isPosBig = (n: bigint) => typeof n === 'bigint' && _0n <= n;\n\nexport function inRange(n: bigint, min: bigint, max: bigint): boolean {\n  return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;\n}\n\n/**\n * Asserts min <= n < max. NOTE: It's < max and not <= max.\n * @example\n * aInRange('x', x, 1n, 256n); // would assume x is in (1n..255n)\n */\nexport function aInRange(title: string, n: bigint, min: bigint, max: bigint): void {\n  // Why min <= n < max and not a (min < n < max) OR b (min <= n <= max)?\n  // consider P=256n, min=0n, max=P\n  // - a for min=0 would require -1:          `inRange('x', x, -1n, P)`\n  // - b would commonly require subtraction:  `inRange('x', x, 0n, P - 1n)`\n  // - our way is the cleanest:               `inRange('x', x, 0n, P)\n  if (!inRange(n, min, max))\n    throw new Error('expected valid ' + title + ': ' + min + ' <= n < ' + max + ', got ' + n);\n}\n\n// Bit operations\n\n/**\n * Calculates amount of bits in a bigint.\n * Same as `n.toString(2).length`\n * TODO: merge with nLength in modular\n */\nexport function bitLen(n: bigint): number {\n  let len;\n  for (len = 0; n > _0n; n >>= _1n, len += 1);\n  return len;\n}\n\n/**\n * Gets single bit at position.\n * NOTE: first bit position is 0 (same as arrays)\n * Same as `!!+Array.from(n.toString(2)).reverse()[pos]`\n */\nexport function bitGet(n: bigint, pos: number): bigint {\n  return (n >> BigInt(pos)) & _1n;\n}\n\n/**\n * Sets single bit at position.\n */\nexport function bitSet(n: bigint, pos: number, value: boolean): bigint {\n  return n | ((value ? _1n : _0n) << BigInt(pos));\n}\n\n/**\n * Calculate mask for N bits. Not using ** operator with bigints because of old engines.\n * Same as BigInt(`0b${Array(i).fill('1').join('')}`)\n */\nexport const bitMask = (n: number): bigint => (_1n << BigInt(n)) - _1n;\n\n// DRBG\n\ntype Pred<T> = (v: Uint8Array) => T | undefined;\n/**\n * Minimal HMAC-DRBG from NIST 800-90 for RFC6979 sigs.\n * @returns function that will call DRBG until 2nd arg returns something meaningful\n * @example\n *   const drbg = createHmacDRBG<Key>(32, 32, hmac);\n *   drbg(seed, bytesToKey); // bytesToKey must return Key or undefined\n */\nexport function createHmacDrbg<T>(\n  hashLen: number,\n  qByteLen: number,\n  hmacFn: (key: Uint8Array, message: Uint8Array) => Uint8Array\n): (seed: Uint8Array, predicate: Pred<T>) => T {\n  anumber(hashLen, 'hashLen');\n  anumber(qByteLen, 'qByteLen');\n  if (typeof hmacFn !== 'function') throw new Error('hmacFn must be a function');\n  const u8n = (len: number): Uint8Array => new Uint8Array(len); // creates Uint8Array\n  const NULL = Uint8Array.of();\n  const byte0 = Uint8Array.of(0x00);\n  const byte1 = Uint8Array.of(0x01);\n  const _maxDrbgIters = 1000;\n\n  // Step B, Step C: set hashLen to 8*ceil(hlen/8)\n  let v = u8n(hashLen); // Minimal non-full-spec HMAC-DRBG from NIST 800-90 for RFC6979 sigs.\n  let k = u8n(hashLen); // Steps B and C of RFC6979 3.2: set hashLen, in our case always same\n  let i = 0; // Iterations counter, will throw when over 1000\n  const reset = () => {\n    v.fill(1);\n    k.fill(0);\n    i = 0;\n  };\n  const h = (...msgs: Uint8Array[]) => hmacFn(k, concatBytes_(v, ...msgs)); // hmac(k)(v, ...values)\n  const reseed = (seed: Uint8Array = NULL) => {\n    // HMAC-DRBG reseed() function. Steps D-G\n    k = h(byte0, seed); // k = hmac(k || v || 0x00 || seed)\n    v = h(); // v = hmac(k || v)\n    if (seed.length === 0) return;\n    k = h(byte1, seed); // k = hmac(k || v || 0x01 || seed)\n    v = h(); // v = hmac(k || v)\n  };\n  const gen = () => {\n    // HMAC-DRBG generate() function\n    if (i++ >= _maxDrbgIters) throw new Error('drbg: tried max amount of iterations');\n    let len = 0;\n    const out: Uint8Array[] = [];\n    while (len < qByteLen) {\n      v = h();\n      const sl = v.slice();\n      out.push(sl);\n      len += v.length;\n    }\n    return concatBytes_(...out);\n  };\n  const genUntil = (seed: Uint8Array, pred: Pred<T>): T => {\n    reset();\n    reseed(seed); // Steps D-G\n    let res: T | undefined = undefined; // Step H: grind until k is in [1..n-1]\n    while (!(res = pred(gen()))) reseed();\n    reset();\n    return res;\n  };\n  return genUntil;\n}\n\nexport function validateObject(\n  object: Record<string, any>,\n  fields: Record<string, string> = {},\n  optFields: Record<string, string> = {}\n): void {\n  if (!object || typeof object !== 'object') throw new Error('expected valid options object');\n  type Item = keyof typeof object;\n  function checkField(fieldName: Item, expectedType: string, isOpt: boolean) {\n    const val = object[fieldName];\n    if (isOpt && val === undefined) return;\n    const current = typeof val;\n    if (current !== expectedType || val === null)\n      throw new Error(`param \"${fieldName}\" is invalid: expected ${expectedType}, got ${current}`);\n  }\n  const iter = (f: typeof fields, isOpt: boolean) =>\n    Object.entries(f).forEach(([k, v]) => checkField(k, v, isOpt));\n  iter(fields, false);\n  iter(optFields, true);\n}\n\n/**\n * throws not implemented error\n */\nexport const notImplemented = (): never => {\n  throw new Error('not implemented');\n};\n\n/**\n * Memoizes (caches) computation result.\n * Uses WeakMap: the value is going auto-cleaned by GC after last reference is removed.\n */\nexport function memoized<T extends object, R, O extends any[]>(\n  fn: (arg: T, ...args: O) => R\n): (arg: T, ...args: O) => R {\n  const map = new WeakMap<T, R>();\n  return (arg: T, ...args: O): R => {\n    const val = map.get(arg);\n    if (val !== undefined) return val;\n    const computed = fn(arg, ...args);\n    map.set(arg, computed);\n    return computed;\n  };\n}\n\nexport interface CryptoKeys {\n  lengths: { seed?: number; public?: number; secret?: number };\n  keygen: (seed?: Uint8Array) => { secretKey: Uint8Array; publicKey: Uint8Array };\n  getPublicKey: (secretKey: Uint8Array) => Uint8Array;\n}\n\n/** Generic interface for signatures. Has keygen, sign and verify. */\nexport interface Signer extends CryptoKeys {\n  // Interfaces are fun. We cannot just add new fields without copying old ones.\n  lengths: {\n    seed?: number;\n    public?: number;\n    secret?: number;\n    signRand?: number;\n    signature?: number;\n  };\n  sign: (msg: Uint8Array, secretKey: Uint8Array) => Uint8Array;\n  verify: (sig: Uint8Array, msg: Uint8Array, publicKey: Uint8Array) => boolean;\n}\n", "/**\n * Utils for modular division and fields.\n * Field over 11 is a finite (Galois) field is integer number operations `mod 11`.\n * There is no division: it is replaced by modular multiplicative inverse.\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport {\n  abytes,\n  anumber,\n  bytesToNumberBE,\n  bytesToNumberLE,\n  numberToBytesBE,\n  numberToBytesLE,\n  validateObject,\n} from '../utils.ts';\n\n// Numbers aren't used in x25519 / x448 builds\n// prettier-ignore\nconst _0n = /* @__PURE__ */ BigInt(0), _1n = /* @__PURE__ */ BigInt(1), _2n = /* @__PURE__ */ BigInt(2);\n// prettier-ignore\nconst _3n = /* @__PURE__ */ BigInt(3), _4n = /* @__PURE__ */ BigInt(4), _5n = /* @__PURE__ */ BigInt(5);\n// prettier-ignore\nconst _7n = /* @__PURE__ */ BigInt(7), _8n = /* @__PURE__ */ BigInt(8), _9n = /* @__PURE__ */ BigInt(9);\nconst _16n = /* @__PURE__ */ BigInt(16);\n\n// Calculates a modulo b\nexport function mod(a: bigint, b: bigint): bigint {\n  const result = a % b;\n  return result >= _0n ? result : b + result;\n}\n/**\n * Efficiently raise num to power and do modular division.\n * Unsafe in some contexts: uses ladder, so can expose bigint bits.\n * @example\n * pow(2n, 6n, 11n) // 64n % 11n == 9n\n */\nexport function pow(num: bigint, power: bigint, modulo: bigint): bigint {\n  return FpPow(Field(modulo), num, power);\n}\n\n/** Does `x^(2^power)` mod p. `pow2(30, 4)` == `30^(2^4)` */\nexport function pow2(x: bigint, power: bigint, modulo: bigint): bigint {\n  let res = x;\n  while (power-- > _0n) {\n    res *= res;\n    res %= modulo;\n  }\n  return res;\n}\n\n/**\n * Inverses number over modulo.\n * Implemented using [Euclidean GCD](https://brilliant.org/wiki/extended-euclidean-algorithm/).\n */\nexport function invert(number: bigint, modulo: bigint): bigint {\n  if (number === _0n) throw new Error('invert: expected non-zero number');\n  if (modulo <= _0n) throw new Error('invert: expected positive modulus, got ' + modulo);\n  // Fermat's little theorem \"CT-like\" version inv(n) = n^(m-2) mod m is 30x slower.\n  let a = mod(number, modulo);\n  let b = modulo;\n  // prettier-ignore\n  let x = _0n, y = _1n, u = _1n, v = _0n;\n  while (a !== _0n) {\n    // JIT applies optimization if those two lines follow each other\n    const q = b / a;\n    const r = b % a;\n    const m = x - u * q;\n    const n = y - v * q;\n    // prettier-ignore\n    b = a, a = r, x = u, y = v, u = m, v = n;\n  }\n  const gcd = b;\n  if (gcd !== _1n) throw new Error('invert: does not exist');\n  return mod(x, modulo);\n}\n\nfunction assertIsSquare<T>(Fp: IField<T>, root: T, n: T): void {\n  if (!Fp.eql(Fp.sqr(root), n)) throw new Error('Cannot find square root');\n}\n\n// Not all roots are possible! Example which will throw:\n// const NUM =\n// n = 72057594037927816n;\n// Fp = Field(BigInt('0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab'));\nfunction sqrt3mod4<T>(Fp: IField<T>, n: T) {\n  const p1div4 = (Fp.ORDER + _1n) / _4n;\n  const root = Fp.pow(n, p1div4);\n  assertIsSquare(Fp, root, n);\n  return root;\n}\n\nfunction sqrt5mod8<T>(Fp: IField<T>, n: T) {\n  const p5div8 = (Fp.ORDER - _5n) / _8n;\n  const n2 = Fp.mul(n, _2n);\n  const v = Fp.pow(n2, p5div8);\n  const nv = Fp.mul(n, v);\n  const i = Fp.mul(Fp.mul(nv, _2n), v);\n  const root = Fp.mul(nv, Fp.sub(i, Fp.ONE));\n  assertIsSquare(Fp, root, n);\n  return root;\n}\n\n// Based on RFC9380, Kong algorithm\n// prettier-ignore\nfunction sqrt9mod16(P: bigint): <T>(Fp: IField<T>, n: T) => T {\n  const Fp_ = Field(P);\n  const tn = tonelliShanks(P);\n  const c1 = tn(Fp_, Fp_.neg(Fp_.ONE));//  1. c1 = sqrt(-1) in F, i.e., (c1^2) == -1 in F\n  const c2 = tn(Fp_, c1);              //  2. c2 = sqrt(c1) in F, i.e., (c2^2) == c1 in F\n  const c3 = tn(Fp_, Fp_.neg(c1));     //  3. c3 = sqrt(-c1) in F, i.e., (c3^2) == -c1 in F\n  const c4 = (P + _7n) / _16n;         //  4. c4 = (q + 7) / 16        # Integer arithmetic\n  return <T>(Fp: IField<T>, n: T) => {\n    let tv1 = Fp.pow(n, c4);           //  1. tv1 = x^c4\n    let tv2 = Fp.mul(tv1, c1);         //  2. tv2 = c1 * tv1\n    const tv3 = Fp.mul(tv1, c2);       //  3. tv3 = c2 * tv1\n    const tv4 = Fp.mul(tv1, c3);       //  4. tv4 = c3 * tv1\n    const e1 = Fp.eql(Fp.sqr(tv2), n); //  5.  e1 = (tv2^2) == x\n    const e2 = Fp.eql(Fp.sqr(tv3), n); //  6.  e2 = (tv3^2) == x\n    tv1 = Fp.cmov(tv1, tv2, e1);       //  7. tv1 = CMOV(tv1, tv2, e1)  # Select tv2 if (tv2^2) == x\n    tv2 = Fp.cmov(tv4, tv3, e2);       //  8. tv2 = CMOV(tv4, tv3, e2)  # Select tv3 if (tv3^2) == x\n    const e3 = Fp.eql(Fp.sqr(tv2), n); //  9.  e3 = (tv2^2) == x\n    const root = Fp.cmov(tv1, tv2, e3);// 10.  z = CMOV(tv1, tv2, e3)   # Select sqrt from tv1 & tv2\n    assertIsSquare(Fp, root, n);\n    return root;\n  };\n}\n\n/**\n * Tonelli-Shanks square root search algorithm.\n * 1. https://eprint.iacr.org/2012/685.pdf (page 12)\n * 2. Square Roots from 1; 24, 51, 10 to Dan Shanks\n * @param P field order\n * @returns function that takes field Fp (created from P) and number n\n */\nexport function tonelliShanks(P: bigint): <T>(Fp: IField<T>, n: T) => T {\n  // Initialization (precomputation).\n  // Caching initialization could boost perf by 7%.\n  if (P < _3n) throw new Error('sqrt is not defined for small field');\n  // Factor P - 1 = Q * 2^S, where Q is odd\n  let Q = P - _1n;\n  let S = 0;\n  while (Q % _2n === _0n) {\n    Q /= _2n;\n    S++;\n  }\n\n  // Find the first quadratic non-residue Z >= 2\n  let Z = _2n;\n  const _Fp = Field(P);\n  while (FpLegendre(_Fp, Z) === 1) {\n    // Basic primality test for P. After x iterations, chance of\n    // not finding quadratic non-residue is 2^x, so 2^1000.\n    if (Z++ > 1000) throw new Error('Cannot find square root: probably non-prime P');\n  }\n  // Fast-path; usually done before Z, but we do \"primality test\".\n  if (S === 1) return sqrt3mod4;\n\n  // Slow-path\n  // TODO: test on Fp2 and others\n  let cc = _Fp.pow(Z, Q); // c = z^Q\n  const Q1div2 = (Q + _1n) / _2n;\n  return function tonelliSlow<T>(Fp: IField<T>, n: T): T {\n    if (Fp.is0(n)) return n;\n    // Check if n is a quadratic residue using Legendre symbol\n    if (FpLegendre(Fp, n) !== 1) throw new Error('Cannot find square root');\n\n    // Initialize variables for the main loop\n    let M = S;\n    let c = Fp.mul(Fp.ONE, cc); // c = z^Q, move cc from field _Fp into field Fp\n    let t = Fp.pow(n, Q); // t = n^Q, first guess at the fudge factor\n    let R = Fp.pow(n, Q1div2); // R = n^((Q+1)/2), first guess at the square root\n\n    // Main loop\n    // while t != 1\n    while (!Fp.eql(t, Fp.ONE)) {\n      if (Fp.is0(t)) return Fp.ZERO; // if t=0 return R=0\n      let i = 1;\n\n      // Find the smallest i >= 1 such that t^(2^i) \u2261 1 (mod P)\n      let t_tmp = Fp.sqr(t); // t^(2^1)\n      while (!Fp.eql(t_tmp, Fp.ONE)) {\n        i++;\n        t_tmp = Fp.sqr(t_tmp); // t^(2^2)...\n        if (i === M) throw new Error('Cannot find square root');\n      }\n\n      // Calculate the exponent for b: 2^(M - i - 1)\n      const exponent = _1n << BigInt(M - i - 1); // bigint is important\n      const b = Fp.pow(c, exponent); // b = 2^(M - i - 1)\n\n      // Update variables\n      M = i;\n      c = Fp.sqr(b); // c = b^2\n      t = Fp.mul(t, c); // t = (t * b^2)\n      R = Fp.mul(R, b); // R = R*b\n    }\n    return R;\n  };\n}\n\n/**\n * Square root for a finite field. Will try optimized versions first:\n *\n * 1. P \u2261 3 (mod 4)\n * 2. P \u2261 5 (mod 8)\n * 3. P \u2261 9 (mod 16)\n * 4. Tonelli-Shanks algorithm\n *\n * Different algorithms can give different roots, it is up to user to decide which one they want.\n * For example there is FpSqrtOdd/FpSqrtEven to choice root based on oddness (used for hash-to-curve).\n */\nexport function FpSqrt(P: bigint): <T>(Fp: IField<T>, n: T) => T {\n  // P \u2261 3 (mod 4) => \u221An = n^((P+1)/4)\n  if (P % _4n === _3n) return sqrt3mod4;\n  // P \u2261 5 (mod 8) => Atkin algorithm, page 10 of https://eprint.iacr.org/2012/685.pdf\n  if (P % _8n === _5n) return sqrt5mod8;\n  // P \u2261 9 (mod 16) => Kong algorithm, page 11 of https://eprint.iacr.org/2012/685.pdf (algorithm 4)\n  if (P % _16n === _9n) return sqrt9mod16(P);\n  // Tonelli-Shanks algorithm\n  return tonelliShanks(P);\n}\n\n// Little-endian check for first LE bit (last BE bit);\nexport const isNegativeLE = (num: bigint, modulo: bigint): boolean =>\n  (mod(num, modulo) & _1n) === _1n;\n\n/** Field is not always over prime: for example, Fp2 has ORDER(q)=p^m. */\nexport interface IField<T> {\n  ORDER: bigint;\n  BYTES: number;\n  BITS: number;\n  isLE: boolean;\n  ZERO: T;\n  ONE: T;\n  // 1-arg\n  create: (num: T) => T;\n  isValid: (num: T) => boolean;\n  is0: (num: T) => boolean;\n  isValidNot0: (num: T) => boolean;\n  neg(num: T): T;\n  inv(num: T): T;\n  sqrt(num: T): T;\n  sqr(num: T): T;\n  // 2-args\n  eql(lhs: T, rhs: T): boolean;\n  add(lhs: T, rhs: T): T;\n  sub(lhs: T, rhs: T): T;\n  mul(lhs: T, rhs: T | bigint): T;\n  pow(lhs: T, power: bigint): T;\n  div(lhs: T, rhs: T | bigint): T;\n  // N for NonNormalized (for now)\n  addN(lhs: T, rhs: T): T;\n  subN(lhs: T, rhs: T): T;\n  mulN(lhs: T, rhs: T | bigint): T;\n  sqrN(num: T): T;\n\n  // Optional\n  // Should be same as sgn0 function in\n  // [RFC9380](https://www.rfc-editor.org/rfc/rfc9380#section-4.1).\n  // NOTE: sgn0 is 'negative in LE', which is same as odd. And negative in LE is kinda strange definition anyway.\n  isOdd?(num: T): boolean; // Odd instead of even since we have it for Fp2\n  // legendre?(num: T): T;\n  invertBatch: (lst: T[]) => T[];\n  toBytes(num: T): Uint8Array;\n  fromBytes(bytes: Uint8Array, skipValidation?: boolean): T;\n  // If c is False, CMOV returns a, otherwise it returns b.\n  cmov(a: T, b: T, c: boolean): T;\n}\n// prettier-ignore\nconst FIELD_FIELDS = [\n  'create', 'isValid', 'is0', 'neg', 'inv', 'sqrt', 'sqr',\n  'eql', 'add', 'sub', 'mul', 'pow', 'div',\n  'addN', 'subN', 'mulN', 'sqrN'\n] as const;\nexport function validateField<T>(field: IField<T>): IField<T> {\n  const initial = {\n    ORDER: 'bigint',\n    BYTES: 'number',\n    BITS: 'number',\n  } as Record<string, string>;\n  const opts = FIELD_FIELDS.reduce((map, val: string) => {\n    map[val] = 'function';\n    return map;\n  }, initial);\n  validateObject(field, opts);\n  // const max = 16384;\n  // if (field.BYTES < 1 || field.BYTES > max) throw new Error('invalid field');\n  // if (field.BITS < 1 || field.BITS > 8 * max) throw new Error('invalid field');\n  return field;\n}\n\n// Generic field functions\n\n/**\n * Same as `pow` but for Fp: non-constant-time.\n * Unsafe in some contexts: uses ladder, so can expose bigint bits.\n */\nexport function FpPow<T>(Fp: IField<T>, num: T, power: bigint): T {\n  if (power < _0n) throw new Error('invalid exponent, negatives unsupported');\n  if (power === _0n) return Fp.ONE;\n  if (power === _1n) return num;\n  let p = Fp.ONE;\n  let d = num;\n  while (power > _0n) {\n    if (power & _1n) p = Fp.mul(p, d);\n    d = Fp.sqr(d);\n    power >>= _1n;\n  }\n  return p;\n}\n\n/**\n * Efficiently invert an array of Field elements.\n * Exception-free. Will return `undefined` for 0 elements.\n * @param passZero map 0 to 0 (instead of undefined)\n */\nexport function FpInvertBatch<T>(Fp: IField<T>, nums: T[], passZero = false): T[] {\n  const inverted = new Array(nums.length).fill(passZero ? Fp.ZERO : undefined);\n  // Walk from first to last, multiply them by each other MOD p\n  const multipliedAcc = nums.reduce((acc, num, i) => {\n    if (Fp.is0(num)) return acc;\n    inverted[i] = acc;\n    return Fp.mul(acc, num);\n  }, Fp.ONE);\n  // Invert last element\n  const invertedAcc = Fp.inv(multipliedAcc);\n  // Walk from last to first, multiply them by inverted each other MOD p\n  nums.reduceRight((acc, num, i) => {\n    if (Fp.is0(num)) return acc;\n    inverted[i] = Fp.mul(acc, inverted[i]);\n    return Fp.mul(acc, num);\n  }, invertedAcc);\n  return inverted;\n}\n\n// TODO: remove\nexport function FpDiv<T>(Fp: IField<T>, lhs: T, rhs: T | bigint): T {\n  return Fp.mul(lhs, typeof rhs === 'bigint' ? invert(rhs, Fp.ORDER) : Fp.inv(rhs));\n}\n\n/**\n * Legendre symbol.\n * Legendre constant is used to calculate Legendre symbol (a | p)\n * which denotes the value of a^((p-1)/2) (mod p).\n *\n * * (a | p) \u2261 1    if a is a square (mod p), quadratic residue\n * * (a | p) \u2261 -1   if a is not a square (mod p), quadratic non residue\n * * (a | p) \u2261 0    if a \u2261 0 (mod p)\n */\nexport function FpLegendre<T>(Fp: IField<T>, n: T): -1 | 0 | 1 {\n  // We can use 3rd argument as optional cache of this value\n  // but seems unneeded for now. The operation is very fast.\n  const p1mod2 = (Fp.ORDER - _1n) / _2n;\n  const powered = Fp.pow(n, p1mod2);\n  const yes = Fp.eql(powered, Fp.ONE);\n  const zero = Fp.eql(powered, Fp.ZERO);\n  const no = Fp.eql(powered, Fp.neg(Fp.ONE));\n  if (!yes && !zero && !no) throw new Error('invalid Legendre symbol result');\n  return yes ? 1 : zero ? 0 : -1;\n}\n\n// This function returns True whenever the value x is a square in the field F.\nexport function FpIsSquare<T>(Fp: IField<T>, n: T): boolean {\n  const l = FpLegendre(Fp, n);\n  return l === 1;\n}\n\nexport type NLength = { nByteLength: number; nBitLength: number };\n// CURVE.n lengths\nexport function nLength(n: bigint, nBitLength?: number): NLength {\n  // Bit size, byte size of CURVE.n\n  if (nBitLength !== undefined) anumber(nBitLength);\n  const _nBitLength = nBitLength !== undefined ? nBitLength : n.toString(2).length;\n  const nByteLength = Math.ceil(_nBitLength / 8);\n  return { nBitLength: _nBitLength, nByteLength };\n}\n\ntype FpField = IField<bigint> & Required<Pick<IField<bigint>, 'isOdd'>>;\ntype SqrtFn = (n: bigint) => bigint;\ntype FieldOpts = Partial<{\n  isLE: boolean;\n  BITS: number;\n  sqrt: SqrtFn;\n  allowedLengths?: readonly number[]; // for P521 (adds padding for smaller sizes)\n  modFromBytes: boolean; // bls12-381 requires mod(n) instead of rejecting keys >= n\n}>;\nclass _Field implements IField<bigint> {\n  readonly ORDER: bigint;\n  readonly BITS: number;\n  readonly BYTES: number;\n  readonly isLE: boolean;\n  readonly ZERO = _0n;\n  readonly ONE = _1n;\n  readonly _lengths?: number[];\n  private _sqrt: ReturnType<typeof FpSqrt> | undefined; // cached sqrt\n  private readonly _mod?: boolean;\n  constructor(ORDER: bigint, opts: FieldOpts = {}) {\n    if (ORDER <= _0n) throw new Error('invalid field: expected ORDER > 0, got ' + ORDER);\n    let _nbitLength: number | undefined = undefined;\n    this.isLE = false;\n    if (opts != null && typeof opts === 'object') {\n      if (typeof opts.BITS === 'number') _nbitLength = opts.BITS;\n      if (typeof opts.sqrt === 'function') this.sqrt = opts.sqrt;\n      if (typeof opts.isLE === 'boolean') this.isLE = opts.isLE;\n      if (opts.allowedLengths) this._lengths = opts.allowedLengths?.slice();\n      if (typeof opts.modFromBytes === 'boolean') this._mod = opts.modFromBytes;\n    }\n    const { nBitLength, nByteLength } = nLength(ORDER, _nbitLength);\n    if (nByteLength > 2048) throw new Error('invalid field: expected ORDER of <= 2048 bytes');\n    this.ORDER = ORDER;\n    this.BITS = nBitLength;\n    this.BYTES = nByteLength;\n    this._sqrt = undefined;\n    Object.preventExtensions(this);\n  }\n\n  create(num: bigint) {\n    return mod(num, this.ORDER);\n  }\n  isValid(num: bigint) {\n    if (typeof num !== 'bigint')\n      throw new Error('invalid field element: expected bigint, got ' + typeof num);\n    return _0n <= num && num < this.ORDER; // 0 is valid element, but it's not invertible\n  }\n  is0(num: bigint) {\n    return num === _0n;\n  }\n  // is valid and invertible\n  isValidNot0(num: bigint) {\n    return !this.is0(num) && this.isValid(num);\n  }\n  isOdd(num: bigint) {\n    return (num & _1n) === _1n;\n  }\n  neg(num: bigint) {\n    return mod(-num, this.ORDER);\n  }\n  eql(lhs: bigint, rhs: bigint) {\n    return lhs === rhs;\n  }\n\n  sqr(num: bigint) {\n    return mod(num * num, this.ORDER);\n  }\n  add(lhs: bigint, rhs: bigint) {\n    return mod(lhs + rhs, this.ORDER);\n  }\n  sub(lhs: bigint, rhs: bigint) {\n    return mod(lhs - rhs, this.ORDER);\n  }\n  mul(lhs: bigint, rhs: bigint) {\n    return mod(lhs * rhs, this.ORDER);\n  }\n  pow(num: bigint, power: bigint): bigint {\n    return FpPow(this, num, power);\n  }\n  div(lhs: bigint, rhs: bigint) {\n    return mod(lhs * invert(rhs, this.ORDER), this.ORDER);\n  }\n\n  // Same as above, but doesn't normalize\n  sqrN(num: bigint) {\n    return num * num;\n  }\n  addN(lhs: bigint, rhs: bigint) {\n    return lhs + rhs;\n  }\n  subN(lhs: bigint, rhs: bigint) {\n    return lhs - rhs;\n  }\n  mulN(lhs: bigint, rhs: bigint) {\n    return lhs * rhs;\n  }\n\n  inv(num: bigint) {\n    return invert(num, this.ORDER);\n  }\n  sqrt(num: bigint): bigint {\n    // Caching _sqrt speeds up sqrt9mod16 by 5x and tonneli-shanks by 10%\n    if (!this._sqrt) this._sqrt = FpSqrt(this.ORDER);\n    return this._sqrt(this, num);\n  }\n  toBytes(num: bigint) {\n    return this.isLE ? numberToBytesLE(num, this.BYTES) : numberToBytesBE(num, this.BYTES);\n  }\n  fromBytes(bytes: Uint8Array, skipValidation = false) {\n    abytes(bytes);\n    const { _lengths: allowedLengths, BYTES, isLE, ORDER, _mod: modFromBytes } = this;\n    if (allowedLengths) {\n      if (!allowedLengths.includes(bytes.length) || bytes.length > BYTES) {\n        throw new Error(\n          'Field.fromBytes: expected ' + allowedLengths + ' bytes, got ' + bytes.length\n        );\n      }\n      const padded = new Uint8Array(BYTES);\n      // isLE add 0 to right, !isLE to the left.\n      padded.set(bytes, isLE ? 0 : padded.length - bytes.length);\n      bytes = padded;\n    }\n    if (bytes.length !== BYTES)\n      throw new Error('Field.fromBytes: expected ' + BYTES + ' bytes, got ' + bytes.length);\n    let scalar = isLE ? bytesToNumberLE(bytes) : bytesToNumberBE(bytes);\n    if (modFromBytes) scalar = mod(scalar, ORDER);\n    if (!skipValidation)\n      if (!this.isValid(scalar))\n        throw new Error('invalid field element: outside of range 0..ORDER');\n    // NOTE: we don't validate scalar here, please use isValid. This done such way because some\n    // protocol may allow non-reduced scalar that reduced later or changed some other way.\n    return scalar;\n  }\n  // TODO: we don't need it here, move out to separate fn\n  invertBatch(lst: bigint[]): bigint[] {\n    return FpInvertBatch(this, lst);\n  }\n  // We can't move this out because Fp6, Fp12 implement it\n  // and it's unclear what to return in there.\n  cmov(a: bigint, b: bigint, condition: boolean) {\n    return condition ? b : a;\n  }\n}\n\n/**\n * Creates a finite field. Major performance optimizations:\n * * 1. Denormalized operations like mulN instead of mul.\n * * 2. Identical object shape: never add or remove keys.\n * * 3. `Object.freeze`.\n * Fragile: always run a benchmark on a change.\n * Security note: operations don't check 'isValid' for all elements for performance reasons,\n * it is caller responsibility to check this.\n * This is low-level code, please make sure you know what you're doing.\n *\n * Note about field properties:\n * * CHARACTERISTIC p = prime number, number of elements in main subgroup.\n * * ORDER q = similar to cofactor in curves, may be composite `q = p^m`.\n *\n * @param ORDER field order, probably prime, or could be composite\n * @param bitLen how many bits the field consumes\n * @param isLE (default: false) if encoding / decoding should be in little-endian\n * @param redef optional faster redefinitions of sqrt and other methods\n */\nexport function Field(ORDER: bigint, opts: FieldOpts = {}): Readonly<FpField> {\n  return new _Field(ORDER, opts);\n}\n\n// Generic random scalar, we can do same for other fields if via Fp2.mul(Fp2.ONE, Fp2.random)?\n// This allows unsafe methods like ignore bias or zero. These unsafe, but often used in different protocols (if deterministic RNG).\n// which mean we cannot force this via opts.\n// Not sure what to do with randomBytes, we can accept it inside opts if wanted.\n// Probably need to export getMinHashLength somewhere?\n// random(bytes?: Uint8Array, unsafeAllowZero = false, unsafeAllowBias = false) {\n//   const LEN = !unsafeAllowBias ? getMinHashLength(ORDER) : BYTES;\n//   if (bytes === undefined) bytes = randomBytes(LEN); // _opts.randomBytes?\n//   const num = isLE ? bytesToNumberLE(bytes) : bytesToNumberBE(bytes);\n//   // `mod(x, 11)` can sometimes produce 0. `mod(x, 10) + 1` is the same, but no 0\n//   const reduced = unsafeAllowZero ? mod(num, ORDER) : mod(num, ORDER - _1n) + _1n;\n//   return reduced;\n// },\n\nexport function FpSqrtOdd<T>(Fp: IField<T>, elm: T): T {\n  if (!Fp.isOdd) throw new Error(\"Field doesn't have isOdd\");\n  const root = Fp.sqrt(elm);\n  return Fp.isOdd(root) ? root : Fp.neg(root);\n}\n\nexport function FpSqrtEven<T>(Fp: IField<T>, elm: T): T {\n  if (!Fp.isOdd) throw new Error(\"Field doesn't have isOdd\");\n  const root = Fp.sqrt(elm);\n  return Fp.isOdd(root) ? Fp.neg(root) : root;\n}\n\n/**\n * Returns total number of bytes consumed by the field element.\n * For example, 32 bytes for usual 256-bit weierstrass curve.\n * @param fieldOrder number of field elements, usually CURVE.n\n * @returns byte length of field\n */\nexport function getFieldBytesLength(fieldOrder: bigint): number {\n  if (typeof fieldOrder !== 'bigint') throw new Error('field order must be bigint');\n  const bitLength = fieldOrder.toString(2).length;\n  return Math.ceil(bitLength / 8);\n}\n\n/**\n * Returns minimal amount of bytes that can be safely reduced\n * by field order.\n * Should be 2^-128 for 128-bit curve such as P256.\n * @param fieldOrder number of field elements, usually CURVE.n\n * @returns byte length of target hash\n */\nexport function getMinHashLength(fieldOrder: bigint): number {\n  const length = getFieldBytesLength(fieldOrder);\n  return length + Math.ceil(length / 2);\n}\n\n/**\n * \"Constant-time\" private key generation utility.\n * Can take (n + n/2) or more bytes of uniform input e.g. from CSPRNG or KDF\n * and convert them into private scalar, with the modulo bias being negligible.\n * Needs at least 48 bytes of input for 32-byte private key.\n * https://research.kudelskisecurity.com/2020/07/28/the-definitive-guide-to-modulo-bias-and-how-to-avoid-it/\n * FIPS 186-5, A.2 https://csrc.nist.gov/publications/detail/fips/186/5/final\n * RFC 9380, https://www.rfc-editor.org/rfc/rfc9380#section-5\n * @param hash hash output from SHA3 or a similar function\n * @param groupOrder size of subgroup - (e.g. secp256k1.Point.Fn.ORDER)\n * @param isLE interpret hash bytes as LE num\n * @returns valid private scalar\n */\nexport function mapHashToField(key: Uint8Array, fieldOrder: bigint, isLE = false): Uint8Array {\n  abytes(key);\n  const len = key.length;\n  const fieldLen = getFieldBytesLength(fieldOrder);\n  const minLen = getMinHashLength(fieldOrder);\n  // No small numbers: need to understand bias story. No huge numbers: easier to detect JS timings.\n  if (len < 16 || len < minLen || len > 1024)\n    throw new Error('expected ' + minLen + '-1024 bytes of input, got ' + len);\n  const num = isLE ? bytesToNumberLE(key) : bytesToNumberBE(key);\n  // `mod(x, 11)` can sometimes produce 0. `mod(x, 10) + 1` is the same, but no 0\n  const reduced = mod(num, fieldOrder - _1n) + _1n;\n  return isLE ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);\n}\n", "/**\n * Short Weierstrass curve methods. The formula is: y\u00B2 = x\u00B3 + ax + b.\n *\n * ### Design rationale for types\n *\n * * Interaction between classes from different curves should fail:\n *   `k256.Point.BASE.add(p256.Point.BASE)`\n * * For this purpose we want to use `instanceof` operator, which is fast and works during runtime\n * * Different calls of `curve()` would return different classes -\n *   `curve(params) !== curve(params)`: if somebody decided to monkey-patch their curve,\n *   it won't affect others\n *\n * TypeScript can't infer types for classes created inside a function. Classes is one instance\n * of nominative types in TypeScript and interfaces only check for shape, so it's hard to create\n * unique type for every function call.\n *\n * We can use generic types via some param, like curve opts, but that would:\n *     1. Enable interaction between `curve(params)` and `curve(params)` (curves of same params)\n *     which is hard to debug.\n *     2. Params can be generic and we can't enforce them to be constant value:\n *     if somebody creates curve from non-constant params,\n *     it would be allowed to interact with other curves with non-constant params\n *\n * @todo https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-7.html#unique-symbol\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { hmac as nobleHmac } from '@noble/hashes/hmac.js';\nimport { ahash } from '@noble/hashes/utils.js';\nimport {\n  abool,\n  abytes,\n  aInRange,\n  bitLen,\n  bitMask,\n  bytesToHex,\n  bytesToNumberBE,\n  concatBytes,\n  createHmacDrbg,\n  hexToBytes,\n  isBytes,\n  memoized,\n  numberToHexUnpadded,\n  validateObject,\n  randomBytes as wcRandomBytes,\n  type CHash,\n  type Signer,\n} from '../utils.ts';\nimport {\n  createCurveFields,\n  createKeygen,\n  mulEndoUnsafe,\n  negateCt,\n  normalizeZ,\n  wNAF,\n  type AffinePoint,\n  type CurveLengths,\n  type CurvePoint,\n  type CurvePointCons,\n} from './curve.ts';\nimport {\n  FpInvertBatch,\n  getMinHashLength,\n  mapHashToField,\n  validateField,\n  type IField,\n} from './modular.ts';\n\nexport type { AffinePoint };\n\ntype EndoBasis = [[bigint, bigint], [bigint, bigint]];\n/**\n * When Weierstrass curve has `a=0`, it becomes Koblitz curve.\n * Koblitz curves allow using **efficiently-computable GLV endomorphism \u03C8**.\n * Endomorphism uses 2x less RAM, speeds up precomputation by 2x and ECDH / key recovery by 20%.\n * For precomputed wNAF it trades off 1/2 init time & 1/3 ram for 20% perf hit.\n *\n * Endomorphism consists of beta, lambda and splitScalar:\n *\n * 1. GLV endomorphism \u03C8 transforms a point: `P = (x, y) \u21A6 \u03C8(P) = (\u03B2\u00B7x mod p, y)`\n * 2. GLV scalar decomposition transforms a scalar: `k \u2261 k\u2081 + k\u2082\u00B7\u03BB (mod n)`\n * 3. Then these are combined: `k\u00B7P = k\u2081\u00B7P + k\u2082\u00B7\u03C8(P)`\n * 4. Two 128-bit point-by-scalar multiplications + one point addition is faster than\n *    one 256-bit multiplication.\n *\n * where\n * * beta: \u03B2 \u2208 F\u209A with \u03B2\u00B3 = 1, \u03B2 \u2260 1\n * * lambda: \u03BB \u2208 F\u2099 with \u03BB\u00B3 = 1, \u03BB \u2260 1\n * * splitScalar decomposes k \u21A6 k\u2081, k\u2082, by using reduced basis vectors.\n *   Gauss lattice reduction calculates them from initial basis vectors `(n, 0), (-\u03BB, 0)`\n *\n * Check out `test/misc/endomorphism.js` and\n * [gist](https://gist.github.com/paulmillr/eb670806793e84df628a7c434a873066).\n */\nexport type EndomorphismOpts = {\n  beta: bigint;\n  basises?: EndoBasis;\n  splitScalar?: (k: bigint) => { k1neg: boolean; k1: bigint; k2neg: boolean; k2: bigint };\n};\n// We construct basis in such way that den is always positive and equals n, but num sign depends on basis (not on secret value)\nconst divNearest = (num: bigint, den: bigint) => (num + (num >= 0 ? den : -den) / _2n) / den;\n\nexport type ScalarEndoParts = { k1neg: boolean; k1: bigint; k2neg: boolean; k2: bigint };\n\n/**\n * Splits scalar for GLV endomorphism.\n */\nexport function _splitEndoScalar(k: bigint, basis: EndoBasis, n: bigint): ScalarEndoParts {\n  // Split scalar into two such that part is ~half bits: `abs(part) < sqrt(N)`\n  // Since part can be negative, we need to do this on point.\n  // TODO: verifyScalar function which consumes lambda\n  const [[a1, b1], [a2, b2]] = basis;\n  const c1 = divNearest(b2 * k, n);\n  const c2 = divNearest(-b1 * k, n);\n  // |k1|/|k2| is < sqrt(N), but can be negative.\n  // If we do `k1 mod N`, we'll get big scalar (`> sqrt(N)`): so, we do cheaper negation instead.\n  let k1 = k - c1 * a1 - c2 * a2;\n  let k2 = -c1 * b1 - c2 * b2;\n  const k1neg = k1 < _0n;\n  const k2neg = k2 < _0n;\n  if (k1neg) k1 = -k1;\n  if (k2neg) k2 = -k2;\n  // Double check that resulting scalar less than half bits of N: otherwise wNAF will fail.\n  // This should only happen on wrong basises. Also, math inside is too complex and I don't trust it.\n  const MAX_NUM = bitMask(Math.ceil(bitLen(n) / 2)) + _1n; // Half bits of N\n  if (k1 < _0n || k1 >= MAX_NUM || k2 < _0n || k2 >= MAX_NUM) {\n    throw new Error('splitScalar (endomorphism): failed, k=' + k);\n  }\n  return { k1neg, k1, k2neg, k2 };\n}\n\n/**\n * Option to enable hedged signatures with improved security.\n *\n * * Randomly generated k is bad, because broken CSPRNG would leak private keys.\n * * Deterministic k (RFC6979) is better; but is suspectible to fault attacks.\n *\n * We allow using technique described in RFC6979 3.6: additional k', a.k.a. adding randomness\n * to deterministic sig. If CSPRNG is broken & randomness is weak, it would STILL be as secure\n * as ordinary sig without ExtraEntropy.\n *\n * * `true` means \"fetch data, from CSPRNG, incorporate it into k generation\"\n * * `false` means \"disable extra entropy, use purely deterministic k\"\n * * `Uint8Array` passed means \"incorporate following data into k generation\"\n *\n * https://paulmillr.com/posts/deterministic-signatures/\n */\nexport type ECDSAExtraEntropy = boolean | Uint8Array;\n/**\n * - `compact` is the default format\n * - `recovered` is the same as compact, but with an extra byte indicating recovery byte\n * - `der` is ASN.1 DER encoding\n */\nexport type ECDSASignatureFormat = 'compact' | 'recovered' | 'der';\n/**\n * - `prehash`: (default: true) indicates whether to do sha256(message).\n *   When a custom hash is used, it must be set to `false`.\n */\nexport type ECDSARecoverOpts = {\n  prehash?: boolean;\n};\n/**\n * - `prehash`: (default: true) indicates whether to do sha256(message).\n *   When a custom hash is used, it must be set to `false`.\n * - `lowS`: (default: true) prohibits signatures which have (sig.s >= CURVE.n/2n).\n *   Compatible with BTC/ETH. Setting `lowS: false` allows to create malleable signatures,\n *   which is default openssl behavior.\n *   Non-malleable signatures can still be successfully verified in openssl.\n * - `format`: (default: 'compact') 'compact' or 'recovered' with recovery byte\n */\nexport type ECDSAVerifyOpts = {\n  prehash?: boolean;\n  lowS?: boolean;\n  format?: ECDSASignatureFormat;\n};\n/**\n * - `prehash`: (default: true) indicates whether to do sha256(message).\n *   When a custom hash is used, it must be set to `false`.\n * - `lowS`: (default: true) prohibits signatures which have (sig.s >= CURVE.n/2n).\n *   Compatible with BTC/ETH. Setting `lowS: false` allows to create malleable signatures,\n *   which is default openssl behavior.\n *   Non-malleable signatures can still be successfully verified in openssl.\n * - `format`: (default: 'compact') 'compact' or 'recovered' with recovery byte\n * - `extraEntropy`: (default: false) creates sigs with increased security, see {@link ECDSAExtraEntropy}\n */\nexport type ECDSASignOpts = {\n  prehash?: boolean;\n  lowS?: boolean;\n  format?: ECDSASignatureFormat;\n  extraEntropy?: ECDSAExtraEntropy;\n};\n\nfunction validateSigFormat(format: string): ECDSASignatureFormat {\n  if (!['compact', 'recovered', 'der'].includes(format))\n    throw new Error('Signature format must be \"compact\", \"recovered\", or \"der\"');\n  return format as ECDSASignatureFormat;\n}\n\nfunction validateSigOpts<T extends ECDSASignOpts, D extends Required<ECDSASignOpts>>(\n  opts: T,\n  def: D\n): Required<ECDSASignOpts> {\n  const optsn: ECDSASignOpts = {};\n  for (let optName of Object.keys(def)) {\n    // @ts-ignore\n    optsn[optName] = opts[optName] === undefined ? def[optName] : opts[optName];\n  }\n  abool(optsn.lowS!, 'lowS');\n  abool(optsn.prehash!, 'prehash');\n  if (optsn.format !== undefined) validateSigFormat(optsn.format);\n  return optsn as Required<ECDSASignOpts>;\n}\n\n/** Instance methods for 3D XYZ projective points. */\nexport interface WeierstrassPoint<T> extends CurvePoint<T, WeierstrassPoint<T>> {\n  /** projective X coordinate. Different from affine x. */\n  readonly X: T;\n  /** projective Y coordinate. Different from affine y. */\n  readonly Y: T;\n  /** projective z coordinate */\n  readonly Z: T;\n  /** affine x coordinate. Different from projective X. */\n  get x(): T;\n  /** affine y coordinate. Different from projective Y. */\n  get y(): T;\n  /** Encodes point using IEEE P1363 (DER) encoding. First byte is 2/3/4. Default = isCompressed. */\n  toBytes(isCompressed?: boolean): Uint8Array;\n  toHex(isCompressed?: boolean): string;\n}\n\n/** Static methods for 3D XYZ projective points. */\nexport interface WeierstrassPointCons<T> extends CurvePointCons<WeierstrassPoint<T>> {\n  /** Does NOT validate if the point is valid. Use `.assertValidity()`. */\n  new (X: T, Y: T, Z: T): WeierstrassPoint<T>;\n  CURVE(): WeierstrassOpts<T>;\n}\n\n/**\n * Weierstrass curve options.\n *\n * * p: prime characteristic (order) of finite field, in which arithmetics is done\n * * n: order of prime subgroup a.k.a total amount of valid curve points\n * * h: cofactor, usually 1. h*n is group order; n is subgroup order\n * * a: formula param, must be in field of p\n * * b: formula param, must be in field of p\n * * Gx: x coordinate of generator point a.k.a. base point\n * * Gy: y coordinate of generator point\n */\nexport type WeierstrassOpts<T> = Readonly<{\n  p: bigint;\n  n: bigint;\n  h: bigint;\n  a: T;\n  b: T;\n  Gx: T;\n  Gy: T;\n}>;\n\n// When a cofactor != 1, there can be an effective methods to:\n// 1. Determine whether a point is torsion-free\n// 2. Clear torsion component\nexport type WeierstrassExtraOpts<T> = Partial<{\n  Fp: IField<T>;\n  Fn: IField<bigint>;\n  allowInfinityPoint: boolean;\n  endo: EndomorphismOpts;\n  isTorsionFree: (c: WeierstrassPointCons<T>, point: WeierstrassPoint<T>) => boolean;\n  clearCofactor: (c: WeierstrassPointCons<T>, point: WeierstrassPoint<T>) => WeierstrassPoint<T>;\n  fromBytes: (bytes: Uint8Array) => AffinePoint<T>;\n  toBytes: (\n    c: WeierstrassPointCons<T>,\n    point: WeierstrassPoint<T>,\n    isCompressed: boolean\n  ) => Uint8Array;\n}>;\n\n/**\n * Options for ECDSA signatures over a Weierstrass curve.\n *\n * * lowS: (default: true) whether produced / verified signatures occupy low half of ecdsaOpts.p. Prevents malleability.\n * * hmac: (default: noble-hashes hmac) function, would be used to init hmac-drbg for k generation.\n * * randomBytes: (default: webcrypto os-level CSPRNG) custom method for fetching secure randomness.\n * * bits2int, bits2int_modN: used in sigs, sometimes overridden by curves\n */\nexport type ECDSAOpts = Partial<{\n  lowS: boolean;\n  hmac: (key: Uint8Array, message: Uint8Array) => Uint8Array;\n  randomBytes: (bytesLength?: number) => Uint8Array;\n  bits2int: (bytes: Uint8Array) => bigint;\n  bits2int_modN: (bytes: Uint8Array) => bigint;\n}>;\n\n/**\n * Elliptic Curve Diffie-Hellman interface.\n * Provides keygen, secret-to-public conversion, calculating shared secrets.\n */\nexport interface ECDH {\n  keygen: (seed?: Uint8Array) => { secretKey: Uint8Array; publicKey: Uint8Array };\n  getPublicKey: (secretKey: Uint8Array, isCompressed?: boolean) => Uint8Array;\n  getSharedSecret: (\n    secretKeyA: Uint8Array,\n    publicKeyB: Uint8Array,\n    isCompressed?: boolean\n  ) => Uint8Array;\n  Point: WeierstrassPointCons<bigint>;\n  utils: {\n    isValidSecretKey: (secretKey: Uint8Array) => boolean;\n    isValidPublicKey: (publicKey: Uint8Array, isCompressed?: boolean) => boolean;\n    randomSecretKey: (seed?: Uint8Array) => Uint8Array;\n  };\n  lengths: CurveLengths;\n}\n\n/**\n * ECDSA interface.\n * Only supported for prime fields, not Fp2 (extension fields).\n */\nexport interface ECDSA extends ECDH {\n  sign: (message: Uint8Array, secretKey: Uint8Array, opts?: ECDSASignOpts) => Uint8Array;\n  verify: (\n    signature: Uint8Array,\n    message: Uint8Array,\n    publicKey: Uint8Array,\n    opts?: ECDSAVerifyOpts\n  ) => boolean;\n  recoverPublicKey(signature: Uint8Array, message: Uint8Array, opts?: ECDSARecoverOpts): Uint8Array;\n  Signature: ECDSASignatureCons;\n}\nexport class DERErr extends Error {\n  constructor(m = '') {\n    super(m);\n  }\n}\nexport type IDER = {\n  // asn.1 DER encoding utils\n  Err: typeof DERErr;\n  // Basic building block is TLV (Tag-Length-Value)\n  _tlv: {\n    encode: (tag: number, data: string) => string;\n    // v - value, l - left bytes (unparsed)\n    decode(tag: number, data: Uint8Array): { v: Uint8Array; l: Uint8Array };\n  };\n  // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,\n  // since we always use positive integers here. It must always be empty:\n  // - add zero byte if exists\n  // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)\n  _int: {\n    encode(num: bigint): string;\n    decode(data: Uint8Array): bigint;\n  };\n  toSig(hex: string | Uint8Array): { r: bigint; s: bigint };\n  hexFromSig(sig: { r: bigint; s: bigint }): string;\n};\n/**\n * ASN.1 DER encoding utilities. ASN is very complex & fragile. Format:\n *\n *     [0x30 (SEQUENCE), bytelength, 0x02 (INTEGER), intLength, R, 0x02 (INTEGER), intLength, S]\n *\n * Docs: https://letsencrypt.org/docs/a-warm-welcome-to-asn1-and-der/, https://luca.ntop.org/Teaching/Appunti/asn1.html\n */\nexport const DER: IDER = {\n  // asn.1 DER encoding utils\n  Err: DERErr,\n  // Basic building block is TLV (Tag-Length-Value)\n  _tlv: {\n    encode: (tag: number, data: string): string => {\n      const { Err: E } = DER;\n      if (tag < 0 || tag > 256) throw new E('tlv.encode: wrong tag');\n      if (data.length & 1) throw new E('tlv.encode: unpadded data');\n      const dataLen = data.length / 2;\n      const len = numberToHexUnpadded(dataLen);\n      if ((len.length / 2) & 0b1000_0000) throw new E('tlv.encode: long form length too big');\n      // length of length with long form flag\n      const lenLen = dataLen > 127 ? numberToHexUnpadded((len.length / 2) | 0b1000_0000) : '';\n      const t = numberToHexUnpadded(tag);\n      return t + lenLen + len + data;\n    },\n    // v - value, l - left bytes (unparsed)\n    decode(tag: number, data: Uint8Array): { v: Uint8Array; l: Uint8Array } {\n      const { Err: E } = DER;\n      let pos = 0;\n      if (tag < 0 || tag > 256) throw new E('tlv.encode: wrong tag');\n      if (data.length < 2 || data[pos++] !== tag) throw new E('tlv.decode: wrong tlv');\n      const first = data[pos++];\n      const isLong = !!(first & 0b1000_0000); // First bit of first length byte is flag for short/long form\n      let length = 0;\n      if (!isLong) length = first;\n      else {\n        // Long form: [longFlag(1bit), lengthLength(7bit), length (BE)]\n        const lenLen = first & 0b0111_1111;\n        if (!lenLen) throw new E('tlv.decode(long): indefinite length not supported');\n        if (lenLen > 4) throw new E('tlv.decode(long): byte length is too big'); // this will overflow u32 in js\n        const lengthBytes = data.subarray(pos, pos + lenLen);\n        if (lengthBytes.length !== lenLen) throw new E('tlv.decode: length bytes not complete');\n        if (lengthBytes[0] === 0) throw new E('tlv.decode(long): zero leftmost byte');\n        for (const b of lengthBytes) length = (length << 8) | b;\n        pos += lenLen;\n        if (length < 128) throw new E('tlv.decode(long): not minimal encoding');\n      }\n      const v = data.subarray(pos, pos + length);\n      if (v.length !== length) throw new E('tlv.decode: wrong value length');\n      return { v, l: data.subarray(pos + length) };\n    },\n  },\n  // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,\n  // since we always use positive integers here. It must always be empty:\n  // - add zero byte if exists\n  // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)\n  _int: {\n    encode(num: bigint): string {\n      const { Err: E } = DER;\n      if (num < _0n) throw new E('integer: negative integers are not allowed');\n      let hex = numberToHexUnpadded(num);\n      // Pad with zero byte if negative flag is present\n      if (Number.parseInt(hex[0], 16) & 0b1000) hex = '00' + hex;\n      if (hex.length & 1) throw new E('unexpected DER parsing assertion: unpadded hex');\n      return hex;\n    },\n    decode(data: Uint8Array): bigint {\n      const { Err: E } = DER;\n      if (data[0] & 0b1000_0000) throw new E('invalid signature integer: negative');\n      if (data[0] === 0x00 && !(data[1] & 0b1000_0000))\n        throw new E('invalid signature integer: unnecessary leading zero');\n      return bytesToNumberBE(data);\n    },\n  },\n  toSig(bytes: Uint8Array): { r: bigint; s: bigint } {\n    // parse DER signature\n    const { Err: E, _int: int, _tlv: tlv } = DER;\n    const data = abytes(bytes, undefined, 'signature');\n    const { v: seqBytes, l: seqLeftBytes } = tlv.decode(0x30, data);\n    if (seqLeftBytes.length) throw new E('invalid signature: left bytes after parsing');\n    const { v: rBytes, l: rLeftBytes } = tlv.decode(0x02, seqBytes);\n    const { v: sBytes, l: sLeftBytes } = tlv.decode(0x02, rLeftBytes);\n    if (sLeftBytes.length) throw new E('invalid signature: left bytes after parsing');\n    return { r: int.decode(rBytes), s: int.decode(sBytes) };\n  },\n  hexFromSig(sig: { r: bigint; s: bigint }): string {\n    const { _tlv: tlv, _int: int } = DER;\n    const rs = tlv.encode(0x02, int.encode(sig.r));\n    const ss = tlv.encode(0x02, int.encode(sig.s));\n    const seq = rs + ss;\n    return tlv.encode(0x30, seq);\n  },\n};\n\n// Be friendly to bad ECMAScript parsers by not using bigint literals\n// prettier-ignore\nconst _0n = BigInt(0), _1n = BigInt(1), _2n = BigInt(2), _3n = BigInt(3), _4n = BigInt(4);\n\n/**\n * Creates weierstrass Point constructor, based on specified curve options.\n *\n * See {@link WeierstrassOpts}.\n *\n * @example\n```js\nconst opts = {\n  p: 0xfffffffffffffffffffffffffffffffeffffac73n,\n  n: 0x100000000000000000001b8fa16dfab9aca16b6b3n,\n  h: 1n,\n  a: 0n,\n  b: 7n,\n  Gx: 0x3b4c382ce37aa192a4019e763036f4f5dd4d7ebbn,\n  Gy: 0x938cf935318fdced6bc28286531733c3f03c4feen,\n};\nconst secp160k1_Point = weierstrass(opts);\n```\n */\nexport function weierstrass<T>(\n  params: WeierstrassOpts<T>,\n  extraOpts: WeierstrassExtraOpts<T> = {}\n): WeierstrassPointCons<T> {\n  const validated = createCurveFields('weierstrass', params, extraOpts);\n  const { Fp, Fn } = validated;\n  let CURVE = validated.CURVE as WeierstrassOpts<T>;\n  const { h: cofactor, n: CURVE_ORDER } = CURVE;\n  validateObject(\n    extraOpts,\n    {},\n    {\n      allowInfinityPoint: 'boolean',\n      clearCofactor: 'function',\n      isTorsionFree: 'function',\n      fromBytes: 'function',\n      toBytes: 'function',\n      endo: 'object',\n    }\n  );\n\n  const { endo } = extraOpts;\n  if (endo) {\n    // validateObject(endo, { beta: 'bigint', splitScalar: 'function' });\n    if (!Fp.is0(CURVE.a) || typeof endo.beta !== 'bigint' || !Array.isArray(endo.basises)) {\n      throw new Error('invalid endo: expected \"beta\": bigint and \"basises\": array');\n    }\n  }\n\n  const lengths = getWLengths(Fp, Fn);\n\n  function assertCompressionIsSupported() {\n    if (!Fp.isOdd) throw new Error('compression is not supported: Field does not have .isOdd()');\n  }\n\n  // Implements IEEE P1363 point encoding\n  function pointToBytes(\n    _c: WeierstrassPointCons<T>,\n    point: WeierstrassPoint<T>,\n    isCompressed: boolean\n  ): Uint8Array {\n    const { x, y } = point.toAffine();\n    const bx = Fp.toBytes(x);\n    abool(isCompressed, 'isCompressed');\n    if (isCompressed) {\n      assertCompressionIsSupported();\n      const hasEvenY = !Fp.isOdd!(y);\n      return concatBytes(pprefix(hasEvenY), bx);\n    } else {\n      return concatBytes(Uint8Array.of(0x04), bx, Fp.toBytes(y));\n    }\n  }\n  function pointFromBytes(bytes: Uint8Array) {\n    abytes(bytes, undefined, 'Point');\n    const { publicKey: comp, publicKeyUncompressed: uncomp } = lengths; // e.g. for 32-byte: 33, 65\n    const length = bytes.length;\n    const head = bytes[0];\n    const tail = bytes.subarray(1);\n    // No actual validation is done here: use .assertValidity()\n    if (length === comp && (head === 0x02 || head === 0x03)) {\n      const x = Fp.fromBytes(tail);\n      if (!Fp.isValid(x)) throw new Error('bad point: is not on curve, wrong x');\n      const y2 = weierstrassEquation(x); // y\u00B2 = x\u00B3 + ax + b\n      let y: T;\n      try {\n        y = Fp.sqrt(y2); // y = y\u00B2 ^ (p+1)/4\n      } catch (sqrtError) {\n        const err = sqrtError instanceof Error ? ': ' + sqrtError.message : '';\n        throw new Error('bad point: is not on curve, sqrt error' + err);\n      }\n      assertCompressionIsSupported();\n      const evenY = Fp.isOdd!(y);\n      const evenH = (head & 1) === 1; // ECDSA-specific\n      if (evenH !== evenY) y = Fp.neg(y);\n      return { x, y };\n    } else if (length === uncomp && head === 0x04) {\n      // TODO: more checks\n      const L = Fp.BYTES;\n      const x = Fp.fromBytes(tail.subarray(0, L));\n      const y = Fp.fromBytes(tail.subarray(L, L * 2));\n      if (!isValidXY(x, y)) throw new Error('bad point: is not on curve');\n      return { x, y };\n    } else {\n      throw new Error(\n        `bad point: got length ${length}, expected compressed=${comp} or uncompressed=${uncomp}`\n      );\n    }\n  }\n\n  const encodePoint = extraOpts.toBytes || pointToBytes;\n  const decodePoint = extraOpts.fromBytes || pointFromBytes;\n  function weierstrassEquation(x: T): T {\n    const x2 = Fp.sqr(x); // x * x\n    const x3 = Fp.mul(x2, x); // x\u00B2 * x\n    return Fp.add(Fp.add(x3, Fp.mul(x, CURVE.a)), CURVE.b); // x\u00B3 + a * x + b\n  }\n\n  // TODO: move top-level\n  /** Checks whether equation holds for given x, y: y\u00B2 == x\u00B3 + ax + b */\n  function isValidXY(x: T, y: T): boolean {\n    const left = Fp.sqr(y); // y\u00B2\n    const right = weierstrassEquation(x); // x\u00B3 + ax + b\n    return Fp.eql(left, right);\n  }\n\n  // Validate whether the passed curve params are valid.\n  // Test 1: equation y\u00B2 = x\u00B3 + ax + b should work for generator point.\n  if (!isValidXY(CURVE.Gx, CURVE.Gy)) throw new Error('bad curve params: generator point');\n\n  // Test 2: discriminant \u0394 part should be non-zero: 4a\u00B3 + 27b\u00B2 != 0.\n  // Guarantees curve is genus-1, smooth (non-singular).\n  const _4a3 = Fp.mul(Fp.pow(CURVE.a, _3n), _4n);\n  const _27b2 = Fp.mul(Fp.sqr(CURVE.b), BigInt(27));\n  if (Fp.is0(Fp.add(_4a3, _27b2))) throw new Error('bad curve params: a or b');\n\n  /** Asserts coordinate is valid: 0 <= n < Fp.ORDER. */\n  function acoord(title: string, n: T, banZero = false) {\n    if (!Fp.isValid(n) || (banZero && Fp.is0(n))) throw new Error(`bad point coordinate ${title}`);\n    return n;\n  }\n\n  function aprjpoint(other: unknown) {\n    if (!(other instanceof Point)) throw new Error('Weierstrass Point expected');\n  }\n\n  function splitEndoScalarN(k: bigint) {\n    if (!endo || !endo.basises) throw new Error('no endo');\n    return _splitEndoScalar(k, endo.basises, Fn.ORDER);\n  }\n\n  // Memoized toAffine / validity check. They are heavy. Points are immutable.\n\n  // Converts Projective point to affine (x, y) coordinates.\n  // Can accept precomputed Z^-1 - for example, from invertBatch.\n  // (X, Y, Z) \u220B (x=X/Z, y=Y/Z)\n  const toAffineMemo = memoized((p: Point, iz?: T): AffinePoint<T> => {\n    const { X, Y, Z } = p;\n    // Fast-path for normalized points\n    if (Fp.eql(Z, Fp.ONE)) return { x: X, y: Y };\n    const is0 = p.is0();\n    // If invZ was 0, we return zero point. However we still want to execute\n    // all operations, so we replace invZ with a random number, 1.\n    if (iz == null) iz = is0 ? Fp.ONE : Fp.inv(Z);\n    const x = Fp.mul(X, iz);\n    const y = Fp.mul(Y, iz);\n    const zz = Fp.mul(Z, iz);\n    if (is0) return { x: Fp.ZERO, y: Fp.ZERO };\n    if (!Fp.eql(zz, Fp.ONE)) throw new Error('invZ was invalid');\n    return { x, y };\n  });\n  // NOTE: on exception this will crash 'cached' and no value will be set.\n  // Otherwise true will be return\n  const assertValidMemo = memoized((p: Point) => {\n    if (p.is0()) {\n      // (0, 1, 0) aka ZERO is invalid in most contexts.\n      // In BLS, ZERO can be serialized, so we allow it.\n      // (0, 0, 0) is invalid representation of ZERO.\n      if (extraOpts.allowInfinityPoint && !Fp.is0(p.Y)) return;\n      throw new Error('bad point: ZERO');\n    }\n    // Some 3rd-party test vectors require different wording between here & `fromCompressedHex`\n    const { x, y } = p.toAffine();\n    if (!Fp.isValid(x) || !Fp.isValid(y)) throw new Error('bad point: x or y not field elements');\n    if (!isValidXY(x, y)) throw new Error('bad point: equation left != right');\n    if (!p.isTorsionFree()) throw new Error('bad point: not in prime-order subgroup');\n    return true;\n  });\n\n  function finishEndo(\n    endoBeta: EndomorphismOpts['beta'],\n    k1p: Point,\n    k2p: Point,\n    k1neg: boolean,\n    k2neg: boolean\n  ) {\n    k2p = new Point(Fp.mul(k2p.X, endoBeta), k2p.Y, k2p.Z);\n    k1p = negateCt(k1neg, k1p);\n    k2p = negateCt(k2neg, k2p);\n    return k1p.add(k2p);\n  }\n\n  /**\n   * Projective Point works in 3d / projective (homogeneous) coordinates:(X, Y, Z) \u220B (x=X/Z, y=Y/Z).\n   * Default Point works in 2d / affine coordinates: (x, y).\n   * We're doing calculations in projective, because its operations don't require costly inversion.\n   */\n  class Point implements WeierstrassPoint<T> {\n    // base / generator point\n    static readonly BASE = new Point(CURVE.Gx, CURVE.Gy, Fp.ONE);\n    // zero / infinity / identity point\n    static readonly ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ZERO); // 0, 1, 0\n    // math field\n    static readonly Fp = Fp;\n    // scalar field\n    static readonly Fn = Fn;\n\n    readonly X: T;\n    readonly Y: T;\n    readonly Z: T;\n\n    /** Does NOT validate if the point is valid. Use `.assertValidity()`. */\n    constructor(X: T, Y: T, Z: T) {\n      this.X = acoord('x', X);\n      this.Y = acoord('y', Y, true);\n      this.Z = acoord('z', Z);\n      Object.freeze(this);\n    }\n\n    static CURVE(): WeierstrassOpts<T> {\n      return CURVE;\n    }\n\n    /** Does NOT validate if the point is valid. Use `.assertValidity()`. */\n    static fromAffine(p: AffinePoint<T>): Point {\n      const { x, y } = p || {};\n      if (!p || !Fp.isValid(x) || !Fp.isValid(y)) throw new Error('invalid affine point');\n      if (p instanceof Point) throw new Error('projective point not allowed');\n      // (0, 0) would've produced (0, 0, 1) - instead, we need (0, 1, 0)\n      if (Fp.is0(x) && Fp.is0(y)) return Point.ZERO;\n      return new Point(x, y, Fp.ONE);\n    }\n\n    static fromBytes(bytes: Uint8Array): Point {\n      const P = Point.fromAffine(decodePoint(abytes(bytes, undefined, 'point')));\n      P.assertValidity();\n      return P;\n    }\n\n    static fromHex(hex: string): Point {\n      return Point.fromBytes(hexToBytes(hex));\n    }\n\n    get x(): T {\n      return this.toAffine().x;\n    }\n    get y(): T {\n      return this.toAffine().y;\n    }\n\n    /**\n     *\n     * @param windowSize\n     * @param isLazy true will defer table computation until the first multiplication\n     * @returns\n     */\n    precompute(windowSize: number = 8, isLazy = true): Point {\n      wnaf.createCache(this, windowSize);\n      if (!isLazy) this.multiply(_3n); // random number\n      return this;\n    }\n\n    // TODO: return `this`\n    /** A point on curve is valid if it conforms to equation. */\n    assertValidity(): void {\n      assertValidMemo(this);\n    }\n\n    hasEvenY(): boolean {\n      const { y } = this.toAffine();\n      if (!Fp.isOdd) throw new Error(\"Field doesn't support isOdd\");\n      return !Fp.isOdd(y);\n    }\n\n    /** Compare one point to another. */\n    equals(other: Point): boolean {\n      aprjpoint(other);\n      const { X: X1, Y: Y1, Z: Z1 } = this;\n      const { X: X2, Y: Y2, Z: Z2 } = other;\n      const U1 = Fp.eql(Fp.mul(X1, Z2), Fp.mul(X2, Z1));\n      const U2 = Fp.eql(Fp.mul(Y1, Z2), Fp.mul(Y2, Z1));\n      return U1 && U2;\n    }\n\n    /** Flips point to one corresponding to (x, -y) in Affine coordinates. */\n    negate(): Point {\n      return new Point(this.X, Fp.neg(this.Y), this.Z);\n    }\n\n    // Renes-Costello-Batina exception-free doubling formula.\n    // There is 30% faster Jacobian formula, but it is not complete.\n    // https://eprint.iacr.org/2015/1060, algorithm 3\n    // Cost: 8M + 3S + 3*a + 2*b3 + 15add.\n    double() {\n      const { a, b } = CURVE;\n      const b3 = Fp.mul(b, _3n);\n      const { X: X1, Y: Y1, Z: Z1 } = this;\n      let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO; // prettier-ignore\n      let t0 = Fp.mul(X1, X1); // step 1\n      let t1 = Fp.mul(Y1, Y1);\n      let t2 = Fp.mul(Z1, Z1);\n      let t3 = Fp.mul(X1, Y1);\n      t3 = Fp.add(t3, t3); // step 5\n      Z3 = Fp.mul(X1, Z1);\n      Z3 = Fp.add(Z3, Z3);\n      X3 = Fp.mul(a, Z3);\n      Y3 = Fp.mul(b3, t2);\n      Y3 = Fp.add(X3, Y3); // step 10\n      X3 = Fp.sub(t1, Y3);\n      Y3 = Fp.add(t1, Y3);\n      Y3 = Fp.mul(X3, Y3);\n      X3 = Fp.mul(t3, X3);\n      Z3 = Fp.mul(b3, Z3); // step 15\n      t2 = Fp.mul(a, t2);\n      t3 = Fp.sub(t0, t2);\n      t3 = Fp.mul(a, t3);\n      t3 = Fp.add(t3, Z3);\n      Z3 = Fp.add(t0, t0); // step 20\n      t0 = Fp.add(Z3, t0);\n      t0 = Fp.add(t0, t2);\n      t0 = Fp.mul(t0, t3);\n      Y3 = Fp.add(Y3, t0);\n      t2 = Fp.mul(Y1, Z1); // step 25\n      t2 = Fp.add(t2, t2);\n      t0 = Fp.mul(t2, t3);\n      X3 = Fp.sub(X3, t0);\n      Z3 = Fp.mul(t2, t1);\n      Z3 = Fp.add(Z3, Z3); // step 30\n      Z3 = Fp.add(Z3, Z3);\n      return new Point(X3, Y3, Z3);\n    }\n\n    // Renes-Costello-Batina exception-free addition formula.\n    // There is 30% faster Jacobian formula, but it is not complete.\n    // https://eprint.iacr.org/2015/1060, algorithm 1\n    // Cost: 12M + 0S + 3*a + 3*b3 + 23add.\n    add(other: Point): Point {\n      aprjpoint(other);\n      const { X: X1, Y: Y1, Z: Z1 } = this;\n      const { X: X2, Y: Y2, Z: Z2 } = other;\n      let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO; // prettier-ignore\n      const a = CURVE.a;\n      const b3 = Fp.mul(CURVE.b, _3n);\n      let t0 = Fp.mul(X1, X2); // step 1\n      let t1 = Fp.mul(Y1, Y2);\n      let t2 = Fp.mul(Z1, Z2);\n      let t3 = Fp.add(X1, Y1);\n      let t4 = Fp.add(X2, Y2); // step 5\n      t3 = Fp.mul(t3, t4);\n      t4 = Fp.add(t0, t1);\n      t3 = Fp.sub(t3, t4);\n      t4 = Fp.add(X1, Z1);\n      let t5 = Fp.add(X2, Z2); // step 10\n      t4 = Fp.mul(t4, t5);\n      t5 = Fp.add(t0, t2);\n      t4 = Fp.sub(t4, t5);\n      t5 = Fp.add(Y1, Z1);\n      X3 = Fp.add(Y2, Z2); // step 15\n      t5 = Fp.mul(t5, X3);\n      X3 = Fp.add(t1, t2);\n      t5 = Fp.sub(t5, X3);\n      Z3 = Fp.mul(a, t4);\n      X3 = Fp.mul(b3, t2); // step 20\n      Z3 = Fp.add(X3, Z3);\n      X3 = Fp.sub(t1, Z3);\n      Z3 = Fp.add(t1, Z3);\n      Y3 = Fp.mul(X3, Z3);\n      t1 = Fp.add(t0, t0); // step 25\n      t1 = Fp.add(t1, t0);\n      t2 = Fp.mul(a, t2);\n      t4 = Fp.mul(b3, t4);\n      t1 = Fp.add(t1, t2);\n      t2 = Fp.sub(t0, t2); // step 30\n      t2 = Fp.mul(a, t2);\n      t4 = Fp.add(t4, t2);\n      t0 = Fp.mul(t1, t4);\n      Y3 = Fp.add(Y3, t0);\n      t0 = Fp.mul(t5, t4); // step 35\n      X3 = Fp.mul(t3, X3);\n      X3 = Fp.sub(X3, t0);\n      t0 = Fp.mul(t3, t1);\n      Z3 = Fp.mul(t5, Z3);\n      Z3 = Fp.add(Z3, t0); // step 40\n      return new Point(X3, Y3, Z3);\n    }\n\n    subtract(other: Point) {\n      return this.add(other.negate());\n    }\n\n    is0(): boolean {\n      return this.equals(Point.ZERO);\n    }\n\n    /**\n     * Constant time multiplication.\n     * Uses wNAF method. Windowed method may be 10% faster,\n     * but takes 2x longer to generate and consumes 2x memory.\n     * Uses precomputes when available.\n     * Uses endomorphism for Koblitz curves.\n     * @param scalar by which the point would be multiplied\n     * @returns New point\n     */\n    multiply(scalar: bigint): Point {\n      const { endo } = extraOpts;\n      if (!Fn.isValidNot0(scalar)) throw new Error('invalid scalar: out of range'); // 0 is invalid\n      let point: Point, fake: Point; // Fake point is used to const-time mult\n      const mul = (n: bigint) => wnaf.cached(this, n, (p) => normalizeZ(Point, p));\n      /** See docs for {@link EndomorphismOpts} */\n      if (endo) {\n        const { k1neg, k1, k2neg, k2 } = splitEndoScalarN(scalar);\n        const { p: k1p, f: k1f } = mul(k1);\n        const { p: k2p, f: k2f } = mul(k2);\n        fake = k1f.add(k2f);\n        point = finishEndo(endo.beta, k1p, k2p, k1neg, k2neg);\n      } else {\n        const { p, f } = mul(scalar);\n        point = p;\n        fake = f;\n      }\n      // Normalize `z` for both points, but return only real one\n      return normalizeZ(Point, [point, fake])[0];\n    }\n\n    /**\n     * Non-constant-time multiplication. Uses double-and-add algorithm.\n     * It's faster, but should only be used when you don't care about\n     * an exposed secret key e.g. sig verification, which works over *public* keys.\n     */\n    multiplyUnsafe(sc: bigint): Point {\n      const { endo } = extraOpts;\n      const p = this as Point;\n      if (!Fn.isValid(sc)) throw new Error('invalid scalar: out of range'); // 0 is valid\n      if (sc === _0n || p.is0()) return Point.ZERO; // 0\n      if (sc === _1n) return p; // 1\n      if (wnaf.hasCache(this)) return this.multiply(sc); // precomputes\n      // We don't have method for double scalar multiplication (aP + bQ):\n      // Even with using Strauss-Shamir trick, it's 35% slower than na\u00EFve mul+add.\n      if (endo) {\n        const { k1neg, k1, k2neg, k2 } = splitEndoScalarN(sc);\n        const { p1, p2 } = mulEndoUnsafe(Point, p, k1, k2); // 30% faster vs wnaf.unsafe\n        return finishEndo(endo.beta, p1, p2, k1neg, k2neg);\n      } else {\n        return wnaf.unsafe(p, sc);\n      }\n    }\n\n    /**\n     * Converts Projective point to affine (x, y) coordinates.\n     * @param invertedZ Z^-1 (inverted zero) - optional, precomputation is useful for invertBatch\n     */\n    toAffine(invertedZ?: T): AffinePoint<T> {\n      return toAffineMemo(this, invertedZ);\n    }\n\n    /**\n     * Checks whether Point is free of torsion elements (is in prime subgroup).\n     * Always torsion-free for cofactor=1 curves.\n     */\n    isTorsionFree(): boolean {\n      const { isTorsionFree } = extraOpts;\n      if (cofactor === _1n) return true;\n      if (isTorsionFree) return isTorsionFree(Point, this);\n      return wnaf.unsafe(this, CURVE_ORDER).is0();\n    }\n\n    clearCofactor(): Point {\n      const { clearCofactor } = extraOpts;\n      if (cofactor === _1n) return this; // Fast-path\n      if (clearCofactor) return clearCofactor(Point, this) as Point;\n      return this.multiplyUnsafe(cofactor);\n    }\n\n    isSmallOrder(): boolean {\n      // can we use this.clearCofactor()?\n      return this.multiplyUnsafe(cofactor).is0();\n    }\n\n    toBytes(isCompressed = true): Uint8Array {\n      abool(isCompressed, 'isCompressed');\n      this.assertValidity();\n      return encodePoint(Point, this, isCompressed);\n    }\n\n    toHex(isCompressed = true): string {\n      return bytesToHex(this.toBytes(isCompressed));\n    }\n\n    toString() {\n      return `<Point ${this.is0() ? 'ZERO' : this.toHex()}>`;\n    }\n  }\n  const bits = Fn.BITS;\n  const wnaf = new wNAF(Point, extraOpts.endo ? Math.ceil(bits / 2) : bits);\n  Point.BASE.precompute(8); // Enable precomputes. Slows down first publicKey computation by 20ms.\n  return Point;\n}\n\n/** Methods of ECDSA signature instance. */\nexport interface ECDSASignature {\n  readonly r: bigint;\n  readonly s: bigint;\n  readonly recovery?: number;\n  addRecoveryBit(recovery: number): ECDSASignature & { readonly recovery: number };\n  hasHighS(): boolean;\n  recoverPublicKey(messageHash: Uint8Array): WeierstrassPoint<bigint>;\n  toBytes(format?: string): Uint8Array;\n  toHex(format?: string): string;\n}\n/** Methods of ECDSA signature constructor. */\nexport type ECDSASignatureCons = {\n  new (r: bigint, s: bigint, recovery?: number): ECDSASignature;\n  fromBytes(bytes: Uint8Array, format?: ECDSASignatureFormat): ECDSASignature;\n  fromHex(hex: string, format?: ECDSASignatureFormat): ECDSASignature;\n};\n\n// Points start with byte 0x02 when y is even; otherwise 0x03\nfunction pprefix(hasEvenY: boolean): Uint8Array {\n  return Uint8Array.of(hasEvenY ? 0x02 : 0x03);\n}\n\n/**\n * Implementation of the Shallue and van de Woestijne method for any weierstrass curve.\n * TODO: check if there is a way to merge this with uvRatio in Edwards; move to modular.\n * b = True and y = sqrt(u / v) if (u / v) is square in F, and\n * b = False and y = sqrt(Z * (u / v)) otherwise.\n * @param Fp\n * @param Z\n * @returns\n */\nexport function SWUFpSqrtRatio<T>(\n  Fp: IField<T>,\n  Z: T\n): (u: T, v: T) => { isValid: boolean; value: T } {\n  // Generic implementation\n  const q = Fp.ORDER;\n  let l = _0n;\n  for (let o = q - _1n; o % _2n === _0n; o /= _2n) l += _1n;\n  const c1 = l; // 1. c1, the largest integer such that 2^c1 divides q - 1.\n  // We need 2n ** c1 and 2n ** (c1-1). We can't use **; but we can use <<.\n  // 2n ** c1 == 2n << (c1-1)\n  const _2n_pow_c1_1 = _2n << (c1 - _1n - _1n);\n  const _2n_pow_c1 = _2n_pow_c1_1 * _2n;\n  const c2 = (q - _1n) / _2n_pow_c1; // 2. c2 = (q - 1) / (2^c1)  # Integer arithmetic\n  const c3 = (c2 - _1n) / _2n; // 3. c3 = (c2 - 1) / 2            # Integer arithmetic\n  const c4 = _2n_pow_c1 - _1n; // 4. c4 = 2^c1 - 1                # Integer arithmetic\n  const c5 = _2n_pow_c1_1; // 5. c5 = 2^(c1 - 1)                  # Integer arithmetic\n  const c6 = Fp.pow(Z, c2); // 6. c6 = Z^c2\n  const c7 = Fp.pow(Z, (c2 + _1n) / _2n); // 7. c7 = Z^((c2 + 1) / 2)\n  let sqrtRatio = (u: T, v: T): { isValid: boolean; value: T } => {\n    let tv1 = c6; // 1. tv1 = c6\n    let tv2 = Fp.pow(v, c4); // 2. tv2 = v^c4\n    let tv3 = Fp.sqr(tv2); // 3. tv3 = tv2^2\n    tv3 = Fp.mul(tv3, v); // 4. tv3 = tv3 * v\n    let tv5 = Fp.mul(u, tv3); // 5. tv5 = u * tv3\n    tv5 = Fp.pow(tv5, c3); // 6. tv5 = tv5^c3\n    tv5 = Fp.mul(tv5, tv2); // 7. tv5 = tv5 * tv2\n    tv2 = Fp.mul(tv5, v); // 8. tv2 = tv5 * v\n    tv3 = Fp.mul(tv5, u); // 9. tv3 = tv5 * u\n    let tv4 = Fp.mul(tv3, tv2); // 10. tv4 = tv3 * tv2\n    tv5 = Fp.pow(tv4, c5); // 11. tv5 = tv4^c5\n    let isQR = Fp.eql(tv5, Fp.ONE); // 12. isQR = tv5 == 1\n    tv2 = Fp.mul(tv3, c7); // 13. tv2 = tv3 * c7\n    tv5 = Fp.mul(tv4, tv1); // 14. tv5 = tv4 * tv1\n    tv3 = Fp.cmov(tv2, tv3, isQR); // 15. tv3 = CMOV(tv2, tv3, isQR)\n    tv4 = Fp.cmov(tv5, tv4, isQR); // 16. tv4 = CMOV(tv5, tv4, isQR)\n    // 17. for i in (c1, c1 - 1, ..., 2):\n    for (let i = c1; i > _1n; i--) {\n      let tv5 = i - _2n; // 18.    tv5 = i - 2\n      tv5 = _2n << (tv5 - _1n); // 19.    tv5 = 2^tv5\n      let tvv5 = Fp.pow(tv4, tv5); // 20.    tv5 = tv4^tv5\n      const e1 = Fp.eql(tvv5, Fp.ONE); // 21.    e1 = tv5 == 1\n      tv2 = Fp.mul(tv3, tv1); // 22.    tv2 = tv3 * tv1\n      tv1 = Fp.mul(tv1, tv1); // 23.    tv1 = tv1 * tv1\n      tvv5 = Fp.mul(tv4, tv1); // 24.    tv5 = tv4 * tv1\n      tv3 = Fp.cmov(tv2, tv3, e1); // 25.    tv3 = CMOV(tv2, tv3, e1)\n      tv4 = Fp.cmov(tvv5, tv4, e1); // 26.    tv4 = CMOV(tv5, tv4, e1)\n    }\n    return { isValid: isQR, value: tv3 };\n  };\n  if (Fp.ORDER % _4n === _3n) {\n    // sqrt_ratio_3mod4(u, v)\n    const c1 = (Fp.ORDER - _3n) / _4n; // 1. c1 = (q - 3) / 4     # Integer arithmetic\n    const c2 = Fp.sqrt(Fp.neg(Z)); // 2. c2 = sqrt(-Z)\n    sqrtRatio = (u: T, v: T) => {\n      let tv1 = Fp.sqr(v); // 1. tv1 = v^2\n      const tv2 = Fp.mul(u, v); // 2. tv2 = u * v\n      tv1 = Fp.mul(tv1, tv2); // 3. tv1 = tv1 * tv2\n      let y1 = Fp.pow(tv1, c1); // 4. y1 = tv1^c1\n      y1 = Fp.mul(y1, tv2); // 5. y1 = y1 * tv2\n      const y2 = Fp.mul(y1, c2); // 6. y2 = y1 * c2\n      const tv3 = Fp.mul(Fp.sqr(y1), v); // 7. tv3 = y1^2; 8. tv3 = tv3 * v\n      const isQR = Fp.eql(tv3, u); // 9. isQR = tv3 == u\n      let y = Fp.cmov(y2, y1, isQR); // 10. y = CMOV(y2, y1, isQR)\n      return { isValid: isQR, value: y }; // 11. return (isQR, y) isQR ? y : y*c2\n    };\n  }\n  // No curves uses that\n  // if (Fp.ORDER % _8n === _5n) // sqrt_ratio_5mod8\n  return sqrtRatio;\n}\n/**\n * Simplified Shallue-van de Woestijne-Ulas Method\n * https://www.rfc-editor.org/rfc/rfc9380#section-6.6.2\n */\nexport function mapToCurveSimpleSWU<T>(\n  Fp: IField<T>,\n  opts: {\n    A: T;\n    B: T;\n    Z: T;\n  }\n): (u: T) => { x: T; y: T } {\n  validateField(Fp);\n  const { A, B, Z } = opts;\n  if (!Fp.isValid(A) || !Fp.isValid(B) || !Fp.isValid(Z))\n    throw new Error('mapToCurveSimpleSWU: invalid opts');\n  const sqrtRatio = SWUFpSqrtRatio(Fp, Z);\n  if (!Fp.isOdd) throw new Error('Field does not have .isOdd()');\n  // Input: u, an element of F.\n  // Output: (x, y), a point on E.\n  return (u: T): { x: T; y: T } => {\n    // prettier-ignore\n    let tv1, tv2, tv3, tv4, tv5, tv6, x, y;\n    tv1 = Fp.sqr(u); // 1.  tv1 = u^2\n    tv1 = Fp.mul(tv1, Z); // 2.  tv1 = Z * tv1\n    tv2 = Fp.sqr(tv1); // 3.  tv2 = tv1^2\n    tv2 = Fp.add(tv2, tv1); // 4.  tv2 = tv2 + tv1\n    tv3 = Fp.add(tv2, Fp.ONE); // 5.  tv3 = tv2 + 1\n    tv3 = Fp.mul(tv3, B); // 6.  tv3 = B * tv3\n    tv4 = Fp.cmov(Z, Fp.neg(tv2), !Fp.eql(tv2, Fp.ZERO)); // 7.  tv4 = CMOV(Z, -tv2, tv2 != 0)\n    tv4 = Fp.mul(tv4, A); // 8.  tv4 = A * tv4\n    tv2 = Fp.sqr(tv3); // 9.  tv2 = tv3^2\n    tv6 = Fp.sqr(tv4); // 10. tv6 = tv4^2\n    tv5 = Fp.mul(tv6, A); // 11. tv5 = A * tv6\n    tv2 = Fp.add(tv2, tv5); // 12. tv2 = tv2 + tv5\n    tv2 = Fp.mul(tv2, tv3); // 13. tv2 = tv2 * tv3\n    tv6 = Fp.mul(tv6, tv4); // 14. tv6 = tv6 * tv4\n    tv5 = Fp.mul(tv6, B); // 15. tv5 = B * tv6\n    tv2 = Fp.add(tv2, tv5); // 16. tv2 = tv2 + tv5\n    x = Fp.mul(tv1, tv3); // 17.   x = tv1 * tv3\n    const { isValid, value } = sqrtRatio(tv2, tv6); // 18. (is_gx1_square, y1) = sqrt_ratio(tv2, tv6)\n    y = Fp.mul(tv1, u); // 19.   y = tv1 * u  -> Z * u^3 * y1\n    y = Fp.mul(y, value); // 20.   y = y * y1\n    x = Fp.cmov(x, tv3, isValid); // 21.   x = CMOV(x, tv3, is_gx1_square)\n    y = Fp.cmov(y, value, isValid); // 22.   y = CMOV(y, y1, is_gx1_square)\n    const e1 = Fp.isOdd!(u) === Fp.isOdd!(y); // 23.  e1 = sgn0(u) == sgn0(y)\n    y = Fp.cmov(Fp.neg(y), y, e1); // 24.   y = CMOV(-y, y, e1)\n    const tv4_inv = FpInvertBatch(Fp, [tv4], true)[0];\n    x = Fp.mul(x, tv4_inv); // 25.   x = x / tv4\n    return { x, y };\n  };\n}\n\nfunction getWLengths<T>(Fp: IField<T>, Fn: IField<bigint>) {\n  return {\n    secretKey: Fn.BYTES,\n    publicKey: 1 + Fp.BYTES,\n    publicKeyUncompressed: 1 + 2 * Fp.BYTES,\n    publicKeyHasPrefix: true,\n    signature: 2 * Fn.BYTES,\n  };\n}\n\n/**\n * Sometimes users only need getPublicKey, getSharedSecret, and secret key handling.\n * This helper ensures no signature functionality is present. Less code, smaller bundle size.\n */\nexport function ecdh(\n  Point: WeierstrassPointCons<bigint>,\n  ecdhOpts: { randomBytes?: (bytesLength?: number) => Uint8Array } = {}\n): ECDH {\n  const { Fn } = Point;\n  const randomBytes_ = ecdhOpts.randomBytes || wcRandomBytes;\n  const lengths = Object.assign(getWLengths(Point.Fp, Fn), { seed: getMinHashLength(Fn.ORDER) });\n\n  function isValidSecretKey(secretKey: Uint8Array) {\n    try {\n      const num = Fn.fromBytes(secretKey);\n      return Fn.isValidNot0(num);\n    } catch (error) {\n      return false;\n    }\n  }\n\n  function isValidPublicKey(publicKey: Uint8Array, isCompressed?: boolean): boolean {\n    const { publicKey: comp, publicKeyUncompressed } = lengths;\n    try {\n      const l = publicKey.length;\n      if (isCompressed === true && l !== comp) return false;\n      if (isCompressed === false && l !== publicKeyUncompressed) return false;\n      return !!Point.fromBytes(publicKey);\n    } catch (error) {\n      return false;\n    }\n  }\n\n  /**\n   * Produces cryptographically secure secret key from random of size\n   * (groupLen + ceil(groupLen / 2)) with modulo bias being negligible.\n   */\n  function randomSecretKey(seed = randomBytes_(lengths.seed)): Uint8Array {\n    return mapHashToField(abytes(seed, lengths.seed, 'seed'), Fn.ORDER);\n  }\n\n  /**\n   * Computes public key for a secret key. Checks for validity of the secret key.\n   * @param isCompressed whether to return compact (default), or full key\n   * @returns Public key, full when isCompressed=false; short when isCompressed=true\n   */\n  function getPublicKey(secretKey: Uint8Array, isCompressed = true): Uint8Array {\n    return Point.BASE.multiply(Fn.fromBytes(secretKey)).toBytes(isCompressed);\n  }\n\n  /**\n   * Quick and dirty check for item being public key. Does not validate hex, or being on-curve.\n   */\n  function isProbPub(item: Uint8Array): boolean | undefined {\n    const { secretKey, publicKey, publicKeyUncompressed } = lengths;\n    if (!isBytes(item)) return undefined;\n    if (('_lengths' in Fn && Fn._lengths) || secretKey === publicKey) return undefined;\n    const l = abytes(item, undefined, 'key').length;\n    return l === publicKey || l === publicKeyUncompressed;\n  }\n\n  /**\n   * ECDH (Elliptic Curve Diffie Hellman).\n   * Computes shared public key from secret key A and public key B.\n   * Checks: 1) secret key validity 2) shared key is on-curve.\n   * Does NOT hash the result.\n   * @param isCompressed whether to return compact (default), or full key\n   * @returns shared public key\n   */\n  function getSharedSecret(\n    secretKeyA: Uint8Array,\n    publicKeyB: Uint8Array,\n    isCompressed = true\n  ): Uint8Array {\n    if (isProbPub(secretKeyA) === true) throw new Error('first arg must be private key');\n    if (isProbPub(publicKeyB) === false) throw new Error('second arg must be public key');\n    const s = Fn.fromBytes(secretKeyA);\n    const b = Point.fromBytes(publicKeyB); // checks for being on-curve\n    return b.multiply(s).toBytes(isCompressed);\n  }\n\n  const utils = {\n    isValidSecretKey,\n    isValidPublicKey,\n    randomSecretKey,\n  };\n  const keygen = createKeygen(randomSecretKey, getPublicKey);\n\n  return Object.freeze({ getPublicKey, getSharedSecret, keygen, Point, utils, lengths });\n}\n\n/**\n * Creates ECDSA signing interface for given elliptic curve `Point` and `hash` function.\n *\n * @param Point created using {@link weierstrass} function\n * @param hash used for 1) message prehash-ing 2) k generation in `sign`, using hmac_drbg(hash)\n * @param ecdsaOpts rarely needed, see {@link ECDSAOpts}\n *\n * @example\n * ```js\n * const p256_Point = weierstrass(...);\n * const p256_sha256 = ecdsa(p256_Point, sha256);\n * const p256_sha224 = ecdsa(p256_Point, sha224);\n * const p256_sha224_r = ecdsa(p256_Point, sha224, { randomBytes: (length) => { ... } });\n * ```\n */\nexport function ecdsa(\n  Point: WeierstrassPointCons<bigint>,\n  hash: CHash,\n  ecdsaOpts: ECDSAOpts = {}\n): ECDSA {\n  ahash(hash);\n  validateObject(\n    ecdsaOpts,\n    {},\n    {\n      hmac: 'function',\n      lowS: 'boolean',\n      randomBytes: 'function',\n      bits2int: 'function',\n      bits2int_modN: 'function',\n    }\n  );\n  ecdsaOpts = Object.assign({}, ecdsaOpts);\n  const randomBytes = ecdsaOpts.randomBytes || wcRandomBytes;\n  const hmac = ecdsaOpts.hmac || ((key, msg) => nobleHmac(hash, key, msg));\n\n  const { Fp, Fn } = Point;\n  const { ORDER: CURVE_ORDER, BITS: fnBits } = Fn;\n  const { keygen, getPublicKey, getSharedSecret, utils, lengths } = ecdh(Point, ecdsaOpts);\n  const defaultSigOpts: Required<ECDSASignOpts> = {\n    prehash: true,\n    lowS: typeof ecdsaOpts.lowS === 'boolean' ? ecdsaOpts.lowS : true,\n    format: 'compact' as ECDSASignatureFormat,\n    extraEntropy: false,\n  };\n  const hasLargeCofactor = CURVE_ORDER * _2n < Fp.ORDER; // Won't CURVE().h > 2n be more effective?\n\n  function isBiggerThanHalfOrder(number: bigint) {\n    const HALF = CURVE_ORDER >> _1n;\n    return number > HALF;\n  }\n  function validateRS(title: string, num: bigint): bigint {\n    if (!Fn.isValidNot0(num))\n      throw new Error(`invalid signature ${title}: out of range 1..Point.Fn.ORDER`);\n    return num;\n  }\n  function assertSmallCofactor(): void {\n    // ECDSA recovery is hard for cofactor > 1 curves.\n    // In sign, `r = q.x mod n`, and here we recover q.x from r.\n    // While recovering q.x >= n, we need to add r+n for cofactor=1 curves.\n    // However, for cofactor>1, r+n may not get q.x:\n    // r+n*i would need to be done instead where i is unknown.\n    // To easily get i, we either need to:\n    // a. increase amount of valid recid values (4, 5...); OR\n    // b. prohibit non-prime-order signatures (recid > 1).\n    if (hasLargeCofactor)\n      throw new Error('\"recovered\" sig type is not supported for cofactor >2 curves');\n  }\n  function validateSigLength(bytes: Uint8Array, format: ECDSASignatureFormat) {\n    validateSigFormat(format);\n    const size = lengths.signature!;\n    const sizer = format === 'compact' ? size : format === 'recovered' ? size + 1 : undefined;\n    return abytes(bytes, sizer);\n  }\n\n  /**\n   * ECDSA signature with its (r, s) properties. Supports compact, recovered & DER representations.\n   */\n  class Signature implements ECDSASignature {\n    readonly r: bigint;\n    readonly s: bigint;\n    readonly recovery?: number;\n\n    constructor(r: bigint, s: bigint, recovery?: number) {\n      this.r = validateRS('r', r); // r in [1..N-1];\n      this.s = validateRS('s', s); // s in [1..N-1];\n      if (recovery != null) {\n        assertSmallCofactor();\n        if (![0, 1, 2, 3].includes(recovery)) throw new Error('invalid recovery id');\n        this.recovery = recovery;\n      }\n      Object.freeze(this);\n    }\n\n    static fromBytes(\n      bytes: Uint8Array,\n      format: ECDSASignatureFormat = defaultSigOpts.format\n    ): Signature {\n      validateSigLength(bytes, format);\n      let recid: number | undefined;\n      if (format === 'der') {\n        const { r, s } = DER.toSig(abytes(bytes));\n        return new Signature(r, s);\n      }\n      if (format === 'recovered') {\n        recid = bytes[0];\n        format = 'compact';\n        bytes = bytes.subarray(1);\n      }\n      const L = lengths.signature! / 2;\n      const r = bytes.subarray(0, L);\n      const s = bytes.subarray(L, L * 2);\n      return new Signature(Fn.fromBytes(r), Fn.fromBytes(s), recid);\n    }\n\n    static fromHex(hex: string, format?: ECDSASignatureFormat) {\n      return this.fromBytes(hexToBytes(hex), format);\n    }\n\n    private assertRecovery(): number {\n      const { recovery } = this;\n      if (recovery == null) throw new Error('invalid recovery id: must be present');\n      return recovery;\n    }\n\n    addRecoveryBit(recovery: number): RecoveredSignature {\n      return new Signature(this.r, this.s, recovery) as RecoveredSignature;\n    }\n\n    recoverPublicKey(messageHash: Uint8Array): WeierstrassPoint<bigint> {\n      const { r, s } = this;\n      const recovery = this.assertRecovery();\n      const radj = recovery === 2 || recovery === 3 ? r + CURVE_ORDER : r;\n      if (!Fp.isValid(radj)) throw new Error('invalid recovery id: sig.r+curve.n != R.x');\n      const x = Fp.toBytes(radj);\n      const R = Point.fromBytes(concatBytes(pprefix((recovery & 1) === 0), x));\n      const ir = Fn.inv(radj); // r^-1\n      const h = bits2int_modN(abytes(messageHash, undefined, 'msgHash')); // Truncate hash\n      const u1 = Fn.create(-h * ir); // -hr^-1\n      const u2 = Fn.create(s * ir); // sr^-1\n      // (sr^-1)R-(hr^-1)G = -(hr^-1)G + (sr^-1). unsafe is fine: there is no private data.\n      const Q = Point.BASE.multiplyUnsafe(u1).add(R.multiplyUnsafe(u2));\n      if (Q.is0()) throw new Error('invalid recovery: point at infinify');\n      Q.assertValidity();\n      return Q;\n    }\n\n    // Signatures should be low-s, to prevent malleability.\n    hasHighS(): boolean {\n      return isBiggerThanHalfOrder(this.s);\n    }\n\n    toBytes(format: ECDSASignatureFormat = defaultSigOpts.format) {\n      validateSigFormat(format);\n      if (format === 'der') return hexToBytes(DER.hexFromSig(this));\n      const { r, s } = this;\n      const rb = Fn.toBytes(r);\n      const sb = Fn.toBytes(s);\n      if (format === 'recovered') {\n        assertSmallCofactor();\n        return concatBytes(Uint8Array.of(this.assertRecovery()), rb, sb);\n      }\n      return concatBytes(rb, sb);\n    }\n\n    toHex(format?: ECDSASignatureFormat) {\n      return bytesToHex(this.toBytes(format));\n    }\n  }\n  type RecoveredSignature = Signature & { recovery: number };\n\n  // RFC6979: ensure ECDSA msg is X bytes and < N. RFC suggests optional truncating via bits2octets.\n  // FIPS 186-4 4.6 suggests the leftmost min(nBitLen, outLen) bits, which matches bits2int.\n  // bits2int can produce res>N, we can do mod(res, N) since the bitLen is the same.\n  // int2octets can't be used; pads small msgs with 0: unacceptatble for trunc as per RFC vectors\n  const bits2int =\n    ecdsaOpts.bits2int ||\n    function bits2int_def(bytes: Uint8Array): bigint {\n      // Our custom check \"just in case\", for protection against DoS\n      if (bytes.length > 8192) throw new Error('input is too large');\n      // For curves with nBitLength % 8 !== 0: bits2octets(bits2octets(m)) !== bits2octets(m)\n      // for some cases, since bytes.length * 8 is not actual bitLength.\n      const num = bytesToNumberBE(bytes); // check for == u8 done here\n      const delta = bytes.length * 8 - fnBits; // truncate to nBitLength leftmost bits\n      return delta > 0 ? num >> BigInt(delta) : num;\n    };\n  const bits2int_modN =\n    ecdsaOpts.bits2int_modN ||\n    function bits2int_modN_def(bytes: Uint8Array): bigint {\n      return Fn.create(bits2int(bytes)); // can't use bytesToNumberBE here\n    };\n  // Pads output with zero as per spec\n  const ORDER_MASK = bitMask(fnBits);\n  /** Converts to bytes. Checks if num in `[0..ORDER_MASK-1]` e.g.: `[0..2^256-1]`. */\n  function int2octets(num: bigint): Uint8Array {\n    // IMPORTANT: the check ensures working for case `Fn.BYTES != Fn.BITS * 8`\n    aInRange('num < 2^' + fnBits, num, _0n, ORDER_MASK);\n    return Fn.toBytes(num);\n  }\n\n  function validateMsgAndHash(message: Uint8Array, prehash: boolean) {\n    abytes(message, undefined, 'message');\n    return prehash ? abytes(hash(message), undefined, 'prehashed message') : message;\n  }\n\n  /**\n   * Steps A, D of RFC6979 3.2.\n   * Creates RFC6979 seed; converts msg/privKey to numbers.\n   * Used only in sign, not in verify.\n   *\n   * Warning: we cannot assume here that message has same amount of bytes as curve order,\n   * this will be invalid at least for P521. Also it can be bigger for P224 + SHA256.\n   */\n  function prepSig(message: Uint8Array, secretKey: Uint8Array, opts: ECDSASignOpts) {\n    const { lowS, prehash, extraEntropy } = validateSigOpts(opts, defaultSigOpts);\n    message = validateMsgAndHash(message, prehash); // RFC6979 3.2 A: h1 = H(m)\n    // We can't later call bits2octets, since nested bits2int is broken for curves\n    // with fnBits % 8 !== 0. Because of that, we unwrap it here as int2octets call.\n    // const bits2octets = (bits) => int2octets(bits2int_modN(bits))\n    const h1int = bits2int_modN(message);\n    const d = Fn.fromBytes(secretKey); // validate secret key, convert to bigint\n    if (!Fn.isValidNot0(d)) throw new Error('invalid private key');\n    const seedArgs = [int2octets(d), int2octets(h1int)];\n    // extraEntropy. RFC6979 3.6: additional k' (optional).\n    if (extraEntropy != null && extraEntropy !== false) {\n      // K = HMAC_K(V || 0x00 || int2octets(x) || bits2octets(h1) || k')\n      // gen random bytes OR pass as-is\n      const e = extraEntropy === true ? randomBytes(lengths.secretKey) : extraEntropy;\n      seedArgs.push(abytes(e, undefined, 'extraEntropy')); // check for being bytes\n    }\n    const seed = concatBytes(...seedArgs); // Step D of RFC6979 3.2\n    const m = h1int; // no need to call bits2int second time here, it is inside truncateHash!\n    // Converts signature params into point w r/s, checks result for validity.\n    // To transform k => Signature:\n    // q = k\u22C5G\n    // r = q.x mod n\n    // s = k^-1(m + rd) mod n\n    // Can use scalar blinding b^-1(bm + bdr) where b \u2208 [1,q\u22121] according to\n    // https://tches.iacr.org/index.php/TCHES/article/view/7337/6509. We've decided against it:\n    // a) dependency on CSPRNG b) 15% slowdown c) doesn't really help since bigints are not CT\n    function k2sig(kBytes: Uint8Array): Signature | undefined {\n      // RFC 6979 Section 3.2, step 3: k = bits2int(T)\n      // Important: all mod() calls here must be done over N\n      const k = bits2int(kBytes); // Cannot use fields methods, since it is group element\n      if (!Fn.isValidNot0(k)) return; // Valid scalars (including k) must be in 1..N-1\n      const ik = Fn.inv(k); // k^-1 mod n\n      const q = Point.BASE.multiply(k).toAffine(); // q = k\u22C5G\n      const r = Fn.create(q.x); // r = q.x mod n\n      if (r === _0n) return;\n      const s = Fn.create(ik * Fn.create(m + r * d)); // s = k^-1(m + rd) mod n\n      if (s === _0n) return;\n      let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n); // recovery bit (2 or 3 when q.x>n)\n      let normS = s;\n      if (lowS && isBiggerThanHalfOrder(s)) {\n        normS = Fn.neg(s); // if lowS was passed, ensure s is always in the bottom half of N\n        recovery ^= 1;\n      }\n      return new Signature(r, normS, hasLargeCofactor ? undefined : recovery);\n    }\n    return { seed, k2sig };\n  }\n\n  /**\n   * Signs message hash with a secret key.\n   *\n   * ```\n   * sign(m, d) where\n   *   k = rfc6979_hmac_drbg(m, d)\n   *   (x, y) = G \u00D7 k\n   *   r = x mod n\n   *   s = (m + dr) / k mod n\n   * ```\n   */\n  function sign(message: Uint8Array, secretKey: Uint8Array, opts: ECDSASignOpts = {}): Uint8Array {\n    const { seed, k2sig } = prepSig(message, secretKey, opts); // Steps A, D of RFC6979 3.2.\n    const drbg = createHmacDrbg<Signature>(hash.outputLen, Fn.BYTES, hmac);\n    const sig = drbg(seed, k2sig); // Steps B, C, D, E, F, G\n    return sig.toBytes(opts.format);\n  }\n\n  /**\n   * Verifies a signature against message and public key.\n   * Rejects lowS signatures by default: see {@link ECDSAVerifyOpts}.\n   * Implements section 4.1.4 from https://www.secg.org/sec1-v2.pdf:\n   *\n   * ```\n   * verify(r, s, h, P) where\n   *   u1 = hs^-1 mod n\n   *   u2 = rs^-1 mod n\n   *   R = u1\u22C5G + u2\u22C5P\n   *   mod(R.x, n) == r\n   * ```\n   */\n  function verify(\n    signature: Uint8Array,\n    message: Uint8Array,\n    publicKey: Uint8Array,\n    opts: ECDSAVerifyOpts = {}\n  ): boolean {\n    const { lowS, prehash, format } = validateSigOpts(opts, defaultSigOpts);\n    publicKey = abytes(publicKey, undefined, 'publicKey');\n    message = validateMsgAndHash(message, prehash);\n    if (!isBytes(signature as any)) {\n      const end = signature instanceof Signature ? ', use sig.toBytes()' : '';\n      throw new Error('verify expects Uint8Array signature' + end);\n    }\n    validateSigLength(signature, format); // execute this twice because we want loud error\n    try {\n      const sig = Signature.fromBytes(signature, format);\n      const P = Point.fromBytes(publicKey);\n      if (lowS && sig.hasHighS()) return false;\n      const { r, s } = sig;\n      const h = bits2int_modN(message); // mod n, not mod p\n      const is = Fn.inv(s); // s^-1 mod n\n      const u1 = Fn.create(h * is); // u1 = hs^-1 mod n\n      const u2 = Fn.create(r * is); // u2 = rs^-1 mod n\n      const R = Point.BASE.multiplyUnsafe(u1).add(P.multiplyUnsafe(u2)); // u1\u22C5G + u2\u22C5P\n      if (R.is0()) return false;\n      const v = Fn.create(R.x); // v = r.x mod n\n      return v === r;\n    } catch (e) {\n      return false;\n    }\n  }\n\n  function recoverPublicKey(\n    signature: Uint8Array,\n    message: Uint8Array,\n    opts: ECDSARecoverOpts = {}\n  ): Uint8Array {\n    const { prehash } = validateSigOpts(opts, defaultSigOpts);\n    message = validateMsgAndHash(message, prehash);\n    return Signature.fromBytes(signature, 'recovered').recoverPublicKey(message).toBytes();\n  }\n\n  return Object.freeze({\n    keygen,\n    getPublicKey,\n    getSharedSecret,\n    utils,\n    lengths,\n    Point,\n    sign,\n    verify,\n    recoverPublicKey,\n    Signature,\n    hash,\n  }) satisfies Signer;\n}\n", "/**\n * HMAC: RFC2104 message authentication code.\n * @module\n */\nimport { abytes, aexists, ahash, clean, type CHash, type Hash } from './utils.ts';\n\n/** Internal class for HMAC. */\nexport class _HMAC<T extends Hash<T>> implements Hash<_HMAC<T>> {\n  oHash: T;\n  iHash: T;\n  blockLen: number;\n  outputLen: number;\n  private finished = false;\n  private destroyed = false;\n\n  constructor(hash: CHash, key: Uint8Array) {\n    ahash(hash);\n    abytes(key, undefined, 'key');\n    this.iHash = hash.create() as T;\n    if (typeof this.iHash.update !== 'function')\n      throw new Error('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++) 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() as T;\n    // Undo internal XOR && apply outer XOR\n    for (let i = 0; i < pad.length; i++) pad[i] ^= 0x36 ^ 0x5c;\n    this.oHash.update(pad);\n    clean(pad);\n  }\n  update(buf: Uint8Array): this {\n    aexists(this);\n    this.iHash.update(buf);\n    return this;\n  }\n  digestInto(out: Uint8Array): void {\n    aexists(this);\n    abytes(out, this.outputLen, 'output');\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(): Uint8Array {\n    const out = new Uint8Array(this.oHash.outputLen);\n    this.digestInto(out);\n    return out;\n  }\n  _cloneInto(to?: _HMAC<T>): _HMAC<T> {\n    // Create new instance without calling constructor since key already in state and we don't know it.\n    to ||= Object.create(Object.getPrototypeOf(this), {});\n    const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;\n    to = to as this;\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  clone(): _HMAC<T> {\n    return this._cloneInto();\n  }\n  destroy(): void {\n    this.destroyed = true;\n    this.oHash.destroy();\n    this.iHash.destroy();\n  }\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 * @example\n * import { hmac } from '@noble/hashes/hmac';\n * import { sha256 } from '@noble/hashes/sha2';\n * const mac1 = hmac(sha256, 'key', 'message');\n */\nexport const hmac: {\n  (hash: CHash, key: Uint8Array, message: Uint8Array): Uint8Array;\n  create(hash: CHash, key: Uint8Array): _HMAC<any>;\n} = (hash: CHash, key: Uint8Array, message: Uint8Array): Uint8Array =>\n  new _HMAC<any>(hash, key).update(message).digest();\nhmac.create = (hash: CHash, key: Uint8Array) => new _HMAC<any>(hash, key);\n", "/**\n * @module logger\n * @description Logger utility for the application\n */\n\nenum LogLevel {\n  DEBUG,\n  INFO,\n  WARN,\n  ERROR\n}\n\nimport pino from 'pino';\n\n/**\n * Create a logger instance with consistent configuration\n * @param name - Component or module name for the logger\n * @returns Configured pino logger instance\n */\nexport function createLogger(name: string): pino.Logger {\n  return pino({\n    name,\n    level: process.env.LOG_LEVEL || 'info',\n    transport: process.env.NODE_ENV === 'development' ? {\n      target: 'pino-pretty',\n      options: {\n        colorize: true,\n        translateTime: 'HH:MM:ss',\n        ignore: 'pid,hostname',\n      }\n    } : undefined,\n    formatters: {\n      level: (label) => {\n        return { level: label.toUpperCase() };\n      }\n    }\n  });\n}\n\n/**\n * Simple log function for basic logging needs\n * @param message - Message to log\n * @param data - Optional data to include\n */\nexport function log(message: string, data?: unknown): void {\n  console.log(message, data);\n}\n\n/**\n * Default logger instance for the application\n * Includes enhanced error handling and formatting\n */\nexport const logger: pino.Logger = pino({\n  name: 'nostr-crypto-utils',\n  level: process.env.LOG_LEVEL || 'info',\n  transport: process.env.NODE_ENV === 'development' ? {\n    target: 'pino-pretty',\n    options: {\n      colorize: true,\n      translateTime: 'HH:MM:ss',\n      ignore: 'pid,hostname',\n    }\n  } : undefined,\n  formatters: {\n    level: (label) => {\n      return { level: label.toUpperCase() };\n    },\n    log: (obj: Record<string, unknown>) => {\n      // Convert error objects to strings for better logging\n      if (obj && typeof obj === 'object' && 'err' in obj) {\n        const newObj = { ...obj };\n        if (newObj.err instanceof Error) {\n          const err = newObj.err as Error;\n          newObj.err = {\n            message: err.message,\n            stack: err.stack,\n            name: err.name,\n          };\n        }\n        return newObj;\n      }\n      return obj;\n    }\n  }\n});\n\nexport class CustomLogger {\n  private _level: LogLevel;\n\n  constructor(level: LogLevel = LogLevel.INFO) {\n    this._level = level;\n  }\n\n  setLevel(level: LogLevel): void {\n    this._level = level;\n  }\n\n  private _log(level: LogLevel, message: string, context?: Record<string, unknown>): void {\n    if (level >= this._level) {\n      const timestamp = new Date().toISOString();\n      const levelName = LogLevel[level];\n      const contextStr = context ? ` ${JSON.stringify(context)}` : '';\n      console.log(`[${timestamp}] ${levelName}: ${message}${contextStr}`);\n    }\n  }\n\n  debug(message: string, context?: Record<string, unknown>): void {\n    this._log(LogLevel.DEBUG, message, context);\n  }\n\n  info(message: string, context?: Record<string, unknown>): void {\n    this._log(LogLevel.INFO, message, context);\n  }\n\n  warn(message: string, context?: Record<string, unknown>): void {\n    this._log(LogLevel.WARN, message, context);\n  }\n\n  error(message: string | Error | unknown, context?: Record<string, unknown>): void {\n    const errorMessage = message instanceof Error ? message.message : String(message);\n    this._log(LogLevel.ERROR, errorMessage, context);\n  }\n}\n\n// Re-export the Logger type for use in other files\nexport type { Logger } from 'pino';\n", "/**\n * Base64 encoding utilities for Nostr\n * Provides consistent base64 encoding/decoding across all Nostr-related projects\n * Uses browser-compatible APIs (no Node.js Buffer dependency)\n */\n\n/**\n * Convert string to base64\n * @param str String to convert\n * @returns Base64 string\n */\nexport function stringToBase64(str: string): string {\n  const bytes = new TextEncoder().encode(str);\n  return bytesToBase64(bytes);\n}\n\n/**\n * Convert base64 to string\n * @param base64 Base64 string to convert\n * @returns UTF-8 string\n * @throws Error if base64 string is invalid\n */\nexport function base64ToString(base64: string): string {\n  if (!isValidBase64(base64)) {\n    throw new Error('Invalid base64 string');\n  }\n  const bytes = base64ToBytes(base64);\n  return new TextDecoder().decode(bytes);\n}\n\n/**\n * Convert Uint8Array to base64\n * @param buffer Uint8Array to convert\n * @returns Base64 string\n */\nexport function bufferToBase64(buffer: Uint8Array): string {\n  return bytesToBase64(buffer);\n}\n\n/**\n * Convert base64 to Uint8Array\n * @param base64 Base64 string to convert\n * @returns Uint8Array\n * @throws Error if base64 string is invalid\n */\nexport function base64ToBuffer(base64: string): Uint8Array {\n  if (!isValidBase64(base64)) {\n    throw new Error('Invalid base64 string');\n  }\n  return base64ToBytes(base64);\n}\n\n/**\n * Check if string is valid base64\n * @param base64 String to check\n * @returns True if valid base64\n */\nexport function isValidBase64(base64: string): boolean {\n  try {\n    return Boolean(base64.match(/^[A-Za-z0-9+/]*={0,2}$/));\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Convert base64 to URL-safe base64\n * @param base64 Standard base64 string\n * @returns URL-safe base64 string\n */\nexport function toBase64Url(base64: string): string {\n  return base64.replace(/\\+/g, '-').replace(/\\//g, '_').replace(/=+$/, '');\n}\n\n/**\n * Convert URL-safe base64 to standard base64\n * @param base64url URL-safe base64 string\n * @returns Standard base64 string\n */\nexport function fromBase64Url(base64url: string): string {\n  const base64 = base64url.replace(/-/g, '+').replace(/_/g, '/');\n  const padding = '='.repeat((4 - base64.length % 4) % 4);\n  return base64 + padding;\n}\n\n/**\n * Convert hex string to base64\n * @param hex Hex string to convert\n * @returns Base64 string\n * @throws Error if hex string is invalid\n */\nexport function hexToBase64(hex: string): string {\n  if (!hex.match(/^[0-9a-fA-F]*$/)) {\n    throw new Error('Invalid hex string');\n  }\n  const bytes = new Uint8Array(hex.length / 2);\n  for (let i = 0; i < hex.length; i += 2) {\n    bytes[i / 2] = parseInt(hex.substring(i, i + 2), 16);\n  }\n  return bytesToBase64(bytes);\n}\n\n/**\n * Convert base64 to hex string\n * @param base64 Base64 string to convert\n * @returns Hex string\n * @throws Error if base64 string is invalid\n */\nexport function base64ToHex(base64: string): string {\n  if (!isValidBase64(base64)) {\n    throw new Error('Invalid base64 string');\n  }\n  const bytes = base64ToBytes(base64);\n  return Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('');\n}\n\n/**\n * Create base64 string from byte array\n * @param bytes Byte array\n * @returns Base64 string\n */\nexport function bytesToBase64(bytes: Uint8Array): string {\n  let binary = '';\n  for (let i = 0; i < bytes.length; i++) {\n    binary += String.fromCharCode(bytes[i]);\n  }\n  return btoa(binary);\n}\n\n/**\n * Convert base64 to byte array\n * @param base64 Base64 string\n * @returns Byte array\n * @throws Error if base64 string is invalid\n */\nexport function base64ToBytes(base64: string): Uint8Array {\n  if (!isValidBase64(base64)) {\n    throw new Error('Invalid base64 string');\n  }\n  const binary = atob(base64);\n  const bytes = new Uint8Array(binary.length);\n  for (let i = 0; i < binary.length; i++) {\n    bytes[i] = binary.charCodeAt(i);\n  }\n  return bytes;\n}\n\n/**\n * Calculate padded length for base64 string\n * @param dataLength Length of raw data\n * @returns Length of padded base64 string\n */\nexport function calculateBase64Length(dataLength: number): number {\n  return Math.ceil(dataLength / 3) * 4;\n}\n\n/**\n * Remove base64 padding\n * @param base64 Base64 string\n * @returns Base64 string without padding\n */\nexport function removeBase64Padding(base64: string): string {\n  return base64.replace(/=+$/, '');\n}\n\n/**\n * Add base64 padding\n * @param base64 Base64 string without padding\n * @returns Properly padded base64 string\n */\nexport function addBase64Padding(base64: string): string {\n  const padding = '='.repeat((4 - base64.length % 4) % 4);\n  return base64 + padding;\n}\n", "/**\n * @module validation\n * @description Validation utilities for Nostr events, messages, and related data structures.\n * Provides functions to validate events, signatures, filters, and subscriptions according to the Nostr protocol.\n */\n\nimport { \n  NostrEvent, \n  SignedNostrEvent, \n  NostrFilter, \n  NostrSubscription, \n  ValidationResult, \n  PublicKey,\n  NostrMessageType\n} from '../types/index';\n\nimport { logger } from '../utils/logger';\n\nimport { sha256 } from '@noble/hashes/sha2.js';\nimport { bytesToHex } from '@noble/hashes/utils.js';\nimport { schnorr } from '@noble/curves/secp256k1.js';\n\n/**\n * Gets the hex string from a PublicKey or string\n */\nfunction getPublicKeyHex(pubkey: PublicKey | string): string {\n  return typeof pubkey === 'string' ? pubkey : pubkey.hex;\n}\n\nfunction hexToBytes(hex: string): Uint8Array {\n  return new Uint8Array(hex.match(/.{1,2}/g)!.map(byte => parseInt(byte, 16)));\n}\n\n/**\n * Validates a Nostr event ID by checking if it matches the SHA-256 hash of the canonical event serialization.\n * \n * @param {SignedNostrEvent} event - The event to validate\n * @returns {ValidationResult} Object containing validation result and any error message\n * @example\n * ```typescript\n * const result = validateEventId(event);\n * if (!result.isValid) {\n *   console.error(result.error);\n * }\n * ```\n */\nexport function validateEventId(event: SignedNostrEvent): ValidationResult {\n  try {\n    const serialized = JSON.stringify([\n      0,\n      getPublicKeyHex(event.pubkey),\n      event.created_at,\n      event.kind,\n      event.tags,\n      event.content\n    ]);\n    const hash = bytesToHex(sha256(new TextEncoder().encode(serialized)));\n    return {\n      isValid: hash === event.id,\n      error: hash === event.id ? undefined : 'Invalid event ID'\n    };\n  } catch (error) {\n    logger.error({ error }, 'Failed to validate event ID');\n    return {\n      isValid: false,\n      error: 'Failed to validate event ID'\n    };\n  }\n}\n\n/**\n * Validates a Nostr event signature using Schnorr signature verification.\n * \n * @param {SignedNostrEvent} event - The event to validate\n * @returns {ValidationResult} Object containing validation result and any error message\n * @example\n * ```typescript\n * const result = validateEventSignature(event);\n * if (!result.isValid) {\n *   console.error(result.error);\n * }\n * ```\n */\nexport function validateEventSignature(event: SignedNostrEvent): ValidationResult {\n  try {\n    // Verify the signature\n    const serialized = JSON.stringify([\n      0,\n      getPublicKeyHex(event.pubkey),\n      event.created_at,\n      event.kind,\n      event.tags,\n      event.content\n    ]);\n    const hash = sha256(new TextEncoder().encode(serialized));\n    const pubkeyHex = getPublicKeyHex(event.pubkey);\n    const pubkeyBytes = hexToBytes(pubkeyHex);\n    const isValid = schnorr.verify(hexToBytes(event.sig), hash, pubkeyBytes);\n    \n    return {\n      isValid,\n      error: isValid ? undefined : 'Invalid signature'\n    };\n  } catch (error) {\n    logger.error({ error }, 'Failed to validate event signature');\n    return {\n      isValid: false,\n      error: 'Failed to validate event signature'\n    };\n  }\n}\n\n/**\n * Validates a complete Nostr event by checking its structure, timestamps, ID, and signature.\n * \n * @param {SignedNostrEvent} event - The event to validate\n * @returns {ValidationResult} Object containing validation result and any error message\n * @example\n * ```typescript\n * const result = validateEvent(event);\n * if (!result.isValid) {\n *   console.error(result.error);\n * }\n * ```\n */\nexport function validateEvent(event: SignedNostrEvent): ValidationResult {\n  // First validate the event structure\n  const baseValidation = validateEventBase(event);\n  if (!baseValidation.isValid) {\n    return baseValidation;\n  }\n\n  // Then validate the event ID\n  const idValidation = validateEventId(event);\n  if (!idValidation.isValid) {\n    return idValidation;\n  }\n\n  // Finally validate the signature\n  return validateEventSignature(event);\n}\n\n/**\n * Validates a signed Nostr event by checking its structure and signature format.\n * \n * @param {SignedNostrEvent} event - The event to validate\n * @returns {ValidationResult} Object containing validation result and any error message\n * @example\n * ```typescript\n * const result = validateSignedEvent(event);\n * if (!result.isValid) {\n *   console.error(result.error);\n * }\n * ```\n */\nexport function validateSignedEvent(event: SignedNostrEvent): ValidationResult {\n  try {\n    // Check basic event structure\n    const baseValidation = validateEventBase(event);\n    if (!baseValidation.isValid) {\n      return baseValidation;\n    }\n\n    // Get pubkey hex\n    const pubkeyHex = getPublicKeyHex(event.pubkey);\n\n    // Validate pubkey format\n    if (!pubkeyHex || typeof pubkeyHex !== 'string' || pubkeyHex.length !== 64) {\n      return {\n        isValid: false,\n        error: 'Invalid public key format'\n      };\n    }\n\n    // Validate signature format\n    if (!event.sig || typeof event.sig !== 'string' || event.sig.length !== 128) {\n      return {\n        isValid: false,\n        error: 'Invalid signature format'\n      };\n    }\n\n    // Validate ID format\n    if (!event.id || typeof event.id !== 'string' || event.id.length !== 64) {\n      return {\n        isValid: false,\n        error: 'Invalid event ID format'\n      };\n    }\n\n    return { isValid: true };\n  } catch (error) {\n    logger.error({ error }, 'Failed to validate signed event');\n    return {\n      isValid: false,\n      error: 'Failed to validate signed event'\n    };\n  }\n}\n\n/**\n * Validates a Nostr event by checking its structure and fields.\n * @param event - The event to validate\n * @returns Validation result and any error message\n */\nexport function validateEventBase(event: NostrEvent | SignedNostrEvent): ValidationResult {\n  // Check required fields\n  if (!event || typeof event !== 'object') {\n    return { isValid: false, error: 'Invalid event structure' };\n  }\n\n  // Validate kind\n  if (typeof event.kind !== 'number' || event.kind < 0) {\n    return { isValid: false, error: 'Event kind must be a non-negative integer' };\n  }\n\n  // Validate timestamp\n  const now = Math.floor(Date.now() / 1000);\n  if (typeof event.created_at !== 'number' || event.created_at > now + 60) {\n    return { isValid: false, error: 'Event timestamp cannot be in the future' };\n  }\n\n  // Validate content\n  if (typeof event.content !== 'string') {\n    return { isValid: false, error: 'Event content must be a string' };\n  }\n\n  // Validate pubkey format\n  if (!event.pubkey) {\n    return { isValid: false, error: 'Missing public key' };\n  }\n\n  // Get pubkey hex\n  const pubkeyHex = getPublicKeyHex(event.pubkey);\n  if (typeof pubkeyHex !== 'string' || !/^[0-9a-f]{64}$/.test(pubkeyHex)) {\n    return { isValid: false, error: 'Invalid public key format' };\n  }\n\n  // Validate tags\n  if (!Array.isArray(event.tags)) {\n    return { isValid: false, error: 'Event tags must be an array' };\n  }\n\n  for (const tag of event.tags) {\n    if (!Array.isArray(tag)) {\n      return { isValid: false, error: 'Each tag must be an array' };\n    }\n    if (tag.length === 0) {\n      return { isValid: false, error: 'Empty tags are not allowed' };\n    }\n    if (typeof tag[0] !== 'string') {\n      return { isValid: false, error: 'Tag identifier must be a string' };\n    }\n  }\n\n  return { isValid: true };\n}\n\n/**\n * Validates a Nostr filter by checking its structure and fields.\n * \n * @param {NostrFilter} filter - The filter to validate\n * @returns {ValidationResult} Object containing validation result and any error message\n * @example\n * ```typescript\n * const result = validateFilter(filter);\n * if (!result.isValid) {\n *   console.error(result.error);\n * }\n * ```\n */\nexport function validateFilter(filter: NostrFilter): ValidationResult {\n  try {\n    // Validate filter structure\n    if (!filter || typeof filter !== 'object') {\n      return { isValid: false, error: 'Invalid filter structure' };\n    }\n\n    // Validate ids array if present\n    if (filter.ids && (!Array.isArray(filter.ids) || !filter.ids.every(id => typeof id === 'string'))) {\n      return { isValid: false, error: 'Filter ids must be an array of strings' };\n    }\n\n    // Validate authors array if present\n    if (filter.authors && (!Array.isArray(filter.authors) || !filter.authors.every(author => typeof author === 'string'))) {\n      return { isValid: false, error: 'Filter authors must be an array of strings' };\n    }\n\n    // Validate kinds array if present\n    if (filter.kinds) {\n      if (!Array.isArray(filter.kinds)) {\n        return { isValid: false, error: 'Filter kinds must be an array of numbers' };\n      }\n      if (!filter.kinds.every(kind => typeof kind === 'number' && Number.isInteger(kind) && kind >= 0)) {\n        return { isValid: false, error: 'Filter kinds must be non-negative integers' };\n      }\n    }\n\n    // Validate timestamps\n    if (filter.since && typeof filter.since !== 'number') {\n      return { isValid: false, error: 'Filter since must be a number' };\n    }\n    if (filter.until && typeof filter.until !== 'number') {\n      return { isValid: false, error: 'Filter until must be a number' };\n    }\n\n    // Validate limit\n    if (filter.limit && typeof filter.limit !== 'number') {\n      return { isValid: false, error: 'Filter limit must be a number' };\n    }\n\n    // Validate search\n    if (filter.search && typeof filter.search !== 'string') {\n      return { isValid: false, error: 'Filter search must be a string' };\n    }\n\n    return { isValid: true };\n  } catch (error) {\n    logger.error({ error }, 'Failed to validate filter');\n    return { isValid: false, error: 'Failed to validate filter' };\n  }\n}\n\n/**\n * Validates a Nostr subscription by checking its structure and filters.\n * \n * @param {NostrSubscription} subscription - The subscription to validate\n * @returns {ValidationResult} Object containing validation result and any error message\n * @example\n * ```typescript\n * const result = validateSubscription(subscription);\n * if (!result.isValid) {\n *   console.error(result.error);\n * }\n * ```\n */\nexport function validateSubscription(subscription: NostrSubscription): ValidationResult {\n  try {\n    // Validate subscription structure\n    if (!subscription || typeof subscription !== 'object') {\n      return { isValid: false, error: 'Invalid subscription structure' };\n    }\n\n    // Validate subscription ID\n    if (!subscription.id || typeof subscription.id !== 'string') {\n      return { isValid: false, error: 'Subscription must have a string ID' };\n    }\n\n    // Validate filters array\n    if (!Array.isArray(subscription.filters)) {\n      return { isValid: false, error: 'Subscription filters must be an array' };\n    }\n\n    // Validate each filter\n    for (const filter of subscription.filters) {\n      const filterValidation = validateFilter(filter);\n      if (!filterValidation.isValid) {\n        return filterValidation;\n      }\n    }\n\n    return { isValid: true };\n  } catch (error) {\n    logger.error({ error }, 'Failed to validate subscription');\n    return { isValid: false, error: 'Failed to validate subscription' };\n  }\n}\n\n/**\n * Validates a Nostr relay response message.\n * \n * @param {unknown} message - The message to validate\n * @returns {ValidationResult} Object containing validation result and any error message\n * @example\n * ```typescript\n * const result = validateResponse(['EVENT', eventObj]);\n * if (!result.isValid) {\n *   console.error(result.error);\n * }\n * ```\n */\nexport function validateResponse(message: unknown): ValidationResult {\n  // Check if message is an array\n  if (!Array.isArray(message)) {\n    return {\n      isValid: false,\n      error: 'Invalid message format: must be an array'\n    };\n  }\n\n  // Check if message has at least one element\n  if (message.length === 0) {\n    return {\n      isValid: false,\n      error: 'Invalid message format: array is empty'\n    };\n  }\n\n  // Check if first element is a valid message type\n  const type = message[0];\n  if (!Object.values(NostrMessageType).includes(type as NostrMessageType)) {\n    return {\n      isValid: false,\n      error: `Invalid message type: ${type}`\n    };\n  }\n\n  // Type-specific validation\n  switch (type) {\n    case NostrMessageType.EVENT:\n      if (message.length !== 2) {\n        return {\n          isValid: false,\n          error: 'EVENT message must have exactly 2 elements'\n        };\n      }\n      return validateSignedEvent(message[1] as SignedNostrEvent);\n\n    case NostrMessageType.NOTICE:\n      if (message.length !== 2 || typeof message[1] !== 'string') {\n        return {\n          isValid: false,\n          error: 'NOTICE message must have exactly 2 elements with a string message'\n        };\n      }\n      return { isValid: true };\n\n    case NostrMessageType.OK:\n      if (message.length !== 4 || \n          typeof message[1] !== 'string' || \n          typeof message[2] !== 'boolean' || \n          typeof message[3] !== 'string') {\n        return {\n          isValid: false,\n          error: 'OK message must have exactly 4 elements: [type, eventId, success, message]'\n        };\n      }\n      return { isValid: true };\n\n    case NostrMessageType.EOSE:\n      if (message.length !== 2 || typeof message[1] !== 'string') {\n        return {\n          isValid: false,\n          error: 'EOSE message must have exactly 2 elements with a subscription ID'\n        };\n      }\n      return { isValid: true };\n\n    case NostrMessageType.REQ:\n      if (message.length < 2) {\n        return {\n          isValid: false,\n          error: 'REQ message must have at least 2 elements'\n        };\n      }\n      if (typeof message[1] !== 'string') {\n        return {\n          isValid: false,\n          error: 'REQ message must have a string subscription ID'\n        };\n      }\n      // Validate each filter if present\n      for (let i = 2; i < message.length; i++) {\n        const filterResult = validateFilter(message[i] as NostrFilter);\n        if (!filterResult.isValid) {\n          return filterResult;\n        }\n      }\n      return { isValid: true };\n\n    case NostrMessageType.CLOSE:\n      if (message.length !== 2 || typeof message[1] !== 'string') {\n        return {\n          isValid: false,\n          error: 'CLOSE message must have exactly 2 elements with a subscription ID'\n        };\n      }\n      return { isValid: true };\n\n    case NostrMessageType.AUTH:\n      if (message.length !== 2) {\n        return {\n          isValid: false,\n          error: 'AUTH message must have exactly 2 elements'\n        };\n      }\n      return validateSignedEvent(message[1] as SignedNostrEvent);\n\n    default:\n      return {\n        isValid: false,\n        error: `Unsupported message type: ${type}`\n      };\n  }\n}\n", "/**\n * @module event\n * @description Event handling utilities for Nostr\n */\n\nexport { createEvent, serializeEvent, getEventHash } from './creation';\nexport { validateEvent, calculateEventId } from './signing';\n", "/**\n * @module event/creation\n * @description Event creation and serialization utilities for Nostr\n */\n\nimport { sha256 } from '@noble/hashes/sha2.js';\nimport { bytesToHex } from '@noble/hashes/utils.js';\nimport { logger } from '../utils/logger';\nimport type { NostrEvent, NostrEventKind } from '../types/index';\n\n/**\n * Creates a new Nostr event with the specified parameters\n * @param params - Event parameters\n * @returns Created event\n */\nexport function createEvent(params: {\n  kind: NostrEventKind;\n  content: string;\n  tags?: string[][];\n  created_at?: number;\n  pubkey?: string;\n}): NostrEvent {\n  const { \n    kind, \n    content, \n    tags = [], \n    created_at = Math.floor(Date.now() / 1000), \n    pubkey = '' \n  } = params;\n  \n  return {\n    kind,\n    content,\n    tags,\n    created_at,\n    pubkey,\n  };\n}\n\n/**\n * Serializes a Nostr event for signing/hashing (NIP-01)\n * @param event - Event to serialize\n * @returns Serialized event JSON string\n */\nexport function serializeEvent(event: NostrEvent): string {\n  return JSON.stringify([\n    0,\n    event.pubkey,\n    event.created_at,\n    event.kind,\n    event.tags,\n    event.content\n  ]);\n}\n\n/**\n * Calculates the hash of a Nostr event (NIP-01)\n * @param event - Event to hash\n * @returns Event hash in hex format\n */\nexport async function getEventHash(event: NostrEvent): Promise<string> {\n  try {\n    const serialized = serializeEvent(event);\n    const hash = await sha256(new TextEncoder().encode(serialized));\n    return bytesToHex(hash);\n  } catch (error) {\n    logger.error({ error }, 'Failed to get event hash');\n    throw error;\n  }\n}\n", "/**\n * @module event/signing\n * @description Event signing and verification utilities for Nostr\n */\n\nimport { schnorr } from '@noble/curves/secp256k1.js';\nimport { bytesToHex, hexToBytes } from '@noble/hashes/utils.js';\nimport { logger } from '../utils/logger';\nimport { getEventHash } from './creation';\nimport type { NostrEvent, SignedNostrEvent } from '../types';\n\n/**\n * Signs a Nostr event with a private key (NIP-01)\n * @param event - Event to sign\n * @param privateKey - Private key in hex format\n * @returns Signed event\n */\nexport async function signEvent(\n  event: NostrEvent, \n  privateKey: string\n): Promise<SignedNostrEvent> {\n  try {\n    const hash = await getEventHash(event);\n    const sig = schnorr.sign(hexToBytes(hash), hexToBytes(privateKey));\n    \n    return {\n      ...event,\n      id: hash,\n      sig: bytesToHex(sig),\n    };\n  } catch (error) {\n    logger.error({ error }, 'Failed to sign event');\n    throw error;\n  }\n}\n\n/**\n * Verifies the signature of a signed Nostr event (NIP-01)\n * @param event - Event to verify\n * @returns True if signature is valid\n */\nexport function verifySignature(event: SignedNostrEvent): boolean {\n  try {\n    return schnorr.verify(\n      hexToBytes(event.sig),\n      hexToBytes(event.id),\n      hexToBytes(event.pubkey)\n    );\n  } catch (error) {\n    logger.error({ error }, 'Failed to verify signature');\n    return false;\n  }\n}\n\n/**\n * Validates a Nostr event\n * @param event - Event to validate\n * @returns True if event is valid\n */\nexport function validateEvent(event: SignedNostrEvent): boolean {\n  try {\n    // Check required fields\n    if (!event.id || !event.pubkey || !event.sig) {\n      return false;\n    }\n\n    // Verify signature\n    return verifySignature(event);\n  } catch (error) {\n    logger.error({ error }, 'Error validating event');\n    return false;\n  }\n}\n\n/**\n * Calculates the event ID for a Nostr event\n * @param event - Event to calculate ID for\n * @returns Event ID\n */\nexport function calculateEventId(event: NostrEvent): Promise<string> {\n  return getEventHash(event);\n}\n", "/**\n * @module nips/nip-04\n * @description Implementation of NIP-04 (Encrypted Direct Messages)\n * @see https://github.com/nostr-protocol/nips/blob/master/04.md\n */\n\nimport { secp256k1 } from '@noble/curves/secp256k1.js';\nimport { hexToBytes } from '@noble/hashes/utils.js';\nimport { logger } from '../utils/logger';\nimport { bytesToBase64, base64ToBytes } from '../encoding/base64';\nimport type { CryptoSubtle } from '../crypto';\n\n\n// Configure crypto for Node.js and test environments\ndeclare global {\n  interface Window {\n    crypto: CryptoSubtle;\n  }\n  interface Global {\n    crypto: CryptoSubtle;\n  }\n}\n\nconst getCrypto = async (): Promise<CryptoSubtle> => {\n  if (typeof window !== 'undefined' && window.crypto) {\n    return window.crypto;\n  }\n  if (typeof global !== 'undefined' && (global as Global).crypto) {\n    return (global as Global).crypto;\n  }\n  try {\n    const cryptoModule = await import('crypto');\n    if (cryptoModule.webcrypto) {\n      return cryptoModule.webcrypto as CryptoSubtle;\n    }\n  } catch {\n    logger.debug('Node crypto not available');\n  }\n\n  throw new Error('No WebCrypto implementation available');\n};\n\nclass CryptoImplementation {\n  private cryptoInstance: CryptoSubtle | null = null;\n  private initPromise: Promise<void>;\n\n  constructor() {\n    this.initPromise = this.initialize();\n  }\n\n  private async initialize(): Promise<void> {\n    this.cryptoInstance = await getCrypto();\n  }\n\n  private async ensureInitialized(): Promise<CryptoSubtle> {\n    await this.initPromise;\n    if (!this.cryptoInstance) {\n      throw new Error('Crypto implementation not initialized');\n    }\n    return this.cryptoInstance;\n  }\n\n  async getSubtle(): Promise<CryptoSubtle['subtle']> {\n    const crypto = await this.ensureInitialized();\n    return crypto.subtle;\n  }\n\n  async getRandomValues<T extends Uint8Array | Int8Array | Uint16Array | Int16Array | Uint32Array | Int32Array>(array: T): Promise<T> {\n    const crypto = await this.ensureInitialized();\n    return crypto.getRandomValues(array);\n  }\n}\n\nconst cryptoImpl = new CryptoImplementation();\n\ninterface SharedSecret {\n  sharedSecret: Uint8Array;\n}\n\n/**\n * Encrypts a message using NIP-04 encryption\n * @param message - Message to encrypt\n * @param senderPrivKey - Sender's private key\n * @param recipientPubKey - Recipient's public key\n * @returns Encrypted message string\n */\nexport async function encryptMessage(\n  message: string,\n  senderPrivKey: string,\n  recipientPubKey: string\n): Promise<string> {\n  try {\n    if (!message || !senderPrivKey || !recipientPubKey) {\n      throw new Error('Invalid input parameters');\n    }\n\n    // Validate keys\n    if (!/^[0-9a-f]{64}$/i.test(senderPrivKey)) {\n      throw new Error('Invalid private key format');\n    }\n\n    // Ensure public key is in correct format\n    const pubKeyHex = recipientPubKey.startsWith('02') || recipientPubKey.startsWith('03') \n      ? recipientPubKey \n      : '02' + recipientPubKey;\n\n    // Generate shared secret\n    const sharedPoint = secp256k1.getSharedSecret(hexToBytes(senderPrivKey), hexToBytes(pubKeyHex));\n    const sharedX = sharedPoint.slice(1, 33); // Use only x-coordinate\n\n    // Import key for AES\n    const sharedKey = await (await cryptoImpl.getSubtle()).importKey(\n      'raw',\n      sharedX.buffer,\n      { name: 'AES-CBC', length: 256 },\n      false,\n      ['encrypt']\n    );\n\n    // Zero shared secret material now that AES key is imported\n    sharedX.fill(0);\n    sharedPoint.fill(0);\n\n    // Generate IV and encrypt\n    const iv = new Uint8Array(16);\n    await cryptoImpl.getRandomValues(iv);\n\n    const encoded = new TextEncoder().encode(message);\n    const encrypted = await (await cryptoImpl.getSubtle()).encrypt(\n      { name: 'AES-CBC', iv },\n      sharedKey,\n      encoded.buffer\n    );\n\n    // NIP-04 standard format: base64(ciphertext) + \"?iv=\" + base64(iv)\n    const ciphertextBase64 = bytesToBase64(new Uint8Array(encrypted));\n    const ivBase64 = bytesToBase64(iv);\n\n    return ciphertextBase64 + '?iv=' + ivBase64;\n  } catch (error) {\n    logger.error({ error }, 'Failed to encrypt message');\n    throw error;\n  }\n}\n\n/**\n * Decrypts a message using NIP-04 decryption\n * @param encryptedMessage - Encrypted message string\n * @param recipientPrivKey - Recipient's private key\n * @param senderPubKey - Sender's public key\n * @returns Decrypted message string\n */\nexport async function decryptMessage(\n  encryptedMessage: string,\n  recipientPrivKey: string,\n  senderPubKey: string\n): Promise<string> {\n  try {\n    if (!encryptedMessage || !recipientPrivKey || !senderPubKey) {\n      throw new Error('Invalid input parameters');\n    }\n\n    // Validate keys\n    if (!/^[0-9a-f]{64}$/i.test(recipientPrivKey)) {\n      throw new Error('Invalid private key format');\n    }\n\n    // Ensure public key is in correct format\n    const pubKeyHex = senderPubKey.startsWith('02') || senderPubKey.startsWith('03')\n      ? senderPubKey\n      : '02' + senderPubKey;\n\n    // Generate shared secret\n    const sharedPoint = secp256k1.getSharedSecret(hexToBytes(recipientPrivKey), hexToBytes(pubKeyHex));\n    const sharedX = sharedPoint.slice(1, 33); // Use only x-coordinate\n\n    // Import key for AES\n    const sharedKey = await (await cryptoImpl.getSubtle()).importKey(\n      'raw',\n      sharedX.buffer,\n      { name: 'AES-CBC', length: 256 },\n      false,\n      ['decrypt']\n    );\n\n    // Zero shared secret material now that AES key is imported\n    sharedX.fill(0);\n    sharedPoint.fill(0);\n\n    // Parse NIP-04 standard format: base64(ciphertext) + \"?iv=\" + base64(iv)\n    // Also support legacy hex format (iv + ciphertext concatenated) as fallback\n    let iv: Uint8Array;\n    let ciphertext: Uint8Array;\n\n    if (encryptedMessage.includes('?iv=')) {\n      // NIP-04 standard format\n      const [ciphertextBase64, ivBase64] = encryptedMessage.split('?iv=');\n      ciphertext = base64ToBytes(ciphertextBase64);\n      iv = base64ToBytes(ivBase64);\n    } else {\n      // Legacy hex format fallback: first 16 bytes are IV, rest is ciphertext\n      const encrypted = hexToBytes(encryptedMessage);\n      iv = encrypted.slice(0, 16);\n      ciphertext = encrypted.slice(16);\n    }\n\n    // Decrypt\n    const decrypted = await (await cryptoImpl.getSubtle()).decrypt(\n      { name: 'AES-CBC', iv },\n      sharedKey,\n      ciphertext.buffer as ArrayBuffer\n    );\n\n    return new TextDecoder().decode(decrypted);\n  } catch (error) {\n    logger.error({ error }, 'Failed to decrypt message');\n    throw error;\n  }\n}\n\n/**\n * Generates a shared secret for NIP-04 encryption\n * @param privateKey - Private key\n * @param publicKey - Public key\n * @returns Shared secret\n */\nexport function generateSharedSecret(\n  privateKey: string,\n  publicKey: string\n): SharedSecret {\n  try {\n    if (!privateKey || !publicKey) {\n      throw new Error('Invalid input parameters');\n    }\n\n    // Validate keys\n    if (!/^[0-9a-f]{64}$/i.test(privateKey)) {\n      throw new Error('Invalid private key format');\n    }\n\n    // Ensure public key is in correct format\n    const pubKeyHex = publicKey.startsWith('02') || publicKey.startsWith('03')\n      ? publicKey\n      : '02' + publicKey;\n\n    // Generate shared secret\n    const sharedPoint = secp256k1.getSharedSecret(hexToBytes(privateKey), hexToBytes(pubKeyHex));\n    return { sharedSecret: sharedPoint.slice(1, 33) }; // Return only x-coordinate\n  } catch (error) {\n    logger.error({ error }, 'Failed to generate shared secret');\n    throw error;\n  }\n}\n\nexport { generateSharedSecret as computeSharedSecret };\n", "/**\n * @module nips/nip-01\n * @description Implementation of NIP-01: Basic Protocol Flow Description\n * @see https://github.com/nostr-protocol/nips/blob/master/01.md\n */\n\nimport { schnorr } from '@noble/curves/secp256k1.js';\nimport { sha256 } from '@noble/hashes/sha2.js';\nimport { bytesToHex, hexToBytes } from '@noble/hashes/utils.js';\nimport { logger } from '../utils/logger';\nimport type { NostrEvent, SignedNostrEvent } from '../types';\n\n/**\n * Creates a new Nostr event with the specified parameters (NIP-01)\n * @param params - Event parameters\n * @returns Created event\n */\nexport function createEvent(params: {\n  kind: number;\n  content: string;\n  tags?: string[][];\n  created_at?: number;\n  pubkey?: string;\n}): NostrEvent {\n  const { \n    kind, \n    content, \n    tags = [], \n    created_at = Math.floor(Date.now() / 1000), \n    pubkey = '' \n  } = params;\n  \n  return {\n    kind,\n    content,\n    tags,\n    created_at,\n    pubkey,\n  };\n}\n\n/**\n * Serializes a Nostr event for signing/hashing (NIP-01)\n * @param event - Event to serialize\n * @returns Serialized event JSON string\n */\nexport function serializeEvent(event: NostrEvent): string {\n  return JSON.stringify([\n    0,\n    event.pubkey,\n    event.created_at,\n    event.kind,\n    event.tags,\n    event.content\n  ]);\n}\n\n/**\n * Calculates the hash of a Nostr event (NIP-01)\n * @param event - Event to hash\n * @returns Event hash in hex format\n */\nexport async function getEventHash(event: NostrEvent): Promise<string> {\n  try {\n    const serialized = serializeEvent(event);\n    const hash = sha256(new TextEncoder().encode(serialized));\n    return bytesToHex(hash);\n  } catch (error) {\n    logger.error({ error }, 'Failed to get event hash');\n    throw error;\n  }\n}\n\n/**\n * Signs a Nostr event with a private key (NIP-01)\n * @param event - Event to sign\n * @param privateKey - Private key in hex format\n * @returns Signed event\n */\nexport async function signEvent(\n  event: NostrEvent, \n  privateKey: string\n): Promise<SignedNostrEvent> {\n  try {\n    const hash = await getEventHash(event);\n    const sig = schnorr.sign(hexToBytes(hash), hexToBytes(privateKey));\n    \n    return {\n      ...event,\n      id: hash,\n      sig: bytesToHex(sig),\n    };\n  } catch (error) {\n    logger.error({ error }, 'Failed to sign event');\n    throw error;\n  }\n}\n\n/**\n * Verifies the signature of a signed Nostr event (NIP-01)\n * @param event - Event to verify\n * @returns True if signature is valid\n */\nexport function verifySignature(event: SignedNostrEvent): boolean {\n  try {\n    // Verify event ID\n    const expectedId = calculateEventId(event);\n    if (event.id !== expectedId) {\n      return false;\n    }\n\n    // Verify signature\n    return schnorr.verify(\n      hexToBytes(event.sig),\n      hexToBytes(event.id),\n      hexToBytes(event.pubkey)\n    );\n  } catch (error) {\n    logger.error({ error }, 'Failed to verify signature');\n    return false;\n  }\n}\n\n/**\n * Calculates the event ID according to NIP-01\n * @param event - Event to calculate ID for\n * @returns Event ID in hex format\n */\nexport function calculateEventId(event: NostrEvent): string {\n  const serialized = serializeEvent(event);\n  const hash = sha256(new TextEncoder().encode(serialized));\n  return bytesToHex(hash);\n}\n\n/**\n * Validates a Nostr event structure (NIP-01)\n * @param event - Event to validate\n * @returns True if event structure is valid\n */\nexport function validateEvent(event: NostrEvent): boolean {\n  try {\n    if (typeof event.content !== 'string') return false;\n    if (typeof event.created_at !== 'number') return false;\n    if (typeof event.kind !== 'number') return false;\n    if (!Array.isArray(event.tags)) return false;\n    if (typeof event.pubkey !== 'string') return false;\n    \n    // Validate tags structure\n    for (const tag of event.tags) {\n      if (!Array.isArray(tag)) return false;\n      if (tag.length === 0) return false;\n      if (typeof tag[0] !== 'string') return false;\n    }\n    \n    return true;\n  } catch (error) {\n    logger.error({ error }, 'Failed to validate event');\n    return false;\n  }\n}\n", "/**\n * NIP-19: bech32-encoded entities\n * Implements encoding and decoding of Nostr entities using bech32 format\n */\n\nimport { bech32 } from 'bech32';\nimport { Buffer } from 'buffer';\n\nexport type Nip19DataType = 'npub' | 'nsec' | 'note' | 'nprofile' | 'nevent' | 'naddr' | 'nrelay';\n\nconst VALID_PREFIXES: Nip19DataType[] = ['npub', 'nsec', 'note', 'nprofile', 'nevent', 'naddr', 'nrelay'];\n\nexport interface Nip19Data {\n  type: Nip19DataType;\n  data: string;\n  relays?: string[];\n  author?: string;\n  kind?: number;\n  identifier?: string; // For naddr\n}\n\n// TLV type constants\nconst TLV_TYPES = {\n  SPECIAL: 0,   // Main data (hex)\n  RELAY: 1,     // Relay URL (utf8)\n  AUTHOR: 2,    // Author pubkey (hex)\n  KIND: 3,      // Event kind (uint8)\n  IDENTIFIER: 4 // Identifier (utf8)\n} as const;\n\n/**\n * Encode a public key as an npub\n * @param pubkey Public key in hex format\n * @returns bech32-encoded npub string\n * @throws {Error} If pubkey is invalid\n */\nexport function npubEncode(pubkey: string): string {\n  validateHexString(pubkey, 64);\n  const data = Buffer.from(pubkey, 'hex');\n  const words = bech32.toWords(data);\n  return bech32.encode('npub', words, 1000);\n}\n\n/**\n * Encode a private key as an nsec\n * @param privkey Private key in hex format\n * @returns bech32-encoded nsec string\n * @throws {Error} If privkey is invalid\n */\nexport function nsecEncode(privkey: string): string {\n  validateHexString(privkey, 64);\n  const data = Buffer.from(privkey, 'hex');\n  const words = bech32.toWords(data);\n  return bech32.encode('nsec', words, 1000);\n}\n\n/**\n * Encode an event ID as a note\n * @param eventId Event ID in hex format\n * @returns bech32-encoded note string\n * @throws {Error} If eventId is invalid\n */\nexport function noteEncode(eventId: string): string {\n  validateHexString(eventId, 64);\n  const data = Buffer.from(eventId, 'hex');\n  const words = bech32.toWords(data);\n  return bech32.encode('note', words, 1000);\n}\n\n/**\n * Encode profile information\n * @param pubkey Public key in hex format\n * @param relays Optional relay URLs\n * @returns bech32-encoded nprofile string\n * @throws {Error} If pubkey is invalid or relays are malformed\n */\nexport function nprofileEncode(pubkey: string, relays?: string[]): string {\n  validateHexString(pubkey, 64);\n  if (relays) {\n    relays.forEach(validateRelayUrl);\n  }\n\n  const data = encodeTLV({\n    type: 'nprofile',\n    data: pubkey,\n    relays\n  });\n  return bech32.encode('nprofile', data, 1000);\n}\n\n/**\n * Encode event information\n * @param eventId Event ID in hex format\n * @param relays Optional relay URLs\n * @param author Optional author public key\n * @param kind Optional event kind\n * @returns bech32-encoded nevent string\n * @throws {Error} If parameters are invalid\n */\nexport function neventEncode(\n  eventId: string,\n  relays?: string[],\n  author?: string,\n  kind?: number\n): string {\n  validateHexString(eventId, 64);\n  if (relays) {\n    relays.forEach(validateRelayUrl);\n  }\n  if (author) {\n    validateHexString(author, 64);\n  }\n  if (kind !== undefined && !Number.isInteger(kind)) {\n    throw new Error('Invalid event kind');\n  }\n\n  const data = encodeTLV({\n    type: 'nevent',\n    data: eventId,\n    relays,\n    author,\n    kind\n  });\n  return bech32.encode('nevent', data, 1000);\n}\n\n/**\n * Encode an address (NIP-33)\n * @param pubkey Author's public key\n * @param kind Event kind\n * @param identifier String identifier\n * @param relays Optional relay URLs\n * @returns bech32-encoded naddr string\n * @throws {Error} If parameters are invalid\n */\nexport function naddrEncode(\n  pubkey: string,\n  kind: number,\n  identifier: string,\n  relays?: string[]\n): string {\n  validateHexString(pubkey, 64);\n  if (!Number.isInteger(kind)) {\n    throw new Error('Invalid event kind');\n  }\n  if (!identifier) {\n    throw new Error('Identifier is required');\n  }\n  if (relays) {\n    relays.forEach(validateRelayUrl);\n  }\n\n  const data = encodeTLV({\n    type: 'naddr',\n    data: pubkey,\n    kind,\n    identifier,\n    relays\n  });\n  return bech32.encode('naddr', data, 1000);\n}\n\n/**\n * Encode a relay URL\n * @param url Relay URL\n * @returns bech32-encoded nrelay string\n * @throws {Error} If URL is invalid\n */\nexport function nrelayEncode(url: string): string {\n  validateRelayUrl(url);\n  const data = Buffer.from(url, 'utf8');\n  const words = bech32.toWords(data);\n  return bech32.encode('nrelay', words, 1000);\n}\n\n/**\n * Decode a bech32-encoded Nostr entity\n * @param str bech32-encoded string\n * @returns Decoded data with type and metadata\n * @throws {Error} If string is invalid or malformed\n */\nexport function decode(str: string): Nip19Data {\n  if (!str.includes('1')) {\n    throw new Error('Invalid bech32 string');\n  }\n\n  const prefix = str.split('1')[0].toLowerCase();\n  if (!VALID_PREFIXES.includes(prefix as Nip19DataType)) {\n    throw new Error('Unknown prefix');\n  }\n\n  try {\n    const decoded = bech32.decode(str, 1000);\n    const data = Buffer.from(bech32.fromWords(decoded.words));\n\n    // For nrelay type\n    let url: string;\n    // For TLV types\n    let decodedData: Nip19Data;\n\n    switch (decoded.prefix) {\n      case 'npub':\n      case 'nsec':\n      case 'note':\n        validateHexString(data.toString('hex'), 64);\n        return {\n          type: decoded.prefix as Nip19DataType,\n          data: data.toString('hex')\n        };\n      case 'nrelay':\n        url = data.toString('utf8');\n        validateRelayUrl(url);\n        return {\n          type: 'nrelay',\n          data: url\n        };\n      case 'nprofile':\n      case 'nevent':\n      case 'naddr':\n        decodedData = decodeTLV(decoded.prefix as Nip19DataType, data);\n        return decodedData;\n      default:\n        throw new Error('Unknown prefix');\n    }\n  } catch (error: unknown) {\n    if (error instanceof Error) {\n      throw error;\n    }\n    throw new Error('Invalid bech32 string');\n  }\n}\n\n// Helper functions\n\nfunction validateHexString(str: string, length?: number): void {\n  if (!/^[0-9a-fA-F]+$/.test(str)) {\n    throw new Error('Invalid hex string');\n  }\n  if (length && str.length !== length) {\n    throw new Error(`Invalid hex string length (expected ${length})`);\n  }\n}\n\nfunction validateRelayUrl(url: string): void {\n  try {\n    const parsed = new URL(url);\n    if (!['ws:', 'wss:'].includes(parsed.protocol)) {\n      throw new Error('Invalid relay URL protocol');\n    }\n  } catch {\n    throw new Error('Invalid relay URL');\n  }\n}\n\nfunction encodeTLV(data: Nip19Data): number[] {\n  const result: number[] = [];\n  \n  // Special (type 0): main data\n  const bytes = Buffer.from(data.data, 'hex');\n  result.push(TLV_TYPES.SPECIAL, bytes.length);\n  result.push(...bytes);\n\n  // Relay (type 1): relay URLs\n  if (data.relays?.length) {\n    for (const relay of data.relays) {\n      const relayBytes = Buffer.from(relay, 'utf8');\n      result.push(TLV_TYPES.RELAY, relayBytes.length);\n      result.push(...relayBytes);\n    }\n  }\n\n  // Author (type 2): author pubkey\n  if (data.author) {\n    const authorBytes = Buffer.from(data.author, 'hex');\n    result.push(TLV_TYPES.AUTHOR, authorBytes.length);\n    result.push(...authorBytes);\n  }\n\n  // Kind (type 3): event kind\n  if (data.kind !== undefined) {\n    const kindBytes = Buffer.alloc(4);\n    kindBytes.writeUInt32BE(data.kind);\n    result.push(TLV_TYPES.KIND, kindBytes.length);\n    result.push(...kindBytes);\n  }\n\n  // Identifier (type 4): for naddr\n  if (data.identifier) {\n    const identifierBytes = Buffer.from(data.identifier, 'utf8');\n    result.push(TLV_TYPES.IDENTIFIER, identifierBytes.length);\n    result.push(...identifierBytes);\n  }\n\n  return bech32.toWords(Buffer.from(result));\n}\n\nfunction decodeTLV(prefix: Nip19DataType, data: Buffer): Nip19Data {\n  const result: Nip19Data = {\n    type: prefix,\n    data: '',\n    relays: []\n  };\n\n  let i = 0;\n  // For relay type\n  let relay: string;\n\n  while (i < data.length) {\n    const type = data[i];\n    const length = data[i + 1];\n    \n    if (i + 2 + length > data.length) {\n      throw new Error('Invalid TLV data');\n    }\n    \n    const value = data.slice(i + 2, i + 2 + length);\n\n    switch (type) {\n      case TLV_TYPES.SPECIAL:\n        result.data = value.toString('hex');\n        validateHexString(result.data, 64);\n        break;\n      case TLV_TYPES.RELAY:\n        relay = value.toString('utf8');\n        validateRelayUrl(relay);\n        result.relays = result.relays || [];\n        result.relays.push(relay);\n        break;\n      case TLV_TYPES.AUTHOR:\n        result.author = value.toString('hex');\n        validateHexString(result.author, 64);\n        break;\n      case TLV_TYPES.KIND:\n        result.kind = value.readUInt32BE();\n        break;\n      case TLV_TYPES.IDENTIFIER:\n        result.identifier = value.toString('utf8');\n        break;\n      default:\n        // Skip unknown TLV types\n        break;\n    }\n\n    i += 2 + length;\n  }\n\n  return result;\n}\n", "/**\n * NIP-26: Delegated Event Signing\n * Implements delegation of event signing capabilities\n */\n\nimport { sha256 } from '@noble/hashes/sha2.js';\nimport { NostrEvent } from '../types';\nimport { signSchnorr, verifySchnorrSignature } from '../crypto';\nimport { bytesToHex, hexToBytes } from '@noble/hashes/utils.js';\nimport { schnorr } from '@noble/curves/secp256k1.js';\n\nexport interface DelegationConditions {\n  kind?: number;\n  since?: number;\n  until?: number;\n}\n\nexport interface Delegation {\n  delegator: string;\n  delegatee: string;\n  conditions: DelegationConditions;\n  token: string;\n}\n\n/**\n * Create a delegation token\n * @param delegatorPrivateKey Delegator's private key (used for signing only, never returned)\n * @param delegatee Delegatee's public key\n * @param conditions Delegation conditions\n * @returns Delegation token (delegator field contains the PUBLIC key, not the private key)\n */\nexport function createDelegation(\n  delegatorPrivateKey: string,\n  delegatee: string,\n  conditions: DelegationConditions\n): Delegation {\n  const conditionsString = serializeConditions(conditions);\n  const token = signDelegation(delegatorPrivateKey, delegatee, conditionsString);\n\n  // Derive the public key from the private key \u2014 NEVER return the private key\n  const delegatorPublicKey = bytesToHex(schnorr.getPublicKey(hexToBytes(delegatorPrivateKey)));\n\n  return {\n    delegator: delegatorPublicKey,\n    delegatee,\n    conditions,\n    token\n  };\n}\n\n/**\n * Verify a delegation token\n * @param delegation Delegation to verify\n * @returns True if valid, false otherwise\n */\nexport async function verifyDelegation(delegation: Delegation): Promise<boolean> {\n  const conditionsString = serializeConditions(delegation.conditions);\n  return await verifyDelegationSignature(\n    delegation.delegator,\n    delegation.delegatee,\n    conditionsString,\n    delegation.token\n  );\n}\n\n/**\n * Check if an event meets delegation conditions\n * @param event Event to check\n * @param conditions Delegation conditions\n * @returns True if conditions are met\n */\nexport function checkDelegationConditions(\n  event: NostrEvent,\n  conditions: DelegationConditions\n): boolean {\n  if (conditions.kind !== undefined && event.kind !== conditions.kind) {\n    return false;\n  }\n\n  if (conditions.since !== undefined && event.created_at < conditions.since) {\n    return false;\n  }\n\n  if (conditions.until !== undefined && event.created_at > conditions.until) {\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Add delegation tag to an event\n * @param event Event to add delegation to\n * @param delegation Delegation to add\n * @returns Updated event\n */\nexport function addDelegationTag(\n  event: NostrEvent,\n  delegation: Delegation\n): NostrEvent {\n  const tag = [\n    'delegation',\n    delegation.delegator,\n    serializeConditions(delegation.conditions),\n    delegation.token\n  ];\n\n  return {\n    ...event,\n    tags: [...event.tags, tag]\n  };\n}\n\n/**\n * Extract delegation from an event\n * @param event Event to extract delegation from\n * @returns Delegation or null if not found\n */\nexport function extractDelegation(event: NostrEvent): Delegation | null {\n  const tag = event.tags.find(t => t[0] === 'delegation');\n  if (!tag || tag.length !== 4) {\n    return null;\n  }\n\n  return {\n    delegator: tag[1],\n    delegatee: event.pubkey,\n    conditions: parseConditions(tag[2]),\n    token: tag[3]\n  };\n}\n\n// Helper functions\nfunction serializeConditions(conditions: DelegationConditions): string {\n  const parts: string[] = [];\n\n  if (conditions.kind !== undefined) {\n    parts.push(`kind=${conditions.kind}`);\n  }\n  if (conditions.since !== undefined) {\n    parts.push(`created_at>${conditions.since}`);\n  }\n  if (conditions.until !== undefined) {\n    parts.push(`created_at<${conditions.until}`);\n  }\n\n  return parts.join('&');\n}\n\nfunction parseConditions(conditionsString: string): DelegationConditions {\n  const conditions: DelegationConditions = {};\n  const parts = conditionsString.split('&');\n\n  for (const part of parts) {\n    if (part.startsWith('kind=')) {\n      conditions.kind = parseInt(part.slice(5));\n    } else if (part.startsWith('created_at>')) {\n      conditions.since = parseInt(part.slice(11));\n    } else if (part.startsWith('created_at<')) {\n      conditions.until = parseInt(part.slice(11));\n    }\n  }\n\n  return conditions;\n}\n\nfunction signDelegation(\n  delegator: string,\n  delegatee: string,\n  conditions: string\n): string {\n  const message = `nostr:delegation:${delegatee}:${conditions}`;\n  const hash = sha256(new TextEncoder().encode(message));\n  const signature = signSchnorr(hash, hexToBytes(delegator));\n  return bytesToHex(signature);\n}\n\nasync function verifyDelegationSignature(\n  delegator: string,\n  delegatee: string,\n  conditions: string,\n  signature: string\n): Promise<boolean> {\n  const msgHash = sha256(new TextEncoder().encode(`nostr:delegation:${delegatee}:${conditions}`));\n\n  return verifySchnorrSignature(hexToBytes(signature), msgHash, hexToBytes(delegator));\n}\n", "/**\n * @module nips/nip-44\n * @description Implementation of NIP-44 (Versioned Encrypted Payloads)\n * @see https://github.com/nostr-protocol/nips/blob/master/44.md\n */\n\nimport { chacha20 } from '@noble/ciphers/chacha.js';\nimport { equalBytes } from '@noble/ciphers/utils.js';\nimport { secp256k1 } from '@noble/curves/secp256k1.js';\nimport { extract as hkdf_extract, expand as hkdf_expand } from '@noble/hashes/hkdf.js';\nimport { hmac } from '@noble/hashes/hmac.js';\nimport { sha256 } from '@noble/hashes/sha2.js';\nimport { concatBytes, hexToBytes, randomBytes } from '@noble/hashes/utils.js';\nimport { base64 } from '@scure/base';\n\nconst utf8Encoder = new TextEncoder();\nconst utf8Decoder = new TextDecoder();\n\nconst minPlaintextSize = 1;\nconst maxPlaintextSize = 65535;\n\n/**\n * Calculate padded length for NIP-44 message padding\n */\nfunction calcPaddedLen(len: number): number {\n  if (!Number.isSafeInteger(len) || len < 1) throw new Error('expected positive integer');\n  if (len <= 32) return 32;\n  const nextPower = 1 << (Math.floor(Math.log2(len - 1)) + 1);\n  const chunk = nextPower <= 256 ? 32 : nextPower / 8;\n  return chunk * (Math.floor((len - 1) / chunk) + 1);\n}\n\n/**\n * Pad plaintext per NIP-44 spec\n */\nfunction pad(plaintext: string): Uint8Array {\n  const unpadded = utf8Encoder.encode(plaintext);\n  const unpaddedLen = unpadded.length;\n  if (unpaddedLen < minPlaintextSize || unpaddedLen > maxPlaintextSize)\n    throw new Error('invalid plaintext length: must be between 1 and 65535 bytes');\n  const prefix = new Uint8Array(2);\n  new DataView(prefix.buffer).setUint16(0, unpaddedLen, false); // big-endian\n  const suffix = new Uint8Array(calcPaddedLen(unpaddedLen) - unpaddedLen);\n  return concatBytes(prefix, unpadded, suffix);\n}\n\n/**\n * Unpad decrypted message per NIP-44 spec\n */\nfunction unpad(padded: Uint8Array): string {\n  const unpaddedLen = new DataView(padded.buffer, padded.byteOffset).getUint16(0, false);\n  const unpadded = padded.subarray(2, 2 + unpaddedLen);\n  if (\n    unpaddedLen < minPlaintextSize ||\n    unpaddedLen > maxPlaintextSize ||\n    unpadded.length !== unpaddedLen ||\n    padded.length !== 2 + calcPaddedLen(unpaddedLen)\n  ) {\n    throw new Error('invalid padding');\n  }\n  return utf8Decoder.decode(unpadded);\n}\n\n/**\n * Derive conversation key from private key and public key using ECDH + HKDF\n */\nfunction getConversationKey(privkeyA: Uint8Array, pubkeyB: string): Uint8Array {\n  const sharedPoint = secp256k1.getSharedSecret(privkeyA, hexToBytes('02' + pubkeyB));\n  const sharedX = sharedPoint.subarray(1, 33);\n  return hkdf_extract(sha256, sharedX, utf8Encoder.encode('nip44-v2'));\n}\n\n/**\n * Derive message keys (chacha key, chacha nonce, hmac key) from conversation key and nonce\n */\nfunction getMessageKeys(conversationKey: Uint8Array, nonce: Uint8Array): {\n  chacha_key: Uint8Array;\n  chacha_nonce: Uint8Array;\n  hmac_key: Uint8Array;\n} {\n  const keys = hkdf_expand(sha256, conversationKey, nonce, 76);\n  return {\n    chacha_key: keys.subarray(0, 32),\n    chacha_nonce: keys.subarray(32, 44),\n    hmac_key: keys.subarray(44, 76),\n  };\n}\n\n/**\n * Encrypt plaintext using NIP-44 v2\n * @param plaintext - The message to encrypt\n * @param conversationKey - 32-byte conversation key from getConversationKey\n * @param nonce - Optional 32-byte nonce (random if not provided)\n * @returns Base64-encoded encrypted payload\n */\nfunction encrypt(plaintext: string, conversationKey: Uint8Array, nonce: Uint8Array = randomBytes(32)): string {\n  const { chacha_key, chacha_nonce, hmac_key } = getMessageKeys(conversationKey, nonce);\n  const padded = pad(plaintext);\n  const ciphertext = chacha20(chacha_key, chacha_nonce, padded);\n  const mac = hmac(sha256, hmac_key, concatBytes(nonce, ciphertext));\n  return base64.encode(concatBytes(new Uint8Array([2]), nonce, ciphertext, mac));\n}\n\n/**\n * Decrypt a NIP-44 v2 payload\n * @param payload - Base64-encoded encrypted payload\n * @param conversationKey - 32-byte conversation key from getConversationKey\n * @returns Decrypted plaintext string\n */\nfunction decrypt(payload: string, conversationKey: Uint8Array): string {\n  const data = base64.decode(payload);\n  const version = data[0];\n  if (version !== 2) throw new Error(`unknown encryption version: ${version}`);\n  if (data.length < 99 || data.length > 65603) throw new Error('invalid payload size');\n  const nonce = data.subarray(1, 33);\n  const ciphertext = data.subarray(33, data.length - 32);\n  const mac = data.subarray(data.length - 32);\n  const { chacha_key, chacha_nonce, hmac_key } = getMessageKeys(conversationKey, nonce);\n  const expectedMac = hmac(sha256, hmac_key, concatBytes(nonce, ciphertext));\n  if (!equalBytes(mac, expectedMac)) throw new Error('invalid MAC');\n  const padded = chacha20(chacha_key, chacha_nonce, ciphertext);\n  return unpad(padded);\n}\n\n/**\n * v2 API object matching nostr-tools shape for compatibility\n */\nexport const v2 = {\n  utils: {\n    getConversationKey,\n    calcPaddedLen,\n  },\n  encrypt,\n  decrypt,\n};\n\nexport { getConversationKey, encrypt, decrypt, calcPaddedLen };\n", "/**\n * ChaCha stream cipher, released\n * in 2008. Developed after Salsa20, ChaCha aims to increase diffusion per round.\n * It was standardized in [RFC 8439](https://www.rfc-editor.org/rfc/rfc8439) and\n * is now used in TLS 1.3.\n *\n * [XChaCha20](https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-xchacha)\n * extended-nonce variant is also provided. Similar to XSalsa, it's safe to use with\n * randomly-generated nonces.\n *\n * Check out [PDF](http://cr.yp.to/chacha/chacha-20080128.pdf) and\n * [wiki](https://en.wikipedia.org/wiki/Salsa20) and\n * [website](https://cr.yp.to/chacha.html).\n *\n * @module\n */\nimport { type XorPRG, createCipher, createPRG, rotl } from './_arx.ts';\nimport { poly1305 } from './_poly1305.ts';\nimport {\n  type ARXCipher,\n  type CipherWithOutput,\n  type XorStream,\n  abytes,\n  clean,\n  equalBytes,\n  getOutput,\n  u64Lengths,\n  wrapCipher,\n} from './utils.ts';\n\n/**\n * ChaCha core function. It is implemented twice:\n * 1. Simple loop (chachaCore_small, hchacha_small)\n * 2. Unrolled loop (chachaCore, hchacha) - 4x faster, but larger & harder to read\n * The specific implementation is selected in `createCipher` below.\n */\n\n/** quarter-round */\n// prettier-ignore\nfunction chachaQR(x: Uint32Array, a: number, b: number, c: number, d: number) {\n  x[a] = (x[a] + x[b]) | 0; x[d] = rotl(x[d] ^ x[a], 16);\n  x[c] = (x[c] + x[d]) | 0; x[b] = rotl(x[b] ^ x[c], 12);\n  x[a] = (x[a] + x[b]) | 0; x[d] = rotl(x[d] ^ x[a], 8);\n  x[c] = (x[c] + x[d]) | 0; x[b] = rotl(x[b] ^ x[c], 7);\n}\n\n/** single round */\nfunction chachaRound(x: Uint32Array, rounds = 20) {\n  for (let r = 0; r < rounds; r += 2) {\n    chachaQR(x, 0, 4, 8, 12);\n    chachaQR(x, 1, 5, 9, 13);\n    chachaQR(x, 2, 6, 10, 14);\n    chachaQR(x, 3, 7, 11, 15);\n    chachaQR(x, 0, 5, 10, 15);\n    chachaQR(x, 1, 6, 11, 12);\n    chachaQR(x, 2, 7, 8, 13);\n    chachaQR(x, 3, 4, 9, 14);\n  }\n}\n\nconst ctmp = /* @__PURE__ */ new Uint32Array(16);\n\n/** Small version of chacha without loop unrolling. Unused, provided for auditability. */\n// prettier-ignore\nfunction chacha(\n  s: Uint32Array, k: Uint32Array, i: Uint32Array, out: Uint32Array,\n  isHChacha: boolean = true, rounds: number = 20\n): void {\n  // Create initial array using common pattern\n  const y = Uint32Array.from([\n    s[0], s[1], s[2], s[3], // \"expa\"   \"nd 3\"  \"2-by\"  \"te k\"\n    k[0], k[1], k[2], k[3], // Key      Key     Key     Key\n    k[4], k[5], k[6], k[7], // Key      Key     Key     Key\n    i[0], i[1], i[2], i[3], // Counter  Counter Nonce   Nonce\n  ]);\n  const x = ctmp;\n  x.set(y);\n  chachaRound(x, rounds);\n\n  // hchacha extracts 8 specific bytes, chacha adds orig to result\n  if (isHChacha) {\n    const xindexes = [0, 1, 2, 3, 12, 13, 14, 15];\n    for (let i = 0; i < 8; i++) out[i] = x[xindexes[i]];\n  } else {\n    for (let i = 0; i < 16; i++) out[i] = (y[i] + x[i]) | 0;\n  }\n}\n\n/** Identical to `chachaCore`. Unused. */\n// @ts-ignore\nconst chachaCore_small: typeof chachaCore = (s, k, n, out, cnt, rounds) =>\n  chacha(s, k, Uint32Array.from([n[0], n[1], cnt, 0]), out, false, rounds);\n/** Identical to `hchacha`. Unused. */\n// @ts-ignore\nconst hchacha_small: typeof hchacha = chacha;\n\n/** Identical to `chachaCore_small`. Unused. */\n// prettier-ignore\nfunction chachaCore(\n  s: Uint32Array, k: Uint32Array, n: Uint32Array, out: Uint32Array, cnt: number, rounds = 20\n): void {\n  let y00 = s[0], y01 = s[1], y02 = s[2], y03 = s[3], // \"expa\"   \"nd 3\"  \"2-by\"  \"te k\"\n      y04 = k[0], y05 = k[1], y06 = k[2], y07 = k[3], // Key      Key     Key     Key\n      y08 = k[4], y09 = k[5], y10 = k[6], y11 = k[7], // Key      Key     Key     Key\n      y12 = cnt,  y13 = n[0], y14 = n[1], y15 = n[2];  // Counter  Counter\tNonce   Nonce\n  // Save state to temporary variables\n  let x00 = y00, x01 = y01, x02 = y02, x03 = y03,\n      x04 = y04, x05 = y05, x06 = y06, x07 = y07,\n      x08 = y08, x09 = y09, x10 = y10, x11 = y11,\n      x12 = y12, x13 = y13, x14 = y14, x15 = y15;\n  for (let r = 0; r < rounds; r += 2) {\n    x00 = (x00 + x04) | 0; x12 = rotl(x12 ^ x00, 16);\n    x08 = (x08 + x12) | 0; x04 = rotl(x04 ^ x08, 12);\n    x00 = (x00 + x04) | 0; x12 = rotl(x12 ^ x00, 8);\n    x08 = (x08 + x12) | 0; x04 = rotl(x04 ^ x08, 7);\n\n    x01 = (x01 + x05) | 0; x13 = rotl(x13 ^ x01, 16);\n    x09 = (x09 + x13) | 0; x05 = rotl(x05 ^ x09, 12);\n    x01 = (x01 + x05) | 0; x13 = rotl(x13 ^ x01, 8);\n    x09 = (x09 + x13) | 0; x05 = rotl(x05 ^ x09, 7);\n\n    x02 = (x02 + x06) | 0; x14 = rotl(x14 ^ x02, 16);\n    x10 = (x10 + x14) | 0; x06 = rotl(x06 ^ x10, 12);\n    x02 = (x02 + x06) | 0; x14 = rotl(x14 ^ x02, 8);\n    x10 = (x10 + x14) | 0; x06 = rotl(x06 ^ x10, 7);\n\n    x03 = (x03 + x07) | 0; x15 = rotl(x15 ^ x03, 16);\n    x11 = (x11 + x15) | 0; x07 = rotl(x07 ^ x11, 12);\n    x03 = (x03 + x07) | 0; x15 = rotl(x15 ^ x03, 8)\n    x11 = (x11 + x15) | 0; x07 = rotl(x07 ^ x11, 7);\n\n    x00 = (x00 + x05) | 0; x15 = rotl(x15 ^ x00, 16);\n    x10 = (x10 + x15) | 0; x05 = rotl(x05 ^ x10, 12);\n    x00 = (x00 + x05) | 0; x15 = rotl(x15 ^ x00, 8);\n    x10 = (x10 + x15) | 0; x05 = rotl(x05 ^ x10, 7);\n\n    x01 = (x01 + x06) | 0; x12 = rotl(x12 ^ x01, 16);\n    x11 = (x11 + x12) | 0; x06 = rotl(x06 ^ x11, 12);\n    x01 = (x01 + x06) | 0; x12 = rotl(x12 ^ x01, 8);\n    x11 = (x11 + x12) | 0; x06 = rotl(x06 ^ x11, 7);\n\n    x02 = (x02 + x07) | 0; x13 = rotl(x13 ^ x02, 16);\n    x08 = (x08 + x13) | 0; x07 = rotl(x07 ^ x08, 12);\n    x02 = (x02 + x07) | 0; x13 = rotl(x13 ^ x02, 8);\n    x08 = (x08 + x13) | 0; x07 = rotl(x07 ^ x08, 7);\n\n    x03 = (x03 + x04) | 0; x14 = rotl(x14 ^ x03, 16)\n    x09 = (x09 + x14) | 0; x04 = rotl(x04 ^ x09, 12);\n    x03 = (x03 + x04) | 0; x14 = rotl(x14 ^ x03, 8);\n    x09 = (x09 + x14) | 0; x04 = rotl(x04 ^ x09, 7);\n  }\n  // Write output\n  let oi = 0;\n  out[oi++] = (y00 + x00) | 0; out[oi++] = (y01 + x01) | 0;\n  out[oi++] = (y02 + x02) | 0; out[oi++] = (y03 + x03) | 0;\n  out[oi++] = (y04 + x04) | 0; out[oi++] = (y05 + x05) | 0;\n  out[oi++] = (y06 + x06) | 0; out[oi++] = (y07 + x07) | 0;\n  out[oi++] = (y08 + x08) | 0; out[oi++] = (y09 + x09) | 0;\n  out[oi++] = (y10 + x10) | 0; out[oi++] = (y11 + x11) | 0;\n  out[oi++] = (y12 + x12) | 0; out[oi++] = (y13 + x13) | 0;\n  out[oi++] = (y14 + x14) | 0; out[oi++] = (y15 + x15) | 0;\n}\n/**\n * hchacha hashes key and nonce into key' and nonce' for xchacha20.\n * Identical to `hchacha_small`.\n * Need to find a way to merge it with `chachaCore` without 25% performance hit.\n */\n// prettier-ignore\nexport function hchacha(\n  s: Uint32Array, k: Uint32Array, i: Uint32Array, out: Uint32Array\n): void {\n  let x00 = s[0], x01 = s[1], x02 = s[2], x03 = s[3],\n      x04 = k[0], x05 = k[1], x06 = k[2], x07 = k[3],\n      x08 = k[4], x09 = k[5], x10 = k[6], x11 = k[7],\n      x12 = i[0], x13 = i[1], x14 = i[2], x15 = i[3];\n  for (let r = 0; r < 20; r += 2) {\n    x00 = (x00 + x04) | 0; x12 = rotl(x12 ^ x00, 16);\n    x08 = (x08 + x12) | 0; x04 = rotl(x04 ^ x08, 12);\n    x00 = (x00 + x04) | 0; x12 = rotl(x12 ^ x00, 8);\n    x08 = (x08 + x12) | 0; x04 = rotl(x04 ^ x08, 7);\n\n    x01 = (x01 + x05) | 0; x13 = rotl(x13 ^ x01, 16);\n    x09 = (x09 + x13) | 0; x05 = rotl(x05 ^ x09, 12);\n    x01 = (x01 + x05) | 0; x13 = rotl(x13 ^ x01, 8);\n    x09 = (x09 + x13) | 0; x05 = rotl(x05 ^ x09, 7);\n\n    x02 = (x02 + x06) | 0; x14 = rotl(x14 ^ x02, 16);\n    x10 = (x10 + x14) | 0; x06 = rotl(x06 ^ x10, 12);\n    x02 = (x02 + x06) | 0; x14 = rotl(x14 ^ x02, 8);\n    x10 = (x10 + x14) | 0; x06 = rotl(x06 ^ x10, 7);\n\n    x03 = (x03 + x07) | 0; x15 = rotl(x15 ^ x03, 16);\n    x11 = (x11 + x15) | 0; x07 = rotl(x07 ^ x11, 12);\n    x03 = (x03 + x07) | 0; x15 = rotl(x15 ^ x03, 8)\n    x11 = (x11 + x15) | 0; x07 = rotl(x07 ^ x11, 7);\n\n    x00 = (x00 + x05) | 0; x15 = rotl(x15 ^ x00, 16);\n    x10 = (x10 + x15) | 0; x05 = rotl(x05 ^ x10, 12);\n    x00 = (x00 + x05) | 0; x15 = rotl(x15 ^ x00, 8);\n    x10 = (x10 + x15) | 0; x05 = rotl(x05 ^ x10, 7);\n\n    x01 = (x01 + x06) | 0; x12 = rotl(x12 ^ x01, 16);\n    x11 = (x11 + x12) | 0; x06 = rotl(x06 ^ x11, 12);\n    x01 = (x01 + x06) | 0; x12 = rotl(x12 ^ x01, 8);\n    x11 = (x11 + x12) | 0; x06 = rotl(x06 ^ x11, 7);\n\n    x02 = (x02 + x07) | 0; x13 = rotl(x13 ^ x02, 16);\n    x08 = (x08 + x13) | 0; x07 = rotl(x07 ^ x08, 12);\n    x02 = (x02 + x07) | 0; x13 = rotl(x13 ^ x02, 8);\n    x08 = (x08 + x13) | 0; x07 = rotl(x07 ^ x08, 7);\n\n    x03 = (x03 + x04) | 0; x14 = rotl(x14 ^ x03, 16)\n    x09 = (x09 + x14) | 0; x04 = rotl(x04 ^ x09, 12);\n    x03 = (x03 + x04) | 0; x14 = rotl(x14 ^ x03, 8);\n    x09 = (x09 + x14) | 0; x04 = rotl(x04 ^ x09, 7);\n  }\n  let oi = 0;\n  out[oi++] = x00; out[oi++] = x01;\n  out[oi++] = x02; out[oi++] = x03;\n  out[oi++] = x12; out[oi++] = x13;\n  out[oi++] = x14; out[oi++] = x15;\n}\n\n/** Original, non-RFC chacha20 from DJB. 8-byte nonce, 8-byte counter. */\nexport const chacha20orig: XorStream = /* @__PURE__ */ createCipher(chachaCore, {\n  counterRight: false,\n  counterLength: 8,\n  allowShortKeys: true,\n});\n/**\n * ChaCha stream cipher. Conforms to RFC 8439 (IETF, TLS). 12-byte nonce, 4-byte counter.\n * With smaller nonce, it's not safe to make it random (CSPRNG), due to collision chance.\n */\nexport const chacha20: XorStream = /* @__PURE__ */ createCipher(chachaCore, {\n  counterRight: false,\n  counterLength: 4,\n  allowShortKeys: false,\n});\n\n/**\n * XChaCha eXtended-nonce ChaCha. With 24-byte nonce, it's safe to make it random (CSPRNG).\n * See [IRTF draft](https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-xchacha).\n */\nexport const xchacha20: XorStream = /* @__PURE__ */ createCipher(chachaCore, {\n  counterRight: false,\n  counterLength: 8,\n  extendNonceFn: hchacha,\n  allowShortKeys: false,\n});\n\n/** Reduced 8-round chacha, described in original paper. */\nexport const chacha8: XorStream = /* @__PURE__ */ createCipher(chachaCore, {\n  counterRight: false,\n  counterLength: 4,\n  rounds: 8,\n});\n\n/** Reduced 12-round chacha, described in original paper. */\nexport const chacha12: XorStream = /* @__PURE__ */ createCipher(chachaCore, {\n  counterRight: false,\n  counterLength: 4,\n  rounds: 12,\n});\n\nconst ZEROS16 = /* @__PURE__ */ new Uint8Array(16);\n// Pad to digest size with zeros\nconst updatePadded = (h: ReturnType<typeof poly1305.create>, msg: Uint8Array) => {\n  h.update(msg);\n  const leftover = msg.length % 16;\n  if (leftover) h.update(ZEROS16.subarray(leftover));\n};\n\nconst ZEROS32 = /* @__PURE__ */ new Uint8Array(32);\nfunction computeTag(\n  fn: XorStream,\n  key: Uint8Array,\n  nonce: Uint8Array,\n  ciphertext: Uint8Array,\n  AAD?: Uint8Array\n): Uint8Array {\n  if (AAD !== undefined) abytes(AAD, undefined, 'AAD');\n  const authKey = fn(key, nonce, ZEROS32);\n  const lengths = u64Lengths(ciphertext.length, AAD ? AAD.length : 0, true);\n\n  // Methods below can be replaced with\n  // return poly1305_computeTag_small(authKey, lengths, ciphertext, AAD)\n  const h = poly1305.create(authKey);\n  if (AAD) updatePadded(h, AAD);\n  updatePadded(h, ciphertext);\n  h.update(lengths);\n  const res = h.digest();\n  clean(authKey, lengths);\n  return res;\n}\n\n/**\n * AEAD algorithm from RFC 8439.\n * Salsa20 and chacha (RFC 8439) use poly1305 differently.\n * We could have composed them, but it's hard because of authKey:\n * In salsa20, authKey changes position in salsa stream.\n * In chacha, authKey can't be computed inside computeTag, it modifies the counter.\n */\nexport const _poly1305_aead =\n  (xorStream: XorStream) =>\n  (key: Uint8Array, nonce: Uint8Array, AAD?: Uint8Array): CipherWithOutput => {\n    const tagLength = 16;\n    return {\n      encrypt(plaintext: Uint8Array, output?: Uint8Array) {\n        const plength = plaintext.length;\n        output = getOutput(plength + tagLength, output, false);\n        output.set(plaintext);\n        const oPlain = output.subarray(0, -tagLength);\n        // Actual encryption\n        xorStream(key, nonce, oPlain, oPlain, 1);\n        const tag = computeTag(xorStream, key, nonce, oPlain, AAD);\n        output.set(tag, plength); // append tag\n        clean(tag);\n        return output;\n      },\n      decrypt(ciphertext: Uint8Array, output?: Uint8Array) {\n        output = getOutput(ciphertext.length - tagLength, output, false);\n        const data = ciphertext.subarray(0, -tagLength);\n        const passedTag = ciphertext.subarray(-tagLength);\n        const tag = computeTag(xorStream, key, nonce, data, AAD);\n        if (!equalBytes(passedTag, tag)) throw new Error('invalid tag');\n        output.set(ciphertext.subarray(0, -tagLength));\n        // Actual decryption\n        xorStream(key, nonce, output, output, 1); // start stream with i=1\n        clean(tag);\n        return output;\n      },\n    };\n  };\n\n/**\n * ChaCha20-Poly1305 from RFC 8439.\n *\n * Unsafe to use random nonces under the same key, due to collision chance.\n * Prefer XChaCha instead.\n */\nexport const chacha20poly1305: ARXCipher = /* @__PURE__ */ wrapCipher(\n  { blockSize: 64, nonceLength: 12, tagLength: 16 },\n  _poly1305_aead(chacha20)\n);\n/**\n * XChaCha20-Poly1305 extended-nonce chacha.\n *\n * Can be safely used with random nonces (CSPRNG).\n * See [IRTF draft](https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-xchacha).\n */\nexport const xchacha20poly1305: ARXCipher = /* @__PURE__ */ wrapCipher(\n  { blockSize: 64, nonceLength: 24, tagLength: 16 },\n  _poly1305_aead(xchacha20)\n);\n\n/**\n * Chacha20 CSPRNG (cryptographically secure pseudorandom number generator).\n * It's best to limit usage to non-production, non-critical cases: for example, test-only.\n * Compatible with libtomcrypt. It does not have a specification, so unclear how secure it is.\n */\nexport const rngChacha20: XorPRG = /* @__PURE__ */ createPRG(chacha20orig, 64, 32, 8);\n/**\n * Chacha20/8 CSPRNG (cryptographically secure pseudorandom number generator).\n * It's best to limit usage to non-production, non-critical cases: for example, test-only.\n * Faster than `rngChacha20`.\n */\nexport const rngChacha8: XorPRG = /* @__PURE__ */ createPRG(chacha8, 64, 32, 12);\n", "/**\n * Basic utils for ARX (add-rotate-xor) salsa and chacha ciphers.\n\nRFC8439 requires multi-step cipher stream, where\nauthKey starts with counter: 0, actual msg with counter: 1.\n\nFor this, we need a way to re-use nonce / counter:\n\n    const counter = new Uint8Array(4);\n    chacha(..., counter, ...); // counter is now 1\n    chacha(..., counter, ...); // counter is now 2\n\nThis is complicated:\n\n- 32-bit counters are enough, no need for 64-bit: max ArrayBuffer size in JS is 4GB\n- Original papers don't allow mutating counters\n- Counter overflow is undefined [^1]\n- Idea A: allow providing (nonce | counter) instead of just nonce, re-use it\n- Caveat: Cannot be re-used through all cases:\n- * chacha has (counter | nonce)\n- * xchacha has (nonce16 | counter | nonce16)\n- Idea B: separate nonce / counter and provide separate API for counter re-use\n- Caveat: there are different counter sizes depending on an algorithm.\n- salsa & chacha also differ in structures of key & sigma:\n  salsa20:      s[0] | k(4) | s[1] | nonce(2) | cnt(2) | s[2] | k(4) | s[3]\n  chacha:       s(4) | k(8) | cnt(1) | nonce(3)\n  chacha20orig: s(4) | k(8) | cnt(2) | nonce(2)\n- Idea C: helper method such as `setSalsaState(key, nonce, sigma, data)`\n- Caveat: we can't re-use counter array\n\nxchacha [^2] uses the subkey and remaining 8 byte nonce with ChaCha20 as normal\n(prefixed by 4 NUL bytes, since [RFC8439] specifies a 12-byte nonce).\n\n[^1]: https://mailarchive.ietf.org/arch/msg/cfrg/gsOnTJzcbgG6OqD8Sc0GO5aR_tU/\n[^2]: https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-xchacha#appendix-A.2\n\n * @module\n */\nimport {\n  type PRG,\n  type XorStream,\n  abool,\n  abytes,\n  anumber,\n  checkOpts,\n  clean,\n  copyBytes,\n  randomBytes,\n  u32,\n} from './utils.ts';\n\n// Replaces `TextEncoder`, which is not available in all environments\nconst encodeStr = (str: string) => Uint8Array.from(str.split(''), (c) => c.charCodeAt(0));\nconst sigma16 = encodeStr('expand 16-byte k');\nconst sigma32 = encodeStr('expand 32-byte k');\nconst sigma16_32 = u32(sigma16);\nconst sigma32_32 = u32(sigma32);\n\n/** Rotate left. */\nexport function rotl(a: number, b: number): number {\n  return (a << b) | (a >>> (32 - b));\n}\n\n/** Ciphers must use u32 for efficiency. */\nexport type CipherCoreFn = (\n  sigma: Uint32Array,\n  key: Uint32Array,\n  nonce: Uint32Array,\n  output: Uint32Array,\n  counter: number,\n  rounds?: number\n) => void;\n\n/** Method which extends key + short nonce into larger nonce / diff key. */\nexport type ExtendNonceFn = (\n  sigma: Uint32Array,\n  key: Uint32Array,\n  input: Uint32Array,\n  output: Uint32Array\n) => void;\n\n/** ARX cipher options.\n * * `allowShortKeys` for 16-byte keys\n * * `counterLength` in bytes\n * * `counterRight`: right: `nonce|counter`; left: `counter|nonce`\n * */\nexport type CipherOpts = {\n  allowShortKeys?: boolean; // Original salsa / chacha allow 16-byte keys\n  extendNonceFn?: ExtendNonceFn;\n  counterLength?: number;\n  counterRight?: boolean;\n  rounds?: number;\n};\n\n// Is byte array aligned to 4 byte offset (u32)?\nfunction isAligned32(b: Uint8Array) {\n  return b.byteOffset % 4 === 0;\n}\n\n// Salsa and Chacha block length is always 512-bit\nconst BLOCK_LEN = 64;\nconst BLOCK_LEN32 = 16;\n\n// new Uint32Array([2**32])   // => Uint32Array(1) [ 0 ]\n// new Uint32Array([2**32-1]) // => Uint32Array(1) [ 4294967295 ]\nconst MAX_COUNTER = 2 ** 32 - 1;\n\nconst U32_EMPTY = Uint32Array.of();\nfunction runCipher(\n  core: CipherCoreFn,\n  sigma: Uint32Array,\n  key: Uint32Array,\n  nonce: Uint32Array,\n  data: Uint8Array,\n  output: Uint8Array,\n  counter: number,\n  rounds: number\n): void {\n  const len = data.length;\n  const block = new Uint8Array(BLOCK_LEN);\n  const b32 = u32(block);\n  // Make sure that buffers aligned to 4 bytes\n  const isAligned = isAligned32(data) && isAligned32(output);\n  const d32 = isAligned ? u32(data) : U32_EMPTY;\n  const o32 = isAligned ? u32(output) : U32_EMPTY;\n  for (let pos = 0; pos < len; counter++) {\n    core(sigma, key, nonce, b32, counter, rounds);\n    if (counter >= MAX_COUNTER) throw new Error('arx: counter overflow');\n    const take = Math.min(BLOCK_LEN, len - pos);\n    // aligned to 4 bytes\n    if (isAligned && take === BLOCK_LEN) {\n      const pos32 = pos / 4;\n      if (pos % 4 !== 0) throw new Error('arx: invalid block position');\n      for (let j = 0, posj: number; j < BLOCK_LEN32; j++) {\n        posj = pos32 + j;\n        o32[posj] = d32[posj] ^ b32[j];\n      }\n      pos += BLOCK_LEN;\n      continue;\n    }\n    for (let j = 0, posj; j < take; j++) {\n      posj = pos + j;\n      output[posj] = data[posj] ^ block[j];\n    }\n    pos += take;\n  }\n}\n\n/** Creates ARX-like (ChaCha, Salsa) cipher stream from core function. */\nexport function createCipher(core: CipherCoreFn, opts: CipherOpts): XorStream {\n  const { allowShortKeys, extendNonceFn, counterLength, counterRight, rounds } = checkOpts(\n    { allowShortKeys: false, counterLength: 8, counterRight: false, rounds: 20 },\n    opts\n  );\n  if (typeof core !== 'function') throw new Error('core must be a function');\n  anumber(counterLength);\n  anumber(rounds);\n  abool(counterRight);\n  abool(allowShortKeys);\n  return (\n    key: Uint8Array,\n    nonce: Uint8Array,\n    data: Uint8Array,\n    output?: Uint8Array,\n    counter = 0\n  ): Uint8Array => {\n    abytes(key, undefined, 'key');\n    abytes(nonce, undefined, 'nonce');\n    abytes(data, undefined, 'data');\n    const len = data.length;\n    if (output === undefined) output = new Uint8Array(len);\n    abytes(output, undefined, 'output');\n    anumber(counter);\n    if (counter < 0 || counter >= MAX_COUNTER) throw new Error('arx: counter overflow');\n    if (output.length < len)\n      throw new Error(`arx: output (${output.length}) is shorter than data (${len})`);\n    const toClean = [];\n\n    // Key & sigma\n    // key=16 -> sigma16, k=key|key\n    // key=32 -> sigma32, k=key\n    let l = key.length;\n    let k: Uint8Array;\n    let sigma: Uint32Array;\n    if (l === 32) {\n      toClean.push((k = copyBytes(key)));\n      sigma = sigma32_32;\n    } else if (l === 16 && allowShortKeys) {\n      k = new Uint8Array(32);\n      k.set(key);\n      k.set(key, 16);\n      sigma = sigma16_32;\n      toClean.push(k);\n    } else {\n      abytes(key, 32, 'arx key');\n      throw new Error('invalid key size');\n      // throw new Error(`\"arx key\" expected Uint8Array of length 32, got length=${l}`);\n    }\n\n    // Nonce\n    // salsa20:      8   (8-byte counter)\n    // chacha20orig: 8   (8-byte counter)\n    // chacha20:     12  (4-byte counter)\n    // xsalsa20:     24  (16 -> hsalsa,  8 -> old nonce)\n    // xchacha20:    24  (16 -> hchacha, 8 -> old nonce)\n    // Align nonce to 4 bytes\n    if (!isAligned32(nonce)) toClean.push((nonce = copyBytes(nonce)));\n\n    const k32 = u32(k);\n    // hsalsa & hchacha: handle extended nonce\n    if (extendNonceFn) {\n      if (nonce.length !== 24) throw new Error(`arx: extended nonce must be 24 bytes`);\n      extendNonceFn(sigma, k32, u32(nonce.subarray(0, 16)), k32);\n      nonce = nonce.subarray(16);\n    }\n\n    // Handle nonce counter\n    const nonceNcLen = 16 - counterLength;\n    if (nonceNcLen !== nonce.length)\n      throw new Error(`arx: nonce must be ${nonceNcLen} or 16 bytes`);\n\n    // Pad counter when nonce is 64 bit\n    if (nonceNcLen !== 12) {\n      const nc = new Uint8Array(12);\n      nc.set(nonce, counterRight ? 0 : 12 - nonce.length);\n      nonce = nc;\n      toClean.push(nonce);\n    }\n    const n32 = u32(nonce);\n    runCipher(core, sigma, k32, n32, data, output, counter, rounds);\n    clean(...toClean);\n    return output;\n  };\n}\n\n/** Internal class which wraps chacha20 or chacha8 to create CSPRNG. */\nexport class _XorStreamPRG implements PRG {\n  readonly blockLen: number;\n  readonly keyLen: number;\n  readonly nonceLen: number;\n  private state: Uint8Array;\n  private buf: Uint8Array;\n  private key: Uint8Array;\n  private nonce: Uint8Array;\n  private pos: number;\n  private ctr: number;\n  private cipher: XorStream;\n  constructor(\n    cipher: XorStream,\n    blockLen: number,\n    keyLen: number,\n    nonceLen: number,\n    seed: Uint8Array\n  ) {\n    this.cipher = cipher;\n    this.blockLen = blockLen;\n    this.keyLen = keyLen;\n    this.nonceLen = nonceLen;\n    this.state = new Uint8Array(this.keyLen + this.nonceLen);\n    this.reseed(seed);\n    this.ctr = 0;\n    this.pos = this.blockLen;\n    this.buf = new Uint8Array(this.blockLen);\n    this.key = this.state.subarray(0, this.keyLen);\n    this.nonce = this.state.subarray(this.keyLen);\n  }\n  private reseed(seed: Uint8Array) {\n    abytes(seed);\n    if (!seed || seed.length === 0) throw new Error('entropy required');\n    for (let i = 0; i < seed.length; i++) this.state[i % this.state.length] ^= seed[i];\n    this.ctr = 0;\n    this.pos = this.blockLen;\n  }\n  addEntropy(seed: Uint8Array): void {\n    this.state.set(this.randomBytes(this.state.length));\n    this.reseed(seed);\n  }\n  randomBytes(len: number): Uint8Array {\n    anumber(len);\n    if (len === 0) return new Uint8Array(0);\n    const out = new Uint8Array(len);\n    let outPos = 0;\n    // Leftovers\n    if (this.pos < this.blockLen) {\n      const take = Math.min(len, this.blockLen - this.pos);\n      out.set(this.buf.subarray(this.pos, this.pos + take), 0);\n      this.pos += take;\n      outPos += take;\n      if (outPos === len) return out; // fast path\n    }\n    // Full blocks directly to out\n    const blocks = Math.floor((len - outPos) / this.blockLen);\n    if (blocks > 0) {\n      const blockBytes = blocks * this.blockLen;\n      const b = out.subarray(outPos, outPos + blockBytes);\n      this.cipher(this.key, this.nonce, b, b, this.ctr);\n      this.ctr += blocks;\n      outPos += blockBytes;\n    }\n    // Save leftovers\n    const left = len - outPos;\n    if (left > 0) {\n      this.buf.fill(0);\n      // NOTE: cipher will handle overflow\n      this.cipher(this.key, this.nonce, this.buf, this.buf, this.ctr++);\n      out.set(this.buf.subarray(0, left), outPos);\n      this.pos = left;\n    }\n    return out;\n  }\n  clone(): _XorStreamPRG {\n    return new _XorStreamPRG(\n      this.cipher,\n      this.blockLen,\n      this.keyLen,\n      this.nonceLen,\n      this.randomBytes(this.state.length)\n    );\n  }\n  clean(): void {\n    this.pos = 0;\n    this.ctr = 0;\n    this.buf.fill(0);\n    this.state.fill(0);\n  }\n}\n\nexport type XorPRG = (seed?: Uint8Array) => _XorStreamPRG;\n\nexport const createPRG = (\n  cipher: XorStream,\n  blockLen: number,\n  keyLen: number,\n  nonceLen: number\n): XorPRG => {\n  return (seed: Uint8Array = randomBytes(32)): _XorStreamPRG =>\n    new _XorStreamPRG(cipher, blockLen, keyLen, nonceLen, seed);\n};\n", "/**\n * Utilities for hex, bytes, CSPRNG.\n * @module\n */\n/*! noble-ciphers - MIT License (c) 2023 Paul Miller (paulmillr.com) */\n\n/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */\nexport function isBytes(a: unknown): a is Uint8Array {\n  return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');\n}\n\n/** Asserts something is boolean. */\nexport function abool(b: boolean): void {\n  if (typeof b !== 'boolean') throw new Error(`boolean expected, not ${b}`);\n}\n\n/** Asserts something is positive integer. */\nexport function anumber(n: number): void {\n  if (!Number.isSafeInteger(n) || n < 0) throw new Error('positive integer expected, got ' + n);\n}\n\n/** Asserts something is Uint8Array. */\nexport function abytes(value: Uint8Array, length?: number, title: string = ''): Uint8Array {\n  const bytes = isBytes(value);\n  const len = value?.length;\n  const needsLen = length !== undefined;\n  if (!bytes || (needsLen && len !== length)) {\n    const prefix = title && `\"${title}\" `;\n    const ofLen = needsLen ? ` of length ${length}` : '';\n    const got = bytes ? `length=${len}` : `type=${typeof value}`;\n    throw new Error(prefix + 'expected Uint8Array' + ofLen + ', got ' + got);\n  }\n  return value;\n}\n\n/** Asserts a hash instance has not been destroyed / finished */\nexport function aexists(instance: any, checkFinished = true): void {\n  if (instance.destroyed) throw new Error('Hash instance has been destroyed');\n  if (checkFinished && instance.finished) throw new Error('Hash#digest() has already been called');\n}\n\n/** Asserts output is properly-sized byte array */\nexport function aoutput(out: any, instance: any): void {\n  abytes(out, undefined, 'output');\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}\n\nexport type IHash = {\n  (data: string | Uint8Array): Uint8Array;\n  blockLen: number;\n  outputLen: number;\n  create: any;\n};\n\n/** Generic type encompassing 8/16/32-byte arrays - but not 64-byte. */\n// prettier-ignore\nexport type TypedArray = Int8Array | Uint8ClampedArray | Uint8Array |\n  Uint16Array | Int16Array | Uint32Array | Int32Array;\n\n/** Cast u8 / u16 / u32 to u8. */\nexport function u8(arr: TypedArray): Uint8Array {\n  return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\n}\n\n/** Cast u8 / u16 / u32 to u32. */\nexport function u32(arr: TypedArray): Uint32Array {\n  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));\n}\n\n/** Zeroize a byte array. Warning: JS provides no guarantees. */\nexport function clean(...arrays: TypedArray[]): void {\n  for (let i = 0; i < arrays.length; i++) {\n    arrays[i].fill(0);\n  }\n}\n\n/** Create DataView of an array for easy byte-level manipulation. */\nexport function createView(arr: TypedArray): DataView {\n  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\n}\n\n/** Is current platform little-endian? Most are. Big-Endian platform: IBM */\nexport const isLE: boolean = /* @__PURE__ */ (() =>\n  new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();\n\n// Built-in hex conversion https://caniuse.com/mdn-javascript_builtins_uint8array_fromhex\nconst hasHexBuiltin: boolean = /* @__PURE__ */ (() =>\n  // @ts-ignore\n  typeof Uint8Array.from([]).toHex === 'function' && typeof Uint8Array.fromHex === 'function')();\n\n// Array where index 0xf0 (240) is mapped to string 'f0'\nconst hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) =>\n  i.toString(16).padStart(2, '0')\n);\n\n/**\n * Convert byte array to hex string. Uses built-in function, when available.\n * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'\n */\nexport function bytesToHex(bytes: Uint8Array): string {\n  abytes(bytes);\n  // @ts-ignore\n  if (hasHexBuiltin) return bytes.toHex();\n  // pre-caching improves the speed 6x\n  let hex = '';\n  for (let i = 0; i < bytes.length; i++) {\n    hex += hexes[bytes[i]];\n  }\n  return hex;\n}\n\n// We use optimized technique to convert hex string to byte array\nconst asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 } as const;\nfunction asciiToBase16(ch: number): number | undefined {\n  if (ch >= asciis._0 && ch <= asciis._9) return ch - asciis._0; // '2' => 50-48\n  if (ch >= asciis.A && ch <= asciis.F) return ch - (asciis.A - 10); // 'B' => 66-(65-10)\n  if (ch >= asciis.a && ch <= asciis.f) return ch - (asciis.a - 10); // 'b' => 98-(97-10)\n  return;\n}\n\n/**\n * Convert hex string to byte array. Uses built-in function, when available.\n * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])\n */\nexport function hexToBytes(hex: string): Uint8Array {\n  if (typeof hex !== 'string') throw new Error('hex string expected, got ' + typeof hex);\n  // @ts-ignore\n  if (hasHexBuiltin) return Uint8Array.fromHex(hex);\n  const hl = hex.length;\n  const al = hl / 2;\n  if (hl % 2) throw new Error('hex string expected, got unpadded hex of length ' + hl);\n  const array = new Uint8Array(al);\n  for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {\n    const n1 = asciiToBase16(hex.charCodeAt(hi));\n    const n2 = asciiToBase16(hex.charCodeAt(hi + 1));\n    if (n1 === undefined || n2 === undefined) {\n      const char = hex[hi] + hex[hi + 1];\n      throw new Error('hex string expected, got non-hex character \"' + char + '\" at index ' + hi);\n    }\n    array[ai] = n1 * 16 + n2; // multiply first octet, e.g. 'a3' => 10*16+3 => 160 + 3 => 163\n  }\n  return array;\n}\n\n// Used in micro\nexport function hexToNumber(hex: string): bigint {\n  if (typeof hex !== 'string') throw new Error('hex string expected, got ' + typeof hex);\n  return BigInt(hex === '' ? '0' : '0x' + hex); // Big Endian\n}\n\n// Used in ff1\n// BE: Big Endian, LE: Little Endian\nexport function bytesToNumberBE(bytes: Uint8Array): bigint {\n  return hexToNumber(bytesToHex(bytes));\n}\n\n// Used in micro, ff1\nexport function numberToBytesBE(n: number | bigint, len: number): Uint8Array {\n  return hexToBytes(n.toString(16).padStart(len * 2, '0'));\n}\n\n// Global symbols, but ts doesn't see them: https://github.com/microsoft/TypeScript/issues/31535\ndeclare const TextEncoder: any;\ndeclare const TextDecoder: any;\n\n/**\n * Converts string to bytes using UTF8 encoding.\n * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])\n */\nexport function utf8ToBytes(str: string): Uint8Array {\n  if (typeof str !== 'string') throw new Error('string expected');\n  return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n\n/**\n * Converts bytes to string using UTF8 encoding.\n * @example bytesToUtf8(new Uint8Array([97, 98, 99])) // 'abc'\n */\nexport function bytesToUtf8(bytes: Uint8Array): string {\n  return new TextDecoder().decode(bytes);\n}\n\n/**\n * Checks if two U8A use same underlying buffer and overlaps.\n * This is invalid and can corrupt data.\n */\nexport function overlapBytes(a: Uint8Array, b: Uint8Array): boolean {\n  return (\n    a.buffer === b.buffer && // best we can do, may fail with an obscure Proxy\n    a.byteOffset < b.byteOffset + b.byteLength && // a starts before b end\n    b.byteOffset < a.byteOffset + a.byteLength // b starts before a end\n  );\n}\n\n/**\n * If input and output overlap and input starts before output, we will overwrite end of input before\n * we start processing it, so this is not supported for most ciphers (except chacha/salse, which designed with this)\n */\nexport function complexOverlapBytes(input: Uint8Array, output: Uint8Array): void {\n  // This is very cursed. It works somehow, but I'm completely unsure,\n  // reasoning about overlapping aligned windows is very hard.\n  if (overlapBytes(input, output) && input.byteOffset < output.byteOffset)\n    throw new Error('complex overlap of input and output is not supported');\n}\n\n/**\n * Copies several Uint8Arrays into one.\n */\nexport function concatBytes(...arrays: Uint8Array[]): Uint8Array {\n  let sum = 0;\n  for (let i = 0; i < arrays.length; i++) {\n    const a = arrays[i];\n    abytes(a);\n    sum += a.length;\n  }\n  const res = new Uint8Array(sum);\n  for (let i = 0, pad = 0; i < arrays.length; i++) {\n    const a = arrays[i];\n    res.set(a, pad);\n    pad += a.length;\n  }\n  return res;\n}\n\n// Used in ARX only\ntype EmptyObj = {};\nexport function checkOpts<T1 extends EmptyObj, T2 extends EmptyObj>(\n  defaults: T1,\n  opts: T2\n): T1 & T2 {\n  if (opts == null || typeof opts !== 'object') throw new Error('options must be defined');\n  const merged = Object.assign(defaults, opts);\n  return merged as T1 & T2;\n}\n\n/** Compares 2 uint8array-s in kinda constant time. */\nexport function equalBytes(a: Uint8Array, b: Uint8Array): boolean {\n  if (a.length !== b.length) return false;\n  let diff = 0;\n  for (let i = 0; i < a.length; i++) diff |= a[i] ^ b[i];\n  return diff === 0;\n}\n\n// TODO: remove\nexport interface IHash2 {\n  blockLen: number; // Bytes per block\n  outputLen: number; // Bytes in output\n  update(buf: string | Uint8Array): this;\n  // Writes digest into buf\n  digestInto(buf: Uint8Array): void;\n  digest(): Uint8Array;\n  /**\n   * Resets internal state. Makes Hash instance unusable.\n   * Reset is impossible for keyed hashes if key is consumed into state. If digest is not consumed\n   * by user, they will need to manually call `destroy()` when zeroing is necessary.\n   */\n  destroy(): void;\n}\n\n// This will allow to re-use with composable things like packed & base encoders\n// Also, we probably can make tags composable\n\n/** Sync cipher: takes byte array and returns byte array. */\nexport type Cipher = {\n  encrypt(plaintext: Uint8Array): Uint8Array;\n  decrypt(ciphertext: Uint8Array): Uint8Array;\n};\n\n/** Async cipher e.g. from built-in WebCrypto. */\nexport type AsyncCipher = {\n  encrypt(plaintext: Uint8Array): Promise<Uint8Array>;\n  decrypt(ciphertext: Uint8Array): Promise<Uint8Array>;\n};\n\n/** Cipher with `output` argument which can optimize by doing 1 less allocation. */\nexport type CipherWithOutput = Cipher & {\n  encrypt(plaintext: Uint8Array, output?: Uint8Array): Uint8Array;\n  decrypt(ciphertext: Uint8Array, output?: Uint8Array): Uint8Array;\n};\n\n/**\n * Params are outside of return type, so it is accessible before calling constructor.\n * If function support multiple nonceLength's, we return the best one.\n */\nexport type CipherParams = {\n  blockSize: number;\n  nonceLength?: number;\n  tagLength?: number;\n  varSizeNonce?: boolean;\n};\n/** ARX cipher, like salsa or chacha. */\nexport type ARXCipher = ((\n  key: Uint8Array,\n  nonce: Uint8Array,\n  AAD?: Uint8Array\n) => CipherWithOutput) & {\n  blockSize: number;\n  nonceLength: number;\n  tagLength: number;\n};\nexport type CipherCons<T extends any[]> = (key: Uint8Array, ...args: T) => Cipher;\n/**\n * Wraps a cipher: validates args, ensures encrypt() can only be called once.\n * @__NO_SIDE_EFFECTS__\n */\nexport const wrapCipher = <C extends CipherCons<any>, P extends CipherParams>(\n  params: P,\n  constructor: C\n): C & P => {\n  function wrappedCipher(key: Uint8Array, ...args: any[]): CipherWithOutput {\n    // Validate key\n    abytes(key, undefined, 'key');\n\n    // Big-Endian hardware is rare. Just in case someone still decides to run ciphers:\n    if (!isLE) throw new Error('Non little-endian hardware is not yet supported');\n\n    // Validate nonce if nonceLength is present\n    if (params.nonceLength !== undefined) {\n      const nonce = args[0];\n      abytes(nonce, params.varSizeNonce ? undefined : params.nonceLength, 'nonce');\n    }\n\n    // Validate AAD if tagLength present\n    const tagl = params.tagLength;\n    if (tagl && args[1] !== undefined) abytes(args[1], undefined, 'AAD');\n\n    const cipher = constructor(key, ...args);\n    const checkOutput = (fnLength: number, output?: Uint8Array) => {\n      if (output !== undefined) {\n        if (fnLength !== 2) throw new Error('cipher output not supported');\n        abytes(output, undefined, 'output');\n      }\n    };\n    // Create wrapped cipher with validation and single-use encryption\n    let called = false;\n    const wrCipher = {\n      encrypt(data: Uint8Array, output?: Uint8Array) {\n        if (called) throw new Error('cannot encrypt() twice with same key + nonce');\n        called = true;\n        abytes(data);\n        checkOutput(cipher.encrypt.length, output);\n        return (cipher as CipherWithOutput).encrypt(data, output);\n      },\n      decrypt(data: Uint8Array, output?: Uint8Array) {\n        abytes(data);\n        if (tagl && data.length < tagl)\n          throw new Error('\"ciphertext\" expected length bigger than tagLength=' + tagl);\n        checkOutput(cipher.decrypt.length, output);\n        return (cipher as CipherWithOutput).decrypt(data, output);\n      },\n    };\n\n    return wrCipher;\n  }\n\n  Object.assign(wrappedCipher, params);\n  return wrappedCipher as C & P;\n};\n\n/** Represents salsa / chacha stream. */\nexport type XorStream = (\n  key: Uint8Array,\n  nonce: Uint8Array,\n  data: Uint8Array,\n  output?: Uint8Array,\n  counter?: number\n) => Uint8Array;\n\n/**\n * By default, returns u8a of length.\n * When out is available, it checks it for validity and uses it.\n */\nexport function getOutput(\n  expectedLength: number,\n  out?: Uint8Array,\n  onlyAligned = true\n): Uint8Array {\n  if (out === undefined) return new Uint8Array(expectedLength);\n  if (out.length !== expectedLength)\n    throw new Error(\n      '\"output\" expected Uint8Array of length ' + expectedLength + ', got: ' + out.length\n    );\n  if (onlyAligned && !isAligned32(out)) throw new Error('invalid output, must be aligned');\n  return out;\n}\n\nexport function u64Lengths(dataLength: number, aadLength: number, isLE: boolean): Uint8Array {\n  abool(isLE);\n  const num = new Uint8Array(16);\n  const view = createView(num);\n  view.setBigUint64(0, BigInt(aadLength), isLE);\n  view.setBigUint64(8, BigInt(dataLength), isLE);\n  return num;\n}\n\n// Is byte array aligned to 4 byte offset (u32)?\nexport function isAligned32(bytes: Uint8Array): boolean {\n  return bytes.byteOffset % 4 === 0;\n}\n\n// copy bytes to new u8a (aligned). Because Buffer.slice is broken.\nexport function copyBytes(bytes: Uint8Array): Uint8Array {\n  return Uint8Array.from(bytes);\n}\n\n/** Cryptographically secure PRNG. Uses internal OS-level `crypto.getRandomValues`. */\nexport function randomBytes(bytesLength = 32): Uint8Array {\n  const cr = typeof globalThis === 'object' ? (globalThis as any).crypto : null;\n  if (typeof cr?.getRandomValues !== 'function')\n    throw new Error('crypto.getRandomValues must be defined');\n  return cr.getRandomValues(new Uint8Array(bytesLength));\n}\n\n/**\n * The pseudorandom number generator doesn't wipe current state:\n * instead, it generates new one based on previous state + entropy.\n * Not reseed/rekey, since AES CTR DRBG does rekey on each randomBytes,\n * which is in fact `reseed`, since it changes counter too.\n */\nexport interface PRG {\n  addEntropy(seed: Uint8Array): void;\n  randomBytes(length: number): Uint8Array;\n  clean(): void;\n}\n\ntype RemoveNonceInner<T extends any[], Ret> = ((...args: T) => Ret) extends (\n  arg0: any,\n  arg1: any,\n  ...rest: infer R\n) => any\n  ? (key: Uint8Array, ...args: R) => Ret\n  : never;\n\nexport type RemoveNonce<T extends (...args: any) => any> = RemoveNonceInner<\n  Parameters<T>,\n  ReturnType<T>\n>;\nexport type CipherWithNonce = ((\n  key: Uint8Array,\n  nonce: Uint8Array,\n  ...args: any[]\n) => Cipher | AsyncCipher) & {\n  nonceLength: number;\n};\n\n/**\n * Uses CSPRG for nonce, nonce injected in ciphertext.\n * For `encrypt`, a `nonceBytes`-length buffer is fetched from CSPRNG and\n * prepended to encrypted ciphertext. For `decrypt`, first `nonceBytes` of ciphertext\n * are treated as nonce.\n *\n * NOTE: Under the same key, using random nonces (e.g. `managedNonce`) with AES-GCM and ChaCha\n * should be limited to `2**23` (8M) messages to get a collision chance of `2**-50`. Stretching to  * `2**32` (4B) messages, chance would become `2**-33` - still negligible, but creeping up.\n * @example\n * const gcm = managedNonce(aes.gcm);\n * const ciphr = gcm(key).encrypt(data);\n * const plain = gcm(key).decrypt(ciph);\n */\nexport function managedNonce<T extends CipherWithNonce>(\n  fn: T,\n  randomBytes_: typeof randomBytes = randomBytes\n): RemoveNonce<T> {\n  const { nonceLength } = fn;\n  anumber(nonceLength);\n  const addNonce = (nonce: Uint8Array, ciphertext: Uint8Array) => {\n    const out = concatBytes(nonce, ciphertext);\n    ciphertext.fill(0);\n    return out;\n  };\n  // NOTE: we cannot support DST here, it would be mistake:\n  // - we don't know how much dst length cipher requires\n  // - nonce may unalign dst and break everything\n  // - we create new u8a anyway (concatBytes)\n  // - previously we passed all args to cipher, but that was mistake!\n  return ((key: Uint8Array, ...args: any[]): any => ({\n    encrypt(plaintext: Uint8Array) {\n      abytes(plaintext);\n      const nonce = randomBytes_(nonceLength);\n      const encrypted = fn(key, nonce, ...args).encrypt(plaintext);\n      // @ts-ignore\n      if (encrypted instanceof Promise) return encrypted.then((ct) => addNonce(nonce, ct));\n      return addNonce(nonce, encrypted);\n    },\n    decrypt(ciphertext: Uint8Array) {\n      abytes(ciphertext);\n      const nonce = ciphertext.subarray(0, nonceLength);\n      const decrypted = ciphertext.subarray(nonceLength);\n      return fn(key, nonce, ...args).decrypt(decrypted);\n    },\n  })) as RemoveNonce<T>;\n}\n\n// workaround for TS 5.9 language mess:\nexport type Uint8ArrayBuffer = ReturnType<typeof Uint8Array.of>;\n", "/**\n * Poly1305 ([PDF](https://cr.yp.to/mac/poly1305-20050329.pdf),\n * [wiki](https://en.wikipedia.org/wiki/Poly1305))\n * is a fast and parallel secret-key message-authentication code suitable for\n * a wide variety of applications. It was standardized in\n * [RFC 8439](https://www.rfc-editor.org/rfc/rfc8439) and is now used in TLS 1.3.\n *\n * Polynomial MACs are not perfect for every situation:\n * they lack Random Key Robustness: the MAC can be forged, and can't be used in PAKE schemes.\n * See [invisible salamanders attack](https://keymaterial.net/2020/09/07/invisible-salamanders-in-aes-gcm-siv/).\n * To combat invisible salamanders, `hash(key)` can be included in ciphertext,\n * however, this would violate ciphertext indistinguishability:\n * an attacker would know which key was used - so `HKDF(key, i)`\n * could be used instead.\n *\n * Check out [original website](https://cr.yp.to/mac.html).\n * Based on Public Domain [poly1305-donna](https://github.com/floodyberry/poly1305-donna).\n * @module\n */\n// prettier-ignore\nimport {\n  abytes, aexists, aoutput, bytesToHex,\n  clean, concatBytes, copyBytes, hexToNumber, numberToBytesBE,\n  type IHash2\n} from './utils.ts';\n\nfunction u8to16(a: Uint8Array, i: number) {\n  return (a[i++] & 0xff) | ((a[i++] & 0xff) << 8);\n}\n\nfunction bytesToNumberLE(bytes: Uint8Array): bigint {\n  return hexToNumber(bytesToHex(Uint8Array.from(bytes).reverse()));\n}\n\n/** Small version of `poly1305` without loop unrolling. Unused, provided for auditability. */\nfunction poly1305_small(msg: Uint8Array, key: Uint8Array): Uint8Array {\n  abytes(msg);\n  abytes(key, 32, 'key');\n  const POW_2_130_5 = BigInt(2) ** BigInt(130) - BigInt(5); // 2^130-5\n  const POW_2_128_1 = BigInt(2) ** BigInt(128) - BigInt(1); // 2^128-1\n  const CLAMP_R = BigInt('0x0ffffffc0ffffffc0ffffffc0fffffff');\n  const r = bytesToNumberLE(key.subarray(0, 16)) & CLAMP_R;\n  const s = bytesToNumberLE(key.subarray(16));\n  // Process by 16 byte chunks\n  let acc = BigInt(0);\n  for (let i = 0; i < msg.length; i += 16) {\n    const m = msg.subarray(i, i + 16);\n    const n = bytesToNumberLE(m) | (BigInt(1) << BigInt(8 * m.length));\n    acc = ((acc + n) * r) % POW_2_130_5;\n  }\n  const res = (acc + s) & POW_2_128_1;\n  return numberToBytesBE(res, 16).reverse(); // LE\n}\n\n// Can be used to replace `computeTag` in chacha.ts. Unused, provided for auditability.\n// @ts-expect-error\nfunction poly1305_computeTag_small(\n  authKey: Uint8Array,\n  lengths: Uint8Array,\n  ciphertext: Uint8Array,\n  AAD?: Uint8Array\n): Uint8Array {\n  const res = [];\n  const updatePadded2 = (msg: Uint8Array) => {\n    res.push(msg);\n    const leftover = msg.length % 16;\n    if (leftover) res.push(new Uint8Array(16).slice(leftover));\n  };\n  if (AAD) updatePadded2(AAD);\n  updatePadded2(ciphertext);\n  res.push(lengths);\n  return poly1305_small(concatBytes(...res), authKey);\n}\n\n/** Poly1305 class. Prefer poly1305() function instead. */\nexport class Poly1305 implements IHash2 {\n  readonly blockLen = 16;\n  readonly outputLen = 16;\n  private buffer = new Uint8Array(16);\n  private r = new Uint16Array(10); // Allocating 1 array with .subarray() here is slower than 3\n  private h = new Uint16Array(10);\n  private pad = new Uint16Array(8);\n  private pos = 0;\n  protected finished = false;\n\n  // Can be speed-up using BigUint64Array, at the cost of complexity\n  constructor(key: Uint8Array) {\n    key = copyBytes(abytes(key, 32, 'key'));\n    const t0 = u8to16(key, 0);\n    const t1 = u8to16(key, 2);\n    const t2 = u8to16(key, 4);\n    const t3 = u8to16(key, 6);\n    const t4 = u8to16(key, 8);\n    const t5 = u8to16(key, 10);\n    const t6 = u8to16(key, 12);\n    const t7 = u8to16(key, 14);\n\n    // https://github.com/floodyberry/poly1305-donna/blob/e6ad6e091d30d7f4ec2d4f978be1fcfcbce72781/poly1305-donna-16.h#L47\n    this.r[0] = t0 & 0x1fff;\n    this.r[1] = ((t0 >>> 13) | (t1 << 3)) & 0x1fff;\n    this.r[2] = ((t1 >>> 10) | (t2 << 6)) & 0x1f03;\n    this.r[3] = ((t2 >>> 7) | (t3 << 9)) & 0x1fff;\n    this.r[4] = ((t3 >>> 4) | (t4 << 12)) & 0x00ff;\n    this.r[5] = (t4 >>> 1) & 0x1ffe;\n    this.r[6] = ((t4 >>> 14) | (t5 << 2)) & 0x1fff;\n    this.r[7] = ((t5 >>> 11) | (t6 << 5)) & 0x1f81;\n    this.r[8] = ((t6 >>> 8) | (t7 << 8)) & 0x1fff;\n    this.r[9] = (t7 >>> 5) & 0x007f;\n    for (let i = 0; i < 8; i++) this.pad[i] = u8to16(key, 16 + 2 * i);\n  }\n\n  private process(data: Uint8Array, offset: number, isLast = false) {\n    const hibit = isLast ? 0 : 1 << 11;\n    const { h, r } = this;\n    const r0 = r[0];\n    const r1 = r[1];\n    const r2 = r[2];\n    const r3 = r[3];\n    const r4 = r[4];\n    const r5 = r[5];\n    const r6 = r[6];\n    const r7 = r[7];\n    const r8 = r[8];\n    const r9 = r[9];\n\n    const t0 = u8to16(data, offset + 0);\n    const t1 = u8to16(data, offset + 2);\n    const t2 = u8to16(data, offset + 4);\n    const t3 = u8to16(data, offset + 6);\n    const t4 = u8to16(data, offset + 8);\n    const t5 = u8to16(data, offset + 10);\n    const t6 = u8to16(data, offset + 12);\n    const t7 = u8to16(data, offset + 14);\n\n    let h0 = h[0] + (t0 & 0x1fff);\n    let h1 = h[1] + (((t0 >>> 13) | (t1 << 3)) & 0x1fff);\n    let h2 = h[2] + (((t1 >>> 10) | (t2 << 6)) & 0x1fff);\n    let h3 = h[3] + (((t2 >>> 7) | (t3 << 9)) & 0x1fff);\n    let h4 = h[4] + (((t3 >>> 4) | (t4 << 12)) & 0x1fff);\n    let h5 = h[5] + ((t4 >>> 1) & 0x1fff);\n    let h6 = h[6] + (((t4 >>> 14) | (t5 << 2)) & 0x1fff);\n    let h7 = h[7] + (((t5 >>> 11) | (t6 << 5)) & 0x1fff);\n    let h8 = h[8] + (((t6 >>> 8) | (t7 << 8)) & 0x1fff);\n    let h9 = h[9] + ((t7 >>> 5) | hibit);\n\n    let c = 0;\n\n    let d0 = c + h0 * r0 + h1 * (5 * r9) + h2 * (5 * r8) + h3 * (5 * r7) + h4 * (5 * r6);\n    c = d0 >>> 13;\n    d0 &= 0x1fff;\n    d0 += h5 * (5 * r5) + h6 * (5 * r4) + h7 * (5 * r3) + h8 * (5 * r2) + h9 * (5 * r1);\n    c += d0 >>> 13;\n    d0 &= 0x1fff;\n\n    let d1 = c + h0 * r1 + h1 * r0 + h2 * (5 * r9) + h3 * (5 * r8) + h4 * (5 * r7);\n    c = d1 >>> 13;\n    d1 &= 0x1fff;\n    d1 += h5 * (5 * r6) + h6 * (5 * r5) + h7 * (5 * r4) + h8 * (5 * r3) + h9 * (5 * r2);\n    c += d1 >>> 13;\n    d1 &= 0x1fff;\n\n    let d2 = c + h0 * r2 + h1 * r1 + h2 * r0 + h3 * (5 * r9) + h4 * (5 * r8);\n    c = d2 >>> 13;\n    d2 &= 0x1fff;\n    d2 += h5 * (5 * r7) + h6 * (5 * r6) + h7 * (5 * r5) + h8 * (5 * r4) + h9 * (5 * r3);\n    c += d2 >>> 13;\n    d2 &= 0x1fff;\n\n    let d3 = c + h0 * r3 + h1 * r2 + h2 * r1 + h3 * r0 + h4 * (5 * r9);\n    c = d3 >>> 13;\n    d3 &= 0x1fff;\n    d3 += h5 * (5 * r8) + h6 * (5 * r7) + h7 * (5 * r6) + h8 * (5 * r5) + h9 * (5 * r4);\n    c += d3 >>> 13;\n    d3 &= 0x1fff;\n\n    let d4 = c + h0 * r4 + h1 * r3 + h2 * r2 + h3 * r1 + h4 * r0;\n    c = d4 >>> 13;\n    d4 &= 0x1fff;\n    d4 += h5 * (5 * r9) + h6 * (5 * r8) + h7 * (5 * r7) + h8 * (5 * r6) + h9 * (5 * r5);\n    c += d4 >>> 13;\n    d4 &= 0x1fff;\n\n    let d5 = c + h0 * r5 + h1 * r4 + h2 * r3 + h3 * r2 + h4 * r1;\n    c = d5 >>> 13;\n    d5 &= 0x1fff;\n    d5 += h5 * r0 + h6 * (5 * r9) + h7 * (5 * r8) + h8 * (5 * r7) + h9 * (5 * r6);\n    c += d5 >>> 13;\n    d5 &= 0x1fff;\n\n    let d6 = c + h0 * r6 + h1 * r5 + h2 * r4 + h3 * r3 + h4 * r2;\n    c = d6 >>> 13;\n    d6 &= 0x1fff;\n    d6 += h5 * r1 + h6 * r0 + h7 * (5 * r9) + h8 * (5 * r8) + h9 * (5 * r7);\n    c += d6 >>> 13;\n    d6 &= 0x1fff;\n\n    let d7 = c + h0 * r7 + h1 * r6 + h2 * r5 + h3 * r4 + h4 * r3;\n    c = d7 >>> 13;\n    d7 &= 0x1fff;\n    d7 += h5 * r2 + h6 * r1 + h7 * r0 + h8 * (5 * r9) + h9 * (5 * r8);\n    c += d7 >>> 13;\n    d7 &= 0x1fff;\n\n    let d8 = c + h0 * r8 + h1 * r7 + h2 * r6 + h3 * r5 + h4 * r4;\n    c = d8 >>> 13;\n    d8 &= 0x1fff;\n    d8 += h5 * r3 + h6 * r2 + h7 * r1 + h8 * r0 + h9 * (5 * r9);\n    c += d8 >>> 13;\n    d8 &= 0x1fff;\n\n    let d9 = c + h0 * r9 + h1 * r8 + h2 * r7 + h3 * r6 + h4 * r5;\n    c = d9 >>> 13;\n    d9 &= 0x1fff;\n    d9 += h5 * r4 + h6 * r3 + h7 * r2 + h8 * r1 + h9 * r0;\n    c += d9 >>> 13;\n    d9 &= 0x1fff;\n\n    c = ((c << 2) + c) | 0;\n    c = (c + d0) | 0;\n    d0 = c & 0x1fff;\n    c = c >>> 13;\n    d1 += c;\n\n    h[0] = d0;\n    h[1] = d1;\n    h[2] = d2;\n    h[3] = d3;\n    h[4] = d4;\n    h[5] = d5;\n    h[6] = d6;\n    h[7] = d7;\n    h[8] = d8;\n    h[9] = d9;\n  }\n\n  private finalize() {\n    const { h, pad } = this;\n    const g = new Uint16Array(10);\n    let c = h[1] >>> 13;\n    h[1] &= 0x1fff;\n    for (let i = 2; i < 10; i++) {\n      h[i] += c;\n      c = h[i] >>> 13;\n      h[i] &= 0x1fff;\n    }\n    h[0] += c * 5;\n    c = h[0] >>> 13;\n    h[0] &= 0x1fff;\n    h[1] += c;\n    c = h[1] >>> 13;\n    h[1] &= 0x1fff;\n    h[2] += c;\n\n    g[0] = h[0] + 5;\n    c = g[0] >>> 13;\n    g[0] &= 0x1fff;\n    for (let i = 1; i < 10; i++) {\n      g[i] = h[i] + c;\n      c = g[i] >>> 13;\n      g[i] &= 0x1fff;\n    }\n    g[9] -= 1 << 13;\n\n    let mask = (c ^ 1) - 1;\n    for (let i = 0; i < 10; i++) g[i] &= mask;\n    mask = ~mask;\n    for (let i = 0; i < 10; i++) h[i] = (h[i] & mask) | g[i];\n    h[0] = (h[0] | (h[1] << 13)) & 0xffff;\n    h[1] = ((h[1] >>> 3) | (h[2] << 10)) & 0xffff;\n    h[2] = ((h[2] >>> 6) | (h[3] << 7)) & 0xffff;\n    h[3] = ((h[3] >>> 9) | (h[4] << 4)) & 0xffff;\n    h[4] = ((h[4] >>> 12) | (h[5] << 1) | (h[6] << 14)) & 0xffff;\n    h[5] = ((h[6] >>> 2) | (h[7] << 11)) & 0xffff;\n    h[6] = ((h[7] >>> 5) | (h[8] << 8)) & 0xffff;\n    h[7] = ((h[8] >>> 8) | (h[9] << 5)) & 0xffff;\n\n    let f = h[0] + pad[0];\n    h[0] = f & 0xffff;\n    for (let i = 1; i < 8; i++) {\n      f = (((h[i] + pad[i]) | 0) + (f >>> 16)) | 0;\n      h[i] = f & 0xffff;\n    }\n    clean(g);\n  }\n  update(data: Uint8Array): this {\n    aexists(this);\n    abytes(data);\n    data = copyBytes(data);\n    const { buffer, blockLen } = this;\n    const len = data.length;\n\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\n      if (take === blockLen) {\n        for (; blockLen <= len - pos; pos += blockLen) this.process(data, 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(buffer, 0, false);\n        this.pos = 0;\n      }\n    }\n    return this;\n  }\n  destroy(): void {\n    clean(this.h, this.r, this.buffer, this.pad);\n  }\n  digestInto(out: Uint8Array): Uint8Array {\n    aexists(this);\n    aoutput(out, this);\n    this.finished = true;\n    const { buffer, h } = this;\n    let { pos } = this;\n    if (pos) {\n      buffer[pos++] = 1;\n      for (; pos < 16; pos++) buffer[pos] = 0;\n      this.process(buffer, 0, true);\n    }\n    this.finalize();\n    let opos = 0;\n    for (let i = 0; i < 8; i++) {\n      out[opos++] = h[i] >>> 0;\n      out[opos++] = h[i] >>> 8;\n    }\n    return out;\n  }\n  digest(): Uint8Array {\n    const { buffer, outputLen } = this;\n    this.digestInto(buffer);\n    const res = buffer.slice(0, outputLen);\n    this.destroy();\n    return res;\n  }\n}\n\nexport type CHash = ReturnType<typeof wrapConstructorWithKey>;\nexport function wrapConstructorWithKey<H extends IHash2>(\n  hashCons: (key: Uint8Array) => H\n): {\n  (msg: Uint8Array, key: Uint8Array): Uint8Array;\n  outputLen: number;\n  blockLen: number;\n  create(key: Uint8Array): H;\n} {\n  const hashC = (msg: Uint8Array, key: Uint8Array): Uint8Array =>\n    hashCons(key).update(msg).digest();\n  const tmp = hashCons(new Uint8Array(32)); // tmp array, used just once below\n  hashC.outputLen = tmp.outputLen;\n  hashC.blockLen = tmp.blockLen;\n  hashC.create = (key: Uint8Array) => hashCons(key);\n  return hashC;\n}\n\n/** Poly1305 MAC from RFC 8439. */\nexport const poly1305: CHash = /** @__PURE__ */ (() =>\n  wrapConstructorWithKey((key) => new Poly1305(key)))();\n", "/**\n * HKDF (RFC 5869): extract + expand in one step.\n * See https://soatok.blog/2021/11/17/understanding-hkdf/.\n * @module\n */\nimport { hmac } from './hmac.ts';\nimport { abytes, ahash, anumber, type CHash, clean } from './utils.ts';\n\n/**\n * HKDF-extract from spec. Less important part. `HKDF-Extract(IKM, salt) -> PRK`\n * Arguments position differs from spec (IKM is first one, since it is not optional)\n * @param hash - hash function that would be used (e.g. sha256)\n * @param ikm - input keying material, the initial key\n * @param salt - optional salt value (a non-secret random value)\n */\nexport function extract(hash: CHash, ikm: Uint8Array, salt?: Uint8Array): Uint8Array {\n  ahash(hash);\n  // NOTE: some libraries treat zero-length array as 'not provided';\n  // we don't, since we have undefined as 'not provided'\n  // https://github.com/RustCrypto/KDFs/issues/15\n  if (salt === undefined) salt = new Uint8Array(hash.outputLen);\n  return hmac(hash, salt, ikm);\n}\n\nconst HKDF_COUNTER = /* @__PURE__ */ Uint8Array.of(0);\nconst EMPTY_BUFFER = /* @__PURE__ */ Uint8Array.of();\n\n/**\n * HKDF-expand from the spec. The most important part. `HKDF-Expand(PRK, info, L) -> OKM`\n * @param hash - hash function that would be used (e.g. sha256)\n * @param prk - a pseudorandom key of at least HashLen octets (usually, the output from the extract step)\n * @param info - optional context and application specific information (can be a zero-length string)\n * @param length - length of output keying material in bytes\n */\nexport function expand(\n  hash: CHash,\n  prk: Uint8Array,\n  info?: Uint8Array,\n  length: number = 32\n): Uint8Array {\n  ahash(hash);\n  anumber(length, 'length');\n  const olen = hash.outputLen;\n  if (length > 255 * olen) throw new Error('Length must be <= 255*HashLen');\n  const blocks = Math.ceil(length / olen);\n  if (info === undefined) info = EMPTY_BUFFER;\n  else abytes(info, undefined, 'info');\n  // first L(ength) octets of T\n  const okm = new Uint8Array(blocks * olen);\n  // Re-use HMAC instance between blocks\n  const HMAC = hmac.create(hash, prk);\n  const HMACTmp = HMAC._cloneInto();\n  const T = new Uint8Array(HMAC.outputLen);\n  for (let counter = 0; counter < blocks; counter++) {\n    HKDF_COUNTER[0] = counter + 1;\n    // T(0) = empty string (zero length)\n    // T(N) = HMAC-Hash(PRK, T(N-1) | info | N)\n    HMACTmp.update(counter === 0 ? EMPTY_BUFFER : T)\n      .update(info)\n      .update(HKDF_COUNTER)\n      .digestInto(T);\n    okm.set(T, olen * counter);\n    HMAC._cloneInto(HMACTmp);\n  }\n  HMAC.destroy();\n  HMACTmp.destroy();\n  clean(T, HKDF_COUNTER);\n  return okm.slice(0, length);\n}\n\n/**\n * HKDF (RFC 5869): derive keys from an initial input.\n * Combines hkdf_extract + hkdf_expand in one step\n * @param hash - hash function that would be used (e.g. sha256)\n * @param ikm - input keying material, the initial key\n * @param salt - optional salt value (a non-secret random value)\n * @param info - optional context and application specific information (can be a zero-length string)\n * @param length - length of output keying material in bytes\n * @example\n * import { hkdf } from '@noble/hashes/hkdf';\n * import { sha256 } from '@noble/hashes/sha2';\n * import { randomBytes } from '@noble/hashes/utils';\n * const inputKey = randomBytes(32);\n * const salt = randomBytes(32);\n * const info = 'application-key';\n * const hk1 = hkdf(sha256, inputKey, salt, info, 32);\n */\nexport const hkdf = (\n  hash: CHash,\n  ikm: Uint8Array,\n  salt: Uint8Array | undefined,\n  info: Uint8Array | undefined,\n  length: number\n): Uint8Array => expand(hash, extract(hash, ikm, salt), info, length);\n", "/*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n\nexport interface Coder<F, T> {\n  encode(from: F): T;\n  decode(to: T): F;\n}\n\nexport interface BytesCoder extends Coder<Uint8Array, string> {\n  encode: (data: Uint8Array) => string;\n  decode: (str: string) => Uint8Array;\n}\n\nfunction isBytes(a: unknown): a is Uint8Array {\n  return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');\n}\n/** Asserts something is Uint8Array. */\nfunction abytes(b: Uint8Array | undefined): void {\n  if (!isBytes(b)) throw new Error('Uint8Array expected');\n}\n\nfunction isArrayOf(isString: boolean, arr: any[]) {\n  if (!Array.isArray(arr)) return false;\n  if (arr.length === 0) return true;\n  if (isString) {\n    return arr.every((item) => typeof item === 'string');\n  } else {\n    return arr.every((item) => Number.isSafeInteger(item));\n  }\n}\n\nfunction afn(input: Function): input is Function {\n  if (typeof input !== 'function') throw new Error('function expected');\n  return true;\n}\n\nfunction astr(label: string, input: unknown): input is string {\n  if (typeof input !== 'string') throw new Error(`${label}: string expected`);\n  return true;\n}\n\nfunction anumber(n: number): void {\n  if (!Number.isSafeInteger(n)) throw new Error(`invalid integer: ${n}`);\n}\n\nfunction aArr(input: any[]) {\n  if (!Array.isArray(input)) throw new Error('array expected');\n}\nfunction astrArr(label: string, input: string[]) {\n  if (!isArrayOf(true, input)) throw new Error(`${label}: array of strings expected`);\n}\nfunction anumArr(label: string, input: number[]) {\n  if (!isArrayOf(false, input)) throw new Error(`${label}: array of numbers expected`);\n}\n\n// TODO: some recusive type inference so it would check correct order of input/output inside rest?\n// like <string, number>, <number, bytes>, <bytes, float>\ntype Chain = [Coder<any, any>, ...Coder<any, any>[]];\n// Extract info from Coder type\ntype Input<F> = F extends Coder<infer T, any> ? T : never;\ntype Output<F> = F extends Coder<any, infer T> ? T : never;\n// Generic function for arrays\ntype First<T> = T extends [infer U, ...any[]] ? U : never;\ntype Last<T> = T extends [...any[], infer U] ? U : never;\ntype Tail<T> = T extends [any, ...infer U] ? U : never;\n\ntype AsChain<C extends Chain, Rest = Tail<C>> = {\n  // C[K] = Coder<Input<C[K]>, Input<Rest[k]>>\n  [K in keyof C]: Coder<Input<C[K]>, Input<K extends keyof Rest ? Rest[K] : any>>;\n};\n\n/**\n * @__NO_SIDE_EFFECTS__\n */\nfunction chain<T extends Chain & AsChain<T>>(...args: T): Coder<Input<First<T>>, Output<Last<T>>> {\n  const id = (a: any) => a;\n  // Wrap call in closure so JIT can inline calls\n  const wrap = (a: any, b: any) => (c: any) => a(b(c));\n  // Construct chain of args[-1].encode(args[-2].encode([...]))\n  const encode = args.map((x) => x.encode).reduceRight(wrap, id);\n  // Construct chain of args[0].decode(args[1].decode(...))\n  const decode = args.map((x) => x.decode).reduce(wrap, id);\n  return { encode, decode };\n}\n\n/**\n * Encodes integer radix representation to array of strings using alphabet and back.\n * Could also be array of strings.\n * @__NO_SIDE_EFFECTS__\n */\nfunction alphabet(letters: string | string[]): Coder<number[], string[]> {\n  // mapping 1 to \"b\"\n  const lettersA = typeof letters === 'string' ? letters.split('') : letters;\n  const len = lettersA.length;\n  astrArr('alphabet', lettersA);\n\n  // mapping \"b\" to 1\n  const indexes = new Map(lettersA.map((l, i) => [l, i]));\n  return {\n    encode: (digits: number[]) => {\n      aArr(digits);\n      return digits.map((i) => {\n        if (!Number.isSafeInteger(i) || i < 0 || i >= len)\n          throw new Error(\n            `alphabet.encode: digit index outside alphabet \"${i}\". Allowed: ${letters}`\n          );\n        return lettersA[i]!;\n      });\n    },\n    decode: (input: string[]): number[] => {\n      aArr(input);\n      return input.map((letter) => {\n        astr('alphabet.decode', letter);\n        const i = indexes.get(letter);\n        if (i === undefined) throw new Error(`Unknown letter: \"${letter}\". Allowed: ${letters}`);\n        return i;\n      });\n    },\n  };\n}\n\n/**\n * @__NO_SIDE_EFFECTS__\n */\nfunction join(separator = ''): Coder<string[], string> {\n  astr('join', separator);\n  return {\n    encode: (from) => {\n      astrArr('join.decode', from);\n      return from.join(separator);\n    },\n    decode: (to) => {\n      astr('join.decode', to);\n      return to.split(separator);\n    },\n  };\n}\n\n/**\n * Pad strings array so it has integer number of bits\n * @__NO_SIDE_EFFECTS__\n */\nfunction padding(bits: number, chr = '='): Coder<string[], string[]> {\n  anumber(bits);\n  astr('padding', chr);\n  return {\n    encode(data: string[]): string[] {\n      astrArr('padding.encode', data);\n      while ((data.length * bits) % 8) data.push(chr);\n      return data;\n    },\n    decode(input: string[]): string[] {\n      astrArr('padding.decode', input);\n      let end = input.length;\n      if ((end * bits) % 8)\n        throw new Error('padding: invalid, string should have whole number of bytes');\n      for (; end > 0 && input[end - 1] === chr; end--) {\n        const last = end - 1;\n        const byte = last * bits;\n        if (byte % 8 === 0) throw new Error('padding: invalid, string has too much padding');\n      }\n      return input.slice(0, end);\n    },\n  };\n}\n\n/**\n * @__NO_SIDE_EFFECTS__\n */\nfunction normalize<T>(fn: (val: T) => T): Coder<T, T> {\n  afn(fn);\n  return { encode: (from: T) => from, decode: (to: T) => fn(to) };\n}\n\n/**\n * Slow: O(n^2) time complexity\n */\nfunction convertRadix(data: number[], from: number, to: number): number[] {\n  // base 1 is impossible\n  if (from < 2) throw new Error(`convertRadix: invalid from=${from}, base cannot be less than 2`);\n  if (to < 2) throw new Error(`convertRadix: invalid to=${to}, base cannot be less than 2`);\n  aArr(data);\n  if (!data.length) return [];\n  let pos = 0;\n  const res = [];\n  const digits = Array.from(data, (d) => {\n    anumber(d);\n    if (d < 0 || d >= from) throw new Error(`invalid integer: ${d}`);\n    return d;\n  });\n  const dlen = digits.length;\n  while (true) {\n    let carry = 0;\n    let done = true;\n    for (let i = pos; i < dlen; i++) {\n      const digit = digits[i]!;\n      const fromCarry = from * carry;\n      const digitBase = fromCarry + digit;\n      if (\n        !Number.isSafeInteger(digitBase) ||\n        fromCarry / from !== carry ||\n        digitBase - digit !== fromCarry\n      ) {\n        throw new Error('convertRadix: carry overflow');\n      }\n      const div = digitBase / to;\n      carry = digitBase % to;\n      const rounded = Math.floor(div);\n      digits[i] = rounded;\n      if (!Number.isSafeInteger(rounded) || rounded * to + carry !== digitBase)\n        throw new Error('convertRadix: carry overflow');\n      if (!done) continue;\n      else if (!rounded) pos = i;\n      else done = false;\n    }\n    res.push(carry);\n    if (done) break;\n  }\n  for (let i = 0; i < data.length - 1 && data[i] === 0; i++) res.push(0);\n  return res.reverse();\n}\n\nconst gcd = (a: number, b: number): number => (b === 0 ? a : gcd(b, a % b));\nconst radix2carry = /* @__NO_SIDE_EFFECTS__ */ (from: number, to: number) =>\n  from + (to - gcd(from, to));\nconst powers: number[] = /* @__PURE__ */ (() => {\n  let res = [];\n  for (let i = 0; i < 40; i++) res.push(2 ** i);\n  return res;\n})();\n/**\n * Implemented with numbers, because BigInt is 5x slower\n */\nfunction convertRadix2(data: number[], from: number, to: number, padding: boolean): number[] {\n  aArr(data);\n  if (from <= 0 || from > 32) throw new Error(`convertRadix2: wrong from=${from}`);\n  if (to <= 0 || to > 32) throw new Error(`convertRadix2: wrong to=${to}`);\n  if (radix2carry(from, to) > 32) {\n    throw new Error(\n      `convertRadix2: carry overflow from=${from} to=${to} carryBits=${radix2carry(from, to)}`\n    );\n  }\n  let carry = 0;\n  let pos = 0; // bitwise position in current element\n  const max = powers[from]!;\n  const mask = powers[to]! - 1;\n  const res: number[] = [];\n  for (const n of data) {\n    anumber(n);\n    if (n >= max) throw new Error(`convertRadix2: invalid data word=${n} from=${from}`);\n    carry = (carry << from) | n;\n    if (pos + from > 32) throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from}`);\n    pos += from;\n    for (; pos >= to; pos -= to) res.push(((carry >> (pos - to)) & mask) >>> 0);\n    const pow = powers[pos];\n    if (pow === undefined) throw new Error('invalid carry');\n    carry &= pow - 1; // clean carry, otherwise it will cause overflow\n  }\n  carry = (carry << (to - pos)) & mask;\n  if (!padding && pos >= from) throw new Error('Excess padding');\n  if (!padding && carry > 0) throw new Error(`Non-zero padding: ${carry}`);\n  if (padding && pos > 0) res.push(carry >>> 0);\n  return res;\n}\n\n/**\n * @__NO_SIDE_EFFECTS__\n */\nfunction radix(num: number): Coder<Uint8Array, number[]> {\n  anumber(num);\n  const _256 = 2 ** 8;\n  return {\n    encode: (bytes: Uint8Array) => {\n      if (!isBytes(bytes)) throw new Error('radix.encode input should be Uint8Array');\n      return convertRadix(Array.from(bytes), _256, num);\n    },\n    decode: (digits: number[]) => {\n      anumArr('radix.decode', digits);\n      return Uint8Array.from(convertRadix(digits, num, _256));\n    },\n  };\n}\n\n/**\n * If both bases are power of same number (like `2**8 <-> 2**64`),\n * there is a linear algorithm. For now we have implementation for power-of-two bases only.\n * @__NO_SIDE_EFFECTS__\n */\nfunction radix2(bits: number, revPadding = false): Coder<Uint8Array, number[]> {\n  anumber(bits);\n  if (bits <= 0 || bits > 32) throw new Error('radix2: bits should be in (0..32]');\n  if (radix2carry(8, bits) > 32 || radix2carry(bits, 8) > 32)\n    throw new Error('radix2: carry overflow');\n  return {\n    encode: (bytes: Uint8Array) => {\n      if (!isBytes(bytes)) throw new Error('radix2.encode input should be Uint8Array');\n      return convertRadix2(Array.from(bytes), 8, bits, !revPadding);\n    },\n    decode: (digits: number[]) => {\n      anumArr('radix2.decode', digits);\n      return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding));\n    },\n  };\n}\n\ntype ArgumentTypes<F extends Function> = F extends (...args: infer A) => any ? A : never;\nfunction unsafeWrapper<T extends (...args: any) => any>(fn: T) {\n  afn(fn);\n  return function (...args: ArgumentTypes<T>): ReturnType<T> | void {\n    try {\n      return fn.apply(null, args);\n    } catch (e) {}\n  };\n}\n\nfunction checksum(\n  len: number,\n  fn: (data: Uint8Array) => Uint8Array\n): Coder<Uint8Array, Uint8Array> {\n  anumber(len);\n  afn(fn);\n  return {\n    encode(data: Uint8Array) {\n      if (!isBytes(data)) throw new Error('checksum.encode: input should be Uint8Array');\n      const sum = fn(data).slice(0, len);\n      const res = new Uint8Array(data.length + len);\n      res.set(data);\n      res.set(sum, data.length);\n      return res;\n    },\n    decode(data: Uint8Array) {\n      if (!isBytes(data)) throw new Error('checksum.decode: input should be Uint8Array');\n      const payload = data.slice(0, -len);\n      const oldChecksum = data.slice(-len);\n      const newChecksum = fn(payload).slice(0, len);\n      for (let i = 0; i < len; i++)\n        if (newChecksum[i] !== oldChecksum[i]) throw new Error('Invalid checksum');\n      return payload;\n    },\n  };\n}\n\n// prettier-ignore\nexport const utils: { alphabet: typeof alphabet; chain: typeof chain; checksum: typeof checksum; convertRadix: typeof convertRadix; convertRadix2: typeof convertRadix2; radix: typeof radix; radix2: typeof radix2; join: typeof join; padding: typeof padding; } = {\n  alphabet, chain, checksum, convertRadix, convertRadix2, radix, radix2, join, padding,\n};\n\n// RFC 4648 aka RFC 3548\n// ---------------------\n\n/**\n * base16 encoding from RFC 4648.\n * @example\n * ```js\n * base16.encode(Uint8Array.from([0x12, 0xab]));\n * // => '12AB'\n * ```\n */\nexport const base16: BytesCoder = chain(radix2(4), alphabet('0123456789ABCDEF'), join(''));\n\n/**\n * base32 encoding from RFC 4648. Has padding.\n * Use `base32nopad` for unpadded version.\n * Also check out `base32hex`, `base32hexnopad`, `base32crockford`.\n * @example\n * ```js\n * base32.encode(Uint8Array.from([0x12, 0xab]));\n * // => 'CKVQ===='\n * base32.decode('CKVQ====');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\nexport const base32: BytesCoder = chain(\n  radix2(5),\n  alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'),\n  padding(5),\n  join('')\n);\n\n/**\n * base32 encoding from RFC 4648. No padding.\n * Use `base32` for padded version.\n * Also check out `base32hex`, `base32hexnopad`, `base32crockford`.\n * @example\n * ```js\n * base32nopad.encode(Uint8Array.from([0x12, 0xab]));\n * // => 'CKVQ'\n * base32nopad.decode('CKVQ');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\nexport const base32nopad: BytesCoder = chain(\n  radix2(5),\n  alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'),\n  join('')\n);\n/**\n * base32 encoding from RFC 4648. Padded. Compared to ordinary `base32`, slightly different alphabet.\n * Use `base32hexnopad` for unpadded version.\n * @example\n * ```js\n * base32hex.encode(Uint8Array.from([0x12, 0xab]));\n * // => '2ALG===='\n * base32hex.decode('2ALG====');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\nexport const base32hex: BytesCoder = chain(\n  radix2(5),\n  alphabet('0123456789ABCDEFGHIJKLMNOPQRSTUV'),\n  padding(5),\n  join('')\n);\n\n/**\n * base32 encoding from RFC 4648. No padding. Compared to ordinary `base32`, slightly different alphabet.\n * Use `base32hex` for padded version.\n * @example\n * ```js\n * base32hexnopad.encode(Uint8Array.from([0x12, 0xab]));\n * // => '2ALG'\n * base32hexnopad.decode('2ALG');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\nexport const base32hexnopad: BytesCoder = chain(\n  radix2(5),\n  alphabet('0123456789ABCDEFGHIJKLMNOPQRSTUV'),\n  join('')\n);\n/**\n * base32 encoding from RFC 4648. Doug Crockford's version.\n * https://www.crockford.com/base32.html\n * @example\n * ```js\n * base32crockford.encode(Uint8Array.from([0x12, 0xab]));\n * // => '2ANG'\n * base32crockford.decode('2ANG');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\nexport const base32crockford: BytesCoder = chain(\n  radix2(5),\n  alphabet('0123456789ABCDEFGHJKMNPQRSTVWXYZ'),\n  join(''),\n  normalize((s: string) => s.toUpperCase().replace(/O/g, '0').replace(/[IL]/g, '1'))\n);\n\n// Built-in base64 conversion https://caniuse.com/mdn-javascript_builtins_uint8array_frombase64\n// prettier-ignore\nconst hasBase64Builtin: boolean = /* @__PURE__ */ (() =>\n  typeof (Uint8Array as any).from([]).toBase64 === 'function' &&\n  typeof (Uint8Array as any).fromBase64 === 'function')();\n\nconst decodeBase64Builtin = (s: string, isUrl: boolean) => {\n  astr('base64', s);\n  const re = isUrl ? /^[A-Za-z0-9=_-]+$/ : /^[A-Za-z0-9=+/]+$/;\n  const alphabet = isUrl ? 'base64url' : 'base64';\n  if (s.length > 0 && !re.test(s)) throw new Error('invalid base64');\n  return (Uint8Array as any).fromBase64(s, { alphabet, lastChunkHandling: 'strict' });\n};\n\n/**\n * base64 from RFC 4648. Padded.\n * Use `base64nopad` for unpadded version.\n * Also check out `base64url`, `base64urlnopad`.\n * Falls back to built-in function, when available.\n * @example\n * ```js\n * base64.encode(Uint8Array.from([0x12, 0xab]));\n * // => 'Eqs='\n * base64.decode('Eqs=');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\n// prettier-ignore\nexport const base64: BytesCoder = hasBase64Builtin ? {\n  encode(b) { abytes(b); return (b as any).toBase64(); },\n  decode(s) { return decodeBase64Builtin(s, false); },\n} : chain(\n  radix2(6),\n  alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'),\n  padding(6),\n  join('')\n);\n/**\n * base64 from RFC 4648. No padding.\n * Use `base64` for padded version.\n * @example\n * ```js\n * base64nopad.encode(Uint8Array.from([0x12, 0xab]));\n * // => 'Eqs'\n * base64nopad.decode('Eqs');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\nexport const base64nopad: BytesCoder = chain(\n  radix2(6),\n  alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'),\n  join('')\n);\n\n/**\n * base64 from RFC 4648, using URL-safe alphabet. Padded.\n * Use `base64urlnopad` for unpadded version.\n * Falls back to built-in function, when available.\n * @example\n * ```js\n * base64url.encode(Uint8Array.from([0x12, 0xab]));\n * // => 'Eqs='\n * base64url.decode('Eqs=');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\n// prettier-ignore\nexport const base64url: BytesCoder = hasBase64Builtin ? {\n  encode(b) { abytes(b); return (b as any).toBase64({ alphabet: 'base64url' }); },\n  decode(s) { return decodeBase64Builtin(s, true); },\n} : chain(\n  radix2(6),\n  alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'),\n  padding(6),\n  join('')\n);\n\n/**\n * base64 from RFC 4648, using URL-safe alphabet. No padding.\n * Use `base64url` for padded version.\n * @example\n * ```js\n * base64urlnopad.encode(Uint8Array.from([0x12, 0xab]));\n * // => 'Eqs'\n * base64urlnopad.decode('Eqs');\n * // => Uint8Array.from([0x12, 0xab])\n * ```\n */\nexport const base64urlnopad: BytesCoder = chain(\n  radix2(6),\n  alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'),\n  join('')\n);\n\n// base58 code\n// -----------\nconst genBase58 = /* @__NO_SIDE_EFFECTS__ */ (abc: string) =>\n  chain(radix(58), alphabet(abc), join(''));\n\n/**\n * base58: base64 without ambigous characters +, /, 0, O, I, l.\n * Quadratic (O(n^2)) - so, can't be used on large inputs.\n * @example\n * ```js\n * base58.decode('01abcdef');\n * // => '3UhJW'\n * ```\n */\nexport const base58: BytesCoder = genBase58(\n  '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'\n);\n/**\n * base58: flickr version. Check out `base58`.\n */\nexport const base58flickr: BytesCoder = genBase58(\n  '123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'\n);\n/**\n * base58: XRP version. Check out `base58`.\n */\nexport const base58xrp: BytesCoder = genBase58(\n  'rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz'\n);\n\n// Data len (index) -> encoded block len\nconst XMR_BLOCK_LEN = [0, 2, 3, 5, 6, 7, 9, 10, 11];\n\n/**\n * base58: XMR version. Check out `base58`.\n * Done in 8-byte blocks (which equals 11 chars in decoding). Last (non-full) block padded with '1' to size in XMR_BLOCK_LEN.\n * Block encoding significantly reduces quadratic complexity of base58.\n */\nexport const base58xmr: BytesCoder = {\n  encode(data: Uint8Array) {\n    let res = '';\n    for (let i = 0; i < data.length; i += 8) {\n      const block = data.subarray(i, i + 8);\n      res += base58.encode(block).padStart(XMR_BLOCK_LEN[block.length]!, '1');\n    }\n    return res;\n  },\n  decode(str: string) {\n    let res: number[] = [];\n    for (let i = 0; i < str.length; i += 11) {\n      const slice = str.slice(i, i + 11);\n      const blockLen = XMR_BLOCK_LEN.indexOf(slice.length);\n      const block = base58.decode(slice);\n      for (let j = 0; j < block.length - blockLen; j++) {\n        if (block[j] !== 0) throw new Error('base58xmr: wrong padding');\n      }\n      res = res.concat(Array.from(block.slice(block.length - blockLen)));\n    }\n    return Uint8Array.from(res);\n  },\n};\n\n/**\n * Method, which creates base58check encoder.\n * Requires function, calculating sha256.\n */\nexport const createBase58check = (sha256: (data: Uint8Array) => Uint8Array): BytesCoder =>\n  chain(\n    checksum(4, (data) => sha256(sha256(data))),\n    base58\n  );\n\n/**\n * Use `createBase58check` instead.\n * @deprecated\n */\nexport const base58check: (sha256: (data: Uint8Array) => Uint8Array) => BytesCoder =\n  createBase58check;\n\n// Bech32 code\n// -----------\nexport interface Bech32Decoded<Prefix extends string = string> {\n  prefix: Prefix;\n  words: number[];\n}\nexport interface Bech32DecodedWithArray<Prefix extends string = string> {\n  prefix: Prefix;\n  words: number[];\n  bytes: Uint8Array;\n}\n\nconst BECH_ALPHABET: Coder<number[], string> = chain(\n  alphabet('qpzry9x8gf2tvdw0s3jn54khce6mua7l'),\n  join('')\n);\n\nconst POLYMOD_GENERATORS = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3];\nfunction bech32Polymod(pre: number): number {\n  const b = pre >> 25;\n  let chk = (pre & 0x1ffffff) << 5;\n  for (let i = 0; i < POLYMOD_GENERATORS.length; i++) {\n    if (((b >> i) & 1) === 1) chk ^= POLYMOD_GENERATORS[i]!;\n  }\n  return chk;\n}\n\nfunction bechChecksum(prefix: string, words: number[], encodingConst = 1): string {\n  const len = prefix.length;\n  let chk = 1;\n  for (let i = 0; i < len; i++) {\n    const c = prefix.charCodeAt(i);\n    if (c < 33 || c > 126) throw new Error(`Invalid prefix (${prefix})`);\n    chk = bech32Polymod(chk) ^ (c >> 5);\n  }\n  chk = bech32Polymod(chk);\n  for (let i = 0; i < len; i++) chk = bech32Polymod(chk) ^ (prefix.charCodeAt(i) & 0x1f);\n  for (let v of words) chk = bech32Polymod(chk) ^ v;\n  for (let i = 0; i < 6; i++) chk = bech32Polymod(chk);\n  chk ^= encodingConst;\n  return BECH_ALPHABET.encode(convertRadix2([chk % powers[30]!], 30, 5, false));\n}\n\nexport interface Bech32 {\n  encode<Prefix extends string>(\n    prefix: Prefix,\n    words: number[] | Uint8Array,\n    limit?: number | false\n  ): `${Lowercase<Prefix>}1${string}`;\n  decode<Prefix extends string>(\n    str: `${Prefix}1${string}`,\n    limit?: number | false\n  ): Bech32Decoded<Prefix>;\n  encodeFromBytes(prefix: string, bytes: Uint8Array): string;\n  decodeToBytes(str: string): Bech32DecodedWithArray;\n  decodeUnsafe(str: string, limit?: number | false): void | Bech32Decoded<string>;\n  fromWords(to: number[]): Uint8Array;\n  fromWordsUnsafe(to: number[]): void | Uint8Array;\n  toWords(from: Uint8Array): number[];\n}\n/**\n * @__NO_SIDE_EFFECTS__\n */\nfunction genBech32(encoding: 'bech32' | 'bech32m'): Bech32 {\n  const ENCODING_CONST = encoding === 'bech32' ? 1 : 0x2bc830a3;\n  const _words = radix2(5);\n  const fromWords = _words.decode;\n  const toWords = _words.encode;\n  const fromWordsUnsafe = unsafeWrapper(fromWords);\n\n  function encode<Prefix extends string>(\n    prefix: Prefix,\n    words: number[] | Uint8Array,\n    limit: number | false = 90\n  ): `${Lowercase<Prefix>}1${string}` {\n    astr('bech32.encode prefix', prefix);\n    if (isBytes(words)) words = Array.from(words);\n    anumArr('bech32.encode', words);\n    const plen = prefix.length;\n    if (plen === 0) throw new TypeError(`Invalid prefix length ${plen}`);\n    const actualLength = plen + 7 + words.length;\n    if (limit !== false && actualLength > limit)\n      throw new TypeError(`Length ${actualLength} exceeds limit ${limit}`);\n    const lowered = prefix.toLowerCase();\n    const sum = bechChecksum(lowered, words, ENCODING_CONST);\n    return `${lowered}1${BECH_ALPHABET.encode(words)}${sum}` as `${Lowercase<Prefix>}1${string}`;\n  }\n\n  function decode<Prefix extends string>(\n    str: `${Prefix}1${string}`,\n    limit?: number | false\n  ): Bech32Decoded<Prefix>;\n  function decode(str: string, limit?: number | false): Bech32Decoded;\n  function decode(str: string, limit: number | false = 90): Bech32Decoded {\n    astr('bech32.decode input', str);\n    const slen = str.length;\n    if (slen < 8 || (limit !== false && slen > limit))\n      throw new TypeError(`invalid string length: ${slen} (${str}). Expected (8..${limit})`);\n    // don't allow mixed case\n    const lowered = str.toLowerCase();\n    if (str !== lowered && str !== str.toUpperCase())\n      throw new Error(`String must be lowercase or uppercase`);\n    const sepIndex = lowered.lastIndexOf('1');\n    if (sepIndex === 0 || sepIndex === -1)\n      throw new Error(`Letter \"1\" must be present between prefix and data only`);\n    const prefix = lowered.slice(0, sepIndex);\n    const data = lowered.slice(sepIndex + 1);\n    if (data.length < 6) throw new Error('Data must be at least 6 characters long');\n    const words = BECH_ALPHABET.decode(data).slice(0, -6);\n    const sum = bechChecksum(prefix, words, ENCODING_CONST);\n    if (!data.endsWith(sum)) throw new Error(`Invalid checksum in ${str}: expected \"${sum}\"`);\n    return { prefix, words };\n  }\n\n  const decodeUnsafe = unsafeWrapper(decode);\n\n  function decodeToBytes(str: string): Bech32DecodedWithArray {\n    const { prefix, words } = decode(str, false);\n    return { prefix, words, bytes: fromWords(words) };\n  }\n\n  function encodeFromBytes(prefix: string, bytes: Uint8Array) {\n    return encode(prefix, toWords(bytes));\n  }\n\n  return {\n    encode,\n    decode,\n    encodeFromBytes,\n    decodeToBytes,\n    decodeUnsafe,\n    fromWords,\n    fromWordsUnsafe,\n    toWords,\n  };\n}\n\n/**\n * bech32 from BIP 173. Operates on words.\n * For high-level, check out scure-btc-signer:\n * https://github.com/paulmillr/scure-btc-signer.\n */\nexport const bech32: Bech32 = genBech32('bech32');\n\n/**\n * bech32m from BIP 350. Operates on words.\n * It was to mitigate `bech32` weaknesses.\n * For high-level, check out scure-btc-signer:\n * https://github.com/paulmillr/scure-btc-signer.\n */\nexport const bech32m: Bech32 = genBech32('bech32m');\n\ndeclare const TextEncoder: any;\ndeclare const TextDecoder: any;\n\n/**\n * UTF-8-to-byte decoder. Uses built-in TextDecoder / TextEncoder.\n * @example\n * ```js\n * const b = utf8.decode(\"hey\"); // => new Uint8Array([ 104, 101, 121 ])\n * const str = utf8.encode(b); // \"hey\"\n * ```\n */\nexport const utf8: BytesCoder = {\n  encode: (data) => new TextDecoder().decode(data),\n  decode: (str) => new TextEncoder().encode(str),\n};\n\n// Built-in hex conversion https://caniuse.com/mdn-javascript_builtins_uint8array_fromhex\n// prettier-ignore\nconst hasHexBuiltin: boolean = /* @__PURE__ */ (() =>\n  typeof (Uint8Array as any).from([]).toHex === 'function' &&\n  typeof (Uint8Array as any).fromHex === 'function')();\n// prettier-ignore\nconst hexBuiltin: BytesCoder = {\n  encode(data) { abytes(data); return (data as any).toHex(); },\n  decode(s) { astr('hex', s); return (Uint8Array as any).fromHex(s); },\n};\n/**\n * hex string decoder. Uses built-in function, when available.\n * @example\n * ```js\n * const b = hex.decode(\"0102ff\"); // => new Uint8Array([ 1, 2, 255 ])\n * const str = hex.encode(b); // \"0102ff\"\n * ```\n */\nexport const hex: BytesCoder = hasHexBuiltin\n  ? hexBuiltin\n  : chain(\n      radix2(4),\n      alphabet('0123456789abcdef'),\n      join(''),\n      normalize((s: string) => {\n        if (typeof s !== 'string' || s.length % 2 !== 0)\n          throw new TypeError(\n            `hex.decode: expected string, got ${typeof s} with length ${s.length}`\n          );\n        return s.toLowerCase();\n      })\n    );\n\nexport type SomeCoders = {\n  utf8: BytesCoder;\n  hex: BytesCoder;\n  base16: BytesCoder;\n  base32: BytesCoder;\n  base64: BytesCoder;\n  base64url: BytesCoder;\n  base58: BytesCoder;\n  base58xmr: BytesCoder;\n};\n// prettier-ignore\nconst CODERS: SomeCoders = {\n  utf8, hex, base16, base32, base64, base64url, base58, base58xmr\n};\ntype CoderType = keyof SomeCoders;\nconst coderTypeError =\n  'Invalid encoding type. Available types: utf8, hex, base16, base32, base64, base64url, base58, base58xmr';\n\n/** @deprecated */\nexport const bytesToString = (type: CoderType, bytes: Uint8Array): string => {\n  if (typeof type !== 'string' || !CODERS.hasOwnProperty(type)) throw new TypeError(coderTypeError);\n  if (!isBytes(bytes)) throw new TypeError('bytesToString() expects Uint8Array');\n  return CODERS[type].encode(bytes);\n};\n\n/** @deprecated */\nexport const str: (type: CoderType, bytes: Uint8Array) => string = bytesToString; // as in python, but for bytes only\n\n/** @deprecated */\nexport const stringToBytes = (type: CoderType, str: string): Uint8Array => {\n  if (!CODERS.hasOwnProperty(type)) throw new TypeError(coderTypeError);\n  if (typeof str !== 'string') throw new TypeError('stringToBytes() expects string');\n  return CODERS[type].decode(str);\n};\n/** @deprecated */\nexport const bytes: (type: CoderType, str: string) => Uint8Array = stringToBytes;\n", "/**\n * @module nips/nip-46\n * @description Implementation of NIP-46 (Nostr Connect / Remote Signing)\n *\n * Pure protocol layer \u2014 crypto, encoding, message formatting.\n * No WebSocket, no relay connections, no I/O.\n * Consumers provide their own transport.\n *\n * @see https://github.com/nostr-protocol/nips/blob/master/46.md\n */\n\nimport { schnorr } from '@noble/curves/secp256k1.js';\nimport { bytesToHex, hexToBytes, randomBytes } from '@noble/hashes/utils.js';\nimport { sha256 } from '@noble/hashes/sha2.js';\nimport {\n  getConversationKey as nip44GetConversationKey,\n  encrypt as nip44Encrypt,\n  decrypt as nip44Decrypt,\n} from './nip-44';\nimport type {\n  BunkerURI,\n  BunkerValidationResult,\n  Nip46Request,\n  Nip46Response,\n  Nip46Session,\n  Nip46SessionInfo,\n  SignedNostrEvent,\n} from '../types';\nimport { Nip46Method } from '../types';\n\n// \u2500\u2500\u2500 1. Bunker URI \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n/**\n * Parse a bunker:// URI into its components\n * @param uri - bunker://&lt;remote-pubkey&gt;?relay=...&secret=...\n * @returns Parsed BunkerURI or throws on invalid input\n */\nexport function parseBunkerURI(uri: string): BunkerURI {\n  if (!uri.startsWith('bunker://')) {\n    throw new Error('invalid bunker URI: must start with bunker://');\n  }\n\n  const url = new URL(uri.replace('bunker://', 'https://'));\n  const remotePubkey = url.hostname;\n\n  if (!/^[0-9a-f]{64}$/.test(remotePubkey)) {\n    throw new Error('invalid bunker URI: remote pubkey must be 64 hex characters');\n  }\n\n  const relays = url.searchParams.getAll('relay');\n  if (relays.length === 0) {\n    throw new Error('invalid bunker URI: at least one relay is required');\n  }\n\n  const secret = url.searchParams.get('secret') || undefined;\n\n  return { remotePubkey, relays, secret };\n}\n\n/**\n * Create a bunker:// URI string\n * @param remotePubkey - Remote signer's public key (hex)\n * @param relays - Relay URLs\n * @param secret - Optional connection secret\n * @returns bunker:// URI string\n */\nexport function createBunkerURI(remotePubkey: string, relays: string[], secret?: string): string {\n  if (!/^[0-9a-f]{64}$/.test(remotePubkey)) {\n    throw new Error('remotePubkey must be 64 hex characters');\n  }\n  if (relays.length === 0) {\n    throw new Error('at least one relay is required');\n  }\n\n  const params = relays.map(r => `relay=${encodeURIComponent(r)}`);\n  if (secret) {\n    params.push(`secret=${encodeURIComponent(secret)}`);\n  }\n\n  return `bunker://${remotePubkey}?${params.join('&')}`;\n}\n\n/**\n * Validate a bunker:// URI and return structured result\n */\nexport function validateBunkerURI(uri: string): BunkerValidationResult {\n  try {\n    const parsed = parseBunkerURI(uri);\n    return { isValid: true, uri: parsed };\n  } catch (e) {\n    return { isValid: false, error: (e as Error).message };\n  }\n}\n\n// \u2500\u2500\u2500 2. Session Management \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n/**\n * Create a new NIP-46 session with an ephemeral keypair\n * @param remotePubkey - Remote signer's public key (hex)\n * @returns Session containing ephemeral keys and NIP-44 conversation key\n */\nexport function createSession(remotePubkey: string): Nip46Session {\n  if (!/^[0-9a-f]{64}$/.test(remotePubkey)) {\n    throw new Error('remotePubkey must be 64 hex characters');\n  }\n\n  const clientSecretKeyBytes = randomBytes(32);\n  const clientSecretKey = bytesToHex(clientSecretKeyBytes);\n  const clientPubkeyBytes = schnorr.getPublicKey(clientSecretKeyBytes);\n  const clientPubkey = bytesToHex(clientPubkeyBytes);\n\n  const conversationKey = nip44GetConversationKey(clientSecretKeyBytes, remotePubkey);\n\n  return {\n    clientSecretKey,\n    clientPubkey,\n    remotePubkey,\n    conversationKey,\n  };\n}\n\n/**\n * Restore a session from a previously saved ephemeral private key\n * @param clientSecretKey - Hex-encoded ephemeral private key\n * @param remotePubkey - Remote signer's public key (hex)\n * @returns Restored session\n */\nexport function restoreSession(clientSecretKey: string, remotePubkey: string): Nip46Session {\n  const clientSecretKeyBytes = hexToBytes(clientSecretKey);\n  const clientPubkeyBytes = schnorr.getPublicKey(clientSecretKeyBytes);\n  const clientPubkey = bytesToHex(clientPubkeyBytes);\n\n  const conversationKey = nip44GetConversationKey(clientSecretKeyBytes, remotePubkey);\n\n  return {\n    clientSecretKey,\n    clientPubkey,\n    remotePubkey,\n    conversationKey,\n  };\n}\n\n/**\n * Get public session info (safe to expose)\n */\nexport function getSessionInfo(session: Nip46Session): Nip46SessionInfo {\n  return {\n    clientPubkey: session.clientPubkey,\n    remotePubkey: session.remotePubkey,\n  };\n}\n\n// \u2500\u2500\u2500 3. JSON-RPC Messages \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n/**\n * Create a NIP-46 JSON-RPC request\n * @param method - RPC method name\n * @param params - Array of string parameters\n * @param id - Optional request ID (random if not provided)\n * @returns JSON-RPC request object\n */\nexport function createRequest(method: Nip46Method | string, params: string[], id?: string): Nip46Request {\n  return {\n    id: id || bytesToHex(randomBytes(16)),\n    method,\n    params,\n  };\n}\n\n/**\n * Create a NIP-46 JSON-RPC response\n * @param id - Request ID being responded to\n * @param result - Result string (on success)\n * @param error - Error string (on failure)\n * @returns JSON-RPC response object\n */\nexport function createResponse(id: string, result?: string, error?: string): Nip46Response {\n  const response: Nip46Response = { id };\n  if (result !== undefined) response.result = result;\n  if (error !== undefined) response.error = error;\n  return response;\n}\n\n/**\n * Parse a JSON string into a NIP-46 request or response\n * @param json - JSON string to parse\n * @returns Parsed request or response\n */\nexport function parsePayload(json: string): Nip46Request | Nip46Response {\n  const obj = JSON.parse(json) as Record<string, unknown>;\n  if (typeof obj.id !== 'string') {\n    throw new Error('invalid NIP-46 payload: missing id');\n  }\n  return obj as unknown as Nip46Request | Nip46Response;\n}\n\n/**\n * Check if a payload is a NIP-46 request\n */\nexport function isRequest(payload: Nip46Request | Nip46Response): payload is Nip46Request {\n  return 'method' in payload && 'params' in payload;\n}\n\n/**\n * Check if a payload is a NIP-46 response\n */\nexport function isResponse(payload: Nip46Request | Nip46Response): payload is Nip46Response {\n  return 'result' in payload || 'error' in payload;\n}\n\n// \u2500\u2500\u2500 4. Event Wrapping (Kind 24133) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n/**\n * Encrypt and wrap a NIP-46 payload into a kind 24133 signed event\n * @param payload - JSON-RPC request or response to encrypt\n * @param session - NIP-46 session\n * @param recipientPubkey - The recipient's pubkey (hex)\n * @returns Signed kind 24133 event\n */\nexport async function wrapEvent(\n  payload: Nip46Request | Nip46Response,\n  session: Nip46Session,\n  recipientPubkey: string\n): Promise<SignedNostrEvent> {\n  const json = JSON.stringify(payload);\n  const encrypted = nip44Encrypt(json, session.conversationKey);\n\n  const created_at = Math.floor(Date.now() / 1000);\n  const event = {\n    kind: 24133,\n    created_at,\n    tags: [['p', recipientPubkey]],\n    content: encrypted,\n    pubkey: session.clientPubkey,\n  };\n\n  // Serialize for NIP-01 event ID\n  const serialized = JSON.stringify([\n    0,\n    event.pubkey,\n    event.created_at,\n    event.kind,\n    event.tags,\n    event.content,\n  ]);\n\n  const eventHash = sha256(new TextEncoder().encode(serialized));\n  const privateKeyBytes = hexToBytes(session.clientSecretKey);\n  const signatureBytes = schnorr.sign(eventHash, privateKeyBytes);\n\n  return {\n    ...event,\n    id: bytesToHex(eventHash),\n    sig: bytesToHex(signatureBytes),\n  };\n}\n\n/**\n * Decrypt and parse a kind 24133 event\n * @param event - Signed kind 24133 event\n * @param session - NIP-46 session\n * @returns Decrypted JSON-RPC request or response\n */\nexport function unwrapEvent(\n  event: SignedNostrEvent,\n  session: Nip46Session\n): Nip46Request | Nip46Response {\n  if (event.kind !== 24133) {\n    throw new Error(`expected kind 24133, got ${event.kind}`);\n  }\n\n  const json = nip44Decrypt(event.content, session.conversationKey);\n  return parsePayload(json);\n}\n\n// \u2500\u2500\u2500 5. Convenience Request Creators \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n/**\n * Create a 'connect' request\n * @param remotePubkey - Remote signer's pubkey\n * @param secret - Optional connection secret from bunker URI\n * @param permissions - Optional comma-separated permission string\n */\nexport function connectRequest(remotePubkey: string, secret?: string, permissions?: string): Nip46Request {\n  const params = [remotePubkey];\n  if (secret) params.push(secret);\n  else if (permissions) params.push('');\n  if (permissions) params.push(permissions);\n  return createRequest(Nip46Method.CONNECT, params);\n}\n\n/** Create a 'ping' request */\nexport function pingRequest(): Nip46Request {\n  return createRequest(Nip46Method.PING, []);\n}\n\n/** Create a 'get_public_key' request */\nexport function getPublicKeyRequest(): Nip46Request {\n  return createRequest(Nip46Method.GET_PUBLIC_KEY, []);\n}\n\n/**\n * Create a 'sign_event' request\n * @param eventJson - JSON-stringified unsigned event\n */\nexport function signEventRequest(eventJson: string): Nip46Request {\n  return createRequest(Nip46Method.SIGN_EVENT, [eventJson]);\n}\n\n/**\n * Create a 'nip04_encrypt' request\n * @param thirdPartyPubkey - Public key of the message recipient\n * @param plaintext - Message to encrypt\n */\nexport function nip04EncryptRequest(thirdPartyPubkey: string, plaintext: string): Nip46Request {\n  return createRequest(Nip46Method.NIP04_ENCRYPT, [thirdPartyPubkey, plaintext]);\n}\n\n/**\n * Create a 'nip04_decrypt' request\n * @param thirdPartyPubkey - Public key of the message sender\n * @param ciphertext - Encrypted message to decrypt\n */\nexport function nip04DecryptRequest(thirdPartyPubkey: string, ciphertext: string): Nip46Request {\n  return createRequest(Nip46Method.NIP04_DECRYPT, [thirdPartyPubkey, ciphertext]);\n}\n\n/**\n * Create a 'nip44_encrypt' request\n * @param thirdPartyPubkey - Public key of the message recipient\n * @param plaintext - Message to encrypt\n */\nexport function nip44EncryptRequest(thirdPartyPubkey: string, plaintext: string): Nip46Request {\n  return createRequest(Nip46Method.NIP44_ENCRYPT, [thirdPartyPubkey, plaintext]);\n}\n\n/**\n * Create a 'nip44_decrypt' request\n * @param thirdPartyPubkey - Public key of the message sender\n * @param ciphertext - Encrypted message to decrypt\n */\nexport function nip44DecryptRequest(thirdPartyPubkey: string, ciphertext: string): Nip46Request {\n  return createRequest(Nip46Method.NIP44_DECRYPT, [thirdPartyPubkey, ciphertext]);\n}\n\n/** Create a 'get_relays' request */\nexport function getRelaysRequest(): Nip46Request {\n  return createRequest(Nip46Method.GET_RELAYS, []);\n}\n\n// \u2500\u2500\u2500 6. Filter Helper \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n/**\n * Create a Nostr filter for subscribing to NIP-46 response events\n * @param clientPubkey - Our ephemeral public key (hex)\n * @param since - Optional since timestamp\n * @returns Filter object for kind 24133 events tagged to us\n */\nexport function createResponseFilter(\n  clientPubkey: string,\n  since?: number\n): { kinds: number[]; '#p': string[]; since?: number } {\n  const filter: { kinds: number[]; '#p': string[]; since?: number } = {\n    kinds: [24133],\n    '#p': [clientPubkey],\n  };\n  if (since !== undefined) {\n    filter.since = since;\n  }\n  return filter;\n}\n", "/**\n * @module nips/nip-49\n * @description Implementation of NIP-49 (Private Key Encryption / ncryptsec)\n * @see https://github.com/nostr-protocol/nips/blob/master/49.md\n */\n\nimport { xchacha20poly1305 } from '@noble/ciphers/chacha.js';\nimport { scrypt } from '@noble/hashes/scrypt.js';\nimport { concatBytes, randomBytes } from '@noble/hashes/utils.js';\nimport { bech32 as scureBech32 } from '@scure/base';\n\ntype KeySecurityByte = 0x00 | 0x01 | 0x02;\n\n/**\n * Encrypt a Nostr private key with a password, producing an ncryptsec bech32 string\n * @param sec - 32-byte secret key\n * @param password - Password for encryption\n * @param logn - Scrypt log2(N) parameter (default: 16, meaning N=65536)\n * @param ksb - Key security byte: 0x00=unknown, 0x01=unsafe, 0x02=safe (default: 0x02)\n * @returns bech32-encoded ncryptsec string\n */\nexport function encrypt(\n  sec: Uint8Array,\n  password: string,\n  logn: number = 16,\n  ksb: KeySecurityByte = 0x02\n): string {\n  const salt = randomBytes(16);\n  const n = 2 ** logn;\n  const normalizedPassword = password.normalize('NFKC');\n  const key = scrypt(normalizedPassword, salt, { N: n, r: 8, p: 1, dkLen: 32 });\n  const nonce = randomBytes(24);\n  const aad = Uint8Array.from([ksb]);\n  const cipher = xchacha20poly1305(key, nonce, aad);\n  const ciphertext = cipher.encrypt(sec);\n  // Binary format: version(1) + logn(1) + salt(16) + nonce(24) + ksb(1) + ciphertext(48 = 32 + 16 tag)\n  const payload = concatBytes(\n    Uint8Array.from([0x02]),\n    Uint8Array.from([logn]),\n    salt,\n    nonce,\n    aad,\n    ciphertext\n  );\n  const words = scureBech32.toWords(payload);\n  return scureBech32.encode('ncryptsec', words, 200);\n}\n\n/**\n * Decrypt an ncryptsec bech32 string back to the 32-byte secret key\n * @param ncryptsec - bech32-encoded ncryptsec string\n * @param password - Password used for encryption\n * @returns 32-byte secret key as Uint8Array\n */\nexport function decrypt(ncryptsec: string, password: string): Uint8Array {\n  const { prefix, words } = scureBech32.decode(ncryptsec as `${string}1${string}`, 200);\n  if (prefix !== 'ncryptsec') throw new Error('invalid ncryptsec prefix');\n  const data = new Uint8Array(scureBech32.fromWords(words));\n  const version = data[0];\n  if (version !== 0x02) throw new Error(`unknown ncryptsec version: ${version}`);\n  const logn = data[1];\n  const salt = data.subarray(2, 18);\n  const nonce = data.subarray(18, 42);\n  const ksb = data[42];\n  const ciphertext = data.subarray(43);\n  const n = 2 ** logn;\n  const normalizedPassword = password.normalize('NFKC');\n  const key = scrypt(normalizedPassword, salt, { N: n, r: 8, p: 1, dkLen: 32 });\n  const aad = Uint8Array.from([ksb]);\n  const cipher = xchacha20poly1305(key, nonce, aad);\n  return cipher.decrypt(ciphertext);\n}\n", "/**\n * RFC 7914 Scrypt KDF. Can be used to create a key from password and salt.\n * @module\n */\nimport { pbkdf2 } from './pbkdf2.ts';\nimport { sha256 } from './sha2.ts';\n// prettier-ignore\nimport {\n  anumber, asyncLoop,\n  checkOpts, clean,\n  type KDFInput, rotl,\n  swap32IfBE,\n  u32\n} from './utils.ts';\n\n// The main Scrypt loop: uses Salsa extensively.\n// Six versions of the function were tried, this is the fastest one.\n// prettier-ignore\nfunction XorAndSalsa(\n  prev: Uint32Array,\n  pi: number,\n  input: Uint32Array,\n  ii: number,\n  out: Uint32Array,\n  oi: number\n) {\n  // Based on https://cr.yp.to/salsa20.html\n  // Xor blocks\n  let y00 = prev[pi++] ^ input[ii++], y01 = prev[pi++] ^ input[ii++];\n  let y02 = prev[pi++] ^ input[ii++], y03 = prev[pi++] ^ input[ii++];\n  let y04 = prev[pi++] ^ input[ii++], y05 = prev[pi++] ^ input[ii++];\n  let y06 = prev[pi++] ^ input[ii++], y07 = prev[pi++] ^ input[ii++];\n  let y08 = prev[pi++] ^ input[ii++], y09 = prev[pi++] ^ input[ii++];\n  let y10 = prev[pi++] ^ input[ii++], y11 = prev[pi++] ^ input[ii++];\n  let y12 = prev[pi++] ^ input[ii++], y13 = prev[pi++] ^ input[ii++];\n  let y14 = prev[pi++] ^ input[ii++], y15 = prev[pi++] ^ input[ii++];\n  // Save state to temporary variables (salsa)\n  let x00 = y00, x01 = y01, x02 = y02, x03 = y03,\n      x04 = y04, x05 = y05, x06 = y06, x07 = y07,\n      x08 = y08, x09 = y09, x10 = y10, x11 = y11,\n      x12 = y12, x13 = y13, x14 = y14, x15 = y15;\n  // Main loop (salsa)\n  for (let i = 0; i < 8; i += 2) {\n    x04 ^= rotl(x00 + x12 | 0,  7); x08 ^= rotl(x04 + x00 | 0,  9);\n    x12 ^= rotl(x08 + x04 | 0, 13); x00 ^= rotl(x12 + x08 | 0, 18);\n    x09 ^= rotl(x05 + x01 | 0,  7); x13 ^= rotl(x09 + x05 | 0,  9);\n    x01 ^= rotl(x13 + x09 | 0, 13); x05 ^= rotl(x01 + x13 | 0, 18);\n    x14 ^= rotl(x10 + x06 | 0,  7); x02 ^= rotl(x14 + x10 | 0,  9);\n    x06 ^= rotl(x02 + x14 | 0, 13); x10 ^= rotl(x06 + x02 | 0, 18);\n    x03 ^= rotl(x15 + x11 | 0,  7); x07 ^= rotl(x03 + x15 | 0,  9);\n    x11 ^= rotl(x07 + x03 | 0, 13); x15 ^= rotl(x11 + x07 | 0, 18);\n    x01 ^= rotl(x00 + x03 | 0,  7); x02 ^= rotl(x01 + x00 | 0,  9);\n    x03 ^= rotl(x02 + x01 | 0, 13); x00 ^= rotl(x03 + x02 | 0, 18);\n    x06 ^= rotl(x05 + x04 | 0,  7); x07 ^= rotl(x06 + x05 | 0,  9);\n    x04 ^= rotl(x07 + x06 | 0, 13); x05 ^= rotl(x04 + x07 | 0, 18);\n    x11 ^= rotl(x10 + x09 | 0,  7); x08 ^= rotl(x11 + x10 | 0,  9);\n    x09 ^= rotl(x08 + x11 | 0, 13); x10 ^= rotl(x09 + x08 | 0, 18);\n    x12 ^= rotl(x15 + x14 | 0,  7); x13 ^= rotl(x12 + x15 | 0,  9);\n    x14 ^= rotl(x13 + x12 | 0, 13); x15 ^= rotl(x14 + x13 | 0, 18);\n  }\n  // Write output (salsa)\n  out[oi++] = (y00 + x00) | 0; out[oi++] = (y01 + x01) | 0;\n  out[oi++] = (y02 + x02) | 0; out[oi++] = (y03 + x03) | 0;\n  out[oi++] = (y04 + x04) | 0; out[oi++] = (y05 + x05) | 0;\n  out[oi++] = (y06 + x06) | 0; out[oi++] = (y07 + x07) | 0;\n  out[oi++] = (y08 + x08) | 0; out[oi++] = (y09 + x09) | 0;\n  out[oi++] = (y10 + x10) | 0; out[oi++] = (y11 + x11) | 0;\n  out[oi++] = (y12 + x12) | 0; out[oi++] = (y13 + x13) | 0;\n  out[oi++] = (y14 + x14) | 0; out[oi++] = (y15 + x15) | 0;\n}\n\nfunction BlockMix(input: Uint32Array, ii: number, out: Uint32Array, oi: number, r: number) {\n  // The block B is r 128-byte chunks (which is equivalent of 2r 64-byte chunks)\n  let head = oi + 0;\n  let tail = oi + 16 * r;\n  for (let i = 0; i < 16; i++) out[tail + i] = input[ii + (2 * r - 1) * 16 + i]; // X \u2190 B[2r\u22121]\n  for (let i = 0; i < r; i++, head += 16, ii += 16) {\n    // We write odd & even Yi at same time. Even: 0bXXXXX0 Odd:  0bXXXXX1\n    XorAndSalsa(out, tail, input, ii, out, head); // head[i] = Salsa(blockIn[2*i] ^ tail[i-1])\n    if (i > 0) tail += 16; // First iteration overwrites tmp value in tail\n    XorAndSalsa(out, head, input, (ii += 16), out, tail); // tail[i] = Salsa(blockIn[2*i+1] ^ head[i])\n  }\n}\n\n/**\n * Scrypt options:\n * - `N` is cpu/mem work factor (power of 2 e.g. `2**18`)\n * - `r` is block size (8 is common), fine-tunes sequential memory read size and performance\n * - `p` is parallelization factor (1 is common)\n * - `dkLen` is output key length in bytes e.g. 32.\n * - `asyncTick` - (default: 10) max time in ms for which async function can block execution\n * - `maxmem` - (default: `1024 ** 3 + 1024` aka 1GB+1KB). A limit that the app could use for scrypt\n * - `onProgress` - callback function that would be executed for progress report\n */\nexport type ScryptOpts = {\n  N: number; // cost factor\n  r: number; // block size\n  p: number; // parallelization\n  dkLen?: number; // key length\n  asyncTick?: number; // block execution max time\n  maxmem?: number;\n  onProgress?: (progress: number) => void;\n};\n\n// Common prologue and epilogue for sync/async functions\nfunction scryptInit(password: KDFInput, salt: KDFInput, _opts?: ScryptOpts) {\n  // Maxmem - 1GB+1KB by default\n  const opts = checkOpts(\n    {\n      dkLen: 32,\n      asyncTick: 10,\n      maxmem: 1024 ** 3 + 1024,\n    },\n    _opts\n  );\n  const { N, r, p, dkLen, asyncTick, maxmem, onProgress } = opts;\n  anumber(N, 'N');\n  anumber(r, 'r');\n  anumber(p, 'p');\n  anumber(dkLen, 'dkLen');\n  anumber(asyncTick, 'asyncTick');\n  anumber(maxmem, 'maxmem');\n  if (onProgress !== undefined && typeof onProgress !== 'function')\n    throw new Error('progressCb must be a function');\n  const blockSize = 128 * r;\n  const blockSize32 = blockSize / 4;\n\n  // Max N is 2^32 (Integrify is 32-bit).\n  // Real limit can be 2^22: some JS engines limit Uint8Array to 4GB.\n  // Spec check `N >= 2^(blockSize / 8)` is not done for compat with popular libs,\n  // which used incorrect r: 1, p: 8. Also, the check seems to be a spec error:\n  // https://www.rfc-editor.org/errata_search.php?rfc=7914\n  const pow32 = Math.pow(2, 32);\n  if (N <= 1 || (N & (N - 1)) !== 0 || N > pow32)\n    throw new Error('\"N\" expected a power of 2, and 2^1 <= N <= 2^32');\n  if (p < 1 || p > ((pow32 - 1) * 32) / blockSize)\n    throw new Error('\"p\" expected integer 1..((2^32 - 1) * 32) / (128 * r)');\n  if (dkLen < 1 || dkLen > (pow32 - 1) * 32)\n    throw new Error('\"dkLen\" expected integer 1..(2^32 - 1) * 32');\n  const memUsed = blockSize * (N + p);\n  if (memUsed > maxmem)\n    throw new Error('\"maxmem\" limit was hit, expected 128*r*(N+p) <= \"maxmem\"=' + maxmem);\n  // [B0...Bp\u22121] \u2190 PBKDF2HMAC-SHA256(Passphrase, Salt, 1, blockSize*ParallelizationFactor)\n  // Since it has only one iteration there is no reason to use async variant\n  const B = pbkdf2(sha256, password, salt, { c: 1, dkLen: blockSize * p });\n  const B32 = u32(B);\n  // Re-used between parallel iterations. Array(iterations) of B\n  const V = u32(new Uint8Array(blockSize * N));\n  const tmp = u32(new Uint8Array(blockSize));\n  let blockMixCb = () => {};\n  if (onProgress) {\n    const totalBlockMix = 2 * N * p;\n    // Invoke callback if progress changes from 10.01 to 10.02\n    // Allows to draw smooth progress bar on up to 8K screen\n    const callbackPer = Math.max(Math.floor(totalBlockMix / 10000), 1);\n    let blockMixCnt = 0;\n    blockMixCb = () => {\n      blockMixCnt++;\n      if (onProgress && (!(blockMixCnt % callbackPer) || blockMixCnt === totalBlockMix))\n        onProgress(blockMixCnt / totalBlockMix);\n    };\n  }\n  return { N, r, p, dkLen, blockSize32, V, B32, B, tmp, blockMixCb, asyncTick };\n}\n\nfunction scryptOutput(\n  password: KDFInput,\n  dkLen: number,\n  B: Uint8Array,\n  V: Uint32Array,\n  tmp: Uint32Array\n) {\n  const res = pbkdf2(sha256, password, B, { c: 1, dkLen });\n  clean(B, V, tmp);\n  return res;\n}\n\n/**\n * Scrypt KDF from RFC 7914. See {@link ScryptOpts}.\n * @example\n * scrypt('password', 'salt', { N: 2**18, r: 8, p: 1, dkLen: 32 });\n */\nexport function scrypt(password: KDFInput, salt: KDFInput, opts: ScryptOpts): Uint8Array {\n  const { N, r, p, dkLen, blockSize32, V, B32, B, tmp, blockMixCb } = scryptInit(\n    password,\n    salt,\n    opts\n  );\n  swap32IfBE(B32);\n  for (let pi = 0; pi < p; pi++) {\n    const Pi = blockSize32 * pi;\n    for (let i = 0; i < blockSize32; i++) V[i] = B32[Pi + i]; // V[0] = B[i]\n    for (let i = 0, pos = 0; i < N - 1; i++) {\n      BlockMix(V, pos, V, (pos += blockSize32), r); // V[i] = BlockMix(V[i-1]);\n      blockMixCb();\n    }\n    BlockMix(V, (N - 1) * blockSize32, B32, Pi, r); // Process last element\n    blockMixCb();\n    for (let i = 0; i < N; i++) {\n      // First u32 of the last 64-byte block (u32 is LE)\n      // & (N - 1) is % N as N is a power of 2, N & (N - 1) = 0 is checked above; >>> 0 for unsigned, input fits in u32\n      const j = (B32[Pi + blockSize32 - 16] & (N - 1)) >>> 0; // j = Integrify(X) % iterations\n      for (let k = 0; k < blockSize32; k++) tmp[k] = B32[Pi + k] ^ V[j * blockSize32 + k]; // tmp = B ^ V[j]\n      BlockMix(tmp, 0, B32, Pi, r); // B = BlockMix(B ^ V[j])\n      blockMixCb();\n    }\n  }\n  swap32IfBE(B32);\n  return scryptOutput(password, dkLen, B, V, tmp);\n}\n\n/**\n * Scrypt KDF from RFC 7914. Async version. See {@link ScryptOpts}.\n * @example\n * await scryptAsync('password', 'salt', { N: 2**18, r: 8, p: 1, dkLen: 32 });\n */\nexport async function scryptAsync(\n  password: KDFInput,\n  salt: KDFInput,\n  opts: ScryptOpts\n): Promise<Uint8Array> {\n  const { N, r, p, dkLen, blockSize32, V, B32, B, tmp, blockMixCb, asyncTick } = scryptInit(\n    password,\n    salt,\n    opts\n  );\n  swap32IfBE(B32);\n  for (let pi = 0; pi < p; pi++) {\n    const Pi = blockSize32 * pi;\n    for (let i = 0; i < blockSize32; i++) V[i] = B32[Pi + i]; // V[0] = B[i]\n    let pos = 0;\n    await asyncLoop(N - 1, asyncTick, () => {\n      BlockMix(V, pos, V, (pos += blockSize32), r); // V[i] = BlockMix(V[i-1]);\n      blockMixCb();\n    });\n    BlockMix(V, (N - 1) * blockSize32, B32, Pi, r); // Process last element\n    blockMixCb();\n    await asyncLoop(N, asyncTick, () => {\n      // First u32 of the last 64-byte block (u32 is LE)\n      // & (N - 1) is % N as N is a power of 2, N & (N - 1) = 0 is checked above; >>> 0 for unsigned, input fits in u32\n      const j = (B32[Pi + blockSize32 - 16] & (N - 1)) >>> 0; // j = Integrify(X) % iterations\n      for (let k = 0; k < blockSize32; k++) tmp[k] = B32[Pi + k] ^ V[j * blockSize32 + k]; // tmp = B ^ V[j]\n      BlockMix(tmp, 0, B32, Pi, r); // B = BlockMix(B ^ V[j])\n      blockMixCb();\n    });\n  }\n  swap32IfBE(B32);\n  return scryptOutput(password, dkLen, B, V, tmp);\n}\n", "/**\n * PBKDF (RFC 2898). Can be used to create a key from password and salt.\n * @module\n */\nimport { hmac } from './hmac.ts';\n// prettier-ignore\nimport {\n  ahash, anumber,\n  asyncLoop, checkOpts, clean, createView, kdfInputToBytes,\n  type CHash,\n  type Hash,\n  type KDFInput\n} from './utils.ts';\n\n/**\n * PBKDF2 options:\n * * c: iterations, should probably be higher than 100_000\n * * dkLen: desired length of derived key in bytes\n * * asyncTick: max time in ms for which async function can block execution\n */\nexport type Pbkdf2Opt = {\n  c: number;\n  dkLen?: number;\n  asyncTick?: number;\n};\n// Common start and end for sync/async functions\nfunction pbkdf2Init(hash: CHash, _password: KDFInput, _salt: KDFInput, _opts: Pbkdf2Opt) {\n  ahash(hash);\n  const opts = checkOpts({ dkLen: 32, asyncTick: 10 }, _opts);\n  const { c, dkLen, asyncTick } = opts;\n  anumber(c, 'c');\n  anumber(dkLen, 'dkLen');\n  anumber(asyncTick, 'asyncTick');\n  if (c < 1) throw new Error('iterations (c) must be >= 1');\n  const password = kdfInputToBytes(_password, 'password');\n  const salt = kdfInputToBytes(_salt, 'salt');\n  // DK = PBKDF2(PRF, Password, Salt, c, dkLen);\n  const DK = new Uint8Array(dkLen);\n  // U1 = PRF(Password, Salt + INT_32_BE(i))\n  const PRF = hmac.create(hash, password);\n  const PRFSalt = PRF._cloneInto().update(salt);\n  return { c, dkLen, asyncTick, DK, PRF, PRFSalt };\n}\n\nfunction pbkdf2Output<T extends Hash<T>>(\n  PRF: Hash<T>,\n  PRFSalt: Hash<T>,\n  DK: Uint8Array,\n  prfW: Hash<T>,\n  u: Uint8Array\n) {\n  PRF.destroy();\n  PRFSalt.destroy();\n  if (prfW) prfW.destroy();\n  clean(u);\n  return DK;\n}\n\n/**\n * PBKDF2-HMAC: RFC 2898 key derivation function\n * @param hash - hash function that would be used e.g. sha256\n * @param password - password from which a derived key is generated\n * @param salt - cryptographic salt\n * @param opts - {c, dkLen} where c is work factor and dkLen is output message size\n * @example\n * const key = pbkdf2(sha256, 'password', 'salt', { dkLen: 32, c: Math.pow(2, 18) });\n */\nexport function pbkdf2(\n  hash: CHash,\n  password: KDFInput,\n  salt: KDFInput,\n  opts: Pbkdf2Opt\n): Uint8Array {\n  const { c, dkLen, DK, PRF, PRFSalt } = pbkdf2Init(hash, password, salt, opts);\n  let prfW: any; // Working copy\n  const arr = new Uint8Array(4);\n  const view = createView(arr);\n  const u = new Uint8Array(PRF.outputLen);\n  // DK = T1 + T2 + \u22EF + Tdklen/hlen\n  for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {\n    // Ti = F(Password, Salt, c, i)\n    const Ti = DK.subarray(pos, pos + PRF.outputLen);\n    view.setInt32(0, ti, false);\n    // F(Password, Salt, c, i) = U1 ^ U2 ^ \u22EF ^ Uc\n    // U1 = PRF(Password, Salt + INT_32_BE(i))\n    (prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);\n    Ti.set(u.subarray(0, Ti.length));\n    for (let ui = 1; ui < c; ui++) {\n      // Uc = PRF(Password, Uc\u22121)\n      PRF._cloneInto(prfW).update(u).digestInto(u);\n      for (let i = 0; i < Ti.length; i++) Ti[i] ^= u[i];\n    }\n  }\n  return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);\n}\n\n/**\n * PBKDF2-HMAC: RFC 2898 key derivation function. Async version.\n * @example\n * await pbkdf2Async(sha256, 'password', 'salt', { dkLen: 32, c: 500_000 });\n */\nexport async function pbkdf2Async(\n  hash: CHash,\n  password: KDFInput,\n  salt: KDFInput,\n  opts: Pbkdf2Opt\n): Promise<Uint8Array> {\n  const { c, dkLen, asyncTick, DK, PRF, PRFSalt } = pbkdf2Init(hash, password, salt, opts);\n  let prfW: any; // Working copy\n  const arr = new Uint8Array(4);\n  const view = createView(arr);\n  const u = new Uint8Array(PRF.outputLen);\n  // DK = T1 + T2 + \u22EF + Tdklen/hlen\n  for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {\n    // Ti = F(Password, Salt, c, i)\n    const Ti = DK.subarray(pos, pos + PRF.outputLen);\n    view.setInt32(0, ti, false);\n    // F(Password, Salt, c, i) = U1 ^ U2 ^ \u22EF ^ Uc\n    // U1 = PRF(Password, Salt + INT_32_BE(i))\n    (prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);\n    Ti.set(u.subarray(0, Ti.length));\n    await asyncLoop(c - 1, asyncTick, () => {\n      // Uc = PRF(Password, Uc\u22121)\n      PRF._cloneInto(prfW).update(u).digestInto(u);\n      for (let i = 0; i < Ti.length; i++) Ti[i] ^= u[i];\n    });\n  }\n  return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);\n}\n", "/**\n * Utility functions for encoding and decoding data\n */\n\n/**\n * Convert a hex string to Uint8Array\n * @param hex Hex string to convert\n * @returns Uint8Array of bytes\n */\nexport function hexToBytes(hex: string): Uint8Array {\n    const bytes = new Uint8Array(hex.length / 2);\n    for (let i = 0; i < hex.length; i += 2) {\n        bytes[i / 2] = parseInt(hex.slice(i, i + 2), 16);\n    }\n    return bytes;\n}\n\n/**\n * Convert Uint8Array to hex string\n * @param bytes Uint8Array to convert\n * @returns Hex string\n */\nexport function bytesToHex(bytes: Uint8Array): string {\n    return Array.from(bytes)\n        .map(b => b.toString(16).padStart(2, '0'))\n        .join('');\n}\n\n/**\n * Convert a UTF-8 string to Uint8Array\n * @param str UTF-8 string to convert\n * @returns Uint8Array of bytes\n */\nexport function utf8ToBytes(str: string): Uint8Array {\n    return new TextEncoder().encode(str);\n}\n\n/**\n * Convert Uint8Array to UTF-8 string\n * @param bytes Uint8Array to convert\n * @returns UTF-8 string\n */\nexport function bytesToUtf8(bytes: Uint8Array): string {\n    return new TextDecoder().decode(bytes);\n}\n", "/**\n * BIP39 Seed Phrase utilities for NostrKey.\n *\n * Implements the same algorithm as `nostr-nsec-seedphrase`:\n * the 32-byte private key IS the BIP39 entropy (bidirectional encoding).\n *\n * Uses @scure/bip39 (already a transitive dep of nostr-tools).\n */\n\nimport { entropyToMnemonic, mnemonicToEntropy, validateMnemonic } from '@scure/bip39';\nimport { wordlist } from '@scure/bip39/wordlists/english.js';\nimport { hexToBytes, bytesToHex, getPublicKeySync } from 'nostr-crypto-utils';\n\n/**\n * Convert a hex private key to a 24-word BIP39 mnemonic.\n * @param {string} hexKey - 64-char hex private key\n * @returns {string} 24-word mnemonic\n */\nexport function keyToSeedPhrase(hexKey) {\n    const bytes = hexToBytes(hexKey);\n    return entropyToMnemonic(bytes, wordlist);\n}\n\n/**\n * Convert a BIP39 mnemonic back to a hex private key + derived pubkey.\n * @param {string} phrase - 24-word mnemonic\n * @returns {{ hexKey: string, pubKey: string }}\n */\nexport function seedPhraseToKey(phrase) {\n    const entropy = mnemonicToEntropy(phrase.trim().toLowerCase(), wordlist);\n    const hexKey = bytesToHex(entropy);\n    const pubKey = getPublicKeySync(hexKey);\n    return { hexKey, pubKey };\n}\n\n/**\n * Validate a BIP39 mnemonic (checksum + wordlist).\n * @param {string} phrase\n * @returns {boolean}\n */\nexport function isValidSeedPhrase(phrase) {\n    try {\n        return validateMnemonic(phrase.trim().toLowerCase(), wordlist);\n    } catch {\n        return false;\n    }\n}\n\n/**\n * Fast heuristic: does the input look like it could be a seed phrase?\n * (12+ space-separated alphabetic words)\n * @param {string} input\n * @returns {boolean}\n */\nexport function looksLikeSeedPhrase(input) {\n    if (!input || typeof input !== 'string') return false;\n    const words = input.trim().split(/\\s+/);\n    return words.length >= 12 && words.every(w => /^[a-zA-Z]+$/.test(w));\n}\n", "/*! scure-bip39 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) */\nimport { pbkdf2, pbkdf2Async } from '@noble/hashes/pbkdf2.js';\nimport { sha256, sha512 } from '@noble/hashes/sha2.js';\nimport { abytes, anumber, randomBytes } from '@noble/hashes/utils.js';\nimport { pbkdf2 as pbkdf2web, sha512 as sha512web } from '@noble/hashes/webcrypto.js';\nimport { utils as baseUtils } from '@scure/base';\n// Japanese wordlist\nconst isJapanese = (wordlist) => wordlist[0] === '\\u3042\\u3044\\u3053\\u304f\\u3057\\u3093';\n// Normalization replaces equivalent sequences of characters\n// so that any two texts that are equivalent will be reduced\n// to the same sequence of code points, called the normal form of the original text.\n// https://tonsky.me/blog/unicode/#why-is-a----\nfunction nfkd(str) {\n    if (typeof str !== 'string')\n        throw new TypeError('invalid mnemonic type: ' + typeof str);\n    return str.normalize('NFKD');\n}\nfunction normalize(str) {\n    const norm = nfkd(str);\n    const words = norm.split(' ');\n    if (![12, 15, 18, 21, 24].includes(words.length))\n        throw new Error('Invalid mnemonic');\n    return { nfkd: norm, words };\n}\nfunction aentropy(ent) {\n    abytes(ent);\n    if (![16, 20, 24, 28, 32].includes(ent.length))\n        throw new Error('invalid entropy length');\n}\n/**\n * Generate x random words. Uses Cryptographically-Secure Random Number Generator.\n * @param wordlist imported wordlist for specific language\n * @param strength mnemonic strength 128-256 bits\n * @example\n * generateMnemonic(wordlist, 128)\n * // 'legal winner thank year wave sausage worth useful legal winner thank yellow'\n */\nexport function generateMnemonic(wordlist, strength = 128) {\n    anumber(strength);\n    if (strength % 32 !== 0 || strength > 256)\n        throw new TypeError('Invalid entropy');\n    return entropyToMnemonic(randomBytes(strength / 8), wordlist);\n}\nconst calcChecksum = (entropy) => {\n    // Checksum is ent.length/4 bits long\n    const bitsLeft = 8 - entropy.length / 4;\n    // Zero rightmost \"bitsLeft\" bits in byte\n    // For example: bitsLeft=4 val=10111101 -> 10110000\n    return new Uint8Array([(sha256(entropy)[0] >> bitsLeft) << bitsLeft]);\n};\nfunction getCoder(wordlist) {\n    if (!Array.isArray(wordlist) || wordlist.length !== 2048 || typeof wordlist[0] !== 'string')\n        throw new Error('Wordlist: expected array of 2048 strings');\n    wordlist.forEach((i) => {\n        if (typeof i !== 'string')\n            throw new Error('wordlist: non-string element: ' + i);\n    });\n    return baseUtils.chain(baseUtils.checksum(1, calcChecksum), baseUtils.radix2(11, true), baseUtils.alphabet(wordlist));\n}\n/**\n * Reversible: Converts mnemonic string to raw entropy in form of byte array.\n * @param mnemonic 12-24 words\n * @param wordlist imported wordlist for specific language\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * mnemonicToEntropy(mnem, wordlist)\n * // Produces\n * new Uint8Array([\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f\n * ])\n */\nexport function mnemonicToEntropy(mnemonic, wordlist) {\n    const { words } = normalize(mnemonic);\n    const entropy = getCoder(wordlist).decode(words);\n    aentropy(entropy);\n    return entropy;\n}\n/**\n * Reversible: Converts raw entropy in form of byte array to mnemonic string.\n * @param entropy byte array\n * @param wordlist imported wordlist for specific language\n * @returns 12-24 words\n * @example\n * const ent = new Uint8Array([\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f\n * ]);\n * entropyToMnemonic(ent, wordlist);\n * // 'legal winner thank year wave sausage worth useful legal winner thank yellow'\n */\nexport function entropyToMnemonic(entropy, wordlist) {\n    aentropy(entropy);\n    const words = getCoder(wordlist).encode(entropy);\n    return words.join(isJapanese(wordlist) ? '\\u3000' : ' ');\n}\n/**\n * Validates mnemonic for being 12-24 words contained in `wordlist`.\n */\nexport function validateMnemonic(mnemonic, wordlist) {\n    try {\n        mnemonicToEntropy(mnemonic, wordlist);\n    }\n    catch (e) {\n        return false;\n    }\n    return true;\n}\nconst psalt = (passphrase) => nfkd('mnemonic' + passphrase);\n/**\n * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.\n * @param mnemonic 12-24 words\n * @param passphrase string that will additionally protect the key\n * @returns 64 bytes of key data\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * await mnemonicToSeed(mnem, 'password');\n * // new Uint8Array([...64 bytes])\n */\nexport function mnemonicToSeed(mnemonic, passphrase = '') {\n    return pbkdf2Async(sha512, normalize(mnemonic).nfkd, psalt(passphrase), { c: 2048, dkLen: 64 });\n}\n/**\n * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.\n * @param mnemonic 12-24 words\n * @param passphrase string that will additionally protect the key\n * @returns 64 bytes of key data\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * mnemonicToSeedSync(mnem, 'password');\n * // new Uint8Array([...64 bytes])\n */\nexport function mnemonicToSeedSync(mnemonic, passphrase = '') {\n    return pbkdf2(sha512, normalize(mnemonic).nfkd, psalt(passphrase), { c: 2048, dkLen: 64 });\n}\n/**\n * Uses native, built-in functionality, provided by globalThis.crypto.\n * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.\n * @param mnemonic 12-24 words\n * @param passphrase string that will additionally protect the key\n * @returns 64 bytes of key data\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * mnemonicToSeedWebcrypto(mnem, 'password');\n * // new Uint8Array([...64 bytes])\n */\nexport function mnemonicToSeedWebcrypto(mnemonic, passphrase = '') {\n    return pbkdf2web(sha512web, normalize(mnemonic).nfkd, psalt(passphrase), { c: 2048, dkLen: 64 });\n}\n", "export const wordlist = `abandon\nability\nable\nabout\nabove\nabsent\nabsorb\nabstract\nabsurd\nabuse\naccess\naccident\naccount\naccuse\nachieve\nacid\nacoustic\nacquire\nacross\nact\naction\nactor\nactress\nactual\nadapt\nadd\naddict\naddress\nadjust\nadmit\nadult\nadvance\nadvice\naerobic\naffair\nafford\nafraid\nagain\nage\nagent\nagree\nahead\naim\nair\nairport\naisle\nalarm\nalbum\nalcohol\nalert\nalien\nall\nalley\nallow\nalmost\nalone\nalpha\nalready\nalso\nalter\nalways\namateur\namazing\namong\namount\namused\nanalyst\nanchor\nancient\nanger\nangle\nangry\nanimal\nankle\nannounce\nannual\nanother\nanswer\nantenna\nantique\nanxiety\nany\napart\napology\nappear\napple\napprove\napril\narch\narctic\narea\narena\nargue\narm\narmed\narmor\narmy\naround\narrange\narrest\narrive\narrow\nart\nartefact\nartist\nartwork\nask\naspect\nassault\nasset\nassist\nassume\nasthma\nathlete\natom\nattack\nattend\nattitude\nattract\nauction\naudit\naugust\naunt\nauthor\nauto\nautumn\naverage\navocado\navoid\nawake\naware\naway\nawesome\nawful\nawkward\naxis\nbaby\nbachelor\nbacon\nbadge\nbag\nbalance\nbalcony\nball\nbamboo\nbanana\nbanner\nbar\nbarely\nbargain\nbarrel\nbase\nbasic\nbasket\nbattle\nbeach\nbean\nbeauty\nbecause\nbecome\nbeef\nbefore\nbegin\nbehave\nbehind\nbelieve\nbelow\nbelt\nbench\nbenefit\nbest\nbetray\nbetter\nbetween\nbeyond\nbicycle\nbid\nbike\nbind\nbiology\nbird\nbirth\nbitter\nblack\nblade\nblame\nblanket\nblast\nbleak\nbless\nblind\nblood\nblossom\nblouse\nblue\nblur\nblush\nboard\nboat\nbody\nboil\nbomb\nbone\nbonus\nbook\nboost\nborder\nboring\nborrow\nboss\nbottom\nbounce\nbox\nboy\nbracket\nbrain\nbrand\nbrass\nbrave\nbread\nbreeze\nbrick\nbridge\nbrief\nbright\nbring\nbrisk\nbroccoli\nbroken\nbronze\nbroom\nbrother\nbrown\nbrush\nbubble\nbuddy\nbudget\nbuffalo\nbuild\nbulb\nbulk\nbullet\nbundle\nbunker\nburden\nburger\nburst\nbus\nbusiness\nbusy\nbutter\nbuyer\nbuzz\ncabbage\ncabin\ncable\ncactus\ncage\ncake\ncall\ncalm\ncamera\ncamp\ncan\ncanal\ncancel\ncandy\ncannon\ncanoe\ncanvas\ncanyon\ncapable\ncapital\ncaptain\ncar\ncarbon\ncard\ncargo\ncarpet\ncarry\ncart\ncase\ncash\ncasino\ncastle\ncasual\ncat\ncatalog\ncatch\ncategory\ncattle\ncaught\ncause\ncaution\ncave\nceiling\ncelery\ncement\ncensus\ncentury\ncereal\ncertain\nchair\nchalk\nchampion\nchange\nchaos\nchapter\ncharge\nchase\nchat\ncheap\ncheck\ncheese\nchef\ncherry\nchest\nchicken\nchief\nchild\nchimney\nchoice\nchoose\nchronic\nchuckle\nchunk\nchurn\ncigar\ncinnamon\ncircle\ncitizen\ncity\ncivil\nclaim\nclap\nclarify\nclaw\nclay\nclean\nclerk\nclever\nclick\nclient\ncliff\nclimb\nclinic\nclip\nclock\nclog\nclose\ncloth\ncloud\nclown\nclub\nclump\ncluster\nclutch\ncoach\ncoast\ncoconut\ncode\ncoffee\ncoil\ncoin\ncollect\ncolor\ncolumn\ncombine\ncome\ncomfort\ncomic\ncommon\ncompany\nconcert\nconduct\nconfirm\ncongress\nconnect\nconsider\ncontrol\nconvince\ncook\ncool\ncopper\ncopy\ncoral\ncore\ncorn\ncorrect\ncost\ncotton\ncouch\ncountry\ncouple\ncourse\ncousin\ncover\ncoyote\ncrack\ncradle\ncraft\ncram\ncrane\ncrash\ncrater\ncrawl\ncrazy\ncream\ncredit\ncreek\ncrew\ncricket\ncrime\ncrisp\ncritic\ncrop\ncross\ncrouch\ncrowd\ncrucial\ncruel\ncruise\ncrumble\ncrunch\ncrush\ncry\ncrystal\ncube\nculture\ncup\ncupboard\ncurious\ncurrent\ncurtain\ncurve\ncushion\ncustom\ncute\ncycle\ndad\ndamage\ndamp\ndance\ndanger\ndaring\ndash\ndaughter\ndawn\nday\ndeal\ndebate\ndebris\ndecade\ndecember\ndecide\ndecline\ndecorate\ndecrease\ndeer\ndefense\ndefine\ndefy\ndegree\ndelay\ndeliver\ndemand\ndemise\ndenial\ndentist\ndeny\ndepart\ndepend\ndeposit\ndepth\ndeputy\nderive\ndescribe\ndesert\ndesign\ndesk\ndespair\ndestroy\ndetail\ndetect\ndevelop\ndevice\ndevote\ndiagram\ndial\ndiamond\ndiary\ndice\ndiesel\ndiet\ndiffer\ndigital\ndignity\ndilemma\ndinner\ndinosaur\ndirect\ndirt\ndisagree\ndiscover\ndisease\ndish\ndismiss\ndisorder\ndisplay\ndistance\ndivert\ndivide\ndivorce\ndizzy\ndoctor\ndocument\ndog\ndoll\ndolphin\ndomain\ndonate\ndonkey\ndonor\ndoor\ndose\ndouble\ndove\ndraft\ndragon\ndrama\ndrastic\ndraw\ndream\ndress\ndrift\ndrill\ndrink\ndrip\ndrive\ndrop\ndrum\ndry\nduck\ndumb\ndune\nduring\ndust\ndutch\nduty\ndwarf\ndynamic\neager\neagle\nearly\nearn\nearth\neasily\neast\neasy\necho\necology\neconomy\nedge\nedit\neducate\neffort\negg\neight\neither\nelbow\nelder\nelectric\nelegant\nelement\nelephant\nelevator\nelite\nelse\nembark\nembody\nembrace\nemerge\nemotion\nemploy\nempower\nempty\nenable\nenact\nend\nendless\nendorse\nenemy\nenergy\nenforce\nengage\nengine\nenhance\nenjoy\nenlist\nenough\nenrich\nenroll\nensure\nenter\nentire\nentry\nenvelope\nepisode\nequal\nequip\nera\nerase\nerode\nerosion\nerror\nerupt\nescape\nessay\nessence\nestate\neternal\nethics\nevidence\nevil\nevoke\nevolve\nexact\nexample\nexcess\nexchange\nexcite\nexclude\nexcuse\nexecute\nexercise\nexhaust\nexhibit\nexile\nexist\nexit\nexotic\nexpand\nexpect\nexpire\nexplain\nexpose\nexpress\nextend\nextra\neye\neyebrow\nfabric\nface\nfaculty\nfade\nfaint\nfaith\nfall\nfalse\nfame\nfamily\nfamous\nfan\nfancy\nfantasy\nfarm\nfashion\nfat\nfatal\nfather\nfatigue\nfault\nfavorite\nfeature\nfebruary\nfederal\nfee\nfeed\nfeel\nfemale\nfence\nfestival\nfetch\nfever\nfew\nfiber\nfiction\nfield\nfigure\nfile\nfilm\nfilter\nfinal\nfind\nfine\nfinger\nfinish\nfire\nfirm\nfirst\nfiscal\nfish\nfit\nfitness\nfix\nflag\nflame\nflash\nflat\nflavor\nflee\nflight\nflip\nfloat\nflock\nfloor\nflower\nfluid\nflush\nfly\nfoam\nfocus\nfog\nfoil\nfold\nfollow\nfood\nfoot\nforce\nforest\nforget\nfork\nfortune\nforum\nforward\nfossil\nfoster\nfound\nfox\nfragile\nframe\nfrequent\nfresh\nfriend\nfringe\nfrog\nfront\nfrost\nfrown\nfrozen\nfruit\nfuel\nfun\nfunny\nfurnace\nfury\nfuture\ngadget\ngain\ngalaxy\ngallery\ngame\ngap\ngarage\ngarbage\ngarden\ngarlic\ngarment\ngas\ngasp\ngate\ngather\ngauge\ngaze\ngeneral\ngenius\ngenre\ngentle\ngenuine\ngesture\nghost\ngiant\ngift\ngiggle\nginger\ngiraffe\ngirl\ngive\nglad\nglance\nglare\nglass\nglide\nglimpse\nglobe\ngloom\nglory\nglove\nglow\nglue\ngoat\ngoddess\ngold\ngood\ngoose\ngorilla\ngospel\ngossip\ngovern\ngown\ngrab\ngrace\ngrain\ngrant\ngrape\ngrass\ngravity\ngreat\ngreen\ngrid\ngrief\ngrit\ngrocery\ngroup\ngrow\ngrunt\nguard\nguess\nguide\nguilt\nguitar\ngun\ngym\nhabit\nhair\nhalf\nhammer\nhamster\nhand\nhappy\nharbor\nhard\nharsh\nharvest\nhat\nhave\nhawk\nhazard\nhead\nhealth\nheart\nheavy\nhedgehog\nheight\nhello\nhelmet\nhelp\nhen\nhero\nhidden\nhigh\nhill\nhint\nhip\nhire\nhistory\nhobby\nhockey\nhold\nhole\nholiday\nhollow\nhome\nhoney\nhood\nhope\nhorn\nhorror\nhorse\nhospital\nhost\nhotel\nhour\nhover\nhub\nhuge\nhuman\nhumble\nhumor\nhundred\nhungry\nhunt\nhurdle\nhurry\nhurt\nhusband\nhybrid\nice\nicon\nidea\nidentify\nidle\nignore\nill\nillegal\nillness\nimage\nimitate\nimmense\nimmune\nimpact\nimpose\nimprove\nimpulse\ninch\ninclude\nincome\nincrease\nindex\nindicate\nindoor\nindustry\ninfant\ninflict\ninform\ninhale\ninherit\ninitial\ninject\ninjury\ninmate\ninner\ninnocent\ninput\ninquiry\ninsane\ninsect\ninside\ninspire\ninstall\nintact\ninterest\ninto\ninvest\ninvite\ninvolve\niron\nisland\nisolate\nissue\nitem\nivory\njacket\njaguar\njar\njazz\njealous\njeans\njelly\njewel\njob\njoin\njoke\njourney\njoy\njudge\njuice\njump\njungle\njunior\njunk\njust\nkangaroo\nkeen\nkeep\nketchup\nkey\nkick\nkid\nkidney\nkind\nkingdom\nkiss\nkit\nkitchen\nkite\nkitten\nkiwi\nknee\nknife\nknock\nknow\nlab\nlabel\nlabor\nladder\nlady\nlake\nlamp\nlanguage\nlaptop\nlarge\nlater\nlatin\nlaugh\nlaundry\nlava\nlaw\nlawn\nlawsuit\nlayer\nlazy\nleader\nleaf\nlearn\nleave\nlecture\nleft\nleg\nlegal\nlegend\nleisure\nlemon\nlend\nlength\nlens\nleopard\nlesson\nletter\nlevel\nliar\nliberty\nlibrary\nlicense\nlife\nlift\nlight\nlike\nlimb\nlimit\nlink\nlion\nliquid\nlist\nlittle\nlive\nlizard\nload\nloan\nlobster\nlocal\nlock\nlogic\nlonely\nlong\nloop\nlottery\nloud\nlounge\nlove\nloyal\nlucky\nluggage\nlumber\nlunar\nlunch\nluxury\nlyrics\nmachine\nmad\nmagic\nmagnet\nmaid\nmail\nmain\nmajor\nmake\nmammal\nman\nmanage\nmandate\nmango\nmansion\nmanual\nmaple\nmarble\nmarch\nmargin\nmarine\nmarket\nmarriage\nmask\nmass\nmaster\nmatch\nmaterial\nmath\nmatrix\nmatter\nmaximum\nmaze\nmeadow\nmean\nmeasure\nmeat\nmechanic\nmedal\nmedia\nmelody\nmelt\nmember\nmemory\nmention\nmenu\nmercy\nmerge\nmerit\nmerry\nmesh\nmessage\nmetal\nmethod\nmiddle\nmidnight\nmilk\nmillion\nmimic\nmind\nminimum\nminor\nminute\nmiracle\nmirror\nmisery\nmiss\nmistake\nmix\nmixed\nmixture\nmobile\nmodel\nmodify\nmom\nmoment\nmonitor\nmonkey\nmonster\nmonth\nmoon\nmoral\nmore\nmorning\nmosquito\nmother\nmotion\nmotor\nmountain\nmouse\nmove\nmovie\nmuch\nmuffin\nmule\nmultiply\nmuscle\nmuseum\nmushroom\nmusic\nmust\nmutual\nmyself\nmystery\nmyth\nnaive\nname\nnapkin\nnarrow\nnasty\nnation\nnature\nnear\nneck\nneed\nnegative\nneglect\nneither\nnephew\nnerve\nnest\nnet\nnetwork\nneutral\nnever\nnews\nnext\nnice\nnight\nnoble\nnoise\nnominee\nnoodle\nnormal\nnorth\nnose\nnotable\nnote\nnothing\nnotice\nnovel\nnow\nnuclear\nnumber\nnurse\nnut\noak\nobey\nobject\noblige\nobscure\nobserve\nobtain\nobvious\noccur\nocean\noctober\nodor\noff\noffer\noffice\noften\noil\nokay\nold\nolive\nolympic\nomit\nonce\none\nonion\nonline\nonly\nopen\nopera\nopinion\noppose\noption\norange\norbit\norchard\norder\nordinary\norgan\norient\noriginal\norphan\nostrich\nother\noutdoor\nouter\noutput\noutside\noval\noven\nover\nown\nowner\noxygen\noyster\nozone\npact\npaddle\npage\npair\npalace\npalm\npanda\npanel\npanic\npanther\npaper\nparade\nparent\npark\nparrot\nparty\npass\npatch\npath\npatient\npatrol\npattern\npause\npave\npayment\npeace\npeanut\npear\npeasant\npelican\npen\npenalty\npencil\npeople\npepper\nperfect\npermit\nperson\npet\nphone\nphoto\nphrase\nphysical\npiano\npicnic\npicture\npiece\npig\npigeon\npill\npilot\npink\npioneer\npipe\npistol\npitch\npizza\nplace\nplanet\nplastic\nplate\nplay\nplease\npledge\npluck\nplug\nplunge\npoem\npoet\npoint\npolar\npole\npolice\npond\npony\npool\npopular\nportion\nposition\npossible\npost\npotato\npottery\npoverty\npowder\npower\npractice\npraise\npredict\nprefer\nprepare\npresent\npretty\nprevent\nprice\npride\nprimary\nprint\npriority\nprison\nprivate\nprize\nproblem\nprocess\nproduce\nprofit\nprogram\nproject\npromote\nproof\nproperty\nprosper\nprotect\nproud\nprovide\npublic\npudding\npull\npulp\npulse\npumpkin\npunch\npupil\npuppy\npurchase\npurity\npurpose\npurse\npush\nput\npuzzle\npyramid\nquality\nquantum\nquarter\nquestion\nquick\nquit\nquiz\nquote\nrabbit\nraccoon\nrace\nrack\nradar\nradio\nrail\nrain\nraise\nrally\nramp\nranch\nrandom\nrange\nrapid\nrare\nrate\nrather\nraven\nraw\nrazor\nready\nreal\nreason\nrebel\nrebuild\nrecall\nreceive\nrecipe\nrecord\nrecycle\nreduce\nreflect\nreform\nrefuse\nregion\nregret\nregular\nreject\nrelax\nrelease\nrelief\nrely\nremain\nremember\nremind\nremove\nrender\nrenew\nrent\nreopen\nrepair\nrepeat\nreplace\nreport\nrequire\nrescue\nresemble\nresist\nresource\nresponse\nresult\nretire\nretreat\nreturn\nreunion\nreveal\nreview\nreward\nrhythm\nrib\nribbon\nrice\nrich\nride\nridge\nrifle\nright\nrigid\nring\nriot\nripple\nrisk\nritual\nrival\nriver\nroad\nroast\nrobot\nrobust\nrocket\nromance\nroof\nrookie\nroom\nrose\nrotate\nrough\nround\nroute\nroyal\nrubber\nrude\nrug\nrule\nrun\nrunway\nrural\nsad\nsaddle\nsadness\nsafe\nsail\nsalad\nsalmon\nsalon\nsalt\nsalute\nsame\nsample\nsand\nsatisfy\nsatoshi\nsauce\nsausage\nsave\nsay\nscale\nscan\nscare\nscatter\nscene\nscheme\nschool\nscience\nscissors\nscorpion\nscout\nscrap\nscreen\nscript\nscrub\nsea\nsearch\nseason\nseat\nsecond\nsecret\nsection\nsecurity\nseed\nseek\nsegment\nselect\nsell\nseminar\nsenior\nsense\nsentence\nseries\nservice\nsession\nsettle\nsetup\nseven\nshadow\nshaft\nshallow\nshare\nshed\nshell\nsheriff\nshield\nshift\nshine\nship\nshiver\nshock\nshoe\nshoot\nshop\nshort\nshoulder\nshove\nshrimp\nshrug\nshuffle\nshy\nsibling\nsick\nside\nsiege\nsight\nsign\nsilent\nsilk\nsilly\nsilver\nsimilar\nsimple\nsince\nsing\nsiren\nsister\nsituate\nsix\nsize\nskate\nsketch\nski\nskill\nskin\nskirt\nskull\nslab\nslam\nsleep\nslender\nslice\nslide\nslight\nslim\nslogan\nslot\nslow\nslush\nsmall\nsmart\nsmile\nsmoke\nsmooth\nsnack\nsnake\nsnap\nsniff\nsnow\nsoap\nsoccer\nsocial\nsock\nsoda\nsoft\nsolar\nsoldier\nsolid\nsolution\nsolve\nsomeone\nsong\nsoon\nsorry\nsort\nsoul\nsound\nsoup\nsource\nsouth\nspace\nspare\nspatial\nspawn\nspeak\nspecial\nspeed\nspell\nspend\nsphere\nspice\nspider\nspike\nspin\nspirit\nsplit\nspoil\nsponsor\nspoon\nsport\nspot\nspray\nspread\nspring\nspy\nsquare\nsqueeze\nsquirrel\nstable\nstadium\nstaff\nstage\nstairs\nstamp\nstand\nstart\nstate\nstay\nsteak\nsteel\nstem\nstep\nstereo\nstick\nstill\nsting\nstock\nstomach\nstone\nstool\nstory\nstove\nstrategy\nstreet\nstrike\nstrong\nstruggle\nstudent\nstuff\nstumble\nstyle\nsubject\nsubmit\nsubway\nsuccess\nsuch\nsudden\nsuffer\nsugar\nsuggest\nsuit\nsummer\nsun\nsunny\nsunset\nsuper\nsupply\nsupreme\nsure\nsurface\nsurge\nsurprise\nsurround\nsurvey\nsuspect\nsustain\nswallow\nswamp\nswap\nswarm\nswear\nsweet\nswift\nswim\nswing\nswitch\nsword\nsymbol\nsymptom\nsyrup\nsystem\ntable\ntackle\ntag\ntail\ntalent\ntalk\ntank\ntape\ntarget\ntask\ntaste\ntattoo\ntaxi\nteach\nteam\ntell\nten\ntenant\ntennis\ntent\nterm\ntest\ntext\nthank\nthat\ntheme\nthen\ntheory\nthere\nthey\nthing\nthis\nthought\nthree\nthrive\nthrow\nthumb\nthunder\nticket\ntide\ntiger\ntilt\ntimber\ntime\ntiny\ntip\ntired\ntissue\ntitle\ntoast\ntobacco\ntoday\ntoddler\ntoe\ntogether\ntoilet\ntoken\ntomato\ntomorrow\ntone\ntongue\ntonight\ntool\ntooth\ntop\ntopic\ntopple\ntorch\ntornado\ntortoise\ntoss\ntotal\ntourist\ntoward\ntower\ntown\ntoy\ntrack\ntrade\ntraffic\ntragic\ntrain\ntransfer\ntrap\ntrash\ntravel\ntray\ntreat\ntree\ntrend\ntrial\ntribe\ntrick\ntrigger\ntrim\ntrip\ntrophy\ntrouble\ntruck\ntrue\ntruly\ntrumpet\ntrust\ntruth\ntry\ntube\ntuition\ntumble\ntuna\ntunnel\nturkey\nturn\nturtle\ntwelve\ntwenty\ntwice\ntwin\ntwist\ntwo\ntype\ntypical\nugly\numbrella\nunable\nunaware\nuncle\nuncover\nunder\nundo\nunfair\nunfold\nunhappy\nuniform\nunique\nunit\nuniverse\nunknown\nunlock\nuntil\nunusual\nunveil\nupdate\nupgrade\nuphold\nupon\nupper\nupset\nurban\nurge\nusage\nuse\nused\nuseful\nuseless\nusual\nutility\nvacant\nvacuum\nvague\nvalid\nvalley\nvalve\nvan\nvanish\nvapor\nvarious\nvast\nvault\nvehicle\nvelvet\nvendor\nventure\nvenue\nverb\nverify\nversion\nvery\nvessel\nveteran\nviable\nvibrant\nvicious\nvictory\nvideo\nview\nvillage\nvintage\nviolin\nvirtual\nvirus\nvisa\nvisit\nvisual\nvital\nvivid\nvocal\nvoice\nvoid\nvolcano\nvolume\nvote\nvoyage\nwage\nwagon\nwait\nwalk\nwall\nwalnut\nwant\nwarfare\nwarm\nwarrior\nwash\nwasp\nwaste\nwater\nwave\nway\nwealth\nweapon\nwear\nweasel\nweather\nweb\nwedding\nweekend\nweird\nwelcome\nwest\nwet\nwhale\nwhat\nwheat\nwheel\nwhen\nwhere\nwhip\nwhisper\nwide\nwidth\nwife\nwild\nwill\nwin\nwindow\nwine\nwing\nwink\nwinner\nwinter\nwire\nwisdom\nwise\nwish\nwitness\nwolf\nwoman\nwonder\nwood\nwool\nword\nwork\nworld\nworry\nworth\nwrap\nwreck\nwrestle\nwrist\nwrite\nwrong\nyard\nyear\nyellow\nyou\nyoung\nyouth\nzebra\nzero\nzone\nzoo`.split('\\n');\n", "/**\n * Key generation utilities for Nostr\n *\n * Uses nostr-crypto-utils for all cryptographic operations.\n * Returns plain hex strings for both private and public keys.\n */\n\nimport { generateKeyPair as generateKeyPairCrypto, getPublicKeySync, bytesToHex } from 'nostr-crypto-utils';\n\n/**\n * Generates a new Nostr keypair.\n * Returns the private key and public key as hex strings.\n */\nexport async function generateKeyPair() {\n    const keyPair = await generateKeyPairCrypto();\n    return {\n        privateKey: keyPair.privateKey,\n        publicKey: keyPair.publicKey.hex,\n    };\n}\n\n/**\n * Gets the public key from a private key (hex string).\n */\nexport function getPublicKeyFromPrivate(privateKeyHex) {\n    return getPublicKeySync(privateKeyHex);\n}\n\nexport { bytesToHex };\n", "const E_TIMEOUT = new Error('timeout while waiting for mutex to become available');\nconst E_ALREADY_LOCKED = new Error('mutex already locked');\nconst E_CANCELED = new Error('request for lock canceled');\n\nvar __awaiter$2 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nclass Semaphore {\n    constructor(_value, _cancelError = E_CANCELED) {\n        this._value = _value;\n        this._cancelError = _cancelError;\n        this._queue = [];\n        this._weightedWaiters = [];\n    }\n    acquire(weight = 1, priority = 0) {\n        if (weight <= 0)\n            throw new Error(`invalid weight ${weight}: must be positive`);\n        return new Promise((resolve, reject) => {\n            const task = { resolve, reject, weight, priority };\n            const i = findIndexFromEnd(this._queue, (other) => priority <= other.priority);\n            if (i === -1 && weight <= this._value) {\n                // Needs immediate dispatch, skip the queue\n                this._dispatchItem(task);\n            }\n            else {\n                this._queue.splice(i + 1, 0, task);\n            }\n        });\n    }\n    runExclusive(callback_1) {\n        return __awaiter$2(this, arguments, void 0, function* (callback, weight = 1, priority = 0) {\n            const [value, release] = yield this.acquire(weight, priority);\n            try {\n                return yield callback(value);\n            }\n            finally {\n                release();\n            }\n        });\n    }\n    waitForUnlock(weight = 1, priority = 0) {\n        if (weight <= 0)\n            throw new Error(`invalid weight ${weight}: must be positive`);\n        if (this._couldLockImmediately(weight, priority)) {\n            return Promise.resolve();\n        }\n        else {\n            return new Promise((resolve) => {\n                if (!this._weightedWaiters[weight - 1])\n                    this._weightedWaiters[weight - 1] = [];\n                insertSorted(this._weightedWaiters[weight - 1], { resolve, priority });\n            });\n        }\n    }\n    isLocked() {\n        return this._value <= 0;\n    }\n    getValue() {\n        return this._value;\n    }\n    setValue(value) {\n        this._value = value;\n        this._dispatchQueue();\n    }\n    release(weight = 1) {\n        if (weight <= 0)\n            throw new Error(`invalid weight ${weight}: must be positive`);\n        this._value += weight;\n        this._dispatchQueue();\n    }\n    cancel() {\n        this._queue.forEach((entry) => entry.reject(this._cancelError));\n        this._queue = [];\n    }\n    _dispatchQueue() {\n        this._drainUnlockWaiters();\n        while (this._queue.length > 0 && this._queue[0].weight <= this._value) {\n            this._dispatchItem(this._queue.shift());\n            this._drainUnlockWaiters();\n        }\n    }\n    _dispatchItem(item) {\n        const previousValue = this._value;\n        this._value -= item.weight;\n        item.resolve([previousValue, this._newReleaser(item.weight)]);\n    }\n    _newReleaser(weight) {\n        let called = false;\n        return () => {\n            if (called)\n                return;\n            called = true;\n            this.release(weight);\n        };\n    }\n    _drainUnlockWaiters() {\n        if (this._queue.length === 0) {\n            for (let weight = this._value; weight > 0; weight--) {\n                const waiters = this._weightedWaiters[weight - 1];\n                if (!waiters)\n                    continue;\n                waiters.forEach((waiter) => waiter.resolve());\n                this._weightedWaiters[weight - 1] = [];\n            }\n        }\n        else {\n            const queuedPriority = this._queue[0].priority;\n            for (let weight = this._value; weight > 0; weight--) {\n                const waiters = this._weightedWaiters[weight - 1];\n                if (!waiters)\n                    continue;\n                const i = waiters.findIndex((waiter) => waiter.priority <= queuedPriority);\n                (i === -1 ? waiters : waiters.splice(0, i))\n                    .forEach((waiter => waiter.resolve()));\n            }\n        }\n    }\n    _couldLockImmediately(weight, priority) {\n        return (this._queue.length === 0 || this._queue[0].priority < priority) &&\n            weight <= this._value;\n    }\n}\nfunction insertSorted(a, v) {\n    const i = findIndexFromEnd(a, (other) => v.priority <= other.priority);\n    a.splice(i + 1, 0, v);\n}\nfunction findIndexFromEnd(a, predicate) {\n    for (let i = a.length - 1; i >= 0; i--) {\n        if (predicate(a[i])) {\n            return i;\n        }\n    }\n    return -1;\n}\n\nvar __awaiter$1 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nclass Mutex {\n    constructor(cancelError) {\n        this._semaphore = new Semaphore(1, cancelError);\n    }\n    acquire() {\n        return __awaiter$1(this, arguments, void 0, function* (priority = 0) {\n            const [, releaser] = yield this._semaphore.acquire(1, priority);\n            return releaser;\n        });\n    }\n    runExclusive(callback, priority = 0) {\n        return this._semaphore.runExclusive(() => callback(), 1, priority);\n    }\n    isLocked() {\n        return this._semaphore.isLocked();\n    }\n    waitForUnlock(priority = 0) {\n        return this._semaphore.waitForUnlock(1, priority);\n    }\n    release() {\n        if (this._semaphore.isLocked())\n            this._semaphore.release();\n    }\n    cancel() {\n        return this._semaphore.cancel();\n    }\n}\n\nvar __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nfunction withTimeout(sync, timeout, timeoutError = E_TIMEOUT) {\n    return {\n        acquire: (weightOrPriority, priority) => {\n            let weight;\n            if (isSemaphore(sync)) {\n                weight = weightOrPriority;\n            }\n            else {\n                weight = undefined;\n                priority = weightOrPriority;\n            }\n            if (weight !== undefined && weight <= 0) {\n                throw new Error(`invalid weight ${weight}: must be positive`);\n            }\n            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {\n                let isTimeout = false;\n                const handle = setTimeout(() => {\n                    isTimeout = true;\n                    reject(timeoutError);\n                }, timeout);\n                try {\n                    const ticket = yield (isSemaphore(sync)\n                        ? sync.acquire(weight, priority)\n                        : sync.acquire(priority));\n                    if (isTimeout) {\n                        const release = Array.isArray(ticket) ? ticket[1] : ticket;\n                        release();\n                    }\n                    else {\n                        clearTimeout(handle);\n                        resolve(ticket);\n                    }\n                }\n                catch (e) {\n                    if (!isTimeout) {\n                        clearTimeout(handle);\n                        reject(e);\n                    }\n                }\n            }));\n        },\n        runExclusive(callback, weight, priority) {\n            return __awaiter(this, void 0, void 0, function* () {\n                let release = () => undefined;\n                try {\n                    const ticket = yield this.acquire(weight, priority);\n                    if (Array.isArray(ticket)) {\n                        release = ticket[1];\n                        return yield callback(ticket[0]);\n                    }\n                    else {\n                        release = ticket;\n                        return yield callback();\n                    }\n                }\n                finally {\n                    release();\n                }\n            });\n        },\n        release(weight) {\n            sync.release(weight);\n        },\n        cancel() {\n            return sync.cancel();\n        },\n        waitForUnlock: (weightOrPriority, priority) => {\n            let weight;\n            if (isSemaphore(sync)) {\n                weight = weightOrPriority;\n            }\n            else {\n                weight = undefined;\n                priority = weightOrPriority;\n            }\n            if (weight !== undefined && weight <= 0) {\n                throw new Error(`invalid weight ${weight}: must be positive`);\n            }\n            return new Promise((resolve, reject) => {\n                const handle = setTimeout(() => reject(timeoutError), timeout);\n                (isSemaphore(sync)\n                    ? sync.waitForUnlock(weight, priority)\n                    : sync.waitForUnlock(priority)).then(() => {\n                    clearTimeout(handle);\n                    resolve();\n                });\n            });\n        },\n        isLocked: () => sync.isLocked(),\n        getValue: () => sync.getValue(),\n        setValue: (value) => sync.setValue(value),\n    };\n}\nfunction isSemaphore(sync) {\n    return sync.getValue !== undefined;\n}\n\n// eslint-disable-next-lisne @typescript-eslint/explicit-module-boundary-types\nfunction tryAcquire(sync, alreadyAcquiredError = E_ALREADY_LOCKED) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    return withTimeout(sync, 0, alreadyAcquiredError);\n}\n\nexport { E_ALREADY_LOCKED, E_CANCELED, E_TIMEOUT, Mutex, Semaphore, tryAcquire, withTimeout };\n", "import { api } from './browser-polyfill';\nimport { encrypt, decrypt, hashPassword, verifyPassword } from './crypto';\nimport { looksLikeSeedPhrase, isValidSeedPhrase } from './seedphrase';\n\nconst DB_VERSION = 6;\nconst storage = api.storage.local;\nexport const RECOMMENDED_RELAYS = [\n    new URL('wss://relay.damus.io'),\n    new URL('wss://relay.primal.net'),\n    new URL('wss://relay.snort.social'),\n    new URL('wss://relay.getalby.com/v1'),\n    new URL('wss://nos.lol'),\n];\n// prettier-ignore\nexport const KINDS = [\n    [0, 'Metadata', 'https://github.com/nostr-protocol/nips/blob/master/01.md'],\n    [1, 'Text', 'https://github.com/nostr-protocol/nips/blob/master/01.md'],\n    [2, 'Recommend Relay', 'https://github.com/nostr-protocol/nips/blob/master/01.md'],\n    [3, 'Contacts', 'https://github.com/nostr-protocol/nips/blob/master/02.md'],\n    [4, 'Encrypted Direct Messages', 'https://github.com/nostr-protocol/nips/blob/master/04.md'],\n    [5, 'Event Deletion', 'https://github.com/nostr-protocol/nips/blob/master/09.md'],\n    [6, 'Repost', 'https://github.com/nostr-protocol/nips/blob/master/18.md'],\n    [7, 'Reaction', 'https://github.com/nostr-protocol/nips/blob/master/25.md'],\n    [8, 'Badge Award', 'https://github.com/nostr-protocol/nips/blob/master/58.md'],\n    [16, 'Generic Repost', 'https://github.com/nostr-protocol/nips/blob/master/18.md'],\n    [40, 'Channel Creation', 'https://github.com/nostr-protocol/nips/blob/master/28.md'],\n    [41, 'Channel Metadata', 'https://github.com/nostr-protocol/nips/blob/master/28.md'],\n    [42, 'Channel Message', 'https://github.com/nostr-protocol/nips/blob/master/28.md'],\n    [43, 'Channel Hide Message', 'https://github.com/nostr-protocol/nips/blob/master/28.md'],\n    [44, 'Channel Mute User', 'https://github.com/nostr-protocol/nips/blob/master/28.md'],\n    [1063, 'File Metadata', 'https://github.com/nostr-protocol/nips/blob/master/94.md'],\n    [1311, 'Live Chat Message', 'https://github.com/nostr-protocol/nips/blob/master/53.md'],\n    [1984, 'Reporting', 'https://github.com/nostr-protocol/nips/blob/master/56.md'],\n    [1985, 'Label', 'https://github.com/nostr-protocol/nips/blob/master/32.md'],\n    [4550, 'Community Post Approval', 'https://github.com/nostr-protocol/nips/blob/master/72.md'],\n    [7000, 'Job Feedback', 'https://github.com/nostr-protocol/nips/blob/master/90.md'],\n    [9041, 'Zap Goal', 'https://github.com/nostr-protocol/nips/blob/master/75.md'],\n    [9734, 'Zap Request', 'https://github.com/nostr-protocol/nips/blob/master/57.md'],\n    [9735, 'Zap', 'https://github.com/nostr-protocol/nips/blob/master/57.md'],\n    [10000, 'Mute List', 'https://github.com/nostr-protocol/nips/blob/master/51.md'],\n    [10001, 'Pin List', 'https://github.com/nostr-protocol/nips/blob/master/51.md'],\n    [10002, 'Relay List Metadata', 'https://github.com/nostr-protocol/nips/blob/master/65.md'],\n    [13194, 'Wallet Info', 'https://github.com/nostr-protocol/nips/blob/master/47.md'],\n    [22242, 'Client Authentication', 'https://github.com/nostr-protocol/nips/blob/master/42.md'],\n    [23194, 'Wallet Request', 'https://github.com/nostr-protocol/nips/blob/master/47.md'],\n    [23195, 'Wallet Response', 'https://github.com/nostr-protocol/nips/blob/master/47.md'],\n    [24133, 'Nostr Connect', 'https://github.com/nostr-protocol/nips/blob/master/46.md'],\n    [27235, 'HTTP Auth', 'https://github.com/nostr-protocol/nips/blob/master/98.md'],\n    [30000, 'Categorized People List', 'https://github.com/nostr-protocol/nips/blob/master/51.md'],\n    [30001, 'Categorized Bookmark List', 'https://github.com/nostr-protocol/nips/blob/master/51.md'],\n    [30008, 'Profile Badges', 'https://github.com/nostr-protocol/nips/blob/master/58.md'],\n    [30009, 'Badge Definition', 'https://github.com/nostr-protocol/nips/blob/master/58.md'],\n    [30017, 'Create or update a stall', 'https://github.com/nostr-protocol/nips/blob/master/15.md'],\n    [30018, 'Create or update a product', 'https://github.com/nostr-protocol/nips/blob/master/15.md'],\n    [30023, 'Long-Form Content', 'https://github.com/nostr-protocol/nips/blob/master/23.md'],\n    [30024, 'Draft Long-form Content', 'https://github.com/nostr-protocol/nips/blob/master/23.md'],\n    [30078, 'Application-specific Data', 'https://github.com/nostr-protocol/nips/blob/master/78.md'],\n    [30311, 'Live Event', 'https://github.com/nostr-protocol/nips/blob/master/53.md'],\n    [30315, 'User Statuses', 'https://github.com/nostr-protocol/nips/blob/master/38.md'],\n    [30402, 'Classified Listing', 'https://github.com/nostr-protocol/nips/blob/master/99.md'],\n    [30403, 'Draft Classified Listing', 'https://github.com/nostr-protocol/nips/blob/master/99.md'],\n    [31922, 'Date-Based Calendar Event', 'https://github.com/nostr-protocol/nips/blob/master/52.md'],\n    [31923, 'Time-Based Calendar Event', 'https://github.com/nostr-protocol/nips/blob/master/52.md'],\n    [31924, 'Calendar', 'https://github.com/nostr-protocol/nips/blob/master/52.md'],\n    [31925, 'Calendar Event RSVP', 'https://github.com/nostr-protocol/nips/blob/master/52.md'],\n    [31989, 'Handler recommendation', 'https://github.com/nostr-protocol/nips/blob/master/89.md'],\n    [31990, 'Handler information', 'https://github.com/nostr-protocol/nips/blob/master/89.md'],\n    [34550, 'Community Definition', 'https://github.com/nostr-protocol/nips/blob/master/72.md'],\n];\n\nexport async function initialize() {\n    await getOrSetDefault('profileIndex', 0);\n    await getOrSetDefault('profiles', [await generateProfile()]);\n    let version = (await storage.get({ version: 0 })).version;\n    console.log('DB version: ', version);\n    while (version < DB_VERSION) {\n        version = await migrate(version, DB_VERSION);\n        await storage.set({ version });\n    }\n}\n\nasync function migrate(version, goal) {\n    if (version === 0) {\n        console.log('Migrating to version 1.');\n        let profiles = await getProfiles();\n        profiles.forEach(profile => (profile.hosts = {}));\n        await storage.set({ profiles });\n        return version + 1;\n    }\n\n    if (version === 1) {\n        console.log('migrating to version 2.');\n        let profiles = await getProfiles();\n        await storage.set({ profiles });\n        return version + 1;\n    }\n\n    if (version === 2) {\n        console.log('Migrating to version 3.');\n        let profiles = await getProfiles();\n        profiles.forEach(profile => (profile.relayReminder = true));\n        await storage.set({ profiles });\n        return version + 1;\n    }\n\n    if (version === 3) {\n        console.log('Migrating to version 4 (encryption support).');\n        // No data transformation needed \u2014 existing plaintext keys stay as-is.\n        // Encryption only activates when the user sets a master password.\n        // We just ensure the isEncrypted flag exists and defaults to false.\n        let data = await storage.get({ isEncrypted: false });\n        if (!data.isEncrypted) {\n            await storage.set({ isEncrypted: false });\n        }\n        return version + 1;\n    }\n\n    if (version === 4) {\n        console.log('Migrating to version 5 (NIP-46 bunker support).');\n        let profiles = await getProfiles();\n        profiles.forEach(profile => {\n            if (!profile.type) profile.type = 'local';\n            if (profile.bunkerUrl === undefined) profile.bunkerUrl = null;\n            if (profile.remotePubkey === undefined) profile.remotePubkey = null;\n        });\n        await storage.set({ profiles });\n        return version + 1;\n    }\n\n    if (version === 5) {\n        console.log('Migrating to version 6 (platform sync support).');\n        const now = Math.floor(Date.now() / 1000);\n        let profiles = await getProfiles();\n        profiles.forEach(profile => {\n            if (profile.updatedAt === undefined) profile.updatedAt = now;\n        });\n        await storage.set({ profiles, platformSyncEnabled: true });\n        return version + 1;\n    }\n}\n\nexport async function getProfiles() {\n    let profiles = await storage.get({ profiles: [] });\n    return profiles.profiles;\n}\n\nexport async function getProfile(index) {\n    let profiles = await getProfiles();\n    return profiles[index];\n}\n\nexport async function getProfileNames() {\n    let profiles = await getProfiles();\n    return profiles.map(p => p.name);\n}\n\nexport async function getProfileIndex() {\n    const index = await storage.get({ profileIndex: 0 });\n    return index.profileIndex;\n}\n\nexport async function setProfileIndex(profileIndex) {\n    await storage.set({ profileIndex });\n}\n\nexport async function deleteProfile(index) {\n    let profiles = await getProfiles();\n    let profileIndex = await getProfileIndex();\n    profiles.splice(index, 1);\n    if (profiles.length == 0) {\n        await clearData(); // If we have deleted all of the profiles, let's just start fresh with all new data\n        await initialize();\n    } else {\n        // If the index deleted was the active profile, change the active profile to the next one\n        let newIndex =\n            profileIndex === index ? Math.max(index - 1, 0) : profileIndex;\n        await storage.set({ profiles, profileIndex: newIndex });\n    }\n}\n\nexport async function clearData() {\n    let ignoreInstallHook = await storage.get({ ignoreInstallHook: false });\n    await storage.clear();\n    await storage.set(ignoreInstallHook);\n}\n\nasync function generatePrivateKey() {\n    return await api.runtime.sendMessage({ kind: 'generatePrivateKey' });\n}\n\nexport async function generateProfile(name = 'Default Nostr Profile', type = 'local') {\n    return {\n        name,\n        privKey: type === 'local' ? await generatePrivateKey() : '',\n        hosts: {},\n        relays: RECOMMENDED_RELAYS.map(r => ({ url: r.href, read: true, write: true })),\n        relayReminder: false,\n        type,\n        bunkerUrl: null,\n        remotePubkey: null,\n        updatedAt: Math.floor(Date.now() / 1000),\n    };\n}\n\nasync function getOrSetDefault(key, def) {\n    let val = (await storage.get(key))[key];\n    if (val == null || val == undefined) {\n        await storage.set({ [key]: def });\n        return def;\n    }\n\n    return val;\n}\n\nexport async function saveProfileName(index, profileName) {\n    let profiles = await getProfiles();\n    profiles[index].name = profileName;\n    profiles[index].updatedAt = Math.floor(Date.now() / 1000);\n    await storage.set({ profiles });\n}\n\nexport async function savePrivateKey(index, privateKey) {\n    const res = await api.runtime.sendMessage({\n        kind: 'savePrivateKey',\n        payload: [index, privateKey],\n    });\n    if (!res || !res.success) {\n        throw new Error(res?.error || 'Failed to save private key');\n    }\n    return res;\n}\n\nexport async function newProfile() {\n    let profiles = await getProfiles();\n    const newProfile = await generateProfile('New Profile');\n    profiles.push(newProfile);\n    await storage.set({ profiles });\n    return profiles.length - 1;\n}\n\nexport async function newBunkerProfile(name = 'New Bunker', bunkerUrl = null) {\n    let profiles = await getProfiles();\n    const profile = await generateProfile(name, 'bunker');\n    profile.bunkerUrl = bunkerUrl;\n    profiles.push(profile);\n    await storage.set({ profiles });\n    return profiles.length - 1;\n}\n\nexport async function getRelays(profileIndex) {\n    let profile = await getProfile(profileIndex);\n    return profile.relays || [];\n}\n\nexport async function saveRelays(profileIndex, relays) {\n    // Having an Alpine proxy object as a sub-object does not serialize correctly in storage,\n    // so we are pre-serializing here before assigning it to the profile, so the proxy\n    // obj doesn't bug out.\n    let fixedRelays = JSON.parse(JSON.stringify(relays));\n    let profiles = await getProfiles();\n    let profile = profiles[profileIndex];\n    profile.relays = fixedRelays;\n    profile.updatedAt = Math.floor(Date.now() / 1000);\n    await storage.set({ profiles });\n}\n\nexport async function get(item) {\n    return (await storage.get(item))[item];\n}\n\nexport async function getPermissions(index = null) {\n    if (index == null) {\n        index = await getProfileIndex();\n    }\n    let profile = await getProfile(index);\n    let hosts = await profile.hosts;\n    return hosts;\n}\n\nexport async function getPermission(host, action) {\n    let index = await getProfileIndex();\n    let profile = await getProfile(index);\n    return profile?.hosts?.[host]?.[action] || 'ask';\n}\n\nexport async function setPermission(host, action, perm, index = null) {\n    let profiles = await getProfiles();\n    if (!index) {\n        index = await getProfileIndex();\n    }\n    let profile = profiles[index];\n    let newPerms = profile.hosts[host] || {};\n    newPerms = { ...newPerms, [action]: perm };\n    profile.hosts[host] = newPerms;\n    profile.updatedAt = Math.floor(Date.now() / 1000);\n    profiles[index] = profile;\n    await storage.set({ profiles });\n}\n\nexport function humanPermission(p) {\n    // Handle special case where event signing includes a kind number\n    if (p.startsWith('signEvent:')) {\n        let [e, n] = p.split(':');\n        n = parseInt(n);\n        let nname = KINDS.find(k => k[0] === n)?.[1] || `Unknown (Kind ${n})`;\n        return `Sign event: ${nname}`;\n    }\n\n    switch (p) {\n        case 'getPubKey':\n            return 'Read public key';\n        case 'signEvent':\n            return 'Sign event';\n        case 'getRelays':\n            return 'Read relay list';\n        case 'nip04.encrypt':\n            return 'Encrypt private message (NIP-04)';\n        case 'nip04.decrypt':\n            return 'Decrypt private message (NIP-04)';\n        case 'nip44.encrypt':\n            return 'Encrypt private message (NIP-44)';\n        case 'nip44.decrypt':\n            return 'Decrypt private message (NIP-44)';\n        default:\n            return 'Unknown';\n    }\n}\n\nexport function validateKey(key) {\n    const hexMatch = /^[\\da-f]{64}$/i.test(key);\n    const b32Match = /^nsec1[qpzry9x8gf2tvdw0s3jn54khce6mua7l]{58}$/.test(key);\n\n    return hexMatch || b32Match || isNcryptsec(key) || isValidSeedPhrase(key);\n}\n\nexport { looksLikeSeedPhrase };\nexport const isSeedPhrase = isValidSeedPhrase;\n\nexport function isNcryptsec(key) {\n    return /^ncryptsec1[qpzry9x8gf2tvdw0s3jn54khce6mua7l]+$/.test(key);\n}\n\nexport async function feature(name) {\n    let fname = `feature:${name}`;\n    let f = await api.storage.local.get({ [fname]: false });\n    return f[fname];\n}\n\nexport async function relayReminder() {\n    let index = await getProfileIndex();\n    let profile = await getProfile(index);\n    return profile.relayReminder;\n}\n\nexport async function toggleRelayReminder() {\n    let index = await getProfileIndex();\n    let profiles = await getProfiles();\n    profiles[index].relayReminder = false;\n    await storage.set({ profiles });\n}\n\nexport async function getNpub() {\n    let index = await getProfileIndex();\n    return await api.runtime.sendMessage({\n        kind: 'getNpub',\n        payload: index,\n    });\n}\n\n// --- Master password encryption helpers -------------------------------------\n\n/**\n * Check whether master password encryption is active.\n *\n * Defensive: checks multiple indicators, not just the boolean flag.\n * If passwordHash or encrypted key blobs exist but the isEncrypted flag\n * is false (inconsistent state from service worker crash, race condition,\n * etc.), self-heals by setting the flag back to true.\n */\nexport async function isEncrypted() {\n    const data = await storage.get({ isEncrypted: false, passwordHash: null, profiles: [] });\n    if (data.isEncrypted) return true;\n\n    // Fallback 1: passwordHash exists but flag is stale\n    if (data.passwordHash) {\n        await storage.set({ isEncrypted: true });\n        return true;\n    }\n\n    // Fallback 2: encrypted blobs exist in profiles but flag + hash are missing\n    for (const profile of data.profiles) {\n        if (isEncryptedBlob(profile.privKey)) {\n            await storage.set({ isEncrypted: true });\n            return true;\n        }\n    }\n\n    return false;\n}\n\n/**\n * Store the password verification hash (never the password itself).\n */\nexport async function setPasswordHash(password) {\n    const { hash, salt } = await hashPassword(password);\n    await storage.set({\n        passwordHash: hash,\n        passwordSalt: salt,\n        isEncrypted: true,\n    });\n}\n\n/**\n * Verify a password against the stored hash.\n */\nexport async function checkPassword(password) {\n    const data = await storage.get({\n        passwordHash: null,\n        passwordSalt: null,\n    });\n    if (!data.passwordHash || !data.passwordSalt) return false;\n    return verifyPassword(password, data.passwordHash, data.passwordSalt);\n}\n\n/**\n * Remove master password protection \u2014 clears hash and decrypts all keys.\n */\nexport async function removePasswordProtection(password) {\n    const valid = await checkPassword(password);\n    if (!valid) throw new Error('Invalid password');\n\n    let profiles = await getProfiles();\n    for (let i = 0; i < profiles.length; i++) {\n        if (profiles[i].type === 'bunker') continue;\n        if (isEncryptedBlob(profiles[i].privKey)) {\n            profiles[i].privKey = await decrypt(profiles[i].privKey, password);\n        }\n    }\n    await storage.set({\n        profiles,\n        isEncrypted: false,\n        passwordHash: null,\n        passwordSalt: null,\n    });\n}\n\n/**\n * Encrypt all profile private keys with a master password.\n */\nexport async function encryptAllKeys(password) {\n    let profiles = await getProfiles();\n    for (let i = 0; i < profiles.length; i++) {\n        if (profiles[i].type === 'bunker') continue;\n        if (!isEncryptedBlob(profiles[i].privKey)) {\n            profiles[i].privKey = await encrypt(profiles[i].privKey, password);\n        }\n    }\n    await setPasswordHash(password);\n    await storage.set({ profiles });\n}\n\n/**\n * Re-encrypt all keys with a new password (requires the old password).\n */\nexport async function changePasswordForKeys(oldPassword, newPassword) {\n    let profiles = await getProfiles();\n    for (let i = 0; i < profiles.length; i++) {\n        if (profiles[i].type === 'bunker') continue;\n        let hex = profiles[i].privKey;\n        if (isEncryptedBlob(hex)) {\n            hex = await decrypt(hex, oldPassword);\n        }\n        profiles[i].privKey = await encrypt(hex, newPassword);\n    }\n    const { hash, salt } = await hashPassword(newPassword);\n    await storage.set({\n        profiles,\n        passwordHash: hash,\n        passwordSalt: salt,\n        isEncrypted: true,\n    });\n}\n\n/**\n * Decrypt a single profile's private key, returning the hex string.\n */\nexport async function getDecryptedPrivKey(profile, password) {\n    if (profile.type === 'bunker') return '';\n    if (isEncryptedBlob(profile.privKey)) {\n        return decrypt(profile.privKey, password);\n    }\n    return profile.privKey;\n}\n\n/**\n * Check whether a stored value looks like an encrypted blob.\n * Encrypted blobs are JSON strings containing {salt, iv, ciphertext}.\n */\nexport function isEncryptedBlob(value) {\n    if (typeof value !== 'string') return false;\n    try {\n        const parsed = JSON.parse(value);\n        return !!(parsed.salt && parsed.iv && parsed.ciphertext);\n    } catch {\n        return false;\n    }\n}\n", "/**\n * Browser API compatibility layer for Chrome / Safari / Firefox.\n *\n * Safari and Firefox expose `browser.*` (Promise-based, WebExtension standard).\n * Chrome exposes `chrome.*` (callback-based historically, but MV3 supports\n * promises on most APIs). In a service-worker context `browser` is undefined\n * on Chrome, so we normalise everything here.\n *\n * Usage:  import { api } from './utilities/browser-polyfill';\n *         api.runtime.sendMessage(...)\n *\n * The exported `api` object mirrors the subset of the WebExtension API that\n * NostrKey actually uses, with every method returning a Promise.\n */\n\n// Detect which global namespace is available.\nconst _browser =\n    typeof browser !== 'undefined' ? browser :\n    typeof chrome  !== 'undefined' ? chrome  :\n    null;\n\nif (!_browser) {\n    throw new Error('browser-polyfill: No extension API namespace found (neither browser nor chrome).');\n}\n\n/**\n * True when running on Chrome (or any Chromium-based browser that only\n * exposes the `chrome` namespace).\n */\nconst isChrome = typeof browser === 'undefined' && typeof chrome !== 'undefined';\n\n/**\n * Wrap a Chrome callback-style method so it returns a Promise.\n * If the method already returns a promise (MV3) we just pass through.\n */\nfunction promisify(context, method) {\n    return (...args) => {\n        // MV3 Chrome APIs return promises when no callback is supplied.\n        // We try the promise path first; if the runtime signals an error\n        // via chrome.runtime.lastError inside a callback we catch that too.\n        try {\n            const result = method.apply(context, args);\n            if (result && typeof result.then === 'function') {\n                return result;\n            }\n        } catch (_) {\n            // fall through to callback wrapping\n        }\n\n        return new Promise((resolve, reject) => {\n            method.apply(context, [\n                ...args,\n                (...cbArgs) => {\n                    if (_browser.runtime && _browser.runtime.lastError) {\n                        reject(new Error(_browser.runtime.lastError.message));\n                    } else {\n                        resolve(cbArgs.length <= 1 ? cbArgs[0] : cbArgs);\n                    }\n                },\n            ]);\n        });\n    };\n}\n\n// ---------------------------------------------------------------------------\n// Build the unified `api` object\n// ---------------------------------------------------------------------------\n\nconst api = {};\n\n// --- runtime ---------------------------------------------------------------\napi.runtime = {\n    /**\n     * sendMessage \u2013 always returns a Promise.\n     */\n    sendMessage(...args) {\n        if (!isChrome) {\n            return _browser.runtime.sendMessage(...args);\n        }\n        return promisify(_browser.runtime, _browser.runtime.sendMessage)(...args);\n    },\n\n    /**\n     * onMessage \u2013 thin wrapper so callers use a consistent reference.\n     * The listener signature is (message, sender, sendResponse).\n     * On Chrome the listener can return `true` to keep the channel open,\n     * or return a Promise (MV3).  Safari / Firefox expect a Promise return.\n     */\n    onMessage: _browser.runtime.onMessage,\n\n    /**\n     * getURL \u2013 synchronous on all browsers.\n     */\n    getURL(path) {\n        return _browser.runtime.getURL(path);\n    },\n\n    /**\n     * openOptionsPage\n     */\n    openOptionsPage() {\n        if (!isChrome) {\n            return _browser.runtime.openOptionsPage();\n        }\n        return promisify(_browser.runtime, _browser.runtime.openOptionsPage)();\n    },\n\n    /**\n     * Expose the id for convenience.\n     */\n    get id() {\n        return _browser.runtime.id;\n    },\n};\n\n// --- storage.local ---------------------------------------------------------\napi.storage = {\n    local: {\n        get(...args) {\n            if (!isChrome) {\n                return _browser.storage.local.get(...args);\n            }\n            return promisify(_browser.storage.local, _browser.storage.local.get)(...args);\n        },\n        set(...args) {\n            if (!isChrome) {\n                return _browser.storage.local.set(...args);\n            }\n            return promisify(_browser.storage.local, _browser.storage.local.set)(...args);\n        },\n        clear(...args) {\n            if (!isChrome) {\n                return _browser.storage.local.clear(...args);\n            }\n            return promisify(_browser.storage.local, _browser.storage.local.clear)(...args);\n        },\n        remove(...args) {\n            if (!isChrome) {\n                return _browser.storage.local.remove(...args);\n            }\n            return promisify(_browser.storage.local, _browser.storage.local.remove)(...args);\n        },\n    },\n\n    // --- storage.sync ----------------------------------------------------------\n    // Null when the browser doesn't support sync (older Safari, etc.)\n    sync: _browser.storage?.sync ? {\n        get(...args) {\n            if (!isChrome) {\n                return _browser.storage.sync.get(...args);\n            }\n            return promisify(_browser.storage.sync, _browser.storage.sync.get)(...args);\n        },\n        set(...args) {\n            if (!isChrome) {\n                return _browser.storage.sync.set(...args);\n            }\n            return promisify(_browser.storage.sync, _browser.storage.sync.set)(...args);\n        },\n        remove(...args) {\n            if (!isChrome) {\n                return _browser.storage.sync.remove(...args);\n            }\n            return promisify(_browser.storage.sync, _browser.storage.sync.remove)(...args);\n        },\n        clear(...args) {\n            if (!isChrome) {\n                return _browser.storage.sync.clear(...args);\n            }\n            return promisify(_browser.storage.sync, _browser.storage.sync.clear)(...args);\n        },\n        getBytesInUse(...args) {\n            if (!_browser.storage.sync.getBytesInUse) {\n                // Safari doesn't support getBytesInUse \u2014 return 0\n                return Promise.resolve(0);\n            }\n            if (!isChrome) {\n                return _browser.storage.sync.getBytesInUse(...args);\n            }\n            return promisify(_browser.storage.sync, _browser.storage.sync.getBytesInUse)(...args);\n        },\n    } : null,\n\n    // --- storage.onChanged -----------------------------------------------------\n    onChanged: _browser.storage?.onChanged || null,\n};\n\n// --- tabs ------------------------------------------------------------------\napi.tabs = {\n    create(...args) {\n        if (!isChrome) {\n            return _browser.tabs.create(...args);\n        }\n        return promisify(_browser.tabs, _browser.tabs.create)(...args);\n    },\n    query(...args) {\n        if (!isChrome) {\n            return _browser.tabs.query(...args);\n        }\n        return promisify(_browser.tabs, _browser.tabs.query)(...args);\n    },\n    remove(...args) {\n        if (!isChrome) {\n            return _browser.tabs.remove(...args);\n        }\n        return promisify(_browser.tabs, _browser.tabs.remove)(...args);\n    },\n    update(...args) {\n        if (!isChrome) {\n            return _browser.tabs.update(...args);\n        }\n        return promisify(_browser.tabs, _browser.tabs.update)(...args);\n    },\n    get(...args) {\n        if (!isChrome) {\n            return _browser.tabs.get(...args);\n        }\n        return promisify(_browser.tabs, _browser.tabs.get)(...args);\n    },\n    getCurrent(...args) {\n        if (!isChrome) {\n            return _browser.tabs.getCurrent(...args);\n        }\n        return promisify(_browser.tabs, _browser.tabs.getCurrent)(...args);\n    },\n    sendMessage(...args) {\n        if (!isChrome) {\n            return _browser.tabs.sendMessage(...args);\n        }\n        return promisify(_browser.tabs, _browser.tabs.sendMessage)(...args);\n    },\n};\n\n// --- alarms ----------------------------------------------------------------\n// chrome.alarms survives MV3 service-worker eviction; setTimeout does not.\napi.alarms = _browser.alarms ? {\n    create(...args) {\n        // alarms.create is synchronous on Chrome, returns Promise on Firefox/Safari\n        const result = _browser.alarms.create(...args);\n        return result && typeof result.then === 'function' ? result : Promise.resolve();\n    },\n    clear(...args) {\n        if (!isChrome) {\n            return _browser.alarms.clear(...args);\n        }\n        return promisify(_browser.alarms, _browser.alarms.clear)(...args);\n    },\n    onAlarm: _browser.alarms.onAlarm,\n} : null;\n\nexport { api, isChrome };\n", "/**\n * Encryption utilities for NostrKey master password feature.\n *\n * Uses Web Crypto API (crypto.subtle) exclusively \u2014 no external libraries.\n * - PBKDF2 with 600,000 iterations (OWASP 2023 recommendation)\n * - AES-256-GCM for authenticated encryption\n * - Random salt (16 bytes) and IV (12 bytes) per operation\n * - All binary data encoded as base64 for JSON storage compatibility\n */\n\nconst PBKDF2_ITERATIONS = 600_000;\nconst SALT_BYTES = 16;\nconst IV_BYTES = 12;\n\n// --- Base64 helpers ---------------------------------------------------------\n\nfunction arrayBufferToBase64(buffer) {\n    const bytes = new Uint8Array(buffer);\n    let binary = '';\n    for (let i = 0; i < bytes.length; i++) {\n        binary += String.fromCharCode(bytes[i]);\n    }\n    return btoa(binary);\n}\n\nfunction base64ToArrayBuffer(base64) {\n    const binary = atob(base64);\n    const bytes = new Uint8Array(binary.length);\n    for (let i = 0; i < binary.length; i++) {\n        bytes[i] = binary.charCodeAt(i);\n    }\n    return bytes.buffer;\n}\n\n// --- Key derivation ---------------------------------------------------------\n\n/**\n * Derive an AES-256-GCM CryptoKey from a password and salt using PBKDF2.\n *\n * @param {string} password - The master password\n * @param {ArrayBuffer|Uint8Array} salt - 16-byte salt\n * @returns {Promise<CryptoKey>} AES-256-GCM key\n */\nexport async function deriveKey(password, salt) {\n    const enc = new TextEncoder();\n    const keyMaterial = await crypto.subtle.importKey(\n        'raw',\n        enc.encode(password),\n        'PBKDF2',\n        false,\n        ['deriveKey']\n    );\n\n    return crypto.subtle.deriveKey(\n        {\n            name: 'PBKDF2',\n            salt: salt instanceof Uint8Array ? salt : new Uint8Array(salt),\n            iterations: PBKDF2_ITERATIONS,\n            hash: 'SHA-256',\n        },\n        keyMaterial,\n        { name: 'AES-GCM', length: 256 },\n        false,\n        ['encrypt', 'decrypt']\n    );\n}\n\n// --- Encrypt with pre-derived key -------------------------------------------\n\n/**\n * Encrypt a plaintext string using a pre-derived CryptoKey and its salt.\n *\n * This avoids holding the raw password in memory \u2014 the caller derives the\n * key once (via deriveKey) and reuses it for the session.  The output\n * format is identical to encrypt(), so decrypt() can still be used with\n * the original password.\n *\n * @param {string} plaintext          - The data to encrypt\n * @param {CryptoKey} key             - AES-256-GCM key from deriveKey()\n * @param {Uint8Array} salt           - The salt that was used to derive `key`\n * @returns {Promise<string>} JSON string: { salt, iv, ciphertext } (all base64)\n */\nexport async function encryptWithKey(plaintext, key, salt) {\n    const iv = crypto.getRandomValues(new Uint8Array(IV_BYTES));\n    const enc = new TextEncoder();\n    const ciphertext = await crypto.subtle.encrypt(\n        { name: 'AES-GCM', iv },\n        key,\n        enc.encode(plaintext)\n    );\n\n    return JSON.stringify({\n        salt: arrayBufferToBase64(salt),\n        iv: arrayBufferToBase64(iv),\n        ciphertext: arrayBufferToBase64(ciphertext),\n    });\n}\n\n// --- Encrypt / Decrypt ------------------------------------------------------\n\n/**\n * Encrypt a plaintext string with a password.\n *\n * Generates a random salt (16 bytes) and IV (12 bytes), derives an\n * AES-256-GCM key via PBKDF2, and returns a JSON string containing\n * base64-encoded salt, iv, and ciphertext.\n *\n * @param {string} plaintext - The data to encrypt (e.g. hex private key)\n * @param {string} password  - The master password\n * @returns {Promise<string>} JSON string: { salt, iv, ciphertext } (all base64)\n */\nexport async function encrypt(plaintext, password) {\n    const salt = crypto.getRandomValues(new Uint8Array(SALT_BYTES));\n    const iv = crypto.getRandomValues(new Uint8Array(IV_BYTES));\n    const key = await deriveKey(password, salt);\n\n    const enc = new TextEncoder();\n    const ciphertext = await crypto.subtle.encrypt(\n        { name: 'AES-GCM', iv },\n        key,\n        enc.encode(plaintext)\n    );\n\n    return JSON.stringify({\n        salt: arrayBufferToBase64(salt),\n        iv: arrayBufferToBase64(iv),\n        ciphertext: arrayBufferToBase64(ciphertext),\n    });\n}\n\n/**\n * Decrypt data that was encrypted with `encrypt()`.\n *\n * @param {string} encryptedData - JSON string from encrypt()\n * @param {string} password      - The master password\n * @returns {Promise<string>} The original plaintext\n * @throws {Error} If the password is wrong or data is tampered with\n */\nexport async function decrypt(encryptedData, password) {\n    const { salt, iv, ciphertext } = JSON.parse(encryptedData);\n\n    const saltBuf = new Uint8Array(base64ToArrayBuffer(salt));\n    const ivBuf = new Uint8Array(base64ToArrayBuffer(iv));\n    const ctBuf = base64ToArrayBuffer(ciphertext);\n\n    const key = await deriveKey(password, saltBuf);\n\n    const plainBuf = await crypto.subtle.decrypt(\n        { name: 'AES-GCM', iv: ivBuf },\n        key,\n        ctBuf\n    );\n\n    const dec = new TextDecoder();\n    return dec.decode(plainBuf);\n}\n\n// --- Password hashing (for verification) ------------------------------------\n\n/**\n * Hash a password with PBKDF2 for verification purposes.\n *\n * This produces a separate hash (not the encryption key) that can be stored\n * to verify the password without needing to attempt decryption.\n *\n * @param {string} password - The master password\n * @param {Uint8Array} [salt] - Optional salt; generated if omitted\n * @returns {Promise<{ hash: string, salt: string }>} base64-encoded hash and salt\n */\nexport async function hashPassword(password, salt) {\n    if (!salt) {\n        salt = crypto.getRandomValues(new Uint8Array(SALT_BYTES));\n    } else if (typeof salt === 'string') {\n        salt = new Uint8Array(base64ToArrayBuffer(salt));\n    }\n\n    const enc = new TextEncoder();\n    const keyMaterial = await crypto.subtle.importKey(\n        'raw',\n        enc.encode(password),\n        'PBKDF2',\n        false,\n        ['deriveBits']\n    );\n\n    const hashBits = await crypto.subtle.deriveBits(\n        {\n            name: 'PBKDF2',\n            salt,\n            iterations: PBKDF2_ITERATIONS,\n            hash: 'SHA-256',\n        },\n        keyMaterial,\n        256\n    );\n\n    return {\n        hash: arrayBufferToBase64(hashBits),\n        salt: arrayBufferToBase64(salt),\n    };\n}\n\n/**\n * Verify a password against a stored hash.\n *\n * @param {string} password   - The password to verify\n * @param {string} storedHash - base64-encoded hash from hashPassword()\n * @param {string} storedSalt - base64-encoded salt from hashPassword()\n * @returns {Promise<boolean>} True if the password matches\n */\nexport async function verifyPassword(password, storedHash, storedSalt) {\n    const { hash } = await hashPassword(password, storedSalt);\n    return hash === storedHash;\n}\n", "import { openDB } from 'idb';\n\nasync function openEventsDb() {\n    return await openDB('events', 1, {\n        upgrade(db) {\n            const events = db.createObjectStore('events', {\n                keyPath: 'event.id',\n            });\n            events.createIndex('pubkey', 'event.pubkey');\n            events.createIndex('created_at', 'event.created_at');\n            events.createIndex('kind', 'event.kind');\n            events.createIndex('host', 'metadata.host');\n        },\n    });\n}\n\nexport async function saveEvent(event) {\n    let db = await openEventsDb();\n    return db.put('events', event);\n}\n\nexport async function sortByIndex(index, query, asc, max) {\n    let db = await openEventsDb();\n    let events = [];\n    let cursor = await db\n        .transaction('events')\n        .store.index(index)\n        .openCursor(query, asc ? 'next' : 'prev');\n    while (cursor) {\n        events.push(cursor.value);\n        if (events.length >= max) {\n            break;\n        }\n        cursor = await cursor.continue();\n    }\n    return events;\n}\n\nexport async function getHosts() {\n    let db = await openEventsDb();\n    let hosts = new Set();\n    let cursor = await db.transaction('events').store.openCursor();\n    while (cursor) {\n        hosts.add(cursor.value.metadata.host);\n        cursor = await cursor.continue();\n    }\n    return [...hosts];\n}\n\nexport async function downloadAllContents() {\n    let db = await openEventsDb();\n    let events = [];\n    let cursor = await db.transaction('events').store.openCursor();\n    while (cursor) {\n        events.push(cursor.value.event);\n        cursor = await cursor.continue();\n    }\n    events = events.map(e => JSON.stringify(e));\n    events = events.join('\\n');\n    console.log(events);\n\n    const file = new File([events], 'events.jsonl', {\n        type: 'application/octet-stream',\n    });\n\n    const blob = new Blob([events], { type: 'plain/text' });\n\n    return blob;\n}\n", "const instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);\n\nlet idbProxyableTypes;\nlet cursorAdvanceMethods;\n// This is a function to prevent it throwing up in node environments.\nfunction getIdbProxyableTypes() {\n    return (idbProxyableTypes ||\n        (idbProxyableTypes = [\n            IDBDatabase,\n            IDBObjectStore,\n            IDBIndex,\n            IDBCursor,\n            IDBTransaction,\n        ]));\n}\n// This is a function to prevent it throwing up in node environments.\nfunction getCursorAdvanceMethods() {\n    return (cursorAdvanceMethods ||\n        (cursorAdvanceMethods = [\n            IDBCursor.prototype.advance,\n            IDBCursor.prototype.continue,\n            IDBCursor.prototype.continuePrimaryKey,\n        ]));\n}\nconst transactionDoneMap = new WeakMap();\nconst transformCache = new WeakMap();\nconst reverseTransformCache = new WeakMap();\nfunction promisifyRequest(request) {\n    const promise = new Promise((resolve, reject) => {\n        const unlisten = () => {\n            request.removeEventListener('success', success);\n            request.removeEventListener('error', error);\n        };\n        const success = () => {\n            resolve(wrap(request.result));\n            unlisten();\n        };\n        const error = () => {\n            reject(request.error);\n            unlisten();\n        };\n        request.addEventListener('success', success);\n        request.addEventListener('error', error);\n    });\n    // This mapping exists in reverseTransformCache but doesn't exist in transformCache. This\n    // is because we create many promises from a single IDBRequest.\n    reverseTransformCache.set(promise, request);\n    return promise;\n}\nfunction cacheDonePromiseForTransaction(tx) {\n    // Early bail if we've already created a done promise for this transaction.\n    if (transactionDoneMap.has(tx))\n        return;\n    const done = new Promise((resolve, reject) => {\n        const unlisten = () => {\n            tx.removeEventListener('complete', complete);\n            tx.removeEventListener('error', error);\n            tx.removeEventListener('abort', error);\n        };\n        const complete = () => {\n            resolve();\n            unlisten();\n        };\n        const error = () => {\n            reject(tx.error || new DOMException('AbortError', 'AbortError'));\n            unlisten();\n        };\n        tx.addEventListener('complete', complete);\n        tx.addEventListener('error', error);\n        tx.addEventListener('abort', error);\n    });\n    // Cache it for later retrieval.\n    transactionDoneMap.set(tx, done);\n}\nlet idbProxyTraps = {\n    get(target, prop, receiver) {\n        if (target instanceof IDBTransaction) {\n            // Special handling for transaction.done.\n            if (prop === 'done')\n                return transactionDoneMap.get(target);\n            // Make tx.store return the only store in the transaction, or undefined if there are many.\n            if (prop === 'store') {\n                return receiver.objectStoreNames[1]\n                    ? undefined\n                    : receiver.objectStore(receiver.objectStoreNames[0]);\n            }\n        }\n        // Else transform whatever we get back.\n        return wrap(target[prop]);\n    },\n    set(target, prop, value) {\n        target[prop] = value;\n        return true;\n    },\n    has(target, prop) {\n        if (target instanceof IDBTransaction &&\n            (prop === 'done' || prop === 'store')) {\n            return true;\n        }\n        return prop in target;\n    },\n};\nfunction replaceTraps(callback) {\n    idbProxyTraps = callback(idbProxyTraps);\n}\nfunction wrapFunction(func) {\n    // Due to expected object equality (which is enforced by the caching in `wrap`), we\n    // only create one new func per func.\n    // Cursor methods are special, as the behaviour is a little more different to standard IDB. In\n    // IDB, you advance the cursor and wait for a new 'success' on the IDBRequest that gave you the\n    // cursor. It's kinda like a promise that can resolve with many values. That doesn't make sense\n    // with real promises, so each advance methods returns a new promise for the cursor object, or\n    // undefined if the end of the cursor has been reached.\n    if (getCursorAdvanceMethods().includes(func)) {\n        return function (...args) {\n            // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use\n            // the original object.\n            func.apply(unwrap(this), args);\n            return wrap(this.request);\n        };\n    }\n    return function (...args) {\n        // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use\n        // the original object.\n        return wrap(func.apply(unwrap(this), args));\n    };\n}\nfunction transformCachableValue(value) {\n    if (typeof value === 'function')\n        return wrapFunction(value);\n    // This doesn't return, it just creates a 'done' promise for the transaction,\n    // which is later returned for transaction.done (see idbObjectHandler).\n    if (value instanceof IDBTransaction)\n        cacheDonePromiseForTransaction(value);\n    if (instanceOfAny(value, getIdbProxyableTypes()))\n        return new Proxy(value, idbProxyTraps);\n    // Return the same value back if we're not going to transform it.\n    return value;\n}\nfunction wrap(value) {\n    // We sometimes generate multiple promises from a single IDBRequest (eg when cursoring), because\n    // IDB is weird and a single IDBRequest can yield many responses, so these can't be cached.\n    if (value instanceof IDBRequest)\n        return promisifyRequest(value);\n    // If we've already transformed this value before, reuse the transformed value.\n    // This is faster, but it also provides object equality.\n    if (transformCache.has(value))\n        return transformCache.get(value);\n    const newValue = transformCachableValue(value);\n    // Not all types are transformed.\n    // These may be primitive types, so they can't be WeakMap keys.\n    if (newValue !== value) {\n        transformCache.set(value, newValue);\n        reverseTransformCache.set(newValue, value);\n    }\n    return newValue;\n}\nconst unwrap = (value) => reverseTransformCache.get(value);\n\n/**\n * Open a database.\n *\n * @param name Name of the database.\n * @param version Schema version.\n * @param callbacks Additional callbacks.\n */\nfunction openDB(name, version, { blocked, upgrade, blocking, terminated } = {}) {\n    const request = indexedDB.open(name, version);\n    const openPromise = wrap(request);\n    if (upgrade) {\n        request.addEventListener('upgradeneeded', (event) => {\n            upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction), event);\n        });\n    }\n    if (blocked) {\n        request.addEventListener('blocked', (event) => blocked(\n        // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405\n        event.oldVersion, event.newVersion, event));\n    }\n    openPromise\n        .then((db) => {\n        if (terminated)\n            db.addEventListener('close', () => terminated());\n        if (blocking) {\n            db.addEventListener('versionchange', (event) => blocking(event.oldVersion, event.newVersion, event));\n        }\n    })\n        .catch(() => { });\n    return openPromise;\n}\n/**\n * Delete a database.\n *\n * @param name Name of the database.\n */\nfunction deleteDB(name, { blocked } = {}) {\n    const request = indexedDB.deleteDatabase(name);\n    if (blocked) {\n        request.addEventListener('blocked', (event) => blocked(\n        // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405\n        event.oldVersion, event));\n    }\n    return wrap(request).then(() => undefined);\n}\n\nconst readMethods = ['get', 'getKey', 'getAll', 'getAllKeys', 'count'];\nconst writeMethods = ['put', 'add', 'delete', 'clear'];\nconst cachedMethods = new Map();\nfunction getMethod(target, prop) {\n    if (!(target instanceof IDBDatabase &&\n        !(prop in target) &&\n        typeof prop === 'string')) {\n        return;\n    }\n    if (cachedMethods.get(prop))\n        return cachedMethods.get(prop);\n    const targetFuncName = prop.replace(/FromIndex$/, '');\n    const useIndex = prop !== targetFuncName;\n    const isWrite = writeMethods.includes(targetFuncName);\n    if (\n    // Bail if the target doesn't exist on the target. Eg, getAll isn't in Edge.\n    !(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) ||\n        !(isWrite || readMethods.includes(targetFuncName))) {\n        return;\n    }\n    const method = async function (storeName, ...args) {\n        // isWrite ? 'readwrite' : undefined gzipps better, but fails in Edge :(\n        const tx = this.transaction(storeName, isWrite ? 'readwrite' : 'readonly');\n        let target = tx.store;\n        if (useIndex)\n            target = target.index(args.shift());\n        // Must reject if op rejects.\n        // If it's a write operation, must reject if tx.done rejects.\n        // Must reject with op rejection first.\n        // Must resolve with op value.\n        // Must handle both promises (no unhandled rejections)\n        return (await Promise.all([\n            target[targetFuncName](...args),\n            isWrite && tx.done,\n        ]))[0];\n    };\n    cachedMethods.set(prop, method);\n    return method;\n}\nreplaceTraps((oldTraps) => ({\n    ...oldTraps,\n    get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),\n    has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop),\n}));\n\nconst advanceMethodProps = ['continue', 'continuePrimaryKey', 'advance'];\nconst methodMap = {};\nconst advanceResults = new WeakMap();\nconst ittrProxiedCursorToOriginalProxy = new WeakMap();\nconst cursorIteratorTraps = {\n    get(target, prop) {\n        if (!advanceMethodProps.includes(prop))\n            return target[prop];\n        let cachedFunc = methodMap[prop];\n        if (!cachedFunc) {\n            cachedFunc = methodMap[prop] = function (...args) {\n                advanceResults.set(this, ittrProxiedCursorToOriginalProxy.get(this)[prop](...args));\n            };\n        }\n        return cachedFunc;\n    },\n};\nasync function* iterate(...args) {\n    // tslint:disable-next-line:no-this-assignment\n    let cursor = this;\n    if (!(cursor instanceof IDBCursor)) {\n        cursor = await cursor.openCursor(...args);\n    }\n    if (!cursor)\n        return;\n    cursor = cursor;\n    const proxiedCursor = new Proxy(cursor, cursorIteratorTraps);\n    ittrProxiedCursorToOriginalProxy.set(proxiedCursor, cursor);\n    // Map this double-proxy back to the original, so other cursor methods work.\n    reverseTransformCache.set(proxiedCursor, unwrap(cursor));\n    while (cursor) {\n        yield proxiedCursor;\n        // If one of the advancing methods was not called, call continue().\n        cursor = await (advanceResults.get(proxiedCursor) || cursor.continue());\n        advanceResults.delete(proxiedCursor);\n    }\n}\nfunction isIteratorProp(target, prop) {\n    return ((prop === Symbol.asyncIterator &&\n        instanceOfAny(target, [IDBIndex, IDBObjectStore, IDBCursor])) ||\n        (prop === 'iterate' && instanceOfAny(target, [IDBIndex, IDBObjectStore])));\n}\nreplaceTraps((oldTraps) => ({\n    ...oldTraps,\n    get(target, prop, receiver) {\n        if (isIteratorProp(target, prop))\n            return iterate;\n        return oldTraps.get(target, prop, receiver);\n    },\n    has(target, prop) {\n        return isIteratorProp(target, prop) || oldTraps.has(target, prop);\n    },\n}));\n\nexport { deleteDB, openDB, unwrap, wrap };\n", "/**\n * Sync Manager \u2014 Platform sync via storage.sync (Chrome \u2192 Google, Safari \u2192 iCloud)\n *\n * Architecture:\n *   Write: app \u2192 storage.local \u2192 scheduleSyncPush() \u2192 storage.sync\n *   Read:  pullFromSync() on startup \u2192 merge into storage.local\n *   Listen: storage.onChanged(\"sync\") \u2192 merge remote changes into local\n *\n * storage.local remains the source of truth. storage.sync is a best-effort mirror.\n */\n\nimport { api } from './browser-polyfill';\n\n// ---------------------------------------------------------------------------\n// Constants\n// ---------------------------------------------------------------------------\nconst SYNC_QUOTA = 102_400;       // 100 KB total\nconst MAX_ITEM = 8_192;           // 8 KB per item\nconst MAX_ITEMS = 512;\nconst CHUNK_PREFIX = '_chunk:';\nconst SYNC_META_KEY = '_sync_meta';\nconst LOCAL_ENABLED_KEY = 'platformSyncEnabled';\n\n// Keys that should never be synced\nconst EXCLUDED_KEYS = [\n    'bunkerSessions',\n    'ignoreInstallHook',\n    'passwordHash',\n    'passwordSalt',\n];\n\n// Priority tiers for budget allocation\nconst PRIORITY = {\n    P1_PROFILES: 1,\n    P2_SETTINGS: 2,\n    P3_APIKEYS: 3,\n    P4_VAULT: 4,\n};\n\nconst storage = api.storage.local;\nlet pushTimer = null;\n\n// ---------------------------------------------------------------------------\n// Chunking helpers\n// ---------------------------------------------------------------------------\n\n/**\n * Split a JSON-serialised value into <=8KB chunks.\n * Returns an array of { key, value } pairs ready for storage.sync.set().\n */\nfunction chunkValue(key, jsonString) {\n    const chunks = [];\n    for (let i = 0; i < jsonString.length; i += MAX_ITEM - 100) {\n        // Reserve ~100 bytes for the key overhead in the stored item\n        chunks.push(jsonString.slice(i, i + MAX_ITEM - 100));\n    }\n    if (chunks.length === 1) {\n        // Fits in a single item \u2014 store directly\n        return [{ key, value: jsonString }];\n    }\n    // Multiple chunks\n    const entries = [];\n    for (let i = 0; i < chunks.length; i++) {\n        entries.push({ key: `${CHUNK_PREFIX}${key}:${i}`, value: chunks[i] });\n    }\n    // Store a metadata entry so we know how many chunks there are\n    entries.push({ key, value: JSON.stringify({ __chunked: true, count: chunks.length }) });\n    return entries;\n}\n\n/**\n * Reassemble chunked data from a sync data object.\n * Returns the parsed JSON value, or null on error.\n */\nfunction reassembleFromSyncData(key, syncData) {\n    try {\n        const meta = typeof syncData[key] === 'string' ? JSON.parse(syncData[key]) : syncData[key];\n        if (!meta || !meta.__chunked) {\n            // Not chunked \u2014 parse directly\n            return typeof syncData[key] === 'string' ? JSON.parse(syncData[key]) : syncData[key];\n        }\n        let combined = '';\n        for (let i = 0; i < meta.count; i++) {\n            const chunkKey = `${CHUNK_PREFIX}${key}:${i}`;\n            if (syncData[chunkKey] == null) return null;\n            combined += syncData[chunkKey];\n        }\n        return JSON.parse(combined);\n    } catch {\n        return null;\n    }\n}\n\n// ---------------------------------------------------------------------------\n// Build sync payload\n// ---------------------------------------------------------------------------\n\n/**\n * Read all local data and build a prioritised list of entries to sync.\n * Returns { entries: [{ key, jsonString, priority, size }], totalSize }\n */\nasync function buildSyncPayload() {\n    const all = await storage.get(null);\n    const entries = [];\n\n    // P1: Profiles (strip `hosts` to save space) + profileIndex\n    if (all.profiles) {\n        const cleanProfiles = all.profiles.map(p => {\n            const { hosts, ...rest } = p;\n            return rest;\n        });\n        const json = JSON.stringify(cleanProfiles);\n        entries.push({ key: 'profiles', jsonString: json, priority: PRIORITY.P1_PROFILES, size: json.length });\n    }\n    if (all.profileIndex != null) {\n        const json = JSON.stringify(all.profileIndex);\n        entries.push({ key: 'profileIndex', jsonString: json, priority: PRIORITY.P1_PROFILES, size: json.length });\n    }\n    // NOTE: `isEncrypted` is intentionally NOT synced. The password verifier\n    // (passwordHash/passwordSalt) is excluded from sync for security, so a device\n    // that received isEncrypted=true with no hash would be permanently locked out\n    // (checkPassword always fails). Encryption state is strictly device-local.\n\n    // P2: Settings\n    const settingsKeys = ['autoLockMinutes', 'version', 'protocol_handler', LOCAL_ENABLED_KEY];\n    for (const k of settingsKeys) {\n        if (all[k] != null) {\n            const json = JSON.stringify(all[k]);\n            entries.push({ key: k, jsonString: json, priority: PRIORITY.P2_SETTINGS, size: json.length });\n        }\n    }\n    // Feature flags\n    for (const k of Object.keys(all)) {\n        if (k.startsWith('feature:')) {\n            const json = JSON.stringify(all[k]);\n            entries.push({ key: k, jsonString: json, priority: PRIORITY.P2_SETTINGS, size: json.length });\n        }\n    }\n\n    // P3: API key vault\n    if (all.apiKeyVault) {\n        const json = JSON.stringify(all.apiKeyVault);\n        entries.push({ key: 'apiKeyVault', jsonString: json, priority: PRIORITY.P3_APIKEYS, size: json.length });\n    }\n\n    // P4: Vault docs (individually, newest first)\n    if (all.vaultDocs && typeof all.vaultDocs === 'object') {\n        const docs = Object.values(all.vaultDocs).sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0));\n        for (const doc of docs) {\n            const docKey = `vaultDoc:${doc.path}`;\n            const json = JSON.stringify(doc);\n            entries.push({ key: docKey, jsonString: json, priority: PRIORITY.P4_VAULT, size: json.length });\n        }\n    }\n\n    return entries;\n}\n\n// ---------------------------------------------------------------------------\n// Push to sync\n// ---------------------------------------------------------------------------\n\nasync function pushToSync() {\n    if (!api.storage.sync) return;\n\n    const enabled = await isSyncEnabled();\n    if (!enabled) return;\n\n    try {\n        const entries = await buildSyncPayload();\n\n        // Sort by priority (ascending = most important first)\n        entries.sort((a, b) => a.priority - b.priority);\n\n        // Build the sync payload respecting budget\n        let usedBytes = 0;\n        let usedItems = 0;\n        const syncPayload = {};\n        const allSyncKeys = [];\n        let budgetExhausted = false;\n\n        for (const entry of entries) {\n            if (budgetExhausted) break;\n\n            const chunks = chunkValue(entry.key, entry.jsonString);\n            let entrySize = 0;\n            for (const c of chunks) {\n                entrySize += c.key.length + (typeof c.value === 'string' ? c.value.length : JSON.stringify(c.value).length);\n            }\n\n            if (usedBytes + entrySize > SYNC_QUOTA - 500 || usedItems + chunks.length > MAX_ITEMS - 5) {\n                if (entry.priority <= PRIORITY.P3_APIKEYS) {\n                    // Critical data \u2014 try anyway, let the API throw if truly over\n                } else {\n                    console.warn(`[SyncManager] Budget exhausted at priority ${entry.priority}, skipping remaining entries`);\n                    budgetExhausted = true;\n                    break;\n                }\n            }\n\n            for (const c of chunks) {\n                syncPayload[c.key] = c.value;\n                allSyncKeys.push(c.key);\n            }\n            usedBytes += entrySize;\n            usedItems += chunks.length;\n        }\n\n        // Add sync metadata\n        const meta = {\n            lastWrittenAt: Date.now(),\n            keys: allSyncKeys,\n        };\n        syncPayload[SYNC_META_KEY] = JSON.stringify(meta);\n\n        // Write to sync storage\n        await api.storage.sync.set(syncPayload);\n\n        // Clean orphaned chunks: read existing sync keys and remove any not in our payload\n        try {\n            const existing = await api.storage.sync.get(null);\n            const orphanKeys = Object.keys(existing).filter(k =>\n                k !== SYNC_META_KEY && !allSyncKeys.includes(k)\n            );\n            if (orphanKeys.length > 0) {\n                await api.storage.sync.remove(orphanKeys);\n            }\n        } catch {\n            // Non-critical cleanup\n        }\n\n        console.log(`[SyncManager] Pushed ${allSyncKeys.length} entries (${usedBytes} bytes) to sync storage`);\n    } catch (e) {\n        console.error('[SyncManager] pushToSync error:', e);\n        // Local storage is unaffected \u2014 graceful degradation\n    }\n}\n\n// ---------------------------------------------------------------------------\n// Pull from sync\n// ---------------------------------------------------------------------------\n\n/**\n * Read all data from sync storage and return as a plain object with\n * reassembled chunked values.\n */\nasync function pullFromSync() {\n    if (!api.storage.sync) return null;\n\n    try {\n        const raw = await api.storage.sync.get(null);\n        if (!raw || Object.keys(raw).length === 0) return null;\n\n        const metaStr = raw[SYNC_META_KEY];\n        if (!metaStr) return null;\n\n        let meta;\n        try { meta = JSON.parse(metaStr); } catch { return null; }\n\n        const result = {};\n        // Collect the non-chunk, non-meta keys\n        const dataKeys = meta.keys.filter(k => !k.startsWith(CHUNK_PREFIX) && k !== SYNC_META_KEY);\n\n        for (const key of dataKeys) {\n            const value = reassembleFromSyncData(key, raw);\n            if (value != null) {\n                result[key] = value;\n            }\n        }\n\n        result._syncMeta = meta;\n        return result;\n    } catch (e) {\n        console.error('[SyncManager] pullFromSync error:', e);\n        return null;\n    }\n}\n\n// ---------------------------------------------------------------------------\n// Merge logic\n// ---------------------------------------------------------------------------\n\n/**\n * Merge sync data into local storage with conflict resolution.\n */\nasync function mergeIntoLocal(syncData) {\n    if (!syncData) return;\n\n    const local = await storage.get(null);\n    const { updates, changed } = computeMergeUpdates(local, syncData);\n\n    if (changed) {\n        await storage.set(updates);\n        console.log('[SyncManager] Merged sync data into local:', Object.keys(updates));\n    }\n}\n\n/**\n * Pure merge: given the current local state and an incoming sync payload,\n * compute the storage updates to apply. No I/O \u2014 exported so the merge rules\n * (fresh-install detection, pubkey-keyed profile matching, encryption-state\n * exclusion) can be regression-tested directly.\n *\n * @returns {{ updates: Object, changed: boolean }}\n */\nexport function computeMergeUpdates(local, syncData) {\n    const updates = {};\n    let changed = false;\n    if (!syncData) return { updates, changed };\n\n    // Detect fresh install: no profiles, or only profile(s) that carry no\n    // identity at all (no private key, no cached pubkey, not a bunker/remote\n    // signer). A bunker profile legitimately has privKey:'' but IS a real\n    // identity \u2014 it must not be treated as a blank install and wiped.\n    const hasIdentity = (p) =>\n        !!(p.privKey || p.pubKey || p.type === 'bunker' || p.bunkerUrl || p.remotePubkey);\n    const isFresh = !local.profiles ||\n        local.profiles.length === 0 ||\n        !local.profiles.some(hasIdentity);\n\n    // --- Profiles (P1) ---\n    if (syncData.profiles) {\n        if (isFresh) {\n            // Fresh install \u2014 adopt sync profiles entirely\n            updates.profiles = syncData.profiles;\n            changed = true;\n        } else if (local.profiles) {\n            // Match profiles by pubkey (stable identity), NOT array index \u2014\n            // reordering or inserting a profile on one device must never cause\n            // one identity's key material to overwrite an unrelated profile.\n            const merged = [...local.profiles];\n            const indexByPubkey = new Map();\n            merged.forEach((p, i) => { if (p.pubKey) indexByPubkey.set(p.pubKey, i); });\n\n            for (const syncProfile of syncData.profiles) {\n                const localIdx = syncProfile.pubKey != null\n                    ? indexByPubkey.get(syncProfile.pubKey)\n                    : undefined;\n\n                if (localIdx === undefined) {\n                    // No local profile with this pubkey \u2014 it's a new one from sync.\n                    // (Profiles without a pubkey can't be safely matched, so we add\n                    // rather than risk clobbering an unrelated local profile.)\n                    merged.push(syncProfile);\n                    if (syncProfile.pubKey) indexByPubkey.set(syncProfile.pubKey, merged.length - 1);\n                    changed = true;\n                } else {\n                    const localProfile = merged[localIdx];\n                    const syncTime = syncProfile.updatedAt || 0;\n                    const localTime = localProfile.updatedAt || 0;\n                    if (syncTime > localTime) {\n                        // Sync is newer \u2014 merge but preserve local hosts\n                        merged[localIdx] = { ...syncProfile, hosts: localProfile.hosts || {} };\n                        changed = true;\n                    }\n                }\n            }\n            if (changed) updates.profiles = merged;\n        }\n    }\n\n    // --- Profile index (P1) ---\n    if (syncData.profileIndex != null && isFresh) {\n        updates.profileIndex = syncData.profileIndex;\n        changed = true;\n    }\n\n    // --- Encryption state (P1) ---\n    // Intentionally NOT merged from sync. See buildSyncPayload(): the password\n    // verifier is never synced, so trusting a synced isEncrypted=true would lock\n    // the user out permanently. Encryption state stays device-local.\n\n    // --- Settings (P2) \u2014 last-write-wins ---\n    const syncMeta = syncData._syncMeta || {};\n    const settingsKeys = ['autoLockMinutes', 'version', 'protocol_handler', LOCAL_ENABLED_KEY];\n    for (const key of settingsKeys) {\n        if (syncData[key] != null && syncData[key] !== local[key]) {\n            // For version, only accept higher\n            if (key === 'version' && local.version && syncData.version <= local.version) continue;\n            updates[key] = syncData[key];\n            changed = true;\n        }\n    }\n    // Feature flags\n    for (const key of Object.keys(syncData)) {\n        if (key.startsWith('feature:') && syncData[key] !== local[key]) {\n            updates[key] = syncData[key];\n            changed = true;\n        }\n    }\n\n    // --- API Key Vault (P3) ---\n    if (syncData.apiKeyVault) {\n        if (!local.apiKeyVault || isFresh) {\n            updates.apiKeyVault = syncData.apiKeyVault;\n            changed = true;\n        } else {\n            // Merge individual keys by updatedAt\n            const localKeys = local.apiKeyVault.keys || {};\n            const syncKeys = syncData.apiKeyVault.keys || {};\n            const merged = { ...localKeys };\n            for (const [id, syncKey] of Object.entries(syncKeys)) {\n                const localKey = merged[id];\n                if (!localKey || (syncKey.updatedAt || 0) > (localKey.updatedAt || 0)) {\n                    merged[id] = syncKey;\n                    changed = true;\n                }\n            }\n            if (changed) {\n                updates.apiKeyVault = { ...local.apiKeyVault, keys: merged };\n            }\n        }\n    }\n\n    // --- Vault docs (P4) ---\n    const localDocs = local.vaultDocs || {};\n    let docsChanged = false;\n    const mergedDocs = { ...localDocs };\n    for (const key of Object.keys(syncData)) {\n        if (!key.startsWith('vaultDoc:')) continue;\n        const doc = syncData[key];\n        if (!doc || !doc.path) continue;\n        const localDoc = mergedDocs[doc.path];\n        if (!localDoc || (doc.updatedAt || 0) > (localDoc.updatedAt || 0)) {\n            mergedDocs[doc.path] = doc;\n            docsChanged = true;\n        }\n    }\n    if (docsChanged) {\n        updates.vaultDocs = mergedDocs;\n        changed = true;\n    }\n\n    return { updates, changed };\n}\n\n// ---------------------------------------------------------------------------\n// Debounced push\n// ---------------------------------------------------------------------------\n\n/**\n * Schedule a sync push with a 2-second debounce.\n * Exported for use by stores and the storage interceptor.\n */\nexport function scheduleSyncPush() {\n    if (!api.storage.sync) return;\n    if (pushTimer) clearTimeout(pushTimer);\n    pushTimer = setTimeout(() => {\n        pushTimer = null;\n        pushToSync();\n    }, 2000);\n}\n\n// ---------------------------------------------------------------------------\n// Enable / disable\n// ---------------------------------------------------------------------------\n\nexport async function isSyncEnabled() {\n    const data = await storage.get({ [LOCAL_ENABLED_KEY]: true });\n    return data[LOCAL_ENABLED_KEY];\n}\n\nexport async function setSyncEnabled(enabled) {\n    await storage.set({ [LOCAL_ENABLED_KEY]: enabled });\n    if (enabled) {\n        scheduleSyncPush();\n    }\n}\n\n// ---------------------------------------------------------------------------\n// Initialisation\n// ---------------------------------------------------------------------------\n\n/**\n * Called once on startup (from background.js).\n * Pulls from sync, merges, then listens for remote changes.\n */\nexport async function initSync() {\n    if (!api.storage.sync) {\n        console.log('[SyncManager] storage.sync not available \u2014 skipping');\n        return;\n    }\n\n    const enabled = await isSyncEnabled();\n    if (!enabled) {\n        console.log('[SyncManager] Platform sync disabled');\n        return;\n    }\n\n    // Pull + merge\n    try {\n        const syncData = await pullFromSync();\n        if (syncData) {\n            await mergeIntoLocal(syncData);\n            console.log('[SyncManager] Initial pull+merge complete');\n        } else {\n            console.log('[SyncManager] No sync data found \u2014 fresh sync');\n        }\n    } catch (e) {\n        console.error('[SyncManager] Initial pull failed:', e);\n    }\n\n    // Listen for remote changes\n    if (api.storage.onChanged) {\n        api.storage.onChanged.addListener((changes, areaName) => {\n            if (areaName !== 'sync') return;\n            console.log('[SyncManager] Remote sync change detected');\n            // Re-pull and merge the full sync data to handle chunked values correctly\n            pullFromSync().then(syncData => {\n                if (syncData) mergeIntoLocal(syncData);\n            }).catch(e => {\n                console.error('[SyncManager] Remote merge error:', e);\n            });\n        });\n    }\n\n    // Do an initial push so local data is mirrored\n    scheduleSyncPush();\n}\n", "/**\n * NIP-46 Nostr Connect (nsecBunker) Client\n *\n * Implements the client side of NIP-46 for remote signing.\n * The extension connects to a bunker via Nostr relays.\n * The bunker holds the nsec and performs signing operations.\n *\n * Flow:\n *   1. User provides a bunker:// connection string\n *   2. Client generates an ephemeral keypair for the session\n *   3. Client connects to the relay specified in the connection string\n *   4. Client sends NIP-44 encrypted requests to the bunker pubkey\n *   5. Bunker responds with NIP-44 encrypted results\n *   6. Client decrypts and returns the result\n *\n * Connection string format:\n *   bunker://<remote-signer-pubkey>?relay=wss://...&relay=wss://...&secret=<optional>\n */\n\nimport {\n    finalizeEvent,\n    bytesToHex,\n    hexToBytes,\n} from 'nostr-crypto-utils';\nimport { generateKeyPair } from './keys.js';\nimport * as nip44 from 'nostr-crypto-utils/nip44';\nimport { api } from './browser-polyfill';\n\nconst storage = api.storage.local;\nconst log = msg => console.log('NIP-46: ', msg);\n\n// Active bunker sessions keyed by profile index\nconst sessions = new Map();\n\n/**\n * Parse a bunker:// connection string\n * Format: bunker://<pubkey>?relay=wss://...&relay=wss://...&secret=<optional>\n */\nexport function parseBunkerUrl(url) {\n    if (!url.startsWith('bunker://')) {\n        throw new Error('Invalid bunker URL: must start with bunker://');\n    }\n\n    const parsed = new URL(url);\n    const remotePubkey = parsed.hostname || parsed.pathname.replace('//', '');\n\n    if (!/^[0-9a-f]{64}$/i.test(remotePubkey)) {\n        throw new Error('Invalid bunker URL: pubkey must be 64 hex characters');\n    }\n\n    const relays = parsed.searchParams.getAll('relay');\n    if (relays.length === 0) {\n        throw new Error('Invalid bunker URL: at least one relay is required');\n    }\n\n    // Validate relay URLs\n    for (const relay of relays) {\n        try {\n            const r = new URL(relay);\n            if (r.protocol !== 'wss:' && r.protocol !== 'ws:') {\n                throw new Error(`Invalid relay protocol: ${r.protocol}`);\n            }\n        } catch (e) {\n            throw new Error(`Invalid relay URL: ${relay}`);\n        }\n    }\n\n    const secret = parsed.searchParams.get('secret') || null;\n\n    return { remotePubkey, relays, secret };\n}\n\n/**\n * A single WebSocket connection to a Nostr relay\n */\nexport class RelayConnection {\n    constructor(url) {\n        this.url = url;\n        this.ws = null;\n        this.subscriptions = new Map();\n        this.eoseCallbacks = new Map();\n        this.connected = false;\n        this.reconnectTimer = null;\n        this.reconnectAttempts = 0;\n        this.maxReconnectAttempts = 5;\n    }\n\n    connect() {\n        return new Promise((resolve, reject) => {\n            try {\n                this.ws = new WebSocket(this.url);\n            } catch (e) {\n                reject(new Error(`Failed to create WebSocket: ${e.message}`));\n                return;\n            }\n\n            const timeout = setTimeout(() => {\n                this.ws?.close();\n                reject(new Error(`Connection timeout: ${this.url}`));\n            }, 10000);\n\n            this.ws.onopen = () => {\n                clearTimeout(timeout);\n                this.connected = true;\n                this.reconnectAttempts = 0;\n                log(`Connected to ${this.url}`);\n                resolve();\n            };\n\n            this.ws.onerror = (err) => {\n                clearTimeout(timeout);\n                log(`WebSocket error: ${this.url}`);\n                reject(new Error(`WebSocket error: ${this.url}`));\n            };\n\n            this.ws.onclose = () => {\n                this.connected = false;\n                log(`Disconnected from ${this.url}`);\n                this.scheduleReconnect();\n            };\n\n            this.ws.onmessage = (msg) => {\n                try {\n                    const data = JSON.parse(msg.data);\n                    this.handleMessage(data);\n                } catch (e) {\n                    log(`Failed to parse message: ${e.message}`);\n                }\n            };\n        });\n    }\n\n    handleMessage(data) {\n        const [type, subId, ...rest] = data;\n\n        if (type === 'EVENT' && subId && rest[0]) {\n            const event = rest[0];\n            const handler = this.subscriptions.get(subId);\n            if (handler) {\n                handler(event);\n            }\n        } else if (type === 'EOSE' && subId) {\n            const eoseHandler = this.eoseCallbacks.get(subId);\n            if (eoseHandler) {\n                this.eoseCallbacks.delete(subId);\n                eoseHandler();\n            }\n        } else if (type === 'OK') {\n            // Event accepted\n        } else if (type === 'NOTICE') {\n            log(`Relay notice: ${rest[0]}`);\n        }\n    }\n\n    subscribe(subId, filters, onEvent, onEose = null) {\n        if (!this.connected || !this.ws) {\n            throw new Error('Not connected');\n        }\n        this.subscriptions.set(subId, onEvent);\n        if (onEose) {\n            this.eoseCallbacks.set(subId, onEose);\n        }\n        this.ws.send(JSON.stringify(['REQ', subId, ...filters]));\n    }\n\n    unsubscribe(subId) {\n        if (this.ws && this.connected) {\n            this.ws.send(JSON.stringify(['CLOSE', subId]));\n        }\n        this.subscriptions.delete(subId);\n        this.eoseCallbacks.delete(subId);\n    }\n\n    publish(event) {\n        if (!this.connected || !this.ws) {\n            throw new Error('Not connected');\n        }\n        this.ws.send(JSON.stringify(['EVENT', event]));\n    }\n\n    scheduleReconnect() {\n        if (this.reconnectAttempts >= this.maxReconnectAttempts) {\n            log(`Max reconnect attempts reached for ${this.url}`);\n            return;\n        }\n\n        const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30000);\n        this.reconnectAttempts++;\n\n        this.reconnectTimer = setTimeout(() => {\n            log(`Reconnecting to ${this.url} (attempt ${this.reconnectAttempts})`);\n            this.connect().catch(() => {});\n        }, delay);\n    }\n\n    close() {\n        clearTimeout(this.reconnectTimer);\n        this.maxReconnectAttempts = 0; // Prevent further reconnects\n        this.subscriptions.clear();\n        this.eoseCallbacks.clear();\n        if (this.ws) {\n            this.ws.close();\n            this.ws = null;\n        }\n        this.connected = false;\n    }\n}\n\n/**\n * NIP-46 Bunker Session\n *\n * Manages a session with a remote signer (nsecBunker).\n * Uses an ephemeral keypair for encrypted communication.\n */\nexport class BunkerSession {\n    constructor({ remotePubkey, relays, secret }) {\n        this.remotePubkey = remotePubkey;\n        this.relayUrls = relays;\n        this.secret = secret;\n\n        // Keypair will be initialized in init()\n        this.sessionPrivkey = null;\n        this.sessionPubkey = null;\n        this.conversationKey = null;\n\n        this.relays = [];\n        this.pendingRequests = new Map();\n        this.connected = false;\n        this.subId = `nostrkey-${crypto.randomUUID().slice(0, 8)}`;\n    }\n\n    /**\n     * Initialize the ephemeral session keypair (async)\n     */\n    async init() {\n        if (this.sessionPrivkey) return; // Already initialized\n\n        // Generate ephemeral session keypair\n        const keyPair = await generateKeyPair();\n        this.sessionPrivkey = hexToBytes(keyPair.privateKey);\n        this.sessionPubkey = keyPair.publicKey;\n\n        // Derive NIP-44 conversation key\n        this.conversationKey = nip44.v2.utils.getConversationKey(\n            this.sessionPrivkey,\n            this.remotePubkey\n        );\n    }\n\n    /**\n     * Connect to all relays and subscribe for responses\n     */\n    async connect() {\n        // Ensure keypair is initialized\n        await this.init();\n\n        // Connect to relays\n        const connections = this.relayUrls.map(url => {\n            const relay = new RelayConnection(url);\n            return relay.connect().then(() => {\n                this.relays.push(relay);\n                return relay;\n            });\n        });\n\n        // Wait for at least one connection\n        const results = await Promise.allSettled(connections);\n        const connected = results.filter(r => r.status === 'fulfilled');\n\n        if (connected.length === 0) {\n            throw new Error('Failed to connect to any relay');\n        }\n\n        log(`Connected to ${connected.length}/${this.relayUrls.length} relays`);\n\n        // Subscribe for NIP-46 responses (kind 24133 addressed to our session pubkey)\n        for (const relay of this.relays) {\n            relay.subscribe(\n                this.subId,\n                [{ kinds: [24133], '#p': [this.sessionPubkey] }],\n                (event) => this.handleResponse(event)\n            );\n        }\n\n        this.connected = true;\n\n        // Send connect request if secret is provided\n        if (this.secret) {\n            await this.sendRequest('connect', [this.remotePubkey, this.secret]);\n        } else {\n            await this.sendRequest('connect', [this.remotePubkey]);\n        }\n    }\n\n    /**\n     * Handle an incoming NIP-46 response event\n     */\n    handleResponse(event) {\n        // Must be from the remote signer\n        if (event.pubkey !== this.remotePubkey) {\n            log(`Ignoring event from unknown pubkey: ${event.pubkey}`);\n            return;\n        }\n\n        try {\n            // Decrypt the response\n            const plaintext = nip44.v2.decrypt(event.content, this.conversationKey);\n            const response = JSON.parse(plaintext);\n\n            log(`Response: ${response.id} -> ${response.result ? 'ok' : response.error}`);\n\n            const pending = this.pendingRequests.get(response.id);\n            if (pending) {\n                this.pendingRequests.delete(response.id);\n\n                if (response.error) {\n                    pending.reject(new Error(response.error));\n                } else {\n                    pending.resolve(response.result);\n                }\n            }\n        } catch (e) {\n            log(`Failed to handle response: ${e.message}`);\n        }\n    }\n\n    /**\n     * Send an encrypted NIP-46 request to the bunker\n     */\n    async sendRequest(method, params = []) {\n        if (!this.connected && method !== 'connect') {\n            throw new Error('Not connected to bunker');\n        }\n\n        const id = crypto.randomUUID();\n\n        const request = JSON.stringify({ id, method, params });\n        const encrypted = nip44.v2.encrypt(request, this.conversationKey);\n\n        // Create and sign the event\n        const event = await finalizeEvent({\n            kind: 24133,\n            content: encrypted,\n            tags: [['p', this.remotePubkey]],\n            created_at: Math.floor(Date.now() / 1000),\n        }, this.sessionPrivkey);\n\n        // Publish to all connected relays\n        for (const relay of this.relays) {\n            try {\n                relay.publish(event);\n            } catch (e) {\n                log(`Failed to publish to ${relay.url}: ${e.message}`);\n            }\n        }\n\n        // Wait for response with timeout\n        return new Promise((resolve, reject) => {\n            const timeout = setTimeout(() => {\n                this.pendingRequests.delete(id);\n                reject(new Error(`Request timeout: ${method}`));\n            }, 30000);\n\n            this.pendingRequests.set(id, {\n                resolve: (result) => {\n                    clearTimeout(timeout);\n                    resolve(result);\n                },\n                reject: (error) => {\n                    clearTimeout(timeout);\n                    reject(error);\n                },\n            });\n        });\n    }\n\n    /**\n     * NIP-46 Methods\n     */\n\n    async getPublicKey() {\n        return await this.sendRequest('get_public_key');\n    }\n\n    async signEvent(event) {\n        const result = await this.sendRequest('sign_event', [JSON.stringify(event)]);\n        return JSON.parse(result);\n    }\n\n    async nip04Encrypt(thirdPartyPubkey, plaintext) {\n        return await this.sendRequest('nip04_encrypt', [thirdPartyPubkey, plaintext]);\n    }\n\n    async nip04Decrypt(thirdPartyPubkey, ciphertext) {\n        return await this.sendRequest('nip04_decrypt', [thirdPartyPubkey, ciphertext]);\n    }\n\n    async nip44Encrypt(thirdPartyPubkey, plaintext) {\n        return await this.sendRequest('nip44_encrypt', [thirdPartyPubkey, plaintext]);\n    }\n\n    async nip44Decrypt(thirdPartyPubkey, ciphertext) {\n        return await this.sendRequest('nip44_decrypt', [thirdPartyPubkey, ciphertext]);\n    }\n\n    async ping() {\n        return await this.sendRequest('ping');\n    }\n\n    /**\n     * Get session info for persistence\n     */\n    getSessionInfo() {\n        return {\n            remotePubkey: this.remotePubkey,\n            relayUrls: this.relayUrls,\n            secret: this.secret,\n            sessionPrivkey: bytesToHex(this.sessionPrivkey),\n            sessionPubkey: this.sessionPubkey,\n        };\n    }\n\n    /**\n     * Disconnect from all relays\n     */\n    disconnect() {\n        for (const relay of this.relays) {\n            relay.unsubscribe(this.subId);\n            relay.close();\n        }\n        this.relays = [];\n        this.pendingRequests.clear();\n        this.connected = false;\n        log('Disconnected from bunker');\n    }\n}\n\n/**\n * Restore a session from persisted session info\n */\nexport function restoreSession(sessionInfo) {\n    const session = new BunkerSession({\n        remotePubkey: sessionInfo.remotePubkey,\n        relays: sessionInfo.relayUrls,\n        secret: sessionInfo.secret,\n    });\n\n    // Restore the original session keypair instead of generating new one\n    session.sessionPrivkey = hexToBytes(sessionInfo.sessionPrivkey);\n    session.sessionPubkey = sessionInfo.sessionPubkey;\n    session.conversationKey = nip44.v2.utils.getConversationKey(\n        session.sessionPrivkey,\n        session.remotePubkey\n    );\n\n    return session;\n}\n\n/**\n * Session Manager \u2014 manages active bunker sessions per profile\n */\n\nexport async function getOrCreateSession(profileIndex) {\n    // Check if we have an active session\n    if (sessions.has(profileIndex)) {\n        const session = sessions.get(profileIndex);\n        if (session.connected) {\n            return session;\n        }\n        // Session disconnected, clean up\n        session.disconnect();\n        sessions.delete(profileIndex);\n    }\n\n    // Try to restore from persisted session info\n    const data = await storage.get({ bunkerSessions: {} });\n    const sessionInfo = data.bunkerSessions?.[profileIndex];\n\n    if (!sessionInfo) {\n        throw new Error('No bunker session configured for this profile');\n    }\n\n    const session = restoreSession(sessionInfo);\n    await session.connect();\n    sessions.set(profileIndex, session);\n    return session;\n}\n\nexport async function createSession(profileIndex, bunkerUrl) {\n    // Disconnect existing session\n    if (sessions.has(profileIndex)) {\n        sessions.get(profileIndex).disconnect();\n        sessions.delete(profileIndex);\n    }\n\n    const config = parseBunkerUrl(bunkerUrl);\n    const session = new BunkerSession(config);\n    await session.connect();\n\n    // Persist session info\n    const data = await storage.get({ bunkerSessions: {} });\n    const bunkerSessions = data.bunkerSessions || {};\n    bunkerSessions[profileIndex] = session.getSessionInfo();\n    await storage.set({ bunkerSessions });\n\n    sessions.set(profileIndex, session);\n    return session;\n}\n\nexport async function disconnectSession(profileIndex) {\n    if (sessions.has(profileIndex)) {\n        sessions.get(profileIndex).disconnect();\n        sessions.delete(profileIndex);\n    }\n\n    // Remove persisted session\n    const data = await storage.get({ bunkerSessions: {} });\n    const bunkerSessions = data.bunkerSessions || {};\n    delete bunkerSessions[profileIndex];\n    await storage.set({ bunkerSessions });\n}\n\nexport function isSessionActive(profileIndex) {\n    return sessions.has(profileIndex) && sessions.get(profileIndex).connected;\n}\n\n/**\n * Validate a bunker URL without connecting\n */\nexport function validateBunkerUrl(url) {\n    try {\n        parseBunkerUrl(url);\n        return { valid: true, error: null };\n    } catch (e) {\n        return { valid: false, error: e.message };\n    }\n}\n", "/**\n * NIP-46 Bunker Server\n *\n * The inverse of BunkerSession in nip46.js \u2014 this makes the NostrKey\n * extension act as a NIP-46 remote signer (bunker).\n *\n * Flow:\n *   1. Extension generates a connection secret and opens a WebSocket to the relay\n *   2. Extension subscribes for kind 24133 events tagged with the user's pubkey\n *   3. A remote client sends an encrypted request (connect, sign_event, etc.)\n *   4. Extension decrypts, executes, encrypts the response, publishes back\n *\n * Connection string format:\n *   bunker://<user-pubkey>?relay=wss://...&secret=<random>\n */\n\nimport {\n    finalizeEvent,\n    bytesToHex,\n    nip04,\n} from 'nostr-crypto-utils';\nimport * as nip44 from 'nostr-crypto-utils/nip44';\nimport { RelayConnection } from './nip46.js';\n\nconst log = msg => console.log('BunkerServer: ', msg);\n\nexport class BunkerServer {\n    /**\n     * @param {Object} opts\n     * @param {string[]} opts.relayUrls  - relay URLs to connect to\n     * @param {string}   opts.userPubkey - hex pubkey of the local user\n     * @param {string}   opts.secret     - shared secret for connect handshake\n     */\n    constructor({ relayUrls, userPubkey, secret }) {\n        this.relayUrls = relayUrls;\n        this.userPubkey = userPubkey;\n        this.secret = secret;\n\n        this.relays = [];\n        this.authenticatedClients = new Set();\n        this.subId = `bunker-srv-${crypto.randomUUID().slice(0, 8)}`;\n        this.active = false;\n\n        // Will be set by start()\n        this._getPrivKey = null;\n    }\n\n    /**\n     * Start the bunker server.\n     * @param {Object} opts\n     * @param {Function} opts.getPrivKey - async () => Uint8Array (user's private key)\n     */\n    async start({ getPrivKey }) {\n        this._getPrivKey = getPrivKey;\n\n        // Connect to relays\n        const connections = this.relayUrls.map(url => {\n            const relay = new RelayConnection(url);\n            return relay.connect().then(() => {\n                this.relays.push(relay);\n                return relay;\n            });\n        });\n\n        const results = await Promise.allSettled(connections);\n        const connected = results.filter(r => r.status === 'fulfilled');\n\n        if (connected.length === 0) {\n            throw new Error('Failed to connect to any relay');\n        }\n\n        log(`Connected to ${connected.length}/${this.relayUrls.length} relays`);\n\n        // Subscribe for incoming NIP-46 requests (kind 24133 tagged with our pubkey)\n        for (const relay of this.relays) {\n            relay.subscribe(\n                this.subId,\n                [{ kinds: [24133], '#p': [this.userPubkey], since: Math.floor(Date.now() / 1000) - 5 }],\n                (event) => this._handleRequest(event)\n            );\n        }\n\n        this.active = true;\n        log('Bunker server started');\n    }\n\n    /**\n     * Stop the bunker server.\n     */\n    stop() {\n        for (const relay of this.relays) {\n            relay.unsubscribe(this.subId);\n            relay.close();\n        }\n        this.relays = [];\n        this.authenticatedClients.clear();\n        this.active = false;\n        this._getPrivKey = null;\n        log('Bunker server stopped');\n    }\n\n    /**\n     * Generate the bunker:// connection string.\n     */\n    getConnectionString() {\n        const relayParams = this.relayUrls.map(u => `relay=${encodeURIComponent(u)}`).join('&');\n        return `bunker://${this.userPubkey}?${relayParams}&secret=${this.secret}`;\n    }\n\n    /**\n     * Handle an incoming NIP-46 request event.\n     */\n    async _handleRequest(event) {\n        const clientPubkey = event.pubkey;\n\n        let privKey;\n        try {\n            privKey = await this._getPrivKey();\n        } catch (e) {\n            log(`Cannot get private key (locked?): ${e.message}`);\n            return;\n        }\n\n        // Derive conversation key with the requesting client\n        let conversationKey;\n        try {\n            conversationKey = nip44.v2.utils.getConversationKey(privKey, clientPubkey);\n        } catch (e) {\n            log(`Failed to derive conversation key: ${e.message}`);\n            return;\n        }\n\n        // Decrypt the request\n        let request;\n        try {\n            const plaintext = nip44.v2.decrypt(event.content, conversationKey);\n            request = JSON.parse(plaintext);\n        } catch (e) {\n            log(`Failed to decrypt request: ${e.message}`);\n            return;\n        }\n\n        const { id, method, params } = request;\n        log(`Request: ${method} (id=${id}) from ${clientPubkey.slice(0, 8)}...`);\n\n        // Security: reject unauthenticated clients for everything except connect\n        if (method !== 'connect' && !this.authenticatedClients.has(clientPubkey)) {\n            await this._sendResponse(privKey, clientPubkey, conversationKey, {\n                id,\n                result: null,\n                error: 'Unauthorized: send connect first',\n            });\n            return;\n        }\n\n        // Dispatch\n        let result = null;\n        let error = null;\n\n        try {\n            switch (method) {\n                case 'connect': {\n                    // params[0] = remote pubkey (should match ours), params[1] = secret\n                    const clientSecret = params[1];\n                    if (this.secret && clientSecret !== this.secret) {\n                        error = 'Invalid secret';\n                    } else {\n                        this.authenticatedClients.add(clientPubkey);\n                        result = 'ack';\n                        log(`Client authenticated: ${clientPubkey.slice(0, 8)}...`);\n                    }\n                    break;\n                }\n\n                case 'get_public_key':\n                    result = this.userPubkey;\n                    break;\n\n                case 'sign_event': {\n                    const unsigned = JSON.parse(params[0]);\n                    const signed = await finalizeEvent(unsigned, privKey);\n                    result = JSON.stringify(signed);\n                    break;\n                }\n\n                case 'nip44_encrypt': {\n                    const thirdPartyPubkey = params[0];\n                    const plaintext = params[1];\n                    const ck = nip44.v2.utils.getConversationKey(privKey, thirdPartyPubkey);\n                    result = nip44.v2.encrypt(plaintext, ck);\n                    break;\n                }\n\n                case 'nip44_decrypt': {\n                    const thirdPartyPubkey = params[0];\n                    const ciphertext = params[1];\n                    const ck = nip44.v2.utils.getConversationKey(privKey, thirdPartyPubkey);\n                    result = nip44.v2.decrypt(ciphertext, ck);\n                    break;\n                }\n\n                case 'nip04_encrypt': {\n                    const thirdPartyPubkey = params[0];\n                    const plaintext = params[1];\n                    result = await nip04.encryptMessage(plaintext, bytesToHex(privKey), thirdPartyPubkey);\n                    break;\n                }\n\n                case 'nip04_decrypt': {\n                    const thirdPartyPubkey = params[0];\n                    const ciphertext = params[1];\n                    result = await nip04.decryptMessage(ciphertext, bytesToHex(privKey), thirdPartyPubkey);\n                    break;\n                }\n\n                case 'ping':\n                    result = 'pong';\n                    break;\n\n                default:\n                    error = `Unsupported method: ${method}`;\n            }\n        } catch (e) {\n            error = e.message;\n            log(`Error handling ${method}: ${e.message}`);\n        }\n\n        await this._sendResponse(privKey, clientPubkey, conversationKey, { id, result, error });\n    }\n\n    /**\n     * Encrypt and publish a NIP-46 response.\n     */\n    async _sendResponse(privKey, clientPubkey, conversationKey, response) {\n        const encrypted = nip44.v2.encrypt(JSON.stringify(response), conversationKey);\n\n        const event = await finalizeEvent({\n            kind: 24133,\n            content: encrypted,\n            tags: [['p', clientPubkey]],\n            created_at: Math.floor(Date.now() / 1000),\n        }, privKey);\n\n        for (const relay of this.relays) {\n            try {\n                relay.publish(event);\n            } catch (e) {\n                log(`Failed to publish response to ${relay.url}: ${e.message}`);\n            }\n        }\n\n        log(`Response sent: ${response.id} ${response.error ? 'ERROR' : 'OK'}`);\n    }\n}\n", "/**\n * NIP-78 Encrypted Vault Protocol\n *\n * Pure functions for building/parsing kind 30078 (parameterized replaceable)\n * events used as an encrypted markdown document vault.\n *\n * d-tag prefix \"nostrkey:\" namespaces our vault items from other NIP-78 apps.\n * Relays see file paths but not content (NIP-44 encrypted to self).\n */\n\nconst KIND_APP_DATA = 30078;\nconst KIND_DELETION = 5;\nconst DTAG_PREFIX = 'nostrkey:';\nconst CLIENT_TAG = 'nostrkey';\n\n/**\n * Build an unsigned kind 30078 vault event.\n * Caller must sign (finalizeEvent or bunker session.signEvent).\n *\n * @param {string} path - Document path (e.g. \"notes/todo.md\")\n * @param {string} encryptedContent - NIP-44 encrypted content string\n * @returns {object} Unsigned event template\n */\nexport function buildVaultEvent(path, encryptedContent) {\n    return {\n        kind: KIND_APP_DATA,\n        content: encryptedContent,\n        tags: [\n            ['d', `${DTAG_PREFIX}${path}`],\n            ['client', CLIENT_TAG],\n        ],\n        created_at: Math.floor(Date.now() / 1000),\n    };\n}\n\n/**\n * Build an unsigned kind 5 deletion event (NIP-09) for a vault document.\n *\n * @param {string} eventId - The event id to delete\n * @param {string} path - Document path (for the a-tag reference)\n * @returns {object} Unsigned deletion event template\n */\nexport function buildVaultDeletion(eventId, path) {\n    return {\n        kind: KIND_DELETION,\n        content: 'vault document deleted',\n        tags: [\n            ['e', eventId],\n            ['a', `${KIND_APP_DATA}::${DTAG_PREFIX}${path}`],\n        ],\n        created_at: Math.floor(Date.now() / 1000),\n    };\n}\n\n/**\n * Build a REQ filter for fetching all vault documents for a pubkey.\n *\n * @param {string} pubkey - Hex public key\n * @returns {object} Nostr REQ filter\n */\nexport function buildVaultFilter(pubkey) {\n    return {\n        kinds: [KIND_APP_DATA],\n        authors: [pubkey],\n    };\n}\n\n/**\n * Parse a kind 30078 event into a vault document descriptor.\n * Returns null if the event is not a nostrkey vault event.\n *\n * @param {object} event - Nostr event\n * @returns {{ path: string, content: string, createdAt: number, eventId: string } | null}\n */\nexport function parseVaultEvent(event) {\n    if (event.kind !== KIND_APP_DATA) return null;\n\n    const dTag = event.tags?.find(t => t[0] === 'd');\n    if (!dTag || !dTag[1]?.startsWith(DTAG_PREFIX)) return null;\n\n    const path = dTag[1].slice(DTAG_PREFIX.length);\n    if (!path) return null;\n\n    return {\n        path,\n        content: event.content,\n        createdAt: event.created_at,\n        eventId: event.id,\n    };\n}\n"],
  "mappings": "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;AACtB,YAAI,KAAK,GAAG,IAAI,IAAI,EAAE;AACtB,YAAI,KAAK,GAAG,IAAI,IAAI,EAAE;AACtB,YAAI,KAAK,GAAG,IAAI,IAAI,EAAE;AACtB,aAAK,GAAG,IAAI,IAAI,EAAE;AAClB,aAAK,GAAG,IAAI,IAAI,EAAE;AAClB,aAAK,GAAG,IAAI,IAAI,EAAE;AAClB,aAAK,GAAG,IAAI,IAAI,EAAE;AAClB,YAAI,KAAK,GAAG,IAAI,IAAI,EAAE;AACtB,aAAK,GAAG,IAAI,IAAI,EAAE;AAClB,aAAK,GAAG,IAAI,IAAI,EAAE;AAClB,aAAK,GAAG,IAAI,IAAI,EAAE;AAClB,aAAK,GAAG,IAAI,IAAI,EAAE;AAClB,aAAK,GAAG,IAAI,IAAI,EAAE;AAClB,aAAK,GAAG,IAAI,IAAI,EAAE;AAClB,aAAK,GAAG,IAAI,IAAI,EAAE;AAClB,aAAK,GAAG,IAAI,IAAI,EAAE;AAClB,aAAK,GAAG,IAAI,GAAG,EAAE;AACjB,aAAK,GAAG,IAAI,IAAI,EAAE;AAClB,aAAK,GAAG,IAAI,IAAI,EAAE;AAClB,aAAK,GAAG,IAAI,IAAI,EAAE;AAClB,aAAK,GAAG,IAAI,IAAI,EAAE;AAClB,aAAK,GAAG,IAAI,IAAI,EAAE;AAClB,aAAK,GAAG,IAAI,IAAI,EAAE;AAClB,aAAK,GAAG,IAAI,IAAI,EAAE;AAClB,aAAK,GAAG,IAAI,GAAG,EAAE;AACjB,aAAK,GAAG,IAAI,IAAI,EAAE;AAClB,aAAK,GAAG,IAAI,IAAI,EAAE;AAClB,aAAK,GAAG,IAAI,IAAI,EAAE;AAClB,aAAK,GAAG,IAAI,GAAG,EAAE;AACjB,aAAK,GAAG,IAAI,IAAI,EAAE;AAClB,aAAK,GAAG,IAAI,IAAI,EAAE;AAClB,aAAK,GAAG,IAAI,IAAI,EAAE;AAClB,aAAK,GAAG,IAAI,IAAI,EAAE;AAClB,aAAK,GAAG,IAAI,IAAI,EAAE;AAClB,aAAK,GAAG,IAAI,IAAI,EAAE;AAClB,aAAK,GAAG,IAAI,IAAI,EAAE;AAClB,aAAK,GAAG,IAAI,IAAI,EAAE;AAClB,aAAK,GAAG,IAAI,IAAI,EAAE;A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AA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA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",
  "names": ["pino", "logger", "transmit", "level", "setOpts", "self", "pad", "decode", "len", "i", "num", "len2", "isLE", "base64", "Buffer", "utf8ToBytes", "base64ToBytes", "i", "asciiToBytes", "byteLength", "alphabet", "NostrEventKind", "NostrMessageType", "Nip46Method", "NostrEventKind", "pad", "isLE", "num", "_0n", "_1n", "_0n", "_1n", "gcd", "num", "_0n", "_1n", "_1n", "_0n", "_1n", "num", "isLE", "isLE", "num", "_1n", "_0n", "_1n", "window", "_0n", "_1n", "window", "isLE", "_0n", "getPublicKey", "pad", "num", "_2n", "_0n", "_1n", "_3n", "_4n", "pointToBytes", "endo", "num", "getPublicKey", "utils", "randomBytes", "hmac", "_2n", "_1n", "r", "s", "_0n", "_0n", "_2n", "_3n", "LogLevel", "pino", "base64", "base64", "crypto", "getCrypto", "crypto", "isBytes", "abool", "anumber", "abytes", "aexists", "aoutput", "u32", "clean", "createView", "isLE", "checkOpts", "abytes", "isLE", "abool", "num", "createView", "copyBytes", "u32", "rotl", "isAligned32", "checkOpts", "anumber", "abool", "abytes", "copyBytes", "clean", "copyBytes", "abytes", "pad", "clean", "aexists", "aoutput", "rotl", "abytes", "clean", "isBytes", "abytes", "anumber", "wrap", "decode", "anumber", "padding", "num", "isBytes", "alphabet", "abytes", "isBytes", "decode", "bech32", "encrypt", "bech32", "decrypt", "hexToBytes", "bytesToHex", "wordlist", "wordlist", "hexToBytes", "bytesToHex", "generateKeyPair", "base64", "encrypt", "decrypt", "decrypt", "encrypt", "complete", "target", "storage", "storage", "generateKeyPair", "hexToBytes", "bytesToHex", "session", "log", "getPrivKey", "bytesToHex", "storage", "log", "bytesToHex", "decrypt", "encrypt", "hexToBytes", "generateKeyPair"]
}
 diff --git a/distros/safari/background.js b/distros/safari/background.js index f62e006..351a0e4 100644 --- a/distros/safari/background.js +++ b/distros/safari/background.js @@ -128,6 +128,21 @@ const permissionRateMap = new Map(); // host → { count, resetAt } await storage.set({ isEncrypted: true }); data.isEncrypted = true; } + // Lockout recovery: if isEncrypted=true but there is NO password verifier AND + // no actually-encrypted key blobs, encryption is bogus (e.g. a stale flag + // received from an older buggy sync). Clearing it prevents a permanent lockout + // where the user can never unlock because checkPassword() always fails. + // We ONLY clear when no encrypted blobs exist — never when real ciphertext is + // present (that would corrupt encrypted keys into "plaintext"). + if (data.isEncrypted && !data.passwordHash) { + const { profiles = [] } = await storage.get({ profiles: [] }); + const hasEncryptedBlob = profiles.some(p => isEncryptedBlob(p.privKey)); + if (!hasEncryptedBlob) { + log('[STARTUP] Lockout recovery: isEncrypted=true with no passwordHash and no encrypted blobs → clearing bogus encryption flag'); + await storage.set({ isEncrypted: false }); + data.isEncrypted = false; + } + } encryptionEnabled = data.isEncrypted; nostrAccessWhileLocked = !!data.nostrAccessWhileLocked; blockCrossOriginFrames = data.blockCrossOriginFrames !== false; @@ -419,7 +434,20 @@ api.runtime.onMessage.addListener((message, _sender, sendResponse) => { return true; // Keep message channel open for async sendResponse case 'savePrivateKey': resetAutoLock(); - return savePrivateKey(message.payload); + // Must use sendResponse + return true (not a Promise return): Chrome MV3 + // does not deliver Promise-return values to sendMessage callers, so the + // caller could not tell whether the key was actually saved (or whether it + // threw). That made imported keys silently fail while the UI showed success. + (async () => { + try { + await savePrivateKey(message.payload); + sendResponse({ success: true }); + } catch (e) { + console.error('savePrivateKey error:', e); + sendResponse({ success: false, error: e.message || 'Failed to save key' }); + } + })(); + return true; case 'getNpub': (async () => { try { @@ -1118,8 +1146,13 @@ api.runtime.onMessage.addListener((message, _sender, sendResponse) => { // --- Encrypted vault backup / restore --- case 'backup.export': reply(sendResponse, async () => { - if (!sessionCryptoKey) { - return { success: false, error: 'Extension must be unlocked to create a backup' }; + // Backups are encrypted with a dedicated backup password supplied at + // export time — NOT the in-memory session key. This lets users with no + // master password create backups, and works even while locked (the + // stored key blobs stay encrypted and get wrapped again here). + const password = message.payload?.password; + if (typeof password !== 'string' || password.length < 8) { + return { success: false, error: 'A backup password of at least 8 characters is required' }; } const data = await storage.get({ profiles: [], @@ -1135,7 +1168,7 @@ api.runtime.onMessage.addListener((message, _sender, sendResponse) => { version: null, }); const plaintext = JSON.stringify(data); - const encrypted = await encryptWithKey(plaintext, sessionCryptoKey, sessionKeySalt); + const encrypted = await encryptBlob(plaintext, password); const version = api.runtime.getManifest?.()?.version || 'unknown'; return { success: true, diff --git a/distros/safari/content.build.js b/distros/safari/content.build.js index 1a2824e..313a376 100644 --- a/distros/safari/content.build.js +++ b/distros/safari/content.build.js @@ -1,4 +1,233 @@ -(()=>{var t=typeof browser<"u"?browser:typeof chrome<"u"?chrome:null;if(!t)throw new Error("browser-polyfill: No extension API namespace found (neither browser nor chrome).");var r=typeof browser>"u"&&typeof chrome<"u";function s(e,n){return(...o)=>{try{let i=n.apply(e,o);if(i&&typeof i.then=="function")return i}catch{}return new Promise((i,c)=>{n.apply(e,[...o,(...u)=>{t.runtime&&t.runtime.lastError?c(new Error(t.runtime.lastError.message)):i(u.length<=1?u[0]:u)}])})}}var a={};a.runtime={sendMessage(...e){return r?s(t.runtime,t.runtime.sendMessage)(...e):t.runtime.sendMessage(...e)},onMessage:t.runtime.onMessage,getURL(e){return t.runtime.getURL(e)},openOptionsPage(){return r?s(t.runtime,t.runtime.openOptionsPage)():t.runtime.openOptionsPage()},get id(){return t.runtime.id}};a.storage={local:{get(...e){return r?s(t.storage.local,t.storage.local.get)(...e):t.storage.local.get(...e)},set(...e){return r?s(t.storage.local,t.storage.local.set)(...e):t.storage.local.set(...e)},clear(...e){return r?s(t.storage.local,t.storage.local.clear)(...e):t.storage.local.clear(...e)},remove(...e){return r?s(t.storage.local,t.storage.local.remove)(...e):t.storage.local.remove(...e)}},sync:t.storage?.sync?{get(...e){return r?s(t.storage.sync,t.storage.sync.get)(...e):t.storage.sync.get(...e)},set(...e){return r?s(t.storage.sync,t.storage.sync.set)(...e):t.storage.sync.set(...e)},remove(...e){return r?s(t.storage.sync,t.storage.sync.remove)(...e):t.storage.sync.remove(...e)},clear(...e){return r?s(t.storage.sync,t.storage.sync.clear)(...e):t.storage.sync.clear(...e)},getBytesInUse(...e){return t.storage.sync.getBytesInUse?r?s(t.storage.sync,t.storage.sync.getBytesInUse)(...e):t.storage.sync.getBytesInUse(...e):Promise.resolve(0)}}:null,onChanged:t.storage?.onChanged||null};a.tabs={create(...e){return r?s(t.tabs,t.tabs.create)(...e):t.tabs.create(...e)},query(...e){return r?s(t.tabs,t.tabs.query)(...e):t.tabs.query(...e)},remove(...e){return r?s(t.tabs,t.tabs.remove)(...e):t.tabs.remove(...e)},update(...e){return r?s(t.tabs,t.tabs.update)(...e):t.tabs.update(...e)},get(...e){return r?s(t.tabs,t.tabs.get)(...e):t.tabs.get(...e)},getCurrent(...e){return r?s(t.tabs,t.tabs.getCurrent)(...e):t.tabs.getCurrent(...e)},sendMessage(...e){return r?s(t.tabs,t.tabs.sendMessage)(...e):t.tabs.sendMessage(...e)}};a.alarms=t.alarms?{create(...e){let n=t.alarms.create(...e);return n&&typeof n.then=="function"?n:Promise.resolve()},clear(...e){return r?s(t.alarms,t.alarms.clear)(...e):t.alarms.clear(...e)},onAlarm:t.alarms.onAlarm}:null;async function b(){if(window===window.top)return!0;try{if(!(await a.storage.local.get({blockCrossOriginFrames:!0})).blockCrossOriginFrames)return!0}catch{return!1}try{return window.top.location.href,!0}catch{return!1}}b().then(e=>{if(!e)return;let n=document.createElement("script");n.setAttribute("src",a.runtime.getURL("nostr.build.js")),document.body.appendChild(n),document.addEventListener("visibilitychange",()=>{document.visibilityState==="visible"&&a.runtime.sendMessage({kind:"resetAutoLock"}).catch(()=>{})})});var d=null,m=null;function g(){if(d)return;let e=document.createElement("div");e.id="nostrkey-permission-sheet",e.innerHTML=` +(() => { + // src/utilities/browser-polyfill.js + var _browser = typeof browser !== "undefined" ? browser : typeof chrome !== "undefined" ? chrome : null; + if (!_browser) { + throw new Error("browser-polyfill: No extension API namespace found (neither browser nor chrome)."); + } + var isChrome = typeof browser === "undefined" && typeof chrome !== "undefined"; + function promisify(context, method) { + return (...args) => { + try { + const result = method.apply(context, args); + if (result && typeof result.then === "function") { + return result; + } + } catch (_) { + } + return new Promise((resolve, reject) => { + method.apply(context, [ + ...args, + (...cbArgs) => { + if (_browser.runtime && _browser.runtime.lastError) { + reject(new Error(_browser.runtime.lastError.message)); + } else { + resolve(cbArgs.length <= 1 ? cbArgs[0] : cbArgs); + } + } + ]); + }); + }; + } + var api = {}; + api.runtime = { + /** + * sendMessage – always returns a Promise. + */ + sendMessage(...args) { + if (!isChrome) { + return _browser.runtime.sendMessage(...args); + } + return promisify(_browser.runtime, _browser.runtime.sendMessage)(...args); + }, + /** + * onMessage – thin wrapper so callers use a consistent reference. + * The listener signature is (message, sender, sendResponse). + * On Chrome the listener can return `true` to keep the channel open, + * or return a Promise (MV3). Safari / Firefox expect a Promise return. + */ + onMessage: _browser.runtime.onMessage, + /** + * getURL – synchronous on all browsers. + */ + getURL(path) { + return _browser.runtime.getURL(path); + }, + /** + * openOptionsPage + */ + openOptionsPage() { + if (!isChrome) { + return _browser.runtime.openOptionsPage(); + } + return promisify(_browser.runtime, _browser.runtime.openOptionsPage)(); + }, + /** + * Expose the id for convenience. + */ + get id() { + return _browser.runtime.id; + } + }; + api.storage = { + local: { + get(...args) { + if (!isChrome) { + return _browser.storage.local.get(...args); + } + return promisify(_browser.storage.local, _browser.storage.local.get)(...args); + }, + set(...args) { + if (!isChrome) { + return _browser.storage.local.set(...args); + } + return promisify(_browser.storage.local, _browser.storage.local.set)(...args); + }, + clear(...args) { + if (!isChrome) { + return _browser.storage.local.clear(...args); + } + return promisify(_browser.storage.local, _browser.storage.local.clear)(...args); + }, + remove(...args) { + if (!isChrome) { + return _browser.storage.local.remove(...args); + } + return promisify(_browser.storage.local, _browser.storage.local.remove)(...args); + } + }, + // --- storage.sync ---------------------------------------------------------- + // Null when the browser doesn't support sync (older Safari, etc.) + sync: _browser.storage?.sync ? { + get(...args) { + if (!isChrome) { + return _browser.storage.sync.get(...args); + } + return promisify(_browser.storage.sync, _browser.storage.sync.get)(...args); + }, + set(...args) { + if (!isChrome) { + return _browser.storage.sync.set(...args); + } + return promisify(_browser.storage.sync, _browser.storage.sync.set)(...args); + }, + remove(...args) { + if (!isChrome) { + return _browser.storage.sync.remove(...args); + } + return promisify(_browser.storage.sync, _browser.storage.sync.remove)(...args); + }, + clear(...args) { + if (!isChrome) { + return _browser.storage.sync.clear(...args); + } + return promisify(_browser.storage.sync, _browser.storage.sync.clear)(...args); + }, + getBytesInUse(...args) { + if (!_browser.storage.sync.getBytesInUse) { + return Promise.resolve(0); + } + if (!isChrome) { + return _browser.storage.sync.getBytesInUse(...args); + } + return promisify(_browser.storage.sync, _browser.storage.sync.getBytesInUse)(...args); + } + } : null, + // --- storage.onChanged ----------------------------------------------------- + onChanged: _browser.storage?.onChanged || null + }; + api.tabs = { + create(...args) { + if (!isChrome) { + return _browser.tabs.create(...args); + } + return promisify(_browser.tabs, _browser.tabs.create)(...args); + }, + query(...args) { + if (!isChrome) { + return _browser.tabs.query(...args); + } + return promisify(_browser.tabs, _browser.tabs.query)(...args); + }, + remove(...args) { + if (!isChrome) { + return _browser.tabs.remove(...args); + } + return promisify(_browser.tabs, _browser.tabs.remove)(...args); + }, + update(...args) { + if (!isChrome) { + return _browser.tabs.update(...args); + } + return promisify(_browser.tabs, _browser.tabs.update)(...args); + }, + get(...args) { + if (!isChrome) { + return _browser.tabs.get(...args); + } + return promisify(_browser.tabs, _browser.tabs.get)(...args); + }, + getCurrent(...args) { + if (!isChrome) { + return _browser.tabs.getCurrent(...args); + } + return promisify(_browser.tabs, _browser.tabs.getCurrent)(...args); + }, + sendMessage(...args) { + if (!isChrome) { + return _browser.tabs.sendMessage(...args); + } + return promisify(_browser.tabs, _browser.tabs.sendMessage)(...args); + } + }; + api.alarms = _browser.alarms ? { + create(...args) { + const result = _browser.alarms.create(...args); + return result && typeof result.then === "function" ? result : Promise.resolve(); + }, + clear(...args) { + if (!isChrome) { + return _browser.alarms.clear(...args); + } + return promisify(_browser.alarms, _browser.alarms.clear)(...args); + }, + onAlarm: _browser.alarms.onAlarm + } : null; + + // src/content.js + async function shouldInject() { + if (window === window.top) return true; + try { + const data = await api.storage.local.get({ blockCrossOriginFrames: true }); + if (!data.blockCrossOriginFrames) return true; + } catch { + return false; + } + try { + void window.top.location.href; + return true; + } catch { + return false; + } + } + shouldInject().then((inject) => { + if (!inject) return; + let script = document.createElement("script"); + script.setAttribute("src", api.runtime.getURL("nostr.build.js")); + document.body.appendChild(script); + document.addEventListener("visibilitychange", () => { + if (document.visibilityState === "visible") { + api.runtime.sendMessage({ kind: "resetAutoLock" }).catch(() => { + }); + } + }); + }); + var permissionSheet = null; + var permissionResolve = null; + function createPermissionSheet() { + if (permissionSheet) return; + const sheet = document.createElement("div"); + sheet.id = "nostrkey-permission-sheet"; + sheet.innerHTML = `