From 7958464d6ee024456caca57da80c9cd5308f3353 Mon Sep 17 00:00:00 2001 From: "|| Prof. - Xadk3!#0000 || @naryal2580" Date: Mon, 22 May 2023 20:40:39 +0530 Subject: [PATCH] background.js --- TODO | 1 - picheTohDekho2x.js | 9927 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 9927 insertions(+), 1 deletion(-) delete mode 100644 TODO create mode 100644 picheTohDekho2x.js diff --git a/TODO b/TODO deleted file mode 100644 index 5d2e442..0000000 --- a/TODO +++ /dev/null @@ -1 +0,0 @@ -Impl. PATCH. diff --git a/picheTohDekho2x.js b/picheTohDekho2x.js new file mode 100644 index 0000000..9deb282 --- /dev/null +++ b/picheTohDekho2x.js @@ -0,0 +1,9927 @@ +(()=>{ + 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 __commonJS = (cb,mod3)=>function __require() { + return mod3 || (0, + cb[__getOwnPropNames(cb)[0]])((mod3 = { + exports: {} + }).exports, mod3), + mod3.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 = (mod3,isNodeMode,target)=>(target = mod3 != null ? __create(__getProtoOf(mod3)) : {}, + __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 || !mod3 || !mod3.__esModule ? __defProp(target, "default", { + value: mod3, + enumerable: true + }) : target, mod3)); + + // node_modules/.pnpm/webextension-polyfill@0.8.0/node_modules/webextension-polyfill/dist/browser-polyfill.js + var require_browser_polyfill = __commonJS({ + "node_modules/.pnpm/webextension-polyfill@0.8.0/node_modules/webextension-polyfill/dist/browser-polyfill.js"(exports, module2) { + (function(global, factory) { + if (typeof define === "function" && define.amd) { + define("webextension-polyfill", ["module"], factory); + } else if (typeof exports !== "undefined") { + factory(module2); + } else { + var mod3 = { + exports: {} + }; + factory(mod3); + global.browser = mod3.exports; + } + } + )(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : exports, function(module3) { + "use strict"; + if (typeof browser === "undefined" || Object.getPrototypeOf(browser) !== Object.prototype) { + const CHROME_SEND_MESSAGE_CALLBACK_NO_RESPONSE_MESSAGE = "The message port closed before a response was received."; + const SEND_RESPONSE_DEPRECATION_WARNING = "Returning a Promise is the preferred way to send a reply from an onMessage/onMessageExternal listener, as the sendResponse will be removed from the specs (See https://developer.mozilla.org/docs/Mozilla/Add-ons/WebExtensions/API/runtime/onMessage)"; + const wrapAPIs = (extensionAPIs)=>{ + const apiMetadata = { + "alarms": { + "clear": { + "minArgs": 0, + "maxArgs": 1 + }, + "clearAll": { + "minArgs": 0, + "maxArgs": 0 + }, + "get": { + "minArgs": 0, + "maxArgs": 1 + }, + "getAll": { + "minArgs": 0, + "maxArgs": 0 + } + }, + "bookmarks": { + "create": { + "minArgs": 1, + "maxArgs": 1 + }, + "get": { + "minArgs": 1, + "maxArgs": 1 + }, + "getChildren": { + "minArgs": 1, + "maxArgs": 1 + }, + "getRecent": { + "minArgs": 1, + "maxArgs": 1 + }, + "getSubTree": { + "minArgs": 1, + "maxArgs": 1 + }, + "getTree": { + "minArgs": 0, + "maxArgs": 0 + }, + "move": { + "minArgs": 2, + "maxArgs": 2 + }, + "remove": { + "minArgs": 1, + "maxArgs": 1 + }, + "removeTree": { + "minArgs": 1, + "maxArgs": 1 + }, + "search": { + "minArgs": 1, + "maxArgs": 1 + }, + "update": { + "minArgs": 2, + "maxArgs": 2 + } + }, + "browserAction": { + "disable": { + "minArgs": 0, + "maxArgs": 1, + "fallbackToNoCallback": true + }, + "enable": { + "minArgs": 0, + "maxArgs": 1, + "fallbackToNoCallback": true + }, + "getBadgeBackgroundColor": { + "minArgs": 1, + "maxArgs": 1 + }, + "getBadgeText": { + "minArgs": 1, + "maxArgs": 1 + }, + "getPopup": { + "minArgs": 1, + "maxArgs": 1 + }, + "getTitle": { + "minArgs": 1, + "maxArgs": 1 + }, + "openPopup": { + "minArgs": 0, + "maxArgs": 0 + }, + "setBadgeBackgroundColor": { + "minArgs": 1, + "maxArgs": 1, + "fallbackToNoCallback": true + }, + "setBadgeText": { + "minArgs": 1, + "maxArgs": 1, + "fallbackToNoCallback": true + }, + "setIcon": { + "minArgs": 1, + "maxArgs": 1 + }, + "setPopup": { + "minArgs": 1, + "maxArgs": 1, + "fallbackToNoCallback": true + }, + "setTitle": { + "minArgs": 1, + "maxArgs": 1, + "fallbackToNoCallback": true + } + }, + "browsingData": { + "remove": { + "minArgs": 2, + "maxArgs": 2 + }, + "removeCache": { + "minArgs": 1, + "maxArgs": 1 + }, + "removeCookies": { + "minArgs": 1, + "maxArgs": 1 + }, + "removeDownloads": { + "minArgs": 1, + "maxArgs": 1 + }, + "removeFormData": { + "minArgs": 1, + "maxArgs": 1 + }, + "removeHistory": { + "minArgs": 1, + "maxArgs": 1 + }, + "removeLocalStorage": { + "minArgs": 1, + "maxArgs": 1 + }, + "removePasswords": { + "minArgs": 1, + "maxArgs": 1 + }, + "removePluginData": { + "minArgs": 1, + "maxArgs": 1 + }, + "settings": { + "minArgs": 0, + "maxArgs": 0 + } + }, + "commands": { + "getAll": { + "minArgs": 0, + "maxArgs": 0 + } + }, + "contextMenus": { + "remove": { + "minArgs": 1, + "maxArgs": 1 + }, + "removeAll": { + "minArgs": 0, + "maxArgs": 0 + }, + "update": { + "minArgs": 2, + "maxArgs": 2 + } + }, + "cookies": { + "get": { + "minArgs": 1, + "maxArgs": 1 + }, + "getAll": { + "minArgs": 1, + "maxArgs": 1 + }, + "getAllCookieStores": { + "minArgs": 0, + "maxArgs": 0 + }, + "remove": { + "minArgs": 1, + "maxArgs": 1 + }, + "set": { + "minArgs": 1, + "maxArgs": 1 + } + }, + "devtools": { + "inspectedWindow": { + "eval": { + "minArgs": 1, + "maxArgs": 2, + "singleCallbackArg": false + } + }, + "panels": { + "create": { + "minArgs": 3, + "maxArgs": 3, + "singleCallbackArg": true + }, + "elements": { + "createSidebarPane": { + "minArgs": 1, + "maxArgs": 1 + } + } + } + }, + "downloads": { + "cancel": { + "minArgs": 1, + "maxArgs": 1 + }, + "download": { + "minArgs": 1, + "maxArgs": 1 + }, + "erase": { + "minArgs": 1, + "maxArgs": 1 + }, + "getFileIcon": { + "minArgs": 1, + "maxArgs": 2 + }, + "open": { + "minArgs": 1, + "maxArgs": 1, + "fallbackToNoCallback": true + }, + "pause": { + "minArgs": 1, + "maxArgs": 1 + }, + "removeFile": { + "minArgs": 1, + "maxArgs": 1 + }, + "resume": { + "minArgs": 1, + "maxArgs": 1 + }, + "search": { + "minArgs": 1, + "maxArgs": 1 + }, + "show": { + "minArgs": 1, + "maxArgs": 1, + "fallbackToNoCallback": true + } + }, + "extension": { + "isAllowedFileSchemeAccess": { + "minArgs": 0, + "maxArgs": 0 + }, + "isAllowedIncognitoAccess": { + "minArgs": 0, + "maxArgs": 0 + } + }, + "history": { + "addUrl": { + "minArgs": 1, + "maxArgs": 1 + }, + "deleteAll": { + "minArgs": 0, + "maxArgs": 0 + }, + "deleteRange": { + "minArgs": 1, + "maxArgs": 1 + }, + "deleteUrl": { + "minArgs": 1, + "maxArgs": 1 + }, + "getVisits": { + "minArgs": 1, + "maxArgs": 1 + }, + "search": { + "minArgs": 1, + "maxArgs": 1 + } + }, + "i18n": { + "detectLanguage": { + "minArgs": 1, + "maxArgs": 1 + }, + "getAcceptLanguages": { + "minArgs": 0, + "maxArgs": 0 + } + }, + "identity": { + "launchWebAuthFlow": { + "minArgs": 1, + "maxArgs": 1 + } + }, + "idle": { + "queryState": { + "minArgs": 1, + "maxArgs": 1 + } + }, + "management": { + "get": { + "minArgs": 1, + "maxArgs": 1 + }, + "getAll": { + "minArgs": 0, + "maxArgs": 0 + }, + "getSelf": { + "minArgs": 0, + "maxArgs": 0 + }, + "setEnabled": { + "minArgs": 2, + "maxArgs": 2 + }, + "uninstallSelf": { + "minArgs": 0, + "maxArgs": 1 + } + }, + "notifications": { + "clear": { + "minArgs": 1, + "maxArgs": 1 + }, + "create": { + "minArgs": 1, + "maxArgs": 2 + }, + "getAll": { + "minArgs": 0, + "maxArgs": 0 + }, + "getPermissionLevel": { + "minArgs": 0, + "maxArgs": 0 + }, + "update": { + "minArgs": 2, + "maxArgs": 2 + } + }, + "pageAction": { + "getPopup": { + "minArgs": 1, + "maxArgs": 1 + }, + "getTitle": { + "minArgs": 1, + "maxArgs": 1 + }, + "hide": { + "minArgs": 1, + "maxArgs": 1, + "fallbackToNoCallback": true + }, + "setIcon": { + "minArgs": 1, + "maxArgs": 1 + }, + "setPopup": { + "minArgs": 1, + "maxArgs": 1, + "fallbackToNoCallback": true + }, + "setTitle": { + "minArgs": 1, + "maxArgs": 1, + "fallbackToNoCallback": true + }, + "show": { + "minArgs": 1, + "maxArgs": 1, + "fallbackToNoCallback": true + } + }, + "permissions": { + "contains": { + "minArgs": 1, + "maxArgs": 1 + }, + "getAll": { + "minArgs": 0, + "maxArgs": 0 + }, + "remove": { + "minArgs": 1, + "maxArgs": 1 + }, + "request": { + "minArgs": 1, + "maxArgs": 1 + } + }, + "runtime": { + "getBackgroundPage": { + "minArgs": 0, + "maxArgs": 0 + }, + "getPlatformInfo": { + "minArgs": 0, + "maxArgs": 0 + }, + "openOptionsPage": { + "minArgs": 0, + "maxArgs": 0 + }, + "requestUpdateCheck": { + "minArgs": 0, + "maxArgs": 0 + }, + "sendMessage": { + "minArgs": 1, + "maxArgs": 3 + }, + "sendNativeMessage": { + "minArgs": 2, + "maxArgs": 2 + }, + "setUninstallURL": { + "minArgs": 1, + "maxArgs": 1 + } + }, + "sessions": { + "getDevices": { + "minArgs": 0, + "maxArgs": 1 + }, + "getRecentlyClosed": { + "minArgs": 0, + "maxArgs": 1 + }, + "restore": { + "minArgs": 0, + "maxArgs": 1 + } + }, + "storage": { + "local": { + "clear": { + "minArgs": 0, + "maxArgs": 0 + }, + "get": { + "minArgs": 0, + "maxArgs": 1 + }, + "getBytesInUse": { + "minArgs": 0, + "maxArgs": 1 + }, + "remove": { + "minArgs": 1, + "maxArgs": 1 + }, + "set": { + "minArgs": 1, + "maxArgs": 1 + } + }, + "managed": { + "get": { + "minArgs": 0, + "maxArgs": 1 + }, + "getBytesInUse": { + "minArgs": 0, + "maxArgs": 1 + } + }, + "sync": { + "clear": { + "minArgs": 0, + "maxArgs": 0 + }, + "get": { + "minArgs": 0, + "maxArgs": 1 + }, + "getBytesInUse": { + "minArgs": 0, + "maxArgs": 1 + }, + "remove": { + "minArgs": 1, + "maxArgs": 1 + }, + "set": { + "minArgs": 1, + "maxArgs": 1 + } + } + }, + "tabs": { + "captureVisibleTab": { + "minArgs": 0, + "maxArgs": 2 + }, + "create": { + "minArgs": 1, + "maxArgs": 1 + }, + "detectLanguage": { + "minArgs": 0, + "maxArgs": 1 + }, + "discard": { + "minArgs": 0, + "maxArgs": 1 + }, + "duplicate": { + "minArgs": 1, + "maxArgs": 1 + }, + "executeScript": { + "minArgs": 1, + "maxArgs": 2 + }, + "get": { + "minArgs": 1, + "maxArgs": 1 + }, + "getCurrent": { + "minArgs": 0, + "maxArgs": 0 + }, + "getZoom": { + "minArgs": 0, + "maxArgs": 1 + }, + "getZoomSettings": { + "minArgs": 0, + "maxArgs": 1 + }, + "goBack": { + "minArgs": 0, + "maxArgs": 1 + }, + "goForward": { + "minArgs": 0, + "maxArgs": 1 + }, + "highlight": { + "minArgs": 1, + "maxArgs": 1 + }, + "insertCSS": { + "minArgs": 1, + "maxArgs": 2 + }, + "move": { + "minArgs": 2, + "maxArgs": 2 + }, + "query": { + "minArgs": 1, + "maxArgs": 1 + }, + "reload": { + "minArgs": 0, + "maxArgs": 2 + }, + "remove": { + "minArgs": 1, + "maxArgs": 1 + }, + "removeCSS": { + "minArgs": 1, + "maxArgs": 2 + }, + "sendMessage": { + "minArgs": 2, + "maxArgs": 3 + }, + "setZoom": { + "minArgs": 1, + "maxArgs": 2 + }, + "setZoomSettings": { + "minArgs": 1, + "maxArgs": 2 + }, + "update": { + "minArgs": 1, + "maxArgs": 2 + } + }, + "topSites": { + "get": { + "minArgs": 0, + "maxArgs": 0 + } + }, + "webNavigation": { + "getAllFrames": { + "minArgs": 1, + "maxArgs": 1 + }, + "getFrame": { + "minArgs": 1, + "maxArgs": 1 + } + }, + "webRequest": { + "handlerBehaviorChanged": { + "minArgs": 0, + "maxArgs": 0 + } + }, + "windows": { + "create": { + "minArgs": 0, + "maxArgs": 1 + }, + "get": { + "minArgs": 1, + "maxArgs": 2 + }, + "getAll": { + "minArgs": 0, + "maxArgs": 1 + }, + "getCurrent": { + "minArgs": 0, + "maxArgs": 1 + }, + "getLastFocused": { + "minArgs": 0, + "maxArgs": 1 + }, + "remove": { + "minArgs": 1, + "maxArgs": 1 + }, + "update": { + "minArgs": 2, + "maxArgs": 2 + } + } + }; + if (Object.keys(apiMetadata).length === 0) { + throw new Error("api-metadata.json has not been included in browser-polyfill"); + } + class DefaultWeakMap extends WeakMap { + constructor(createItem, items=void 0) { + super(items); + this.createItem = createItem; + } + get(key) { + if (!this.has(key)) { + this.set(key, this.createItem(key)); + } + return super.get(key); + } + } + const isThenable = (value)=>{ + return value && typeof value === "object" && typeof value.then === "function"; + } + ; + const makeCallback = (promise,metadata)=>{ + return (...callbackArgs)=>{ + if (extensionAPIs.runtime.lastError) { + promise.reject(new Error(extensionAPIs.runtime.lastError.message)); + } else if (metadata.singleCallbackArg || callbackArgs.length <= 1 && metadata.singleCallbackArg !== false) { + promise.resolve(callbackArgs[0]); + } else { + promise.resolve(callbackArgs); + } + } + ; + } + ; + const pluralizeArguments = (numArgs)=>numArgs == 1 ? "argument" : "arguments"; + const wrapAsyncFunction = (name,metadata)=>{ + return function asyncFunctionWrapper(target, ...args) { + if (args.length < metadata.minArgs) { + throw new Error(`Expected at least ${metadata.minArgs} ${pluralizeArguments(metadata.minArgs)} for ${name}(), got ${args.length}`); + } + if (args.length > metadata.maxArgs) { + throw new Error(`Expected at most ${metadata.maxArgs} ${pluralizeArguments(metadata.maxArgs)} for ${name}(), got ${args.length}`); + } + return new Promise((resolve,reject)=>{ + if (metadata.fallbackToNoCallback) { + try { + target[name](...args, makeCallback({ + resolve, + reject + }, metadata)); + } catch (cbError) { + console.warn(`${name} API method doesn't seem to support the callback parameter, falling back to call it without a callback: `, cbError); + target[name](...args); + metadata.fallbackToNoCallback = false; + metadata.noCallback = true; + resolve(); + } + } else if (metadata.noCallback) { + target[name](...args); + resolve(); + } else { + target[name](...args, makeCallback({ + resolve, + reject + }, metadata)); + } + } + ); + } + ; + } + ; + const wrapMethod = (target,method,wrapper)=>{ + return new Proxy(method,{ + apply(targetMethod, thisObj, args) { + return wrapper.call(thisObj, target, ...args); + } + }); + } + ; + let hasOwnProperty = Function.call.bind(Object.prototype.hasOwnProperty); + const wrapObject = (target,wrappers={},metadata={})=>{ + let cache = /* @__PURE__ */ + Object.create(null); + let handlers = { + has(proxyTarget2, prop) { + return prop in target || prop in cache; + }, + get(proxyTarget2, prop, receiver) { + if (prop in cache) { + return cache[prop]; + } + if (!(prop in target)) { + return void 0; + } + let value = target[prop]; + if (typeof value === "function") { + if (typeof wrappers[prop] === "function") { + value = wrapMethod(target, target[prop], wrappers[prop]); + } else if (hasOwnProperty(metadata, prop)) { + let wrapper = wrapAsyncFunction(prop, metadata[prop]); + value = wrapMethod(target, target[prop], wrapper); + } else { + value = value.bind(target); + } + } else if (typeof value === "object" && value !== null && (hasOwnProperty(wrappers, prop) || hasOwnProperty(metadata, prop))) { + value = wrapObject(value, wrappers[prop], metadata[prop]); + } else if (hasOwnProperty(metadata, "*")) { + value = wrapObject(value, wrappers[prop], metadata["*"]); + } else { + Object.defineProperty(cache, prop, { + configurable: true, + enumerable: true, + get() { + return target[prop]; + }, + set(value2) { + target[prop] = value2; + } + }); + return value; + } + cache[prop] = value; + return value; + }, + set(proxyTarget2, prop, value, receiver) { + if (prop in cache) { + cache[prop] = value; + } else { + target[prop] = value; + } + return true; + }, + defineProperty(proxyTarget2, prop, desc) { + return Reflect.defineProperty(cache, prop, desc); + }, + deleteProperty(proxyTarget2, prop) { + return Reflect.deleteProperty(cache, prop); + } + }; + let proxyTarget = Object.create(target); + return new Proxy(proxyTarget,handlers); + } + ; + const wrapEvent = (wrapperMap)=>({ + addListener(target, listener, ...args) { + target.addListener(wrapperMap.get(listener), ...args); + }, + hasListener(target, listener) { + return target.hasListener(wrapperMap.get(listener)); + }, + removeListener(target, listener) { + target.removeListener(wrapperMap.get(listener)); + } + }); + const onRequestFinishedWrappers = new DefaultWeakMap((listener)=>{ + if (typeof listener !== "function") { + return listener; + } + return function onRequestFinished(req) { + const wrappedReq = wrapObject(req, {}, { + getContent: { + minArgs: 0, + maxArgs: 0 + } + }); + listener(wrappedReq); + } + ; + } + ); + let loggedSendResponseDeprecationWarning = false; + const onMessageWrappers = new DefaultWeakMap((listener)=>{ + if (typeof listener !== "function") { + return listener; + } + return function onMessage(message, sender, sendResponse) { + let didCallSendResponse = false; + let wrappedSendResponse; + let sendResponsePromise = new Promise((resolve)=>{ + wrappedSendResponse = function(response) { + if (!loggedSendResponseDeprecationWarning) { + console.warn(SEND_RESPONSE_DEPRECATION_WARNING, new Error().stack); + loggedSendResponseDeprecationWarning = true; + } + didCallSendResponse = true; + resolve(response); + } + ; + } + ); + let result; + try { + result = listener(message, sender, wrappedSendResponse); + } catch (err) { + result = Promise.reject(err); + } + const isResultThenable = result !== true && isThenable(result); + if (result !== true && !isResultThenable && !didCallSendResponse) { + return false; + } + const sendPromisedResult = (promise)=>{ + promise.then((msg)=>{ + sendResponse(msg); + } + , (error)=>{ + let message2; + if (error && (error instanceof Error || typeof error.message === "string")) { + message2 = error.message; + } else { + message2 = "An unexpected error occurred"; + } + sendResponse({ + __mozWebExtensionPolyfillReject__: true, + message: message2 + }); + } + ).catch((err)=>{ + console.error("Failed to send onMessage rejected reply", err); + } + ); + } + ; + if (isResultThenable) { + sendPromisedResult(result); + } else { + sendPromisedResult(sendResponsePromise); + } + return true; + } + ; + } + ); + const wrappedSendMessageCallback = ({reject, resolve},reply)=>{ + if (extensionAPIs.runtime.lastError) { + if (extensionAPIs.runtime.lastError.message === CHROME_SEND_MESSAGE_CALLBACK_NO_RESPONSE_MESSAGE) { + resolve(); + } else { + reject(new Error(extensionAPIs.runtime.lastError.message)); + } + } else if (reply && reply.__mozWebExtensionPolyfillReject__) { + reject(new Error(reply.message)); + } else { + resolve(reply); + } + } + ; + const wrappedSendMessage = (name,metadata,apiNamespaceObj,...args)=>{ + if (args.length < metadata.minArgs) { + throw new Error(`Expected at least ${metadata.minArgs} ${pluralizeArguments(metadata.minArgs)} for ${name}(), got ${args.length}`); + } + if (args.length > metadata.maxArgs) { + throw new Error(`Expected at most ${metadata.maxArgs} ${pluralizeArguments(metadata.maxArgs)} for ${name}(), got ${args.length}`); + } + return new Promise((resolve,reject)=>{ + const wrappedCb = wrappedSendMessageCallback.bind(null, { + resolve, + reject + }); + args.push(wrappedCb); + apiNamespaceObj.sendMessage(...args); + } + ); + } + ; + const staticWrappers = { + devtools: { + network: { + onRequestFinished: wrapEvent(onRequestFinishedWrappers) + } + }, + runtime: { + onMessage: wrapEvent(onMessageWrappers), + onMessageExternal: wrapEvent(onMessageWrappers), + sendMessage: wrappedSendMessage.bind(null, "sendMessage", { + minArgs: 1, + maxArgs: 3 + }) + }, + tabs: { + sendMessage: wrappedSendMessage.bind(null, "sendMessage", { + minArgs: 2, + maxArgs: 3 + }) + } + }; + const settingMetadata = { + clear: { + minArgs: 1, + maxArgs: 1 + }, + get: { + minArgs: 1, + maxArgs: 1 + }, + set: { + minArgs: 1, + maxArgs: 1 + } + }; + apiMetadata.privacy = { + network: { + "*": settingMetadata + }, + services: { + "*": settingMetadata + }, + websites: { + "*": settingMetadata + } + }; + return wrapObject(extensionAPIs, staticWrappers, apiMetadata); + } + ; + if (typeof chrome != "object" || !chrome || !chrome.runtime || !chrome.runtime.id) { + throw new Error("This script should only be loaded in a browser extension."); + } + module3.exports = wrapAPIs(chrome); + } else { + module3.exports = browser; + } + }); + } + }); + + // (disabled):crypto + var require_crypto = __commonJS({ + "(disabled):crypto"() {} + }); + + // node_modules/.pnpm/@scure+bip39@1.2.0/node_modules/@scure/bip39/wordlists/english.js + var require_english = __commonJS({ + "node_modules/.pnpm/@scure+bip39@1.2.0/node_modules/@scure/bip39/wordlists/english.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { + value: true + }); + exports.wordlist = void 0; + exports.wordlist = `abandon +ability +able +about +above +absent +absorb +abstract +absurd +abuse +access +accident +account +accuse +achieve +acid +acoustic +acquire +across +act +action +actor +actress +actual +adapt +add +addict +address +adjust +admit +adult +advance +advice +aerobic +affair +afford +afraid +again +age +agent +agree +ahead +aim +air +airport +aisle +alarm +album +alcohol +alert +alien +all +alley +allow +almost +alone +alpha +already +also +alter +always +amateur +amazing +among +amount +amused +analyst +anchor +ancient +anger +angle +angry +animal +ankle +announce +annual +another +answer +antenna +antique +anxiety +any +apart +apology +appear +apple +approve +april +arch +arctic +area +arena +argue +arm +armed +armor +army +around +arrange +arrest +arrive +arrow +art +artefact +artist +artwork +ask +aspect +assault +asset +assist +assume +asthma +athlete +atom +attack +attend +attitude +attract +auction +audit +august +aunt +author +auto +autumn +average +avocado +avoid +awake +aware +away +awesome +awful +awkward +axis +baby +bachelor +bacon +badge +bag +balance +balcony +ball +bamboo +banana +banner +bar +barely +bargain +barrel +base +basic +basket +battle +beach +bean +beauty +because +become +beef +before +begin +behave +behind +believe +below +belt +bench +benefit +best +betray +better +between +beyond +bicycle +bid +bike +bind +biology +bird +birth +bitter +black +blade +blame +blanket +blast +bleak +bless +blind +blood +blossom +blouse +blue +blur +blush +board +boat +body +boil +bomb +bone +bonus +book +boost +border +boring +borrow +boss +bottom +bounce +box +boy +bracket +brain +brand +brass +brave +bread +breeze +brick +bridge +brief +bright +bring +brisk +broccoli +broken +bronze +broom +brother +brown +brush +bubble +buddy +budget +buffalo +build +bulb +bulk +bullet +bundle +bunker +burden +burger +burst +bus +business +busy +butter +buyer +buzz +cabbage +cabin +cable +cactus +cage +cake +call +calm +camera +camp +can +canal +cancel +candy +cannon +canoe +canvas +canyon +capable +capital +captain +car +carbon +card +cargo +carpet +carry +cart +case +cash +casino +castle +casual +cat +catalog +catch +category +cattle +caught +cause +caution +cave +ceiling +celery +cement +census +century +cereal +certain +chair +chalk +champion +change +chaos +chapter +charge +chase +chat +cheap +check +cheese +chef +cherry +chest +chicken +chief +child +chimney +choice +choose +chronic +chuckle +chunk +churn +cigar +cinnamon +circle +citizen +city +civil +claim +clap +clarify +claw +clay +clean +clerk +clever +click +client +cliff +climb +clinic +clip +clock +clog +close +cloth +cloud +clown +club +clump +cluster +clutch +coach +coast +coconut +code +coffee +coil +coin +collect +color +column +combine +come +comfort +comic +common +company +concert +conduct +confirm +congress +connect +consider +control +convince +cook +cool +copper +copy +coral +core +corn +correct +cost +cotton +couch +country +couple +course +cousin +cover +coyote +crack +cradle +craft +cram +crane +crash +crater +crawl +crazy +cream +credit +creek +crew +cricket +crime +crisp +critic +crop +cross +crouch +crowd +crucial +cruel +cruise +crumble +crunch +crush +cry +crystal +cube +culture +cup +cupboard +curious +current +curtain +curve +cushion +custom +cute +cycle +dad +damage +damp +dance +danger +daring +dash +daughter +dawn +day +deal +debate +debris +decade +december +decide +decline +decorate +decrease +deer +defense +define +defy +degree +delay +deliver +demand +demise +denial +dentist +deny +depart +depend +deposit +depth +deputy +derive +describe +desert +design +desk +despair +destroy +detail +detect +develop +device +devote +diagram +dial +diamond +diary +dice +diesel +diet +differ +digital +dignity +dilemma +dinner +dinosaur +direct +dirt +disagree +discover +disease +dish +dismiss +disorder +display +distance +divert +divide +divorce +dizzy +doctor +document +dog +doll +dolphin +domain +donate +donkey +donor +door +dose +double +dove +draft +dragon +drama +drastic +draw +dream +dress +drift +drill +drink +drip +drive +drop +drum +dry +duck +dumb +dune +during +dust +dutch +duty +dwarf +dynamic +eager +eagle +early +earn +earth +easily +east +easy +echo +ecology +economy +edge +edit +educate +effort +egg +eight +either +elbow +elder +electric +elegant +element +elephant +elevator +elite +else +embark +embody +embrace +emerge +emotion +employ +empower +empty +enable +enact +end +endless +endorse +enemy +energy +enforce +engage +engine +enhance +enjoy +enlist +enough +enrich +enroll +ensure +enter +entire +entry +envelope +episode +equal +equip +era +erase +erode +erosion +error +erupt +escape +essay +essence +estate +eternal +ethics +evidence +evil +evoke +evolve +exact +example +excess +exchange +excite +exclude +excuse +execute +exercise +exhaust +exhibit +exile +exist +exit +exotic +expand +expect +expire +explain +expose +express +extend +extra +eye +eyebrow +fabric +face +faculty +fade +faint +faith +fall +false +fame +family +famous +fan +fancy +fantasy +farm +fashion +fat +fatal +father +fatigue +fault +favorite +feature +february +federal +fee +feed +feel +female +fence +festival +fetch +fever +few +fiber +fiction +field +figure +file +film +filter +final +find +fine +finger +finish +fire +firm +first +fiscal +fish +fit +fitness +fix +flag +flame +flash +flat +flavor +flee +flight +flip +float +flock +floor +flower +fluid +flush +fly +foam +focus +fog +foil +fold +follow +food +foot +force +forest +forget +fork +fortune +forum +forward +fossil +foster +found +fox +fragile +frame +frequent +fresh +friend +fringe +frog +front +frost +frown +frozen +fruit +fuel +fun +funny +furnace +fury +future +gadget +gain +galaxy +gallery +game +gap +garage +garbage +garden +garlic +garment +gas +gasp +gate +gather +gauge +gaze +general +genius +genre +gentle +genuine +gesture +ghost +giant +gift +giggle +ginger +giraffe +girl +give +glad +glance +glare +glass +glide +glimpse +globe +gloom +glory +glove +glow +glue +goat +goddess +gold +good +goose +gorilla +gospel +gossip +govern +gown +grab +grace +grain +grant +grape +grass +gravity +great +green +grid +grief +grit +grocery +group +grow +grunt +guard +guess +guide +guilt +guitar +gun +gym +habit +hair +half +hammer +hamster +hand +happy +harbor +hard +harsh +harvest +hat +have +hawk +hazard +head +health +heart +heavy +hedgehog +height +hello +helmet +help +hen +hero +hidden +high +hill +hint +hip +hire +history +hobby +hockey +hold +hole +holiday +hollow +home +honey +hood +hope +horn +horror +horse +hospital +host +hotel +hour +hover +hub +huge +human +humble +humor +hundred +hungry +hunt +hurdle +hurry +hurt +husband +hybrid +ice +icon +idea +identify +idle +ignore +ill +illegal +illness +image +imitate +immense +immune +impact +impose +improve +impulse +inch +include +income +increase +index +indicate +indoor +industry +infant +inflict +inform +inhale +inherit +initial +inject +injury +inmate +inner +innocent +input +inquiry +insane +insect +inside +inspire +install +intact +interest +into +invest +invite +involve +iron +island +isolate +issue +item +ivory +jacket +jaguar +jar +jazz +jealous +jeans +jelly +jewel +job +join +joke +journey +joy +judge +juice +jump +jungle +junior +junk +just +kangaroo +keen +keep +ketchup +key +kick +kid +kidney +kind +kingdom +kiss +kit +kitchen +kite +kitten +kiwi +knee +knife +knock +know +lab +label +labor +ladder +lady +lake +lamp +language +laptop +large +later +latin +laugh +laundry +lava +law +lawn +lawsuit +layer +lazy +leader +leaf +learn +leave +lecture +left +leg +legal +legend +leisure +lemon +lend +length +lens +leopard +lesson +letter +level +liar +liberty +library +license +life +lift +light +like +limb +limit +link +lion +liquid +list +little +live +lizard +load +loan +lobster +local +lock +logic +lonely +long +loop +lottery +loud +lounge +love +loyal +lucky +luggage +lumber +lunar +lunch +luxury +lyrics +machine +mad +magic +magnet +maid +mail +main +major +make +mammal +man +manage +mandate +mango +mansion +manual +maple +marble +march +margin +marine +market +marriage +mask +mass +master +match +material +math +matrix +matter +maximum +maze +meadow +mean +measure +meat +mechanic +medal +media +melody +melt +member +memory +mention +menu +mercy +merge +merit +merry +mesh +message +metal +method +middle +midnight +milk +million +mimic +mind +minimum +minor +minute +miracle +mirror +misery +miss +mistake +mix +mixed +mixture +mobile +model +modify +mom +moment +monitor +monkey +monster +month +moon +moral +more +morning +mosquito +mother +motion +motor +mountain +mouse +move +movie +much +muffin +mule +multiply +muscle +museum +mushroom +music +must +mutual +myself +mystery +myth +naive +name +napkin +narrow +nasty +nation +nature +near +neck +need +negative +neglect +neither +nephew +nerve +nest +net +network +neutral +never +news +next +nice +night +noble +noise +nominee +noodle +normal +north +nose +notable +note +nothing +notice +novel +now +nuclear +number +nurse +nut +oak +obey +object +oblige +obscure +observe +obtain +obvious +occur +ocean +october +odor +off +offer +office +often +oil +okay +old +olive +olympic +omit +once +one +onion +online +only +open +opera +opinion +oppose +option +orange +orbit +orchard +order +ordinary +organ +orient +original +orphan +ostrich +other +outdoor +outer +output +outside +oval +oven +over +own +owner +oxygen +oyster +ozone +pact +paddle +page +pair +palace +palm +panda +panel +panic +panther +paper +parade +parent +park +parrot +party +pass +patch +path +patient +patrol +pattern +pause +pave +payment +peace +peanut +pear +peasant +pelican +pen +penalty +pencil +people +pepper +perfect +permit +person +pet +phone +photo +phrase +physical +piano +picnic +picture +piece +pig +pigeon +pill +pilot +pink +pioneer +pipe +pistol +pitch +pizza +place +planet +plastic +plate +play +please +pledge +pluck +plug +plunge +poem +poet +point +polar +pole +police +pond +pony +pool +popular +portion +position +possible +post +potato +pottery +poverty +powder +power +practice +praise +predict +prefer +prepare +present +pretty +prevent +price +pride +primary +print +priority +prison +private +prize +problem +process +produce +profit +program +project +promote +proof +property +prosper +protect +proud +provide +public +pudding +pull +pulp +pulse +pumpkin +punch +pupil +puppy +purchase +purity +purpose +purse +push +put +puzzle +pyramid +quality +quantum +quarter +question +quick +quit +quiz +quote +rabbit +raccoon +race +rack +radar +radio +rail +rain +raise +rally +ramp +ranch +random +range +rapid +rare +rate +rather +raven +raw +razor +ready +real +reason +rebel +rebuild +recall +receive +recipe +record +recycle +reduce +reflect +reform +refuse +region +regret +regular +reject +relax +release +relief +rely +remain +remember +remind +remove +render +renew +rent +reopen +repair +repeat +replace +report +require +rescue +resemble +resist +resource +response +result +retire +retreat +return +reunion +reveal +review +reward +rhythm +rib +ribbon +rice +rich +ride +ridge +rifle +right +rigid +ring +riot +ripple +risk +ritual +rival +river +road +roast +robot +robust +rocket +romance +roof +rookie +room +rose +rotate +rough +round +route +royal +rubber +rude +rug +rule +run +runway +rural +sad +saddle +sadness +safe +sail +salad +salmon +salon +salt +salute +same +sample +sand +satisfy +satoshi +sauce +sausage +save +say +scale +scan +scare +scatter +scene +scheme +school +science +scissors +scorpion +scout +scrap +screen +script +scrub +sea +search +season +seat +second +secret +section +security +seed +seek +segment +select +sell +seminar +senior +sense +sentence +series +service +session +settle +setup +seven +shadow +shaft +shallow +share +shed +shell +sheriff +shield +shift +shine +ship +shiver +shock +shoe +shoot +shop +short +shoulder +shove +shrimp +shrug +shuffle +shy +sibling +sick +side +siege +sight +sign +silent +silk +silly +silver +similar +simple +since +sing +siren +sister +situate +six +size +skate +sketch +ski +skill +skin +skirt +skull +slab +slam +sleep +slender +slice +slide +slight +slim +slogan +slot +slow +slush +small +smart +smile +smoke +smooth +snack +snake +snap +sniff +snow +soap +soccer +social +sock +soda +soft +solar +soldier +solid +solution +solve +someone +song +soon +sorry +sort +soul +sound +soup +source +south +space +spare +spatial +spawn +speak +special +speed +spell +spend +sphere +spice +spider +spike +spin +spirit +split +spoil +sponsor +spoon +sport +spot +spray +spread +spring +spy +square +squeeze +squirrel +stable +stadium +staff +stage +stairs +stamp +stand +start +state +stay +steak +steel +stem +step +stereo +stick +still +sting +stock +stomach +stone +stool +story +stove +strategy +street +strike +strong +struggle +student +stuff +stumble +style +subject +submit +subway +success +such +sudden +suffer +sugar +suggest +suit +summer +sun +sunny +sunset +super +supply +supreme +sure +surface +surge +surprise +surround +survey +suspect +sustain +swallow +swamp +swap +swarm +swear +sweet +swift +swim +swing +switch +sword +symbol +symptom +syrup +system +table +tackle +tag +tail +talent +talk +tank +tape +target +task +taste +tattoo +taxi +teach +team +tell +ten +tenant +tennis +tent +term +test +text +thank +that +theme +then +theory +there +they +thing +this +thought +three +thrive +throw +thumb +thunder +ticket +tide +tiger +tilt +timber +time +tiny +tip +tired +tissue +title +toast +tobacco +today +toddler +toe +together +toilet +token +tomato +tomorrow +tone +tongue +tonight +tool +tooth +top +topic +topple +torch +tornado +tortoise +toss +total +tourist +toward +tower +town +toy +track +trade +traffic +tragic +train +transfer +trap +trash +travel +tray +treat +tree +trend +trial +tribe +trick +trigger +trim +trip +trophy +trouble +truck +true +truly +trumpet +trust +truth +try +tube +tuition +tumble +tuna +tunnel +turkey +turn +turtle +twelve +twenty +twice +twin +twist +two +type +typical +ugly +umbrella +unable +unaware +uncle +uncover +under +undo +unfair +unfold +unhappy +uniform +unique +unit +universe +unknown +unlock +until +unusual +unveil +update +upgrade +uphold +upon +upper +upset +urban +urge +usage +use +used +useful +useless +usual +utility +vacant +vacuum +vague +valid +valley +valve +van +vanish +vapor +various +vast +vault +vehicle +velvet +vendor +venture +venue +verb +verify +version +very +vessel +veteran +viable +vibrant +vicious +victory +video +view +village +vintage +violin +virtual +virus +visa +visit +visual +vital +vivid +vocal +voice +void +volcano +volume +vote +voyage +wage +wagon +wait +walk +wall +walnut +want +warfare +warm +warrior +wash +wasp +waste +water +wave +way +wealth +weapon +wear +weasel +weather +web +wedding +weekend +weird +welcome +west +wet +whale +what +wheat +wheel +when +where +whip +whisper +wide +width +wife +wild +will +win +window +wine +wing +wink +winner +winter +wire +wisdom +wise +wish +witness +wolf +woman +wonder +wood +wool +word +work +world +worry +worth +wrap +wreck +wrestle +wrist +write +wrong +yard +year +yellow +you +young +youth +zebra +zero +zone +zoo`.split("\n"); + } + }); + + // node_modules/.pnpm/@noble+hashes@1.3.0/node_modules/@noble/hashes/_assert.js + var require_assert = __commonJS({ + "node_modules/.pnpm/@noble+hashes@1.3.0/node_modules/@noble/hashes/_assert.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { + value: true + }); + exports.output = exports.exists = exports.hash = exports.bytes = exports.bool = exports.number = void 0; + function number2(n) { + if (!Number.isSafeInteger(n) || n < 0) + throw new Error(`Wrong positive integer: ${n}`); + } + exports.number = number2; + function bool2(b) { + if (typeof b !== "boolean") + throw new Error(`Expected boolean, not ${b}`); + } + exports.bool = bool2; + function bytes2(b, ...lengths) { + if (!(b instanceof Uint8Array)) + throw new TypeError("Expected Uint8Array"); + if (lengths.length > 0 && !lengths.includes(b.length)) + throw new TypeError(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`); + } + exports.bytes = bytes2; + function hash2(hash3) { + if (typeof hash3 !== "function" || typeof hash3.create !== "function") + throw new Error("Hash should be wrapped by utils.wrapConstructor"); + number2(hash3.outputLen); + number2(hash3.blockLen); + } + exports.hash = hash2; + function exists2(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"); + } + exports.exists = exists2; + function output2(out, instance) { + bytes2(out); + const min = instance.outputLen; + if (out.length < min) { + throw new Error(`digestInto() expects output buffer of length at least ${min}`); + } + } + exports.output = output2; + var assert2 = { + number: number2, + bool: bool2, + bytes: bytes2, + hash: hash2, + exists: exists2, + output: output2 + }; + exports.default = assert2; + } + }); + + // node_modules/.pnpm/@noble+hashes@1.3.0/node_modules/@noble/hashes/crypto.js + var require_crypto2 = __commonJS({ + "node_modules/.pnpm/@noble+hashes@1.3.0/node_modules/@noble/hashes/crypto.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { + value: true + }); + exports.crypto = void 0; + exports.crypto = typeof globalThis === "object" && "crypto"in globalThis ? globalThis.crypto : void 0; + } + }); + + // node_modules/.pnpm/@noble+hashes@1.3.0/node_modules/@noble/hashes/utils.js + var require_utils = __commonJS({ + "node_modules/.pnpm/@noble+hashes@1.3.0/node_modules/@noble/hashes/utils.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { + value: true + }); + exports.randomBytes = exports.wrapConstructorWithOpts = exports.wrapConstructor = exports.checkOpts = exports.Hash = exports.concatBytes = exports.toBytes = exports.utf8ToBytes = exports.asyncLoop = exports.nextTick = exports.hexToBytes = exports.bytesToHex = exports.isLE = exports.rotr = exports.createView = exports.u32 = exports.u8 = void 0; + var crypto_1 = require_crypto2(); + var u8 = (arr)=>new Uint8Array(arr.buffer,arr.byteOffset,arr.byteLength); + exports.u8 = u8; + var u32 = (arr)=>new Uint32Array(arr.buffer,arr.byteOffset,Math.floor(arr.byteLength / 4)); + exports.u32 = u32; + var createView3 = (arr)=>new DataView(arr.buffer,arr.byteOffset,arr.byteLength); + exports.createView = createView3; + var rotr3 = (word,shift)=>word << 32 - shift | word >>> shift; + exports.rotr = rotr3; + exports.isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68; + if (!exports.isLE) + throw new Error("Non little-endian hardware is not supported"); + var hexes5 = Array.from({ + length: 256 + }, (v,i)=>i.toString(16).padStart(2, "0")); + function bytesToHex4(uint8a) { + if (!(uint8a instanceof Uint8Array)) + throw new Error("Uint8Array expected"); + let hex2 = ""; + for (let i = 0; i < uint8a.length; i++) { + hex2 += hexes5[uint8a[i]]; + } + return hex2; + } + exports.bytesToHex = bytesToHex4; + function hexToBytes4(hex2) { + if (typeof hex2 !== "string") { + throw new TypeError("hexToBytes: expected string, got " + typeof hex2); + } + if (hex2.length % 2) + throw new Error("hexToBytes: received invalid unpadded hex"); + const array = new Uint8Array(hex2.length / 2); + for (let i = 0; i < array.length; i++) { + const j = i * 2; + const hexByte = hex2.slice(j, j + 2); + const byte = Number.parseInt(hexByte, 16); + if (Number.isNaN(byte) || byte < 0) + throw new Error("Invalid byte sequence"); + array[i] = byte; + } + return array; + } + exports.hexToBytes = hexToBytes4; + var nextTick2 = async()=>{} + ; + exports.nextTick = nextTick2; + async function asyncLoop(iters, tick, cb) { + let ts = Date.now(); + for (let i = 0; i < iters; i++) { + cb(i); + const diff = Date.now() - ts; + if (diff >= 0 && diff < tick) + continue; + await (0, + exports.nextTick)(); + ts += diff; + } + } + exports.asyncLoop = asyncLoop; + function utf8ToBytes4(str) { + if (typeof str !== "string") { + throw new TypeError(`utf8ToBytes expected string, got ${typeof str}`); + } + return new TextEncoder().encode(str); + } + exports.utf8ToBytes = utf8ToBytes4; + function toBytes3(data) { + if (typeof data === "string") + data = utf8ToBytes4(data); + if (!(data instanceof Uint8Array)) + throw new TypeError(`Expected input type is Uint8Array (got ${typeof data})`); + return data; + } + exports.toBytes = toBytes3; + function concatBytes4(...arrays) { + if (!arrays.every((a)=>a instanceof Uint8Array)) + throw new Error("Uint8Array list expected"); + if (arrays.length === 1) + return arrays[0]; + const length = arrays.reduce((a,arr)=>a + arr.length, 0); + const result = new Uint8Array(length); + for (let i = 0, pad = 0; i < arrays.length; i++) { + const arr = arrays[i]; + result.set(arr, pad); + pad += arr.length; + } + return result; + } + exports.concatBytes = concatBytes4; + var Hash3 = class { + // Safe version that clones internal state + clone() { + return this._cloneInto(); + } + } + ; + exports.Hash = Hash3; + var isPlainObject = (obj)=>Object.prototype.toString.call(obj) === "[object Object]" && obj.constructor === Object; + function checkOpts(defaults, opts) { + if (opts !== void 0 && (typeof opts !== "object" || !isPlainObject(opts))) + throw new TypeError("Options should be object or undefined"); + const merged = Object.assign(defaults, opts); + return merged; + } + exports.checkOpts = checkOpts; + function wrapConstructor3(hashConstructor) { + const hashC = (message)=>hashConstructor().update(toBytes3(message)).digest(); + const tmp = hashConstructor(); + hashC.outputLen = tmp.outputLen; + hashC.blockLen = tmp.blockLen; + hashC.create = ()=>hashConstructor(); + return hashC; + } + exports.wrapConstructor = wrapConstructor3; + function wrapConstructorWithOpts(hashCons) { + const hashC = (msg,opts)=>hashCons(opts).update(toBytes3(msg)).digest(); + const tmp = hashCons({}); + hashC.outputLen = tmp.outputLen; + hashC.blockLen = tmp.blockLen; + hashC.create = (opts)=>hashCons(opts); + return hashC; + } + exports.wrapConstructorWithOpts = wrapConstructorWithOpts; + function randomBytes3(bytesLength=32) { + if (crypto_1.crypto && typeof crypto_1.crypto.getRandomValues === "function") { + return crypto_1.crypto.getRandomValues(new Uint8Array(bytesLength)); + } + throw new Error("crypto.getRandomValues must be defined"); + } + exports.randomBytes = randomBytes3; + } + }); + + // node_modules/.pnpm/@noble+hashes@1.3.0/node_modules/@noble/hashes/hmac.js + var require_hmac = __commonJS({ + "node_modules/.pnpm/@noble+hashes@1.3.0/node_modules/@noble/hashes/hmac.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { + value: true + }); + exports.hmac = void 0; + var _assert_js_1 = require_assert(); + var utils_js_1 = require_utils(); + var HMAC3 = class extends utils_js_1.Hash { + constructor(hash2, _key) { + super(); + this.finished = false; + this.destroyed = false; + _assert_js_1.default.hash(hash2); + const key = (0, + utils_js_1.toBytes)(_key); + this.iHash = hash2.create(); + if (typeof this.iHash.update !== "function") + throw new TypeError("Expected instance of class which extends utils.Hash"); + this.blockLen = this.iHash.blockLen; + this.outputLen = this.iHash.outputLen; + const blockLen = this.blockLen; + const pad = new Uint8Array(blockLen); + pad.set(key.length > blockLen ? hash2.create().update(key).digest() : key); + for (let i = 0; i < pad.length; i++) + pad[i] ^= 54; + this.iHash.update(pad); + this.oHash = hash2.create(); + for (let i = 0; i < pad.length; i++) + pad[i] ^= 54 ^ 92; + this.oHash.update(pad); + pad.fill(0); + } + update(buf) { + _assert_js_1.default.exists(this); + this.iHash.update(buf); + return this; + } + digestInto(out) { + _assert_js_1.default.exists(this); + _assert_js_1.default.bytes(out, this.outputLen); + 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 || (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; + } + destroy() { + this.destroyed = true; + this.oHash.destroy(); + this.iHash.destroy(); + } + } + ; + var hmac3 = (hash2,key,message)=>new HMAC3(hash2,key).update(message).digest(); + exports.hmac = hmac3; + exports.hmac.create = (hash2,key)=>new HMAC3(hash2,key); + } + }); + + // node_modules/.pnpm/@noble+hashes@1.3.0/node_modules/@noble/hashes/pbkdf2.js + var require_pbkdf2 = __commonJS({ + "node_modules/.pnpm/@noble+hashes@1.3.0/node_modules/@noble/hashes/pbkdf2.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { + value: true + }); + exports.pbkdf2Async = exports.pbkdf2 = void 0; + var _assert_js_1 = require_assert(); + var hmac_js_1 = require_hmac(); + var utils_js_1 = require_utils(); + function pbkdf2Init(hash2, _password, _salt, _opts) { + _assert_js_1.default.hash(hash2); + const opts = (0, + utils_js_1.checkOpts)({ + dkLen: 32, + asyncTick: 10 + }, _opts); + const {c, dkLen, asyncTick} = opts; + _assert_js_1.default.number(c); + _assert_js_1.default.number(dkLen); + _assert_js_1.default.number(asyncTick); + if (c < 1) + throw new Error("PBKDF2: iterations (c) should be >= 1"); + const password = (0, + utils_js_1.toBytes)(_password); + const salt = (0, + utils_js_1.toBytes)(_salt); + const DK = new Uint8Array(dkLen); + const PRF = hmac_js_1.hmac.create(hash2, 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(); + u.fill(0); + return DK; + } + function pbkdf2(hash2, password, salt, opts) { + const {c, dkLen, DK, PRF, PRFSalt} = pbkdf2Init(hash2, password, salt, opts); + let prfW; + const arr = new Uint8Array(4); + const view = (0, + utils_js_1.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); + } + exports.pbkdf2 = pbkdf2; + async function pbkdf2Async(hash2, password, salt, opts) { + const {c, dkLen, asyncTick, DK, PRF, PRFSalt} = pbkdf2Init(hash2, password, salt, opts); + let prfW; + const arr = new Uint8Array(4); + const view = (0, + utils_js_1.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)); + await (0, + utils_js_1.asyncLoop)(c - 1, asyncTick, (i)=>{ + PRF._cloneInto(prfW).update(u).digestInto(u); + for (let i2 = 0; i2 < Ti.length; i2++) + Ti[i2] ^= u[i2]; + } + ); + } + return pbkdf2Output(PRF, PRFSalt, DK, prfW, u); + } + exports.pbkdf2Async = pbkdf2Async; + } + }); + + // node_modules/.pnpm/@noble+hashes@1.3.0/node_modules/@noble/hashes/_sha2.js + var require_sha2 = __commonJS({ + "node_modules/.pnpm/@noble+hashes@1.3.0/node_modules/@noble/hashes/_sha2.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { + value: true + }); + exports.SHA2 = void 0; + var _assert_js_1 = require_assert(); + var utils_js_1 = require_utils(); + function setBigUint643(view, byteOffset, value, isLE3) { + if (typeof view.setBigUint64 === "function") + return view.setBigUint64(byteOffset, value, isLE3); + const _32n2 = BigInt(32); + const _u32_max = BigInt(4294967295); + const wh = Number(value >> _32n2 & _u32_max); + const wl = Number(value & _u32_max); + const h = isLE3 ? 4 : 0; + const l = isLE3 ? 0 : 4; + view.setUint32(byteOffset + h, wh, isLE3); + view.setUint32(byteOffset + l, wl, isLE3); + } + var SHA23 = class extends utils_js_1.Hash { + constructor(blockLen, outputLen, padOffset, isLE3) { + super(); + this.blockLen = blockLen; + this.outputLen = outputLen; + this.padOffset = padOffset; + this.isLE = isLE3; + this.finished = false; + this.length = 0; + this.pos = 0; + this.destroyed = false; + this.buffer = new Uint8Array(blockLen); + this.view = (0, + utils_js_1.createView)(this.buffer); + } + update(data) { + _assert_js_1.default.exists(this); + const {view, buffer, blockLen} = this; + data = (0, + utils_js_1.toBytes)(data); + const len = data.length; + for (let pos = 0; pos < len; ) { + const take = Math.min(blockLen - this.pos, len - pos); + if (take === blockLen) { + const dataView = (0, + utils_js_1.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) { + _assert_js_1.default.exists(this); + _assert_js_1.default.output(out, this); + this.finished = true; + const {buffer, view, blockLen, isLE: isLE3} = this; + let {pos} = this; + buffer[pos++] = 128; + this.buffer.subarray(pos).fill(0); + if (this.padOffset > blockLen - pos) { + this.process(view, 0); + pos = 0; + } + for (let i = pos; i < blockLen; i++) + buffer[i] = 0; + setBigUint643(view, blockLen - 8, BigInt(this.length * 8), isLE3); + this.process(view, 0); + const oview = (0, + utils_js_1.createView)(out); + const len = this.outputLen; + if (len % 4) + throw new Error("_sha2: outputLen should 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 || (to = new this.constructor()); + to.set(...this.get()); + const {blockLen, buffer, length, finished, destroyed, pos} = this; + to.length = length; + to.pos = pos; + to.finished = finished; + to.destroyed = destroyed; + if (length % blockLen) + to.buffer.set(buffer); + return to; + } + } + ; + exports.SHA2 = SHA23; + } + }); + + // node_modules/.pnpm/@noble+hashes@1.3.0/node_modules/@noble/hashes/sha256.js + var require_sha256 = __commonJS({ + "node_modules/.pnpm/@noble+hashes@1.3.0/node_modules/@noble/hashes/sha256.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { + value: true + }); + exports.sha224 = exports.sha256 = void 0; + var _sha2_js_1 = require_sha2(); + var utils_js_1 = require_utils(); + var Chi3 = (a,b,c)=>a & b ^ ~a & c; + var Maj3 = (a,b,c)=>a & b ^ a & c ^ b & c; + var SHA256_K3 = new Uint32Array([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 IV3 = new Uint32Array([1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225]); + var SHA256_W3 = new Uint32Array(64); + var SHA2563 = class extends _sha2_js_1.SHA2 { + constructor() { + super(64, 32, 8, false); + this.A = IV3[0] | 0; + this.B = IV3[1] | 0; + this.C = IV3[2] | 0; + this.D = IV3[3] | 0; + this.E = IV3[4] | 0; + this.F = IV3[5] | 0; + this.G = IV3[6] | 0; + this.H = IV3[7] | 0; + } + 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_W3[i] = view.getUint32(offset, false); + for (let i = 16; i < 64; i++) { + const W15 = SHA256_W3[i - 15]; + const W2 = SHA256_W3[i - 2]; + const s0 = (0, + utils_js_1.rotr)(W15, 7) ^ (0, + utils_js_1.rotr)(W15, 18) ^ W15 >>> 3; + const s1 = (0, + utils_js_1.rotr)(W2, 17) ^ (0, + utils_js_1.rotr)(W2, 19) ^ W2 >>> 10; + SHA256_W3[i] = s1 + SHA256_W3[i - 7] + s0 + SHA256_W3[i - 16] | 0; + } + let {A, B, C, D, E, F, G, H} = this; + for (let i = 0; i < 64; i++) { + const sigma1 = (0, + utils_js_1.rotr)(E, 6) ^ (0, + utils_js_1.rotr)(E, 11) ^ (0, + utils_js_1.rotr)(E, 25); + const T1 = H + sigma1 + Chi3(E, F, G) + SHA256_K3[i] + SHA256_W3[i] | 0; + const sigma0 = (0, + utils_js_1.rotr)(A, 2) ^ (0, + utils_js_1.rotr)(A, 13) ^ (0, + utils_js_1.rotr)(A, 22); + const T2 = sigma0 + Maj3(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() { + SHA256_W3.fill(0); + } + destroy() { + this.set(0, 0, 0, 0, 0, 0, 0, 0); + this.buffer.fill(0); + } + } + ; + var SHA2242 = class extends SHA2563 { + constructor() { + super(); + this.A = 3238371032 | 0; + this.B = 914150663 | 0; + this.C = 812702999 | 0; + this.D = 4144912697 | 0; + this.E = 4290775857 | 0; + this.F = 1750603025 | 0; + this.G = 1694076839 | 0; + this.H = 3204075428 | 0; + this.outputLen = 28; + } + } + ; + exports.sha256 = (0, + utils_js_1.wrapConstructor)(()=>new SHA2563()); + exports.sha224 = (0, + utils_js_1.wrapConstructor)(()=>new SHA2242()); + } + }); + + // node_modules/.pnpm/@noble+hashes@1.3.0/node_modules/@noble/hashes/_u64.js + var require_u64 = __commonJS({ + "node_modules/.pnpm/@noble+hashes@1.3.0/node_modules/@noble/hashes/_u64.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { + value: true + }); + exports.add = exports.toBig = exports.split = exports.fromBig = void 0; + var U32_MASK642 = BigInt(2 ** 32 - 1); + var _32n2 = BigInt(32); + function fromBig2(n, le=false) { + if (le) + return { + h: Number(n & U32_MASK642), + l: Number(n >> _32n2 & U32_MASK642) + }; + return { + h: Number(n >> _32n2 & U32_MASK642) | 0, + l: Number(n & U32_MASK642) | 0 + }; + } + exports.fromBig = fromBig2; + function split2(lst, le=false) { + let Ah = new Uint32Array(lst.length); + let Al = new Uint32Array(lst.length); + for (let i = 0; i < lst.length; i++) { + const {h, l} = fromBig2(lst[i], le); + [Ah[i],Al[i]] = [h, l]; + } + return [Ah, Al]; + } + exports.split = split2; + var toBig2 = (h,l)=>BigInt(h >>> 0) << _32n2 | BigInt(l >>> 0); + exports.toBig = toBig2; + var shrSH2 = (h,l,s)=>h >>> s; + var shrSL2 = (h,l,s)=>h << 32 - s | l >>> s; + var rotrSH2 = (h,l,s)=>h >>> s | l << 32 - s; + var rotrSL2 = (h,l,s)=>h << 32 - s | l >>> s; + var rotrBH2 = (h,l,s)=>h << 64 - s | l >>> s - 32; + var rotrBL2 = (h,l,s)=>h >>> s - 32 | l << 64 - s; + var rotr32H2 = (h,l)=>l; + var rotr32L2 = (h,l)=>h; + var rotlSH2 = (h,l,s)=>h << s | l >>> 32 - s; + var rotlSL2 = (h,l,s)=>l << s | h >>> 32 - s; + var rotlBH2 = (h,l,s)=>l << s - 32 | h >>> 64 - s; + var rotlBL2 = (h,l,s)=>h << s - 32 | l >>> 64 - s; + function add2(Ah, Al, Bh, Bl) { + const l = (Al >>> 0) + (Bl >>> 0); + return { + h: Ah + Bh + (l / 2 ** 32 | 0) | 0, + l: l | 0 + }; + } + exports.add = add2; + var add3L2 = (Al,Bl,Cl)=>(Al >>> 0) + (Bl >>> 0) + (Cl >>> 0); + var add3H2 = (low,Ah,Bh,Ch)=>Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0; + var add4L2 = (Al,Bl,Cl,Dl)=>(Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0); + var add4H2 = (low,Ah,Bh,Ch,Dh)=>Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0; + var add5L2 = (Al,Bl,Cl,Dl,El)=>(Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0); + var add5H2 = (low,Ah,Bh,Ch,Dh,Eh)=>Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0; + var u642 = { + fromBig: fromBig2, + split: split2, + toBig: exports.toBig, + shrSH: shrSH2, + shrSL: shrSL2, + rotrSH: rotrSH2, + rotrSL: rotrSL2, + rotrBH: rotrBH2, + rotrBL: rotrBL2, + rotr32H: rotr32H2, + rotr32L: rotr32L2, + rotlSH: rotlSH2, + rotlSL: rotlSL2, + rotlBH: rotlBH2, + rotlBL: rotlBL2, + add: add2, + add3L: add3L2, + add3H: add3H2, + add4L: add4L2, + add4H: add4H2, + add5H: add5H2, + add5L: add5L2 + }; + exports.default = u642; + } + }); + + // node_modules/.pnpm/@noble+hashes@1.3.0/node_modules/@noble/hashes/sha512.js + var require_sha512 = __commonJS({ + "node_modules/.pnpm/@noble+hashes@1.3.0/node_modules/@noble/hashes/sha512.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { + value: true + }); + exports.sha384 = exports.sha512_256 = exports.sha512_224 = exports.sha512 = exports.SHA512 = void 0; + var _sha2_js_1 = require_sha2(); + var _u64_js_1 = require_u64(); + var utils_js_1 = require_utils(); + var [SHA512_Kh2,SHA512_Kl2] = _u64_js_1.default.split(["0x428a2f98d728ae22", "0x7137449123ef65cd", "0xb5c0fbcfec4d3b2f", "0xe9b5dba58189dbbc", "0x3956c25bf348b538", "0x59f111f1b605d019", "0x923f82a4af194f9b", "0xab1c5ed5da6d8118", "0xd807aa98a3030242", "0x12835b0145706fbe", "0x243185be4ee4b28c", "0x550c7dc3d5ffb4e2", "0x72be5d74f27b896f", "0x80deb1fe3b1696b1", "0x9bdc06a725c71235", "0xc19bf174cf692694", "0xe49b69c19ef14ad2", "0xefbe4786384f25e3", "0x0fc19dc68b8cd5b5", "0x240ca1cc77ac9c65", "0x2de92c6f592b0275", "0x4a7484aa6ea6e483", "0x5cb0a9dcbd41fbd4", "0x76f988da831153b5", "0x983e5152ee66dfab", "0xa831c66d2db43210", "0xb00327c898fb213f", "0xbf597fc7beef0ee4", "0xc6e00bf33da88fc2", "0xd5a79147930aa725", "0x06ca6351e003826f", "0x142929670a0e6e70", "0x27b70a8546d22ffc", "0x2e1b21385c26c926", "0x4d2c6dfc5ac42aed", "0x53380d139d95b3df", "0x650a73548baf63de", "0x766a0abb3c77b2a8", "0x81c2c92e47edaee6", "0x92722c851482353b", "0xa2bfe8a14cf10364", "0xa81a664bbc423001", "0xc24b8b70d0f89791", "0xc76c51a30654be30", "0xd192e819d6ef5218", "0xd69906245565a910", "0xf40e35855771202a", "0x106aa07032bbd1b8", "0x19a4c116b8d2d0c8", "0x1e376c085141ab53", "0x2748774cdf8eeb99", "0x34b0bcb5e19b48a8", "0x391c0cb3c5c95a63", "0x4ed8aa4ae3418acb", "0x5b9cca4f7763e373", "0x682e6ff3d6b2b8a3", "0x748f82ee5defb2fc", "0x78a5636f43172f60", "0x84c87814a1f0ab72", "0x8cc702081a6439ec", "0x90befffa23631e28", "0xa4506cebde82bde9", "0xbef9a3f7b2c67915", "0xc67178f2e372532b", "0xca273eceea26619c", "0xd186b8c721c0c207", "0xeada7dd6cde0eb1e", "0xf57d4f7fee6ed178", "0x06f067aa72176fba", "0x0a637dc5a2c898a6", "0x113f9804bef90dae", "0x1b710b35131c471b", "0x28db77f523047d84", "0x32caab7b40c72493", "0x3c9ebe0a15c9bebc", "0x431d67c49c100d4c", "0x4cc5d4becb3e42b6", "0x597f299cfc657e2a", "0x5fcb6fab3ad6faec", "0x6c44198c4a475817"].map((n)=>BigInt(n))); + var SHA512_W_H2 = new Uint32Array(80); + var SHA512_W_L2 = new Uint32Array(80); + var SHA5122 = class extends _sha2_js_1.SHA2 { + constructor() { + super(128, 64, 16, false); + this.Ah = 1779033703 | 0; + this.Al = 4089235720 | 0; + this.Bh = 3144134277 | 0; + this.Bl = 2227873595 | 0; + this.Ch = 1013904242 | 0; + this.Cl = 4271175723 | 0; + this.Dh = 2773480762 | 0; + this.Dl = 1595750129 | 0; + this.Eh = 1359893119 | 0; + this.El = 2917565137 | 0; + this.Fh = 2600822924 | 0; + this.Fl = 725511199 | 0; + this.Gh = 528734635 | 0; + this.Gl = 4215389547 | 0; + this.Hh = 1541459225 | 0; + this.Hl = 327033209 | 0; + } + // prettier-ignore + get() { + const {Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl} = this; + return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl]; + } + // prettier-ignore + set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) { + this.Ah = Ah | 0; + this.Al = Al | 0; + this.Bh = Bh | 0; + this.Bl = Bl | 0; + this.Ch = Ch | 0; + this.Cl = Cl | 0; + this.Dh = Dh | 0; + this.Dl = Dl | 0; + this.Eh = Eh | 0; + this.El = El | 0; + this.Fh = Fh | 0; + this.Fl = Fl | 0; + this.Gh = Gh | 0; + this.Gl = Gl | 0; + this.Hh = Hh | 0; + this.Hl = Hl | 0; + } + process(view, offset) { + for (let i = 0; i < 16; i++, + offset += 4) { + SHA512_W_H2[i] = view.getUint32(offset); + SHA512_W_L2[i] = view.getUint32(offset += 4); + } + for (let i = 16; i < 80; i++) { + const W15h = SHA512_W_H2[i - 15] | 0; + const W15l = SHA512_W_L2[i - 15] | 0; + const s0h = _u64_js_1.default.rotrSH(W15h, W15l, 1) ^ _u64_js_1.default.rotrSH(W15h, W15l, 8) ^ _u64_js_1.default.shrSH(W15h, W15l, 7); + const s0l = _u64_js_1.default.rotrSL(W15h, W15l, 1) ^ _u64_js_1.default.rotrSL(W15h, W15l, 8) ^ _u64_js_1.default.shrSL(W15h, W15l, 7); + const W2h = SHA512_W_H2[i - 2] | 0; + const W2l = SHA512_W_L2[i - 2] | 0; + const s1h = _u64_js_1.default.rotrSH(W2h, W2l, 19) ^ _u64_js_1.default.rotrBH(W2h, W2l, 61) ^ _u64_js_1.default.shrSH(W2h, W2l, 6); + const s1l = _u64_js_1.default.rotrSL(W2h, W2l, 19) ^ _u64_js_1.default.rotrBL(W2h, W2l, 61) ^ _u64_js_1.default.shrSL(W2h, W2l, 6); + const SUMl = _u64_js_1.default.add4L(s0l, s1l, SHA512_W_L2[i - 7], SHA512_W_L2[i - 16]); + const SUMh = _u64_js_1.default.add4H(SUMl, s0h, s1h, SHA512_W_H2[i - 7], SHA512_W_H2[i - 16]); + SHA512_W_H2[i] = SUMh | 0; + SHA512_W_L2[i] = SUMl | 0; + } + let {Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl} = this; + for (let i = 0; i < 80; i++) { + const sigma1h = _u64_js_1.default.rotrSH(Eh, El, 14) ^ _u64_js_1.default.rotrSH(Eh, El, 18) ^ _u64_js_1.default.rotrBH(Eh, El, 41); + const sigma1l = _u64_js_1.default.rotrSL(Eh, El, 14) ^ _u64_js_1.default.rotrSL(Eh, El, 18) ^ _u64_js_1.default.rotrBL(Eh, El, 41); + const CHIh = Eh & Fh ^ ~Eh & Gh; + const CHIl = El & Fl ^ ~El & Gl; + const T1ll = _u64_js_1.default.add5L(Hl, sigma1l, CHIl, SHA512_Kl2[i], SHA512_W_L2[i]); + const T1h = _u64_js_1.default.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh2[i], SHA512_W_H2[i]); + const T1l = T1ll | 0; + const sigma0h = _u64_js_1.default.rotrSH(Ah, Al, 28) ^ _u64_js_1.default.rotrBH(Ah, Al, 34) ^ _u64_js_1.default.rotrBH(Ah, Al, 39); + const sigma0l = _u64_js_1.default.rotrSL(Ah, Al, 28) ^ _u64_js_1.default.rotrBL(Ah, Al, 34) ^ _u64_js_1.default.rotrBL(Ah, Al, 39); + const MAJh = Ah & Bh ^ Ah & Ch ^ Bh & Ch; + const MAJl = Al & Bl ^ Al & Cl ^ Bl & Cl; + Hh = Gh | 0; + Hl = Gl | 0; + Gh = Fh | 0; + Gl = Fl | 0; + Fh = Eh | 0; + Fl = El | 0; + ({h: Eh, l: El} = _u64_js_1.default.add(Dh | 0, Dl | 0, T1h | 0, T1l | 0)); + Dh = Ch | 0; + Dl = Cl | 0; + Ch = Bh | 0; + Cl = Bl | 0; + Bh = Ah | 0; + Bl = Al | 0; + const All = _u64_js_1.default.add3L(T1l, sigma0l, MAJl); + Ah = _u64_js_1.default.add3H(All, T1h, sigma0h, MAJh); + Al = All | 0; + } + ({h: Ah, l: Al} = _u64_js_1.default.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0)); + ({h: Bh, l: Bl} = _u64_js_1.default.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0)); + ({h: Ch, l: Cl} = _u64_js_1.default.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0)); + ({h: Dh, l: Dl} = _u64_js_1.default.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0)); + ({h: Eh, l: El} = _u64_js_1.default.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0)); + ({h: Fh, l: Fl} = _u64_js_1.default.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0)); + ({h: Gh, l: Gl} = _u64_js_1.default.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0)); + ({h: Hh, l: Hl} = _u64_js_1.default.add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0)); + this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl); + } + roundClean() { + SHA512_W_H2.fill(0); + SHA512_W_L2.fill(0); + } + destroy() { + this.buffer.fill(0); + this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); + } + } + ; + exports.SHA512 = SHA5122; + var SHA512_2242 = class extends SHA5122 { + constructor() { + super(); + this.Ah = 2352822216 | 0; + this.Al = 424955298 | 0; + this.Bh = 1944164710 | 0; + this.Bl = 2312950998 | 0; + this.Ch = 502970286 | 0; + this.Cl = 855612546 | 0; + this.Dh = 1738396948 | 0; + this.Dl = 1479516111 | 0; + this.Eh = 258812777 | 0; + this.El = 2077511080 | 0; + this.Fh = 2011393907 | 0; + this.Fl = 79989058 | 0; + this.Gh = 1067287976 | 0; + this.Gl = 1780299464 | 0; + this.Hh = 286451373 | 0; + this.Hl = 2446758561 | 0; + this.outputLen = 28; + } + } + ; + var SHA512_2562 = class extends SHA5122 { + constructor() { + super(); + this.Ah = 573645204 | 0; + this.Al = 4230739756 | 0; + this.Bh = 2673172387 | 0; + this.Bl = 3360449730 | 0; + this.Ch = 596883563 | 0; + this.Cl = 1867755857 | 0; + this.Dh = 2520282905 | 0; + this.Dl = 1497426621 | 0; + this.Eh = 2519219938 | 0; + this.El = 2827943907 | 0; + this.Fh = 3193839141 | 0; + this.Fl = 1401305490 | 0; + this.Gh = 721525244 | 0; + this.Gl = 746961066 | 0; + this.Hh = 246885852 | 0; + this.Hl = 2177182882 | 0; + this.outputLen = 32; + } + } + ; + var SHA3842 = class extends SHA5122 { + constructor() { + super(); + this.Ah = 3418070365 | 0; + this.Al = 3238371032 | 0; + this.Bh = 1654270250 | 0; + this.Bl = 914150663 | 0; + this.Ch = 2438529370 | 0; + this.Cl = 812702999 | 0; + this.Dh = 355462360 | 0; + this.Dl = 4144912697 | 0; + this.Eh = 1731405415 | 0; + this.El = 4290775857 | 0; + this.Fh = 2394180231 | 0; + this.Fl = 1750603025 | 0; + this.Gh = 3675008525 | 0; + this.Gl = 1694076839 | 0; + this.Hh = 1203062813 | 0; + this.Hl = 3204075428 | 0; + this.outputLen = 48; + } + } + ; + exports.sha512 = (0, + utils_js_1.wrapConstructor)(()=>new SHA5122()); + exports.sha512_224 = (0, + utils_js_1.wrapConstructor)(()=>new SHA512_2242()); + exports.sha512_256 = (0, + utils_js_1.wrapConstructor)(()=>new SHA512_2562()); + exports.sha384 = (0, + utils_js_1.wrapConstructor)(()=>new SHA3842()); + } + }); + + // node_modules/.pnpm/@scure+base@1.1.1/node_modules/@scure/base/lib/index.js + var require_lib = __commonJS({ + "node_modules/.pnpm/@scure+base@1.1.1/node_modules/@scure/base/lib/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { + value: true + }); + exports.bytes = exports.stringToBytes = exports.str = exports.bytesToString = exports.hex = exports.utf8 = exports.bech32m = exports.bech32 = exports.base58check = exports.base58xmr = exports.base58xrp = exports.base58flickr = exports.base58 = exports.base64url = exports.base64 = exports.base32crockford = exports.base32hex = exports.base32 = exports.base16 = exports.utils = exports.assertNumber = void 0; + function assertNumber3(n) { + if (!Number.isSafeInteger(n)) + throw new Error(`Wrong integer: ${n}`); + } + exports.assertNumber = assertNumber3; + function chain2(...args) { + const wrap = (a,b)=>(c)=>a(b(c)); + const encode = Array.from(args).reverse().reduce((acc,i)=>acc ? wrap(acc, i.encode) : i.encode, void 0); + const decode2 = args.reduce((acc,i)=>acc ? wrap(acc, i.decode) : i.decode, void 0); + return { + encode, + decode: decode2 + }; + } + function alphabet2(alphabet3) { + return { + encode: (digits)=>{ + if (!Array.isArray(digits) || digits.length && typeof digits[0] !== "number") + throw new Error("alphabet.encode input should be an array of numbers"); + return digits.map((i)=>{ + assertNumber3(i); + if (i < 0 || i >= alphabet3.length) + throw new Error(`Digit index outside alphabet: ${i} (alphabet: ${alphabet3.length})`); + return alphabet3[i]; + } + ); + } + , + decode: (input)=>{ + if (!Array.isArray(input) || input.length && typeof input[0] !== "string") + throw new Error("alphabet.decode input should be array of strings"); + return input.map((letter)=>{ + if (typeof letter !== "string") + throw new Error(`alphabet.decode: not string element=${letter}`); + const index = alphabet3.indexOf(letter); + if (index === -1) + throw new Error(`Unknown letter: "${letter}". Allowed: ${alphabet3}`); + return index; + } + ); + } + }; + } + function join2(separator="") { + if (typeof separator !== "string") + throw new Error("join separator should be string"); + return { + encode: (from)=>{ + if (!Array.isArray(from) || from.length && typeof from[0] !== "string") + throw new Error("join.encode input should be array of strings"); + for (let i of from) + if (typeof i !== "string") + throw new Error(`join.encode: non-string input=${i}`); + return from.join(separator); + } + , + decode: (to)=>{ + if (typeof to !== "string") + throw new Error("join.decode input should be string"); + return to.split(separator); + } + }; + } + function padding2(bits, chr="=") { + assertNumber3(bits); + if (typeof chr !== "string") + throw new Error("padding chr should be string"); + return { + encode(data) { + if (!Array.isArray(data) || data.length && typeof data[0] !== "string") + throw new Error("padding.encode input should be array of strings"); + for (let i of data) + if (typeof i !== "string") + throw new Error(`padding.encode: non-string input=${i}`); + while (data.length * bits % 8) + data.push(chr); + return data; + }, + decode(input) { + if (!Array.isArray(input) || input.length && typeof input[0] !== "string") + throw new Error("padding.encode input should be array of strings"); + for (let i of input) + if (typeof i !== "string") + throw new Error(`padding.decode: non-string input=${i}`); + let end = input.length; + if (end * bits % 8) + throw new Error("Invalid padding: string should have whole number of bytes"); + for (; end > 0 && input[end - 1] === chr; end--) { + if (!((end - 1) * bits % 8)) + throw new Error("Invalid padding: string has too much padding"); + } + return input.slice(0, end); + } + }; + } + function normalize2(fn) { + if (typeof fn !== "function") + throw new Error("normalize fn should be function"); + return { + encode: (from)=>from, + decode: (to)=>fn(to) + }; + } + function convertRadix3(data, from, to) { + if (from < 2) + throw new Error(`convertRadix: wrong from=${from}, base cannot be less than 2`); + if (to < 2) + throw new Error(`convertRadix: wrong to=${to}, base cannot be less than 2`); + if (!Array.isArray(data)) + throw new Error("convertRadix: data should be array"); + if (!data.length) + return []; + let pos = 0; + const res = []; + const digits = Array.from(data); + digits.forEach((d)=>{ + assertNumber3(d); + if (d < 0 || d >= from) + throw new Error(`Wrong integer: ${d}`); + } + ); + while (true) { + let carry = 0; + let done = true; + for (let i = pos; i < digits.length; i++) { + const digit = digits[i]; + const digitBase = from * carry + digit; + if (!Number.isSafeInteger(digitBase) || from * carry / from !== carry || digitBase - digit !== from * carry) { + throw new Error("convertRadix: carry overflow"); + } + carry = digitBase % to; + digits[i] = Math.floor(digitBase / to); + if (!Number.isSafeInteger(digits[i]) || digits[i] * to + carry !== digitBase) + throw new Error("convertRadix: carry overflow"); + if (!done) + continue; + else if (!digits[i]) + 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 gcd2 = (a,b)=>!b ? a : gcd2(b, a % b); + var radix2carry2 = (from,to)=>from + (to - gcd2(from, to)); + function convertRadix22(data, from, to, padding3) { + if (!Array.isArray(data)) + throw new Error("convertRadix2: data should be array"); + 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 (radix2carry2(from, to) > 32) { + throw new Error(`convertRadix2: carry overflow from=${from} to=${to} carryBits=${radix2carry2(from, to)}`); + } + let carry = 0; + let pos = 0; + const mask = 2 ** to - 1; + const res = []; + for (const n of data) { + assertNumber3(n); + if (n >= 2 ** from) + 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); + carry &= 2 ** pos - 1; + } + carry = carry << to - pos & mask; + if (!padding3 && pos >= from) + throw new Error("Excess padding"); + if (!padding3 && carry) + throw new Error(`Non-zero padding: ${carry}`); + if (padding3 && pos > 0) + res.push(carry >>> 0); + return res; + } + function radix3(num) { + assertNumber3(num); + return { + encode: (bytes2)=>{ + if (!(bytes2 instanceof Uint8Array)) + throw new Error("radix.encode input should be Uint8Array"); + return convertRadix3(Array.from(bytes2), 2 ** 8, num); + } + , + decode: (digits)=>{ + if (!Array.isArray(digits) || digits.length && typeof digits[0] !== "number") + throw new Error("radix.decode input should be array of strings"); + return Uint8Array.from(convertRadix3(digits, num, 2 ** 8)); + } + }; + } + function radix22(bits, revPadding=false) { + assertNumber3(bits); + if (bits <= 0 || bits > 32) + throw new Error("radix2: bits should be in (0..32]"); + if (radix2carry2(8, bits) > 32 || radix2carry2(bits, 8) > 32) + throw new Error("radix2: carry overflow"); + return { + encode: (bytes2)=>{ + if (!(bytes2 instanceof Uint8Array)) + throw new Error("radix2.encode input should be Uint8Array"); + return convertRadix22(Array.from(bytes2), 8, bits, !revPadding); + } + , + decode: (digits)=>{ + if (!Array.isArray(digits) || digits.length && typeof digits[0] !== "number") + throw new Error("radix2.decode input should be array of strings"); + return Uint8Array.from(convertRadix22(digits, bits, 8, revPadding)); + } + }; + } + function unsafeWrapper2(fn) { + if (typeof fn !== "function") + throw new Error("unsafeWrapper fn should be function"); + return function(...args) { + try { + return fn.apply(null, args); + } catch (e) {} + } + ; + } + function checksum2(len, fn) { + assertNumber3(len); + if (typeof fn !== "function") + throw new Error("checksum fn should be function"); + return { + encode(data) { + if (!(data instanceof Uint8Array)) + throw new Error("checksum.encode: input should be Uint8Array"); + const checksum3 = fn(data).slice(0, len); + const res = new Uint8Array(data.length + len); + res.set(data); + res.set(checksum3, data.length); + return res; + }, + decode(data) { + if (!(data instanceof Uint8Array)) + throw new Error("checksum.decode: input should be Uint8Array"); + const payload = data.slice(0, -len); + const newChecksum = fn(payload).slice(0, len); + const oldChecksum = data.slice(-len); + for (let i = 0; i < len; i++) + if (newChecksum[i] !== oldChecksum[i]) + throw new Error("Invalid checksum"); + return payload; + } + }; + } + exports.utils = { + alphabet: alphabet2, + chain: chain2, + checksum: checksum2, + radix: radix3, + radix2: radix22, + join: join2, + padding: padding2 + }; + exports.base16 = chain2(radix22(4), alphabet2("0123456789ABCDEF"), join2("")); + exports.base32 = chain2(radix22(5), alphabet2("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"), padding2(5), join2("")); + exports.base32hex = chain2(radix22(5), alphabet2("0123456789ABCDEFGHIJKLMNOPQRSTUV"), padding2(5), join2("")); + exports.base32crockford = chain2(radix22(5), alphabet2("0123456789ABCDEFGHJKMNPQRSTVWXYZ"), join2(""), normalize2((s)=>s.toUpperCase().replace(/O/g, "0").replace(/[IL]/g, "1"))); + exports.base64 = chain2(radix22(6), alphabet2("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), padding2(6), join2("")); + exports.base64url = chain2(radix22(6), alphabet2("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"), padding2(6), join2("")); + var genBase582 = (abc)=>chain2(radix3(58), alphabet2(abc), join2("")); + exports.base58 = genBase582("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"); + exports.base58flickr = genBase582("123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"); + exports.base58xrp = genBase582("rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz"); + var XMR_BLOCK_LEN2 = [0, 2, 3, 5, 6, 7, 9, 10, 11]; + exports.base58xmr = { + encode(data) { + let res = ""; + for (let i = 0; i < data.length; i += 8) { + const block = data.subarray(i, i + 8); + res += exports.base58.encode(block).padStart(XMR_BLOCK_LEN2[block.length], "1"); + } + return res; + }, + decode(str) { + let res = []; + for (let i = 0; i < str.length; i += 11) { + const slice = str.slice(i, i + 11); + const blockLen = XMR_BLOCK_LEN2.indexOf(slice.length); + const block = exports.base58.decode(slice); + for (let j = 0; j < block.length - blockLen; j++) { + if (block[j] !== 0) + throw new Error("base58xmr: wrong padding"); + } + res = res.concat(Array.from(block.slice(block.length - blockLen))); + } + return Uint8Array.from(res); + } + }; + var base58check3 = (sha2563)=>chain2(checksum2(4, (data)=>sha2563(sha2563(data))), exports.base58); + exports.base58check = base58check3; + var BECH_ALPHABET2 = chain2(alphabet2("qpzry9x8gf2tvdw0s3jn54khce6mua7l"), join2("")); + var POLYMOD_GENERATORS2 = [996825010, 642813549, 513874426, 1027748829, 705979059]; + function bech32Polymod2(pre) { + const b = pre >> 25; + let chk = (pre & 33554431) << 5; + for (let i = 0; i < POLYMOD_GENERATORS2.length; i++) { + if ((b >> i & 1) === 1) + chk ^= POLYMOD_GENERATORS2[i]; + } + return chk; + } + function bechChecksum2(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 = bech32Polymod2(chk) ^ c >> 5; + } + chk = bech32Polymod2(chk); + for (let i = 0; i < len; i++) + chk = bech32Polymod2(chk) ^ prefix.charCodeAt(i) & 31; + for (let v of words) + chk = bech32Polymod2(chk) ^ v; + for (let i = 0; i < 6; i++) + chk = bech32Polymod2(chk); + chk ^= encodingConst; + return BECH_ALPHABET2.encode(convertRadix22([chk % 2 ** 30], 30, 5, false)); + } + function genBech322(encoding) { + const ENCODING_CONST = encoding === "bech32" ? 1 : 734539939; + const _words = radix22(5); + const fromWords = _words.decode; + const toWords = _words.encode; + const fromWordsUnsafe = unsafeWrapper2(fromWords); + function encode(prefix, words, limit=90) { + if (typeof prefix !== "string") + throw new Error(`bech32.encode prefix should be string, not ${typeof prefix}`); + if (!Array.isArray(words) || words.length && typeof words[0] !== "number") + throw new Error(`bech32.encode words should be array of numbers, not ${typeof words}`); + const actualLength = prefix.length + 7 + words.length; + if (limit !== false && actualLength > limit) + throw new TypeError(`Length ${actualLength} exceeds limit ${limit}`); + prefix = prefix.toLowerCase(); + return `${prefix}1 ${BECH_ALPHABET2.encode(words)}${bechChecksum2(prefix, words, ENCODING_CONST)}`; + } + function decode2(str, limit=90) { + if (typeof str !== "string") + throw new Error(`bech32.decode input should be string, not ${typeof str}`); + if (str.length < 8 || limit !== false && str.length > limit) + throw new TypeError(`Wrong string length: ${str.length} (${str}). Expected (8..${limit})`); + const lowered = str.toLowerCase(); + if (str !== lowered && str !== str.toUpperCase()) + throw new Error(`String must be lowercase or uppercase`); + str = lowered; + const sepIndex = str.lastIndexOf("1"); + if (sepIndex === 0 || sepIndex === -1) + throw new Error(`Letter "1" must be present between prefix and data only`); + const prefix = str.slice(0, sepIndex); + const _words2 = str.slice(sepIndex + 1); + if (_words2.length < 6) + throw new Error("Data must be at least 6 characters long"); + const words = BECH_ALPHABET2.decode(_words2).slice(0, -6); + const sum = bechChecksum2(prefix, words, ENCODING_CONST); + if (!_words2.endsWith(sum)) + throw new Error(`Invalid checksum in ${str}: expected "${sum}"`); + return { + prefix, + words + }; + } + const decodeUnsafe = unsafeWrapper2(decode2); + function decodeToBytes(str) { + const {prefix, words} = decode2(str, false); + return { + prefix, + words, + bytes: fromWords(words) + }; + } + return { + encode, + decode: decode2, + decodeToBytes, + decodeUnsafe, + fromWords, + fromWordsUnsafe, + toWords + }; + } + exports.bech32 = genBech322("bech32"); + exports.bech32m = genBech322("bech32m"); + exports.utf8 = { + encode: (data)=>new TextDecoder().decode(data), + decode: (str)=>new TextEncoder().encode(str) + }; + exports.hex = chain2(radix22(4), alphabet2("0123456789abcdef"), join2(""), normalize2((s)=>{ + if (typeof s !== "string" || s.length % 2) + throw new TypeError(`hex.decode: expected string, got ${typeof s} with length ${s.length}`); + return s.toLowerCase(); + } + )); + var CODERS2 = { + utf8: exports.utf8, + hex: exports.hex, + base16: exports.base16, + base32: exports.base32, + base64: exports.base64, + base64url: exports.base64url, + base58: exports.base58, + base58xmr: exports.base58xmr + }; + var coderTypeError2 = `Invalid encoding type. Available types: ${Object.keys(CODERS2).join(", ")}`; + var bytesToString = (type,bytes2)=>{ + if (typeof type !== "string" || !CODERS2.hasOwnProperty(type)) + throw new TypeError(coderTypeError2); + if (!(bytes2 instanceof Uint8Array)) + throw new TypeError("bytesToString() expects Uint8Array"); + return CODERS2[type].encode(bytes2); + } + ; + exports.bytesToString = bytesToString; + exports.str = exports.bytesToString; + var stringToBytes = (type,str)=>{ + if (!CODERS2.hasOwnProperty(type)) + throw new TypeError(coderTypeError2); + if (typeof str !== "string") + throw new TypeError("stringToBytes() expects string"); + return CODERS2[type].decode(str); + } + ; + exports.stringToBytes = stringToBytes; + exports.bytes = exports.stringToBytes; + } + }); + + // node_modules/.pnpm/@scure+bip39@1.2.0/node_modules/@scure/bip39/index.js + var require_bip39 = __commonJS({ + "node_modules/.pnpm/@scure+bip39@1.2.0/node_modules/@scure/bip39/index.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { + value: true + }); + exports.mnemonicToSeedSync = exports.mnemonicToSeed = exports.validateMnemonic = exports.entropyToMnemonic = exports.mnemonicToEntropy = exports.generateMnemonic = void 0; + var _assert_1 = require_assert(); + var pbkdf2_1 = require_pbkdf2(); + var sha256_1 = require_sha256(); + var sha512_1 = require_sha512(); + var utils_1 = require_utils(); + var base_1 = require_lib(); + 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 normalize2(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 assertEntropy(entropy) { + _assert_1.default.bytes(entropy, 16, 20, 24, 28, 32); + } + function generateMnemonic2(wordlist2, strength=128) { + _assert_1.default.number(strength); + if (strength % 32 !== 0 || strength > 256) + throw new TypeError("Invalid entropy"); + return entropyToMnemonic((0, + utils_1.randomBytes)(strength / 8), wordlist2); + } + exports.generateMnemonic = generateMnemonic2; + var calcChecksum = (entropy)=>{ + const bitsLeft = 8 - entropy.length / 4; + return new Uint8Array([(0, + sha256_1.sha256)(entropy)[0] >> bitsLeft << bitsLeft]); + } + ; + function getCoder(wordlist2) { + if (!Array.isArray(wordlist2) || wordlist2.length !== 2048 || typeof wordlist2[0] !== "string") + throw new Error("Worlist: expected array of 2048 strings"); + wordlist2.forEach((i)=>{ + if (typeof i !== "string") + throw new Error(`Wordlist: non-string element: ${i}`); + } + ); + return base_1.utils.chain(base_1.utils.checksum(1, calcChecksum), base_1.utils.radix2(11, true), base_1.utils.alphabet(wordlist2)); + } + function mnemonicToEntropy(mnemonic, wordlist2) { + const {words} = normalize2(mnemonic); + const entropy = getCoder(wordlist2).decode(words); + assertEntropy(entropy); + return entropy; + } + exports.mnemonicToEntropy = mnemonicToEntropy; + function entropyToMnemonic(entropy, wordlist2) { + assertEntropy(entropy); + const words = getCoder(wordlist2).encode(entropy); + return words.join(isJapanese(wordlist2) ? "\u3000" : " "); + } + exports.entropyToMnemonic = entropyToMnemonic; + function validateMnemonic2(mnemonic, wordlist2) { + try { + mnemonicToEntropy(mnemonic, wordlist2); + } catch (e) { + return false; + } + return true; + } + exports.validateMnemonic = validateMnemonic2; + var salt = (passphrase)=>nfkd(`mnemonic ${passphrase}`); + function mnemonicToSeed(mnemonic, passphrase="") { + return (0, + pbkdf2_1.pbkdf2Async)(sha512_1.sha512, normalize2(mnemonic).nfkd, salt(passphrase), { + c: 2048, + dkLen: 64 + }); + } + exports.mnemonicToSeed = mnemonicToSeed; + function mnemonicToSeedSync2(mnemonic, passphrase="") { + return (0, + pbkdf2_1.pbkdf2)(sha512_1.sha512, normalize2(mnemonic).nfkd, salt(passphrase), { + c: 2048, + dkLen: 64 + }); + } + exports.mnemonicToSeedSync = mnemonicToSeedSync2; + } + }); + + // src/background.js + var import_webextension_polyfill2 = __toESM(require_browser_polyfill()); + + // node_modules/.pnpm/@noble+secp256k1@1.7.1/node_modules/@noble/secp256k1/lib/esm/index.js + var nodeCrypto = __toESM(require_crypto(), 1); + var _0n = BigInt(0); + var _1n = BigInt(1); + var _2n = BigInt(2); + var _3n = BigInt(3); + var _8n = BigInt(8); + var CURVE = Object.freeze({ + a: _0n, + b: BigInt(7), + P: BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"), + n: BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"), + h: _1n, + Gx: BigInt("55066263022277343669578718895168534326250603453777594175500187360389116729240"), + Gy: BigInt("32670510020758816978083085130507043184471273380659243275938904335757337482424"), + beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee") + }); + var divNearest = (a,b)=>(a + b / _2n) / b; + var endo = { + beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"), + splitScalar(k) { + const {n} = CURVE; + const a1 = BigInt("0x3086d221a7d46bcde86c90e49284eb15"); + const b1 = -_1n * BigInt("0xe4437ed6010e88286f547fa90abfe4c3"); + const a2 = BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8"); + const b2 = a1; + const POW_2_128 = BigInt("0x100000000000000000000000000000000"); + const c1 = divNearest(b2 * k, n); + const c2 = divNearest(-b1 * k, n); + let k1 = mod(k - c1 * a1 - c2 * a2, n); + let k2 = mod(-c1 * b1 - c2 * b2, n); + const k1neg = k1 > POW_2_128; + const k2neg = k2 > POW_2_128; + if (k1neg) + k1 = n - k1; + if (k2neg) + k2 = n - k2; + if (k1 > POW_2_128 || k2 > POW_2_128) { + throw new Error("splitScalarEndo: Endomorphism failed, k=" + k); + } + return { + k1neg, + k1, + k2neg, + k2 + }; + } + }; + var fieldLen = 32; + var groupLen = 32; + var compressedLen = fieldLen + 1; + var uncompressedLen = 2 * fieldLen + 1; + function weierstrass(x) { + const {a, b} = CURVE; + const x2 = mod(x * x); + const x3 = mod(x2 * x); + return mod(x3 + a * x + b); + } + var USE_ENDOMORPHISM = CURVE.a === _0n; + var ShaError = class extends Error { + constructor(message) { + super(message); + } + } + ; + function assertJacPoint(other) { + if (!(other instanceof JacobianPoint)) + throw new TypeError("JacobianPoint expected"); + } + var JacobianPoint = class { + constructor(x, y, z) { + this.x = x; + this.y = y; + this.z = z; + } + static fromAffine(p) { + if (!(p instanceof Point)) { + throw new TypeError("JacobianPoint#fromAffine: expected Point"); + } + if (p.equals(Point.ZERO)) + return JacobianPoint.ZERO; + return new JacobianPoint(p.x,p.y,_1n); + } + static toAffineBatch(points) { + const toInv = invertBatch(points.map((p)=>p.z)); + return points.map((p,i)=>p.toAffine(toInv[i])); + } + static normalizeZ(points) { + return JacobianPoint.toAffineBatch(points).map(JacobianPoint.fromAffine); + } + equals(other) { + assertJacPoint(other); + const {x: X1, y: Y1, z: Z1} = this; + const {x: X2, y: Y2, z: Z2} = other; + const Z1Z1 = mod(Z1 * Z1); + const Z2Z2 = mod(Z2 * Z2); + const U1 = mod(X1 * Z2Z2); + const U2 = mod(X2 * Z1Z1); + const S1 = mod(mod(Y1 * Z2) * Z2Z2); + const S2 = mod(mod(Y2 * Z1) * Z1Z1); + return U1 === U2 && S1 === S2; + } + negate() { + return new JacobianPoint(this.x,mod(-this.y),this.z); + } + double() { + const {x: X1, y: Y1, z: Z1} = this; + const A = mod(X1 * X1); + const B = mod(Y1 * Y1); + const C = mod(B * B); + const x1b = X1 + B; + const D = mod(_2n * (mod(x1b * x1b) - A - C)); + const E = mod(_3n * A); + const F = mod(E * E); + const X3 = mod(F - _2n * D); + const Y3 = mod(E * (D - X3) - _8n * C); + const Z3 = mod(_2n * Y1 * Z1); + return new JacobianPoint(X3,Y3,Z3); + } + add(other) { + assertJacPoint(other); + const {x: X1, y: Y1, z: Z1} = this; + const {x: X2, y: Y2, z: Z2} = other; + if (X2 === _0n || Y2 === _0n) + return this; + if (X1 === _0n || Y1 === _0n) + return other; + const Z1Z1 = mod(Z1 * Z1); + const Z2Z2 = mod(Z2 * Z2); + const U1 = mod(X1 * Z2Z2); + const U2 = mod(X2 * Z1Z1); + const S1 = mod(mod(Y1 * Z2) * Z2Z2); + const S2 = mod(mod(Y2 * Z1) * Z1Z1); + const H = mod(U2 - U1); + const r = mod(S2 - S1); + if (H === _0n) { + if (r === _0n) { + return this.double(); + } else { + return JacobianPoint.ZERO; + } + } + const HH = mod(H * H); + const HHH = mod(H * HH); + const V = mod(U1 * HH); + const X3 = mod(r * r - HHH - _2n * V); + const Y3 = mod(r * (V - X3) - S1 * HHH); + const Z3 = mod(Z1 * Z2 * H); + return new JacobianPoint(X3,Y3,Z3); + } + subtract(other) { + return this.add(other.negate()); + } + multiplyUnsafe(scalar) { + const P0 = JacobianPoint.ZERO; + if (typeof scalar === "bigint" && scalar === _0n) + return P0; + let n = normalizeScalar(scalar); + if (n === _1n) + return this; + if (!USE_ENDOMORPHISM) { + let p = P0; + let d2 = this; + while (n > _0n) { + if (n & _1n) + p = p.add(d2); + d2 = d2.double(); + n >>= _1n; + } + return p; + } + let {k1neg, k1, k2neg, k2} = endo.splitScalar(n); + let k1p = P0; + let k2p = P0; + let d = this; + while (k1 > _0n || k2 > _0n) { + if (k1 & _1n) + k1p = k1p.add(d); + if (k2 & _1n) + k2p = k2p.add(d); + d = d.double(); + k1 >>= _1n; + k2 >>= _1n; + } + if (k1neg) + k1p = k1p.negate(); + if (k2neg) + k2p = k2p.negate(); + k2p = new JacobianPoint(mod(k2p.x * endo.beta),k2p.y,k2p.z); + return k1p.add(k2p); + } + precomputeWindow(W) { + const windows = USE_ENDOMORPHISM ? 128 / W + 1 : 256 / W + 1; + const points = []; + let p = this; + let base = p; + for (let window = 0; window < windows; window++) { + base = p; + points.push(base); + for (let i = 1; i < 2 ** (W - 1); i++) { + base = base.add(p); + points.push(base); + } + p = base.double(); + } + return points; + } + wNAF(n, affinePoint) { + if (!affinePoint && this.equals(JacobianPoint.BASE)) + affinePoint = Point.BASE; + const W = affinePoint && affinePoint._WINDOW_SIZE || 1; + if (256 % W) { + throw new Error("Point#wNAF: Invalid precomputation window, must be power of 2"); + } + let precomputes = affinePoint && pointPrecomputes.get(affinePoint); + if (!precomputes) { + precomputes = this.precomputeWindow(W); + if (affinePoint && W !== 1) { + precomputes = JacobianPoint.normalizeZ(precomputes); + pointPrecomputes.set(affinePoint, precomputes); + } + } + let p = JacobianPoint.ZERO; + let f2 = JacobianPoint.BASE; + const windows = 1 + (USE_ENDOMORPHISM ? 128 / W : 256 / W); + const windowSize = 2 ** (W - 1); + const mask = BigInt(2 ** W - 1); + const maxNumber = 2 ** W; + const shiftBy = BigInt(W); + for (let window = 0; window < windows; window++) { + const offset = window * windowSize; + let wbits = Number(n & mask); + n >>= shiftBy; + if (wbits > windowSize) { + wbits -= maxNumber; + n += _1n; + } + const offset1 = offset; + const offset2 = offset + Math.abs(wbits) - 1; + const cond1 = window % 2 !== 0; + const cond2 = wbits < 0; + if (wbits === 0) { + f2 = f2.add(constTimeNegate(cond1, precomputes[offset1])); + } else { + p = p.add(constTimeNegate(cond2, precomputes[offset2])); + } + } + return { + p, + f: f2 + }; + } + multiply(scalar, affinePoint) { + let n = normalizeScalar(scalar); + let point; + let fake; + if (USE_ENDOMORPHISM) { + const {k1neg, k1, k2neg, k2} = endo.splitScalar(n); + let {p: k1p, f: f1p} = this.wNAF(k1, affinePoint); + let {p: k2p, f: f2p} = this.wNAF(k2, affinePoint); + k1p = constTimeNegate(k1neg, k1p); + k2p = constTimeNegate(k2neg, k2p); + k2p = new JacobianPoint(mod(k2p.x * endo.beta),k2p.y,k2p.z); + point = k1p.add(k2p); + fake = f1p.add(f2p); + } else { + const {p, f: f2} = this.wNAF(n, affinePoint); + point = p; + fake = f2; + } + return JacobianPoint.normalizeZ([point, fake])[0]; + } + toAffine(invZ) { + const {x, y, z} = this; + const is0 = this.equals(JacobianPoint.ZERO); + if (invZ == null) + invZ = is0 ? _8n : invert(z); + const iz1 = invZ; + const iz2 = mod(iz1 * iz1); + const iz3 = mod(iz2 * iz1); + const ax = mod(x * iz2); + const ay = mod(y * iz3); + const zz = mod(z * iz1); + if (is0) + return Point.ZERO; + if (zz !== _1n) + throw new Error("invZ was invalid"); + return new Point(ax,ay); + } + } + ; + JacobianPoint.BASE = new JacobianPoint(CURVE.Gx,CURVE.Gy,_1n); + JacobianPoint.ZERO = new JacobianPoint(_0n,_1n,_0n); + function constTimeNegate(condition, item) { + const neg = item.negate(); + return condition ? neg : item; + } + var pointPrecomputes = /* @__PURE__ */ + new WeakMap(); + var Point = class { + constructor(x, y) { + this.x = x; + this.y = y; + } + _setWindowSize(windowSize) { + this._WINDOW_SIZE = windowSize; + pointPrecomputes.delete(this); + } + hasEvenY() { + return this.y % _2n === _0n; + } + static fromCompressedHex(bytes2) { + const isShort = bytes2.length === 32; + const x = bytesToNumber(isShort ? bytes2 : bytes2.subarray(1)); + if (!isValidFieldElement(x)) + throw new Error("Point is not on curve"); + const y2 = weierstrass(x); + let y = sqrtMod(y2); + const isYOdd = (y & _1n) === _1n; + if (isShort) { + if (isYOdd) + y = mod(-y); + } else { + const isFirstByteOdd = (bytes2[0] & 1) === 1; + if (isFirstByteOdd !== isYOdd) + y = mod(-y); + } + const point = new Point(x,y); + point.assertValidity(); + return point; + } + static fromUncompressedHex(bytes2) { + const x = bytesToNumber(bytes2.subarray(1, fieldLen + 1)); + const y = bytesToNumber(bytes2.subarray(fieldLen + 1, fieldLen * 2 + 1)); + const point = new Point(x,y); + point.assertValidity(); + return point; + } + static fromHex(hex2) { + const bytes2 = ensureBytes(hex2); + const len = bytes2.length; + const header = bytes2[0]; + if (len === fieldLen) + return this.fromCompressedHex(bytes2); + if (len === compressedLen && (header === 2 || header === 3)) { + return this.fromCompressedHex(bytes2); + } + if (len === uncompressedLen && header === 4) + return this.fromUncompressedHex(bytes2); + throw new Error(`Point.fromHex: received invalid point. Expected 32-${compressedLen} compressed bytes or ${uncompressedLen} uncompressed bytes, not ${len}`); + } + static fromPrivateKey(privateKey) { + return Point.BASE.multiply(normalizePrivateKey(privateKey)); + } + static fromSignature(msgHash, signature, recovery) { + const {r, s} = normalizeSignature(signature); + if (![0, 1, 2, 3].includes(recovery)) + throw new Error("Cannot recover: invalid recovery bit"); + const h = truncateHash(ensureBytes(msgHash)); + const {n} = CURVE; + const radj = recovery === 2 || recovery === 3 ? r + n : r; + const rinv = invert(radj, n); + const u1 = mod(-h * rinv, n); + const u2 = mod(s * rinv, n); + const prefix = recovery & 1 ? "03" : "02"; + const R = Point.fromHex(prefix + numTo32bStr(radj)); + const Q = Point.BASE.multiplyAndAddUnsafe(R, u1, u2); + if (!Q) + throw new Error("Cannot recover signature: point at infinify"); + Q.assertValidity(); + return Q; + } + toRawBytes(isCompressed=false) { + return hexToBytes(this.toHex(isCompressed)); + } + toHex(isCompressed=false) { + const x = numTo32bStr(this.x); + if (isCompressed) { + const prefix = this.hasEvenY() ? "02" : "03"; + return `${prefix}${x}`; + } else { + return `04 ${x}${numTo32bStr(this.y)}`; + } + } + toHexX() { + return this.toHex(true).slice(2); + } + toRawX() { + return this.toRawBytes(true).slice(1); + } + assertValidity() { + const msg = "Point is not on elliptic curve"; + const {x, y} = this; + if (!isValidFieldElement(x) || !isValidFieldElement(y)) + throw new Error(msg); + const left = mod(y * y); + const right = weierstrass(x); + if (mod(left - right) !== _0n) + throw new Error(msg); + } + equals(other) { + return this.x === other.x && this.y === other.y; + } + negate() { + return new Point(this.x,mod(-this.y)); + } + double() { + return JacobianPoint.fromAffine(this).double().toAffine(); + } + add(other) { + return JacobianPoint.fromAffine(this).add(JacobianPoint.fromAffine(other)).toAffine(); + } + subtract(other) { + return this.add(other.negate()); + } + multiply(scalar) { + return JacobianPoint.fromAffine(this).multiply(scalar, this).toAffine(); + } + multiplyAndAddUnsafe(Q, a, b) { + const P = JacobianPoint.fromAffine(this); + const aP = a === _0n || a === _1n || this !== Point.BASE ? P.multiplyUnsafe(a) : P.multiply(a); + const bQ = JacobianPoint.fromAffine(Q).multiplyUnsafe(b); + const sum = aP.add(bQ); + return sum.equals(JacobianPoint.ZERO) ? void 0 : sum.toAffine(); + } + } + ; + Point.BASE = new Point(CURVE.Gx,CURVE.Gy); + Point.ZERO = new Point(_0n,_0n); + function sliceDER(s) { + return Number.parseInt(s[0], 16) >= 8 ? "00" + s : s; + } + function parseDERInt(data) { + if (data.length < 2 || data[0] !== 2) { + throw new Error(`Invalid signature integer tag: ${bytesToHex(data)}`); + } + const len = data[1]; + const res = data.subarray(2, len + 2); + if (!len || res.length !== len) { + throw new Error(`Invalid signature integer: wrong length`); + } + if (res[0] === 0 && res[1] <= 127) { + throw new Error("Invalid signature integer: trailing length"); + } + return { + data: bytesToNumber(res), + left: data.subarray(len + 2) + }; + } + function parseDERSignature(data) { + if (data.length < 2 || data[0] != 48) { + throw new Error(`Invalid signature tag: ${bytesToHex(data)}`); + } + if (data[1] !== data.length - 2) { + throw new Error("Invalid signature: incorrect length"); + } + const {data: r, left: sBytes} = parseDERInt(data.subarray(2)); + const {data: s, left: rBytesLeft} = parseDERInt(sBytes); + if (rBytesLeft.length) { + throw new Error(`Invalid signature: left bytes after parsing: ${bytesToHex(rBytesLeft)}`); + } + return { + r, + s + }; + } + var Signature = class { + constructor(r, s) { + this.r = r; + this.s = s; + this.assertValidity(); + } + static fromCompact(hex2) { + const arr = hex2 instanceof Uint8Array; + const name = "Signature.fromCompact"; + if (typeof hex2 !== "string" && !arr) + throw new TypeError(`${name}: Expected string or Uint8Array`); + const str = arr ? bytesToHex(hex2) : hex2; + if (str.length !== 128) + throw new Error(`${name}: Expected 64-byte hex`); + return new Signature(hexToNumber(str.slice(0, 64)),hexToNumber(str.slice(64, 128))); + } + static fromDER(hex2) { + const arr = hex2 instanceof Uint8Array; + if (typeof hex2 !== "string" && !arr) + throw new TypeError(`Signature.fromDER: Expected string or Uint8Array`); + const {r, s} = parseDERSignature(arr ? hex2 : hexToBytes(hex2)); + return new Signature(r,s); + } + static fromHex(hex2) { + return this.fromDER(hex2); + } + assertValidity() { + const {r, s} = this; + if (!isWithinCurveOrder(r)) + throw new Error("Invalid Signature: r must be 0 < r < n"); + if (!isWithinCurveOrder(s)) + throw new Error("Invalid Signature: s must be 0 < s < n"); + } + hasHighS() { + const HALF = CURVE.n >> _1n; + return this.s > HALF; + } + normalizeS() { + return this.hasHighS() ? new Signature(this.r,mod(-this.s, CURVE.n)) : this; + } + toDERRawBytes() { + return hexToBytes(this.toDERHex()); + } + toDERHex() { + const sHex = sliceDER(numberToHexUnpadded(this.s)); + const rHex = sliceDER(numberToHexUnpadded(this.r)); + const sHexL = sHex.length / 2; + const rHexL = rHex.length / 2; + const sLen = numberToHexUnpadded(sHexL); + const rLen = numberToHexUnpadded(rHexL); + const length = numberToHexUnpadded(rHexL + sHexL + 4); + return `30 ${length}02 ${rLen}${rHex}02 ${sLen}${sHex}`; + } + toRawBytes() { + return this.toDERRawBytes(); + } + toHex() { + return this.toDERHex(); + } + toCompactRawBytes() { + return hexToBytes(this.toCompactHex()); + } + toCompactHex() { + return numTo32bStr(this.r) + numTo32bStr(this.s); + } + } + ; + function concatBytes(...arrays) { + if (!arrays.every((b)=>b instanceof Uint8Array)) + throw new Error("Uint8Array list expected"); + if (arrays.length === 1) + return arrays[0]; + const length = arrays.reduce((a,arr)=>a + arr.length, 0); + const result = new Uint8Array(length); + for (let i = 0, pad = 0; i < arrays.length; i++) { + const arr = arrays[i]; + result.set(arr, pad); + pad += arr.length; + } + return result; + } + var hexes = Array.from({ + length: 256 + }, (v,i)=>i.toString(16).padStart(2, "0")); + function bytesToHex(uint8a) { + if (!(uint8a instanceof Uint8Array)) + throw new Error("Expected Uint8Array"); + let hex2 = ""; + for (let i = 0; i < uint8a.length; i++) { + hex2 += hexes[uint8a[i]]; + } + return hex2; + } + var POW_2_256 = BigInt("0x10000000000000000000000000000000000000000000000000000000000000000"); + function numTo32bStr(num) { + if (typeof num !== "bigint") + throw new Error("Expected bigint"); + if (!(_0n <= num && num < POW_2_256)) + throw new Error("Expected number 0 <= n < 2^256"); + return num.toString(16).padStart(64, "0"); + } + function numTo32b(num) { + const b = hexToBytes(numTo32bStr(num)); + if (b.length !== 32) + throw new Error("Error: expected 32 bytes"); + return b; + } + function numberToHexUnpadded(num) { + const hex2 = num.toString(16); + return hex2.length & 1 ? `0 ${hex2}` : hex2; + } + function hexToNumber(hex2) { + if (typeof hex2 !== "string") { + throw new TypeError("hexToNumber: expected string, got " + typeof hex2); + } + return BigInt(`0x ${hex2}`); + } + function hexToBytes(hex2) { + if (typeof hex2 !== "string") { + throw new TypeError("hexToBytes: expected string, got " + typeof hex2); + } + if (hex2.length % 2) + throw new Error("hexToBytes: received invalid unpadded hex" + hex2.length); + const array = new Uint8Array(hex2.length / 2); + for (let i = 0; i < array.length; i++) { + const j = i * 2; + const hexByte = hex2.slice(j, j + 2); + const byte = Number.parseInt(hexByte, 16); + if (Number.isNaN(byte) || byte < 0) + throw new Error("Invalid byte sequence"); + array[i] = byte; + } + return array; + } + function bytesToNumber(bytes2) { + return hexToNumber(bytesToHex(bytes2)); + } + function ensureBytes(hex2) { + return hex2 instanceof Uint8Array ? Uint8Array.from(hex2) : hexToBytes(hex2); + } + function normalizeScalar(num) { + if (typeof num === "number" && Number.isSafeInteger(num) && num > 0) + return BigInt(num); + if (typeof num === "bigint" && isWithinCurveOrder(num)) + return num; + throw new TypeError("Expected valid private scalar: 0 < scalar < curve.n"); + } + function mod(a, b=CURVE.P) { + const result = a % b; + return result >= _0n ? result : b + result; + } + function pow2(x, power) { + const {P} = CURVE; + let res = x; + while (power-- > _0n) { + res *= res; + res %= P; + } + return res; + } + function sqrtMod(x) { + const {P} = CURVE; + const _6n = BigInt(6); + const _11n = BigInt(11); + const _22n = BigInt(22); + const _23n = BigInt(23); + const _44n = BigInt(44); + const _88n = BigInt(88); + const b2 = x * x * x % P; + const b3 = b2 * b2 * x % P; + const b6 = pow2(b3, _3n) * b3 % P; + const b9 = pow2(b6, _3n) * b3 % P; + const b11 = pow2(b9, _2n) * b2 % P; + const b22 = pow2(b11, _11n) * b11 % P; + const b44 = pow2(b22, _22n) * b22 % P; + const b88 = pow2(b44, _44n) * b44 % P; + const b176 = pow2(b88, _88n) * b88 % P; + const b220 = pow2(b176, _44n) * b44 % P; + const b223 = pow2(b220, _3n) * b3 % P; + const t1 = pow2(b223, _23n) * b22 % P; + const t2 = pow2(t1, _6n) * b2 % P; + const rt = pow2(t2, _2n); + const xc = rt * rt % P; + if (xc !== x) + throw new Error("Cannot find square root"); + return rt; + } + function invert(number2, modulo=CURVE.P) { + if (number2 === _0n || modulo <= _0n) { + throw new Error(`invert: expected positive integers, got n=${number2} mod=${modulo}`); + } + let a = mod(number2, modulo); + let b = modulo; + let x = _0n + , y = _1n + , u = _1n + , v = _0n; + while (a !== _0n) { + 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 !== _1n) + throw new Error("invert: does not exist"); + return mod(x, modulo); + } + function invertBatch(nums, p=CURVE.P) { + const scratch = new Array(nums.length); + const lastMultiplied = nums.reduce((acc,num,i)=>{ + if (num === _0n) + return acc; + scratch[i] = acc; + return mod(acc * num, p); + } + , _1n); + const inverted = invert(lastMultiplied, p); + nums.reduceRight((acc,num,i)=>{ + if (num === _0n) + return acc; + scratch[i] = mod(acc * scratch[i], p); + return mod(acc * num, p); + } + , inverted); + return scratch; + } + function bits2int_2(bytes2) { + const delta = bytes2.length * 8 - groupLen * 8; + const num = bytesToNumber(bytes2); + return delta > 0 ? num >> BigInt(delta) : num; + } + function truncateHash(hash2, truncateOnly=false) { + const h = bits2int_2(hash2); + if (truncateOnly) + return h; + const {n} = CURVE; + return h >= n ? h - n : h; + } + var _sha256Sync; + var _hmacSha256Sync; + function isWithinCurveOrder(num) { + return _0n < num && num < CURVE.n; + } + function isValidFieldElement(num) { + return _0n < num && num < CURVE.P; + } + function normalizePrivateKey(key) { + let num; + if (typeof key === "bigint") { + num = key; + } else if (typeof key === "number" && Number.isSafeInteger(key) && key > 0) { + num = BigInt(key); + } else if (typeof key === "string") { + if (key.length !== 2 * groupLen) + throw new Error("Expected 32 bytes of private key"); + num = hexToNumber(key); + } else if (key instanceof Uint8Array) { + if (key.length !== groupLen) + throw new Error("Expected 32 bytes of private key"); + num = bytesToNumber(key); + } else { + throw new TypeError("Expected valid private key"); + } + if (!isWithinCurveOrder(num)) + throw new Error("Expected private key: 0 < key < n"); + return num; + } + function normalizePublicKey(publicKey) { + if (publicKey instanceof Point) { + publicKey.assertValidity(); + return publicKey; + } else { + return Point.fromHex(publicKey); + } + } + function normalizeSignature(signature) { + if (signature instanceof Signature) { + signature.assertValidity(); + return signature; + } + try { + return Signature.fromDER(signature); + } catch (error) { + return Signature.fromCompact(signature); + } + } + function isProbPub(item) { + const arr = item instanceof Uint8Array; + const str = typeof item === "string"; + const len = (arr || str) && item.length; + if (arr) + return len === compressedLen || len === uncompressedLen; + if (str) + return len === compressedLen * 2 || len === uncompressedLen * 2; + if (item instanceof Point) + return true; + return false; + } + function getSharedSecret(privateA, publicB, isCompressed=false) { + if (isProbPub(privateA)) + throw new TypeError("getSharedSecret: first arg must be private key"); + if (!isProbPub(publicB)) + throw new TypeError("getSharedSecret: second arg must be public key"); + const b = normalizePublicKey(publicB); + b.assertValidity(); + return b.multiply(normalizePrivateKey(privateA)).toRawBytes(isCompressed); + } + function schnorrChallengeFinalize(ch) { + return mod(bytesToNumber(ch), CURVE.n); + } + var SchnorrSignature = class { + constructor(r, s) { + this.r = r; + this.s = s; + this.assertValidity(); + } + static fromHex(hex2) { + const bytes2 = ensureBytes(hex2); + if (bytes2.length !== 64) + throw new TypeError(`SchnorrSignature.fromHex: expected 64 bytes, not ${bytes2.length}`); + const r = bytesToNumber(bytes2.subarray(0, 32)); + const s = bytesToNumber(bytes2.subarray(32, 64)); + return new SchnorrSignature(r,s); + } + assertValidity() { + const {r, s} = this; + if (!isValidFieldElement(r) || !isWithinCurveOrder(s)) + throw new Error("Invalid signature"); + } + toHex() { + return numTo32bStr(this.r) + numTo32bStr(this.s); + } + toRawBytes() { + return hexToBytes(this.toHex()); + } + } + ; + function schnorrGetPublicKey(privateKey) { + return Point.fromPrivateKey(privateKey).toRawX(); + } + var InternalSchnorrSignature = class { + constructor(message, privateKey, auxRand=utils.randomBytes()) { + if (message == null) + throw new TypeError(`sign: Expected valid message, not "${message}"`); + this.m = ensureBytes(message); + const {x, scalar} = this.getScalar(normalizePrivateKey(privateKey)); + this.px = x; + this.d = scalar; + this.rand = ensureBytes(auxRand); + if (this.rand.length !== 32) + throw new TypeError("sign: Expected 32 bytes of aux randomness"); + } + getScalar(priv) { + const point = Point.fromPrivateKey(priv); + const scalar = point.hasEvenY() ? priv : CURVE.n - priv; + return { + point, + scalar, + x: point.toRawX() + }; + } + initNonce(d, t0h) { + return numTo32b(d ^ bytesToNumber(t0h)); + } + finalizeNonce(k0h) { + const k0 = mod(bytesToNumber(k0h), CURVE.n); + if (k0 === _0n) + throw new Error("sign: Creation of signature failed. k is zero"); + const {point: R, x: rx, scalar: k} = this.getScalar(k0); + return { + R, + rx, + k + }; + } + finalizeSig(R, k, e, d) { + return new SchnorrSignature(R.x,mod(k + e * d, CURVE.n)).toRawBytes(); + } + error() { + throw new Error("sign: Invalid signature produced"); + } + async calc() { + const {m, d, px, rand} = this; + const tag = utils.taggedHash; + const t = this.initNonce(d, await tag(TAGS.aux, rand)); + const {R, rx, k} = this.finalizeNonce(await tag(TAGS.nonce, t, px, m)); + const e = schnorrChallengeFinalize(await tag(TAGS.challenge, rx, px, m)); + const sig = this.finalizeSig(R, k, e, d); + if (!await schnorrVerify(sig, m, px)) + this.error(); + return sig; + } + calcSync() { + const {m, d, px, rand} = this; + const tag = utils.taggedHashSync; + const t = this.initNonce(d, tag(TAGS.aux, rand)); + const {R, rx, k} = this.finalizeNonce(tag(TAGS.nonce, t, px, m)); + const e = schnorrChallengeFinalize(tag(TAGS.challenge, rx, px, m)); + const sig = this.finalizeSig(R, k, e, d); + if (!schnorrVerifySync(sig, m, px)) + this.error(); + return sig; + } + } + ; + async function schnorrSign(msg, privKey, auxRand) { + return new InternalSchnorrSignature(msg,privKey,auxRand).calc(); + } + function schnorrSignSync(msg, privKey, auxRand) { + return new InternalSchnorrSignature(msg,privKey,auxRand).calcSync(); + } + function initSchnorrVerify(signature, message, publicKey) { + const raw = signature instanceof SchnorrSignature; + const sig = raw ? signature : SchnorrSignature.fromHex(signature); + if (raw) + sig.assertValidity(); + return { + ...sig, + m: ensureBytes(message), + P: normalizePublicKey(publicKey) + }; + } + function finalizeSchnorrVerify(r, P, s, e) { + const R = Point.BASE.multiplyAndAddUnsafe(P, normalizePrivateKey(s), mod(-e, CURVE.n)); + if (!R || !R.hasEvenY() || R.x !== r) + return false; + return true; + } + async function schnorrVerify(signature, message, publicKey) { + try { + const {r, s, m, P} = initSchnorrVerify(signature, message, publicKey); + const e = schnorrChallengeFinalize(await utils.taggedHash(TAGS.challenge, numTo32b(r), P.toRawX(), m)); + return finalizeSchnorrVerify(r, P, s, e); + } catch (error) { + return false; + } + } + function schnorrVerifySync(signature, message, publicKey) { + try { + const {r, s, m, P} = initSchnorrVerify(signature, message, publicKey); + const e = schnorrChallengeFinalize(utils.taggedHashSync(TAGS.challenge, numTo32b(r), P.toRawX(), m)); + return finalizeSchnorrVerify(r, P, s, e); + } catch (error) { + if (error instanceof ShaError) + throw error; + return false; + } + } + var schnorr = { + Signature: SchnorrSignature, + getPublicKey: schnorrGetPublicKey, + sign: schnorrSign, + verify: schnorrVerify, + signSync: schnorrSignSync, + verifySync: schnorrVerifySync + }; + Point.BASE._setWindowSize(8); + var crypto2 = { + node: nodeCrypto, + web: typeof self === "object" && "crypto"in self ? self.crypto : void 0 + }; + var TAGS = { + challenge: "BIP0340/challenge", + aux: "BIP0340/aux", + nonce: "BIP0340/nonce" + }; + var TAGGED_HASH_PREFIXES = {}; + var utils = { + bytesToHex, + hexToBytes, + concatBytes, + mod, + invert, + isValidPrivateKey(privateKey) { + try { + normalizePrivateKey(privateKey); + return true; + } catch (error) { + return false; + } + }, + _bigintTo32Bytes: numTo32b, + _normalizePrivateKey: normalizePrivateKey, + hashToPrivateKey: (hash2)=>{ + hash2 = ensureBytes(hash2); + const minLen = groupLen + 8; + if (hash2.length < minLen || hash2.length > 1024) { + throw new Error(`Expected valid bytes of private key as per FIPS 186`); + } + const num = mod(bytesToNumber(hash2), CURVE.n - _1n) + _1n; + return numTo32b(num); + } + , + randomBytes: (bytesLength=32)=>{ + if (crypto2.web) { + return crypto2.web.getRandomValues(new Uint8Array(bytesLength)); + } else if (crypto2.node) { + const {randomBytes: randomBytes3} = crypto2.node; + return Uint8Array.from(randomBytes3(bytesLength)); + } else { + throw new Error("The environment doesn't have randomBytes function"); + } + } + , + randomPrivateKey: ()=>utils.hashToPrivateKey(utils.randomBytes(groupLen + 8)), + precompute(windowSize=8, point=Point.BASE) { + const cached = point === Point.BASE ? point : new Point(point.x,point.y); + cached._setWindowSize(windowSize); + cached.multiply(_3n); + return cached; + }, + sha256: async(...messages)=>{ + if (crypto2.web) { + const buffer = await crypto2.web.subtle.digest("SHA-256", concatBytes(...messages)); + return new Uint8Array(buffer); + } else if (crypto2.node) { + const {createHash} = crypto2.node; + const hash2 = createHash("sha256"); + messages.forEach((m)=>hash2.update(m)); + return Uint8Array.from(hash2.digest()); + } else { + throw new Error("The environment doesn't have sha256 function"); + } + } + , + hmacSha256: async(key,...messages)=>{ + if (crypto2.web) { + const ckey = await crypto2.web.subtle.importKey("raw", key, { + name: "HMAC", + hash: { + name: "SHA-256" + } + }, false, ["sign"]); + const message = concatBytes(...messages); + const buffer = await crypto2.web.subtle.sign("HMAC", ckey, message); + return new Uint8Array(buffer); + } else if (crypto2.node) { + const {createHmac} = crypto2.node; + const hash2 = createHmac("sha256", key); + messages.forEach((m)=>hash2.update(m)); + return Uint8Array.from(hash2.digest()); + } else { + throw new Error("The environment doesn't have hmac-sha256 function"); + } + } + , + sha256Sync: void 0, + hmacSha256Sync: void 0, + taggedHash: async(tag,...messages)=>{ + let tagP = TAGGED_HASH_PREFIXES[tag]; + if (tagP === void 0) { + const tagH = await utils.sha256(Uint8Array.from(tag, (c)=>c.charCodeAt(0))); + tagP = concatBytes(tagH, tagH); + TAGGED_HASH_PREFIXES[tag] = tagP; + } + return utils.sha256(tagP, ...messages); + } + , + taggedHashSync: (tag,...messages)=>{ + if (typeof _sha256Sync !== "function") + throw new ShaError("sha256Sync is undefined, you need to set it"); + let tagP = TAGGED_HASH_PREFIXES[tag]; + if (tagP === void 0) { + const tagH = _sha256Sync(Uint8Array.from(tag, (c)=>c.charCodeAt(0))); + tagP = concatBytes(tagH, tagH); + TAGGED_HASH_PREFIXES[tag] = tagP; + } + return _sha256Sync(tagP, ...messages); + } + , + _JacobianPoint: JacobianPoint + }; + Object.defineProperties(utils, { + sha256Sync: { + configurable: false, + get() { + return _sha256Sync; + }, + set(val) { + if (!_sha256Sync) + _sha256Sync = val; + } + }, + hmacSha256Sync: { + configurable: false, + get() { + return _hmacSha256Sync; + }, + set(val) { + if (!_hmacSha256Sync) + _hmacSha256Sync = val; + } + } + }); + + // node_modules/.pnpm/@noble+hashes@0.5.9/node_modules/@noble/hashes/esm/cryptoBrowser.js + var crypto3 = { + node: void 0, + web: typeof self === "object" && "crypto"in self ? self.crypto : void 0 + }; + + // node_modules/.pnpm/@noble+hashes@0.5.9/node_modules/@noble/hashes/esm/utils.js + var createView = (arr)=>new DataView(arr.buffer,arr.byteOffset,arr.byteLength); + var rotr = (word,shift)=>word << 32 - shift | word >>> shift; + var isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68; + if (!isLE) + throw new Error("Non little-endian hardware is not supported"); + var hexes2 = Array.from({ + length: 256 + }, (v,i)=>i.toString(16).padStart(2, "0")); + var nextTick = (()=>{ + const nodeRequire = typeof module !== "undefined" && typeof module.require === "function" && module.require.bind(module); + try { + if (nodeRequire) { + const {setImmediate} = nodeRequire("timers"); + return ()=>new Promise((resolve)=>setImmediate(resolve)); + } + } catch (e) {} + return ()=>new Promise((resolve)=>setTimeout(resolve, 0)); + } + )(); + function utf8ToBytes(str) { + if (typeof str !== "string") { + throw new TypeError(`utf8ToBytes expected string, got ${typeof str}`); + } + return new TextEncoder().encode(str); + } + function toBytes(data) { + if (typeof data === "string") + data = utf8ToBytes(data); + if (!(data instanceof Uint8Array)) + throw new TypeError(`Expected input type is Uint8Array (got ${typeof data})`); + return data; + } + function assertNumber(n) { + if (!Number.isSafeInteger(n) || n < 0) + throw new Error(`Wrong positive integer: ${n}`); + } + function assertHash(hash2) { + if (typeof hash2 !== "function" || typeof hash2.init !== "function") + throw new Error("Hash should be wrapped by utils.wrapConstructor"); + assertNumber(hash2.outputLen); + assertNumber(hash2.blockLen); + } + var Hash = class { + // Safe version that clones internal state + clone() { + return this._cloneInto(); + } + } + ; + function wrapConstructor(hashConstructor) { + const hashC = (message)=>hashConstructor().update(toBytes(message)).digest(); + const tmp = hashConstructor(); + hashC.outputLen = tmp.outputLen; + hashC.blockLen = tmp.blockLen; + hashC.create = ()=>hashConstructor(); + hashC.init = hashC.create; + return hashC; + } + function randomBytes(bytesLength=32) { + if (crypto3.web) { + return crypto3.web.getRandomValues(new Uint8Array(bytesLength)); + } else if (crypto3.node) { + return new Uint8Array(crypto3.node.randomBytes(bytesLength).buffer); + } else { + throw new Error("The environment doesn't have randomBytes function"); + } + } + + // node_modules/.pnpm/@noble+hashes@0.5.9/node_modules/@noble/hashes/esm/_sha2.js + function setBigUint64(view, byteOffset, value, isLE3) { + if (typeof view.setBigUint64 === "function") + return view.setBigUint64(byteOffset, value, isLE3); + const _32n2 = BigInt(32); + const _u32_max = BigInt(4294967295); + const wh = Number(value >> _32n2 & _u32_max); + const wl = Number(value & _u32_max); + const h = isLE3 ? 4 : 0; + const l = isLE3 ? 0 : 4; + view.setUint32(byteOffset + h, wh, isLE3); + view.setUint32(byteOffset + l, wl, isLE3); + } + var SHA2 = class extends Hash { + constructor(blockLen, outputLen, padOffset, isLE3) { + super(); + this.blockLen = blockLen; + this.outputLen = outputLen; + this.padOffset = padOffset; + this.isLE = isLE3; + this.finished = false; + this.length = 0; + this.pos = 0; + this.destroyed = false; + this.buffer = new Uint8Array(blockLen); + this.view = createView(this.buffer); + } + update(data) { + if (this.destroyed) + throw new Error("instance is destroyed"); + const {view, buffer, blockLen, finished} = this; + if (finished) + throw new Error("digest() was already called"); + data = toBytes(data); + 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) { + if (this.destroyed) + throw new Error("instance is destroyed"); + if (!(out instanceof Uint8Array) || out.length < this.outputLen) + throw new Error("_Sha2: Invalid output buffer"); + if (this.finished) + throw new Error("digest() was already called"); + this.finished = true; + const {buffer, view, blockLen, isLE: isLE3} = this; + let {pos} = this; + buffer[pos++] = 128; + this.buffer.subarray(pos).fill(0); + if (this.padOffset > blockLen - pos) { + this.process(view, 0); + pos = 0; + } + for (let i = pos; i < blockLen; i++) + buffer[i] = 0; + setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE3); + this.process(view, 0); + const oview = createView(out); + this.get().forEach((v,i)=>oview.setUint32(4 * i, v, isLE3)); + } + digest() { + const {buffer, outputLen} = this; + this.digestInto(buffer); + const res = buffer.slice(0, outputLen); + this.destroy(); + return res; + } + _cloneInto(to) { + to || (to = new this.constructor()); + to.set(...this.get()); + const {blockLen, buffer, length, finished, destroyed, pos} = this; + to.length = length; + to.pos = pos; + to.finished = finished; + to.destroyed = destroyed; + if (length % blockLen) + to.buffer.set(buffer); + return to; + } + } + ; + + // node_modules/.pnpm/@noble+hashes@0.5.9/node_modules/@noble/hashes/esm/sha256.js + var Chi = (a,b,c)=>a & b ^ ~a & c; + var Maj = (a,b,c)=>a & b ^ a & c ^ b & c; + var SHA256_K = new Uint32Array([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 IV = new Uint32Array([1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225]); + var SHA256_W = new Uint32Array(64); + var SHA256 = class extends SHA2 { + constructor() { + super(64, 32, 8, false); + this.A = IV[0] | 0; + this.B = IV[1] | 0; + this.C = IV[2] | 0; + this.D = IV[3] | 0; + this.E = IV[4] | 0; + this.F = IV[5] | 0; + this.G = IV[6] | 0; + this.H = IV[7] | 0; + } + 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() { + SHA256_W.fill(0); + } + destroy() { + this.set(0, 0, 0, 0, 0, 0, 0, 0); + this.buffer.fill(0); + } + } + ; + var sha256 = wrapConstructor(()=>new SHA256()); + + // node_modules/.pnpm/@scure+base@1.1.1/node_modules/@scure/base/lib/esm/index.js + function assertNumber2(n) { + if (!Number.isSafeInteger(n)) + throw new Error(`Wrong integer: ${n}`); + } + function chain(...args) { + const wrap = (a,b)=>(c)=>a(b(c)); + const encode = Array.from(args).reverse().reduce((acc,i)=>acc ? wrap(acc, i.encode) : i.encode, void 0); + const decode2 = args.reduce((acc,i)=>acc ? wrap(acc, i.decode) : i.decode, void 0); + return { + encode, + decode: decode2 + }; + } + function alphabet(alphabet2) { + return { + encode: (digits)=>{ + if (!Array.isArray(digits) || digits.length && typeof digits[0] !== "number") + throw new Error("alphabet.encode input should be an array of numbers"); + return digits.map((i)=>{ + assertNumber2(i); + if (i < 0 || i >= alphabet2.length) + throw new Error(`Digit index outside alphabet: ${i} (alphabet: ${alphabet2.length})`); + return alphabet2[i]; + } + ); + } + , + decode: (input)=>{ + if (!Array.isArray(input) || input.length && typeof input[0] !== "string") + throw new Error("alphabet.decode input should be array of strings"); + return input.map((letter)=>{ + if (typeof letter !== "string") + throw new Error(`alphabet.decode: not string element=${letter}`); + const index = alphabet2.indexOf(letter); + if (index === -1) + throw new Error(`Unknown letter: "${letter}". Allowed: ${alphabet2}`); + return index; + } + ); + } + }; + } + function join(separator="") { + if (typeof separator !== "string") + throw new Error("join separator should be string"); + return { + encode: (from)=>{ + if (!Array.isArray(from) || from.length && typeof from[0] !== "string") + throw new Error("join.encode input should be array of strings"); + for (let i of from) + if (typeof i !== "string") + throw new Error(`join.encode: non-string input=${i}`); + return from.join(separator); + } + , + decode: (to)=>{ + if (typeof to !== "string") + throw new Error("join.decode input should be string"); + return to.split(separator); + } + }; + } + function padding(bits, chr="=") { + assertNumber2(bits); + if (typeof chr !== "string") + throw new Error("padding chr should be string"); + return { + encode(data) { + if (!Array.isArray(data) || data.length && typeof data[0] !== "string") + throw new Error("padding.encode input should be array of strings"); + for (let i of data) + if (typeof i !== "string") + throw new Error(`padding.encode: non-string input=${i}`); + while (data.length * bits % 8) + data.push(chr); + return data; + }, + decode(input) { + if (!Array.isArray(input) || input.length && typeof input[0] !== "string") + throw new Error("padding.encode input should be array of strings"); + for (let i of input) + if (typeof i !== "string") + throw new Error(`padding.decode: non-string input=${i}`); + let end = input.length; + if (end * bits % 8) + throw new Error("Invalid padding: string should have whole number of bytes"); + for (; end > 0 && input[end - 1] === chr; end--) { + if (!((end - 1) * bits % 8)) + throw new Error("Invalid padding: string has too much padding"); + } + return input.slice(0, end); + } + }; + } + function normalize(fn) { + if (typeof fn !== "function") + throw new Error("normalize fn should be function"); + return { + encode: (from)=>from, + decode: (to)=>fn(to) + }; + } + function convertRadix(data, from, to) { + if (from < 2) + throw new Error(`convertRadix: wrong from=${from}, base cannot be less than 2`); + if (to < 2) + throw new Error(`convertRadix: wrong to=${to}, base cannot be less than 2`); + if (!Array.isArray(data)) + throw new Error("convertRadix: data should be array"); + if (!data.length) + return []; + let pos = 0; + const res = []; + const digits = Array.from(data); + digits.forEach((d)=>{ + assertNumber2(d); + if (d < 0 || d >= from) + throw new Error(`Wrong integer: ${d}`); + } + ); + while (true) { + let carry = 0; + let done = true; + for (let i = pos; i < digits.length; i++) { + const digit = digits[i]; + const digitBase = from * carry + digit; + if (!Number.isSafeInteger(digitBase) || from * carry / from !== carry || digitBase - digit !== from * carry) { + throw new Error("convertRadix: carry overflow"); + } + carry = digitBase % to; + digits[i] = Math.floor(digitBase / to); + if (!Number.isSafeInteger(digits[i]) || digits[i] * to + carry !== digitBase) + throw new Error("convertRadix: carry overflow"); + if (!done) + continue; + else if (!digits[i]) + 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 ? a : gcd(b, a % b); + var radix2carry = (from,to)=>from + (to - gcd(from, to)); + function convertRadix2(data, from, to, padding2) { + if (!Array.isArray(data)) + throw new Error("convertRadix2: data should be array"); + 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 (radix2carry(from, to) > 32) { + throw new Error(`convertRadix2: carry overflow from=${from} to=${to} carryBits=${radix2carry(from, to)}`); + } + let carry = 0; + let pos = 0; + const mask = 2 ** to - 1; + const res = []; + for (const n of data) { + assertNumber2(n); + if (n >= 2 ** from) + 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); + carry &= 2 ** pos - 1; + } + carry = carry << to - pos & mask; + if (!padding2 && pos >= from) + throw new Error("Excess padding"); + if (!padding2 && carry) + throw new Error(`Non-zero padding: ${carry}`); + if (padding2 && pos > 0) + res.push(carry >>> 0); + return res; + } + function radix(num) { + assertNumber2(num); + return { + encode: (bytes2)=>{ + if (!(bytes2 instanceof Uint8Array)) + throw new Error("radix.encode input should be Uint8Array"); + return convertRadix(Array.from(bytes2), 2 ** 8, num); + } + , + decode: (digits)=>{ + if (!Array.isArray(digits) || digits.length && typeof digits[0] !== "number") + throw new Error("radix.decode input should be array of strings"); + return Uint8Array.from(convertRadix(digits, num, 2 ** 8)); + } + }; + } + function radix2(bits, revPadding=false) { + assertNumber2(bits); + if (bits <= 0 || bits > 32) + throw new Error("radix2: bits should be in (0..32]"); + if (radix2carry(8, bits) > 32 || radix2carry(bits, 8) > 32) + throw new Error("radix2: carry overflow"); + return { + encode: (bytes2)=>{ + if (!(bytes2 instanceof Uint8Array)) + throw new Error("radix2.encode input should be Uint8Array"); + return convertRadix2(Array.from(bytes2), 8, bits, !revPadding); + } + , + decode: (digits)=>{ + if (!Array.isArray(digits) || digits.length && typeof digits[0] !== "number") + throw new Error("radix2.decode input should be array of strings"); + return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding)); + } + }; + } + function unsafeWrapper(fn) { + if (typeof fn !== "function") + throw new Error("unsafeWrapper fn should be function"); + return function(...args) { + try { + return fn.apply(null, args); + } catch (e) {} + } + ; + } + function checksum(len, fn) { + assertNumber2(len); + if (typeof fn !== "function") + throw new Error("checksum fn should be function"); + return { + encode(data) { + if (!(data instanceof Uint8Array)) + throw new Error("checksum.encode: input should be Uint8Array"); + const checksum2 = fn(data).slice(0, len); + const res = new Uint8Array(data.length + len); + res.set(data); + res.set(checksum2, data.length); + return res; + }, + decode(data) { + if (!(data instanceof Uint8Array)) + throw new Error("checksum.decode: input should be Uint8Array"); + const payload = data.slice(0, -len); + const newChecksum = fn(payload).slice(0, len); + const oldChecksum = data.slice(-len); + for (let i = 0; i < len; i++) + if (newChecksum[i] !== oldChecksum[i]) + throw new Error("Invalid checksum"); + return payload; + } + }; + } + var base16 = chain(radix2(4), alphabet("0123456789ABCDEF"), join("")); + var base32 = chain(radix2(5), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"), padding(5), join("")); + var base32hex = chain(radix2(5), alphabet("0123456789ABCDEFGHIJKLMNOPQRSTUV"), padding(5), join("")); + var base32crockford = chain(radix2(5), alphabet("0123456789ABCDEFGHJKMNPQRSTVWXYZ"), join(""), normalize((s)=>s.toUpperCase().replace(/O/g, "0").replace(/[IL]/g, "1"))); + var base64 = chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), padding(6), join("")); + var base64url = chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"), padding(6), join("")); + var genBase58 = (abc)=>chain(radix(58), alphabet(abc), join("")); + var base58 = genBase58("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"); + var base58flickr = genBase58("123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"); + var base58xrp = genBase58("rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz"); + var XMR_BLOCK_LEN = [0, 2, 3, 5, 6, 7, 9, 10, 11]; + var base58xmr = { + encode(data) { + let res = ""; + for (let i = 0; i < data.length; i += 8) { + const block = data.subarray(i, i + 8); + res += base58.encode(block).padStart(XMR_BLOCK_LEN[block.length], "1"); + } + return res; + }, + decode(str) { + let res = []; + for (let i = 0; i < str.length; i += 11) { + const slice = str.slice(i, i + 11); + const blockLen = XMR_BLOCK_LEN.indexOf(slice.length); + const block = base58.decode(slice); + for (let j = 0; j < block.length - blockLen; j++) { + if (block[j] !== 0) + throw new Error("base58xmr: wrong padding"); + } + res = res.concat(Array.from(block.slice(block.length - blockLen))); + } + return Uint8Array.from(res); + } + }; + var base58check = (sha2563)=>chain(checksum(4, (data)=>sha2563(sha2563(data))), base58); + var BECH_ALPHABET = chain(alphabet("qpzry9x8gf2tvdw0s3jn54khce6mua7l"), 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 % 2 ** 30], 30, 5, false)); + } + function genBech32(encoding) { + const ENCODING_CONST = encoding === "bech32" ? 1 : 734539939; + const _words = radix2(5); + const fromWords = _words.decode; + const toWords = _words.encode; + const fromWordsUnsafe = unsafeWrapper(fromWords); + function encode(prefix, words, limit=90) { + if (typeof prefix !== "string") + throw new Error(`bech32.encode prefix should be string, not ${typeof prefix}`); + if (!Array.isArray(words) || words.length && typeof words[0] !== "number") + throw new Error(`bech32.encode words should be array of numbers, not ${typeof words}`); + const actualLength = prefix.length + 7 + words.length; + if (limit !== false && actualLength > limit) + throw new TypeError(`Length ${actualLength} exceeds limit ${limit}`); + prefix = prefix.toLowerCase(); + return `${prefix}1 ${BECH_ALPHABET.encode(words)}${bechChecksum(prefix, words, ENCODING_CONST)}`; + } + function decode2(str, limit=90) { + if (typeof str !== "string") + throw new Error(`bech32.decode input should be string, not ${typeof str}`); + if (str.length < 8 || limit !== false && str.length > limit) + throw new TypeError(`Wrong string length: ${str.length} (${str}). Expected (8..${limit})`); + const lowered = str.toLowerCase(); + if (str !== lowered && str !== str.toUpperCase()) + throw new Error(`String must be lowercase or uppercase`); + str = lowered; + const sepIndex = str.lastIndexOf("1"); + if (sepIndex === 0 || sepIndex === -1) + throw new Error(`Letter "1" must be present between prefix and data only`); + const prefix = str.slice(0, sepIndex); + const _words2 = str.slice(sepIndex + 1); + if (_words2.length < 6) + throw new Error("Data must be at least 6 characters long"); + const words = BECH_ALPHABET.decode(_words2).slice(0, -6); + const sum = bechChecksum(prefix, words, ENCODING_CONST); + if (!_words2.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) + }; + } + return { + encode, + decode: decode2, + decodeToBytes, + decodeUnsafe, + fromWords, + fromWordsUnsafe, + toWords + }; + } + var bech32 = genBech32("bech32"); + var bech32m = genBech32("bech32m"); + var utf8 = { + encode: (data)=>new TextDecoder().decode(data), + decode: (str)=>new TextEncoder().encode(str) + }; + var hex = chain(radix2(4), alphabet("0123456789abcdef"), join(""), normalize((s)=>{ + if (typeof s !== "string" || s.length % 2) + throw new TypeError(`hex.decode: expected string, got ${typeof s} with length ${s.length}`); + return s.toLowerCase(); + } + )); + var CODERS = { + utf8, + hex, + base16, + base32, + base64, + base64url, + base58, + base58xmr + }; + var coderTypeError = `Invalid encoding type. Available types: ${Object.keys(CODERS).join(", ")}`; + + // node_modules/.pnpm/nostr-tools@1.1.0/node_modules/nostr-tools/lib/nostr.esm.js + var import_english = __toESM(require_english()); + var import_bip39 = __toESM(require_bip39()); + + // node_modules/.pnpm/@noble+hashes@1.3.0/node_modules/@noble/hashes/esm/_assert.js + function number(n) { + if (!Number.isSafeInteger(n) || n < 0) + throw new Error(`Wrong positive integer: ${n}`); + } + function bool(b) { + if (typeof b !== "boolean") + throw new Error(`Expected boolean, not ${b}`); + } + function bytes(b, ...lengths) { + if (!(b instanceof Uint8Array)) + throw new TypeError("Expected Uint8Array"); + if (lengths.length > 0 && !lengths.includes(b.length)) + throw new TypeError(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`); + } + function hash(hash2) { + if (typeof hash2 !== "function" || typeof hash2.create !== "function") + throw new Error("Hash should be wrapped by utils.wrapConstructor"); + number(hash2.outputLen); + number(hash2.blockLen); + } + function exists(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 output(out, instance) { + bytes(out); + const min = instance.outputLen; + if (out.length < min) { + throw new Error(`digestInto() expects output buffer of length at least ${min}`); + } + } + var assert = { + number, + bool, + bytes, + hash, + exists, + output + }; + var assert_default = assert; + + // node_modules/.pnpm/@noble+hashes@1.3.0/node_modules/@noble/hashes/esm/crypto.js + var crypto4 = typeof globalThis === "object" && "crypto"in globalThis ? globalThis.crypto : void 0; + + // node_modules/.pnpm/@noble+hashes@1.3.0/node_modules/@noble/hashes/esm/utils.js + var createView2 = (arr)=>new DataView(arr.buffer,arr.byteOffset,arr.byteLength); + var rotr2 = (word,shift)=>word << 32 - shift | word >>> shift; + var isLE2 = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68; + if (!isLE2) + throw new Error("Non little-endian hardware is not supported"); + var hexes3 = Array.from({ + length: 256 + }, (v,i)=>i.toString(16).padStart(2, "0")); + function bytesToHex2(uint8a) { + if (!(uint8a instanceof Uint8Array)) + throw new Error("Uint8Array expected"); + let hex2 = ""; + for (let i = 0; i < uint8a.length; i++) { + hex2 += hexes3[uint8a[i]]; + } + return hex2; + } + function hexToBytes2(hex2) { + if (typeof hex2 !== "string") { + throw new TypeError("hexToBytes: expected string, got " + typeof hex2); + } + if (hex2.length % 2) + throw new Error("hexToBytes: received invalid unpadded hex"); + const array = new Uint8Array(hex2.length / 2); + for (let i = 0; i < array.length; i++) { + const j = i * 2; + const hexByte = hex2.slice(j, j + 2); + const byte = Number.parseInt(hexByte, 16); + if (Number.isNaN(byte) || byte < 0) + throw new Error("Invalid byte sequence"); + array[i] = byte; + } + return array; + } + function utf8ToBytes2(str) { + if (typeof str !== "string") { + throw new TypeError(`utf8ToBytes expected string, got ${typeof str}`); + } + return new TextEncoder().encode(str); + } + function toBytes2(data) { + if (typeof data === "string") + data = utf8ToBytes2(data); + if (!(data instanceof Uint8Array)) + throw new TypeError(`Expected input type is Uint8Array (got ${typeof data})`); + return data; + } + function concatBytes2(...arrays) { + if (!arrays.every((a)=>a instanceof Uint8Array)) + throw new Error("Uint8Array list expected"); + if (arrays.length === 1) + return arrays[0]; + const length = arrays.reduce((a,arr)=>a + arr.length, 0); + const result = new Uint8Array(length); + for (let i = 0, pad = 0; i < arrays.length; i++) { + const arr = arrays[i]; + result.set(arr, pad); + pad += arr.length; + } + return result; + } + var Hash2 = class { + // Safe version that clones internal state + clone() { + return this._cloneInto(); + } + } + ; + function wrapConstructor2(hashConstructor) { + const hashC = (message)=>hashConstructor().update(toBytes2(message)).digest(); + const tmp = hashConstructor(); + hashC.outputLen = tmp.outputLen; + hashC.blockLen = tmp.blockLen; + hashC.create = ()=>hashConstructor(); + return hashC; + } + function randomBytes2(bytesLength=32) { + if (crypto4 && typeof crypto4.getRandomValues === "function") { + return crypto4.getRandomValues(new Uint8Array(bytesLength)); + } + throw new Error("crypto.getRandomValues must be defined"); + } + + // node_modules/.pnpm/@noble+hashes@1.3.0/node_modules/@noble/hashes/esm/hmac.js + var HMAC = class extends Hash2 { + constructor(hash2, _key) { + super(); + this.finished = false; + this.destroyed = false; + assert_default.hash(hash2); + const key = toBytes2(_key); + this.iHash = hash2.create(); + if (typeof this.iHash.update !== "function") + throw new TypeError("Expected instance of class which extends utils.Hash"); + this.blockLen = this.iHash.blockLen; + this.outputLen = this.iHash.outputLen; + const blockLen = this.blockLen; + const pad = new Uint8Array(blockLen); + pad.set(key.length > blockLen ? hash2.create().update(key).digest() : key); + for (let i = 0; i < pad.length; i++) + pad[i] ^= 54; + this.iHash.update(pad); + this.oHash = hash2.create(); + for (let i = 0; i < pad.length; i++) + pad[i] ^= 54 ^ 92; + this.oHash.update(pad); + pad.fill(0); + } + update(buf) { + assert_default.exists(this); + this.iHash.update(buf); + return this; + } + digestInto(out) { + assert_default.exists(this); + assert_default.bytes(out, this.outputLen); + 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 || (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; + } + destroy() { + this.destroyed = true; + this.oHash.destroy(); + this.iHash.destroy(); + } + } + ; + var hmac = (hash2,key,message)=>new HMAC(hash2,key).update(message).digest(); + hmac.create = (hash2,key)=>new HMAC(hash2,key); + + // node_modules/.pnpm/@noble+hashes@1.3.0/node_modules/@noble/hashes/esm/_sha2.js + function setBigUint642(view, byteOffset, value, isLE3) { + if (typeof view.setBigUint64 === "function") + return view.setBigUint64(byteOffset, value, isLE3); + const _32n2 = BigInt(32); + const _u32_max = BigInt(4294967295); + const wh = Number(value >> _32n2 & _u32_max); + const wl = Number(value & _u32_max); + const h = isLE3 ? 4 : 0; + const l = isLE3 ? 0 : 4; + view.setUint32(byteOffset + h, wh, isLE3); + view.setUint32(byteOffset + l, wl, isLE3); + } + var SHA22 = class extends Hash2 { + constructor(blockLen, outputLen, padOffset, isLE3) { + super(); + this.blockLen = blockLen; + this.outputLen = outputLen; + this.padOffset = padOffset; + this.isLE = isLE3; + this.finished = false; + this.length = 0; + this.pos = 0; + this.destroyed = false; + this.buffer = new Uint8Array(blockLen); + this.view = createView2(this.buffer); + } + update(data) { + assert_default.exists(this); + const {view, buffer, blockLen} = this; + data = toBytes2(data); + const len = data.length; + for (let pos = 0; pos < len; ) { + const take = Math.min(blockLen - this.pos, len - pos); + if (take === blockLen) { + const dataView = createView2(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) { + assert_default.exists(this); + assert_default.output(out, this); + this.finished = true; + const {buffer, view, blockLen, isLE: isLE3} = this; + let {pos} = this; + buffer[pos++] = 128; + this.buffer.subarray(pos).fill(0); + if (this.padOffset > blockLen - pos) { + this.process(view, 0); + pos = 0; + } + for (let i = pos; i < blockLen; i++) + buffer[i] = 0; + setBigUint642(view, blockLen - 8, BigInt(this.length * 8), isLE3); + this.process(view, 0); + const oview = createView2(out); + const len = this.outputLen; + if (len % 4) + throw new Error("_sha2: outputLen should 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 || (to = new this.constructor()); + to.set(...this.get()); + const {blockLen, buffer, length, finished, destroyed, pos} = this; + to.length = length; + to.pos = pos; + to.finished = finished; + to.destroyed = destroyed; + if (length % blockLen) + to.buffer.set(buffer); + return to; + } + } + ; + + // node_modules/.pnpm/@noble+hashes@1.3.0/node_modules/@noble/hashes/esm/ripemd160.js + var Rho = new Uint8Array([7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8]); + var Id = Uint8Array.from({ + length: 16 + }, (_,i)=>i); + var Pi = Id.map((i)=>(9 * i + 5) % 16); + var idxL = [Id]; + var idxR = [Pi]; + for (let i = 0; i < 4; i++) + for (let j of [idxL, idxR]) + j.push(j[i].map((k)=>Rho[k])); + var shifts = [[11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8], [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7], [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9], [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6], [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5]].map((i)=>new Uint8Array(i)); + var shiftsL = idxL.map((idx,i)=>idx.map((j)=>shifts[i][j])); + var shiftsR = idxR.map((idx,i)=>idx.map((j)=>shifts[i][j])); + var Kl = new Uint32Array([0, 1518500249, 1859775393, 2400959708, 2840853838]); + var Kr = new Uint32Array([1352829926, 1548603684, 1836072691, 2053994217, 0]); + var rotl = (word,shift)=>word << shift | word >>> 32 - shift; + function f(group, x, y, z) { + if (group === 0) + return x ^ y ^ z; + else if (group === 1) + return x & y | ~x & z; + else if (group === 2) + return (x | ~y) ^ z; + else if (group === 3) + return x & z | y & ~z; + else + return x ^ (y | ~z); + } + var BUF = new Uint32Array(16); + var RIPEMD160 = class extends SHA22 { + constructor() { + super(64, 20, 8, true); + this.h0 = 1732584193 | 0; + this.h1 = 4023233417 | 0; + this.h2 = 2562383102 | 0; + this.h3 = 271733878 | 0; + this.h4 = 3285377520 | 0; + } + get() { + const {h0, h1, h2, h3, h4} = this; + return [h0, h1, h2, h3, h4]; + } + set(h0, h1, h2, h3, h4) { + this.h0 = h0 | 0; + this.h1 = h1 | 0; + this.h2 = h2 | 0; + this.h3 = h3 | 0; + this.h4 = h4 | 0; + } + process(view, offset) { + for (let i = 0; i < 16; i++, + offset += 4) + BUF[i] = view.getUint32(offset, true); + let al = this.h0 | 0 + , ar = al + , bl = this.h1 | 0 + , br = bl + , cl = this.h2 | 0 + , cr = cl + , dl = this.h3 | 0 + , dr = dl + , el = this.h4 | 0 + , er = el; + for (let group = 0; group < 5; group++) { + const rGroup = 4 - group; + const hbl = Kl[group] + , hbr = Kr[group]; + const rl = idxL[group] + , rr = idxR[group]; + const sl = shiftsL[group] + , sr = shiftsR[group]; + for (let i = 0; i < 16; i++) { + const tl = rotl(al + f(group, bl, cl, dl) + BUF[rl[i]] + hbl, sl[i]) + el | 0; + al = el, + el = dl, + dl = rotl(cl, 10) | 0, + cl = bl, + bl = tl; + } + for (let i = 0; i < 16; i++) { + const tr = rotl(ar + f(rGroup, br, cr, dr) + BUF[rr[i]] + hbr, sr[i]) + er | 0; + ar = er, + er = dr, + dr = rotl(cr, 10) | 0, + cr = br, + br = tr; + } + } + this.set(this.h1 + cl + dr | 0, this.h2 + dl + er | 0, this.h3 + el + ar | 0, this.h4 + al + br | 0, this.h0 + bl + cr | 0); + } + roundClean() { + BUF.fill(0); + } + destroy() { + this.destroyed = true; + this.buffer.fill(0); + this.set(0, 0, 0, 0, 0); + } + } + ; + var ripemd160 = wrapConstructor2(()=>new RIPEMD160()); + + // node_modules/.pnpm/@noble+hashes@1.3.0/node_modules/@noble/hashes/esm/sha256.js + var Chi2 = (a,b,c)=>a & b ^ ~a & c; + var Maj2 = (a,b,c)=>a & b ^ a & c ^ b & c; + var SHA256_K2 = new Uint32Array([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 IV2 = new Uint32Array([1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225]); + var SHA256_W2 = new Uint32Array(64); + var SHA2562 = class extends SHA22 { + constructor() { + super(64, 32, 8, false); + this.A = IV2[0] | 0; + this.B = IV2[1] | 0; + this.C = IV2[2] | 0; + this.D = IV2[3] | 0; + this.E = IV2[4] | 0; + this.F = IV2[5] | 0; + this.G = IV2[6] | 0; + this.H = IV2[7] | 0; + } + 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_W2[i] = view.getUint32(offset, false); + for (let i = 16; i < 64; i++) { + const W15 = SHA256_W2[i - 15]; + const W2 = SHA256_W2[i - 2]; + const s0 = rotr2(W15, 7) ^ rotr2(W15, 18) ^ W15 >>> 3; + const s1 = rotr2(W2, 17) ^ rotr2(W2, 19) ^ W2 >>> 10; + SHA256_W2[i] = s1 + SHA256_W2[i - 7] + s0 + SHA256_W2[i - 16] | 0; + } + let {A, B, C, D, E, F, G, H} = this; + for (let i = 0; i < 64; i++) { + const sigma1 = rotr2(E, 6) ^ rotr2(E, 11) ^ rotr2(E, 25); + const T1 = H + sigma1 + Chi2(E, F, G) + SHA256_K2[i] + SHA256_W2[i] | 0; + const sigma0 = rotr2(A, 2) ^ rotr2(A, 13) ^ rotr2(A, 22); + const T2 = sigma0 + Maj2(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() { + SHA256_W2.fill(0); + } + destroy() { + this.set(0, 0, 0, 0, 0, 0, 0, 0); + this.buffer.fill(0); + } + } + ; + var SHA224 = class extends SHA2562 { + constructor() { + super(); + this.A = 3238371032 | 0; + this.B = 914150663 | 0; + this.C = 812702999 | 0; + this.D = 4144912697 | 0; + this.E = 4290775857 | 0; + this.F = 1750603025 | 0; + this.G = 1694076839 | 0; + this.H = 3204075428 | 0; + this.outputLen = 28; + } + } + ; + var sha2562 = wrapConstructor2(()=>new SHA2562()); + var sha224 = wrapConstructor2(()=>new SHA224()); + + // node_modules/.pnpm/@noble+hashes@1.3.0/node_modules/@noble/hashes/esm/_u64.js + var U32_MASK64 = BigInt(2 ** 32 - 1); + var _32n = BigInt(32); + function fromBig(n, le=false) { + if (le) + return { + h: Number(n & U32_MASK64), + l: Number(n >> _32n & U32_MASK64) + }; + return { + h: Number(n >> _32n & U32_MASK64) | 0, + l: Number(n & U32_MASK64) | 0 + }; + } + function split(lst, le=false) { + let Ah = new Uint32Array(lst.length); + let Al = new Uint32Array(lst.length); + for (let i = 0; i < lst.length; i++) { + const {h, l} = fromBig(lst[i], le); + [Ah[i],Al[i]] = [h, l]; + } + return [Ah, Al]; + } + var toBig = (h,l)=>BigInt(h >>> 0) << _32n | BigInt(l >>> 0); + var shrSH = (h,l,s)=>h >>> s; + var shrSL = (h,l,s)=>h << 32 - s | l >>> s; + var rotrSH = (h,l,s)=>h >>> s | l << 32 - s; + var rotrSL = (h,l,s)=>h << 32 - s | l >>> s; + var rotrBH = (h,l,s)=>h << 64 - s | l >>> s - 32; + var rotrBL = (h,l,s)=>h >>> s - 32 | l << 64 - s; + var rotr32H = (h,l)=>l; + var rotr32L = (h,l)=>h; + var rotlSH = (h,l,s)=>h << s | l >>> 32 - s; + var rotlSL = (h,l,s)=>l << s | h >>> 32 - s; + var rotlBH = (h,l,s)=>l << s - 32 | h >>> 64 - s; + var rotlBL = (h,l,s)=>h << s - 32 | l >>> 64 - s; + function add(Ah, Al, Bh, Bl) { + const l = (Al >>> 0) + (Bl >>> 0); + return { + h: Ah + Bh + (l / 2 ** 32 | 0) | 0, + l: l | 0 + }; + } + var add3L = (Al,Bl,Cl)=>(Al >>> 0) + (Bl >>> 0) + (Cl >>> 0); + var add3H = (low,Ah,Bh,Ch)=>Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0; + var add4L = (Al,Bl,Cl,Dl)=>(Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0); + var add4H = (low,Ah,Bh,Ch,Dh)=>Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0; + var add5L = (Al,Bl,Cl,Dl,El)=>(Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0); + var add5H = (low,Ah,Bh,Ch,Dh,Eh)=>Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0; + var u64 = { + fromBig, + split, + toBig, + shrSH, + shrSL, + rotrSH, + rotrSL, + rotrBH, + rotrBL, + rotr32H, + rotr32L, + rotlSH, + rotlSL, + rotlBH, + rotlBL, + add, + add3L, + add3H, + add4L, + add4H, + add5H, + add5L + }; + var u64_default = u64; + + // node_modules/.pnpm/@noble+hashes@1.3.0/node_modules/@noble/hashes/esm/sha512.js + var [SHA512_Kh,SHA512_Kl] = u64_default.split(["0x428a2f98d728ae22", "0x7137449123ef65cd", "0xb5c0fbcfec4d3b2f", "0xe9b5dba58189dbbc", "0x3956c25bf348b538", "0x59f111f1b605d019", "0x923f82a4af194f9b", "0xab1c5ed5da6d8118", "0xd807aa98a3030242", "0x12835b0145706fbe", "0x243185be4ee4b28c", "0x550c7dc3d5ffb4e2", "0x72be5d74f27b896f", "0x80deb1fe3b1696b1", "0x9bdc06a725c71235", "0xc19bf174cf692694", "0xe49b69c19ef14ad2", "0xefbe4786384f25e3", "0x0fc19dc68b8cd5b5", "0x240ca1cc77ac9c65", "0x2de92c6f592b0275", "0x4a7484aa6ea6e483", "0x5cb0a9dcbd41fbd4", "0x76f988da831153b5", "0x983e5152ee66dfab", "0xa831c66d2db43210", "0xb00327c898fb213f", "0xbf597fc7beef0ee4", "0xc6e00bf33da88fc2", "0xd5a79147930aa725", "0x06ca6351e003826f", "0x142929670a0e6e70", "0x27b70a8546d22ffc", "0x2e1b21385c26c926", "0x4d2c6dfc5ac42aed", "0x53380d139d95b3df", "0x650a73548baf63de", "0x766a0abb3c77b2a8", "0x81c2c92e47edaee6", "0x92722c851482353b", "0xa2bfe8a14cf10364", "0xa81a664bbc423001", "0xc24b8b70d0f89791", "0xc76c51a30654be30", "0xd192e819d6ef5218", "0xd69906245565a910", "0xf40e35855771202a", "0x106aa07032bbd1b8", "0x19a4c116b8d2d0c8", "0x1e376c085141ab53", "0x2748774cdf8eeb99", "0x34b0bcb5e19b48a8", "0x391c0cb3c5c95a63", "0x4ed8aa4ae3418acb", "0x5b9cca4f7763e373", "0x682e6ff3d6b2b8a3", "0x748f82ee5defb2fc", "0x78a5636f43172f60", "0x84c87814a1f0ab72", "0x8cc702081a6439ec", "0x90befffa23631e28", "0xa4506cebde82bde9", "0xbef9a3f7b2c67915", "0xc67178f2e372532b", "0xca273eceea26619c", "0xd186b8c721c0c207", "0xeada7dd6cde0eb1e", "0xf57d4f7fee6ed178", "0x06f067aa72176fba", "0x0a637dc5a2c898a6", "0x113f9804bef90dae", "0x1b710b35131c471b", "0x28db77f523047d84", "0x32caab7b40c72493", "0x3c9ebe0a15c9bebc", "0x431d67c49c100d4c", "0x4cc5d4becb3e42b6", "0x597f299cfc657e2a", "0x5fcb6fab3ad6faec", "0x6c44198c4a475817"].map((n)=>BigInt(n))); + var SHA512_W_H = new Uint32Array(80); + var SHA512_W_L = new Uint32Array(80); + var SHA512 = class extends SHA22 { + constructor() { + super(128, 64, 16, false); + this.Ah = 1779033703 | 0; + this.Al = 4089235720 | 0; + this.Bh = 3144134277 | 0; + this.Bl = 2227873595 | 0; + this.Ch = 1013904242 | 0; + this.Cl = 4271175723 | 0; + this.Dh = 2773480762 | 0; + this.Dl = 1595750129 | 0; + this.Eh = 1359893119 | 0; + this.El = 2917565137 | 0; + this.Fh = 2600822924 | 0; + this.Fl = 725511199 | 0; + this.Gh = 528734635 | 0; + this.Gl = 4215389547 | 0; + this.Hh = 1541459225 | 0; + this.Hl = 327033209 | 0; + } + // prettier-ignore + get() { + const {Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl} = this; + return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl]; + } + // prettier-ignore + set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) { + this.Ah = Ah | 0; + this.Al = Al | 0; + this.Bh = Bh | 0; + this.Bl = Bl | 0; + this.Ch = Ch | 0; + this.Cl = Cl | 0; + this.Dh = Dh | 0; + this.Dl = Dl | 0; + this.Eh = Eh | 0; + this.El = El | 0; + this.Fh = Fh | 0; + this.Fl = Fl | 0; + this.Gh = Gh | 0; + this.Gl = Gl | 0; + this.Hh = Hh | 0; + this.Hl = Hl | 0; + } + process(view, offset) { + for (let i = 0; i < 16; i++, + offset += 4) { + SHA512_W_H[i] = view.getUint32(offset); + SHA512_W_L[i] = view.getUint32(offset += 4); + } + for (let i = 16; i < 80; i++) { + const W15h = SHA512_W_H[i - 15] | 0; + const W15l = SHA512_W_L[i - 15] | 0; + const s0h = u64_default.rotrSH(W15h, W15l, 1) ^ u64_default.rotrSH(W15h, W15l, 8) ^ u64_default.shrSH(W15h, W15l, 7); + const s0l = u64_default.rotrSL(W15h, W15l, 1) ^ u64_default.rotrSL(W15h, W15l, 8) ^ u64_default.shrSL(W15h, W15l, 7); + const W2h = SHA512_W_H[i - 2] | 0; + const W2l = SHA512_W_L[i - 2] | 0; + const s1h = u64_default.rotrSH(W2h, W2l, 19) ^ u64_default.rotrBH(W2h, W2l, 61) ^ u64_default.shrSH(W2h, W2l, 6); + const s1l = u64_default.rotrSL(W2h, W2l, 19) ^ u64_default.rotrBL(W2h, W2l, 61) ^ u64_default.shrSL(W2h, W2l, 6); + const SUMl = u64_default.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]); + const SUMh = u64_default.add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]); + SHA512_W_H[i] = SUMh | 0; + SHA512_W_L[i] = SUMl | 0; + } + let {Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl} = this; + for (let i = 0; i < 80; i++) { + const sigma1h = u64_default.rotrSH(Eh, El, 14) ^ u64_default.rotrSH(Eh, El, 18) ^ u64_default.rotrBH(Eh, El, 41); + const sigma1l = u64_default.rotrSL(Eh, El, 14) ^ u64_default.rotrSL(Eh, El, 18) ^ u64_default.rotrBL(Eh, El, 41); + const CHIh = Eh & Fh ^ ~Eh & Gh; + const CHIl = El & Fl ^ ~El & Gl; + const T1ll = u64_default.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]); + const T1h = u64_default.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]); + const T1l = T1ll | 0; + const sigma0h = u64_default.rotrSH(Ah, Al, 28) ^ u64_default.rotrBH(Ah, Al, 34) ^ u64_default.rotrBH(Ah, Al, 39); + const sigma0l = u64_default.rotrSL(Ah, Al, 28) ^ u64_default.rotrBL(Ah, Al, 34) ^ u64_default.rotrBL(Ah, Al, 39); + const MAJh = Ah & Bh ^ Ah & Ch ^ Bh & Ch; + const MAJl = Al & Bl ^ Al & Cl ^ Bl & Cl; + Hh = Gh | 0; + Hl = Gl | 0; + Gh = Fh | 0; + Gl = Fl | 0; + Fh = Eh | 0; + Fl = El | 0; + ({h: Eh, l: El} = u64_default.add(Dh | 0, Dl | 0, T1h | 0, T1l | 0)); + Dh = Ch | 0; + Dl = Cl | 0; + Ch = Bh | 0; + Cl = Bl | 0; + Bh = Ah | 0; + Bl = Al | 0; + const All = u64_default.add3L(T1l, sigma0l, MAJl); + Ah = u64_default.add3H(All, T1h, sigma0h, MAJh); + Al = All | 0; + } + ({h: Ah, l: Al} = u64_default.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0)); + ({h: Bh, l: Bl} = u64_default.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0)); + ({h: Ch, l: Cl} = u64_default.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0)); + ({h: Dh, l: Dl} = u64_default.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0)); + ({h: Eh, l: El} = u64_default.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0)); + ({h: Fh, l: Fl} = u64_default.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0)); + ({h: Gh, l: Gl} = u64_default.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0)); + ({h: Hh, l: Hl} = u64_default.add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0)); + this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl); + } + roundClean() { + SHA512_W_H.fill(0); + SHA512_W_L.fill(0); + } + destroy() { + this.buffer.fill(0); + this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); + } + } + ; + var SHA512_224 = class extends SHA512 { + constructor() { + super(); + this.Ah = 2352822216 | 0; + this.Al = 424955298 | 0; + this.Bh = 1944164710 | 0; + this.Bl = 2312950998 | 0; + this.Ch = 502970286 | 0; + this.Cl = 855612546 | 0; + this.Dh = 1738396948 | 0; + this.Dl = 1479516111 | 0; + this.Eh = 258812777 | 0; + this.El = 2077511080 | 0; + this.Fh = 2011393907 | 0; + this.Fl = 79989058 | 0; + this.Gh = 1067287976 | 0; + this.Gl = 1780299464 | 0; + this.Hh = 286451373 | 0; + this.Hl = 2446758561 | 0; + this.outputLen = 28; + } + } + ; + var SHA512_256 = class extends SHA512 { + constructor() { + super(); + this.Ah = 573645204 | 0; + this.Al = 4230739756 | 0; + this.Bh = 2673172387 | 0; + this.Bl = 3360449730 | 0; + this.Ch = 596883563 | 0; + this.Cl = 1867755857 | 0; + this.Dh = 2520282905 | 0; + this.Dl = 1497426621 | 0; + this.Eh = 2519219938 | 0; + this.El = 2827943907 | 0; + this.Fh = 3193839141 | 0; + this.Fl = 1401305490 | 0; + this.Gh = 721525244 | 0; + this.Gl = 746961066 | 0; + this.Hh = 246885852 | 0; + this.Hl = 2177182882 | 0; + this.outputLen = 32; + } + } + ; + var SHA384 = class extends SHA512 { + constructor() { + super(); + this.Ah = 3418070365 | 0; + this.Al = 3238371032 | 0; + this.Bh = 1654270250 | 0; + this.Bl = 914150663 | 0; + this.Ch = 2438529370 | 0; + this.Cl = 812702999 | 0; + this.Dh = 355462360 | 0; + this.Dl = 4144912697 | 0; + this.Eh = 1731405415 | 0; + this.El = 4290775857 | 0; + this.Fh = 2394180231 | 0; + this.Fl = 1750603025 | 0; + this.Gh = 3675008525 | 0; + this.Gl = 1694076839 | 0; + this.Hh = 1203062813 | 0; + this.Hl = 3204075428 | 0; + this.outputLen = 48; + } + } + ; + var sha512 = wrapConstructor2(()=>new SHA512()); + var sha512_224 = wrapConstructor2(()=>new SHA512_224()); + var sha512_256 = wrapConstructor2(()=>new SHA512_256()); + var sha384 = wrapConstructor2(()=>new SHA384()); + + // node_modules/.pnpm/@noble+curves@1.0.0/node_modules/@noble/curves/esm/abstract/utils.js + var utils_exports = {}; + __export(utils_exports, { + bitGet: ()=>bitGet, + bitLen: ()=>bitLen, + bitMask: ()=>bitMask, + bitSet: ()=>bitSet, + bytesToHex: ()=>bytesToHex3, + bytesToNumberBE: ()=>bytesToNumberBE, + bytesToNumberLE: ()=>bytesToNumberLE, + concatBytes: ()=>concatBytes3, + createHmacDrbg: ()=>createHmacDrbg, + ensureBytes: ()=>ensureBytes2, + equalBytes: ()=>equalBytes, + hexToBytes: ()=>hexToBytes3, + hexToNumber: ()=>hexToNumber2, + numberToBytesBE: ()=>numberToBytesBE, + numberToBytesLE: ()=>numberToBytesLE, + numberToHexUnpadded: ()=>numberToHexUnpadded2, + numberToVarBytesBE: ()=>numberToVarBytesBE, + utf8ToBytes: ()=>utf8ToBytes3, + validateObject: ()=>validateObject + }); + var _0n2 = BigInt(0); + var _1n2 = BigInt(1); + var _2n2 = BigInt(2); + var u8a = (a)=>a instanceof Uint8Array; + var hexes4 = Array.from({ + length: 256 + }, (v,i)=>i.toString(16).padStart(2, "0")); + function bytesToHex3(bytes2) { + if (!u8a(bytes2)) + throw new Error("Uint8Array expected"); + let hex2 = ""; + for (let i = 0; i < bytes2.length; i++) { + hex2 += hexes4[bytes2[i]]; + } + return hex2; + } + function numberToHexUnpadded2(num) { + const hex2 = num.toString(16); + return hex2.length & 1 ? `0 ${hex2}` : hex2; + } + function hexToNumber2(hex2) { + if (typeof hex2 !== "string") + throw new Error("hex string expected, got " + typeof hex2); + return BigInt(hex2 === "" ? "0" : `0x ${hex2}`); + } + function hexToBytes3(hex2) { + if (typeof hex2 !== "string") + throw new Error("hex string expected, got " + typeof hex2); + if (hex2.length % 2) + throw new Error("hex string is invalid: unpadded " + hex2.length); + const array = new Uint8Array(hex2.length / 2); + for (let i = 0; i < array.length; i++) { + const j = i * 2; + const hexByte = hex2.slice(j, j + 2); + const byte = Number.parseInt(hexByte, 16); + if (Number.isNaN(byte) || byte < 0) + throw new Error("invalid byte sequence"); + array[i] = byte; + } + return array; + } + function bytesToNumberBE(bytes2) { + return hexToNumber2(bytesToHex3(bytes2)); + } + function bytesToNumberLE(bytes2) { + if (!u8a(bytes2)) + throw new Error("Uint8Array expected"); + return hexToNumber2(bytesToHex3(Uint8Array.from(bytes2).reverse())); + } + var numberToBytesBE = (n,len)=>hexToBytes3(n.toString(16).padStart(len * 2, "0")); + var numberToBytesLE = (n,len)=>numberToBytesBE(n, len).reverse(); + var numberToVarBytesBE = (n)=>hexToBytes3(numberToHexUnpadded2(n)); + function ensureBytes2(title, hex2, expectedLength) { + let res; + if (typeof hex2 === "string") { + try { + res = hexToBytes3(hex2); + } catch (e) { + throw new Error(`${title} must be valid hex string, got "${hex2}". Cause: ${e}`); + } + } else if (u8a(hex2)) { + res = Uint8Array.from(hex2); + } else { + throw new Error(`${title} must be hex string or Uint8Array`); + } + const len = res.length; + if (typeof expectedLength === "number" && len !== expectedLength) + throw new Error(`${title} expected ${expectedLength} bytes, got ${len}`); + return res; + } + function concatBytes3(...arrs) { + const r = new Uint8Array(arrs.reduce((sum,a)=>sum + a.length, 0)); + let pad = 0; + arrs.forEach((a)=>{ + if (!u8a(a)) + throw new Error("Uint8Array expected"); + r.set(a, pad); + pad += a.length; + } + ); + return r; + } + function equalBytes(b1, b2) { + if (b1.length !== b2.length) + return false; + for (let i = 0; i < b1.length; i++) + if (b1[i] !== b2[i]) + return false; + return true; + } + function utf8ToBytes3(str) { + if (typeof str !== "string") { + throw new Error(`utf8ToBytes expected string, got ${typeof str}`); + } + return new TextEncoder().encode(str); + } + function bitLen(n) { + let len; + for (len = 0; n > _0n2; n >>= _1n2, + len += 1) + ; + return len; + } + var bitGet = (n,pos)=>n >> BigInt(pos) & _1n2; + var bitSet = (n,pos,value)=>n | (value ? _1n2 : _0n2) << BigInt(pos); + var bitMask = (n)=>(_2n2 << BigInt(n - 1)) - _1n2; + var u8n = (data)=>new Uint8Array(data); + var u8fr = (arr)=>Uint8Array.from(arr); + function createHmacDrbg(hashLen, qByteLen, hmacFn) { + if (typeof hashLen !== "number" || hashLen < 2) + throw new Error("hashLen must be a number"); + if (typeof qByteLen !== "number" || qByteLen < 2) + throw new Error("qByteLen must be a number"); + if (typeof hmacFn !== "function") + throw new Error("hmacFn must be a function"); + let v = u8n(hashLen); + let k = u8n(hashLen); + let i = 0; + const reset = ()=>{ + v.fill(1); + k.fill(0); + i = 0; + } + ; + const h = (...b)=>hmacFn(k, v, ...b); + const reseed = (seed=u8n())=>{ + k = h(u8fr([0]), seed); + v = h(); + if (seed.length === 0) + return; + k = h(u8fr([1]), seed); + v = h(); + } + ; + const gen = ()=>{ + if (i++ >= 1e3) + throw new Error("drbg: tried 1000 values"); + let len = 0; + const out = []; + while (len < qByteLen) { + v = h(); + const sl = v.slice(); + out.push(sl); + len += v.length; + } + return concatBytes3(...out); + } + ; + const genUntil = (seed,pred)=>{ + reset(); + reseed(seed); + let res = void 0; + while (!(res = pred(gen()))) + reseed(); + reset(); + return res; + } + ; + return genUntil; + } + var validatorFns = { + bigint: (val)=>typeof val === "bigint", + function: (val)=>typeof val === "function", + boolean: (val)=>typeof val === "boolean", + string: (val)=>typeof val === "string", + isSafeInteger: (val)=>Number.isSafeInteger(val), + array: (val)=>Array.isArray(val), + field: (val,object)=>object.Fp.isValid(val), + hash: (val)=>typeof val === "function" && Number.isSafeInteger(val.outputLen) + }; + function validateObject(object, validators, optValidators={}) { + const checkField = (fieldName,type,isOptional)=>{ + const checkVal = validatorFns[type]; + if (typeof checkVal !== "function") + throw new Error(`Invalid validator "${type}", expected function`); + const val = object[fieldName]; + if (isOptional && val === void 0) + return; + if (!checkVal(val, object)) { + throw new Error(`Invalid param ${String(fieldName)}=${val} (${typeof val}), expected ${type}`); + } + } + ; + for (const [fieldName,type] of Object.entries(validators)) + checkField(fieldName, type, false); + for (const [fieldName,type] of Object.entries(optValidators)) + checkField(fieldName, type, true); + return object; + } + + // node_modules/.pnpm/@noble+curves@1.0.0/node_modules/@noble/curves/esm/abstract/modular.js + var _0n3 = BigInt(0); + var _1n3 = BigInt(1); + var _2n3 = BigInt(2); + var _3n2 = BigInt(3); + var _4n = BigInt(4); + var _5n = BigInt(5); + var _8n2 = BigInt(8); + var _9n = BigInt(9); + var _16n = BigInt(16); + function mod2(a, b) { + const result = a % b; + return result >= _0n3 ? result : b + result; + } + function pow(num, power, modulo) { + if (modulo <= _0n3 || power < _0n3) + throw new Error("Expected power/modulo > 0"); + if (modulo === _1n3) + return _0n3; + let res = _1n3; + while (power > _0n3) { + if (power & _1n3) + res = res * num % modulo; + num = num * num % modulo; + power >>= _1n3; + } + return res; + } + function pow22(x, power, modulo) { + let res = x; + while (power-- > _0n3) { + res *= res; + res %= modulo; + } + return res; + } + function invert2(number2, modulo) { + if (number2 === _0n3 || modulo <= _0n3) { + throw new Error(`invert: expected positive integers, got n=${number2} mod=${modulo}`); + } + let a = mod2(number2, modulo); + let b = modulo; + let x = _0n3 + , y = _1n3 + , u = _1n3 + , v = _0n3; + while (a !== _0n3) { + 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 !== _1n3) + throw new Error("invert: does not exist"); + return mod2(x, modulo); + } + function tonelliShanks(P) { + const legendreC = (P - _1n3) / _2n3; + let Q, S, Z; + for (Q = P - _1n3, + S = 0; Q % _2n3 === _0n3; Q /= _2n3, + S++) + ; + for (Z = _2n3; Z < P && pow(Z, legendreC, P) !== P - _1n3; Z++) + ; + if (S === 1) { + const p1div4 = (P + _1n3) / _4n; + return function tonelliFast(Fp2, n) { + const root = Fp2.pow(n, p1div4); + if (!Fp2.eql(Fp2.sqr(root), n)) + throw new Error("Cannot find square root"); + return root; + } + ; + } + const Q1div2 = (Q + _1n3) / _2n3; + return function tonelliSlow(Fp2, n) { + if (Fp2.pow(n, legendreC) === Fp2.neg(Fp2.ONE)) + throw new Error("Cannot find square root"); + let r = S; + let g = Fp2.pow(Fp2.mul(Fp2.ONE, Z), Q); + let x = Fp2.pow(n, Q1div2); + let b = Fp2.pow(n, Q); + while (!Fp2.eql(b, Fp2.ONE)) { + if (Fp2.eql(b, Fp2.ZERO)) + return Fp2.ZERO; + let m = 1; + for (let t2 = Fp2.sqr(b); m < r; m++) { + if (Fp2.eql(t2, Fp2.ONE)) + break; + t2 = Fp2.sqr(t2); + } + const ge2 = Fp2.pow(g, _1n3 << BigInt(r - m - 1)); + g = Fp2.sqr(ge2); + x = Fp2.mul(x, ge2); + b = Fp2.mul(b, g); + r = m; + } + return x; + } + ; + } + function FpSqrt(P) { + if (P % _4n === _3n2) { + const p1div4 = (P + _1n3) / _4n; + return function sqrt3mod4(Fp2, n) { + const root = Fp2.pow(n, p1div4); + if (!Fp2.eql(Fp2.sqr(root), n)) + throw new Error("Cannot find square root"); + return root; + } + ; + } + if (P % _8n2 === _5n) { + const c1 = (P - _5n) / _8n2; + return function sqrt5mod8(Fp2, n) { + const n2 = Fp2.mul(n, _2n3); + const v = Fp2.pow(n2, c1); + const nv = Fp2.mul(n, v); + const i = Fp2.mul(Fp2.mul(nv, _2n3), v); + const root = Fp2.mul(nv, Fp2.sub(i, Fp2.ONE)); + if (!Fp2.eql(Fp2.sqr(root), n)) + throw new Error("Cannot find square root"); + return root; + } + ; + } + if (P % _16n === _9n) {} + 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", + MASK: "bigint", + BYTES: "isSafeInteger", + BITS: "isSafeInteger" + }; + const opts = FIELD_FIELDS.reduce((map,val)=>{ + map[val] = "function"; + return map; + } + , initial); + return validateObject(field, opts); + } + function FpPow(f2, num, power) { + if (power < _0n3) + throw new Error("Expected power > 0"); + if (power === _0n3) + return f2.ONE; + if (power === _1n3) + return num; + let p = f2.ONE; + let d = num; + while (power > _0n3) { + if (power & _1n3) + p = f2.mul(p, d); + d = f2.sqr(d); + power >>= _1n3; + } + return p; + } + function FpInvertBatch(f2, nums) { + const tmp = new Array(nums.length); + const lastMultiplied = nums.reduce((acc,num,i)=>{ + if (f2.is0(num)) + return acc; + tmp[i] = acc; + return f2.mul(acc, num); + } + , f2.ONE); + const inverted = f2.inv(lastMultiplied); + nums.reduceRight((acc,num,i)=>{ + if (f2.is0(num)) + return acc; + tmp[i] = f2.mul(acc, tmp[i]); + return f2.mul(acc, num); + } + , inverted); + return tmp; + } + function nLength(n, nBitLength) { + const _nBitLength = nBitLength !== void 0 ? nBitLength : n.toString(2).length; + const nByteLength = Math.ceil(_nBitLength / 8); + return { + nBitLength: _nBitLength, + nByteLength + }; + } + function Field(ORDER, bitLen2, isLE3=false, redef={}) { + if (ORDER <= _0n3) + throw new Error(`Expected Fp ORDER > 0, got ${ORDER}`); + const {nBitLength: BITS, nByteLength: BYTES} = nLength(ORDER, bitLen2); + if (BYTES > 2048) + throw new Error("Field lengths over 2048 bytes are not supported"); + const sqrtP = FpSqrt(ORDER); + const f2 = Object.freeze({ + ORDER, + BITS, + BYTES, + MASK: bitMask(BITS), + ZERO: _0n3, + ONE: _1n3, + create: (num)=>mod2(num, ORDER), + isValid: (num)=>{ + if (typeof num !== "bigint") + throw new Error(`Invalid field element: expected bigint, got ${typeof num}`); + return _0n3 <= num && num < ORDER; + } + , + is0: (num)=>num === _0n3, + isOdd: (num)=>(num & _1n3) === _1n3, + neg: (num)=>mod2(-num, ORDER), + eql: (lhs,rhs)=>lhs === rhs, + sqr: (num)=>mod2(num * num, ORDER), + add: (lhs,rhs)=>mod2(lhs + rhs, ORDER), + sub: (lhs,rhs)=>mod2(lhs - rhs, ORDER), + mul: (lhs,rhs)=>mod2(lhs * rhs, ORDER), + pow: (num,power)=>FpPow(f2, num, power), + div: (lhs,rhs)=>mod2(lhs * invert2(rhs, ORDER), ORDER), + // Same as above, but doesn't normalize + sqrN: (num)=>num * num, + addN: (lhs,rhs)=>lhs + rhs, + subN: (lhs,rhs)=>lhs - rhs, + mulN: (lhs,rhs)=>lhs * rhs, + inv: (num)=>invert2(num, ORDER), + sqrt: redef.sqrt || ((n)=>sqrtP(f2, n)), + invertBatch: (lst)=>FpInvertBatch(f2, lst), + // TODO: do we really need constant cmov? + // We don't have const-time bigints anyway, so probably will be not very useful + cmov: (a,b,c)=>c ? b : a, + toBytes: (num)=>isLE3 ? numberToBytesLE(num, BYTES) : numberToBytesBE(num, BYTES), + fromBytes: (bytes2)=>{ + if (bytes2.length !== BYTES) + throw new Error(`Fp.fromBytes: expected ${BYTES}, got ${bytes2.length}`); + return isLE3 ? bytesToNumberLE(bytes2) : bytesToNumberBE(bytes2); + } + }); + return Object.freeze(f2); + } + function hashToPrivateScalar(hash2, groupOrder, isLE3=false) { + hash2 = ensureBytes2("privateHash", hash2); + const hashLen = hash2.length; + const minLen = nLength(groupOrder).nByteLength + 8; + if (minLen < 24 || hashLen < minLen || hashLen > 1024) + throw new Error(`hashToPrivateScalar: expected ${minLen}-1024 bytes of input, got ${hashLen}`); + const num = isLE3 ? bytesToNumberLE(hash2) : bytesToNumberBE(hash2); + return mod2(num, groupOrder - _1n3) + _1n3; + } + + // node_modules/.pnpm/@noble+curves@1.0.0/node_modules/@noble/curves/esm/abstract/curve.js + var _0n4 = BigInt(0); + var _1n4 = BigInt(1); + function wNAF(c, bits) { + const constTimeNegate2 = (condition,item)=>{ + const neg = item.negate(); + return condition ? neg : item; + } + ; + const opts = (W)=>{ + const windows = Math.ceil(bits / W) + 1; + const windowSize = 2 ** (W - 1); + return { + windows, + windowSize + }; + } + ; + return { + constTimeNegate: constTimeNegate2, + // non-const time multiplication ladder + unsafeLadder(elm, n) { + let p = c.ZERO; + let d = elm; + while (n > _0n4) { + if (n & _1n4) + p = p.add(d); + d = d.double(); + n >>= _1n4; + } + 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. + * @returns precomputed point tables flattened to a single array + */ + precomputeWindow(elm, W) { + const {windows, windowSize} = opts(W); + const points = []; + let p = elm; + let base = p; + for (let window = 0; window < windows; window++) { + 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. + * @param W window size + * @param precomputes precomputed tables + * @param n scalar (we don't check here, but should be less than curve order) + * @returns real and fake (for const-time) points + */ + wNAF(W, precomputes, n) { + const {windows, windowSize} = opts(W); + let p = c.ZERO; + let f2 = c.BASE; + const mask = BigInt(2 ** W - 1); + const maxNumber = 2 ** W; + const shiftBy = BigInt(W); + for (let window = 0; window < windows; window++) { + const offset = window * windowSize; + let wbits = Number(n & mask); + n >>= shiftBy; + if (wbits > windowSize) { + wbits -= maxNumber; + n += _1n4; + } + const offset1 = offset; + const offset2 = offset + Math.abs(wbits) - 1; + const cond1 = window % 2 !== 0; + const cond2 = wbits < 0; + if (wbits === 0) { + f2 = f2.add(constTimeNegate2(cond1, precomputes[offset1])); + } else { + p = p.add(constTimeNegate2(cond2, precomputes[offset2])); + } + } + return { + p, + f: f2 + }; + }, + wNAFCached(P, precomputesMap, n, transform) { + const W = P._WINDOW_SIZE || 1; + let comp = precomputesMap.get(P); + if (!comp) { + comp = this.precomputeWindow(P, W); + if (W !== 1) { + precomputesMap.set(P, transform(comp)); + } + } + return this.wNAF(W, comp, n); + } + }; + } + function validateBasic(curve) { + validateField(curve.Fp); + validateObject(curve, { + n: "bigint", + h: "bigint", + Gx: "field", + Gy: "field" + }, { + nBitLength: "isSafeInteger", + nByteLength: "isSafeInteger" + }); + return Object.freeze({ + ...nLength(curve.n, curve.nBitLength), + ...curve, + ...{ + p: curve.Fp.ORDER + } + }); + } + + // node_modules/.pnpm/@noble+curves@1.0.0/node_modules/@noble/curves/esm/abstract/weierstrass.js + function validatePointOpts(curve) { + const opts = validateBasic(curve); + validateObject(opts, { + a: "field", + b: "field" + }, { + allowedPrivateKeyLengths: "array", + wrapPrivateKey: "boolean", + isTorsionFree: "function", + clearCofactor: "function", + allowInfinityPoint: "boolean", + fromBytes: "function", + toBytes: "function" + }); + const {endo: endo2, Fp: Fp2, a} = opts; + if (endo2) { + if (!Fp2.eql(a, Fp2.ZERO)) { + throw new Error("Endomorphism can only be defined for Koblitz curves that have a=0"); + } + if (typeof endo2 !== "object" || typeof endo2.beta !== "bigint" || typeof endo2.splitScalar !== "function") { + throw new Error("Expected endomorphism with beta: bigint and splitScalar: function"); + } + } + return Object.freeze({ + ...opts + }); + } + var {bytesToNumberBE: b2n, hexToBytes: h2b} = utils_exports; + var DER = { + // asn.1 DER encoding utils + Err: class DERErr extends Error { + constructor(m="") { + super(m); + } + } + , + _parseInt(data) { + const {Err: E} = DER; + if (data.length < 2 || data[0] !== 2) + throw new E("Invalid signature integer tag"); + const len = data[1]; + const res = data.subarray(2, len + 2); + if (!len || res.length !== len) + throw new E("Invalid signature integer: wrong length"); + if (res[0] & 128) + throw new E("Invalid signature integer: negative"); + if (res[0] === 0 && !(res[1] & 128)) + throw new E("Invalid signature integer: unnecessary leading zero"); + return { + d: b2n(res), + l: data.subarray(len + 2) + }; + }, + toSig(hex2) { + const {Err: E} = DER; + const data = typeof hex2 === "string" ? h2b(hex2) : hex2; + if (!(data instanceof Uint8Array)) + throw new Error("ui8a expected"); + let l = data.length; + if (l < 2 || data[0] != 48) + throw new E("Invalid signature tag"); + if (data[1] !== l - 2) + throw new E("Invalid signature: incorrect length"); + const {d: r, l: sBytes} = DER._parseInt(data.subarray(2)); + const {d: s, l: rBytesLeft} = DER._parseInt(sBytes); + if (rBytesLeft.length) + throw new E("Invalid signature: left bytes after parsing"); + return { + r, + s + }; + }, + hexFromSig(sig) { + const slice = (s2)=>Number.parseInt(s2[0], 16) & 8 ? "00" + s2 : s2; + const h = (num)=>{ + const hex2 = num.toString(16); + return hex2.length & 1 ? `0 ${hex2}` : hex2; + } + ; + const s = slice(h(sig.s)); + const r = slice(h(sig.r)); + const shl = s.length / 2; + const rhl = r.length / 2; + const sl = h(shl); + const rl = h(rhl); + return `30 ${h(rhl + shl + 4)}02 ${rl}${r}02 ${sl}${s}`; + } + }; + var _0n5 = BigInt(0); + var _1n5 = BigInt(1); + var _2n4 = BigInt(2); + var _3n3 = BigInt(3); + var _4n2 = BigInt(4); + function weierstrassPoints(opts) { + const CURVE2 = validatePointOpts(opts); + const {Fp: Fp2} = CURVE2; + const toBytes3 = CURVE2.toBytes || ((c,point,isCompressed)=>{ + const a = point.toAffine(); + return concatBytes3(Uint8Array.from([4]), Fp2.toBytes(a.x), Fp2.toBytes(a.y)); + } + ); + const fromBytes = CURVE2.fromBytes || ((bytes2)=>{ + const tail = bytes2.subarray(1); + const x = Fp2.fromBytes(tail.subarray(0, Fp2.BYTES)); + const y = Fp2.fromBytes(tail.subarray(Fp2.BYTES, 2 * Fp2.BYTES)); + return { + x, + y + }; + } + ); + function weierstrassEquation(x) { + const {a, b} = CURVE2; + const x2 = Fp2.sqr(x); + const x3 = Fp2.mul(x2, x); + return Fp2.add(Fp2.add(x3, Fp2.mul(x, a)), b); + } + if (!Fp2.eql(Fp2.sqr(CURVE2.Gy), weierstrassEquation(CURVE2.Gx))) + throw new Error("bad generator point: equation left != right"); + function isWithinCurveOrder2(num) { + return typeof num === "bigint" && _0n5 < num && num < CURVE2.n; + } + function assertGE(num) { + if (!isWithinCurveOrder2(num)) + throw new Error("Expected valid bigint: 0 < bigint < curve.n"); + } + function normPrivateKeyToScalar(key) { + const {allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n} = CURVE2; + if (lengths && typeof key !== "bigint") { + if (key instanceof Uint8Array) + key = bytesToHex3(key); + if (typeof key !== "string" || !lengths.includes(key.length)) + throw new Error("Invalid key"); + key = key.padStart(nByteLength * 2, "0"); + } + let num; + try { + num = typeof key === "bigint" ? key : bytesToNumberBE(ensureBytes2("private key", key, nByteLength)); + } catch (error) { + throw new Error(`private key must be ${nByteLength} bytes, hex or bigint, not ${typeof key}`); + } + if (wrapPrivateKey) + num = mod2(num, n); + assertGE(num); + return num; + } + const pointPrecomputes2 = /* @__PURE__ */ + new Map(); + function assertPrjPoint(other) { + if (!(other instanceof Point4)) + throw new Error("ProjectivePoint expected"); + } + class Point4 { + constructor(px, py, pz) { + this.px = px; + this.py = py; + this.pz = pz; + if (px == null || !Fp2.isValid(px)) + throw new Error("x required"); + if (py == null || !Fp2.isValid(py)) + throw new Error("y required"); + if (pz == null || !Fp2.isValid(pz)) + throw new Error("z required"); + } + // Does not validate if the point is on-curve. + // Use fromHex instead, or call assertValidity() later. + static fromAffine(p) { + const {x, y} = p || {}; + if (!p || !Fp2.isValid(x) || !Fp2.isValid(y)) + throw new Error("invalid affine point"); + if (p instanceof Point4) + throw new Error("projective point not allowed"); + const is0 = (i)=>Fp2.eql(i, Fp2.ZERO); + if (is0(x) && is0(y)) + return Point4.ZERO; + return new Point4(x,y,Fp2.ONE); + } + get x() { + return this.toAffine().x; + } + get y() { + return this.toAffine().y; + } + /** + * Takes a bunch of Projective Points but executes only one + * inversion on all of them. Inversion is very slow operation, + * so this improves performance massively. + * Optimization: converts a list of projective points to a list of identical points with Z=1. + */ + static normalizeZ(points) { + const toInv = Fp2.invertBatch(points.map((p)=>p.pz)); + return points.map((p,i)=>p.toAffine(toInv[i])).map(Point4.fromAffine); + } + /** + * Converts hash string or Uint8Array to Point. + * @param hex short/long ECDSA hex + */ + static fromHex(hex2) { + const P = Point4.fromAffine(fromBytes(ensureBytes2("pointHex", hex2))); + P.assertValidity(); + return P; + } + // Multiplies generator point by privateKey. + static fromPrivateKey(privateKey) { + return Point4.BASE.multiply(normPrivateKeyToScalar(privateKey)); + } + // "Private method", don't use it directly + _setWindowSize(windowSize) { + this._WINDOW_SIZE = windowSize; + pointPrecomputes2.delete(this); + } + // A point on curve is valid if it conforms to equation. + assertValidity() { + if (this.is0()) { + if (CURVE2.allowInfinityPoint) + return; + throw new Error("bad point: ZERO"); + } + const {x, y} = this.toAffine(); + if (!Fp2.isValid(x) || !Fp2.isValid(y)) + throw new Error("bad point: x or y not FE"); + const left = Fp2.sqr(y); + const right = weierstrassEquation(x); + if (!Fp2.eql(left, right)) + throw new Error("bad point: equation left != right"); + if (!this.isTorsionFree()) + throw new Error("bad point: not in prime-order subgroup"); + } + hasEvenY() { + const {y} = this.toAffine(); + if (Fp2.isOdd) + return !Fp2.isOdd(y); + throw new Error("Field doesn't support isOdd"); + } + /** + * Compare one point to another. + */ + equals(other) { + assertPrjPoint(other); + const {px: X1, py: Y1, pz: Z1} = this; + const {px: X2, py: Y2, pz: Z2} = other; + const U1 = Fp2.eql(Fp2.mul(X1, Z2), Fp2.mul(X2, Z1)); + const U2 = Fp2.eql(Fp2.mul(Y1, Z2), Fp2.mul(Y2, Z1)); + return U1 && U2; + } + /** + * Flips point to one corresponding to (x, -y) in Affine coordinates. + */ + negate() { + return new Point4(this.px,Fp2.neg(this.py),this.pz); + } + // 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} = CURVE2; + const b3 = Fp2.mul(b, _3n3); + const {px: X1, py: Y1, pz: Z1} = this; + let X3 = Fp2.ZERO + , Y3 = Fp2.ZERO + , Z3 = Fp2.ZERO; + let t0 = Fp2.mul(X1, X1); + let t1 = Fp2.mul(Y1, Y1); + let t2 = Fp2.mul(Z1, Z1); + let t3 = Fp2.mul(X1, Y1); + t3 = Fp2.add(t3, t3); + Z3 = Fp2.mul(X1, Z1); + Z3 = Fp2.add(Z3, Z3); + X3 = Fp2.mul(a, Z3); + Y3 = Fp2.mul(b3, t2); + Y3 = Fp2.add(X3, Y3); + X3 = Fp2.sub(t1, Y3); + Y3 = Fp2.add(t1, Y3); + Y3 = Fp2.mul(X3, Y3); + X3 = Fp2.mul(t3, X3); + Z3 = Fp2.mul(b3, Z3); + t2 = Fp2.mul(a, t2); + t3 = Fp2.sub(t0, t2); + t3 = Fp2.mul(a, t3); + t3 = Fp2.add(t3, Z3); + Z3 = Fp2.add(t0, t0); + t0 = Fp2.add(Z3, t0); + t0 = Fp2.add(t0, t2); + t0 = Fp2.mul(t0, t3); + Y3 = Fp2.add(Y3, t0); + t2 = Fp2.mul(Y1, Z1); + t2 = Fp2.add(t2, t2); + t0 = Fp2.mul(t2, t3); + X3 = Fp2.sub(X3, t0); + Z3 = Fp2.mul(t2, t1); + Z3 = Fp2.add(Z3, Z3); + Z3 = Fp2.add(Z3, Z3); + return new Point4(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) { + assertPrjPoint(other); + const {px: X1, py: Y1, pz: Z1} = this; + const {px: X2, py: Y2, pz: Z2} = other; + let X3 = Fp2.ZERO + , Y3 = Fp2.ZERO + , Z3 = Fp2.ZERO; + const a = CURVE2.a; + const b3 = Fp2.mul(CURVE2.b, _3n3); + let t0 = Fp2.mul(X1, X2); + let t1 = Fp2.mul(Y1, Y2); + let t2 = Fp2.mul(Z1, Z2); + let t3 = Fp2.add(X1, Y1); + let t4 = Fp2.add(X2, Y2); + t3 = Fp2.mul(t3, t4); + t4 = Fp2.add(t0, t1); + t3 = Fp2.sub(t3, t4); + t4 = Fp2.add(X1, Z1); + let t5 = Fp2.add(X2, Z2); + t4 = Fp2.mul(t4, t5); + t5 = Fp2.add(t0, t2); + t4 = Fp2.sub(t4, t5); + t5 = Fp2.add(Y1, Z1); + X3 = Fp2.add(Y2, Z2); + t5 = Fp2.mul(t5, X3); + X3 = Fp2.add(t1, t2); + t5 = Fp2.sub(t5, X3); + Z3 = Fp2.mul(a, t4); + X3 = Fp2.mul(b3, t2); + Z3 = Fp2.add(X3, Z3); + X3 = Fp2.sub(t1, Z3); + Z3 = Fp2.add(t1, Z3); + Y3 = Fp2.mul(X3, Z3); + t1 = Fp2.add(t0, t0); + t1 = Fp2.add(t1, t0); + t2 = Fp2.mul(a, t2); + t4 = Fp2.mul(b3, t4); + t1 = Fp2.add(t1, t2); + t2 = Fp2.sub(t0, t2); + t2 = Fp2.mul(a, t2); + t4 = Fp2.add(t4, t2); + t0 = Fp2.mul(t1, t4); + Y3 = Fp2.add(Y3, t0); + t0 = Fp2.mul(t5, t4); + X3 = Fp2.mul(t3, X3); + X3 = Fp2.sub(X3, t0); + t0 = Fp2.mul(t3, t1); + Z3 = Fp2.mul(t5, Z3); + Z3 = Fp2.add(Z3, t0); + return new Point4(X3,Y3,Z3); + } + subtract(other) { + return this.add(other.negate()); + } + is0() { + return this.equals(Point4.ZERO); + } + wNAF(n) { + return wnaf.wNAFCached(this, pointPrecomputes2, n, (comp)=>{ + const toInv = Fp2.invertBatch(comp.map((p)=>p.pz)); + return comp.map((p,i)=>p.toAffine(toInv[i])).map(Point4.fromAffine); + } + ); + } + /** + * 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 private key e.g. sig verification, which works over *public* keys. + */ + multiplyUnsafe(n) { + const I = Point4.ZERO; + if (n === _0n5) + return I; + assertGE(n); + if (n === _1n5) + return this; + const {endo: endo2} = CURVE2; + if (!endo2) + return wnaf.unsafeLadder(this, n); + let {k1neg, k1, k2neg, k2} = endo2.splitScalar(n); + let k1p = I; + let k2p = I; + let d = this; + while (k1 > _0n5 || k2 > _0n5) { + if (k1 & _1n5) + k1p = k1p.add(d); + if (k2 & _1n5) + k2p = k2p.add(d); + d = d.double(); + k1 >>= _1n5; + k2 >>= _1n5; + } + if (k1neg) + k1p = k1p.negate(); + if (k2neg) + k2p = k2p.negate(); + k2p = new Point4(Fp2.mul(k2p.px, endo2.beta),k2p.py,k2p.pz); + return k1p.add(k2p); + } + /** + * 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) { + assertGE(scalar); + let n = scalar; + let point, fake; + const {endo: endo2} = CURVE2; + if (endo2) { + const {k1neg, k1, k2neg, k2} = endo2.splitScalar(n); + let {p: k1p, f: f1p} = this.wNAF(k1); + let {p: k2p, f: f2p} = this.wNAF(k2); + k1p = wnaf.constTimeNegate(k1neg, k1p); + k2p = wnaf.constTimeNegate(k2neg, k2p); + k2p = new Point4(Fp2.mul(k2p.px, endo2.beta),k2p.py,k2p.pz); + point = k1p.add(k2p); + fake = f1p.add(f2p); + } else { + const {p, f: f2} = this.wNAF(n); + point = p; + fake = f2; + } + return Point4.normalizeZ([point, fake])[0]; + } + /** + * Efficiently calculate `aP + bQ`. Unsafe, can expose private key, if used incorrectly. + * Not using Strauss-Shamir trick: precomputation tables are faster. + * The trick could be useful if both P and Q are not G (not in our case). + * @returns non-zero affine point + */ + multiplyAndAddUnsafe(Q, a, b) { + const G = Point4.BASE; + const mul = (P,a2)=>a2 === _0n5 || a2 === _1n5 || !P.equals(G) ? P.multiplyUnsafe(a2) : P.multiply(a2); + const sum = mul(this, a).add(mul(Q, b)); + return sum.is0() ? void 0 : sum; + } + // Converts Projective point to affine (x, y) coordinates. + // Can accept precomputed Z^-1 - for example, from invertBatch. + // (x, y, z) ∋ (x=x/z, y=y/z) + toAffine(iz) { + const {px: x, py: y, pz: z} = this; + const is0 = this.is0(); + if (iz == null) + iz = is0 ? Fp2.ONE : Fp2.inv(z); + const ax = Fp2.mul(x, iz); + const ay = Fp2.mul(y, iz); + const zz = Fp2.mul(z, iz); + if (is0) + return { + x: Fp2.ZERO, + y: Fp2.ZERO + }; + if (!Fp2.eql(zz, Fp2.ONE)) + throw new Error("invZ was invalid"); + return { + x: ax, + y: ay + }; + } + isTorsionFree() { + const {h: cofactor, isTorsionFree} = CURVE2; + if (cofactor === _1n5) + return true; + if (isTorsionFree) + return isTorsionFree(Point4, this); + throw new Error("isTorsionFree() has not been declared for the elliptic curve"); + } + clearCofactor() { + const {h: cofactor, clearCofactor} = CURVE2; + if (cofactor === _1n5) + return this; + if (clearCofactor) + return clearCofactor(Point4, this); + return this.multiplyUnsafe(CURVE2.h); + } + toRawBytes(isCompressed=true) { + this.assertValidity(); + return toBytes3(Point4, this, isCompressed); + } + toHex(isCompressed=true) { + return bytesToHex3(this.toRawBytes(isCompressed)); + } + } + Point4.BASE = new Point4(CURVE2.Gx,CURVE2.Gy,Fp2.ONE); + Point4.ZERO = new Point4(Fp2.ZERO,Fp2.ONE,Fp2.ZERO); + const _bits = CURVE2.nBitLength; + const wnaf = wNAF(Point4, CURVE2.endo ? Math.ceil(_bits / 2) : _bits); + return { + CURVE: CURVE2, + ProjectivePoint: Point4, + normPrivateKeyToScalar, + weierstrassEquation, + isWithinCurveOrder: isWithinCurveOrder2 + }; + } + function validateOpts(curve) { + const opts = validateBasic(curve); + validateObject(opts, { + hash: "hash", + hmac: "function", + randomBytes: "function" + }, { + bits2int: "function", + bits2int_modN: "function", + lowS: "boolean" + }); + return Object.freeze({ + lowS: true, + ...opts + }); + } + function weierstrass2(curveDef) { + const CURVE2 = validateOpts(curveDef); + const {Fp: Fp2, n: CURVE_ORDER} = CURVE2; + const compressedLen2 = Fp2.BYTES + 1; + const uncompressedLen2 = 2 * Fp2.BYTES + 1; + function isValidFieldElement2(num) { + return _0n5 < num && num < Fp2.ORDER; + } + function modN2(a) { + return mod2(a, CURVE_ORDER); + } + function invN(a) { + return invert2(a, CURVE_ORDER); + } + const {ProjectivePoint: Point4, normPrivateKeyToScalar, weierstrassEquation, isWithinCurveOrder: isWithinCurveOrder2} = weierstrassPoints({ + ...CURVE2, + toBytes(c, point, isCompressed) { + const a = point.toAffine(); + const x = Fp2.toBytes(a.x); + const cat = concatBytes3; + if (isCompressed) { + return cat(Uint8Array.from([point.hasEvenY() ? 2 : 3]), x); + } else { + return cat(Uint8Array.from([4]), x, Fp2.toBytes(a.y)); + } + }, + fromBytes(bytes2) { + const len = bytes2.length; + const head = bytes2[0]; + const tail = bytes2.subarray(1); + if (len === compressedLen2 && (head === 2 || head === 3)) { + const x = bytesToNumberBE(tail); + if (!isValidFieldElement2(x)) + throw new Error("Point is not on curve"); + const y2 = weierstrassEquation(x); + let y = Fp2.sqrt(y2); + const isYOdd = (y & _1n5) === _1n5; + const isHeadOdd = (head & 1) === 1; + if (isHeadOdd !== isYOdd) + y = Fp2.neg(y); + return { + x, + y + }; + } else if (len === uncompressedLen2 && head === 4) { + const x = Fp2.fromBytes(tail.subarray(0, Fp2.BYTES)); + const y = Fp2.fromBytes(tail.subarray(Fp2.BYTES, 2 * Fp2.BYTES)); + return { + x, + y + }; + } else { + throw new Error(`Point of length ${len} was invalid. Expected ${compressedLen2} compressed bytes or ${uncompressedLen2} uncompressed bytes`); + } + } + }); + const numToNByteStr = (num)=>bytesToHex3(numberToBytesBE(num, CURVE2.nByteLength)); + function isBiggerThanHalfOrder(number2) { + const HALF = CURVE_ORDER >> _1n5; + return number2 > HALF; + } + function normalizeS(s) { + return isBiggerThanHalfOrder(s) ? modN2(-s) : s; + } + const slcNum = (b,from,to)=>bytesToNumberBE(b.slice(from, to)); + class Signature2 { + constructor(r, s, recovery) { + this.r = r; + this.s = s; + this.recovery = recovery; + this.assertValidity(); + } + // pair (bytes of r, bytes of s) + static fromCompact(hex2) { + const l = CURVE2.nByteLength; + hex2 = ensureBytes2("compactSignature", hex2, l * 2); + return new Signature2(slcNum(hex2, 0, l),slcNum(hex2, l, 2 * l)); + } + // DER encoded ECDSA signature + // https://bitcoin.stackexchange.com/questions/57644/what-are-the-parts-of-a-bitcoin-transaction-input-script + static fromDER(hex2) { + const {r, s} = DER.toSig(ensureBytes2("DER", hex2)); + return new Signature2(r,s); + } + assertValidity() { + if (!isWithinCurveOrder2(this.r)) + throw new Error("r must be 0 < r < CURVE.n"); + if (!isWithinCurveOrder2(this.s)) + throw new Error("s must be 0 < s < CURVE.n"); + } + addRecoveryBit(recovery) { + return new Signature2(this.r,this.s,recovery); + } + recoverPublicKey(msgHash) { + const {r, s, recovery: rec} = this; + const h = bits2int_modN(ensureBytes2("msgHash", msgHash)); + if (rec == null || ![0, 1, 2, 3].includes(rec)) + throw new Error("recovery id invalid"); + const radj = rec === 2 || rec === 3 ? r + CURVE2.n : r; + if (radj >= Fp2.ORDER) + throw new Error("recovery id 2 or 3 invalid"); + const prefix = (rec & 1) === 0 ? "02" : "03"; + const R = Point4.fromHex(prefix + numToNByteStr(radj)); + const ir = invN(radj); + const u1 = modN2(-h * ir); + const u2 = modN2(s * ir); + const Q = Point4.BASE.multiplyAndAddUnsafe(R, u1, u2); + if (!Q) + throw new Error("point at infinify"); + Q.assertValidity(); + return Q; + } + // Signatures should be low-s, to prevent malleability. + hasHighS() { + return isBiggerThanHalfOrder(this.s); + } + normalizeS() { + return this.hasHighS() ? new Signature2(this.r,modN2(-this.s),this.recovery) : this; + } + // DER-encoded + toDERRawBytes() { + return hexToBytes3(this.toDERHex()); + } + toDERHex() { + return DER.hexFromSig({ + r: this.r, + s: this.s + }); + } + // padded bytes of r, then padded bytes of s + toCompactRawBytes() { + return hexToBytes3(this.toCompactHex()); + } + toCompactHex() { + return numToNByteStr(this.r) + numToNByteStr(this.s); + } + } + const utils2 = { + isValidPrivateKey(privateKey) { + try { + normPrivateKeyToScalar(privateKey); + return true; + } catch (error) { + return false; + } + }, + normPrivateKeyToScalar, + /** + * Produces cryptographically secure private key from random of size (nBitLength+64) + * as per FIPS 186 B.4.1 with modulo bias being neglible. + */ + randomPrivateKey: ()=>{ + const rand = CURVE2.randomBytes(Fp2.BYTES + 8); + const num = hashToPrivateScalar(rand, CURVE_ORDER); + return numberToBytesBE(num, CURVE2.nByteLength); + } + , + /** + * Creates precompute table for an arbitrary EC point. Makes point "cached". + * Allows to massively speed-up `point.multiply(scalar)`. + * @returns cached point + * @example + * const fast = utils.precompute(8, ProjectivePoint.fromHex(someonesPubKey)); + * fast.multiply(privKey); // much faster ECDH now + */ + precompute(windowSize=8, point=Point4.BASE) { + point._setWindowSize(windowSize); + point.multiply(BigInt(3)); + return point; + } + }; + function getPublicKey2(privateKey, isCompressed=true) { + return Point4.fromPrivateKey(privateKey).toRawBytes(isCompressed); + } + function isProbPub2(item) { + const arr = item instanceof Uint8Array; + const str = typeof item === "string"; + const len = (arr || str) && item.length; + if (arr) + return len === compressedLen2 || len === uncompressedLen2; + if (str) + return len === 2 * compressedLen2 || len === 2 * uncompressedLen2; + if (item instanceof Point4) + return true; + return false; + } + function getSharedSecret2(privateA, publicB, isCompressed=true) { + if (isProbPub2(privateA)) + throw new Error("first arg must be private key"); + if (!isProbPub2(publicB)) + throw new Error("second arg must be public key"); + const b = Point4.fromHex(publicB); + return b.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed); + } + const bits2int = CURVE2.bits2int || function(bytes2) { + const num = bytesToNumberBE(bytes2); + const delta = bytes2.length * 8 - CURVE2.nBitLength; + return delta > 0 ? num >> BigInt(delta) : num; + } + ; + const bits2int_modN = CURVE2.bits2int_modN || function(bytes2) { + return modN2(bits2int(bytes2)); + } + ; + const ORDER_MASK = bitMask(CURVE2.nBitLength); + function int2octets(num) { + if (typeof num !== "bigint") + throw new Error("bigint expected"); + if (!(_0n5 <= num && num < ORDER_MASK)) + throw new Error(`bigint expected < 2^${CURVE2.nBitLength}`); + return numberToBytesBE(num, CURVE2.nByteLength); + } + function prepSig(msgHash, privateKey, opts=defaultSigOpts) { + if (["recovered", "canonical"].some((k)=>k in opts)) + throw new Error("sign() legacy options not supported"); + const {hash: hash2, randomBytes: randomBytes3} = CURVE2; + let {lowS, prehash, extraEntropy: ent} = opts; + if (lowS == null) + lowS = true; + msgHash = ensureBytes2("msgHash", msgHash); + if (prehash) + msgHash = ensureBytes2("prehashed msgHash", hash2(msgHash)); + const h1int = bits2int_modN(msgHash); + const d = normPrivateKeyToScalar(privateKey); + const seedArgs = [int2octets(d), int2octets(h1int)]; + if (ent != null) { + const e = ent === true ? randomBytes3(Fp2.BYTES) : ent; + seedArgs.push(ensureBytes2("extraEntropy", e, Fp2.BYTES)); + } + const seed = concatBytes3(...seedArgs); + const m = h1int; + function k2sig(kBytes) { + const k = bits2int(kBytes); + if (!isWithinCurveOrder2(k)) + return; + const ik = invN(k); + const q = Point4.BASE.multiply(k).toAffine(); + const r = modN2(q.x); + if (r === _0n5) + return; + const s = modN2(ik * modN2(m + r * d)); + if (s === _0n5) + return; + let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n5); + let normS = s; + if (lowS && isBiggerThanHalfOrder(s)) { + normS = normalizeS(s); + recovery ^= 1; + } + return new Signature2(r,normS,recovery); + } + return { + seed, + k2sig + }; + } + const defaultSigOpts = { + lowS: CURVE2.lowS, + prehash: false + }; + const defaultVerOpts = { + lowS: CURVE2.lowS, + prehash: false + }; + function sign(msgHash, privKey, opts=defaultSigOpts) { + const {seed, k2sig} = prepSig(msgHash, privKey, opts); + const drbg = createHmacDrbg(CURVE2.hash.outputLen, CURVE2.nByteLength, CURVE2.hmac); + return drbg(seed, k2sig); + } + Point4.BASE._setWindowSize(8); + function verify(signature, msgHash, publicKey, opts=defaultVerOpts) { + const sg = signature; + msgHash = ensureBytes2("msgHash", msgHash); + publicKey = ensureBytes2("publicKey", publicKey); + if ("strict"in opts) + throw new Error("options.strict was renamed to lowS"); + const {lowS, prehash} = opts; + let _sig = void 0; + let P; + try { + if (typeof sg === "string" || sg instanceof Uint8Array) { + try { + _sig = Signature2.fromDER(sg); + } catch (derError) { + if (!(derError instanceof DER.Err)) + throw derError; + _sig = Signature2.fromCompact(sg); + } + } else if (typeof sg === "object" && typeof sg.r === "bigint" && typeof sg.s === "bigint") { + const {r: r2, s: s2} = sg; + _sig = new Signature2(r2,s2); + } else { + throw new Error("PARSE"); + } + P = Point4.fromHex(publicKey); + } catch (error) { + if (error.message === "PARSE") + throw new Error(`signature must be Signature instance, Uint8Array or hex string`); + return false; + } + if (lowS && _sig.hasHighS()) + return false; + if (prehash) + msgHash = CURVE2.hash(msgHash); + const {r, s} = _sig; + const h = bits2int_modN(msgHash); + const is = invN(s); + const u1 = modN2(h * is); + const u2 = modN2(r * is); + const R = Point4.BASE.multiplyAndAddUnsafe(P, u1, u2)?.toAffine(); + if (!R) + return false; + const v = modN2(R.x); + return v === r; + } + return { + CURVE: CURVE2, + getPublicKey: getPublicKey2, + getSharedSecret: getSharedSecret2, + sign, + verify, + ProjectivePoint: Point4, + Signature: Signature2, + utils: utils2 + }; + } + function SWUFpSqrtRatio(Fp2, Z) { + const q = Fp2.ORDER; + let l = _0n5; + for (let o = q - _1n5; o % _2n4 === _0n5; o /= _2n4) + l += _1n5; + const c1 = l; + const c2 = (q - _1n5) / _2n4 ** c1; + const c3 = (c2 - _1n5) / _2n4; + const c4 = _2n4 ** c1 - _1n5; + const c5 = _2n4 ** (c1 - _1n5); + const c6 = Fp2.pow(Z, c2); + const c7 = Fp2.pow(Z, (c2 + _1n5) / _2n4); + let sqrtRatio = (u,v)=>{ + let tv1 = c6; + let tv2 = Fp2.pow(v, c4); + let tv3 = Fp2.sqr(tv2); + tv3 = Fp2.mul(tv3, v); + let tv5 = Fp2.mul(u, tv3); + tv5 = Fp2.pow(tv5, c3); + tv5 = Fp2.mul(tv5, tv2); + tv2 = Fp2.mul(tv5, v); + tv3 = Fp2.mul(tv5, u); + let tv4 = Fp2.mul(tv3, tv2); + tv5 = Fp2.pow(tv4, c5); + let isQR = Fp2.eql(tv5, Fp2.ONE); + tv2 = Fp2.mul(tv3, c7); + tv5 = Fp2.mul(tv4, tv1); + tv3 = Fp2.cmov(tv2, tv3, isQR); + tv4 = Fp2.cmov(tv5, tv4, isQR); + for (let i = c1; i > _1n5; i--) { + let tv52 = _2n4 ** (i - _2n4); + let tvv5 = Fp2.pow(tv4, tv52); + const e1 = Fp2.eql(tvv5, Fp2.ONE); + tv2 = Fp2.mul(tv3, tv1); + tv1 = Fp2.mul(tv1, tv1); + tvv5 = Fp2.mul(tv4, tv1); + tv3 = Fp2.cmov(tv2, tv3, e1); + tv4 = Fp2.cmov(tvv5, tv4, e1); + } + return { + isValid: isQR, + value: tv3 + }; + } + ; + if (Fp2.ORDER % _4n2 === _3n3) { + const c12 = (Fp2.ORDER - _3n3) / _4n2; + const c22 = Fp2.sqrt(Fp2.neg(Z)); + sqrtRatio = (u,v)=>{ + let tv1 = Fp2.sqr(v); + const tv2 = Fp2.mul(u, v); + tv1 = Fp2.mul(tv1, tv2); + let y1 = Fp2.pow(tv1, c12); + y1 = Fp2.mul(y1, tv2); + const y2 = Fp2.mul(y1, c22); + const tv3 = Fp2.mul(Fp2.sqr(y1), v); + const isQR = Fp2.eql(tv3, u); + let y = Fp2.cmov(y2, y1, isQR); + return { + isValid: isQR, + value: y + }; + } + ; + } + return sqrtRatio; + } + function mapToCurveSimpleSWU(Fp2, opts) { + validateField(Fp2); + if (!Fp2.isValid(opts.A) || !Fp2.isValid(opts.B) || !Fp2.isValid(opts.Z)) + throw new Error("mapToCurveSimpleSWU: invalid opts"); + const sqrtRatio = SWUFpSqrtRatio(Fp2, opts.Z); + if (!Fp2.isOdd) + throw new Error("Fp.isOdd is not implemented!"); + return (u)=>{ + let tv1, tv2, tv3, tv4, tv5, tv6, x, y; + tv1 = Fp2.sqr(u); + tv1 = Fp2.mul(tv1, opts.Z); + tv2 = Fp2.sqr(tv1); + tv2 = Fp2.add(tv2, tv1); + tv3 = Fp2.add(tv2, Fp2.ONE); + tv3 = Fp2.mul(tv3, opts.B); + tv4 = Fp2.cmov(opts.Z, Fp2.neg(tv2), !Fp2.eql(tv2, Fp2.ZERO)); + tv4 = Fp2.mul(tv4, opts.A); + tv2 = Fp2.sqr(tv3); + tv6 = Fp2.sqr(tv4); + tv5 = Fp2.mul(tv6, opts.A); + tv2 = Fp2.add(tv2, tv5); + tv2 = Fp2.mul(tv2, tv3); + tv6 = Fp2.mul(tv6, tv4); + tv5 = Fp2.mul(tv6, opts.B); + tv2 = Fp2.add(tv2, tv5); + x = Fp2.mul(tv1, tv3); + const {isValid, value} = sqrtRatio(tv2, tv6); + y = Fp2.mul(tv1, u); + y = Fp2.mul(y, value); + x = Fp2.cmov(x, tv3, isValid); + y = Fp2.cmov(y, value, isValid); + const e1 = Fp2.isOdd(u) === Fp2.isOdd(y); + y = Fp2.cmov(Fp2.neg(y), y, e1); + x = Fp2.div(x, tv4); + return { + x, + y + }; + } + ; + } + + // node_modules/.pnpm/@noble+curves@1.0.0/node_modules/@noble/curves/esm/abstract/hash-to-curve.js + function validateDST(dst) { + if (dst instanceof Uint8Array) + return dst; + if (typeof dst === "string") + return utf8ToBytes3(dst); + throw new Error("DST must be Uint8Array or string"); + } + var os2ip = bytesToNumberBE; + function i2osp(value, length) { + if (value < 0 || value >= 1 << 8 * length) { + throw new Error(`bad I2OSP call: value=${value} length=${length}`); + } + const res = Array.from({ + length + }).fill(0); + for (let i = length - 1; i >= 0; i--) { + res[i] = value & 255; + value >>>= 8; + } + return new Uint8Array(res); + } + function strxor(a, b) { + const arr = new Uint8Array(a.length); + for (let i = 0; i < a.length; i++) { + arr[i] = a[i] ^ b[i]; + } + return arr; + } + function isBytes(item) { + if (!(item instanceof Uint8Array)) + throw new Error("Uint8Array expected"); + } + function isNum(item) { + if (!Number.isSafeInteger(item)) + throw new Error("number expected"); + } + function expand_message_xmd(msg, DST, lenInBytes, H) { + isBytes(msg); + isBytes(DST); + isNum(lenInBytes); + if (DST.length > 255) + DST = H(concatBytes3(utf8ToBytes3("H2C-OVERSIZE-DST-"), DST)); + const {outputLen: b_in_bytes, blockLen: r_in_bytes} = H; + const ell = Math.ceil(lenInBytes / b_in_bytes); + if (ell > 255) + throw new Error("Invalid xmd length"); + const DST_prime = concatBytes3(DST, i2osp(DST.length, 1)); + const Z_pad = i2osp(0, r_in_bytes); + const l_i_b_str = i2osp(lenInBytes, 2); + const b = new Array(ell); + const b_0 = H(concatBytes3(Z_pad, msg, l_i_b_str, i2osp(0, 1), DST_prime)); + b[0] = H(concatBytes3(b_0, i2osp(1, 1), DST_prime)); + for (let i = 1; i <= ell; i++) { + const args = [strxor(b_0, b[i - 1]), i2osp(i + 1, 1), DST_prime]; + b[i] = H(concatBytes3(...args)); + } + const pseudo_random_bytes = concatBytes3(...b); + return pseudo_random_bytes.slice(0, lenInBytes); + } + function expand_message_xof(msg, DST, lenInBytes, k, H) { + isBytes(msg); + isBytes(DST); + isNum(lenInBytes); + if (DST.length > 255) { + const dkLen = Math.ceil(2 * k / 8); + DST = H.create({ + dkLen + }).update(utf8ToBytes3("H2C-OVERSIZE-DST-")).update(DST).digest(); + } + if (lenInBytes > 65535 || DST.length > 255) + throw new Error("expand_message_xof: invalid lenInBytes"); + return H.create({ + dkLen: lenInBytes + }).update(msg).update(i2osp(lenInBytes, 2)).update(DST).update(i2osp(DST.length, 1)).digest(); + } + function hash_to_field(msg, count, options) { + validateObject(options, { + DST: "string", + p: "bigint", + m: "isSafeInteger", + k: "isSafeInteger", + hash: "hash" + }); + const {p, k, m, hash: hash2, expand, DST: _DST} = options; + isBytes(msg); + isNum(count); + const DST = validateDST(_DST); + const log2p = p.toString(2).length; + const L = Math.ceil((log2p + k) / 8); + const len_in_bytes = count * m * L; + let prb; + if (expand === "xmd") { + prb = expand_message_xmd(msg, DST, len_in_bytes, hash2); + } else if (expand === "xof") { + prb = expand_message_xof(msg, DST, len_in_bytes, k, hash2); + } else if (expand === "_internal_pass") { + prb = msg; + } else { + throw new Error('expand must be "xmd" or "xof"'); + } + const u = new Array(count); + for (let i = 0; i < count; i++) { + const e = new Array(m); + for (let j = 0; j < m; j++) { + const elm_offset = L * (j + i * m); + const tv = prb.subarray(elm_offset, elm_offset + L); + e[j] = mod2(os2ip(tv), p); + } + u[i] = e; + } + return u; + } + function isogenyMap(field, map) { + const COEFF = map.map((i)=>Array.from(i).reverse()); + return (x,y)=>{ + const [xNum,xDen,yNum,yDen] = COEFF.map((val)=>val.reduce((acc,i)=>field.add(field.mul(acc, x), i))); + x = field.div(xNum, xDen); + y = field.mul(y, field.div(yNum, yDen)); + return { + x, + y + }; + } + ; + } + function createHasher(Point4, mapToCurve, def) { + if (typeof mapToCurve !== "function") + throw new Error("mapToCurve() must be defined"); + return { + // Encodes byte string to elliptic curve + // https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-hash-to-curve-16#section-3 + hashToCurve(msg, options) { + const u = hash_to_field(msg, 2, { + ...def, + DST: def.DST, + ...options + }); + const u0 = Point4.fromAffine(mapToCurve(u[0])); + const u1 = Point4.fromAffine(mapToCurve(u[1])); + const P = u0.add(u1).clearCofactor(); + P.assertValidity(); + return P; + }, + // https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-hash-to-curve-16#section-3 + encodeToCurve(msg, options) { + const u = hash_to_field(msg, 1, { + ...def, + DST: def.encodeDST, + ...options + }); + const P = Point4.fromAffine(mapToCurve(u[0])).clearCofactor(); + P.assertValidity(); + return P; + } + }; + } + + // node_modules/.pnpm/@noble+curves@1.0.0/node_modules/@noble/curves/esm/_shortw_utils.js + function getHash(hash2) { + return { + hash: hash2, + hmac: (key,...msgs)=>hmac(hash2, key, concatBytes2(...msgs)), + randomBytes: randomBytes2 + }; + } + function createCurve(curveDef, defHash) { + const create = (hash2)=>weierstrass2({ + ...curveDef, + ...getHash(hash2) + }); + return Object.freeze({ + ...create(defHash), + create + }); + } + + // node_modules/.pnpm/@noble+curves@1.0.0/node_modules/@noble/curves/esm/secp256k1.js + var secp256k1P = BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"); + var secp256k1N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"); + var _1n6 = BigInt(1); + var _2n5 = BigInt(2); + var divNearest2 = (a,b)=>(a + b / _2n5) / b; + function sqrtMod2(y) { + const P = secp256k1P; + const _3n4 = 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 = pow22(b3, _3n4, P) * b3 % P; + const b9 = pow22(b6, _3n4, P) * b3 % P; + const b11 = pow22(b9, _2n5, P) * b2 % P; + const b22 = pow22(b11, _11n, P) * b11 % P; + const b44 = pow22(b22, _22n, P) * b22 % P; + const b88 = pow22(b44, _44n, P) * b44 % P; + const b176 = pow22(b88, _88n, P) * b88 % P; + const b220 = pow22(b176, _44n, P) * b44 % P; + const b223 = pow22(b220, _3n4, P) * b3 % P; + const t1 = pow22(b223, _23n, P) * b22 % P; + const t2 = pow22(t1, _6n, P) * b2 % P; + const root = pow22(t2, _2n5, P); + if (!Fp.eql(Fp.sqr(root), y)) + throw new Error("Cannot find square root"); + return root; + } + var Fp = Field(secp256k1P, void 0, void 0, { + sqrt: sqrtMod2 + }); + var secp256k1 = createCurve({ + a: BigInt(0), + b: BigInt(7), + Fp, + n: secp256k1N, + // Base point (x, y) aka generator point + Gx: BigInt("55066263022277343669578718895168534326250603453777594175500187360389116729240"), + Gy: BigInt("32670510020758816978083085130507043184471273380659243275938904335757337482424"), + h: BigInt(1), + lowS: true, + /** + * secp256k1 belongs to Koblitz curves: it has efficiently computable endomorphism. + * Endomorphism uses 2x less RAM, speeds up precomputation by 2x and ECDH / key recovery by 20%. + * For precomputed wNAF it trades off 1/2 init time & 1/3 ram for 20% perf hit. + * Explanation: https://gist.github.com/paulmillr/eb670806793e84df628a7c434a873066 + */ + endo: { + beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"), + splitScalar: (k)=>{ + const n = secp256k1N; + const a1 = BigInt("0x3086d221a7d46bcde86c90e49284eb15"); + const b1 = -_1n6 * BigInt("0xe4437ed6010e88286f547fa90abfe4c3"); + const a2 = BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8"); + const b2 = a1; + const POW_2_128 = BigInt("0x100000000000000000000000000000000"); + const c1 = divNearest2(b2 * k, n); + const c2 = divNearest2(-b1 * k, n); + let k1 = mod2(k - c1 * a1 - c2 * a2, n); + let k2 = mod2(-c1 * b1 - c2 * b2, n); + const k1neg = k1 > POW_2_128; + const k2neg = k2 > POW_2_128; + if (k1neg) + k1 = n - k1; + if (k2neg) + k2 = n - k2; + if (k1 > POW_2_128 || k2 > POW_2_128) { + throw new Error("splitScalar: Endomorphism failed, k=" + k); + } + return { + k1neg, + k1, + k2neg, + k2 + }; + } + } + }, sha2562); + var _0n6 = BigInt(0); + var fe = (x)=>typeof x === "bigint" && _0n6 < x && x < secp256k1P; + var ge = (x)=>typeof x === "bigint" && _0n6 < x && x < secp256k1N; + var TAGGED_HASH_PREFIXES2 = {}; + function taggedHash(tag, ...messages) { + let tagP = TAGGED_HASH_PREFIXES2[tag]; + if (tagP === void 0) { + const tagH = sha2562(Uint8Array.from(tag, (c)=>c.charCodeAt(0))); + tagP = concatBytes3(tagH, tagH); + TAGGED_HASH_PREFIXES2[tag] = tagP; + } + return sha2562(concatBytes3(tagP, ...messages)); + } + var pointToBytes = (point)=>point.toRawBytes(true).slice(1); + var numTo32b2 = (n)=>numberToBytesBE(n, 32); + var modP = (x)=>mod2(x, secp256k1P); + var modN = (x)=>mod2(x, secp256k1N); + var Point2 = secp256k1.ProjectivePoint; + var GmulAdd = (Q,a,b)=>Point2.BASE.multiplyAndAddUnsafe(Q, a, b); + function schnorrGetExtPubKey(priv) { + let d_ = secp256k1.utils.normPrivateKeyToScalar(priv); + let p = Point2.fromPrivateKey(d_); + const scalar = p.hasEvenY() ? d_ : modN(-d_); + return { + scalar, + bytes: pointToBytes(p) + }; + } + function lift_x(x) { + if (!fe(x)) + throw new Error("bad x: need 0 < x < p"); + const xx = modP(x * x); + const c = modP(xx * x + BigInt(7)); + let y = sqrtMod2(c); + if (y % _2n5 !== _0n6) + y = modP(-y); + const p = new Point2(x,y,_1n6); + p.assertValidity(); + return p; + } + function challenge(...args) { + return modN(bytesToNumberBE(taggedHash("BIP0340/challenge", ...args))); + } + function schnorrGetPublicKey2(privateKey) { + return schnorrGetExtPubKey(privateKey).bytes; + } + function schnorrSign2(message, privateKey, auxRand=randomBytes2(32)) { + const m = ensureBytes2("message", message); + const {bytes: px, scalar: d} = schnorrGetExtPubKey(privateKey); + const a = ensureBytes2("auxRand", auxRand, 32); + const t = numTo32b2(d ^ bytesToNumberBE(taggedHash("BIP0340/aux", a))); + const rand = taggedHash("BIP0340/nonce", t, px, m); + const k_ = modN(bytesToNumberBE(rand)); + if (k_ === _0n6) + throw new Error("sign failed: k is zero"); + const {bytes: rx, scalar: k} = schnorrGetExtPubKey(k_); + const e = challenge(rx, px, m); + const sig = new Uint8Array(64); + sig.set(rx, 0); + sig.set(numTo32b2(modN(k + e * d)), 32); + if (!schnorrVerify2(sig, m, px)) + throw new Error("sign: Invalid signature produced"); + return sig; + } + function schnorrVerify2(signature, message, publicKey) { + const sig = ensureBytes2("signature", signature, 64); + const m = ensureBytes2("message", message); + const pub = ensureBytes2("publicKey", publicKey, 32); + try { + const P = lift_x(bytesToNumberBE(pub)); + const r = bytesToNumberBE(sig.subarray(0, 32)); + if (!fe(r)) + return false; + const s = bytesToNumberBE(sig.subarray(32, 64)); + if (!ge(s)) + return false; + const e = challenge(numTo32b2(r), pointToBytes(P), m); + const R = GmulAdd(P, s, modN(-e)); + if (!R || !R.hasEvenY() || R.toAffine().x !== r) + return false; + return true; + } catch (error) { + return false; + } + } + var schnorr2 = { + getPublicKey: schnorrGetPublicKey2, + sign: schnorrSign2, + verify: schnorrVerify2, + utils: { + randomPrivateKey: secp256k1.utils.randomPrivateKey, + lift_x, + pointToBytes, + numberToBytesBE, + bytesToNumberBE, + taggedHash, + mod: mod2 + } + }; + var isoMap = isogenyMap(Fp, [// xNum + ["0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa8c7", "0x7d3d4c80bc321d5b9f315cea7fd44c5d595d2fc0bf63b92dfff1044f17c6581", "0x534c328d23f234e6e2a413deca25caece4506144037c40314ecbd0b53d9dd262", "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa88c"], // xDen + ["0xd35771193d94918a9ca34ccbb7b640dd86cd409542f8487d9fe6b745781eb49b", "0xedadc6f64383dc1df7c4b2d51b54225406d36b641f5e41bbc52a56612a8c6d14", "0x0000000000000000000000000000000000000000000000000000000000000001"// LAST 1 + ], // yNum + ["0x4bda12f684bda12f684bda12f684bda12f684bda12f684bda12f684b8e38e23c", "0xc75e0c32d5cb7c0fa9d0a54b12a0a6d5647ab046d686da6fdffc90fc201d71a3", "0x29a6194691f91a73715209ef6512e576722830a201be2018a765e85a9ecee931", "0x2f684bda12f684bda12f684bda12f684bda12f684bda12f684bda12f38e38d84"], // yDen + ["0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffff93b", "0x7a06534bb8bdb49fd5e9e6632722c2989467c1bfc8e8d978dfb425d2685c2573", "0x6484aa716545ca2cf3a70c3fa8fe337e0a3d21162f0d6299a7bf8192bfd2a76f", "0x0000000000000000000000000000000000000000000000000000000000000001"// LAST 1 + ]].map((i)=>i.map((j)=>BigInt(j)))); + var mapSWU = mapToCurveSimpleSWU(Fp, { + A: BigInt("0x3f8731abdd661adca08a5558f0f5d272e953d363cb6f0e5d405447c01a444533"), + B: BigInt("1771"), + Z: Fp.create(BigInt("-11")) + }); + var {hashToCurve, encodeToCurve} = createHasher(secp256k1.ProjectivePoint, (scalars)=>{ + const {x, y} = mapSWU(Fp.create(scalars[0])); + return isoMap(x, y); + } + , { + DST: "secp256k1_XMD:SHA-256_SSWU_RO_", + encodeDST: "secp256k1_XMD:SHA-256_SSWU_NU_", + p: Fp.ORDER, + m: 1, + k: 128, + expand: "xmd", + hash: sha2562 + }); + + // node_modules/.pnpm/@scure+bip32@1.3.0/node_modules/@scure/bip32/lib/esm/index.js + var Point3 = secp256k1.ProjectivePoint; + var base58check2 = base58check(sha2562); + function bytesToNumber2(bytes2) { + return BigInt(`0x ${bytesToHex2(bytes2)}`); + } + function numberToBytes(num) { + return hexToBytes2(num.toString(16).padStart(64, "0")); + } + var MASTER_SECRET = utf8ToBytes2("Bitcoin seed"); + var BITCOIN_VERSIONS = { + private: 76066276, + public: 76067358 + }; + var HARDENED_OFFSET = 2147483648; + var hash160 = (data)=>ripemd160(sha2562(data)); + var fromU32 = (data)=>createView2(data).getUint32(0, false); + var toU32 = (n)=>{ + if (!Number.isSafeInteger(n) || n < 0 || n > 2 ** 32 - 1) { + throw new Error(`Invalid number=${n}. Should be from 0 to 2 ** 32 - 1`); + } + const buf = new Uint8Array(4); + createView2(buf).setUint32(0, n, false); + return buf; + } + ; + var HDKey = class { + get fingerprint() { + if (!this.pubHash) { + throw new Error("No publicKey set!"); + } + return fromU32(this.pubHash); + } + get identifier() { + return this.pubHash; + } + get pubKeyHash() { + return this.pubHash; + } + get privateKey() { + return this.privKeyBytes || null; + } + get publicKey() { + return this.pubKey || null; + } + get privateExtendedKey() { + const priv = this.privateKey; + if (!priv) { + throw new Error("No private key"); + } + return base58check2.encode(this.serialize(this.versions.private, concatBytes2(new Uint8Array([0]), priv))); + } + get publicExtendedKey() { + if (!this.pubKey) { + throw new Error("No public key"); + } + return base58check2.encode(this.serialize(this.versions.public, this.pubKey)); + } + static fromMasterSeed(seed, versions=BITCOIN_VERSIONS) { + bytes(seed); + if (8 * seed.length < 128 || 8 * seed.length > 512) { + throw new Error(`HDKey: wrong seed length=${seed.length}. Should be between 128 and 512 bits; 256 bits is advised)`); + } + const I = hmac(sha512, MASTER_SECRET, seed); + return new HDKey({ + versions, + chainCode: I.slice(32), + privateKey: I.slice(0, 32) + }); + } + static fromExtendedKey(base58key, versions=BITCOIN_VERSIONS) { + const keyBuffer = base58check2.decode(base58key); + const keyView = createView2(keyBuffer); + const version = keyView.getUint32(0, false); + const opt = { + versions, + depth: keyBuffer[4], + parentFingerprint: keyView.getUint32(5, false), + index: keyView.getUint32(9, false), + chainCode: keyBuffer.slice(13, 45) + }; + const key = keyBuffer.slice(45); + const isPriv = key[0] === 0; + if (version !== versions[isPriv ? "private" : "public"]) { + throw new Error("Version mismatch"); + } + if (isPriv) { + return new HDKey({ + ...opt, + privateKey: key.slice(1) + }); + } else { + return new HDKey({ + ...opt, + publicKey: key + }); + } + } + static fromJSON(json) { + return HDKey.fromExtendedKey(json.xpriv); + } + constructor(opt) { + this.depth = 0; + this.index = 0; + this.chainCode = null; + this.parentFingerprint = 0; + if (!opt || typeof opt !== "object") { + throw new Error("HDKey.constructor must not be called directly"); + } + this.versions = opt.versions || BITCOIN_VERSIONS; + this.depth = opt.depth || 0; + this.chainCode = opt.chainCode; + this.index = opt.index || 0; + this.parentFingerprint = opt.parentFingerprint || 0; + if (!this.depth) { + if (this.parentFingerprint || this.index) { + throw new Error("HDKey: zero depth with non-zero index/parent fingerprint"); + } + } + if (opt.publicKey && opt.privateKey) { + throw new Error("HDKey: publicKey and privateKey at same time."); + } + if (opt.privateKey) { + if (!secp256k1.utils.isValidPrivateKey(opt.privateKey)) { + throw new Error("Invalid private key"); + } + this.privKey = typeof opt.privateKey === "bigint" ? opt.privateKey : bytesToNumber2(opt.privateKey); + this.privKeyBytes = numberToBytes(this.privKey); + this.pubKey = secp256k1.getPublicKey(opt.privateKey, true); + } else if (opt.publicKey) { + this.pubKey = Point3.fromHex(opt.publicKey).toRawBytes(true); + } else { + throw new Error("HDKey: no public or private key provided"); + } + this.pubHash = hash160(this.pubKey); + } + derive(path) { + if (!/^[mM]'?/.test(path)) { + throw new Error('Path must start with "m" or "M"'); + } + if (/^[mM]'?$/.test(path)) { + return this; + } + const parts = path.replace(/^[mM]'?\//, "").split("/"); + let child = this; + for (const c of parts) { + const m = /^(\d+)('?)$/.exec(c); + if (!m || m.length !== 3) { + throw new Error(`Invalid child index: ${c}`); + } + let idx = +m[1]; + if (!Number.isSafeInteger(idx) || idx >= HARDENED_OFFSET) { + throw new Error("Invalid index"); + } + if (m[2] === "'") { + idx += HARDENED_OFFSET; + } + child = child.deriveChild(idx); + } + return child; + } + deriveChild(index) { + if (!this.pubKey || !this.chainCode) { + throw new Error("No publicKey or chainCode set"); + } + let data = toU32(index); + if (index >= HARDENED_OFFSET) { + const priv = this.privateKey; + if (!priv) { + throw new Error("Could not derive hardened child key"); + } + data = concatBytes2(new Uint8Array([0]), priv, data); + } else { + data = concatBytes2(this.pubKey, data); + } + const I = hmac(sha512, this.chainCode, data); + const childTweak = bytesToNumber2(I.slice(0, 32)); + const chainCode = I.slice(32); + if (!secp256k1.utils.isValidPrivateKey(childTweak)) { + throw new Error("Tweak bigger than curve order"); + } + const opt = { + versions: this.versions, + chainCode, + depth: this.depth + 1, + parentFingerprint: this.fingerprint, + index + }; + try { + if (this.privateKey) { + const added = mod2(this.privKey + childTweak, secp256k1.CURVE.n); + if (!secp256k1.utils.isValidPrivateKey(added)) { + throw new Error("The tweak was out of range or the resulted private key is invalid"); + } + opt.privateKey = added; + } else { + const added = Point3.fromHex(this.pubKey).add(Point3.fromPrivateKey(childTweak)); + if (added.equals(Point3.ZERO)) { + throw new Error("The tweak was equal to negative P, which made the result key invalid"); + } + opt.publicKey = added.toRawBytes(true); + } + return new HDKey(opt); + } catch (err) { + return this.deriveChild(index + 1); + } + } + sign(hash2) { + if (!this.privateKey) { + throw new Error("No privateKey set!"); + } + bytes(hash2, 32); + return secp256k1.sign(hash2, this.privKey).toCompactRawBytes(); + } + verify(hash2, signature) { + bytes(hash2, 32); + bytes(signature, 64); + if (!this.publicKey) { + throw new Error("No publicKey set!"); + } + let sig; + try { + sig = secp256k1.Signature.fromCompact(signature); + } catch (error) { + return false; + } + return secp256k1.verify(sig, hash2, this.publicKey); + } + wipePrivateData() { + this.privKey = void 0; + if (this.privKeyBytes) { + this.privKeyBytes.fill(0); + this.privKeyBytes = void 0; + } + return this; + } + toJSON() { + return { + xpriv: this.privateExtendedKey, + xpub: this.publicExtendedKey + }; + } + serialize(version, key) { + if (!this.chainCode) { + throw new Error("No chainCode set"); + } + bytes(key, 33); + return concatBytes2(toU32(version), new Uint8Array([this.depth]), toU32(this.parentFingerprint), toU32(this.index), this.chainCode, key); + } + } + ; + + // node_modules/.pnpm/@noble+hashes@0.5.9/node_modules/@noble/hashes/esm/hmac.js + var HMAC2 = class extends Hash { + constructor(hash2, _key) { + super(); + this.finished = false; + this.destroyed = false; + assertHash(hash2); + const key = toBytes(_key); + this.iHash = hash2.create(); + if (!(this.iHash instanceof Hash)) + throw new TypeError("Expected instance of class which extends utils.Hash"); + const blockLen = this.blockLen = this.iHash.blockLen; + this.outputLen = this.iHash.outputLen; + const pad = new Uint8Array(blockLen); + pad.set(key.length > this.iHash.blockLen ? hash2.create().update(key).digest() : key); + for (let i = 0; i < pad.length; i++) + pad[i] ^= 54; + this.iHash.update(pad); + this.oHash = hash2.create(); + for (let i = 0; i < pad.length; i++) + pad[i] ^= 54 ^ 92; + this.oHash.update(pad); + pad.fill(0); + } + update(buf) { + if (this.destroyed) + throw new Error("instance is destroyed"); + this.iHash.update(buf); + return this; + } + digestInto(out) { + if (this.destroyed) + throw new Error("instance is destroyed"); + if (!(out instanceof Uint8Array) || out.length !== this.outputLen) + throw new Error("HMAC: Invalid output buffer"); + if (this.finished) + throw new Error("digest() was already called"); + 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 || (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; + } + destroy() { + this.destroyed = true; + this.oHash.destroy(); + this.iHash.destroy(); + } + } + ; + var hmac2 = (hash2,key,message)=>new HMAC2(hash2,key).update(message).digest(); + hmac2.create = (hash2,key)=>new HMAC2(hash2,key); + hmac2.init = hmac2.create; + + // node_modules/.pnpm/nostr-tools@1.1.0/node_modules/nostr-tools/lib/nostr.esm.js + var __defProp2 = Object.defineProperty; + var __export2 = (target,all)=>{ + for (var name in all) + __defProp2(target, name, { + get: all[name], + enumerable: true + }); + } + ; + function getPublicKey(privateKey) { + return utils.bytesToHex(schnorr.getPublicKey(privateKey)); + } + var utf8Decoder = new TextDecoder("utf-8"); + var utf8Encoder = new TextEncoder(); + function serializeEvent(evt) { + return JSON.stringify([0, evt.pubkey, evt.created_at, evt.kind, evt.tags, evt.content]); + } + function getEventHash(event) { + let eventHash = sha256(utf8Encoder.encode(serializeEvent(event))); + return utils.bytesToHex(eventHash); + } + function validateEvent(event) { + if (event.id !== getEventHash(event)) + return false; + if (typeof event.content !== "string") + return false; + if (typeof event.created_at !== "number") + return false; + if (!Array.isArray(event.tags)) + return false; + for (let i = 0; i < event.tags.length; i++) { + let tag = event.tags[i]; + if (!Array.isArray(tag)) + return false; + for (let j = 0; j < tag.length; j++) { + if (typeof tag[j] === "object") + return false; + } + } + return true; + } + function signEvent(event, key) { + return utils.bytesToHex(schnorr.signSync(getEventHash(event), key)); + } + var nip04_exports = {}; + __export2(nip04_exports, { + decrypt: ()=>decrypt, + encrypt: ()=>encrypt + }); + async function encrypt(privkey, pubkey, text) { + const key = getSharedSecret(privkey, "02" + pubkey); + const normalizedKey = getNormalizedX(key); + let iv = Uint8Array.from(randomBytes(16)); + let plaintext = utf8Encoder.encode(text); + let cryptoKey = await crypto.subtle.importKey("raw", normalizedKey, { + name: "AES-CBC" + }, false, ["encrypt"]); + let ciphertext = await crypto.subtle.encrypt({ + name: "AES-CBC", + iv + }, cryptoKey, plaintext); + let ctb64 = base64.encode(new Uint8Array(ciphertext)); + let ivb64 = base64.encode(new Uint8Array(iv.buffer)); + return `${ctb64}?iv=${ivb64}`; + } + async function decrypt(privkey, pubkey, data) { + let[ctb64,ivb64] = data.split("?iv="); + let key = getSharedSecret(privkey, "02" + pubkey); + let normalizedKey = getNormalizedX(key); + let cryptoKey = await crypto.subtle.importKey("raw", normalizedKey, { + name: "AES-CBC" + }, false, ["decrypt"]); + let ciphertext = base64.decode(ctb64); + let iv = base64.decode(ivb64); + let plaintext = await crypto.subtle.decrypt({ + name: "AES-CBC", + iv + }, cryptoKey, ciphertext); + let text = utf8Decoder.decode(plaintext); + return text; + } + function getNormalizedX(key) { + return key.slice(1, 33); + } + var nip05_exports = {}; + __export2(nip05_exports, { + queryProfile: ()=>queryProfile, + searchDomain: ()=>searchDomain, + useFetchImplementation: ()=>useFetchImplementation + }); + var _fetch; + try { + _fetch = fetch; + } catch {} + function useFetchImplementation(fetchImplementation) { + _fetch = fetchImplementation; + } + async function searchDomain(domain, query="") { + try { + let res = await (await _fetch(`https://${domain}/.well-known/nostr.json?name=${query}`)).json(); + return res.names; + } catch (_) { + return {}; + } + } + async function queryProfile(fullname) { + let[name,domain] = fullname.split("@"); + if (!domain) { + domain = name; + name = "_"; + } + if (!name.match(/^[a-z0-9-_]+$/)) + return null; + let res = await (await _fetch(`https://${domain}/.well-known/nostr.json?name=${name}`)).json(); + if (!res?.names?.[name]) + return null; + let pubkey = res.names[name]; + let relays = res.relays?.[pubkey] || []; + return { + pubkey, + relays + }; + } + var nip06_exports = {}; + __export2(nip06_exports, { + generateSeedWords: ()=>generateSeedWords, + privateKeyFromSeedWords: ()=>privateKeyFromSeedWords, + validateWords: ()=>validateWords + }); + function privateKeyFromSeedWords(mnemonic) { + let root = HDKey.fromMasterSeed((0, + import_bip39.mnemonicToSeedSync)(mnemonic)); + let privateKey = root.derive(`m/44'/1237'/0'/0/0`).privateKey; + if (!privateKey) + throw new Error("could not derive private key"); + return utils.bytesToHex(privateKey); + } + function generateSeedWords() { + return (0, + import_bip39.generateMnemonic)(import_english.wordlist); + } + function validateWords(words) { + return (0, + import_bip39.validateMnemonic)(words, import_english.wordlist); + } + var nip19_exports = {}; + __export2(nip19_exports, { + decode: ()=>decode, + neventEncode: ()=>neventEncode, + noteEncode: ()=>noteEncode, + nprofileEncode: ()=>nprofileEncode, + npubEncode: ()=>npubEncode, + nsecEncode: ()=>nsecEncode + }); + function decode(nip19) { + let {prefix, words} = bech32.decode(nip19, 1e3); + let data = new Uint8Array(bech32.fromWords(words)); + if (prefix === "nprofile") { + let tlv = parseTLV(data); + if (!tlv[0]?.[0]) + throw new Error("missing TLV 0 for nprofile"); + if (tlv[0][0].length !== 32) + throw new Error("TLV 0 should be 32 bytes"); + return { + type: "nprofile", + data: { + pubkey: utils.bytesToHex(tlv[0][0]), + relays: tlv[1].map((d)=>utf8Decoder.decode(d)) + } + }; + } + if (prefix === "nevent") { + let tlv = parseTLV(data); + if (!tlv[0]?.[0]) + throw new Error("missing TLV 0 for nevent"); + if (tlv[0][0].length !== 32) + throw new Error("TLV 0 should be 32 bytes"); + return { + type: "nevent", + data: { + id: utils.bytesToHex(tlv[0][0]), + relays: tlv[1].map((d)=>utf8Decoder.decode(d)) + } + }; + } + if (prefix === "nsec" || prefix === "npub" || prefix === "note") { + return { + type: prefix, + data: utils.bytesToHex(data) + }; + } + throw new Error(`unknown prefix ${prefix}`); + } + function parseTLV(data) { + let result = {}; + let rest = data; + while (rest.length > 0) { + let t = rest[0]; + let l = rest[1]; + let v = rest.slice(2, 2 + l); + rest = rest.slice(2 + l); + if (v.length < l) + continue; + result[t] = result[t] || []; + result[t].push(v); + } + return result; + } + function nsecEncode(hex2) { + return encodeBytes("nsec", hex2); + } + function npubEncode(hex2) { + return encodeBytes("npub", hex2); + } + function noteEncode(hex2) { + return encodeBytes("note", hex2); + } + function encodeBytes(prefix, hex2) { + let data = utils.hexToBytes(hex2); + let words = bech32.toWords(data); + return bech32.encode(prefix, words, 1e3); + } + function nprofileEncode(profile) { + let data = encodeTLV({ + 0: [utils.hexToBytes(profile.pubkey)], + 1: (profile.relays || []).map((url)=>utf8Encoder.encode(url)) + }); + let words = bech32.toWords(data); + return bech32.encode("nprofile", words, 1e3); + } + function neventEncode(event) { + let data = encodeTLV({ + 0: [utils.hexToBytes(event.id)], + 1: (event.relays || []).map((url)=>utf8Encoder.encode(url)) + }); + let words = bech32.toWords(data); + return bech32.encode("nevent", words, 1e3); + } + function encodeTLV(tlv) { + let entries = []; + Object.entries(tlv).forEach(([t,vs])=>{ + vs.forEach((v)=>{ + let entry = new Uint8Array(v.length + 2); + entry.set([parseInt(t)], 0); + entry.set([v.length], 1); + entry.set(v, 2); + entries.push(entry); + } + ); + } + ); + return utils.concatBytes(...entries); + } + var nip26_exports = {}; + __export2(nip26_exports, { + createDelegation: ()=>createDelegation, + getDelegator: ()=>getDelegator + }); + function createDelegation(privateKey, parameters) { + let conditions = []; + if ((parameters.kind || -1) >= 0) + conditions.push(`kind=${parameters.kind}`); + if (parameters.until) + conditions.push(`created_at<${parameters.until}`); + if (parameters.since) + conditions.push(`created_at>${parameters.since}`); + let cond = conditions.join("&"); + if (cond === "") + throw new Error("refusing to create a delegation without any conditions"); + let sighash = sha256(utf8Encoder.encode(`nostr:delegation:${parameters.pubkey}:${cond}`)); + let sig = utils.bytesToHex(schnorr.signSync(sighash, privateKey)); + return { + from: getPublicKey(privateKey), + to: parameters.pubkey, + cond, + sig + }; + } + function getDelegator(event) { + let tag = event.tags.find((tag2)=>tag2[0] === "delegation" && tag2.length >= 4); + if (!tag) + return null; + let pubkey = tag[1]; + let cond = tag[2]; + let sig = tag[3]; + let conditions = cond.split("&"); + for (let i = 0; i < conditions.length; i++) { + let[key,operator,value] = conditions[i].split(/\b/); + if (key === "kind" && operator === "=" && event.kind === parseInt(value)) + continue; + else if (key === "created_at" && operator === "<" && event.created_at < parseInt(value)) + continue; + else if (key === "created_at" && operator === ">" && event.created_at > parseInt(value)) + continue; + else + return null; + } + let sighash = sha256(utf8Encoder.encode(`nostr:delegation:${event.pubkey}:${cond}`)); + if (!schnorr.verifySync(sig, sighash, pubkey)) + return null; + return pubkey; + } + utils.hmacSha256Sync = (key,...msgs)=>hmac2(sha256, key, utils.concatBytes(...msgs)); + utils.sha256Sync = (...msgs)=>sha256(utils.concatBytes(...msgs)); + + // node_modules/.pnpm/nostr-tools@1.1.0/node_modules/nostr-tools/utils.ts + var utf8Decoder2 = new TextDecoder("utf-8"); + var utf8Encoder2 = new TextEncoder(); + + // node_modules/.pnpm/nostr-tools@1.1.0/node_modules/nostr-tools/nip04.ts + async function encrypt2(privkey, pubkey, text) { + const key = getSharedSecret(privkey, "02" + pubkey); + const normalizedKey = getNormalizedX2(key); + let iv = Uint8Array.from(randomBytes(16)); + let plaintext = utf8Encoder2.encode(text); + let cryptoKey = await crypto.subtle.importKey("raw", normalizedKey, { + name: "AES-CBC" + }, false, ["encrypt"]); + let ciphertext = await crypto.subtle.encrypt({ + name: "AES-CBC", + iv + }, cryptoKey, plaintext); + let ctb64 = base64.encode(new Uint8Array(ciphertext)); + let ivb64 = base64.encode(new Uint8Array(iv.buffer)); + return `${ctb64}?iv=${ivb64}`; + } + async function decrypt2(privkey, pubkey, data) { + let[ctb64,ivb64] = data.split("?iv="); + let key = getSharedSecret(privkey, "02" + pubkey); + let normalizedKey = getNormalizedX2(key); + let cryptoKey = await crypto.subtle.importKey("raw", normalizedKey, { + name: "AES-CBC" + }, false, ["decrypt"]); + let ciphertext = base64.decode(ctb64); + let iv = base64.decode(ivb64); + let plaintext = await crypto.subtle.decrypt({ + name: "AES-CBC", + iv + }, cryptoKey, ciphertext); + let text = utf8Decoder2.decode(plaintext); + return text; + } + function getNormalizedX2(key) { + return key.slice(1, 33); + } + + // src/storage.ts + var import_webextension_polyfill = __toESM(require_browser_polyfill()); + async function readPrivateKey() { + const data = await import_webextension_polyfill.default.storage.local.get("private_key"/* PRIVATE_KEY */ + ); + return data["private_key"/* PRIVATE_KEY */ + ]; + } + async function readRelays() { + const data = await import_webextension_polyfill.default.storage.local.get("relays"/* RELAYS */ + ); + return data["relays"/* RELAYS */ + ]; + } + async function readPermissions() { + let {permissions={}} = await import_webextension_polyfill.default.storage.local.get("permissions"/* PERMISSIONS */ + ); + var needsUpdate = false; + for (let host in permissions) { + if (permissions[host].condition === "expirable" && permissions[host].created_at < Date.now() / 1e3 - 5 * 60) { + delete permissions[host]; + needsUpdate = true; + } + } + if (needsUpdate) + import_webextension_polyfill.default.storage.local.set({ + permissions + }); + return permissions; + } + async function updatePermission(host, permission) { + import_webextension_polyfill.default.storage.local.set({ + permissions: { + ...await import_webextension_polyfill.default.storage.local.get("permissions"/* PERMISSIONS */ + ).permissions || {}, + [host]: { + ...permission, + created_at: Math.round(Date.now() / 1e3) + } + } + }); + } + + // src/common.ts + var PERMISSIONS_REQUIRED = { + getPublicKey: 1, + getRelays: 5, + signEvent: 10, + "nip04.encrypt": 20, + "nip04.decrypt": 20 + }; + async function readPermissionLevel(host) { + return (await readPermissions())[host]?.level || 0; + } + + // src/background.js + var prompts = {}; + import_webextension_polyfill2.default.runtime.onMessage.addListener(async(req,sender)=>{ + let {prompt} = req; + if (prompt) { + return handlePromptMessage(req, sender); + } else { + return handleContentScriptMessage(req); + } + } + ); + import_webextension_polyfill2.default.runtime.onMessageExternal.addListener(async({type, params},sender)=>{ + let extensionId = new URL(sender.url).host; + handleContentScriptMessage({ + type, + params, + host: extensionId + }); + } + ); + async function handleContentScriptMessage({type, params, host}) { + let level = await readPermissionLevel(host); + if (level >= PERMISSIONS_REQUIRED[type]) {} else { + try { + await promptPermission(host, PERMISSIONS_REQUIRED[type], params); + } catch (_) { + return { + error: `insufficient permissions, required ${PERMISSIONS_REQUIRED[type]}` + }; + } + } + let privateKey = await readPrivateKey(); + if (!privateKey) { + return { + error: "no private key found" + }; + } + let sk = privateKey; + try { + switch (type) { + case "getPublicKey": + { + return getPublicKey(sk); + } + case "getRelays": + { + let relays = await readRelays(); + return relays || {}; + } + case "signEvent": + { + let {event} = params; + if (!event.pubkey) + event.pubkey = getPublicKey(sk); + if (!event.id) + event.id = getEventHash(event); + if (!validateEvent(event)) + return { + error: "invalid event" + }; + event.sig = await signEvent(event, sk); + return event; + } + case "nip04.encrypt": + { + let {peer, plaintext} = params; + return encrypt2(sk, peer, plaintext); + } + case "nip04.decrypt": + { + let {peer, ciphertext} = params; + return decrypt2(sk, peer, ciphertext); + } + } + } catch (error) { + return { + error: { + message: error.message, + stack: error.stack + } + }; + } + } + function handlePromptMessage({id, condition, host, level}, sender) { + switch (condition) { + case "forever": + case "expirable": + prompts[id]?.resolve?.(); + updatePermission(host, { + level, + condition + }); + break; + case "single": + prompts[id]?.resolve?.(); + break; + case "no": + prompts[id]?.reject?.(); + break; + } + delete prompts[id]; + import_webextension_polyfill2.default.windows.remove(sender.tab.windowId); + } + function promptPermission(host, level, params) { + let id = Math.random().toString().slice(4); + let qs = new URLSearchParams({ + host, + level, + id, + params: JSON.stringify(params) + }); + return new Promise((resolve,reject)=>{ + import_webextension_polyfill2.default.windows.create({ + url: `${import_webextension_polyfill2.default.runtime.getURL("prompt.html")}?${qs.toString()}`, + type: "popup", + width: 600, + height: 400 + }); + prompts[id] = { + resolve, + reject + }; + } + ); + } +} +)(); +/*! Bundled license information: + +@noble/hashes/utils.js: + (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *) + +@scure/base/lib/index.js: + (*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) *) + +@scure/bip39/index.js: + (*! scure-bip39 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) *) + +@noble/secp256k1/lib/esm/index.js: + (*! noble-secp256k1 - MIT License (c) 2019 Paul Miller (paulmillr.com) *) + +@noble/hashes/esm/utils.js: + (*! noble-hashes - MIT License (c) 2021 Paul Miller (paulmillr.com) *) + +@scure/base/lib/esm/index.js: + (*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) *) + +@noble/hashes/esm/utils.js: + (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *) + +@noble/curves/esm/abstract/utils.js: + (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *) + +@noble/curves/esm/abstract/modular.js: + (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *) + +@noble/curves/esm/abstract/curve.js: + (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *) + +@noble/curves/esm/abstract/weierstrass.js: + (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *) + +@noble/curves/esm/_shortw_utils.js: + (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *) + +@noble/curves/esm/secp256k1.js: + (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *) +*/