trex-proxy-browser-extension-sdk 0.1.0

package/build/ReclaimExtensionSDK-mv2.bundle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReclaimExtensionSDK-mv2.bundle.js","mappings":"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AAM,IAAM,IAAM,IAAM,GAAM,IAAM,IAAM,IAAM,IAAM,GAAM,GAAM,IAAM,IAAM,IAAM,IAAM,GAAM,GAAM,IAAM,GAAM,IAAM,GAAM,GAAM,IAAM,IAAM,IAAM,GAAM,IAAM,GAAM,GAAM,IAAM,GAAM,IAAM,GAAM,IAAM,GAAM,GAAM,IAAM,IAAM,GAAM,IAAM,IAAM,GAAM,IAAM,GAAM,GAAM,IAAM,IAAM,GAAM,GAAM,GAAM,GAAM,EAAM,GAAM,GAAM,IAAM,IAAM,IAAM,GAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,GAAM,IAAM,IAAM,IAAM,GAAM,IAAM,IAAM,GAAM,IAAM,IAAM,IAAM,IAAM,IAAM,EAAM,IAAM,IAAM,GAAM,GAAM,GAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,GAAM,GAAM,IAAM,IAAM,IAAM,IAAM,GAAM,IAAM,IAAM,GAAM,EAAM,IAAM,GAAM,GAAM,GAAM,GAAM,IAAM,IAAM,IAAM,GAAM,IAAM,IAAM,IAAM,IAAM,GAAM,IAAM,IAAM,IAAM,IAAM,IAAM,GAAM,IAAM,IAAM,IAAM,GAAM,GAAM,IAAM,IAAM,IAAM,IAAM,GAAM,IAAM,IAAM,GAAM,IAAM,GAAM,IAAM,GAAM,GAAM,IAAM,GAAM,IAAM,IAC//C+rB,GAAK,CAAC,GAAM,EAAM,IAAM,IAAM,GAAM,GAAM,IAAM,GAAM,IAAM,GAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,GAAM,IAAM,IAAM,GAAM,IAAM,IAAM,GAAM,IAAM,GAAM,GAAM,IAAM,IAAM,IAAM,IAAM,GAAM,IAAM,IAAM,GAAM,IAAM,IAAM,GAAM,GAAM,IAAM,GAAM,IAAM,GAAM,GAAM,IAAM,IAAM,GAAM,EAAM,GAAM,IAAM,IAAM,GAAM,IAAM,GAAM,IAAM,IAAM,GAAM,IAAM,GAAM,IAAM,IAAM,IAAM,GAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,GAAM,IAAM,IAAM,GAAM,IAAM,GAAM,IAAM,IAAM,IAAM,IAAM,IAAM,GAAM,GAAM,IAAM,IAAM,IAAM,IAAM,GAAM,GAAM,GAAM,GAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,EAAM,IAAM,IAAM,IAAM,GAAM,IAAM,IAAM,GAAM,EAAM,IAAM,IAAM,GAAM,EAAM,IAAM,GAAM,GAAM,IAAM,IAAM,GAAM,GAAM,EAAM,IAAM,IAAM,IAAM,EAAM,EAAM,GAAM,IAAM,IAAM,GAAM,IAAM,GAAM,GAAM,GAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,GAAM,IAAM,IAAM,GAAM,IAAM,IAAM,IAAM,GAAM,IAAM,GAAM,IAAM,IAAM,IAAM,GAAM,IAAM,GAAM,IAAM,GAAM,GAAM,IAAM,IAAM,IAAM,IAAM,GAAM,GAAM,IAAM,GAAM,IAAM,GAAM,IAAM,GAAM,GAAM,GAAM,IAAM,IAAM,IAAM,GAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,GAAM,IAAM,GAAM,IAAM,IAAM,GAAM,IAAM,EAAM,IAAM,GAAM,IAAM,GAAM,GAAM,GAAM,GAAM,IAAM,IAAM,GAAM,GAAM,GAAM,IAAM,IAAM,GAAM,IAAM,GAAM,GAAM,GAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,GAAM,GAAM,IAAM,GAAM,IAAM,IAAM,IAAM,IAAM,IAAM,GAAM,IAAM,GAAM,IAAM,GAAM,GAAM,GAAM,EAAM,IAAM,IAAM,IAAM,IAAM,GAAM,IAAM,IAAM,GAAM,GAAM,GAAM,GAAM,GAAM,KAEhgDxvB,GAAK,CAAC,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,SAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,UAAY,UAAY,UAAY,UAAY,UAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,EAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,SAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,SAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,WAAY,WAAY,UAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,SAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,UAAY,UAAY,WAAY,WAAY,UAAY,UAAY,WAAY,WAAY,UAAY,UAAY,UAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,SAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAC1/FC,GAAK,CAAC,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,SAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,SAAY,WAAY,WAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,UAAY,WAAY,UAAY,WAAY,UAAY,UAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,EAAY,UAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,SAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,UAAY,WAAY,WAAY,UAAY,UAAY,UAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,SAAY,SAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,UAAY,UAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAC1/FwvB,GAAK,CAAC,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,SAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,SAAY,WAAY,UAAY,WAAY,UAAY,WAAY,SAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,UAAY,WAAY,UAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,UAAY,WAAY,UAAY,WAAY,WAAY,WAAY,EAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,SAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,UAAY,WAAY,WAAY,UAAY,UAAY,UAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,UAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,SAAY,WAAY,UAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAC1/FC,GAAK,CAAC,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,SAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,SAAY,WAAY,UAAY,WAAY,UAAY,WAAY,SAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,UAAY,WAAY,UAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,UAAY,WAAY,UAAY,WAAY,WAAY,WAAY,EAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,SAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,UAAY,WAAY,WAAY,UAAY,UAAY,UAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,UAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,SAAY,WAAY,UAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAE1/FC,GAAK,CAAC,WAAY,WAAY,UAAY,UAAY,WAAY,UAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,SAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,UAAY,UAAY,SAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,UAAY,WAAY,SAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,SAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,EAAY,UAAY,UAAY,UAAY,WAAY,WAAY,UAAY,WAAY,UAAY,UAAY,WAAY,WAAY,UAAY,UAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,UAAY,UAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,UAAY,WAAY,UAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,UAAY,WAAY,UAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,SAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,UAAY,WAAY,UAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,YAC1/FC,GAAK,CAAC,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,SAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,UAAY,WAAY,WAAY,UAAY,WAAY,WAAY,UAAY,UAAY,SAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,UAAY,WAAY,UAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,SAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,EAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,WAAY,UAAY,WAAY,UAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,WAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,UAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,UAAY,UAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,SAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,WAAY,UAAY,WAAY,WAAY,UAAY,WAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,SAAY,WAAY,WAAY,UAAY,WAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,YAC1/FC,GAAK,CAAC,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,SAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,SAAY,WAAY,WAAY,UAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,UAAY,SAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,UAAY,EAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,UAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,UAAY,WAAY,UAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,UAAY,UAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,UAAY,WAAY,UAAY,WAAY,UAAY,UAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,SAAY,WAAY,WAAY,UAAY,WAAY,WAAY,UAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,UAAY,WAAY,WAAY,SAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,YAC1/FC,GAAK,CAAC,WAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,SAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,SAAY,WAAY,SAAY,UAAY,WAAY,WAAY,UAAY,WAAY,WAAY,SAAY,UAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,EAAY,WAAY,UAAY,UAAY,WAAY,UAAY,WAAY,WAAY,UAAY,UAAY,WAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,UAAY,UAAY,UAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,SAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,UAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,SAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,UAAY,WAAY,WAAY,UAAY,WAAY,UAAY,WAAY,WAAY,WAAY,UAAY,WAAY,YAE1/FrmB,GAAK,CAAC,EAAY,UAAY,UAAY,UAAY,UAAY,UAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,UAAY,SAAY,UAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,UAAY,SAAY,UAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,UAAY,UAAY,WAAY,UAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,WAAY,UAAY,UAAY,UAAY,UAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,SAAY,UAAY,UAAY,UAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,SAAY,UAAY,UAAY,UAAY,UAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,UAAY,UAAY,UAAY,SAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,YAC1/FC,GAAK,CAAC,EAAY,UAAY,UAAY,UAAY,UAAY,UAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,UAAY,WAAY,UAAY,SAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,UAAY,SAAY,UAAY,UAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,UAAY,UAAY,UAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,UAAY,SAAY,UAAY,UAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,UAAY,UAAY,UAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,SAAY,UAAY,UAAY,UAAY,UAAY,UAAY,WAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,UAAY,WAAY,UAAY,SAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,YAC1/FqmB,GAAK,CAAC,EAAY,UAAY,UAAY,UAAY,UAAY,UAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,SAAY,UAAY,UAAY,UAAY,UAAY,UAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,SAAY,UAAY,UAAY,UAAY,UAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,UAAY,UAAY,UAAY,WAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,UAAY,UAAY,UAAY,UAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,SAAY,UAAY,UAAY,WAAY,UAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,SAAY,UAAY,UAAY,WAAY,UAAY,UAAY,UAAY,UAAY,SAAY,UAAY,UAAY,UAAY,UAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,YAC1/FC,GAAK,CAAC,EAAY,UAAY,UAAY,UAAY,UAAY,UAAY,UAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,UAAY,UAAY,UAAY,UAAY,SAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,UAAY,UAAY,UAAY,UAAY,UAAY,UAAY,SAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,WAAY,SAAY,UAAY,UAAY,UAAY,UAAY,SAAY,UA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","sources":["webpack://trex-proxy-browser-extension-sdk/./src/utils/logger/debugLogger.js","webpack://trex-proxy-browser-extension-sdk/./src/utils/logger/index.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ieee754/index.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/buffer/index.js","webpack://trex-proxy-browser-extension-sdk/./src/utils/websocket-polyfill.js","webpack://trex-proxy-browser-extension-sdk/./src/utils/claim-creator/get-dynamic-geo.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/base64-js/index.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/process/browser.js","webpack://trex-proxy-browser-extension-sdk/./src/utils/fetch-calls.js","webpack://trex-proxy-browser-extension-sdk/./src/utils/offscreen-manager.js","webpack://trex-proxy-browser-extension-sdk/./src/utils/proof-generator/proof-generator.js","webpack://trex-proxy-browser-extension-sdk/./src/utils/proof-generator/proof-formatter.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/jsonpath-plus/dist/index-browser-esm.js","webpack://trex-proxy-browser-extension-sdk/./src/utils/claim-creator/params-extractor-utils.js","webpack://trex-proxy-browser-extension-sdk/./src/utils/claim-creator/network-filter.js","webpack://trex-proxy-browser-extension-sdk/./src/utils/claim-creator/params-extractor.js","webpack://trex-proxy-browser-extension-sdk/./src/utils/claim-creator/claim-creator.js","webpack://trex-proxy-browser-extension-sdk/./src/utils/session-timer.js","webpack://trex-proxy-browser-extension-sdk/./src/background/sessionManager.js","webpack://trex-proxy-browser-extension-sdk/./src/background/messageRouter.js","webpack://trex-proxy-browser-extension-sdk/./src/background/proofQueue.js","webpack://trex-proxy-browser-extension-sdk/./src/background/cookieUtils.js","webpack://trex-proxy-browser-extension-sdk/./src/background/background.js","webpack://trex-proxy-browser-extension-sdk/./src/utils/logger/LogEntry.js","webpack://trex-proxy-browser-extension-sdk/./src/utils/logger/LoggerService.js","webpack://trex-proxy-browser-extension-sdk/./src/utils/logger/constants.js","webpack://trex-proxy-browser-extension-sdk/./src/utils/constants/constants.js","webpack://trex-proxy-browser-extension-sdk/./src/utils/constants/interfaces.js","webpack://trex-proxy-browser-extension-sdk/./src/utils/polyfills.js","webpack://trex-proxy-browser-extension-sdk/webpack/bootstrap","webpack://trex-proxy-browser-extension-sdk/webpack/runtime/compat get default export","webpack://trex-proxy-browser-extension-sdk/webpack/runtime/define property getters","webpack://trex-proxy-browser-extension-sdk/webpack/runtime/harmony module decorator","webpack://trex-proxy-browser-extension-sdk/webpack/runtime/hasOwnProperty shorthand","webpack://trex-proxy-browser-extension-sdk/webpack/runtime/make namespace object","webpack://trex-proxy-browser-extension-sdk/./node_modules/@noble/hashes/esm/_assert.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/@noble/hashes/esm/_u64.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/@noble/hashes/esm/crypto.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/@noble/hashes/esm/utils.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/@noble/hashes/esm/sha3.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/_version.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/utils/properties.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/utils/errors.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/utils/data.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/crypto/keccak.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/@noble/hashes/esm/_sha2.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/@noble/hashes/esm/sha256.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/@noble/curves/esm/abstract/utils.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/@noble/curves/esm/abstract/modular.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/@noble/hashes/esm/hmac.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/@noble/curves/esm/abstract/curve.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/@noble/curves/esm/abstract/weierstrass.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/@noble/curves/esm/_shortw_utils.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/@noble/curves/esm/secp256k1.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/utils/maths.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/constants/hashes.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/crypto/signature.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/crypto/signing-key.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/address/address.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/address/checks.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/utils/utf8.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/hash/message.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/constants/strings.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/utils/rlp-encode.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/hash/authorization.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/hash/id.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/hash/typed-data.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/constants/addresses.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/@noble/hashes/esm/pbkdf2.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/@noble/hashes/esm/sha512.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/crypto/crypto-browser.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/crypto/sha2.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/utils/rlp-decode.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/transaction/accesslist.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/transaction/address.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/transaction/transaction.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/transaction/authorization.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/providers/provider.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/providers/abstract-signer.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/wallet/base-wallet.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/crypto/hmac.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/@noble/hashes/esm/ripemd160.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/crypto/ripemd160.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/crypto/random.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/utils/base58.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/wordlists/decode-owl.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/wordlists/wordlist.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/wordlists/wordlist-owl.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/wordlists/lang-en.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/crypto/pbkdf2.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/wallet/mnemonic.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/aes-js/lib.esm/aes.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/aes-js/lib.esm/mode.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/aes-js/lib.esm/mode-cbc.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/aes-js/lib.esm/mode-cfb.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/aes-js/lib.esm/mode-ctr.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/aes-js/lib.esm/mode-ofb.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/@noble/hashes/esm/scrypt.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/crypto/scrypt.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/utils/uuid.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/wallet/utils.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/wallet/json-keystore.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/wallet/hdwallet.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/wallet/json-crowdsale.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/aes-js/lib.esm/padding.js","webpack://trex-proxy-browser-extension-sdk/./node_modules/ethers/lib.esm/wallet/wallet.js","webpack://trex-proxy-browser-extension-sdk/./src/ReclaimExtensionSDK.js"],"sourcesContent":["// Local debug logger for development\n// Usage: import { debugLogger, DebugLogType } from './debugLogger';\n\nexport const DebugLogType = Object.freeze({\n  BACKGROUND: \"background\",\n  CONTENT: \"content\",\n  POPUP: \"popup\",\n  INIT: \"init\",\n  VERIFICATION: \"verification\",\n  FETCH: \"fetch\",\n  PROVIDER: \"provider\",\n  CLAIM: \"claim\",\n  PROOF: \"proof\",\n  OFFSCREEN: \"offscreen\",\n  POLYFILLS: \"polyfills\",\n  SESSION_TIMER: \"session-timer\",\n});\n\nclass DebugLogger {\n  constructor() {\n    this.enabled = true;\n    this.allowedTypes = new Set(); // If empty, allow all types\n  }\n\n  enable() {\n    this.enabled = true;\n  }\n\n  disable() {\n    this.enabled = false;\n  }\n\n  setTypes(typesArray) {\n    if (!Array.isArray(typesArray)) return;\n    this.allowedTypes = new Set(typesArray);\n  }\n\n  clearTypes() {\n    this.allowedTypes.clear();\n  }\n\n  log(type, ...args) {\n    if (!this.enabled) return;\n    if (this.allowedTypes.size > 0 && !this.allowedTypes.has(type)) return;\n    const color = DebugLogger.typeColor(type);\n    // eslint-disable-next-line no-console\n    console.log(`%c[${type}][INFO]`, `color: ${color}; font-weight: bold;`, ...args);\n  }\n\n  info(type, ...args) {\n    if (!this.enabled) return;\n    if (this.allowedTypes.size > 0 && !this.allowedTypes.has(type)) return;\n    const color = DebugLogger.typeColor(type);\n    // eslint-disable-next-line no-console\n    console.info(`%c[${type}][INFO]`, `color: ${color}; font-weight: bold;`, ...args);\n  }\n\n  warn(type, ...args) {\n    if (!this.enabled) return;\n    if (this.allowedTypes.size > 0 && !this.allowedTypes.has(type)) return;\n    const color = DebugLogger.typeColor(type, \"warn\");\n    // eslint-disable-next-line no-console\n    console.warn(`%c[${type}][WARN]`, `color: ${color}; font-weight: bold;`, ...args);\n  }\n\n  error(type, ...args) {\n    if (!this.enabled) return;\n    if (this.allowedTypes.size > 0 && !this.allowedTypes.has(type)) return;\n    const color = DebugLogger.typeColor(type, \"error\");\n    // eslint-disable-next-line no-console\n    console.error(`%c[${type}][ERROR]`, `color: ${color}; font-weight: bold;`, ...args);\n  }\n\n  static typeColor(type, level = \"info\") {\n    // Assign colors to types for better visibility\n    const colors = {\n      background: \"#0074D9\",\n      content: \"#2ECC40\",\n      popup: \"#FF851B\",\n      init: \"#B10DC9\",\n      verification: \"#FF4136\",\n      fetch: \"#39CCCC\",\n      provider: \"#FFDC00\",\n      claim: \"#7FDBFF\",\n      proof: \"#85144b\",\n      offscreen: \"#AAAAAA\",\n      polyfills: \"#0074D9\",\n      \"session-timer\": \"#2ECC40\",\n    };\n    const levelColors = {\n      info: \"\", // default, use type color\n      warn: \"#FFA500\", // orange\n      error: \"#FF0000\", // red\n    };\n    // Try to match a known type, else use gray\n    const key = Object.keys(colors).find((k) => type.toLowerCase().includes(k));\n    let baseColor = colors[key] || \"#888888\";\n    if (level !== \"info\") {\n      baseColor = levelColors[level] || baseColor;\n    }\n    return baseColor;\n  }\n}\n\nexport const debugLogger = new DebugLogger();\n","import { loggerService, createContextLogger } from \"./LoggerService\";\nimport { debugLogger } from \"./debugLogger\";\n\n// Enable debugLogger in development, disable in production\nif (typeof process !== \"undefined\" && process.env && process.env.NODE_ENV === \"production\") {\n  debugLogger.disable();\n} else {\n  debugLogger.enable();\n}\n\nexport { DebugLogType } from \"./debugLogger\";\nexport { debugLogger };\nexport { LogEntry } from \"./LogEntry\";\nexport { loggerService, createContextLogger };\nexport { LOGGING_ENDPOINTS, LOG_TYPES, LOG_SOURCES, LOG_LEVEL, EVENT_TYPES } from \"./constants\";\n","/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */\nexports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = ((value * c) - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <https://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nconst base64 = require('base64-js')\nconst ieee754 = require('ieee754')\nconst customInspectSymbol =\n  (typeof Symbol === 'function' && typeof Symbol['for'] === 'function') // eslint-disable-line dot-notation\n    ? Symbol['for']('nodejs.util.inspect.custom') // eslint-disable-line dot-notation\n    : null\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\nconst K_MAX_LENGTH = 0x7fffffff\nexports.kMaxLength = K_MAX_LENGTH\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Print warning and recommend using `buffer` v4.x which has an Object\n *               implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * We report that the browser does not support typed arrays if the are not subclassable\n * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`\n * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support\n * for __proto__ and has a buggy typed array implementation.\n */\nBuffer.TYPED_ARRAY_SUPPORT = typedArraySupport()\n\nif (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&\n    typeof console.error === 'function') {\n  console.error(\n    'This browser lacks typed array (Uint8Array) support which is required by ' +\n    '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'\n  )\n}\n\nfunction typedArraySupport () {\n  // Can typed array instances can be augmented?\n  try {\n    const arr = new Uint8Array(1)\n    const proto = { foo: function () { return 42 } }\n    Object.setPrototypeOf(proto, Uint8Array.prototype)\n    Object.setPrototypeOf(arr, proto)\n    return arr.foo() === 42\n  } catch (e) {\n    return false\n  }\n}\n\nObject.defineProperty(Buffer.prototype, 'parent', {\n  enumerable: true,\n  get: function () {\n    if (!Buffer.isBuffer(this)) return undefined\n    return this.buffer\n  }\n})\n\nObject.defineProperty(Buffer.prototype, 'offset', {\n  enumerable: true,\n  get: function () {\n    if (!Buffer.isBuffer(this)) return undefined\n    return this.byteOffset\n  }\n})\n\nfunction createBuffer (length) {\n  if (length > K_MAX_LENGTH) {\n    throw new RangeError('The value \"' + length + '\" is invalid for option \"size\"')\n  }\n  // Return an augmented `Uint8Array` instance\n  const buf = new Uint8Array(length)\n  Object.setPrototypeOf(buf, Buffer.prototype)\n  return buf\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new TypeError(\n        'The \"string\" argument must be of type string. Received type number'\n      )\n    }\n    return allocUnsafe(arg)\n  }\n  return from(arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\nfunction from (value, encodingOrOffset, length) {\n  if (typeof value === 'string') {\n    return fromString(value, encodingOrOffset)\n  }\n\n  if (ArrayBuffer.isView(value)) {\n    return fromArrayView(value)\n  }\n\n  if (value == null) {\n    throw new TypeError(\n      'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\n      'or Array-like Object. Received type ' + (typeof value)\n    )\n  }\n\n  if (isInstance(value, ArrayBuffer) ||\n      (value && isInstance(value.buffer, ArrayBuffer))) {\n    return fromArrayBuffer(value, encodingOrOffset, length)\n  }\n\n  if (typeof SharedArrayBuffer !== 'undefined' &&\n      (isInstance(value, SharedArrayBuffer) ||\n      (value && isInstance(value.buffer, SharedArrayBuffer)))) {\n    return fromArrayBuffer(value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'number') {\n    throw new TypeError(\n      'The \"value\" argument must not be of type number. Received type number'\n    )\n  }\n\n  const valueOf = value.valueOf && value.valueOf()\n  if (valueOf != null && valueOf !== value) {\n    return Buffer.from(valueOf, encodingOrOffset, length)\n  }\n\n  const b = fromObject(value)\n  if (b) return b\n\n  if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&\n      typeof value[Symbol.toPrimitive] === 'function') {\n    return Buffer.from(value[Symbol.toPrimitive]('string'), encodingOrOffset, length)\n  }\n\n  throw new TypeError(\n    'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\n    'or Array-like Object. Received type ' + (typeof value)\n  )\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(value, encodingOrOffset, length)\n}\n\n// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:\n// https://github.com/feross/buffer/pull/148\nObject.setPrototypeOf(Buffer.prototype, Uint8Array.prototype)\nObject.setPrototypeOf(Buffer, Uint8Array)\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be of type number')\n  } else if (size < 0) {\n    throw new RangeError('The value \"' + size + '\" is invalid for option \"size\"')\n  }\n}\n\nfunction alloc (size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpreted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(size).fill(fill, encoding)\n      : createBuffer(size).fill(fill)\n  }\n  return createBuffer(size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(size, fill, encoding)\n}\n\nfunction allocUnsafe (size) {\n  assertSize(size)\n  return createBuffer(size < 0 ? 0 : checked(size) | 0)\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(size)\n}\n\nfunction fromString (string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('Unknown encoding: ' + encoding)\n  }\n\n  const length = byteLength(string, encoding) | 0\n  let buf = createBuffer(length)\n\n  const actual = buf.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    buf = buf.slice(0, actual)\n  }\n\n  return buf\n}\n\nfunction fromArrayLike (array) {\n  const length = array.length < 0 ? 0 : checked(array.length) | 0\n  const buf = createBuffer(length)\n  for (let i = 0; i < length; i += 1) {\n    buf[i] = array[i] & 255\n  }\n  return buf\n}\n\nfunction fromArrayView (arrayView) {\n  if (isInstance(arrayView, Uint8Array)) {\n    const copy = new Uint8Array(arrayView)\n    return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength)\n  }\n  return fromArrayLike(arrayView)\n}\n\nfunction fromArrayBuffer (array, byteOffset, length) {\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\"offset\" is outside of buffer bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\"length\" is outside of buffer bounds')\n  }\n\n  let buf\n  if (byteOffset === undefined && length === undefined) {\n    buf = new Uint8Array(array)\n  } else if (length === undefined) {\n    buf = new Uint8Array(array, byteOffset)\n  } else {\n    buf = new Uint8Array(array, byteOffset, length)\n  }\n\n  // Return an augmented `Uint8Array` instance\n  Object.setPrototypeOf(buf, Buffer.prototype)\n\n  return buf\n}\n\nfunction fromObject (obj) {\n  if (Buffer.isBuffer(obj)) {\n    const len = checked(obj.length) | 0\n    const buf = createBuffer(len)\n\n    if (buf.length === 0) {\n      return buf\n    }\n\n    obj.copy(buf, 0, 0, len)\n    return buf\n  }\n\n  if (obj.length !== undefined) {\n    if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {\n      return createBuffer(0)\n    }\n    return fromArrayLike(obj)\n  }\n\n  if (obj.type === 'Buffer' && Array.isArray(obj.data)) {\n    return fromArrayLike(obj.data)\n  }\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < K_MAX_LENGTH` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= K_MAX_LENGTH) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return b != null && b._isBuffer === true &&\n    b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false\n}\n\nBuffer.compare = function compare (a, b) {\n  if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)\n  if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError(\n      'The \"buf1\", \"buf2\" arguments must be one of type Buffer or Uint8Array'\n    )\n  }\n\n  if (a === b) return 0\n\n  let x = a.length\n  let y = b.length\n\n  for (let i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!Array.isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  let i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  const buffer = Buffer.allocUnsafe(length)\n  let pos = 0\n  for (i = 0; i < list.length; ++i) {\n    let buf = list[i]\n    if (isInstance(buf, Uint8Array)) {\n      if (pos + buf.length > buffer.length) {\n        if (!Buffer.isBuffer(buf)) buf = Buffer.from(buf)\n        buf.copy(buffer, pos)\n      } else {\n        Uint8Array.prototype.set.call(\n          buffer,\n          buf,\n          pos\n        )\n      }\n    } else if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    } else {\n      buf.copy(buffer, pos)\n    }\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length\n  }\n  if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    throw new TypeError(\n      'The \"string\" argument must be one of type string, Buffer, or ArrayBuffer. ' +\n      'Received type ' + typeof string\n    )\n  }\n\n  const len = string.length\n  const mustMatch = (arguments.length > 2 && arguments[2] === true)\n  if (!mustMatch && len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  let loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) {\n          return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8\n        }\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  let loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coercion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)\n// to detect a Buffer instance. It's not possible to use `instanceof Buffer`\n// reliably in a browserify context because there could be multiple different\n// copies of the 'buffer' package in use. This method works even for Buffer\n// instances that were created from another copy of the `buffer` package.\n// See: https://github.com/feross/buffer/issues/154\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  const i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  const len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (let i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  const len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (let i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  const len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (let i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  const length = this.length\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.toLocaleString = Buffer.prototype.toString\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  let str = ''\n  const max = exports.INSPECT_MAX_BYTES\n  str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()\n  if (this.length > max) str += ' ... '\n  return '<Buffer ' + str + '>'\n}\nif (customInspectSymbol) {\n  Buffer.prototype[customInspectSymbol] = Buffer.prototype.inspect\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (isInstance(target, Uint8Array)) {\n    target = Buffer.from(target, target.offset, target.byteLength)\n  }\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError(\n      'The \"target\" argument must be one of type Buffer or Uint8Array. ' +\n      'Received type ' + (typeof target)\n    )\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  let x = thisEnd - thisStart\n  let y = end - start\n  const len = Math.min(x, y)\n\n  const thisCopy = this.slice(thisStart, thisEnd)\n  const targetCopy = target.slice(start, end)\n\n  for (let i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset // Coerce to Number.\n  if (numberIsNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [val], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  let indexSize = 1\n  let arrLength = arr.length\n  let valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  let i\n  if (dir) {\n    let foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      let found = true\n      for (let j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  const remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  const strLen = string.length\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  let i\n  for (i = 0; i < length; ++i) {\n    const parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (numberIsNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset >>> 0\n    if (isFinite(length)) {\n      length = length >>> 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  const remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  let loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return asciiWrite(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  const res = []\n\n  let i = start\n  while (i < end) {\n    const firstByte = buf[i]\n    let codePoint = null\n    let bytesPerSequence = (firstByte > 0xEF)\n      ? 4\n      : (firstByte > 0xDF)\n          ? 3\n          : (firstByte > 0xBF)\n              ? 2\n              : 1\n\n    if (i + bytesPerSequence <= end) {\n      let secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nconst MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  const len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  let res = ''\n  let i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  let ret = ''\n  end = Math.min(buf.length, end)\n\n  for (let i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  let ret = ''\n  end = Math.min(buf.length, end)\n\n  for (let i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  const len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  let out = ''\n  for (let i = start; i < end; ++i) {\n    out += hexSliceLookupTable[buf[i]]\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  const bytes = buf.slice(start, end)\n  let res = ''\n  // If bytes.length is odd, the last 8 bits must be ignored (same as node.js)\n  for (let i = 0; i < bytes.length - 1; i += 2) {\n    res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256))\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  const len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  const newBuf = this.subarray(start, end)\n  // Return an augmented `Uint8Array` instance\n  Object.setPrototypeOf(newBuf, Buffer.prototype)\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUintLE =\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  let val = this[offset]\n  let mul = 1\n  let i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUintBE =\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  let val = this[offset + --byteLength]\n  let mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUint8 =\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUint16LE =\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUint16BE =\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUint32LE =\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUint32BE =\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE (offset) {\n  offset = offset >>> 0\n  validateNumber(offset, 'offset')\n  const first = this[offset]\n  const last = this[offset + 7]\n  if (first === undefined || last === undefined) {\n    boundsError(offset, this.length - 8)\n  }\n\n  const lo = first +\n    this[++offset] * 2 ** 8 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 24\n\n  const hi = this[++offset] +\n    this[++offset] * 2 ** 8 +\n    this[++offset] * 2 ** 16 +\n    last * 2 ** 24\n\n  return BigInt(lo) + (BigInt(hi) << BigInt(32))\n})\n\nBuffer.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE (offset) {\n  offset = offset >>> 0\n  validateNumber(offset, 'offset')\n  const first = this[offset]\n  const last = this[offset + 7]\n  if (first === undefined || last === undefined) {\n    boundsError(offset, this.length - 8)\n  }\n\n  const hi = first * 2 ** 24 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 8 +\n    this[++offset]\n\n  const lo = this[++offset] * 2 ** 24 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 8 +\n    last\n\n  return (BigInt(hi) << BigInt(32)) + BigInt(lo)\n})\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  let val = this[offset]\n  let mul = 1\n  let i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  let i = byteLength\n  let mul = 1\n  let val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  const val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  const val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE (offset) {\n  offset = offset >>> 0\n  validateNumber(offset, 'offset')\n  const first = this[offset]\n  const last = this[offset + 7]\n  if (first === undefined || last === undefined) {\n    boundsError(offset, this.length - 8)\n  }\n\n  const val = this[offset + 4] +\n    this[offset + 5] * 2 ** 8 +\n    this[offset + 6] * 2 ** 16 +\n    (last << 24) // Overflow\n\n  return (BigInt(val) << BigInt(32)) +\n    BigInt(first +\n    this[++offset] * 2 ** 8 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 24)\n})\n\nBuffer.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE (offset) {\n  offset = offset >>> 0\n  validateNumber(offset, 'offset')\n  const first = this[offset]\n  const last = this[offset + 7]\n  if (first === undefined || last === undefined) {\n    boundsError(offset, this.length - 8)\n  }\n\n  const val = (first << 24) + // Overflow\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 8 +\n    this[++offset]\n\n  return (BigInt(val) << BigInt(32)) +\n    BigInt(this[++offset] * 2 ** 24 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 8 +\n    last)\n})\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUintLE =\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) {\n    const maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  let mul = 1\n  let i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUintBE =\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) {\n    const maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  let i = byteLength - 1\n  let mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUint8 =\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeUint16LE =\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\n  return offset + 2\n}\n\nBuffer.prototype.writeUint16BE =\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  this[offset] = (value >>> 8)\n  this[offset + 1] = (value & 0xff)\n  return offset + 2\n}\n\nBuffer.prototype.writeUint32LE =\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  this[offset + 3] = (value >>> 24)\n  this[offset + 2] = (value >>> 16)\n  this[offset + 1] = (value >>> 8)\n  this[offset] = (value & 0xff)\n  return offset + 4\n}\n\nBuffer.prototype.writeUint32BE =\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  this[offset] = (value >>> 24)\n  this[offset + 1] = (value >>> 16)\n  this[offset + 2] = (value >>> 8)\n  this[offset + 3] = (value & 0xff)\n  return offset + 4\n}\n\nfunction wrtBigUInt64LE (buf, value, offset, min, max) {\n  checkIntBI(value, min, max, buf, offset, 7)\n\n  let lo = Number(value & BigInt(0xffffffff))\n  buf[offset++] = lo\n  lo = lo >> 8\n  buf[offset++] = lo\n  lo = lo >> 8\n  buf[offset++] = lo\n  lo = lo >> 8\n  buf[offset++] = lo\n  let hi = Number(value >> BigInt(32) & BigInt(0xffffffff))\n  buf[offset++] = hi\n  hi = hi >> 8\n  buf[offset++] = hi\n  hi = hi >> 8\n  buf[offset++] = hi\n  hi = hi >> 8\n  buf[offset++] = hi\n  return offset\n}\n\nfunction wrtBigUInt64BE (buf, value, offset, min, max) {\n  checkIntBI(value, min, max, buf, offset, 7)\n\n  let lo = Number(value & BigInt(0xffffffff))\n  buf[offset + 7] = lo\n  lo = lo >> 8\n  buf[offset + 6] = lo\n  lo = lo >> 8\n  buf[offset + 5] = lo\n  lo = lo >> 8\n  buf[offset + 4] = lo\n  let hi = Number(value >> BigInt(32) & BigInt(0xffffffff))\n  buf[offset + 3] = hi\n  hi = hi >> 8\n  buf[offset + 2] = hi\n  hi = hi >> 8\n  buf[offset + 1] = hi\n  hi = hi >> 8\n  buf[offset] = hi\n  return offset + 8\n}\n\nBuffer.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE (value, offset = 0) {\n  return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt('0xffffffffffffffff'))\n})\n\nBuffer.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE (value, offset = 0) {\n  return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt('0xffffffffffffffff'))\n})\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    const limit = Math.pow(2, (8 * byteLength) - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  let i = 0\n  let mul = 1\n  let sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    const limit = Math.pow(2, (8 * byteLength) - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  let i = byteLength - 1\n  let mul = 1\n  let sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  this[offset] = (value >>> 8)\n  this[offset + 1] = (value & 0xff)\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\n  this[offset + 2] = (value >>> 16)\n  this[offset + 3] = (value >>> 24)\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  this[offset] = (value >>> 24)\n  this[offset + 1] = (value >>> 16)\n  this[offset + 2] = (value >>> 8)\n  this[offset + 3] = (value & 0xff)\n  return offset + 4\n}\n\nBuffer.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE (value, offset = 0) {\n  return wrtBigUInt64LE(this, value, offset, -BigInt('0x8000000000000000'), BigInt('0x7fffffffffffffff'))\n})\n\nBuffer.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE (value, offset = 0) {\n  return wrtBigUInt64BE(this, value, offset, -BigInt('0x8000000000000000'), BigInt('0x7fffffffffffffff'))\n})\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('Index out of range')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  const len = end - start\n\n  if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {\n    // Use built-in when available, missing from IE11\n    this.copyWithin(targetStart, start, end)\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, end),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n    if (val.length === 1) {\n      const code = val.charCodeAt(0)\n      if ((encoding === 'utf8' && code < 128) ||\n          encoding === 'latin1') {\n        // Fast path: If `val` fits into a single byte, use that numeric value.\n        val = code\n      }\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  } else if (typeof val === 'boolean') {\n    val = Number(val)\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  let i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    const bytes = Buffer.isBuffer(val)\n      ? val\n      : Buffer.from(val, encoding)\n    const len = bytes.length\n    if (len === 0) {\n      throw new TypeError('The value \"' + val +\n        '\" is invalid for argument \"value\"')\n    }\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// CUSTOM ERRORS\n// =============\n\n// Simplified versions from Node, changed for Buffer-only usage\nconst errors = {}\nfunction E (sym, getMessage, Base) {\n  errors[sym] = class NodeError extends Base {\n    constructor () {\n      super()\n\n      Object.defineProperty(this, 'message', {\n        value: getMessage.apply(this, arguments),\n        writable: true,\n        configurable: true\n      })\n\n      // Add the error code to the name to include it in the stack trace.\n      this.name = `${this.name} [${sym}]`\n      // Access the stack to generate the error message including the error code\n      // from the name.\n      this.stack // eslint-disable-line no-unused-expressions\n      // Reset the name to the actual name.\n      delete this.name\n    }\n\n    get code () {\n      return sym\n    }\n\n    set code (value) {\n      Object.defineProperty(this, 'code', {\n        configurable: true,\n        enumerable: true,\n        value,\n        writable: true\n      })\n    }\n\n    toString () {\n      return `${this.name} [${sym}]: ${this.message}`\n    }\n  }\n}\n\nE('ERR_BUFFER_OUT_OF_BOUNDS',\n  function (name) {\n    if (name) {\n      return `${name} is outside of buffer bounds`\n    }\n\n    return 'Attempt to access memory outside buffer bounds'\n  }, RangeError)\nE('ERR_INVALID_ARG_TYPE',\n  function (name, actual) {\n    return `The \"${name}\" argument must be of type number. Received type ${typeof actual}`\n  }, TypeError)\nE('ERR_OUT_OF_RANGE',\n  function (str, range, input) {\n    let msg = `The value of \"${str}\" is out of range.`\n    let received = input\n    if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {\n      received = addNumericalSeparator(String(input))\n    } else if (typeof input === 'bigint') {\n      received = String(input)\n      if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) {\n        received = addNumericalSeparator(received)\n      }\n      received += 'n'\n    }\n    msg += ` It must be ${range}. Received ${received}`\n    return msg\n  }, RangeError)\n\nfunction addNumericalSeparator (val) {\n  let res = ''\n  let i = val.length\n  const start = val[0] === '-' ? 1 : 0\n  for (; i >= start + 4; i -= 3) {\n    res = `_${val.slice(i - 3, i)}${res}`\n  }\n  return `${val.slice(0, i)}${res}`\n}\n\n// CHECK FUNCTIONS\n// ===============\n\nfunction checkBounds (buf, offset, byteLength) {\n  validateNumber(offset, 'offset')\n  if (buf[offset] === undefined || buf[offset + byteLength] === undefined) {\n    boundsError(offset, buf.length - (byteLength + 1))\n  }\n}\n\nfunction checkIntBI (value, min, max, buf, offset, byteLength) {\n  if (value > max || value < min) {\n    const n = typeof min === 'bigint' ? 'n' : ''\n    let range\n    if (byteLength > 3) {\n      if (min === 0 || min === BigInt(0)) {\n        range = `>= 0${n} and < 2${n} ** ${(byteLength + 1) * 8}${n}`\n      } else {\n        range = `>= -(2${n} ** ${(byteLength + 1) * 8 - 1}${n}) and < 2 ** ` +\n                `${(byteLength + 1) * 8 - 1}${n}`\n      }\n    } else {\n      range = `>= ${min}${n} and <= ${max}${n}`\n    }\n    throw new errors.ERR_OUT_OF_RANGE('value', range, value)\n  }\n  checkBounds(buf, offset, byteLength)\n}\n\nfunction validateNumber (value, name) {\n  if (typeof value !== 'number') {\n    throw new errors.ERR_INVALID_ARG_TYPE(name, 'number', value)\n  }\n}\n\nfunction boundsError (value, length, type) {\n  if (Math.floor(value) !== value) {\n    validateNumber(value, type)\n    throw new errors.ERR_OUT_OF_RANGE(type || 'offset', 'an integer', value)\n  }\n\n  if (length < 0) {\n    throw new errors.ERR_BUFFER_OUT_OF_BOUNDS()\n  }\n\n  throw new errors.ERR_OUT_OF_RANGE(type || 'offset',\n                                    `>= ${type ? 1 : 0} and <= ${length}`,\n                                    value)\n}\n\n// HELPER FUNCTIONS\n// ================\n\nconst INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node takes equal signs as end of the Base64 encoding\n  str = str.split('=')[0]\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = str.trim().replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  let codePoint\n  const length = string.length\n  let leadSurrogate = null\n  const bytes = []\n\n  for (let i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  const byteArray = []\n  for (let i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  let c, hi, lo\n  const byteArray = []\n  for (let i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  let i\n  for (i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\n// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass\n// the `instanceof` check but they should be treated as of that type.\n// See: https://github.com/feross/buffer/issues/166\nfunction isInstance (obj, type) {\n  return obj instanceof type ||\n    (obj != null && obj.constructor != null && obj.constructor.name != null &&\n      obj.constructor.name === type.name)\n}\nfunction numberIsNaN (obj) {\n  // For IE11 support\n  return obj !== obj // eslint-disable-line no-self-compare\n}\n\n// Create lookup table for `toString('hex')`\n// See: https://github.com/feross/buffer/issues/219\nconst hexSliceLookupTable = (function () {\n  const alphabet = '0123456789abcdef'\n  const table = new Array(256)\n  for (let i = 0; i < 16; ++i) {\n    const i16 = i * 16\n    for (let j = 0; j < 16; ++j) {\n      table[i16 + j] = alphabet[i] + alphabet[j]\n    }\n  }\n  return table\n})()\n\n// Return not function with Error if BigInt not supported\nfunction defineBigIntMethod (fn) {\n  return typeof BigInt === 'undefined' ? BufferBigIntNotDefined : fn\n}\n\nfunction BufferBigIntNotDefined () {\n  throw new Error('BigInt not supported')\n}\n","/**\n * WebSocket Polyfill\n *\n * This module provides a WebSocket polyfill that uses the browser's native WebSocket when available\n * or provides a mock implementation for background scripts where window is not available.\n * It ensures compatibility with Node.js-style WebSocket usage patterns.\n */\n\n// Check if we're in a context with window (browser/content script) or not (background script)\nconst isBackgroundContext = typeof window === \"undefined\";\nimport { debugLogger, DebugLogType } from \"./logger\";\n\n// Create either a real WebSocket wrapper or a mock implementation\nlet WebSocketPolyfill;\n\nif (!isBackgroundContext) {\n  // Browser context - use the native WebSocket\n  const BrowserWebSocket = window.WebSocket;\n\n  WebSocketPolyfill = class extends BrowserWebSocket {\n    constructor(url, protocols) {\n      debugLogger.info(\n        DebugLogType.POLYFILLS,\n        \"[WEBSOCKET-POLYFILL] Creating WebSocket with URL:\",\n        url,\n      );\n      super(url, protocols);\n\n      // Add event handling compatibility\n      this.addEventListener(\"error\", (event) => {\n        if (typeof this.onerror === \"function\") {\n          this.onerror(event);\n        }\n      });\n\n      this.addEventListener(\"open\", (event) => {\n        if (typeof this.onopen === \"function\") {\n          this.onopen(event);\n        }\n      });\n\n      this.addEventListener(\"close\", (event) => {\n        if (typeof this.onclose === \"function\") {\n          this.onclose(event);\n        }\n      });\n\n      this.addEventListener(\"message\", (event) => {\n        if (typeof this.onmessage === \"function\") {\n          this.onmessage(event);\n        }\n      });\n    }\n\n    // Add a promise-based send method expected by some libraries\n    sendPromise(data) {\n      return new Promise((resolve, reject) => {\n        try {\n          this.send(data);\n          resolve();\n        } catch (error) {\n          reject(error);\n        }\n      });\n    }\n  };\n\n  debugLogger.info(\n    DebugLogType.POLYFILLS,\n    \"[WEBSOCKET-POLYFILL] Using browser WebSocket implementation\",\n  );\n} else {\n  // Background script context - create a mock implementation\n  WebSocketPolyfill = class {\n    constructor(url, protocols) {\n      debugLogger.info(\n        DebugLogType.POLYFILLS,\n        \"[WEBSOCKET-POLYFILL] Creating mock WebSocket for background context\",\n      );\n      this.url = url;\n      this.protocols = protocols;\n      this.readyState = 3; // CLOSED\n\n      // Simulate being closed immediately\n      setTimeout(() => {\n        if (typeof this.onclose === \"function\") {\n          this.onclose({ code: 1000, reason: \"WebSockets not supported in background context\" });\n        }\n      }, 0);\n    }\n\n    // No-op methods\n    send() {\n      debugLogger.warn(\n        DebugLogType.POLYFILLS,\n        \"[WEBSOCKET-POLYFILL] Cannot use WebSockets in background context\",\n      );\n      throw new Error(\"WebSockets are not available in background context\");\n    }\n\n    close() {\n      // Already closed, no-op\n    }\n\n    sendPromise() {\n      return Promise.reject(new Error(\"WebSockets are not available in background context\"));\n    }\n\n    addEventListener() {\n      // No-op\n    }\n\n    removeEventListener() {\n      // No-op\n    }\n  };\n\n  debugLogger.info(\n    DebugLogType.POLYFILLS,\n    \"[WEBSOCKET-POLYFILL] Using mock WebSocket implementation for background context\",\n  );\n}\n\n// Export the WebSocket class and constructor\nexport const WebSocket = WebSocketPolyfill;\nexport default WebSocketPolyfill;\n\n// For CommonJS compatibility\nif (typeof module !== \"undefined\" && module.exports) {\n  module.exports = WebSocketPolyfill;\n  module.exports.WebSocket = WebSocketPolyfill;\n  module.exports.default = WebSocketPolyfill;\n}\n\ndebugLogger.info(DebugLogType.POLYFILLS, \"[WEBSOCKET-POLYFILL] WebSocket polyfill initialized\");\n","export const getUserLocationBasedOnIp = async () => {\n  try {\n    const response = await fetch(\"https://ipapi.co/json/\");\n    const data = await response.json();\n\n    if (response?.status !== 200) {\n      throw new Error(\"Failed to get user location based on IP\");\n    }\n\n    const countryCode = data?.[\"country_code\"] ?? \"US\";\n    return countryCode;\n  } catch (error) {\n    console.error(\"Error getting user location based on IP:\", error);\n    return \"US\"; // default to US if error\n  }\n};\n","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\n// Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction getLens (b64) {\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n  var validLen = b64.indexOf('=')\n  if (validLen === -1) validLen = len\n\n  var placeHoldersLen = validLen === len\n    ? 0\n    : 4 - (validLen % 4)\n\n  return [validLen, placeHoldersLen]\n}\n\n// base64 is 4/3 + up to two characters of the original data\nfunction byteLength (b64) {\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction _byteLength (b64, validLen, placeHoldersLen) {\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction toByteArray (b64) {\n  var tmp\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\n\n  var curByte = 0\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  var len = placeHoldersLen > 0\n    ? validLen - 4\n    : validLen\n\n  var i\n  for (i = 0; i < len; i += 4) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 18) |\n      (revLookup[b64.charCodeAt(i + 1)] << 12) |\n      (revLookup[b64.charCodeAt(i + 2)] << 6) |\n      revLookup[b64.charCodeAt(i + 3)]\n    arr[curByte++] = (tmp >> 16) & 0xFF\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 2) |\n      (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 10) |\n      (revLookup[b64.charCodeAt(i + 1)] << 4) |\n      (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] +\n    lookup[num >> 12 & 0x3F] +\n    lookup[num >> 6 & 0x3F] +\n    lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp =\n      ((uint8[i] << 16) & 0xFF0000) +\n      ((uint8[i + 1] << 8) & 0xFF00) +\n      (uint8[i + 2] & 0xFF)\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 2] +\n      lookup[(tmp << 4) & 0x3F] +\n      '=='\n    )\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 10] +\n      lookup[(tmp >> 4) & 0x3F] +\n      lookup[(tmp << 2) & 0x3F] +\n      '='\n    )\n  }\n\n  return parts.join('')\n}\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","import { API_ENDPOINTS, RECLAIM_SESSION_STATUS } from \"./constants\";\nimport { createContextLogger } from \"./logger/LoggerService\";\nimport { EVENT_TYPES, LOG_LEVEL, LOG_TYPES } from \"./logger/constants\";\n\nexport const fetchProviderData = async (providerId, sessionId, appId) => {\n  const logger = createContextLogger({\n    sessionId: sessionId || \"unknown\",\n    providerId: providerId || \"unknown\",\n    appId: appId || \"unknown\",\n    source: \"reclaim-extension-sdk\",\n    type: LOG_TYPES.FETCH_DATA,\n  });\n  try {\n    // PROVIDER_URL\n    const response = await fetch(`${API_ENDPOINTS.PROVIDER_URL(providerId)}`);\n    // check if response is valid\n    if (!response.ok) {\n      throw new Error(\"Failed to fetch provider data\");\n    }\n    logger.info({\n      message: \"Successfully fetched provider data from the backend: \" + JSON.stringify(response),\n      logLevel: LOG_LEVEL.INFO,\n      type: LOG_TYPES.FETCH_DATA,\n    });\n    const data = await response.json();\n    return data?.providers;\n  } catch (error) {\n    logger.error({\n      message: \"Error fetching provider data: \" + error.toString(),\n      logLevel: LOG_LEVEL.ERROR,\n      type: LOG_TYPES.FETCH_DATA,\n      eventType: EVENT_TYPES.RECLAIM_PROVIDER_DATA_FETCH_ERROR,\n    });\n    throw error;\n  }\n};\n\nexport const updateSessionStatus = async (sessionId, status, providerId, appId) => {\n  const logger = createContextLogger({\n    sessionId: sessionId || \"unknown\",\n    providerId: providerId || \"unknown\",\n    appId: appId || \"unknown\",\n    source: \"reclaim-extension-sdk\",\n    type: LOG_TYPES.FETCH_DATA,\n  });\n  try {\n    const response = await fetch(`${API_ENDPOINTS.UPDATE_SESSION_STATUS()}`, {\n      method: \"POST\",\n      headers: { \"Content-Type\": \"application/json\" },\n      body: JSON.stringify({ sessionId, status }),\n    });\n\n    if (!response.ok) {\n      throw new Error(\"Failed to update session status\");\n    }\n\n    logger.info({\n      message: \"Successfully updated session status: \" + status,\n      logLevel: LOG_LEVEL.INFO,\n      type: LOG_TYPES.FETCH_DATA,\n    });\n\n    const res = await response.json();\n    return res;\n  } catch (error) {\n    logger.error({\n      message: \"Error updating session status: \" + error.toString(),\n      logLevel: LOG_LEVEL.ERROR,\n      type: LOG_TYPES.FETCH_DATA,\n      eventType: EVENT_TYPES.UPDATE_SESSION_STATUS_ERROR,\n    });\n    throw error;\n  }\n};\n\nexport const submitProofOnCallback = async (proofs, submitUrl, sessionId, providerId, appId) => {\n  const logger = createContextLogger({\n    sessionId: sessionId || \"unknown\",\n    providerId: providerId || \"unknown\",\n    appId: appId || \"unknown\",\n    source: \"reclaim-extension-sdk\",\n    type: LOG_TYPES.FETCH_DATA,\n  });\n  try {\n    // 1. Convert the proofs array to a JSON string\n    const jsonStringOfProofs = JSON.stringify(proofs);\n    // 2. URL-encode the JSON string\n    const urlEncodedProofs = encodeURIComponent(jsonStringOfProofs);\n    // 3. Append the URL-encoded string to the submit URL\n    const response = await fetch(submitUrl, {\n      method: \"POST\",\n      headers: { \"Content-Type\": \"text/plain\" },\n      body: urlEncodedProofs, // Send the URL-encoded string as the raw body\n    });\n    const res = await response.text();\n    // check if response is valid\n    if (!response.ok) {\n      await updateSessionStatus(sessionId, RECLAIM_SESSION_STATUS.PROOF_SUBMISSION_FAILED);\n      throw new Error(\"Failed to submit proof to Callback and update session status\");\n    }\n    logger.info({\n      message: \"Successfully submitted proof to Callback and updated session status\",\n      logLevel: LOG_LEVEL.INFO,\n      type: LOG_TYPES.FETCH_DATA,\n      eventType: EVENT_TYPES.SUBMITTING_PROOF_TO_CALLBACK_URL_SUCCESS,\n    });\n\n    await updateSessionStatus(sessionId, RECLAIM_SESSION_STATUS.PROOF_SUBMITTED);\n    return res;\n  } catch (error) {\n    logger.error({\n      message: \"Error submitting proof to Callback: \" + error.toString(),\n      logLevel: LOG_LEVEL.ERROR,\n      type: LOG_TYPES.FETCH_DATA,\n    });\n    throw error;\n  }\n};\n","// src/utils/offscreen-manager.js\nimport { MESSAGE_ACTIONS, MESSAGE_SOURCES } from \"./constants\";\nimport { createContextLogger } from \"./logger/LoggerService\";\nimport { LOG_LEVEL, LOG_TYPES } from \"./logger/constants\";\n\nconst offscreenLogger = createContextLogger({\n  sessionId: \"unknown\",\n  providerId: \"unknown\",\n  appId: \"unknown\",\n  source: \"reclaim-extension-sdk\",\n  type: LOG_TYPES.OFFSCREEN,\n});\n\n// Track the offscreen document status\nlet offscreenReady = false;\nlet offscreenDocTimeout = null; // Used by waitForOffscreenReady's timeout\nlet offscreenCreationPromise = null;\n\n// Define the global listener first\nconst offscreenGlobalListener = (message) => {\n  if (\n    message?.action === MESSAGE_ACTIONS.OFFSCREEN_DOCUMENT_READY &&\n    message?.source === MESSAGE_SOURCES.OFFSCREEN &&\n    message?.target === MESSAGE_SOURCES.BACKGROUND\n  ) {\n    offscreenLogger.info({\n      message: \"[OFFSCREEN-MANAGER] Received offscreen ready signal (global listener).\",\n      logLevel: LOG_LEVEL.INFO,\n      type: LOG_TYPES.OFFSCREEN,\n    });\n\n    offscreenReady = true;\n    if (offscreenDocTimeout) {\n      clearTimeout(offscreenDocTimeout);\n      offscreenDocTimeout = null;\n    }\n  }\n};\n\n// Exported installer to attach the listener safely in SW context\nexport const installOffscreenReadyListener = () => {\n  if (\n    typeof chrome === \"undefined\" ||\n    !chrome.runtime ||\n    !chrome.runtime.onMessage ||\n    !chrome.runtime.onMessage.addListener ||\n    !chrome.runtime.onMessage.hasListener\n  ) {\n    return;\n  }\n  if (chrome.runtime.onMessage.hasListener(offscreenGlobalListener)) {\n    return;\n  }\n  chrome.runtime.onMessage.addListener(offscreenGlobalListener);\n};\n\n// Global listener for the ready signal from offscreen document.\n// This needs to be set up immediately to catch the ready signal if the offscreen document\n// initializes and sends it before any call to ensureOffscreenDocument.\nconst setupOffscreenReadyListener = () => {\n  if (\n    typeof chrome === \"undefined\" ||\n    !chrome.runtime ||\n    !chrome.runtime.onMessage ||\n    !chrome.runtime.onMessage.addListener ||\n    !chrome.runtime.onMessage.hasListener\n  ) {\n    return;\n  }\n  if (chrome.runtime.onMessage.hasListener(offscreenGlobalListener)) {\n    return;\n  }\n  chrome.runtime.onMessage.addListener(offscreenGlobalListener);\n};\n\nif (typeof chrome !== \"undefined\" && chrome.runtime && chrome.runtime.onMessage) {\n  setupOffscreenReadyListener();\n}\n\n// Set up listener immediately when the module loads\nsetupOffscreenReadyListener();\n\nasync function createOffscreenDocumentInternal() {\n  const offscreenUrl = chrome.runtime.getURL(\"trex-browser-extension-sdk/offscreen/offscreen.html\");\n  offscreenLogger.info({\n    message: \"[OFFSCREEN-MANAGER] Attempting to create offscreen document with URL:\",\n    logLevel: LOG_LEVEL.INFO,\n    type: LOG_TYPES.OFFSCREEN,\n    meta: { offscreenUrl },\n  });\n  try {\n    await chrome.offscreen.createDocument({\n      url: offscreenUrl,\n      reasons: [\"DOM_PARSER\", \"IFRAME_SCRIPTING\", \"BLOBS\"], // Added BLOBS for crypto if needed\n      justification:\n        \"Manages DOM-dependent operations like crypto and ZK proof generation for the extension.\",\n    });\n  } catch (error) {\n    if (\n      error.message &&\n      error.message.includes(\"Only a single offscreen document may be created.\")\n    ) {\n      offscreenLogger.info({\n        message:\n          \"[OFFSCREEN-MANAGER] Offscreen document already exists or creation was attempted by another part.\",\n        logLevel: LOG_LEVEL.INFO,\n        type: LOG_TYPES.OFFSCREEN,\n      });\n      // It exists, so we just need to wait for it to be ready if it's not already.\n      // The ensureOffscreenDocument logic will handle waiting for readiness.\n    } else {\n      offscreenLogger.error({\n        message: \"[OFFSCREEN-MANAGER] Error creating offscreen document:\",\n        logLevel: LOG_LEVEL.ERROR,\n        type: LOG_TYPES.OFFSCREEN,\n        meta: { error },\n      });\n      throw error; // Re-throw other errors\n    }\n  }\n}\n\nasync function waitForOffscreenReadyInternal(timeoutMs = 15000) {\n  if (offscreenReady) {\n    offscreenLogger.info({\n      message: \"[OFFSCREEN-MANAGER] Already ready (waitForOffscreenReadyInternal check)\",\n      logLevel: LOG_LEVEL.INFO,\n      type: LOG_TYPES.OFFSCREEN,\n    });\n    return true;\n  }\n\n  offscreenLogger.info({\n    message:\n      \"[OFFSCREEN-MANAGER] Waiting for offscreen document to be ready (timeout:- ${timeoutMs}ms)...\",\n    logLevel: LOG_LEVEL.INFO,\n    type: LOG_TYPES.OFFSCREEN,\n    meta: { timeoutMs },\n  });\n\n  // Proactively ping the offscreen document.\n  // This can help if the offscreen document is already running but this manager missed the initial ready signal.\n  try {\n    chrome.runtime.sendMessage({\n      action: MESSAGE_ACTIONS.PING_OFFSCREEN,\n      source: MESSAGE_SOURCES.BACKGROUND,\n      target: MESSAGE_SOURCES.OFFSCREEN,\n    });\n  } catch (e) {\n    offscreenLogger.info({\n      message: \"[OFFSCREEN-MANAGER] Synchronous error sending ping:\" + e?.message,\n      logLevel: LOG_LEVEL.INFO,\n      type: LOG_TYPES.OFFSCREEN,\n      meta: { error: e },\n    });\n  }\n\n  return new Promise((resolve) => {\n    if (offscreenReady) {\n      // Double check after setup\n      offscreenLogger.info({\n        message: \"[OFFSCREEN-MANAGER] Became ready while setting up promise.\",\n        logLevel: LOG_LEVEL.INFO,\n        type: LOG_TYPES.OFFSCREEN,\n      });\n      resolve(true);\n      return;\n    }\n\n    const listener = (message) => {\n      if (\n        message.action === MESSAGE_ACTIONS.OFFSCREEN_DOCUMENT_READY &&\n        message.source === MESSAGE_SOURCES.OFFSCREEN &&\n        message.target === MESSAGE_SOURCES.BACKGROUND\n      ) {\n        offscreenReady = true;\n        clearTimeout(localTimeoutId);\n        chrome.runtime.onMessage.removeListener(listener);\n        if (offscreenDocTimeout === localTimeoutId) {\n          // Clear global timeout if it's this one\n          offscreenDocTimeout = null;\n        }\n        resolve(true);\n      }\n    };\n\n    chrome.runtime.onMessage.addListener(listener);\n\n    // Clear any previous timeout and set a new one for this wait\n    if (offscreenDocTimeout) {\n      clearTimeout(offscreenDocTimeout);\n    }\n    const localTimeoutId = setTimeout(() => {\n      chrome.runtime.onMessage.removeListener(listener);\n      offscreenLogger.error({\n        message:\n          \"[OFFSCREEN-MANAGER] Timed out waiting for offscreen document after \" +\n          timeoutMs +\n          \" ms.\",\n        logLevel: LOG_LEVEL.ERROR,\n        type: LOG_TYPES.OFFSCREEN,\n        meta: { timeoutMs },\n      });\n\n      if (offscreenDocTimeout === localTimeoutId) {\n        offscreenDocTimeout = null;\n      }\n      resolve(false);\n    }, timeoutMs);\n    offscreenDocTimeout = localTimeoutId;\n  });\n}\n\nexport async function ensureOffscreenDocument(logger) {\n  if (offscreenReady) {\n    logger.info({\n      message: \"[OFFSCREEN-MANAGER] Document already confirmed ready.\",\n      logLevel: LOG_LEVEL.INFO,\n      type: LOG_TYPES.OFFSCREEN,\n    });\n    return true;\n  }\n\n  // If a creation process is already underway, await its completion.\n  if (offscreenCreationPromise) {\n    logger.info({\n      message: \"[OFFSCREEN-MANAGER] Creation already in progress, awaiting...\",\n      logLevel: LOG_LEVEL.INFO,\n      type: LOG_TYPES.OFFSCREEN,\n    });\n    await offscreenCreationPromise;\n    // After creation promise resolves, it might still not be \"ready\" (message might be pending)\n    // Fall through to waitForOffscreenReadyInternal\n  }\n\n  // Check if an offscreen document context already exists.\n  // This is useful if the service worker restarted but the offscreen document persisted.\n  if (chrome.runtime.getContexts) {\n    const contexts = await chrome.runtime.getContexts({ contextTypes: [\"OFFSCREEN_DOCUMENT\"] });\n    if (contexts.length > 0) {\n      await chrome.offscreen.closeDocument();\n      offscreenReady = false;\n    }\n  }\n\n  // If no context found and not ready, and no creation in progress, attempt to create.\n  if (!offscreenCreationPromise) {\n    logger.info({\n      message: \"[OFFSCREEN-MANAGER] No existing context/promise, initiating creation.\",\n      logLevel: LOG_LEVEL.INFO,\n      type: LOG_TYPES.OFFSCREEN,\n    });\n    offscreenCreationPromise = createOffscreenDocumentInternal().finally(() => {\n      offscreenCreationPromise = null; // Clear promise once operation (success or fail) is done\n    });\n    await offscreenCreationPromise;\n  }\n\n  // After ensuring creation was attempted (or awaited), wait for it to become ready.\n  const isReady = await waitForOffscreenReadyInternal(50000);\n  if (!isReady) {\n    throw new Error(\"Failed to initialize or confirm offscreen document readiness.\");\n  }\n  logger.info({\n    message: \"[OFFSCREEN-MANAGER] Offscreen document ensured to be ready.\",\n    logLevel: LOG_LEVEL.INFO,\n    type: LOG_TYPES.OFFSCREEN,\n  });\n  return true;\n}\n\nexport async function closeOffscreenDocument() {\n  try {\n    await chrome.offscreen.closeDocument();\n  } catch (e) {\n    // 容错\n  }\n  offscreenReady = false;\n}\n","// Import polyfills\nimport \"../polyfills\";\n\nimport { MESSAGE_ACTIONS, MESSAGE_SOURCES } from \"../constants/index\";\nimport { ensureOffscreenDocument, closeOffscreenDocument } from \"../offscreen-manager\";\nimport { EVENT_TYPES, LOG_LEVEL, LOG_TYPES } from \"../logger/constants\";\n\n/**\n * 在 Background 中调用：确保 offscreen 文档就绪后，将 claimData 通过消息发给 offscreen，\n * 由 offscreen 内的 createClaimOnAttestor 连 attestor 做证明生成。本函数等待 offscreen\n * 回传 GENERATE_PROOF_RESPONSE（成功则 resolve(response)，失败则 resolve({ success: false, error })），\n * 或 60 秒超时 / 发送失败时 reject。\n */\nexport const generateProof = async (claimData, bgLogger) => {\n  const proofLogger = bgLogger;\n\n  try {\n    proofLogger.setContext({\n      sessionId: claimData.sessionId || \"unknown\",\n      providerId: claimData.providerId || \"unknown\",\n      appId: claimData.applicationId || \"unknown\",\n    });\n\n    if (!claimData) {\n      proofLogger.error({\n        message: \"[PROOF-GENERATOR] No claim data provided for proof generation\",\n        logLevel: LOG_LEVEL.INFO,\n        type: LOG_TYPES.PROOF,\n      });\n      throw new Error(\"No claim data provided for proof generation\");\n    }\n    // 确保 offscreen 文档已创建并处于可接收消息状态\n    await ensureOffscreenDocument(proofLogger);\n\n    // 注册一次性的 GENERATE_PROOF_RESPONSE 监听，向 offscreen 发送 GENERATE_PROOF + claimData，超时或发送失败则 reject\n    return new Promise((resolve, reject) => {\n      const messageTimeout = setTimeout(() => {\n        proofLogger.error({\n          message: \"[PROOF-GENERATOR] Timeout waiting for offscreen document to generate proof\",\n          logLevel: LOG_LEVEL.ERROR,\n          type: LOG_TYPES.PROOF,\n        });\n        closeOffscreenDocument().then(() =>\n          reject({\n            success: false,\n            error: \"Timeout waiting for offscreen document to generate proof\",\n          }),\n        );\n      }, 60000); // 60 second timeout\n\n      // Create a message listener for the offscreen response\n      const messageListener = (response) => {\n        if (\n          response.action === MESSAGE_ACTIONS.GENERATE_PROOF_RESPONSE &&\n          response.source === MESSAGE_SOURCES.OFFSCREEN &&\n          response.target === MESSAGE_SOURCES.BACKGROUND\n        ) {\n          // Clear timeout and remove listener\n          clearTimeout(messageTimeout);\n          chrome.runtime.onMessage.removeListener(messageListener);\n\n          proofLogger.all({\n            message: \"[PROOF-GENERATOR] Offscreen response: \" + JSON.stringify(response),\n            logLevel: LOG_LEVEL.ALL,\n            type: LOG_TYPES.PROOF,\n            meta: { response },\n          });\n\n          // Check if the proof generation was successful\n          if (!response.success) {\n            proofLogger.error({\n              message: \"[PROOF-GENERATOR] Proof generation failed:\",\n              logLevel: LOG_LEVEL.ERROR,\n              type: LOG_TYPES.PROOF,\n              meta: { error: response.error },\n            });\n            (async () => {\n              await closeOffscreenDocument();\n              resolve({\n                success: false,\n                error: response.error || \"Unknown error in proof generation\",\n              });\n            })();\n            return;\n          }\n\n          // Edge case: success=true but proof contains an error\n          const embeddedErr =\n            response?.proof?.error?.message ||\n            (typeof response?.proof?.error === \"string\" ? response.proof.error : null);\n          if (embeddedErr) {\n            proofLogger.error({\n              message: \"[PROOF-GENERATOR] Proof contains embedded error: \" + embeddedErr,\n              logLevel: LOG_LEVEL.ERROR,\n              type: LOG_TYPES.PROOF,\n              meta: { error: embeddedErr },\n            });\n            (async () => {\n              await closeOffscreenDocument();\n              resolve({ success: false, error: embeddedErr });\n            })();\n            return;\n          }\n          // Return the successful response\n          proofLogger.info({\n            message: \"[PROOF-GENERATOR] Proof generation successful\",\n            logLevel: LOG_LEVEL.INFO,\n            type: LOG_TYPES.PROOF,\n          });\n          (async () => {\n            await closeOffscreenDocument();\n            resolve(response);\n          })();\n        }\n      };\n\n      chrome.runtime.onMessage.addListener(messageListener);\n\n      // 把 claimData 发给 offscreen；offscreen 内会调用 createClaimOnAttestor(claimData) 连 attestor 生成 proof，再回传 GENERATE_PROOF_RESPONSE\n      chrome.runtime.sendMessage(\n        {\n          action: MESSAGE_ACTIONS.GENERATE_PROOF,\n          source: MESSAGE_SOURCES.BACKGROUND,\n          target: MESSAGE_SOURCES.OFFSCREEN,\n          data: claimData,\n        },\n        () => {\n          if (chrome.runtime.lastError) {\n            clearTimeout(messageTimeout);\n            chrome.runtime.onMessage.removeListener(messageListener);\n            proofLogger.error({\n              message:\n                \"[PROOF-GENERATOR] Error sending message to offscreen document \" +\n                chrome.runtime.lastError.message,\n              logLevel: LOG_LEVEL.ERROR,\n              type: LOG_TYPES.PROOF,\n              meta: { error: chrome.runtime.lastError.message },\n            });\n            closeOffscreenDocument().then(() =>\n              reject({\n                success: false,\n                error:\n                  chrome.runtime.lastError.message || \"Error communicating with offscreen document\",\n              }),\n            );\n          }\n        },\n      );\n    });\n  } catch (error) {\n    proofLogger.error({\n      message: \"[PROOF-GENERATOR] Error in proof generation process: \" + error.message,\n      logLevel: LOG_LEVEL.ERROR,\n      type: LOG_TYPES.PROOF,\n      meta: { error },\n    });\n    await closeOffscreenDocument();\n    return {\n      success: false,\n      error: error.message || \"Unknown error in proof generation process\",\n    };\n  }\n};\n","import { ATTESTOR_WS_URL } from \"../constants\";\n\nexport const formatProof = (proof, requestData) => {\n  let formattedProof = {\n    identifier: proof.claim.identifier,\n    claimData: proof.claim,\n    signatures: [toHexString(proof.signatures.claimSignature)],\n    witnesses: [\n      {\n        id: proof.signatures.attestorAddress,\n        url: ATTESTOR_WS_URL,\n      },\n    ],\n    taskId: null,\n    publicData: proof.publicData ?? null,\n    providerRequest: requestData,\n  };\n  return formattedProof;\n};\n\nconst toHexString = (signatureObject) => {\n  if (!signatureObject) {\n    return \"\";\n  }\n  // Convert an object {0: byte0, 1: byte1, ...} to a hex string\n  const hexString = Object.values(signatureObject)\n    .map((byte) => byte.toString(16).padStart(2, \"0\"))\n    .join(\"\");\n  return `0x${hexString}`;\n};\n","/**\n * @implements {IHooks}\n */\nclass Hooks {\n  /**\n   * @callback HookCallback\n   * @this {*|Jsep} this\n   * @param {Jsep} env\n   * @returns: void\n   */\n  /**\n   * Adds the given callback to the list of callbacks for the given hook.\n   *\n   * The callback will be invoked when the hook it is registered for is run.\n   *\n   * One callback function can be registered to multiple hooks and the same hook multiple times.\n   *\n   * @param {string|object} name The name of the hook, or an object of callbacks keyed by name\n   * @param {HookCallback|boolean} callback The callback function which is given environment variables.\n   * @param {?boolean} [first=false] Will add the hook to the top of the list (defaults to the bottom)\n   * @public\n   */\n  add(name, callback, first) {\n    if (typeof arguments[0] != 'string') {\n      // Multiple hook callbacks, keyed by name\n      for (let name in arguments[0]) {\n        this.add(name, arguments[0][name], arguments[1]);\n      }\n    } else {\n      (Array.isArray(name) ? name : [name]).forEach(function (name) {\n        this[name] = this[name] || [];\n        if (callback) {\n          this[name][first ? 'unshift' : 'push'](callback);\n        }\n      }, this);\n    }\n  }\n\n  /**\n   * Runs a hook invoking all registered callbacks with the given environment variables.\n   *\n   * Callbacks will be invoked synchronously and in the order in which they were registered.\n   *\n   * @param {string} name The name of the hook.\n   * @param {Object<string, any>} env The environment variables of the hook passed to all callbacks registered.\n   * @public\n   */\n  run(name, env) {\n    this[name] = this[name] || [];\n    this[name].forEach(function (callback) {\n      callback.call(env && env.context ? env.context : env, env);\n    });\n  }\n}\n\n/**\n * @implements {IPlugins}\n */\nclass Plugins {\n  constructor(jsep) {\n    this.jsep = jsep;\n    this.registered = {};\n  }\n\n  /**\n   * @callback PluginSetup\n   * @this {Jsep} jsep\n   * @returns: void\n   */\n  /**\n   * Adds the given plugin(s) to the registry\n   *\n   * @param {object} plugins\n   * @param {string} plugins.name The name of the plugin\n   * @param {PluginSetup} plugins.init The init function\n   * @public\n   */\n  register() {\n    for (var _len = arguments.length, plugins = new Array(_len), _key = 0; _key < _len; _key++) {\n      plugins[_key] = arguments[_key];\n    }\n    plugins.forEach(plugin => {\n      if (typeof plugin !== 'object' || !plugin.name || !plugin.init) {\n        throw new Error('Invalid JSEP plugin format');\n      }\n      if (this.registered[plugin.name]) {\n        // already registered. Ignore.\n        return;\n      }\n      plugin.init(this.jsep);\n      this.registered[plugin.name] = plugin;\n    });\n  }\n}\n\n//     JavaScript Expression Parser (JSEP) 1.4.0\n\nclass Jsep {\n  /**\n   * @returns {string}\n   */\n  static get version() {\n    // To be filled in by the template\n    return '1.4.0';\n  }\n\n  /**\n   * @returns {string}\n   */\n  static toString() {\n    return 'JavaScript Expression Parser (JSEP) v' + Jsep.version;\n  }\n  // ==================== CONFIG ================================\n  /**\n   * @method addUnaryOp\n   * @param {string} op_name The name of the unary op to add\n   * @returns {Jsep}\n   */\n  static addUnaryOp(op_name) {\n    Jsep.max_unop_len = Math.max(op_name.length, Jsep.max_unop_len);\n    Jsep.unary_ops[op_name] = 1;\n    return Jsep;\n  }\n\n  /**\n   * @method jsep.addBinaryOp\n   * @param {string} op_name The name of the binary op to add\n   * @param {number} precedence The precedence of the binary op (can be a float). Higher number = higher precedence\n   * @param {boolean} [isRightAssociative=false] whether operator is right-associative\n   * @returns {Jsep}\n   */\n  static addBinaryOp(op_name, precedence, isRightAssociative) {\n    Jsep.max_binop_len = Math.max(op_name.length, Jsep.max_binop_len);\n    Jsep.binary_ops[op_name] = precedence;\n    if (isRightAssociative) {\n      Jsep.right_associative.add(op_name);\n    } else {\n      Jsep.right_associative.delete(op_name);\n    }\n    return Jsep;\n  }\n\n  /**\n   * @method addIdentifierChar\n   * @param {string} char The additional character to treat as a valid part of an identifier\n   * @returns {Jsep}\n   */\n  static addIdentifierChar(char) {\n    Jsep.additional_identifier_chars.add(char);\n    return Jsep;\n  }\n\n  /**\n   * @method addLiteral\n   * @param {string} literal_name The name of the literal to add\n   * @param {*} literal_value The value of the literal\n   * @returns {Jsep}\n   */\n  static addLiteral(literal_name, literal_value) {\n    Jsep.literals[literal_name] = literal_value;\n    return Jsep;\n  }\n\n  /**\n   * @method removeUnaryOp\n   * @param {string} op_name The name of the unary op to remove\n   * @returns {Jsep}\n   */\n  static removeUnaryOp(op_name) {\n    delete Jsep.unary_ops[op_name];\n    if (op_name.length === Jsep.max_unop_len) {\n      Jsep.max_unop_len = Jsep.getMaxKeyLen(Jsep.unary_ops);\n    }\n    return Jsep;\n  }\n\n  /**\n   * @method removeAllUnaryOps\n   * @returns {Jsep}\n   */\n  static removeAllUnaryOps() {\n    Jsep.unary_ops = {};\n    Jsep.max_unop_len = 0;\n    return Jsep;\n  }\n\n  /**\n   * @method removeIdentifierChar\n   * @param {string} char The additional character to stop treating as a valid part of an identifier\n   * @returns {Jsep}\n   */\n  static removeIdentifierChar(char) {\n    Jsep.additional_identifier_chars.delete(char);\n    return Jsep;\n  }\n\n  /**\n   * @method removeBinaryOp\n   * @param {string} op_name The name of the binary op to remove\n   * @returns {Jsep}\n   */\n  static removeBinaryOp(op_name) {\n    delete Jsep.binary_ops[op_name];\n    if (op_name.length === Jsep.max_binop_len) {\n      Jsep.max_binop_len = Jsep.getMaxKeyLen(Jsep.binary_ops);\n    }\n    Jsep.right_associative.delete(op_name);\n    return Jsep;\n  }\n\n  /**\n   * @method removeAllBinaryOps\n   * @returns {Jsep}\n   */\n  static removeAllBinaryOps() {\n    Jsep.binary_ops = {};\n    Jsep.max_binop_len = 0;\n    return Jsep;\n  }\n\n  /**\n   * @method removeLiteral\n   * @param {string} literal_name The name of the literal to remove\n   * @returns {Jsep}\n   */\n  static removeLiteral(literal_name) {\n    delete Jsep.literals[literal_name];\n    return Jsep;\n  }\n\n  /**\n   * @method removeAllLiterals\n   * @returns {Jsep}\n   */\n  static removeAllLiterals() {\n    Jsep.literals = {};\n    return Jsep;\n  }\n  // ==================== END CONFIG ============================\n\n  /**\n   * @returns {string}\n   */\n  get char() {\n    return this.expr.charAt(this.index);\n  }\n\n  /**\n   * @returns {number}\n   */\n  get code() {\n    return this.expr.charCodeAt(this.index);\n  }\n  /**\n   * @param {string} expr a string with the passed in express\n   * @returns Jsep\n   */\n  constructor(expr) {\n    // `index` stores the character number we are currently at\n    // All of the gobbles below will modify `index` as we move along\n    this.expr = expr;\n    this.index = 0;\n  }\n\n  /**\n   * static top-level parser\n   * @returns {jsep.Expression}\n   */\n  static parse(expr) {\n    return new Jsep(expr).parse();\n  }\n\n  /**\n   * Get the longest key length of any object\n   * @param {object} obj\n   * @returns {number}\n   */\n  static getMaxKeyLen(obj) {\n    return Math.max(0, ...Object.keys(obj).map(k => k.length));\n  }\n\n  /**\n   * `ch` is a character code in the next three functions\n   * @param {number} ch\n   * @returns {boolean}\n   */\n  static isDecimalDigit(ch) {\n    return ch >= 48 && ch <= 57; // 0...9\n  }\n\n  /**\n   * Returns the precedence of a binary operator or `0` if it isn't a binary operator. Can be float.\n   * @param {string} op_val\n   * @returns {number}\n   */\n  static binaryPrecedence(op_val) {\n    return Jsep.binary_ops[op_val] || 0;\n  }\n\n  /**\n   * Looks for start of identifier\n   * @param {number} ch\n   * @returns {boolean}\n   */\n  static isIdentifierStart(ch) {\n    return ch >= 65 && ch <= 90 ||\n    // A...Z\n    ch >= 97 && ch <= 122 ||\n    // a...z\n    ch >= 128 && !Jsep.binary_ops[String.fromCharCode(ch)] ||\n    // any non-ASCII that is not an operator\n    Jsep.additional_identifier_chars.has(String.fromCharCode(ch)); // additional characters\n  }\n\n  /**\n   * @param {number} ch\n   * @returns {boolean}\n   */\n  static isIdentifierPart(ch) {\n    return Jsep.isIdentifierStart(ch) || Jsep.isDecimalDigit(ch);\n  }\n\n  /**\n   * throw error at index of the expression\n   * @param {string} message\n   * @throws\n   */\n  throwError(message) {\n    const error = new Error(message + ' at character ' + this.index);\n    error.index = this.index;\n    error.description = message;\n    throw error;\n  }\n\n  /**\n   * Run a given hook\n   * @param {string} name\n   * @param {jsep.Expression|false} [node]\n   * @returns {?jsep.Expression}\n   */\n  runHook(name, node) {\n    if (Jsep.hooks[name]) {\n      const env = {\n        context: this,\n        node\n      };\n      Jsep.hooks.run(name, env);\n      return env.node;\n    }\n    return node;\n  }\n\n  /**\n   * Runs a given hook until one returns a node\n   * @param {string} name\n   * @returns {?jsep.Expression}\n   */\n  searchHook(name) {\n    if (Jsep.hooks[name]) {\n      const env = {\n        context: this\n      };\n      Jsep.hooks[name].find(function (callback) {\n        callback.call(env.context, env);\n        return env.node;\n      });\n      return env.node;\n    }\n  }\n\n  /**\n   * Push `index` up to the next non-space character\n   */\n  gobbleSpaces() {\n    let ch = this.code;\n    // Whitespace\n    while (ch === Jsep.SPACE_CODE || ch === Jsep.TAB_CODE || ch === Jsep.LF_CODE || ch === Jsep.CR_CODE) {\n      ch = this.expr.charCodeAt(++this.index);\n    }\n    this.runHook('gobble-spaces');\n  }\n\n  /**\n   * Top-level method to parse all expressions and returns compound or single node\n   * @returns {jsep.Expression}\n   */\n  parse() {\n    this.runHook('before-all');\n    const nodes = this.gobbleExpressions();\n\n    // If there's only one expression just try returning the expression\n    const node = nodes.length === 1 ? nodes[0] : {\n      type: Jsep.COMPOUND,\n      body: nodes\n    };\n    return this.runHook('after-all', node);\n  }\n\n  /**\n   * top-level parser (but can be reused within as well)\n   * @param {number} [untilICode]\n   * @returns {jsep.Expression[]}\n   */\n  gobbleExpressions(untilICode) {\n    let nodes = [],\n      ch_i,\n      node;\n    while (this.index < this.expr.length) {\n      ch_i = this.code;\n\n      // Expressions can be separated by semicolons, commas, or just inferred without any\n      // separators\n      if (ch_i === Jsep.SEMCOL_CODE || ch_i === Jsep.COMMA_CODE) {\n        this.index++; // ignore separators\n      } else {\n        // Try to gobble each expression individually\n        if (node = this.gobbleExpression()) {\n          nodes.push(node);\n          // If we weren't able to find a binary expression and are out of room, then\n          // the expression passed in probably has too much\n        } else if (this.index < this.expr.length) {\n          if (ch_i === untilICode) {\n            break;\n          }\n          this.throwError('Unexpected \"' + this.char + '\"');\n        }\n      }\n    }\n    return nodes;\n  }\n\n  /**\n   * The main parsing function.\n   * @returns {?jsep.Expression}\n   */\n  gobbleExpression() {\n    const node = this.searchHook('gobble-expression') || this.gobbleBinaryExpression();\n    this.gobbleSpaces();\n    return this.runHook('after-expression', node);\n  }\n\n  /**\n   * Search for the operation portion of the string (e.g. `+`, `===`)\n   * Start by taking the longest possible binary operations (3 characters: `===`, `!==`, `>>>`)\n   * and move down from 3 to 2 to 1 character until a matching binary operation is found\n   * then, return that binary operation\n   * @returns {string|boolean}\n   */\n  gobbleBinaryOp() {\n    this.gobbleSpaces();\n    let to_check = this.expr.substr(this.index, Jsep.max_binop_len);\n    let tc_len = to_check.length;\n    while (tc_len > 0) {\n      // Don't accept a binary op when it is an identifier.\n      // Binary ops that start with a identifier-valid character must be followed\n      // by a non identifier-part valid character\n      if (Jsep.binary_ops.hasOwnProperty(to_check) && (!Jsep.isIdentifierStart(this.code) || this.index + to_check.length < this.expr.length && !Jsep.isIdentifierPart(this.expr.charCodeAt(this.index + to_check.length)))) {\n        this.index += tc_len;\n        return to_check;\n      }\n      to_check = to_check.substr(0, --tc_len);\n    }\n    return false;\n  }\n\n  /**\n   * This function is responsible for gobbling an individual expression,\n   * e.g. `1`, `1+2`, `a+(b*2)-Math.sqrt(2)`\n   * @returns {?jsep.BinaryExpression}\n   */\n  gobbleBinaryExpression() {\n    let node, biop, prec, stack, biop_info, left, right, i, cur_biop;\n\n    // First, try to get the leftmost thing\n    // Then, check to see if there's a binary operator operating on that leftmost thing\n    // Don't gobbleBinaryOp without a left-hand-side\n    left = this.gobbleToken();\n    if (!left) {\n      return left;\n    }\n    biop = this.gobbleBinaryOp();\n\n    // If there wasn't a binary operator, just return the leftmost node\n    if (!biop) {\n      return left;\n    }\n\n    // Otherwise, we need to start a stack to properly place the binary operations in their\n    // precedence structure\n    biop_info = {\n      value: biop,\n      prec: Jsep.binaryPrecedence(biop),\n      right_a: Jsep.right_associative.has(biop)\n    };\n    right = this.gobbleToken();\n    if (!right) {\n      this.throwError(\"Expected expression after \" + biop);\n    }\n    stack = [left, biop_info, right];\n\n    // Properly deal with precedence using [recursive descent](http://www.engr.mun.ca/~theo/Misc/exp_parsing.htm)\n    while (biop = this.gobbleBinaryOp()) {\n      prec = Jsep.binaryPrecedence(biop);\n      if (prec === 0) {\n        this.index -= biop.length;\n        break;\n      }\n      biop_info = {\n        value: biop,\n        prec,\n        right_a: Jsep.right_associative.has(biop)\n      };\n      cur_biop = biop;\n\n      // Reduce: make a binary expression from the three topmost entries.\n      const comparePrev = prev => biop_info.right_a && prev.right_a ? prec > prev.prec : prec <= prev.prec;\n      while (stack.length > 2 && comparePrev(stack[stack.length - 2])) {\n        right = stack.pop();\n        biop = stack.pop().value;\n        left = stack.pop();\n        node = {\n          type: Jsep.BINARY_EXP,\n          operator: biop,\n          left,\n          right\n        };\n        stack.push(node);\n      }\n      node = this.gobbleToken();\n      if (!node) {\n        this.throwError(\"Expected expression after \" + cur_biop);\n      }\n      stack.push(biop_info, node);\n    }\n    i = stack.length - 1;\n    node = stack[i];\n    while (i > 1) {\n      node = {\n        type: Jsep.BINARY_EXP,\n        operator: stack[i - 1].value,\n        left: stack[i - 2],\n        right: node\n      };\n      i -= 2;\n    }\n    return node;\n  }\n\n  /**\n   * An individual part of a binary expression:\n   * e.g. `foo.bar(baz)`, `1`, `\"abc\"`, `(a % 2)` (because it's in parenthesis)\n   * @returns {boolean|jsep.Expression}\n   */\n  gobbleToken() {\n    let ch, to_check, tc_len, node;\n    this.gobbleSpaces();\n    node = this.searchHook('gobble-token');\n    if (node) {\n      return this.runHook('after-token', node);\n    }\n    ch = this.code;\n    if (Jsep.isDecimalDigit(ch) || ch === Jsep.PERIOD_CODE) {\n      // Char code 46 is a dot `.` which can start off a numeric literal\n      return this.gobbleNumericLiteral();\n    }\n    if (ch === Jsep.SQUOTE_CODE || ch === Jsep.DQUOTE_CODE) {\n      // Single or double quotes\n      node = this.gobbleStringLiteral();\n    } else if (ch === Jsep.OBRACK_CODE) {\n      node = this.gobbleArray();\n    } else {\n      to_check = this.expr.substr(this.index, Jsep.max_unop_len);\n      tc_len = to_check.length;\n      while (tc_len > 0) {\n        // Don't accept an unary op when it is an identifier.\n        // Unary ops that start with a identifier-valid character must be followed\n        // by a non identifier-part valid character\n        if (Jsep.unary_ops.hasOwnProperty(to_check) && (!Jsep.isIdentifierStart(this.code) || this.index + to_check.length < this.expr.length && !Jsep.isIdentifierPart(this.expr.charCodeAt(this.index + to_check.length)))) {\n          this.index += tc_len;\n          const argument = this.gobbleToken();\n          if (!argument) {\n            this.throwError('missing unaryOp argument');\n          }\n          return this.runHook('after-token', {\n            type: Jsep.UNARY_EXP,\n            operator: to_check,\n            argument,\n            prefix: true\n          });\n        }\n        to_check = to_check.substr(0, --tc_len);\n      }\n      if (Jsep.isIdentifierStart(ch)) {\n        node = this.gobbleIdentifier();\n        if (Jsep.literals.hasOwnProperty(node.name)) {\n          node = {\n            type: Jsep.LITERAL,\n            value: Jsep.literals[node.name],\n            raw: node.name\n          };\n        } else if (node.name === Jsep.this_str) {\n          node = {\n            type: Jsep.THIS_EXP\n          };\n        }\n      } else if (ch === Jsep.OPAREN_CODE) {\n        // open parenthesis\n        node = this.gobbleGroup();\n      }\n    }\n    if (!node) {\n      return this.runHook('after-token', false);\n    }\n    node = this.gobbleTokenProperty(node);\n    return this.runHook('after-token', node);\n  }\n\n  /**\n   * Gobble properties of of identifiers/strings/arrays/groups.\n   * e.g. `foo`, `bar.baz`, `foo['bar'].baz`\n   * It also gobbles function calls:\n   * e.g. `Math.acos(obj.angle)`\n   * @param {jsep.Expression} node\n   * @returns {jsep.Expression}\n   */\n  gobbleTokenProperty(node) {\n    this.gobbleSpaces();\n    let ch = this.code;\n    while (ch === Jsep.PERIOD_CODE || ch === Jsep.OBRACK_CODE || ch === Jsep.OPAREN_CODE || ch === Jsep.QUMARK_CODE) {\n      let optional;\n      if (ch === Jsep.QUMARK_CODE) {\n        if (this.expr.charCodeAt(this.index + 1) !== Jsep.PERIOD_CODE) {\n          break;\n        }\n        optional = true;\n        this.index += 2;\n        this.gobbleSpaces();\n        ch = this.code;\n      }\n      this.index++;\n      if (ch === Jsep.OBRACK_CODE) {\n        node = {\n          type: Jsep.MEMBER_EXP,\n          computed: true,\n          object: node,\n          property: this.gobbleExpression()\n        };\n        if (!node.property) {\n          this.throwError('Unexpected \"' + this.char + '\"');\n        }\n        this.gobbleSpaces();\n        ch = this.code;\n        if (ch !== Jsep.CBRACK_CODE) {\n          this.throwError('Unclosed [');\n        }\n        this.index++;\n      } else if (ch === Jsep.OPAREN_CODE) {\n        // A function call is being made; gobble all the arguments\n        node = {\n          type: Jsep.CALL_EXP,\n          'arguments': this.gobbleArguments(Jsep.CPAREN_CODE),\n          callee: node\n        };\n      } else if (ch === Jsep.PERIOD_CODE || optional) {\n        if (optional) {\n          this.index--;\n        }\n        this.gobbleSpaces();\n        node = {\n          type: Jsep.MEMBER_EXP,\n          computed: false,\n          object: node,\n          property: this.gobbleIdentifier()\n        };\n      }\n      if (optional) {\n        node.optional = true;\n      } // else leave undefined for compatibility with esprima\n\n      this.gobbleSpaces();\n      ch = this.code;\n    }\n    return node;\n  }\n\n  /**\n   * Parse simple numeric literals: `12`, `3.4`, `.5`. Do this by using a string to\n   * keep track of everything in the numeric literal and then calling `parseFloat` on that string\n   * @returns {jsep.Literal}\n   */\n  gobbleNumericLiteral() {\n    let number = '',\n      ch,\n      chCode;\n    while (Jsep.isDecimalDigit(this.code)) {\n      number += this.expr.charAt(this.index++);\n    }\n    if (this.code === Jsep.PERIOD_CODE) {\n      // can start with a decimal marker\n      number += this.expr.charAt(this.index++);\n      while (Jsep.isDecimalDigit(this.code)) {\n        number += this.expr.charAt(this.index++);\n      }\n    }\n    ch = this.char;\n    if (ch === 'e' || ch === 'E') {\n      // exponent marker\n      number += this.expr.charAt(this.index++);\n      ch = this.char;\n      if (ch === '+' || ch === '-') {\n        // exponent sign\n        number += this.expr.charAt(this.index++);\n      }\n      while (Jsep.isDecimalDigit(this.code)) {\n        // exponent itself\n        number += this.expr.charAt(this.index++);\n      }\n      if (!Jsep.isDecimalDigit(this.expr.charCodeAt(this.index - 1))) {\n        this.throwError('Expected exponent (' + number + this.char + ')');\n      }\n    }\n    chCode = this.code;\n\n    // Check to make sure this isn't a variable name that start with a number (123abc)\n    if (Jsep.isIdentifierStart(chCode)) {\n      this.throwError('Variable names cannot start with a number (' + number + this.char + ')');\n    } else if (chCode === Jsep.PERIOD_CODE || number.length === 1 && number.charCodeAt(0) === Jsep.PERIOD_CODE) {\n      this.throwError('Unexpected period');\n    }\n    return {\n      type: Jsep.LITERAL,\n      value: parseFloat(number),\n      raw: number\n    };\n  }\n\n  /**\n   * Parses a string literal, staring with single or double quotes with basic support for escape codes\n   * e.g. `\"hello world\"`, `'this is\\nJSEP'`\n   * @returns {jsep.Literal}\n   */\n  gobbleStringLiteral() {\n    let str = '';\n    const startIndex = this.index;\n    const quote = this.expr.charAt(this.index++);\n    let closed = false;\n    while (this.index < this.expr.length) {\n      let ch = this.expr.charAt(this.index++);\n      if (ch === quote) {\n        closed = true;\n        break;\n      } else if (ch === '\\\\') {\n        // Check for all of the common escape codes\n        ch = this.expr.charAt(this.index++);\n        switch (ch) {\n          case 'n':\n            str += '\\n';\n            break;\n          case 'r':\n            str += '\\r';\n            break;\n          case 't':\n            str += '\\t';\n            break;\n          case 'b':\n            str += '\\b';\n            break;\n          case 'f':\n            str += '\\f';\n            break;\n          case 'v':\n            str += '\\x0B';\n            break;\n          default:\n            str += ch;\n        }\n      } else {\n        str += ch;\n      }\n    }\n    if (!closed) {\n      this.throwError('Unclosed quote after \"' + str + '\"');\n    }\n    return {\n      type: Jsep.LITERAL,\n      value: str,\n      raw: this.expr.substring(startIndex, this.index)\n    };\n  }\n\n  /**\n   * Gobbles only identifiers\n   * e.g.: `foo`, `_value`, `$x1`\n   * Also, this function checks if that identifier is a literal:\n   * (e.g. `true`, `false`, `null`) or `this`\n   * @returns {jsep.Identifier}\n   */\n  gobbleIdentifier() {\n    let ch = this.code,\n      start = this.index;\n    if (Jsep.isIdentifierStart(ch)) {\n      this.index++;\n    } else {\n      this.throwError('Unexpected ' + this.char);\n    }\n    while (this.index < this.expr.length) {\n      ch = this.code;\n      if (Jsep.isIdentifierPart(ch)) {\n        this.index++;\n      } else {\n        break;\n      }\n    }\n    return {\n      type: Jsep.IDENTIFIER,\n      name: this.expr.slice(start, this.index)\n    };\n  }\n\n  /**\n   * Gobbles a list of arguments within the context of a function call\n   * or array literal. This function also assumes that the opening character\n   * `(` or `[` has already been gobbled, and gobbles expressions and commas\n   * until the terminator character `)` or `]` is encountered.\n   * e.g. `foo(bar, baz)`, `my_func()`, or `[bar, baz]`\n   * @param {number} termination\n   * @returns {jsep.Expression[]}\n   */\n  gobbleArguments(termination) {\n    const args = [];\n    let closed = false;\n    let separator_count = 0;\n    while (this.index < this.expr.length) {\n      this.gobbleSpaces();\n      let ch_i = this.code;\n      if (ch_i === termination) {\n        // done parsing\n        closed = true;\n        this.index++;\n        if (termination === Jsep.CPAREN_CODE && separator_count && separator_count >= args.length) {\n          this.throwError('Unexpected token ' + String.fromCharCode(termination));\n        }\n        break;\n      } else if (ch_i === Jsep.COMMA_CODE) {\n        // between expressions\n        this.index++;\n        separator_count++;\n        if (separator_count !== args.length) {\n          // missing argument\n          if (termination === Jsep.CPAREN_CODE) {\n            this.throwError('Unexpected token ,');\n          } else if (termination === Jsep.CBRACK_CODE) {\n            for (let arg = args.length; arg < separator_count; arg++) {\n              args.push(null);\n            }\n          }\n        }\n      } else if (args.length !== separator_count && separator_count !== 0) {\n        // NOTE: `&& separator_count !== 0` allows for either all commas, or all spaces as arguments\n        this.throwError('Expected comma');\n      } else {\n        const node = this.gobbleExpression();\n        if (!node || node.type === Jsep.COMPOUND) {\n          this.throwError('Expected comma');\n        }\n        args.push(node);\n      }\n    }\n    if (!closed) {\n      this.throwError('Expected ' + String.fromCharCode(termination));\n    }\n    return args;\n  }\n\n  /**\n   * Responsible for parsing a group of things within parentheses `()`\n   * that have no identifier in front (so not a function call)\n   * This function assumes that it needs to gobble the opening parenthesis\n   * and then tries to gobble everything within that parenthesis, assuming\n   * that the next thing it should see is the close parenthesis. If not,\n   * then the expression probably doesn't have a `)`\n   * @returns {boolean|jsep.Expression}\n   */\n  gobbleGroup() {\n    this.index++;\n    let nodes = this.gobbleExpressions(Jsep.CPAREN_CODE);\n    if (this.code === Jsep.CPAREN_CODE) {\n      this.index++;\n      if (nodes.length === 1) {\n        return nodes[0];\n      } else if (!nodes.length) {\n        return false;\n      } else {\n        return {\n          type: Jsep.SEQUENCE_EXP,\n          expressions: nodes\n        };\n      }\n    } else {\n      this.throwError('Unclosed (');\n    }\n  }\n\n  /**\n   * Responsible for parsing Array literals `[1, 2, 3]`\n   * This function assumes that it needs to gobble the opening bracket\n   * and then tries to gobble the expressions as arguments.\n   * @returns {jsep.ArrayExpression}\n   */\n  gobbleArray() {\n    this.index++;\n    return {\n      type: Jsep.ARRAY_EXP,\n      elements: this.gobbleArguments(Jsep.CBRACK_CODE)\n    };\n  }\n}\n\n// Static fields:\nconst hooks = new Hooks();\nObject.assign(Jsep, {\n  hooks,\n  plugins: new Plugins(Jsep),\n  // Node Types\n  // ----------\n  // This is the full set of types that any JSEP node can be.\n  // Store them here to save space when minified\n  COMPOUND: 'Compound',\n  SEQUENCE_EXP: 'SequenceExpression',\n  IDENTIFIER: 'Identifier',\n  MEMBER_EXP: 'MemberExpression',\n  LITERAL: 'Literal',\n  THIS_EXP: 'ThisExpression',\n  CALL_EXP: 'CallExpression',\n  UNARY_EXP: 'UnaryExpression',\n  BINARY_EXP: 'BinaryExpression',\n  ARRAY_EXP: 'ArrayExpression',\n  TAB_CODE: 9,\n  LF_CODE: 10,\n  CR_CODE: 13,\n  SPACE_CODE: 32,\n  PERIOD_CODE: 46,\n  // '.'\n  COMMA_CODE: 44,\n  // ','\n  SQUOTE_CODE: 39,\n  // single quote\n  DQUOTE_CODE: 34,\n  // double quotes\n  OPAREN_CODE: 40,\n  // (\n  CPAREN_CODE: 41,\n  // )\n  OBRACK_CODE: 91,\n  // [\n  CBRACK_CODE: 93,\n  // ]\n  QUMARK_CODE: 63,\n  // ?\n  SEMCOL_CODE: 59,\n  // ;\n  COLON_CODE: 58,\n  // :\n\n  // Operations\n  // ----------\n  // Use a quickly-accessible map to store all of the unary operators\n  // Values are set to `1` (it really doesn't matter)\n  unary_ops: {\n    '-': 1,\n    '!': 1,\n    '~': 1,\n    '+': 1\n  },\n  // Also use a map for the binary operations but set their values to their\n  // binary precedence for quick reference (higher number = higher precedence)\n  // see [Order of operations](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence)\n  binary_ops: {\n    '||': 1,\n    '??': 1,\n    '&&': 2,\n    '|': 3,\n    '^': 4,\n    '&': 5,\n    '==': 6,\n    '!=': 6,\n    '===': 6,\n    '!==': 6,\n    '<': 7,\n    '>': 7,\n    '<=': 7,\n    '>=': 7,\n    '<<': 8,\n    '>>': 8,\n    '>>>': 8,\n    '+': 9,\n    '-': 9,\n    '*': 10,\n    '/': 10,\n    '%': 10,\n    '**': 11\n  },\n  // sets specific binary_ops as right-associative\n  right_associative: new Set(['**']),\n  // Additional valid identifier chars, apart from a-z, A-Z and 0-9 (except on the starting char)\n  additional_identifier_chars: new Set(['$', '_']),\n  // Literals\n  // ----------\n  // Store the values to return for the various literals we may encounter\n  literals: {\n    'true': true,\n    'false': false,\n    'null': null\n  },\n  // Except for `this`, which is special. This could be changed to something like `'self'` as well\n  this_str: 'this'\n});\nJsep.max_unop_len = Jsep.getMaxKeyLen(Jsep.unary_ops);\nJsep.max_binop_len = Jsep.getMaxKeyLen(Jsep.binary_ops);\n\n// Backward Compatibility:\nconst jsep = expr => new Jsep(expr).parse();\nconst stdClassProps = Object.getOwnPropertyNames(class Test {});\nObject.getOwnPropertyNames(Jsep).filter(prop => !stdClassProps.includes(prop) && jsep[prop] === undefined).forEach(m => {\n  jsep[m] = Jsep[m];\n});\njsep.Jsep = Jsep; // allows for const { Jsep } = require('jsep');\n\nconst CONDITIONAL_EXP = 'ConditionalExpression';\nvar ternary = {\n  name: 'ternary',\n  init(jsep) {\n    // Ternary expression: test ? consequent : alternate\n    jsep.hooks.add('after-expression', function gobbleTernary(env) {\n      if (env.node && this.code === jsep.QUMARK_CODE) {\n        this.index++;\n        const test = env.node;\n        const consequent = this.gobbleExpression();\n        if (!consequent) {\n          this.throwError('Expected expression');\n        }\n        this.gobbleSpaces();\n        if (this.code === jsep.COLON_CODE) {\n          this.index++;\n          const alternate = this.gobbleExpression();\n          if (!alternate) {\n            this.throwError('Expected expression');\n          }\n          env.node = {\n            type: CONDITIONAL_EXP,\n            test,\n            consequent,\n            alternate\n          };\n\n          // check for operators of higher priority than ternary (i.e. assignment)\n          // jsep sets || at 1, and assignment at 0.9, and conditional should be between them\n          if (test.operator && jsep.binary_ops[test.operator] <= 0.9) {\n            let newTest = test;\n            while (newTest.right.operator && jsep.binary_ops[newTest.right.operator] <= 0.9) {\n              newTest = newTest.right;\n            }\n            env.node.test = newTest.right;\n            newTest.right = env.node;\n            env.node = test;\n          }\n        } else {\n          this.throwError('Expected :');\n        }\n      }\n    });\n  }\n};\n\n// Add default plugins:\n\njsep.plugins.register(ternary);\n\nconst FSLASH_CODE = 47; // '/'\nconst BSLASH_CODE = 92; // '\\\\'\n\nvar index = {\n  name: 'regex',\n  init(jsep) {\n    // Regex literal: /abc123/ig\n    jsep.hooks.add('gobble-token', function gobbleRegexLiteral(env) {\n      if (this.code === FSLASH_CODE) {\n        const patternIndex = ++this.index;\n        let inCharSet = false;\n        while (this.index < this.expr.length) {\n          if (this.code === FSLASH_CODE && !inCharSet) {\n            const pattern = this.expr.slice(patternIndex, this.index);\n            let flags = '';\n            while (++this.index < this.expr.length) {\n              const code = this.code;\n              if (code >= 97 && code <= 122 // a...z\n              || code >= 65 && code <= 90 // A...Z\n              || code >= 48 && code <= 57) {\n                // 0-9\n                flags += this.char;\n              } else {\n                break;\n              }\n            }\n            let value;\n            try {\n              value = new RegExp(pattern, flags);\n            } catch (e) {\n              this.throwError(e.message);\n            }\n            env.node = {\n              type: jsep.LITERAL,\n              value,\n              raw: this.expr.slice(patternIndex - 1, this.index)\n            };\n\n            // allow . [] and () after regex: /regex/.test(a)\n            env.node = this.gobbleTokenProperty(env.node);\n            return env.node;\n          }\n          if (this.code === jsep.OBRACK_CODE) {\n            inCharSet = true;\n          } else if (inCharSet && this.code === jsep.CBRACK_CODE) {\n            inCharSet = false;\n          }\n          this.index += this.code === BSLASH_CODE ? 2 : 1;\n        }\n        this.throwError('Unclosed Regex');\n      }\n    });\n  }\n};\n\nconst PLUS_CODE = 43; // +\nconst MINUS_CODE = 45; // -\n\nconst plugin = {\n  name: 'assignment',\n  assignmentOperators: new Set(['=', '*=', '**=', '/=', '%=', '+=', '-=', '<<=', '>>=', '>>>=', '&=', '^=', '|=', '||=', '&&=', '??=']),\n  updateOperators: [PLUS_CODE, MINUS_CODE],\n  assignmentPrecedence: 0.9,\n  init(jsep) {\n    const updateNodeTypes = [jsep.IDENTIFIER, jsep.MEMBER_EXP];\n    plugin.assignmentOperators.forEach(op => jsep.addBinaryOp(op, plugin.assignmentPrecedence, true));\n    jsep.hooks.add('gobble-token', function gobbleUpdatePrefix(env) {\n      const code = this.code;\n      if (plugin.updateOperators.some(c => c === code && c === this.expr.charCodeAt(this.index + 1))) {\n        this.index += 2;\n        env.node = {\n          type: 'UpdateExpression',\n          operator: code === PLUS_CODE ? '++' : '--',\n          argument: this.gobbleTokenProperty(this.gobbleIdentifier()),\n          prefix: true\n        };\n        if (!env.node.argument || !updateNodeTypes.includes(env.node.argument.type)) {\n          this.throwError(`Unexpected ${env.node.operator}`);\n        }\n      }\n    });\n    jsep.hooks.add('after-token', function gobbleUpdatePostfix(env) {\n      if (env.node) {\n        const code = this.code;\n        if (plugin.updateOperators.some(c => c === code && c === this.expr.charCodeAt(this.index + 1))) {\n          if (!updateNodeTypes.includes(env.node.type)) {\n            this.throwError(`Unexpected ${env.node.operator}`);\n          }\n          this.index += 2;\n          env.node = {\n            type: 'UpdateExpression',\n            operator: code === PLUS_CODE ? '++' : '--',\n            argument: env.node,\n            prefix: false\n          };\n        }\n      }\n    });\n    jsep.hooks.add('after-expression', function gobbleAssignment(env) {\n      if (env.node) {\n        // Note: Binaries can be chained in a single expression to respect\n        // operator precedence (i.e. a = b = 1 + 2 + 3)\n        // Update all binary assignment nodes in the tree\n        updateBinariesToAssignments(env.node);\n      }\n    });\n    function updateBinariesToAssignments(node) {\n      if (plugin.assignmentOperators.has(node.operator)) {\n        node.type = 'AssignmentExpression';\n        updateBinariesToAssignments(node.left);\n        updateBinariesToAssignments(node.right);\n      } else if (!node.operator) {\n        Object.values(node).forEach(val => {\n          if (val && typeof val === 'object') {\n            updateBinariesToAssignments(val);\n          }\n        });\n      }\n    }\n  }\n};\n\n/* eslint-disable no-bitwise -- Convenient */\n\n// register plugins\njsep.plugins.register(index, plugin);\njsep.addUnaryOp('typeof');\njsep.addLiteral('null', null);\njsep.addLiteral('undefined', undefined);\nconst BLOCKED_PROTO_PROPERTIES = new Set(['constructor', '__proto__', '__defineGetter__', '__defineSetter__']);\nconst SafeEval = {\n  /**\n   * @param {jsep.Expression} ast\n   * @param {Record<string, any>} subs\n   */\n  evalAst(ast, subs) {\n    switch (ast.type) {\n      case 'BinaryExpression':\n      case 'LogicalExpression':\n        return SafeEval.evalBinaryExpression(ast, subs);\n      case 'Compound':\n        return SafeEval.evalCompound(ast, subs);\n      case 'ConditionalExpression':\n        return SafeEval.evalConditionalExpression(ast, subs);\n      case 'Identifier':\n        return SafeEval.evalIdentifier(ast, subs);\n      case 'Literal':\n        return SafeEval.evalLiteral(ast, subs);\n      case 'MemberExpression':\n        return SafeEval.evalMemberExpression(ast, subs);\n      case 'UnaryExpression':\n        return SafeEval.evalUnaryExpression(ast, subs);\n      case 'ArrayExpression':\n        return SafeEval.evalArrayExpression(ast, subs);\n      case 'CallExpression':\n        return SafeEval.evalCallExpression(ast, subs);\n      case 'AssignmentExpression':\n        return SafeEval.evalAssignmentExpression(ast, subs);\n      default:\n        throw SyntaxError('Unexpected expression', ast);\n    }\n  },\n  evalBinaryExpression(ast, subs) {\n    const result = {\n      '||': (a, b) => a || b(),\n      '&&': (a, b) => a && b(),\n      '|': (a, b) => a | b(),\n      '^': (a, b) => a ^ b(),\n      '&': (a, b) => a & b(),\n      // eslint-disable-next-line eqeqeq -- API\n      '==': (a, b) => a == b(),\n      // eslint-disable-next-line eqeqeq -- API\n      '!=': (a, b) => a != b(),\n      '===': (a, b) => a === b(),\n      '!==': (a, b) => a !== b(),\n      '<': (a, b) => a < b(),\n      '>': (a, b) => a > b(),\n      '<=': (a, b) => a <= b(),\n      '>=': (a, b) => a >= b(),\n      '<<': (a, b) => a << b(),\n      '>>': (a, b) => a >> b(),\n      '>>>': (a, b) => a >>> b(),\n      '+': (a, b) => a + b(),\n      '-': (a, b) => a - b(),\n      '*': (a, b) => a * b(),\n      '/': (a, b) => a / b(),\n      '%': (a, b) => a % b()\n    }[ast.operator](SafeEval.evalAst(ast.left, subs), () => SafeEval.evalAst(ast.right, subs));\n    return result;\n  },\n  evalCompound(ast, subs) {\n    let last;\n    for (let i = 0; i < ast.body.length; i++) {\n      if (ast.body[i].type === 'Identifier' && ['var', 'let', 'const'].includes(ast.body[i].name) && ast.body[i + 1] && ast.body[i + 1].type === 'AssignmentExpression') {\n        // var x=2; is detected as\n        // [{Identifier var}, {AssignmentExpression x=2}]\n        // eslint-disable-next-line @stylistic/max-len -- Long\n        // eslint-disable-next-line sonarjs/updated-loop-counter -- Convenient\n        i += 1;\n      }\n      const expr = ast.body[i];\n      last = SafeEval.evalAst(expr, subs);\n    }\n    return last;\n  },\n  evalConditionalExpression(ast, subs) {\n    if (SafeEval.evalAst(ast.test, subs)) {\n      return SafeEval.evalAst(ast.consequent, subs);\n    }\n    return SafeEval.evalAst(ast.alternate, subs);\n  },\n  evalIdentifier(ast, subs) {\n    if (Object.hasOwn(subs, ast.name)) {\n      return subs[ast.name];\n    }\n    throw ReferenceError(`${ast.name} is not defined`);\n  },\n  evalLiteral(ast) {\n    return ast.value;\n  },\n  evalMemberExpression(ast, subs) {\n    const prop = String(\n    // NOTE: `String(value)` throws error when\n    // value has overwritten the toString method to return non-string\n    // i.e. `value = {toString: () => []}`\n    ast.computed ? SafeEval.evalAst(ast.property) // `object[property]`\n    : ast.property.name // `object.property` property is Identifier\n    );\n    const obj = SafeEval.evalAst(ast.object, subs);\n    if (obj === undefined || obj === null) {\n      throw TypeError(`Cannot read properties of ${obj} (reading '${prop}')`);\n    }\n    if (!Object.hasOwn(obj, prop) && BLOCKED_PROTO_PROPERTIES.has(prop)) {\n      throw TypeError(`Cannot read properties of ${obj} (reading '${prop}')`);\n    }\n    const result = obj[prop];\n    if (typeof result === 'function') {\n      return result.bind(obj); // arrow functions aren't affected by bind.\n    }\n    return result;\n  },\n  evalUnaryExpression(ast, subs) {\n    const result = {\n      '-': a => -SafeEval.evalAst(a, subs),\n      '!': a => !SafeEval.evalAst(a, subs),\n      '~': a => ~SafeEval.evalAst(a, subs),\n      // eslint-disable-next-line no-implicit-coercion -- API\n      '+': a => +SafeEval.evalAst(a, subs),\n      typeof: a => typeof SafeEval.evalAst(a, subs)\n    }[ast.operator](ast.argument);\n    return result;\n  },\n  evalArrayExpression(ast, subs) {\n    return ast.elements.map(el => SafeEval.evalAst(el, subs));\n  },\n  evalCallExpression(ast, subs) {\n    const args = ast.arguments.map(arg => SafeEval.evalAst(arg, subs));\n    const func = SafeEval.evalAst(ast.callee, subs);\n    // if (func === Function) {\n    //     throw new Error('Function constructor is disabled');\n    // }\n    return func(...args);\n  },\n  evalAssignmentExpression(ast, subs) {\n    if (ast.left.type !== 'Identifier') {\n      throw SyntaxError('Invalid left-hand side in assignment');\n    }\n    const id = ast.left.name;\n    const value = SafeEval.evalAst(ast.right, subs);\n    subs[id] = value;\n    return subs[id];\n  }\n};\n\n/**\n * A replacement for NodeJS' VM.Script which is also {@link https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP | Content Security Policy} friendly.\n */\nclass SafeScript {\n  /**\n   * @param {string} expr Expression to evaluate\n   */\n  constructor(expr) {\n    this.code = expr;\n    this.ast = jsep(this.code);\n  }\n\n  /**\n   * @param {object} context Object whose items will be added\n   *   to evaluation\n   * @returns {EvaluatedResult} Result of evaluated code\n   */\n  runInNewContext(context) {\n    // `Object.create(null)` creates a prototypeless object\n    const keyMap = Object.assign(Object.create(null), context);\n    return SafeEval.evalAst(this.ast, keyMap);\n  }\n}\n\n/* eslint-disable camelcase -- Convenient for escaping */\n\n\n/**\n * @typedef {null|boolean|number|string|object|GenericArray} JSONObject\n */\n\n/**\n * @typedef {any} AnyItem\n */\n\n/**\n * @typedef {any} AnyResult\n */\n\n/**\n * Copies array and then pushes item into it.\n * @param {GenericArray} arr Array to copy and into which to push\n * @param {AnyItem} item Array item to add (to end)\n * @returns {GenericArray} Copy of the original array\n */\nfunction push(arr, item) {\n  arr = arr.slice();\n  arr.push(item);\n  return arr;\n}\n/**\n * Copies array and then unshifts item into it.\n * @param {AnyItem} item Array item to add (to beginning)\n * @param {GenericArray} arr Array to copy and into which to unshift\n * @returns {GenericArray} Copy of the original array\n */\nfunction unshift(item, arr) {\n  arr = arr.slice();\n  arr.unshift(item);\n  return arr;\n}\n\n/**\n * Caught when JSONPath is used without `new` but rethrown if with `new`\n * @extends Error\n */\nclass NewError extends Error {\n  /**\n   * @param {AnyResult} value The evaluated scalar value\n   */\n  constructor(value) {\n    super('JSONPath should not be called with \"new\" (it prevents return ' + 'of (unwrapped) scalar values)');\n    this.avoidNew = true;\n    this.value = value;\n    this.name = 'NewError';\n  }\n}\n\n/**\n* @typedef {object} ReturnObject\n* @property {string} path\n* @property {JSONObject} value\n* @property {object|GenericArray} parent\n* @property {string} parentProperty\n*/\n\n/**\n* @callback JSONPathCallback\n* @param {string|object} preferredOutput\n* @param {\"value\"|\"property\"} type\n* @param {ReturnObject} fullRetObj\n* @returns {void}\n*/\n\n/**\n* @callback OtherTypeCallback\n* @param {JSONObject} val\n* @param {string} path\n* @param {object|GenericArray} parent\n* @param {string} parentPropName\n* @returns {boolean}\n*/\n\n/**\n * @typedef {any} ContextItem\n */\n\n/**\n * @typedef {any} EvaluatedResult\n */\n\n/**\n* @callback EvalCallback\n* @param {string} code\n* @param {ContextItem} context\n* @returns {EvaluatedResult}\n*/\n\n/**\n * @typedef {typeof SafeScript} EvalClass\n */\n\n/**\n * @typedef {object} JSONPathOptions\n * @property {JSON} json\n * @property {string|string[]} path\n * @property {\"value\"|\"path\"|\"pointer\"|\"parent\"|\"parentProperty\"|\n *   \"all\"} [resultType=\"value\"]\n * @property {boolean} [flatten=false]\n * @property {boolean} [wrap=true]\n * @property {object} [sandbox={}]\n * @property {EvalCallback|EvalClass|'safe'|'native'|\n *   boolean} [eval = 'safe']\n * @property {object|GenericArray|null} [parent=null]\n * @property {string|null} [parentProperty=null]\n * @property {JSONPathCallback} [callback]\n * @property {OtherTypeCallback} [otherTypeCallback] Defaults to\n *   function which throws on encountering `@other`\n * @property {boolean} [autostart=true]\n */\n\n/**\n * @param {string|JSONPathOptions} opts If a string, will be treated as `expr`\n * @param {string} [expr] JSON path to evaluate\n * @param {JSON} [obj] JSON object to evaluate against\n * @param {JSONPathCallback} [callback] Passed 3 arguments: 1) desired payload\n *     per `resultType`, 2) `\"value\"|\"property\"`, 3) Full returned object with\n *     all payloads\n * @param {OtherTypeCallback} [otherTypeCallback] If `@other()` is at the end\n *   of one's query, this will be invoked with the value of the item, its\n *   path, its parent, and its parent's property name, and it should return\n *   a boolean indicating whether the supplied value belongs to the \"other\"\n *   type or not (or it may handle transformations and return `false`).\n * @returns {JSONPath}\n * @class\n */\nfunction JSONPath(opts, expr, obj, callback, otherTypeCallback) {\n  // eslint-disable-next-line no-restricted-syntax -- Allow for pseudo-class\n  if (!(this instanceof JSONPath)) {\n    try {\n      return new JSONPath(opts, expr, obj, callback, otherTypeCallback);\n    } catch (e) {\n      if (!e.avoidNew) {\n        throw e;\n      }\n      return e.value;\n    }\n  }\n  if (typeof opts === 'string') {\n    otherTypeCallback = callback;\n    callback = obj;\n    obj = expr;\n    expr = opts;\n    opts = null;\n  }\n  const optObj = opts && typeof opts === 'object';\n  opts = opts || {};\n  this.json = opts.json || obj;\n  this.path = opts.path || expr;\n  this.resultType = opts.resultType || 'value';\n  this.flatten = opts.flatten || false;\n  this.wrap = Object.hasOwn(opts, 'wrap') ? opts.wrap : true;\n  this.sandbox = opts.sandbox || {};\n  this.eval = opts.eval === undefined ? 'safe' : opts.eval;\n  this.ignoreEvalErrors = typeof opts.ignoreEvalErrors === 'undefined' ? false : opts.ignoreEvalErrors;\n  this.parent = opts.parent || null;\n  this.parentProperty = opts.parentProperty || null;\n  this.callback = opts.callback || callback || null;\n  this.otherTypeCallback = opts.otherTypeCallback || otherTypeCallback || function () {\n    throw new TypeError('You must supply an otherTypeCallback callback option ' + 'with the @other() operator.');\n  };\n  if (opts.autostart !== false) {\n    const args = {\n      path: optObj ? opts.path : expr\n    };\n    if (!optObj) {\n      args.json = obj;\n    } else if ('json' in opts) {\n      args.json = opts.json;\n    }\n    const ret = this.evaluate(args);\n    if (!ret || typeof ret !== 'object') {\n      throw new NewError(ret);\n    }\n    return ret;\n  }\n}\n\n// PUBLIC METHODS\nJSONPath.prototype.evaluate = function (expr, json, callback, otherTypeCallback) {\n  let currParent = this.parent,\n    currParentProperty = this.parentProperty;\n  let {\n    flatten,\n    wrap\n  } = this;\n  this.currResultType = this.resultType;\n  this.currEval = this.eval;\n  this.currSandbox = this.sandbox;\n  callback = callback || this.callback;\n  this.currOtherTypeCallback = otherTypeCallback || this.otherTypeCallback;\n  json = json || this.json;\n  expr = expr || this.path;\n  if (expr && typeof expr === 'object' && !Array.isArray(expr)) {\n    if (!expr.path && expr.path !== '') {\n      throw new TypeError('You must supply a \"path\" property when providing an object ' + 'argument to JSONPath.evaluate().');\n    }\n    if (!Object.hasOwn(expr, 'json')) {\n      throw new TypeError('You must supply a \"json\" property when providing an object ' + 'argument to JSONPath.evaluate().');\n    }\n    ({\n      json\n    } = expr);\n    flatten = Object.hasOwn(expr, 'flatten') ? expr.flatten : flatten;\n    this.currResultType = Object.hasOwn(expr, 'resultType') ? expr.resultType : this.currResultType;\n    this.currSandbox = Object.hasOwn(expr, 'sandbox') ? expr.sandbox : this.currSandbox;\n    wrap = Object.hasOwn(expr, 'wrap') ? expr.wrap : wrap;\n    this.currEval = Object.hasOwn(expr, 'eval') ? expr.eval : this.currEval;\n    callback = Object.hasOwn(expr, 'callback') ? expr.callback : callback;\n    this.currOtherTypeCallback = Object.hasOwn(expr, 'otherTypeCallback') ? expr.otherTypeCallback : this.currOtherTypeCallback;\n    currParent = Object.hasOwn(expr, 'parent') ? expr.parent : currParent;\n    currParentProperty = Object.hasOwn(expr, 'parentProperty') ? expr.parentProperty : currParentProperty;\n    expr = expr.path;\n  }\n  currParent = currParent || null;\n  currParentProperty = currParentProperty || null;\n  if (Array.isArray(expr)) {\n    expr = JSONPath.toPathString(expr);\n  }\n  if (!expr && expr !== '' || !json) {\n    return undefined;\n  }\n  const exprList = JSONPath.toPathArray(expr);\n  if (exprList[0] === '$' && exprList.length > 1) {\n    exprList.shift();\n  }\n  this._hasParentSelector = null;\n  const result = this._trace(exprList, json, ['$'], currParent, currParentProperty, callback).filter(function (ea) {\n    return ea && !ea.isParentSelector;\n  });\n  if (!result.length) {\n    return wrap ? [] : undefined;\n  }\n  if (!wrap && result.length === 1 && !result[0].hasArrExpr) {\n    return this._getPreferredOutput(result[0]);\n  }\n  return result.reduce((rslt, ea) => {\n    const valOrPath = this._getPreferredOutput(ea);\n    if (flatten && Array.isArray(valOrPath)) {\n      rslt = rslt.concat(valOrPath);\n    } else {\n      rslt.push(valOrPath);\n    }\n    return rslt;\n  }, []);\n};\n\n// PRIVATE METHODS\n\nJSONPath.prototype._getPreferredOutput = function (ea) {\n  const resultType = this.currResultType;\n  switch (resultType) {\n    case 'all':\n      {\n        const path = Array.isArray(ea.path) ? ea.path : JSONPath.toPathArray(ea.path);\n        ea.pointer = JSONPath.toPointer(path);\n        ea.path = typeof ea.path === 'string' ? ea.path : JSONPath.toPathString(ea.path);\n        return ea;\n      }\n    case 'value':\n    case 'parent':\n    case 'parentProperty':\n      return ea[resultType];\n    case 'path':\n      return JSONPath.toPathString(ea[resultType]);\n    case 'pointer':\n      return JSONPath.toPointer(ea.path);\n    default:\n      throw new TypeError('Unknown result type');\n  }\n};\nJSONPath.prototype._handleCallback = function (fullRetObj, callback, type) {\n  if (callback) {\n    const preferredOutput = this._getPreferredOutput(fullRetObj);\n    fullRetObj.path = typeof fullRetObj.path === 'string' ? fullRetObj.path : JSONPath.toPathString(fullRetObj.path);\n    // eslint-disable-next-line n/callback-return -- No need to return\n    callback(preferredOutput, type, fullRetObj);\n  }\n};\n\n/**\n *\n * @param {string} expr\n * @param {JSONObject} val\n * @param {string} path\n * @param {object|GenericArray} parent\n * @param {string} parentPropName\n * @param {JSONPathCallback} callback\n * @param {boolean} hasArrExpr\n * @param {boolean} literalPriority\n * @returns {ReturnObject|ReturnObject[]}\n */\nJSONPath.prototype._trace = function (expr, val, path, parent, parentPropName, callback, hasArrExpr, literalPriority) {\n  // No expr to follow? return path and value as the result of\n  //  this trace branch\n  let retObj;\n  if (!expr.length) {\n    retObj = {\n      path,\n      value: val,\n      parent,\n      parentProperty: parentPropName,\n      hasArrExpr\n    };\n    this._handleCallback(retObj, callback, 'value');\n    return retObj;\n  }\n  const loc = expr[0],\n    x = expr.slice(1);\n\n  // We need to gather the return value of recursive trace calls in order to\n  // do the parent sel computation.\n  const ret = [];\n  /**\n   *\n   * @param {ReturnObject|ReturnObject[]} elems\n   * @returns {void}\n   */\n  function addRet(elems) {\n    if (Array.isArray(elems)) {\n      // This was causing excessive stack size in Node (with or\n      //  without Babel) against our performance test:\n      //  `ret.push(...elems);`\n      elems.forEach(t => {\n        ret.push(t);\n      });\n    } else {\n      ret.push(elems);\n    }\n  }\n  if ((typeof loc !== 'string' || literalPriority) && val && Object.hasOwn(val, loc)) {\n    // simple case--directly follow property\n    addRet(this._trace(x, val[loc], push(path, loc), val, loc, callback, hasArrExpr));\n    // eslint-disable-next-line unicorn/prefer-switch -- Part of larger `if`\n  } else if (loc === '*') {\n    // all child properties\n    this._walk(val, m => {\n      addRet(this._trace(x, val[m], push(path, m), val, m, callback, true, true));\n    });\n  } else if (loc === '..') {\n    // all descendent parent properties\n    // Check remaining expression with val's immediate children\n    addRet(this._trace(x, val, path, parent, parentPropName, callback, hasArrExpr));\n    this._walk(val, m => {\n      // We don't join m and x here because we only want parents,\n      //   not scalar values\n      if (typeof val[m] === 'object') {\n        // Keep going with recursive descent on val's\n        //   object children\n        addRet(this._trace(expr.slice(), val[m], push(path, m), val, m, callback, true));\n      }\n    });\n    // The parent sel computation is handled in the frame above using the\n    // ancestor object of val\n  } else if (loc === '^') {\n    // This is not a final endpoint, so we do not invoke the callback here\n    this._hasParentSelector = true;\n    return {\n      path: path.slice(0, -1),\n      expr: x,\n      isParentSelector: true\n    };\n  } else if (loc === '~') {\n    // property name\n    retObj = {\n      path: push(path, loc),\n      value: parentPropName,\n      parent,\n      parentProperty: null\n    };\n    this._handleCallback(retObj, callback, 'property');\n    return retObj;\n  } else if (loc === '$') {\n    // root only\n    addRet(this._trace(x, val, path, null, null, callback, hasArrExpr));\n  } else if (/^(-?\\d*):(-?\\d*):?(\\d*)$/u.test(loc)) {\n    // [start:end:step]  Python slice syntax\n    addRet(this._slice(loc, x, val, path, parent, parentPropName, callback));\n  } else if (loc.indexOf('?(') === 0) {\n    // [?(expr)] (filtering)\n    if (this.currEval === false) {\n      throw new Error('Eval [?(expr)] prevented in JSONPath expression.');\n    }\n    const safeLoc = loc.replace(/^\\?\\((.*?)\\)$/u, '$1');\n    // check for a nested filter expression\n    const nested = /@.?([^?]*)[['](\\??\\(.*?\\))(?!.\\)\\])[\\]']/gu.exec(safeLoc);\n    if (nested) {\n      // find if there are matches in the nested expression\n      // add them to the result set if there is at least one match\n      this._walk(val, m => {\n        const npath = [nested[2]];\n        const nvalue = nested[1] ? val[m][nested[1]] : val[m];\n        const filterResults = this._trace(npath, nvalue, path, parent, parentPropName, callback, true);\n        if (filterResults.length > 0) {\n          addRet(this._trace(x, val[m], push(path, m), val, m, callback, true));\n        }\n      });\n    } else {\n      this._walk(val, m => {\n        if (this._eval(safeLoc, val[m], m, path, parent, parentPropName)) {\n          addRet(this._trace(x, val[m], push(path, m), val, m, callback, true));\n        }\n      });\n    }\n  } else if (loc[0] === '(') {\n    // [(expr)] (dynamic property/index)\n    if (this.currEval === false) {\n      throw new Error('Eval [(expr)] prevented in JSONPath expression.');\n    }\n    // As this will resolve to a property name (but we don't know it\n    //  yet), property and parent information is relative to the\n    //  parent of the property to which this expression will resolve\n    addRet(this._trace(unshift(this._eval(loc, val, path.at(-1), path.slice(0, -1), parent, parentPropName), x), val, path, parent, parentPropName, callback, hasArrExpr));\n  } else if (loc[0] === '@') {\n    // value type: @boolean(), etc.\n    let addType = false;\n    const valueType = loc.slice(1, -2);\n    switch (valueType) {\n      case 'scalar':\n        if (!val || !['object', 'function'].includes(typeof val)) {\n          addType = true;\n        }\n        break;\n      case 'boolean':\n      case 'string':\n      case 'undefined':\n      case 'function':\n        if (typeof val === valueType) {\n          addType = true;\n        }\n        break;\n      case 'integer':\n        if (Number.isFinite(val) && !(val % 1)) {\n          addType = true;\n        }\n        break;\n      case 'number':\n        if (Number.isFinite(val)) {\n          addType = true;\n        }\n        break;\n      case 'nonFinite':\n        if (typeof val === 'number' && !Number.isFinite(val)) {\n          addType = true;\n        }\n        break;\n      case 'object':\n        if (val && typeof val === valueType) {\n          addType = true;\n        }\n        break;\n      case 'array':\n        if (Array.isArray(val)) {\n          addType = true;\n        }\n        break;\n      case 'other':\n        addType = this.currOtherTypeCallback(val, path, parent, parentPropName);\n        break;\n      case 'null':\n        if (val === null) {\n          addType = true;\n        }\n        break;\n      /* c8 ignore next 2 */\n      default:\n        throw new TypeError('Unknown value type ' + valueType);\n    }\n    if (addType) {\n      retObj = {\n        path,\n        value: val,\n        parent,\n        parentProperty: parentPropName\n      };\n      this._handleCallback(retObj, callback, 'value');\n      return retObj;\n    }\n    // `-escaped property\n  } else if (loc[0] === '`' && val && Object.hasOwn(val, loc.slice(1))) {\n    const locProp = loc.slice(1);\n    addRet(this._trace(x, val[locProp], push(path, locProp), val, locProp, callback, hasArrExpr, true));\n  } else if (loc.includes(',')) {\n    // [name1,name2,...]\n    const parts = loc.split(',');\n    for (const part of parts) {\n      addRet(this._trace(unshift(part, x), val, path, parent, parentPropName, callback, true));\n    }\n    // simple case--directly follow property\n  } else if (!literalPriority && val && Object.hasOwn(val, loc)) {\n    addRet(this._trace(x, val[loc], push(path, loc), val, loc, callback, hasArrExpr, true));\n  }\n\n  // We check the resulting values for parent selections. For parent\n  // selections we discard the value object and continue the trace with the\n  // current val object\n  if (this._hasParentSelector) {\n    for (let t = 0; t < ret.length; t++) {\n      const rett = ret[t];\n      if (rett && rett.isParentSelector) {\n        const tmp = this._trace(rett.expr, val, rett.path, parent, parentPropName, callback, hasArrExpr);\n        if (Array.isArray(tmp)) {\n          ret[t] = tmp[0];\n          const tl = tmp.length;\n          for (let tt = 1; tt < tl; tt++) {\n            // eslint-disable-next-line @stylistic/max-len -- Long\n            // eslint-disable-next-line sonarjs/updated-loop-counter -- Convenient\n            t++;\n            ret.splice(t, 0, tmp[tt]);\n          }\n        } else {\n          ret[t] = tmp;\n        }\n      }\n    }\n  }\n  return ret;\n};\nJSONPath.prototype._walk = function (val, f) {\n  if (Array.isArray(val)) {\n    const n = val.length;\n    for (let i = 0; i < n; i++) {\n      f(i);\n    }\n  } else if (val && typeof val === 'object') {\n    Object.keys(val).forEach(m => {\n      f(m);\n    });\n  }\n};\nJSONPath.prototype._slice = function (loc, expr, val, path, parent, parentPropName, callback) {\n  if (!Array.isArray(val)) {\n    return undefined;\n  }\n  const len = val.length,\n    parts = loc.split(':'),\n    step = parts[2] && Number.parseInt(parts[2]) || 1;\n  let start = parts[0] && Number.parseInt(parts[0]) || 0,\n    end = parts[1] && Number.parseInt(parts[1]) || len;\n  start = start < 0 ? Math.max(0, start + len) : Math.min(len, start);\n  end = end < 0 ? Math.max(0, end + len) : Math.min(len, end);\n  const ret = [];\n  for (let i = start; i < end; i += step) {\n    const tmp = this._trace(unshift(i, expr), val, path, parent, parentPropName, callback, true);\n    // Should only be possible to be an array here since first part of\n    //   ``unshift(i, expr)` passed in above would not be empty, nor `~`,\n    //     nor begin with `@` (as could return objects)\n    // This was causing excessive stack size in Node (with or\n    //  without Babel) against our performance test: `ret.push(...tmp);`\n    tmp.forEach(t => {\n      ret.push(t);\n    });\n  }\n  return ret;\n};\nJSONPath.prototype._eval = function (code, _v, _vname, path, parent, parentPropName) {\n  this.currSandbox._$_parentProperty = parentPropName;\n  this.currSandbox._$_parent = parent;\n  this.currSandbox._$_property = _vname;\n  this.currSandbox._$_root = this.json;\n  this.currSandbox._$_v = _v;\n  const containsPath = code.includes('@path');\n  if (containsPath) {\n    this.currSandbox._$_path = JSONPath.toPathString(path.concat([_vname]));\n  }\n  const scriptCacheKey = this.currEval + 'Script:' + code;\n  if (!JSONPath.cache[scriptCacheKey]) {\n    let script = code.replaceAll('@parentProperty', '_$_parentProperty').replaceAll('@parent', '_$_parent').replaceAll('@property', '_$_property').replaceAll('@root', '_$_root').replaceAll(/@([.\\s)[])/gu, '_$_v$1');\n    if (containsPath) {\n      script = script.replaceAll('@path', '_$_path');\n    }\n    if (this.currEval === 'safe' || this.currEval === true || this.currEval === undefined) {\n      JSONPath.cache[scriptCacheKey] = new this.safeVm.Script(script);\n    } else if (this.currEval === 'native') {\n      JSONPath.cache[scriptCacheKey] = new this.vm.Script(script);\n    } else if (typeof this.currEval === 'function' && this.currEval.prototype && Object.hasOwn(this.currEval.prototype, 'runInNewContext')) {\n      const CurrEval = this.currEval;\n      JSONPath.cache[scriptCacheKey] = new CurrEval(script);\n    } else if (typeof this.currEval === 'function') {\n      JSONPath.cache[scriptCacheKey] = {\n        runInNewContext: context => this.currEval(script, context)\n      };\n    } else {\n      throw new TypeError(`Unknown \"eval\" property \"${this.currEval}\"`);\n    }\n  }\n  try {\n    return JSONPath.cache[scriptCacheKey].runInNewContext(this.currSandbox);\n  } catch (e) {\n    if (this.ignoreEvalErrors) {\n      return false;\n    }\n    throw new Error('jsonPath: ' + e.message + ': ' + code);\n  }\n};\n\n// PUBLIC CLASS PROPERTIES AND METHODS\n\n// Could store the cache object itself\nJSONPath.cache = {};\n\n/**\n * @param {string[]} pathArr Array to convert\n * @returns {string} The path string\n */\nJSONPath.toPathString = function (pathArr) {\n  const x = pathArr,\n    n = x.length;\n  let p = '$';\n  for (let i = 1; i < n; i++) {\n    if (!/^(~|\\^|@.*?\\(\\))$/u.test(x[i])) {\n      p += /^[0-9*]+$/u.test(x[i]) ? '[' + x[i] + ']' : \"['\" + x[i] + \"']\";\n    }\n  }\n  return p;\n};\n\n/**\n * @param {string} pointer JSON Path\n * @returns {string} JSON Pointer\n */\nJSONPath.toPointer = function (pointer) {\n  const x = pointer,\n    n = x.length;\n  let p = '';\n  for (let i = 1; i < n; i++) {\n    if (!/^(~|\\^|@.*?\\(\\))$/u.test(x[i])) {\n      p += '/' + x[i].toString().replaceAll('~', '~0').replaceAll('/', '~1');\n    }\n  }\n  return p;\n};\n\n/**\n * @param {string} expr Expression to convert\n * @returns {string[]}\n */\nJSONPath.toPathArray = function (expr) {\n  const {\n    cache\n  } = JSONPath;\n  if (cache[expr]) {\n    return cache[expr].concat();\n  }\n  const subx = [];\n  const normalized = expr\n  // Properties\n  .replaceAll(/@(?:null|boolean|number|string|integer|undefined|nonFinite|scalar|array|object|function|other)\\(\\)/gu, ';$&;')\n  // Parenthetical evaluations (filtering and otherwise), directly\n  //   within brackets or single quotes\n  .replaceAll(/[['](\\??\\(.*?\\))[\\]'](?!.\\])/gu, function ($0, $1) {\n    return '[#' + (subx.push($1) - 1) + ']';\n  })\n  // Escape periods and tildes within properties\n  .replaceAll(/\\[['\"]([^'\\]]*)['\"]\\]/gu, function ($0, prop) {\n    return \"['\" + prop.replaceAll('.', '%@%').replaceAll('~', '%%@@%%') + \"']\";\n  })\n  // Properties operator\n  .replaceAll('~', ';~;')\n  // Split by property boundaries\n  .replaceAll(/['\"]?\\.['\"]?(?![^[]*\\])|\\[['\"]?/gu, ';')\n  // Reinsert periods within properties\n  .replaceAll('%@%', '.')\n  // Reinsert tildes within properties\n  .replaceAll('%%@@%%', '~')\n  // Parent\n  .replaceAll(/(?:;)?(\\^+)(?:;)?/gu, function ($0, ups) {\n    return ';' + ups.split('').join(';') + ';';\n  })\n  // Descendents\n  .replaceAll(/;;;|;;/gu, ';..;')\n  // Remove trailing\n  .replaceAll(/;$|'?\\]|'$/gu, '');\n  const exprList = normalized.split(';').map(function (exp) {\n    const match = exp.match(/#(\\d+)/u);\n    return !match || !match[1] ? exp : subx[match[1]];\n  });\n  cache[expr] = exprList;\n  return cache[expr].concat();\n};\nJSONPath.prototype.safeVm = {\n  Script: SafeScript\n};\n\n/**\n * @typedef {any} ContextItem\n */\n\n/**\n * @typedef {any} EvaluatedResult\n */\n\n/**\n * @callback ConditionCallback\n * @param {ContextItem} item\n * @returns {boolean}\n */\n\n/**\n * Copy items out of one array into another.\n * @param {GenericArray} source Array with items to copy\n * @param {GenericArray} target Array to which to copy\n * @param {ConditionCallback} conditionCb Callback passed the current item;\n *     will move item if evaluates to `true`\n * @returns {void}\n */\nconst moveToAnotherArray = function (source, target, conditionCb) {\n  const il = source.length;\n  for (let i = 0; i < il; i++) {\n    const item = source[i];\n    if (conditionCb(item)) {\n      // eslint-disable-next-line @stylistic/max-len -- Long\n      // eslint-disable-next-line sonarjs/updated-loop-counter -- Convenient\n      target.push(source.splice(i--, 1)[0]);\n    }\n  }\n};\n\n/**\n * In-browser replacement for NodeJS' VM.Script.\n */\nclass Script {\n  /**\n   * @param {string} expr Expression to evaluate\n   */\n  constructor(expr) {\n    this.code = expr;\n  }\n\n  /**\n   * @param {object} context Object whose items will be added\n   *   to evaluation\n   * @returns {EvaluatedResult} Result of evaluated code\n   */\n  runInNewContext(context) {\n    let expr = this.code;\n    const keys = Object.keys(context);\n    const funcs = [];\n    moveToAnotherArray(keys, funcs, key => {\n      return typeof context[key] === 'function';\n    });\n    const values = keys.map(vr => {\n      return context[vr];\n    });\n    const funcString = funcs.reduce((s, func) => {\n      let fString = context[func].toString();\n      if (!/function/u.test(fString)) {\n        fString = 'function ' + fString;\n      }\n      return 'var ' + func + '=' + fString + ';' + s;\n    }, '');\n    expr = funcString + expr;\n\n    // Mitigate http://perfectionkills.com/global-eval-what-are-the-options/#new_function\n    if (!/(['\"])use strict\\1/u.test(expr) && !keys.includes('arguments')) {\n      expr = 'var arguments = undefined;' + expr;\n    }\n\n    // Remove last semi so `return` will be inserted before\n    //  the previous one instead, allowing for the return\n    //  of a bare ending expression\n    expr = expr.replace(/;\\s*$/u, '');\n\n    // Insert `return`\n    const lastStatementEnd = expr.lastIndexOf(';');\n    const code = lastStatementEnd !== -1 ? expr.slice(0, lastStatementEnd + 1) + ' return ' + expr.slice(lastStatementEnd + 1) : ' return ' + expr;\n\n    // eslint-disable-next-line no-new-func -- User's choice\n    return new Function(...keys, code)(...values);\n  }\n}\nJSONPath.prototype.vm = {\n  Script\n};\n\nexport { JSONPath };\n","/**\n * Utility functions for extracting values from JSON and HTML responses\n * Shared between network-filter.js and params-extractor.js\n */\n\nimport { debugLogger, DebugLogType } from \"../logger\";\nimport { JSONPath } from \"jsonpath-plus\";\n\n/**\n * Extract values from JSON response using jsonPath\n * @param {Object} jsonData - Parsed JSON response\n * @param {string} jsonPath - JSONPath expression (e.g., $.userName, $.profile.electronicAddresses[0].email)\n * @returns {any} Extracted value or null if not found\n */\nexport const getValueFromJsonPath = (jsonData, jsonPath) => {\n  try {\n    const results = JSONPath({ path: jsonPath, json: jsonData });\n    const finalResult = results?.[0];\n    if (finalResult === undefined) {\n      return undefined;\n    } else if (finalResult === null) {\n      return \"null\";\n    }\n    return finalResult;\n  } catch (error) {\n    debugLogger.error(\n      DebugLogType.CLAIM,\n      `[PARAMS-EXTRACTOR-UTILS] Error extracting JSON value with path ${jsonPath}:`,\n      error,\n    );\n    return undefined;\n  }\n};\n\n/**\n * Extract values from HTML response using XPath (simplified)\n * @param {string} htmlString - HTML string\n * @param {string} xPath - XPath expression\n * @returns {string|null|undefined} Extracted value or null if not found\n */\nexport const getValueFromXPath = (htmlString, xPath) => {\n  // This is a simplified implementation\n  // For proper XPath parsing, a library would be needed\n  try {\n    // Extract with regex based on the xPath pattern\n    // This is a very basic implementation and won't work for all XPath expressions\n    const cleanedXPath = xPath.replace(/^\\/\\//, \"\").replace(/\\/@/, \" \");\n    const parts = cleanedXPath.split(\"/\");\n    const element = parts[parts.length - 1];\n\n    // Simple regex to find elements with content\n    const regex = new RegExp(`<${element}[^>]*>(.*?)<\\/${element}>`, \"i\");\n    const match = htmlString.match(regex);\n\n    return match ? match[1] : undefined;\n  } catch (error) {\n    debugLogger.error(\n      DebugLogType.CLAIM,\n      `[PARAMS-EXTRACTOR-UTILS] Error extracting HTML value with XPath ${xPath}:`,\n      error,\n    );\n    return undefined;\n  }\n};\n\n/**\n * Check if a string appears to be JSON format\n * @param {string} text - Text to check\n * @returns {boolean} True if text appears to be JSON\n */\nexport const isJsonFormat = (text) => {\n  if (!text || typeof text !== \"string\") return false;\n  const trimmed = text.trim();\n  return trimmed.startsWith(\"{\") || trimmed.startsWith(\"[\");\n};\n\n/**\n * Safely parse JSON text\n * @param {string} jsonText - JSON text to parse\n * @returns {Object|null} Parsed JSON object or null if parsing fails\n */\nexport const safeJsonParse = (jsonText) => {\n  try {\n    return JSON.parse(jsonText);\n  } catch (e) {\n    debugLogger.warn(\n      DebugLogType.CLAIM,\n      \"[PARAMS-EXTRACTOR-UTILS] Response looks like JSON but couldn't be parsed\",\n    );\n    return null;\n  }\n};\n","// Import shared utility functions\nimport {\n  getValueFromJsonPath,\n  getValueFromXPath,\n  isJsonFormat,\n  safeJsonParse,\n} from \"./params-extractor-utils.js\";\nimport { LOG_LEVEL, LOG_TYPES, EVENT_TYPES } from \"../logger\";\n\n// Escape special regex characters in string\nfunction escapeSpecialCharacters(input) {\n  return input.replace(/[[\\]()*+?.,\\\\^$|#]/g, \"\\\\$&\");\n}\n\n// Extract template variables from a string\nfunction getTemplateVariables(template) {\n  const paramRegex = /{{(\\w+)}}/g;\n  const variables = [];\n  let match;\n\n  while ((match = paramRegex.exec(template)) !== null) {\n    variables.push(match[1]);\n  }\n\n  return variables;\n}\n\n// Convert template to regex, substituting known parameters\nexport function convertTemplateToRegex(template, parameters = {}) {\n  // Escape special regex characters\n  let escapedTemplate = escapeSpecialCharacters(template);\n\n  // Find all template variables\n  const allVars = getTemplateVariables(template);\n  const unsubstitutedVars = [];\n\n  // Replace template variables with actual values or regex patterns\n  for (const param of allVars) {\n    if (parameters[param]) {\n      // Substitute known parameter\n      escapedTemplate = escapedTemplate.replace(`{{${param}}}`, parameters[param]);\n    } else {\n      // Track unsubstituted variables\n      unsubstitutedVars.push(param);\n      // Use appropriate regex pattern based on variable name\n      const replacement = param.endsWith(\"GRD\") ? \"(.*)\" : \"(.*?)\";\n      escapedTemplate = escapedTemplate.replace(`{{${param}}}`, replacement);\n    }\n  }\n\n  return {\n    pattern: escapedTemplate,\n    allVars,\n    unsubstitutedVars,\n  };\n}\n\n// Function to check if a request matches filtering criteria\nfunction matchesRequestCriteria(request, filterCriteria, parameters = {}) {\n  if (!filterCriteria || !request) return false;\n\n  // 1) URL match: exact, REGEX, or TEMPLATE\n  const urlMatches = (() => {\n    const { url, urlType } = filterCriteria;\n    if (!url) return false;\n\n    const type = (urlType || \"EXACT\").toUpperCase();\n\n    if (type === \"EXACT\") {\n      return url === request.url;\n    }\n\n    if (type === \"REGEX\" || type === \"TEMPLATE\") {\n      const { pattern } = convertTemplateToRegex(url, parameters);\n\n      return new RegExp(pattern).test(request.url);\n    }\n\n    return false;\n  })();\n\n  if (!urlMatches) return false;\n  if (request.method?.toUpperCase() !== filterCriteria.method?.toUpperCase()) {\n    return false;\n  }\n\n  // 3) Body match (only if enabled)\n  const bodyMatches = (() => {\n    const sniff = filterCriteria.bodySniff;\n    if (!sniff || !sniff.enabled) return true;\n    const bodyTemplate = sniff.template ?? \"\";\n    const requestBody =\n      typeof request.body === \"string\" ? request.body : JSON.stringify(request.body ?? {});\n\n    // exact body equality satisfies body criterion\n    if (bodyTemplate === requestBody) return true;\n\n    // template/regex body match\n    const { pattern } = convertTemplateToRegex(bodyTemplate, parameters);\n    return new RegExp(pattern).test(requestBody);\n  })();\n\n  return bodyMatches;\n}\n\n// Function to check if response matches criteria\nfunction matchesResponseCriteria(responseText, matchCriteria, parameters = {}) {\n  if (!matchCriteria || matchCriteria.length === 0) {\n    return true;\n  }\n\n  for (const match of matchCriteria) {\n    let pattern;\n    if (match.type === \"regex\") {\n      pattern = match.value;\n    } else {\n      pattern = convertTemplateToRegex(match.value, parameters).pattern;\n    }\n    const regex = new RegExp(pattern);\n    const matches = regex.test(responseText);\n    // Check if match expectation is met\n    const matchExpectation = match.invert ? !matches : matches;\n    if (!matchExpectation) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n// Function to check if response fields match responseRedactions criteria\nfunction matchesResponseFields(responseText, responseRedactions, contentLogger) {\n  if (!responseRedactions || responseRedactions.length === 0) {\n    return true;\n  }\n\n  // Try to parse JSON if the response appears to be JSON\n  let jsonData = null;\n  const isJson = isJsonFormat(responseText);\n\n  if (isJson) {\n    jsonData = safeJsonParse(responseText);\n  }\n\n  // Check each redaction pattern\n  for (const redaction of responseRedactions) {\n    // If jsonPath is specified and response is JSON\n    if (redaction.jsonPath && jsonData) {\n      try {\n        const value = getValueFromJsonPath(jsonData, redaction.jsonPath);\n        // If we get here but value is undefined, the path doesn't exist\n        if (value === undefined) return false;\n      } catch (error) {\n        contentLogger.error({\n          message: `[NETWORK-FILTER] Error checking jsonPath ${redaction.jsonPath}:`,\n          logLevel: LOG_LEVEL.INFO,\n          type: LOG_TYPES.CONTENT,\n          eventType: EVENT_TYPES.JSON_PATH_MATCH_REQUIREMENT_FAILED,\n        });\n        return false;\n      }\n    }\n    // If xPath is specified and response is not JSON (assumed to be HTML)\n    else if (redaction.xPath && !isJson) {\n      try {\n        const value = getValueFromXPath(responseText, redaction.xPath);\n        if (!value) return false;\n      } catch (error) {\n        contentLogger.error({\n          message: `[NETWORK-FILTER] Error checking xPath ${redaction.xPath}:`,\n          logLevel: LOG_LEVEL.INFO,\n          type: LOG_TYPES.CONTENT,\n          eventType: EVENT_TYPES.X_PATH_MATCH_REQUIREMENT_FAILED,\n        });\n        return false;\n      }\n    }\n    // If regex is specified\n    else if (redaction.regex) {\n      try {\n        const regex = new RegExp(redaction.regex);\n        if (!regex.test(responseText)) return false;\n      } catch (error) {\n        contentLogger.error({\n          message: `[NETWORK-FILTER] Error checking regex ${redaction.regex}:`,\n          logLevel: LOG_LEVEL.INFO,\n          type: LOG_TYPES.CONTENT,\n          eventType: EVENT_TYPES.REGEX_MATCH_REQUIREMENT_FAILED,\n        });\n        return false;\n      }\n    }\n  }\n\n  // All checks passed\n  return true;\n}\n\n// Main filtering function\nexport const filterRequest = (request, filterCriteria, parameters = {}, contentLogger) => {\n  try {\n    // First check if request matches criteria\n    if (!matchesRequestCriteria(request, filterCriteria, parameters)) {\n      return false;\n    }\n\n    // Then check if response matches (if we have response data)\n    if (\n      request.responseText &&\n      filterCriteria.responseMatches &&\n      !matchesResponseCriteria(request.responseText, filterCriteria.responseMatches, parameters)\n    ) {\n      return false;\n    }\n\n    // Check if the response fields match the responseRedactions criteria\n    if (\n      request.responseText &&\n      filterCriteria.responseRedactions &&\n      !matchesResponseFields(request.responseText, filterCriteria.responseRedactions, contentLogger)\n    ) {\n      return false;\n    }\n\n    return true;\n  } catch (error) {\n    contentLogger.error({\n      message: \"[NETWORK-FILTER] Error filtering request:\",\n      logLevel: LOG_LEVEL.ERROR,\n      type: LOG_TYPES.CONTENT,\n      eventType: EVENT_TYPES.FILTER_REQUEST_ERROR,\n      meta: { error },\n    });\n    return false;\n  }\n};\n","// Utility functions for parameter extraction from various sources\nimport { convertTemplateToRegex } from \"./network-filter\";\nimport {\n  getValueFromJsonPath,\n  getValueFromXPath,\n  isJsonFormat,\n  safeJsonParse,\n} from \"./params-extractor-utils.js\";\nimport { LOG_LEVEL, LOG_TYPES, EVENT_TYPES } from \"../logger\";\n\n/**\n * Extract dynamic parameters from a string by matching {{PARAM_NAME}} patterns\n * @param {string} text - Text to extract parameters from\n * @returns {string[]} Array of parameter names without braces\n */\nexport const extractDynamicParamNames = (text) => {\n  if (!text) return [];\n  const matches = text.match(/{{([^}]+)}}/g) || [];\n  return matches.map((match) => match.substring(2, match.length - 2));\n};\n\n/**\n * Extract parameter values from URL using template matching\n * @param {string} urlTemplate - URL template with {{param}} placeholders\n * @param {string} actualUrl - Actual URL with values\n * @param {Object} paramValues - Object to store extracted parameter values\n * @returns {Object} Updated paramValues object\n */\nexport const extractParamsFromUrl = (urlTemplate, actualUrl, paramValues = {}) => {\n  if (!urlTemplate || !actualUrl) return paramValues;\n\n  // Extract param names from template\n  const paramNames = extractDynamicParamNames(urlTemplate);\n  const regex = convertTemplateToRegex(urlTemplate, paramNames).pattern;\n\n  // Match actual URL against the pattern\n  const match = actualUrl.match(regex);\n  if (match && match.length > 1) {\n    // Start from index 1 to skip the full match\n    for (let i = 0; i < paramNames.length; i++) {\n      if (match[i + 1]) {\n        paramValues[paramNames[i]] = match[i + 1];\n      }\n    }\n  }\n  return paramValues;\n};\n\n/**\n * Extract parameter values from request body using template matching\n * @param {string} bodyTemplate - Body template with {{param}} placeholders\n * @param {string} actualBody - Actual request body with values\n * @param {Object} paramValues - Object to store extracted parameter values\n * @returns {Object} Updated paramValues object\n */\nexport const extractParamsFromBody = (bodyTemplate, actualBody, paramValues = {}) => {\n  if (!bodyTemplate || !actualBody) return paramValues;\n\n  // Extract param names from template\n  const paramNames = extractDynamicParamNames(bodyTemplate);\n\n  const { pattern } = convertTemplateToRegex(bodyTemplate, {});\n  const regex = new RegExp(pattern);\n\n  // Match actual body against the pattern\n  const match = actualBody.match(regex);\n  if (match && match.length > 1) {\n    // Start from index 1 to skip the full match\n    for (let i = 0; i < paramNames.length; i++) {\n      if (match[i + 1]) {\n        paramValues[paramNames[i]] = match[i + 1];\n      }\n    }\n  }\n\n  return paramValues;\n};\n\n/**\n * Extract parameter values from response text using responseMatches and responseRedactions\n * @param {string} responseText - Response body text\n * @param {Array} responseMatches - Array of response match objects\n * @param {Array} responseRedactions - Array of response redaction objects\n * @param {Object} paramValues - Object to store extracted parameter values\n * @returns {Object} Updated paramValues object\n */\nexport const extractParamsFromResponse = (\n  responseText,\n  responseMatches,\n  responseRedactions,\n  paramValues = {},\n  bgLogger,\n) => {\n  if (!responseText) return paramValues;\n\n  try {\n    // First, determine if the response is JSON or HTML\n    let jsonData = null;\n    const isJson = isJsonFormat(responseText);\n\n    if (isJson) {\n      jsonData = safeJsonParse(responseText);\n    }\n\n    // Process responseMatches to extract parameters\n    if (\n      responseMatches &&\n      responseMatches.length > 0 &&\n      responseRedactions &&\n      responseRedactions.length > 0\n    ) {\n      // iterate over the responseMatches and responseRedactions both have elements with co related to the same index\n      for (let i = 0; i < responseMatches.length; i++) {\n        const match = responseMatches[i];\n        const redaction = responseRedactions[i];\n\n        if (!match.value) return;\n\n        // Extract param names from match value expect one parameter per responseMatch\n        const paramNames = extractDynamicParamNames(match.value);\n        if (paramNames.length === 0) return;\n\n        // Find corresponding redaction for this parameter\n        // Expecting only one redaction per parameter\n        const matchingRedaction = redaction;\n\n        if (matchingRedaction) {\n          let extractedValue = null;\n\n          // Try to extract using jsonPath if available and response is JSON\n          if (matchingRedaction.jsonPath && jsonData) {\n            extractedValue = getValueFromJsonPath(jsonData, matchingRedaction.jsonPath);\n          }\n          // Try to extract using xPath if available and response is HTML\n          else if (matchingRedaction.xPath && !isJson) {\n            extractedValue = getValueFromXPath(responseText, matchingRedaction.xPath);\n          }\n          // Fall back to regex extraction\n          else if (matchingRedaction.regex) {\n            const regexMatch = responseText.match(new RegExp(matchingRedaction.regex));\n            if (regexMatch && regexMatch.length > 1) {\n              extractedValue = regexMatch[1];\n            }\n          }\n\n          // Store the extracted value as string\n          if (extractedValue !== undefined) {\n            // Convert objects and arrays to JSON string, primitives to regular string\n            if (typeof extractedValue === \"object\" && extractedValue !== null) {\n              paramValues[paramNames[0]] = JSON.stringify(extractedValue);\n            } else if (extractedValue === null) {\n              paramValues[paramNames[0]] = null;\n            } else {\n              paramValues[paramNames[0]] = String(extractedValue);\n            }\n          }\n        }\n      }\n    }\n  } catch (error) {\n    bgLogger.error({\n      message: \"[PARAM-EXTRACTOR] Error extracting params from response:\",\n      logLevel: LOG_LEVEL.INFO,\n      type: LOG_TYPES.CLAIM_CREATION,\n      eventType: EVENT_TYPES.CLAIM_PARAMETER_VALIDATION_FAILED_EXCEPTION,\n      meta: { error },\n    });\n  }\n\n  return paramValues;\n};\n\n/**\n * Separate parameters into public and secret based on names\n * @param {Object} paramValues - All parameter values\n * @returns {Object} Object with publicParams and secretParams\n */\nexport const separateParams = (paramValues) => {\n  const publicParams = {};\n  const secretParams = {};\n\n  Object.entries(paramValues || {}).forEach(([key, value]) => {\n    if (key.toLowerCase().includes(\"secret\")) {\n      secretParams[key] = value;\n    } else {\n      publicParams[key] = value;\n    }\n  });\n\n  return { publicParams, secretParams };\n};\n","import {\n  extractParamsFromUrl,\n  extractParamsFromBody,\n  extractParamsFromResponse,\n  separateParams,\n} from \"./params-extractor\";\nimport { MESSAGE_ACTIONS, MESSAGE_SOURCES, ATTESTOR_WS_URL } from \"../constants\";\nimport { ensureOffscreenDocument } from \"../offscreen-manager\";\nimport { getUserLocationBasedOnIp } from \"./get-dynamic-geo\";\nimport { EVENT_TYPES, LOG_LEVEL, LOG_TYPES } from \"../logger/constants\";\n\n// Generate Chrome Android user agent (adapted from reference code)\nconst generateChromeAndroidUserAgent = (chromeMajorVersion = 135, isMobile = true) => {\n  if (chromeMajorVersion <= 0) {\n    chromeMajorVersion = 135;\n  }\n\n  const platform = \"(Linux; Android 10; K)\";\n  const engine = \"AppleWebKit/537.36 (KHTML, like Gecko)\";\n  const chromeVersionString = `Chrome/${chromeMajorVersion}.0.0.0`;\n  const mobileToken = isMobile ? \" Mobile\" : \"\";\n  const safariCompat = \"Safari/537.36\";\n\n  return `Mozilla/5.0 ${platform} ${engine} ${chromeVersionString}${mobileToken} ${safariCompat}`;\n};\n\nconst getPrivateKeyFromOffscreen = (sessionId = \"unknown\", providerId = \"unknown\", bgLogger) => {\n  bgLogger.setContext({\n    sessionId: sessionId,\n    providerId: providerId,\n    type: LOG_TYPES.CLAIM_CREATION,\n  });\n  return new Promise((resolve, reject) => {\n    // Timeout after 10 seconds\n    const callTimeout = setTimeout(() => {\n      chrome.runtime.onMessage.removeListener(messageListener);\n      reject(new Error(\"Timeout: No response from offscreen document for private key request.\"));\n    }, 10000);\n\n    const messageListener = (message, sender) => {\n      // Ensure the message is from the offscreen document and is the expected response\n      if (\n        message.action === MESSAGE_ACTIONS.GET_PRIVATE_KEY_RESPONSE &&\n        message.source === MESSAGE_SOURCES.OFFSCREEN &&\n        message.target === MESSAGE_SOURCES.BACKGROUND\n      ) {\n        // Assuming this script runs in background context\n\n        clearTimeout(callTimeout);\n        chrome.runtime.onMessage.removeListener(messageListener);\n\n        if (message.success && message.privateKey) {\n          bgLogger.info({\n            message: \"[CLAIM-CREATOR] Received private key from offscreen document\",\n            logLevel: LOG_LEVEL.INFO,\n            type: LOG_TYPES.CLAIM_CREATION,\n          });\n          resolve(message.privateKey);\n        } else {\n          bgLogger.error({\n            message:\n              \"[CLAIM-CREATOR] Failed to get private key from offscreen document: \" + message.error,\n            logLevel: LOG_LEVEL.INFO,\n            type: LOG_TYPES.CLAIM_CREATION,\n          });\n          reject(\n            new Error(\n              message.error || \"Unknown error getting private key from offscreen document.\",\n            ),\n          );\n        }\n        return false; // Indicate message has been handled\n      }\n      return true; // Keep listener active for other messages\n    };\n\n    chrome.runtime.onMessage.addListener(messageListener);\n\n    bgLogger.info({\n      message: \"[CLAIM-CREATOR] Requesting private key from offscreen document\",\n      logLevel: LOG_LEVEL.INFO,\n      type: LOG_TYPES.CLAIM_CREATION,\n    });\n\n    chrome.runtime.sendMessage(\n      {\n        action: MESSAGE_ACTIONS.GET_PRIVATE_KEY,\n        source: MESSAGE_SOURCES.BACKGROUND, // Assuming this script runs in background context\n        target: MESSAGE_SOURCES.OFFSCREEN,\n        sessionId: sessionId,\n        providerId: providerId,\n      },\n      (response) => {\n        if (chrome.runtime.lastError) {\n          clearTimeout(callTimeout);\n          chrome.runtime.onMessage.removeListener(messageListener);\n          bgLogger.error({\n            message:\n              \"[CLAIM-CREATOR] Error sending GET_PRIVATE_KEY message: \" +\n              chrome.runtime.lastError.message,\n            logLevel: LOG_LEVEL.INFO,\n            type: LOG_TYPES.CLAIM_CREATION,\n          });\n          reject(\n            new Error(\n              `Error sending message to offscreen document: ${chrome.runtime.lastError.message}`,\n            ),\n          );\n        }\n        // If offscreen.js calls sendResponse synchronously, it can be handled here\n        // but the main logic relies on the async messageListener\n      },\n    );\n  });\n};\n\nexport const createClaimObject = async (\n  request,\n  providerData,\n  sessionId = \"unknown\",\n  providerId = \"unknown\",\n  loginUrl,\n  bgLogger,\n) => {\n  bgLogger.setContext({\n    sessionId: sessionId,\n    providerId: providerId,\n    type: LOG_TYPES.CLAIM_CREATION,\n  });\n\n  bgLogger.info({\n    message: \"[CLAIM-CREATOR] Creating claim object from request data\",\n    logLevel: LOG_LEVEL.INFO,\n    type: LOG_TYPES.CLAIM_CREATION,\n    eventType: EVENT_TYPES.CLAIM_CREATION_STARTED,\n  });\n  // Ensure offscreen document is ready\n  try {\n    await ensureOffscreenDocument(bgLogger);\n    bgLogger.info({\n      message: \"[CLAIM-CREATOR] Offscreen document is ready.\",\n      logLevel: LOG_LEVEL.INFO,\n      type: LOG_TYPES.CLAIM_CREATION,\n      eventType: EVENT_TYPES.OFFSCREEN_DOCUMENT_READY,\n    });\n  } catch (error) {\n    bgLogger.error({\n      message: \"[CLAIM-CREATOR] Failed to ensure offscreen document: \" + error?.message,\n      logLevel: LOG_LEVEL.INFO,\n      type: LOG_TYPES.CLAIM_CREATION,\n      eventType: EVENT_TYPES.OFFSCREEN_DOCUMENT_NOT_READY_EXCEPTION,\n      meta: {\n        error: error?.message,\n        request: request,\n        providerData: providerData,\n        sessionId: sessionId,\n        loginUrl: loginUrl,\n      },\n    });\n    // Depending on requirements, you might want to throw error or handle differently\n    throw new Error(`Failed to initialize offscreen document: ${error.message}`);\n  }\n\n  // Generate appropriate user agent for the platform\n  // const userAgent = await generateChromeAndroidUserAgent();\n\n  const userAgent =\n    (typeof navigator !== \"undefined\" && navigator.userAgent) || generateChromeAndroidUserAgent();\n\n  // Define public headers that should be in params\n  const PUBLIC_HEADERS = [\n    \"user-agent\",\n    \"accept\",\n    \"accept-language\",\n    \"accept-encoding\",\n    \"sec-fetch-mode\",\n    \"sec-fetch-site\",\n    \"sec-fetch-user\",\n    \"origin\",\n    \"x-requested-with\",\n    \"sec-ch-ua\",\n    \"sec-ch-ua-mobile\",\n  ];\n\n  // Initialize params and secretParams objects\n  const params = {};\n  const secretParams = {};\n\n  // Process URL\n  params.url = providerData.urlType === \"TEMPLATE\" ? providerData.url : request.url;\n  params.method = request.method || \"GET\";\n\n  // Process headers - split between public and secret\n  if (request.headers) {\n    const publicHeaders = {\n      \"Sec-Fetch-Mode\": \"same-origin\",\n      \"Sec-Fetch-Site\": \"same-origin\",\n      \"User-Agent\": userAgent,\n    };\n    const secretHeaders = {\n      Referer: (request.referer && String(request.referer)) || loginUrl || origin || \"\",\n    };\n\n    Object.entries(request.headers).forEach(([key, value]) => {\n      const lowerKey = key.toLowerCase();\n      if (PUBLIC_HEADERS.includes(lowerKey)) {\n        publicHeaders[key] = value;\n      } else {\n        secretHeaders[key] = value;\n      }\n    });\n\n    if (Object.keys(publicHeaders).length > 0) {\n      params.headers = publicHeaders;\n    }\n\n    if (Object.keys(secretHeaders).length > 0) {\n      secretParams.headers = secretHeaders;\n    }\n  }\n\n  if (request.body) {\n    if (providerData?.bodySniff?.enabled) {\n      params.body = providerData.bodySniff.template;\n    } else {\n      params.body = request.body; // pass-through raw body\n    }\n  }\n\n  // Process cookie string if available in request\n  if (request.cookieStr) {\n    secretParams.cookieStr = request.cookieStr;\n  }\n\n  // Extract dynamic parameters from various sources\n  let allParamValues = {};\n\n  if (request?.extractedParams && typeof request.extractedParams === \"object\") {\n    allParamValues = { ...allParamValues, ...request.extractedParams };\n  }\n\n  // 1. Extract params from URL if provider has URL template\n  if (providerData.urlType === \"TEMPLATE\" && request.url) {\n    // append the extracted parameters to the existing allParamValues\n    allParamValues = { ...allParamValues, ...extractParamsFromUrl(providerData.url, request.url) };\n  }\n\n  // 2. Extract params from request body if provider has body template\n\n  if (providerData?.bodySniff?.enabled && request.body) {\n    // append the extracted parameters to the existing allParamValues\n    allParamValues = {\n      ...allParamValues,\n      ...extractParamsFromBody(providerData.bodySniff.template, request.body),\n    };\n  }\n\n  // 3. Extract params from response if available\n  if (request.responseText && providerData.responseMatches) {\n    // append the extracted parameters to the existing allParamValues\n    allParamValues = {\n      ...allParamValues,\n      ...extractParamsFromResponse(\n        request.responseText,\n        providerData.responseMatches,\n        providerData.responseRedactions || [],\n      ),\n    };\n  }\n\n  // 5. Separate parameters into public and secret\n  const { publicParams, secretParams: secretParamValues } = separateParams(allParamValues);\n\n  // Add parameter values to respective objects\n  if (Object.keys(publicParams).length > 0) {\n    params.paramValues = publicParams;\n  }\n\n  if (Object.keys(secretParamValues).length > 0) {\n    secretParams.paramValues = secretParamValues;\n  }\n\n  // Process response matches if available\n  if (providerData.responseMatches) {\n    params.responseMatches = providerData.responseMatches.map((match) => {\n      // Create a clean object with only the required fields\n      const cleanMatch = {\n        value: match.value,\n        type: match.type || \"contains\",\n        invert: match.invert || false,\n      };\n\n      return cleanMatch;\n    });\n  }\n\n  // Process response redactions if available\n  if (providerData.responseRedactions) {\n    params.responseRedactions = providerData.responseRedactions.map((redaction) => {\n      // Create a new object without hash field and empty jsonPath/xPath\n      const cleanedRedaction = {};\n\n      Object.entries(redaction).forEach(([key, value]) => {\n        // Skip the hash field\n        if (key === \"hash\") {\n          return;\n        }\n\n        // Skip empty jsonPath and xPath\n        if ((key === \"jsonPath\" || key === \"xPath\") && (!value || value === \"\")) {\n          return;\n        }\n\n        // Keep all other fields\n        cleanedRedaction[key] = value;\n      });\n\n      return cleanedRedaction;\n    });\n  }\n\n  // Process response selections if available\n  if (providerData.responseSelections) {\n    params.responseSelections = providerData.responseSelections.map((selection) => {\n      // Only include value, type, and invert fields\n      const cleanedSelection = {};\n\n      if (\"value\" in selection) {\n        cleanedSelection.value = selection.value;\n      }\n\n      if (\"type\" in selection) {\n        cleanedSelection.type = selection.type;\n      }\n\n      if (\"invert\" in selection) {\n        cleanedSelection.invert = selection.invert;\n      }\n\n      return cleanedSelection;\n    });\n  }\n\n  // Add any additional client options if available\n  if (providerData.additionalClientOptions) {\n    params.additionalClientOptions = providerData.additionalClientOptions;\n  }\n\n  let ownerPrivateKey;\n  try {\n    ownerPrivateKey = await getPrivateKeyFromOffscreen(sessionId, providerId, bgLogger);\n  } catch (error) {\n    // Fallback or re-throw, depending on how critical the key is.\n    // For now, let's re-throw to make the failure visible.\n    bgLogger.error({\n      message: \"[CLAIM-CREATOR] Error obtaining owner private key: \" + error.message,\n      logLevel: LOG_LEVEL.INFO,\n      type: LOG_TYPES.CLAIM_CREATION,\n      eventType: EVENT_TYPES.CLAIM_CREATION_FAILED,\n    });\n    throw new Error(`Could not obtain owner private key: ${error.message}`);\n  }\n\n  let geoLocation = providerData?.geoLocation ?? \"\";\n\n  if (geoLocation === \"{{DYNAMIC_GEO}}\") {\n    geoLocation = await getUserLocationBasedOnIp();\n  }\n\n  bgLogger.log({\n    message: \"[CLAIM-CREATOR] Geo location: \" + geoLocation,\n    logLevel: LOG_LEVEL.INFO,\n    type: LOG_TYPES.CLAIM_CREATION,\n  });\n\n  params.geoLocation = geoLocation;\n\n  // Create the final claim object\n  const claimObject = {\n    name: \"http\",\n    sessionId: sessionId,\n    params,\n    secretParams,\n    ownerPrivateKey: ownerPrivateKey,\n    client: {\n      url: ATTESTOR_WS_URL,\n    },\n  };\n\n  bgLogger.info({\n    message: \"[CLAIM-CREATOR] Claim object created successfully\",\n    logLevel: LOG_LEVEL.INFO,\n    type: LOG_TYPES.CLAIM_CREATION,\n    eventType: EVENT_TYPES.CLAIM_CREATION_SUCCESS,\n  });\n\n  bgLogger.log({\n    message: \"[CLAIM-CREATOR] Claim object: \" + JSON.stringify(claimObject, null, 2),\n    logLevel: LOG_LEVEL.ALL,\n    type: LOG_TYPES.CLAIM_CREATION,\n  });\n\n  return claimObject;\n};\n","/**\n * Session timer utility functions for Reclaim Browser Extension\n * Handles session timeout management\n */\n\nimport { debugLogger, DebugLogType } from \"./logger\";\n\nexport class SessionTimerManager {\n  constructor() {\n    // Timer for session\n    this.sessionTimer = null;\n    this.sessionTimerDuration = 30000; // 30 seconds in milliseconds\n    this.sessionTimerPaused = false;\n    this.sessionTimerRemainingTime = 0;\n    this.sessionTimerStartTime = 0;\n\n    // Callback for session timeout\n    this.onSessionTimeout = null;\n  }\n\n  /**\n   * Set callback for session timer event\n   * @param {Function} sessionTimeoutCallback - Called when session timer expires\n   */\n  setCallbacks(sessionTimeoutCallback) {\n    this.onSessionTimeout = sessionTimeoutCallback;\n  }\n\n  /**\n   * Start session timer (default 30 seconds)\n   */\n  startSessionTimer() {\n    debugLogger.info(DebugLogType.SESSION_TIMER, \"[SESSION TIMER] Starting session timer\");\n    // Clear any existing timer\n    this.clearSessionTimer();\n\n    this.sessionTimerStartTime = Date.now();\n    this.sessionTimer = setTimeout(() => {\n      // Check if timer is still valid before firing timeout\n      if (this.sessionTimer !== null) {\n        debugLogger.error(DebugLogType.SESSION_TIMER, \"[SESSION TIMER] Session timer expired\");\n        if (this.onSessionTimeout) {\n          this.onSessionTimeout(\"Session timeout: No proofs generated within time limit\");\n        }\n      } else {\n        debugLogger.info(\n          DebugLogType.SESSION_TIMER,\n          \"[SESSION TIMER] Timer was already cleared, ignoring timeout\",\n        );\n      }\n    }, this.sessionTimerDuration);\n  }\n\n  /**\n   * Reset session timer (called after successful proof generation)\n   */\n  resetSessionTimer() {\n    debugLogger.info(DebugLogType.SESSION_TIMER, \"[SESSION TIMER] Resetting session timer\");\n    this.clearSessionTimer();\n    this.startSessionTimer();\n  }\n\n  /**\n   * Clear session timer\n   */\n  clearSessionTimer() {\n    if (this.sessionTimer) {\n      clearTimeout(this.sessionTimer);\n      this.sessionTimer = null;\n    }\n  }\n\n  /**\n   * Pause session timer while processing a proof\n   */\n  pauseSessionTimer() {\n    if (this.sessionTimer && !this.sessionTimerPaused) {\n      debugLogger.info(DebugLogType.SESSION_TIMER, \"[SESSION TIMER] Pausing session timer\");\n      // Calculate remaining time\n      const elapsedTime = Date.now() - this.sessionTimerStartTime;\n      this.sessionTimerRemainingTime = Math.max(0, this.sessionTimerDuration - elapsedTime);\n\n      // Clear the current timer\n      this.clearSessionTimer();\n      this.sessionTimerPaused = true;\n    }\n  }\n\n  /**\n   * Resume session timer after processing a proof\n   */\n  resumeSessionTimer() {\n    if (this.sessionTimerPaused) {\n      debugLogger.info(\n        DebugLogType.SESSION_TIMER,\n        \"[SESSION TIMER] Resuming session timer with remaining time:\",\n        this.sessionTimerRemainingTime,\n      );\n\n      this.sessionTimer = setTimeout(() => {\n        debugLogger.error(DebugLogType.SESSION_TIMER, \"[SESSION TIMER] Session timer expired\");\n        if (this.onSessionTimeout) {\n          this.onSessionTimeout(\"Session timeout: No proofs generated within time limit\");\n        }\n      }, this.sessionTimerRemainingTime);\n\n      this.sessionTimerStartTime =\n        Date.now() - (this.sessionTimerDuration - this.sessionTimerRemainingTime);\n      this.sessionTimerPaused = false;\n    }\n  }\n\n  /**\n   * Clear all timers\n   */\n  clearAllTimers() {\n    debugLogger.info(DebugLogType.SESSION_TIMER, \"[SESSION TIMER] Clearing all timers\");\n    this.clearSessionTimer();\n    this.sessionTimerPaused = false;\n    this.sessionTimerRemainingTime = 0;\n    this.sessionTimerStartTime = 0;\n  }\n\n  /**\n   * Set custom duration for session timer\n   * @param {number} sessionDuration - Session timer duration in milliseconds\n   */\n  setTimerDuration(sessionDuration) {\n    if (sessionDuration && typeof sessionDuration === \"number\") {\n      this.sessionTimerDuration = sessionDuration;\n    }\n  }\n}\n","/**\n * @file sessionManager.js\n * @description 后台脚本的会话管理模块，负责验证会话的启动、失败、提交与取消，以及计时器与并发控制。\n *\n * ## 主要功能\n * - **startVerification**: 启动验证流程——拉取 provider 数据、创建 provider 登录页新标签页、初始化会话状态与弹窗/Provider 数据消息。\n * - **failSession**: 将会话标记为失败——清计时器、设 aborted、更新状态为 PROOF_GENERATION_FAILED，并通知 content/original tab 与 runtime。\n * - **submitProofs**: 提交已生成的证明——校验证明完整性、按需提交到 callbackUrl 或仅更新状态，通知各端并释放会话。\n * - **cancelSession**: 用户取消会话——与 fail 类似但带「Cancelled by user」语义，关闭验证页、恢复原标签页并清理会话数据。\n *\n * ## 核心逻辑与流程\n * 1. **启动**: 清空 ctx 成员与计时器 → fetchProviderData → chrome.tabs.create(providerUrl) → 写入 initPopupMessage/providerDataMessage → updateSessionStatus(USER_STARTED_VERIFICATION)。\n * 2. **失败/取消**: clearAllTimers → ctx.aborted = true → updateSessionStatus(PROOF_GENERATION_FAILED) → 向 activeTabId/originalTabId/runtime 发送 PROOF_GENERATION_FAILED → 清队列并置 activeSessionId = null。\n * 3. **提交**: 若 expectManyClaims 则直接返回；否则 clearAllTimers → 检查 generatedProofs 与 requestData 完整性 → formatProof → 有 callbackUrl 则 submitProofOnCallback，否则仅 updateSessionStatus(PROOF_GENERATION_SUCCESS) → 向各端发送 PROOF_SUBMITTED → 可选切回原标签页 → activeSessionId = null。\n *\n * ## 依赖与约定\n * - 依赖 ctx 上的 bgLogger、sessionTimerManager、fetchProviderData、updateSessionStatus、submitProofOnCallback、formatProof、MESSAGE_ACTIONS、MESSAGE_SOURCES、RECLAIM_SESSION_STATUS 等。\n * - 通过 ctx.activeSessionId 做并发守卫；通过 ctx.aborted 控制队列/offscreen 停止处理。\n * @module background/sessionManager\n */\n\nimport { LOG_TYPES, EVENT_TYPES, LOG_LEVEL } from \"../utils/logger\";\n\nexport async function startVerification(ctx, templateData) {\n  const bgLogger = ctx.bgLogger;\n  try {\n    // clear all the member variables\n    ctx.providerData = null;\n    ctx.parameters = {};\n    ctx.providerId = null;\n    ctx.appId = null;\n    ctx.sessionId = null;\n    ctx.callbackUrl = null;\n    ctx.generatedProofs = new Map();\n    ctx.filteredRequests = new Map();\n    ctx.initPopupMessage = new Map();\n    ctx.providerDataMessage = new Map();\n    ctx.providerRequestsByHash = new Map();\n    ctx.aborted = false;\n\n    // Reset timers and timer state variables\n    ctx.sessionTimerManager.clearAllTimers();\n    ctx.firstRequestReceived = false;\n\n    // fetch provider data\n    if (!templateData.providerId) {\n      throw new Error(\"Provider ID not found\");\n    }\n    bgLogger.setContext({\n      type: LOG_TYPES.BACKGROUND,\n      sessionId: templateData.sessionId || ctx.sessionId || \"unknown\",\n      providerId: templateData.providerId || ctx.providerId || \"unknown\",\n      appId: templateData.applicationId || ctx.appId || \"unknown\",\n    });\n    // fetch provider data from the backend\n    bgLogger.info({\n      message: `[BACKGROUND] Fetching provider data from the backend for provider Id ${templateData.providerId}`,\n      logLevel: LOG_LEVEL.INFO,\n      type: LOG_TYPES.BACKGROUND,\n    });\n\n    const providerData = await ctx.fetchProviderData(\n      templateData.providerId,\n      templateData.sessionId,\n      templateData.applicationId,\n    );\n\n    ctx.providerData = providerData;\n\n    ctx.providerId = templateData.providerId;\n    if (templateData.parameters) {\n      ctx.parameters = templateData.parameters;\n    }\n\n    // callbackUrl optional\n    if (typeof templateData.callbackUrl === \"string\") {\n      ctx.callbackUrl = templateData.callbackUrl;\n    }\n\n    if (templateData.sessionId) {\n      ctx.sessionId = templateData.sessionId;\n    }\n\n    if (templateData.applicationId) {\n      ctx.appId = templateData.applicationId;\n    }\n\n    if (!providerData) {\n      throw new Error(\"Provider data not found\");\n    }\n\n    // Create a new tab with provider URL DIRECTLY - not through an async flow\n    const providerUrl = providerData.loginUrl;\n\n    // Use chrome.tabs.create directly and handle the promise explicitly\n    chrome.tabs.create({ url: providerUrl }, (tab) => {\n      ctx.activeTabId = tab.id;\n      bgLogger.info({\n        message: `[BACKGROUND] New tab created for provider ${templateData.providerId} with tab id ${tab.id}`,\n        logLevel: LOG_LEVEL.INFO,\n        type: LOG_TYPES.BACKGROUND,\n      });\n\n      ctx.managedTabs.add(tab.id);\n\n      const providerName = ctx.providerData?.name || \"Default Provider\";\n      const description = ctx.providerData?.description || \"Default Description\";\n      const dataRequired = ctx.providerData?.verificationConfig?.dataRequired || \"Default Data\";\n      const sessionId = ctx.sessionId || \"unknown\";\n\n      if (tab.id) {\n        const popupMessage = {\n          action: ctx.MESSAGE_ACTIONS.SHOW_PROVIDER_VERIFICATION_POPUP,\n          source: ctx.MESSAGE_SOURCES.BACKGROUND,\n          target: ctx.MESSAGE_SOURCES.CONTENT_SCRIPT,\n          data: {\n            providerName,\n            description,\n            dataRequired,\n            sessionId,\n          },\n        };\n\n        const providerDataMessage = {\n          action: ctx.MESSAGE_ACTIONS.PROVIDER_DATA_READY,\n          source: ctx.MESSAGE_SOURCES.BACKGROUND,\n          target: ctx.MESSAGE_SOURCES.CONTENT_SCRIPT,\n          data: {\n            providerData: ctx.providerData,\n            parameters: ctx.parameters,\n            sessionId: ctx.sessionId,\n            callbackUrl: ctx.callbackUrl,\n            providerId: ctx.providerId,\n            appId: ctx.appId,\n          },\n        };\n\n        // Initialize the message map if it doesn't exist\n        if (!ctx.initPopupMessage) {\n          ctx.initPopupMessage = new Map();\n        }\n\n        // Store the message in the init PopupMessage for the tab\n        ctx.initPopupMessage.set(tab.id, { message: popupMessage });\n\n        // Store the provider data in the providerDataMap for the tab\n        ctx.providerDataMessage.set(tab.id, { message: providerDataMessage });\n      } else {\n        bgLogger.error({\n          message: `[BACKGROUND] New tab does not have an ID, cannot queue message for popup.`,\n          logLevel: LOG_LEVEL.INFO,\n          type: LOG_TYPES.BACKGROUND,\n        });\n      }\n\n      bgLogger.info({\n        message: `[BACKGROUND] Starting verification with session id: ${ctx.sessionId}`,\n        logLevel: LOG_LEVEL.INFO,\n        type: LOG_TYPES.BACKGROUND,\n      });\n\n      // Update session status after tab creation\n      ctx\n        .updateSessionStatus(\n          templateData.sessionId,\n          ctx.RECLAIM_SESSION_STATUS.USER_STARTED_VERIFICATION,\n          templateData.providerId,\n          templateData.applicationId,\n        )\n        .catch((error) => {\n          bgLogger.error({\n            message: `[BACKGROUND] Error updating session status: ${error?.message}`,\n            logLevel: LOG_LEVEL.INFO,\n            type: LOG_TYPES.BACKGROUND,\n          });\n        });\n    });\n\n    return {\n      success: true,\n      message: \"Verification started, redirecting to provider login page\",\n    };\n  } catch (error) {\n    bgLogger.error({\n      message: `[BACKGROUND] Error starting verification: ${error?.message}`,\n      logLevel: LOG_LEVEL.INFO,\n      type: LOG_TYPES.BACKGROUND,\n    });\n    // Release concurrency guard on immediate failure\n    ctx.activeSessionId = null;\n    throw error;\n  }\n}\n\nexport async function failSession(ctx, errorMessage, requestHash) {\n  const bgLogger = ctx.bgLogger;\n\n  bgLogger.setContext({\n    type: LOG_TYPES.BACKGROUND,\n    sessionId: ctx.sessionId || \"unknown\",\n    providerId: ctx.providerId || \"unknown\",\n    appId: ctx.appId || \"unknown\",\n  });\n\n  bgLogger.log({\n    message: `[BACKGROUND] Failing session: ${errorMessage}`,\n    logLevel: LOG_LEVEL.INFO,\n    type: LOG_TYPES.BACKGROUND,\n    eventType: EVENT_TYPES.VERIFICATION_FLOW_FAILED,\n  });\n\n  // Clear all timers\n  ctx.sessionTimerManager.clearAllTimers();\n\n  // abort immediately to stop queue/offscreen processing\n  ctx.aborted = true;\n\n  // Update session status to failed\n  if (ctx.sessionId) {\n    try {\n      await ctx.updateSessionStatus(\n        ctx.sessionId,\n        ctx.RECLAIM_SESSION_STATUS.PROOF_GENERATION_FAILED,\n        ctx.providerId,\n        ctx.appId,\n      );\n\n      bgLogger.log({\n        message: `[BACKGROUND] Updated session status to failed: ${ctx.sessionId}`,\n        logLevel: LOG_LEVEL.INFO,\n        type: LOG_TYPES.BACKGROUND,\n      });\n    } catch (error) {\n      bgLogger.error({\n        message: `[BACKGROUND] Error updating session status to failed: ${error?.message}`,\n        logLevel: LOG_LEVEL.INFO,\n        type: LOG_TYPES.BACKGROUND,\n      });\n    }\n  }\n\n  // Notify content script about failure (active tab)\n  if (ctx.activeTabId) {\n    chrome.tabs\n      .sendMessage(ctx.activeTabId, {\n        action: ctx.MESSAGE_ACTIONS.PROOF_GENERATION_FAILED,\n        source: ctx.MESSAGE_SOURCES.BACKGROUND,\n        target: ctx.MESSAGE_SOURCES.CONTENT_SCRIPT,\n        data: { requestHash: requestHash, sessionId: ctx.sessionId },\n      })\n      .catch((err) => {\n        bgLogger.error({\n          message: `[BACKGROUND] Error notifying content script of session failure: ${err?.message}`,\n          logLevel: LOG_LEVEL.INFO,\n          type: LOG_TYPES.BACKGROUND,\n        });\n      });\n  }\n\n  // Also forward to the original tab\n  if (ctx.originalTabId) {\n    try {\n      await chrome.tabs.sendMessage(ctx.originalTabId, {\n        action: ctx.MESSAGE_ACTIONS.PROOF_GENERATION_FAILED,\n        source: ctx.MESSAGE_SOURCES.BACKGROUND,\n        target: ctx.MESSAGE_SOURCES.CONTENT_SCRIPT,\n        data: { error: errorMessage, sessionId: ctx.sessionId },\n      });\n    } catch (e) {\n      bgLogger.error({\n        message: `[BACKGROUND] Error notifying original tab of session failure: ${e?.message}`,\n        logLevel: LOG_LEVEL.INFO,\n        type: LOG_TYPES.BACKGROUND,\n      });\n    }\n  }\n\n  // Broadcast to popup/options pages\n  try {\n    bgLogger.info({\n      message: `[BACKGROUND] Proof generation failed, Broadcasting to popup/options pages: ${errorMessage}`,\n      logLevel: LOG_LEVEL.INFO,\n      type: LOG_TYPES.BACKGROUND,\n    });\n\n    await chrome.runtime.sendMessage({\n      action: ctx.MESSAGE_ACTIONS.PROOF_GENERATION_FAILED,\n      data: { error: errorMessage, sessionId: ctx.sessionId },\n    });\n  } catch (e) {\n    bgLogger.error({\n      message: `[BACKGROUND] Error broadcasting to popup/options pages: ${e?.message}`,\n      logLevel: LOG_LEVEL.INFO,\n      type: LOG_TYPES.BACKGROUND,\n    });\n  }\n\n  // Clear the queue\n  ctx.proofGenerationQueue = [];\n  ctx.isProcessingQueue = false;\n\n  // Release concurrency guard\n  ctx.activeSessionId = null;\n}\n\nexport async function submitProofs(ctx) {\n  const bgLogger = ctx.bgLogger;\n  try {\n    // Hold if user set canExpectManyClaims(true)\n    if (ctx.expectManyClaims) return;\n\n    ctx.sessionTimerManager.clearAllTimers();\n\n    bgLogger.setContext({\n      type: LOG_TYPES.BACKGROUND,\n      sessionId: ctx.sessionId || \"unknown\",\n      providerId: ctx.providerId || \"unknown\",\n      appId: ctx.appId || \"unknown\",\n    });\n\n    if (ctx.generatedProofs.size === 0) return;\n\n    const hasTemplateList =\n      Array.isArray(ctx.providerData?.requestData) && ctx.providerData.requestData.length > 0;\n\n    if (hasTemplateList) {\n      const completedTemplate = ctx.providerData.requestData.filter((rd) =>\n        ctx.generatedProofs.has(rd.requestHash),\n      ).length;\n      if (completedTemplate !== ctx.providerData.requestData.length) return;\n    }\n\n    const formattedProofs = [];\n    const templateHashes = new Set();\n\n    if (hasTemplateList) {\n      for (const rd of ctx.providerData.requestData) {\n        if (ctx.generatedProofs.has(rd.requestHash)) {\n          const proof = ctx.generatedProofs.get(rd.requestHash);\n          formattedProofs.push(ctx.formatProof(proof, rd));\n          templateHashes.add(rd.requestHash);\n        }\n      }\n    }\n\n    for (const [hash, proof] of ctx.generatedProofs.entries()) {\n      if (templateHashes.has(hash)) continue;\n      const providerRequest = ctx.providerRequestsByHash.get(hash) || {\n        url: \"\",\n        expectedPageUrl: \"\",\n        urlType: \"EXACT\",\n        method: \"GET\",\n        responseMatches: [],\n        responseRedactions: [],\n        requestHash: hash,\n      };\n      formattedProofs.push(ctx.formatProof(proof, providerRequest));\n    }\n\n    const finalProofs = formattedProofs.map((fp) => ({\n      ...fp,\n      publicData: ctx.publicData ?? null,\n    }));\n\n    bgLogger.info({\n      message: `[BACKGROUND] Submitting proofs ${JSON.stringify(finalProofs)}`,\n      logLevel: LOG_LEVEL.INFO,\n      type: LOG_TYPES.BACKGROUND,\n      eventType: EVENT_TYPES.SUBMITTING_PROOF,\n    });\n\n    let submitted = false;\n    // If callbackUrl provided, submit; otherwise just signal completion\n    if (ctx.callbackUrl && typeof ctx.callbackUrl === \"string\" && ctx.callbackUrl.length > 0) {\n      try {\n        bgLogger.log({\n          message: `[BACKGROUND] Submitting proofs to callback URL: ${ctx.callbackUrl}`,\n          logLevel: LOG_LEVEL.INFO,\n          type: LOG_TYPES.BACKGROUND,\n          eventType: EVENT_TYPES.SUBMITTING_PROOF_TO_CALLBACK_URL,\n        });\n        await ctx.submitProofOnCallback(\n          finalProofs,\n          ctx.callbackUrl,\n          ctx.sessionId,\n          ctx.providerId,\n          ctx.appId,\n        );\n        submitted = true;\n      } catch (error) {\n        // Notify original tab\n        try {\n          bgLogger.error({\n            message: `[BACKGROUND] Notifying original tab of proof submission failure: ${error.message}`,\n            logLevel: LOG_LEVEL.INFO,\n            type: LOG_TYPES.BACKGROUND,\n            eventType: EVENT_TYPES.SUBMITTING_PROOF_TO_CALLBACK_URL_FAILED,\n          });\n          await chrome.tabs.sendMessage(ctx.originalTabId, {\n            action: ctx.MESSAGE_ACTIONS.PROOF_SUBMISSION_FAILED,\n            source: ctx.MESSAGE_SOURCES.BACKGROUND,\n            target: ctx.MESSAGE_SOURCES.CONTENT_SCRIPT,\n            data: { error: error.message, sessionId: ctx.sessionId },\n          });\n        } catch (e) {\n          bgLogger.error({\n            message: `[BACKGROUND] Error notifying original tab of proof submission failure: ${e?.message}`,\n            logLevel: LOG_LEVEL.INFO,\n            type: LOG_TYPES.BACKGROUND,\n            eventType: EVENT_TYPES.SUBMITTING_PROOF_TO_CALLBACK_URL_FAILED,\n          });\n        }\n\n        chrome.tabs.sendMessage(ctx.activeTabId, {\n          action: ctx.MESSAGE_ACTIONS.PROOF_SUBMISSION_FAILED,\n          source: ctx.MESSAGE_SOURCES.BACKGROUND,\n          target: ctx.MESSAGE_SOURCES.CONTENT_SCRIPT,\n          data: { error: error.message, sessionId: ctx.sessionId },\n        });\n\n        bgLogger.error({\n          message: `[BACKGROUND] Broadcasting to runtime of proof submission failure: ${error.message}`,\n          logLevel: LOG_LEVEL.INFO,\n          type: LOG_TYPES.BACKGROUND,\n          eventType: EVENT_TYPES.PROOF_SUBMISSION_FAILED,\n        });\n        // Broadcast to runtime\n        try {\n          await chrome.runtime.sendMessage({\n            action: ctx.MESSAGE_ACTIONS.PROOF_SUBMISSION_FAILED,\n            data: { error: error.message, sessionId: ctx.sessionId },\n          });\n        } catch (e) {}\n\n        bgLogger.error({\n          message: `[BACKGROUND] Error submitting proofs: ${error.message}`,\n          logLevel: LOG_LEVEL.INFO,\n          type: LOG_TYPES.BACKGROUND,\n        });\n        throw error;\n      }\n    } else {\n      // No callback: set status to generation success\n      if (ctx.sessionId) {\n        try {\n          bgLogger.log({\n            message: `[BACKGROUND] Updating status to PROOF_GENERATION_SUCCESS`,\n            logLevel: LOG_LEVEL.INFO,\n            type: LOG_TYPES.BACKGROUND,\n            eventType: EVENT_TYPES.PROOF_SUBMITTED,\n          });\n          await ctx.updateSessionStatus(\n            ctx.sessionId,\n            ctx.RECLAIM_SESSION_STATUS.PROOF_GENERATION_SUCCESS,\n            ctx.providerId,\n            ctx.appId,\n          );\n        } catch (e) {\n          bgLogger.error({\n            message: `[BACKGROUND] Error updating status to PROOF_GENERATION_SUCCESS: ${e?.message}`,\n            logLevel: LOG_LEVEL.INFO,\n            type: LOG_TYPES.BACKGROUND,\n          });\n        }\n      }\n    }\n\n    // Notify content script with proofs in both cases\n    if (ctx.activeTabId) {\n      try {\n        bgLogger.log({\n          message: `[BACKGROUND] Proof submitted, Notifying content script with proofs`,\n          logLevel: LOG_LEVEL.INFO,\n          type: LOG_TYPES.BACKGROUND,\n        });\n        await chrome.tabs.sendMessage(ctx.activeTabId, {\n          action: ctx.MESSAGE_ACTIONS.PROOF_SUBMITTED,\n          source: ctx.MESSAGE_SOURCES.BACKGROUND,\n          target: ctx.MESSAGE_SOURCES.CONTENT_SCRIPT,\n          data: { formattedProofs, submitted, sessionId: ctx.sessionId },\n        });\n      } catch (error) {\n        bgLogger.error({\n          message: `[BACKGROUND] Error notifying content script: ${error?.message}`,\n          logLevel: LOG_LEVEL.INFO,\n          type: LOG_TYPES.BACKGROUND,\n        });\n      }\n    }\n\n    if (ctx.originalTabId) {\n      try {\n        bgLogger.log({\n          message: `[BACKGROUND] Proof submitted, Notifying original tab with proofs`,\n          logLevel: LOG_LEVEL.INFO,\n          type: LOG_TYPES.BACKGROUND,\n        });\n\n        await chrome.tabs.sendMessage(ctx.originalTabId, {\n          action: ctx.MESSAGE_ACTIONS.PROOF_SUBMITTED,\n          source: ctx.MESSAGE_SOURCES.BACKGROUND,\n          target: ctx.MESSAGE_SOURCES.CONTENT_SCRIPT,\n          data: { formattedProofs, submitted, sessionId: ctx.sessionId },\n        });\n      } catch (e) {\n        bgLogger.error({\n          message: `[BACKGROUND] Error notifying original tab: ${e?.message}`,\n          logLevel: LOG_LEVEL.INFO,\n          type: LOG_TYPES.BACKGROUND,\n        });\n      }\n    }\n\n    // Broadcast to runtime (popup/options)\n    try {\n      bgLogger.log({\n        message: `[BACKGROUND] Proof submitted, Broadcasting to runtime`,\n        logLevel: LOG_LEVEL.INFO,\n        type: LOG_TYPES.BACKGROUND,\n      });\n      await chrome.runtime.sendMessage({\n        action: ctx.MESSAGE_ACTIONS.PROOF_SUBMITTED,\n        data: { formattedProofs, submitted, sessionId: ctx.sessionId },\n      });\n    } catch (e) {}\n\n    if (ctx.originalTabId) {\n      try {\n        setTimeout(async () => {\n          await chrome.tabs.update(ctx.originalTabId, { active: true });\n          if (ctx.activeTabId) {\n            // 注释：验证完成后不再关闭目标（验证）页面\n            // await chrome.tabs.remove(ctx.activeTabId);\n            ctx.activeTabId = null;\n          }\n          ctx.originalTabId = null;\n        }, 3000);\n      } catch (error) {\n        bgLogger.error({\n          message: `[BACKGROUND] Error navigating back or closing tab: ${error?.message}`,\n          logLevel: LOG_LEVEL.INFO,\n          type: LOG_TYPES.BACKGROUND,\n        });\n      }\n    } else if (ctx.activeTabId) {\n      // Fallback: started from panel/popup, no original tab to return to\n      try {\n        setTimeout(async () => {\n          // 注释：验证完成后不再关闭目标（验证）页面\n          // await chrome.tabs.remove(ctx.activeTabId);\n          ctx.activeTabId = null;\n        }, 3000);\n      } catch (e) {\n        /* ignore */\n      }\n    }\n    // Release concurrency guard on success\n    ctx.activeSessionId = null;\n    return { success: true };\n  } catch (error) {\n    bgLogger.error({\n      message: `[BACKGROUND] Error submitting proof: ${error?.message}`,\n      logLevel: LOG_LEVEL.INFO,\n      type: LOG_TYPES.BACKGROUND,\n      eventType: EVENT_TYPES.PROOF_SUBMISSION_FAILED,\n    });\n    // Release concurrency guard on failure\n    ctx.activeSessionId = null;\n    throw error;\n  }\n}\n\nexport async function cancelSession(ctx) {\n  const bgLogger = ctx.bgLogger;\n  try {\n    bgLogger.setContext({\n      type: LOG_TYPES.BACKGROUND,\n      sessionId: ctx.sessionId || \"unknown\",\n      providerId: ctx.providerId || \"unknown\",\n      appId: ctx.appId || \"unknown\",\n    });\n    bgLogger.log({\n      message: `[BACKGROUND] Cancelling session`,\n      logLevel: LOG_LEVEL.INFO,\n      type: LOG_TYPES.BACKGROUND,\n      eventType: EVENT_TYPES.RECLAIM_VERIFICATION_DISMISSED,\n    });\n\n    ctx.sessionTimerManager.clearAllTimers();\n\n    // abort immediately to stop queue/offscreen processing\n    ctx.aborted = true;\n\n    // Update status as failed due to cancellation (no explicit CANCELLED status available)\n    if (ctx.sessionId) {\n      try {\n        bgLogger.log({\n          message: `[BACKGROUND] Proof generation failed, Updating status on cancel`,\n          logLevel: LOG_LEVEL.INFO,\n          type: LOG_TYPES.BACKGROUND,\n        });\n        await ctx.updateSessionStatus(\n          ctx.sessionId,\n          ctx.RECLAIM_SESSION_STATUS.PROOF_GENERATION_FAILED,\n          ctx.providerId,\n          ctx.appId,\n        );\n      } catch (error) {\n        bgLogger.error({\n          message: `[BACKGROUND] Error updating status on cancel: ${error?.message}`,\n          logLevel: LOG_LEVEL.INFO,\n          type: LOG_TYPES.BACKGROUND,\n        });\n      }\n    }\n\n    // Notify content about failure with error message 'Cancelled by user'\n    if (ctx.activeTabId) {\n      try {\n        bgLogger.log({\n          message: `[BACKGROUND] Proof generation failed, Notifying content on cancel`,\n          logLevel: LOG_LEVEL.INFO,\n          type: LOG_TYPES.BACKGROUND,\n        });\n        await chrome.tabs.sendMessage(ctx.activeTabId, {\n          action: ctx.MESSAGE_ACTIONS.PROOF_GENERATION_FAILED,\n          source: ctx.MESSAGE_SOURCES.BACKGROUND,\n          target: ctx.MESSAGE_SOURCES.CONTENT_SCRIPT,\n          data: { error: \"Cancelled by user\", sessionId: ctx.sessionId },\n        });\n      } catch (e) {\n        bgLogger.error({\n          message: `[BACKGROUND] Error notifying content on cancel: ${e?.message}`,\n          logLevel: LOG_LEVEL.INFO,\n          type: LOG_TYPES.BACKGROUND,\n        });\n      }\n    }\n\n    // Also forward to the original tab\n    if (ctx.originalTabId) {\n      try {\n        bgLogger.log({\n          message: `[BACKGROUND] Proof generation failed, Notifying original tab on cancel`,\n          logLevel: LOG_LEVEL.INFO,\n          type: LOG_TYPES.BACKGROUND,\n        });\n        await chrome.tabs.sendMessage(ctx.originalTabId, {\n          action: ctx.MESSAGE_ACTIONS.PROOF_GENERATION_FAILED,\n          source: ctx.MESSAGE_SOURCES.BACKGROUND,\n          target: ctx.MESSAGE_SOURCES.CONTENT_SCRIPT,\n          data: { error: \"Cancelled by user\", sessionId: ctx.sessionId },\n        });\n      } catch (e) {\n        /* ignore */\n        bgLogger.error({\n          message: `[BACKGROUND] Error notifying original tab on cancel: ${e?.message}`,\n          logLevel: LOG_LEVEL.INFO,\n          type: LOG_TYPES.BACKGROUND,\n        });\n      }\n    }\n\n    // Broadcast to runtime\n    try {\n      bgLogger.log({\n        message: `[BACKGROUND] Proof generation failed, Broadcasting to runtime on cancel`,\n        logLevel: LOG_LEVEL.INFO,\n        type: LOG_TYPES.BACKGROUND,\n      });\n      await chrome.runtime.sendMessage({\n        action: ctx.MESSAGE_ACTIONS.PROOF_GENERATION_FAILED,\n        data: { error: \"Cancelled by user\", sessionId: ctx.sessionId },\n      });\n    } catch (e) {\n      bgLogger.error({\n        message: `[BACKGROUND] Error broadcasting to runtime on cancel: ${e?.message}`,\n        logLevel: LOG_LEVEL.INFO,\n        type: LOG_TYPES.BACKGROUND,\n      });\n    }\n\n    // Close managed tab and restore original if available\n    if (ctx.originalTabId) {\n      try {\n        setTimeout(async () => {\n          await chrome.tabs.update(ctx.originalTabId, { active: true });\n          if (ctx.activeTabId) {\n            await chrome.tabs.remove(ctx.activeTabId);\n            ctx.activeTabId = null;\n          }\n          ctx.originalTabId = null;\n        }, 200);\n      } catch (error) {\n        bgLogger.error({\n          message: `[BACKGROUND] Error closing tab on cancel: ${error?.message}`,\n          logLevel: LOG_LEVEL.INFO,\n          type: LOG_TYPES.BACKGROUND,\n        });\n      }\n    } else if (ctx.activeTabId) {\n      try {\n        await chrome.tabs.remove(ctx.activeTabId);\n        ctx.activeTabId = null;\n      } catch (e) {\n        bgLogger.error({\n          message: `[BACKGROUND] Error closing active tab on cancel: ${e?.message}`,\n          logLevel: LOG_LEVEL.INFO,\n          type: LOG_TYPES.BACKGROUND,\n        });\n      }\n    }\n\n    // Clear queues and session data\n    ctx.proofGenerationQueue = [];\n    ctx.isProcessingQueue = false;\n    ctx.providerData = null;\n    ctx.parameters = {};\n    ctx.providerId = null;\n    ctx.appId = null;\n    ctx.sessionId = null;\n    ctx.callbackUrl = null;\n    ctx.providerRequestsByHash = new Map();\n    ctx.managedTabs.clear();\n\n    // Release guard\n    ctx.activeSessionId = null;\n  } catch (e) {\n    ctx.activeSessionId = null;\n    bgLogger.error({\n      message: `[BACKGROUND] Error during cancelSession: ${e?.message}`,\n      logLevel: LOG_LEVEL.INFO,\n      type: LOG_TYPES.BACKGROUND,\n    });\n  }\n}\n","/**\n * @file messageRouter.js\n * @description 后台脚本消息路由器。监听 chrome.runtime.onMessage，按 action 路由到对应逻辑。\n *\n * 主要 action 与流程：\n * - 会话/Tab：CONTENT_SCRIPT_LOADED（下发 SHOULD_INITIALIZE、补发缓存消息）、CHECK_IF_MANAGED_TAB、\n *   REQUEST_PROVIDER_DATA、CLOSE_CURRENT_TAB、GET_CURRENT_TAB_ID\n * - 验证：START_VERIFICATION（并发校验 + sessionManager.startVerification）、CANCEL_VERIFICATION、REPORT_PROVIDER_ERROR\n * - 请求/证明：FILTERED_REQUEST_FOUND（缓存或 processFilteredRequest）、REQUEST_CLAIM\n * - 状态更新：UPDATE_PUBLIC_DATA、UPDATE_EXPECT_MANY_CLAIMS、GET_PARAMETERS（均需受管 tab）\n * - 注入：INJECT_VIA_SCRIPTING（REPLAY_PAGE_FETCH / RUN_CUSTOM_INJECTION）\n * - 其他：OFFSCREEN_DOCUMENT_READY、default（Action not supported）\n * 约定：通过 sendResponse 回传；return true 支持异步；异常时 sendResponse({ success: false, error })。\n */\n\nimport { LOG_TYPES, LOG_LEVEL, EVENT_TYPES } from \"../utils/logger\";\nimport * as sessionManager from \"./sessionManager\";\n\n/**\n * 处理扩展运行时消息，按 action 分发并回传结果。\n * @param {Object} ctx - 后台上下文（bgLogger、managedTabs、providerData、sessionId 等）\n * @param {Object} message - 消息体，含 action、source、target、data\n * @param {chrome.runtime.MessageSender} sender - 发送方（如 tab、extension）\n * @param {function(Object): void} sendResponse - 回调，用于返回 { success, data?, result?, error? }\n * @returns {Promise<boolean>} 恒为 true，表示响应将异步通过 sendResponse 返回\n */\nexport async function handleMessage(ctx, message, sender, sendResponse) {\n  const { action, source, target, data } = message;\n  const bgLogger = ctx.bgLogger;\n  bgLogger.setContext({\n    type: LOG_TYPES.BACKGROUND,\n    sessionId: ctx.sessionId || \"unknown\",\n    providerId: ctx.providerId || \"unknown\",\n    appId: ctx.appId || \"unknown\",\n  });\n  try {\n    switch (action) {\n      case ctx.MESSAGE_ACTIONS.CONTENT_SCRIPT_LOADED:\n        if (\n          source === ctx.MESSAGE_SOURCES.CONTENT_SCRIPT &&\n          target === ctx.MESSAGE_SOURCES.BACKGROUND\n        ) {\n          const isManaged = sender.tab?.id && ctx.managedTabs.has(sender.tab.id);\n          chrome.tabs\n            .sendMessage(sender.tab.id, {\n              action: ctx.MESSAGE_ACTIONS.SHOULD_INITIALIZE,\n              source: ctx.MESSAGE_SOURCES.BACKGROUND,\n              target: ctx.MESSAGE_SOURCES.CONTENT_SCRIPT,\n              data: { shouldInitialize: isManaged },\n            })\n            .catch((err) =>\n              bgLogger.error({\n                message: \"[BACKGROUND] Error sending initialization status: \" + err?.message,\n                logLevel: LOG_LEVEL.INFO,\n                type: LOG_TYPES.BACKGROUND,\n              }),\n            );\n\n          if (isManaged && ctx.initPopupMessage && ctx.initPopupMessage.has(sender.tab.id)) {\n            const pendingMessage = ctx.initPopupMessage.get(sender.tab.id);\n            chrome.tabs\n              .sendMessage(sender.tab.id, pendingMessage.message)\n              .then(() => {\n                if (chrome.runtime.lastError) {\n                  bgLogger.error({\n                    message: `[BACKGROUND] Error sending (pending) SHOW_PROVIDER_VERIFICATION_POPUP to tab ${sender.tab.id}: ${chrome.runtime.lastError.message}`,\n                    logLevel: LOG_LEVEL.INFO,\n                    type: LOG_TYPES.BACKGROUND,\n                    eventType: EVENT_TYPES.VERIFICATION_POPUP_ERROR,\n                  });\n                }\n              })\n              .catch((error) =>\n                bgLogger.error({\n                  message: `[BACKGROUND] Error sending (pending) SHOW_PROVIDER_VERIFICATION_POPUP to tab ${sender.tab.id} (promise catch): ${error?.message}`,\n                  logLevel: LOG_LEVEL.INFO,\n                  type: LOG_TYPES.BACKGROUND,\n                  eventType: EVENT_TYPES.VERIFICATION_POPUP_ERROR,\n                }),\n              );\n          }\n\n          if (isManaged && ctx.providerDataMessage && ctx.providerDataMessage.has(sender.tab.id)) {\n            const pendingMessage = ctx.providerDataMessage.get(sender.tab.id);\n            chrome.tabs\n              .sendMessage(sender.tab.id, pendingMessage.message)\n              .then(() => {\n                if (chrome.runtime.lastError) {\n                  bgLogger.error({\n                    message: `[BACKGROUND] Error sending (pending) PROVIDER_DATA_READY to tab ${sender.tab.id}: ${chrome.runtime.lastError.message}`,\n                    logLevel: LOG_LEVEL.INFO,\n                    type: LOG_TYPES.BACKGROUND,\n                    eventType: EVENT_TYPES.RECLAIM_VERIFICATION_PROVIDER_LOAD_EXCEPTION,\n                  });\n                }\n              })\n              .catch((error) =>\n                bgLogger.error({\n                  message: `[BACKGROUND] Error sending (pending) PROVIDER_DATA_READY to tab ${sender.tab.id} (promise catch): ${error?.message}`,\n                  logLevel: LOG_LEVEL.INFO,\n                  type: LOG_TYPES.BACKGROUND,\n                  eventType: EVENT_TYPES.RECLAIM_VERIFICATION_PROVIDER_LOAD_EXCEPTION,\n                }),\n              );\n            ctx.providerDataMessage.delete(sender.tab.id);\n          }\n\n          bgLogger.info({\n            message: `[BACKGROUND] Successfully sent (pending) SHOW_PROVIDER_VERIFICATION_POPUP and PROVIDER_DATA_READY to tab ${sender.tab.id}`,\n            logLevel: LOG_LEVEL.INFO,\n            type: LOG_TYPES.BACKGROUND,\n          });\n          sendResponse({ success: true });\n          break;\n        }\n        break;\n      case ctx.MESSAGE_ACTIONS.REQUEST_PROVIDER_DATA:\n        if (\n          source === ctx.MESSAGE_SOURCES.CONTENT_SCRIPT &&\n          target === ctx.MESSAGE_SOURCES.BACKGROUND\n        ) {\n          bgLogger.setContext({\n            sessionId: ctx.sessionId || \"unknown\",\n            providerId: ctx.providerId || \"unknown\",\n            appId: ctx.appId || \"unknown\",\n            type: LOG_TYPES.BACKGROUND,\n          });\n          bgLogger.info({\n            message: \"[BACKGROUND] Content script requested provider data\",\n            logLevel: LOG_LEVEL.INFO,\n            type: LOG_TYPES.BACKGROUND,\n          });\n\n          if (\n            sender.tab?.id &&\n            ctx.managedTabs.has(sender.tab.id) &&\n            ctx.providerData &&\n            ctx.parameters &&\n            ctx.sessionId &&\n            ctx.callbackUrl !== undefined // allow empty string as optional\n          ) {\n            bgLogger.info({\n              message:\n                \"[BACKGROUND] Sending the following provider data to content script: \" +\n                JSON.stringify(ctx.providerData),\n              logLevel: LOG_LEVEL.INFO,\n              type: LOG_TYPES.BACKGROUND,\n            });\n\n            sendResponse({\n              success: true,\n              data: {\n                providerData: ctx.providerData,\n                parameters: ctx.parameters || {},\n                sessionId: ctx.sessionId,\n                callbackUrl: ctx.callbackUrl,\n                providerId: ctx.providerId,\n                appId: ctx.appId,\n              },\n            });\n          } else {\n            bgLogger.error({\n              message: \"[BACKGROUND] Provider data not available or tab not managed\",\n              logLevel: LOG_LEVEL.INFO,\n              type: LOG_TYPES.BACKGROUND,\n            });\n            sendResponse({\n              success: false,\n              error: \"Provider data not available or tab not managed\",\n            });\n          }\n        }\n        break;\n      case ctx.MESSAGE_ACTIONS.CHECK_IF_MANAGED_TAB:\n        if (\n          source === ctx.MESSAGE_SOURCES.CONTENT_SCRIPT &&\n          target === ctx.MESSAGE_SOURCES.BACKGROUND\n        ) {\n          const isManaged = sender.tab?.id && ctx.managedTabs.has(sender.tab.id);\n          bgLogger.info({\n            message: \"[BACKGROUND] Checking if tab is managed: \" + isManaged,\n            logLevel: LOG_LEVEL.INFO,\n            type: LOG_TYPES.BACKGROUND,\n          });\n          sendResponse({ success: true, isManaged });\n        }\n        break;\n      case ctx.MESSAGE_ACTIONS.START_VERIFICATION:\n        if (\n          source === ctx.MESSAGE_SOURCES.CONTENT_SCRIPT &&\n          target === ctx.MESSAGE_SOURCES.BACKGROUND\n        ) {\n          bgLogger.setContext({\n            sessionId: data.sessionId || ctx.sessionId || \"unknown\",\n            providerId: data.providerId || ctx.providerId || \"unknown\",\n            appId: data.applicationId || ctx.appId || \"unknown\",\n            type: LOG_TYPES.BACKGROUND,\n          });\n\n          bgLogger.info({\n            message: \"Starting new verification using Reclaim Extension SDK\",\n            logLevel: LOG_LEVEL.INFO,\n            type: LOG_TYPES.BACKGROUND,\n            eventType: EVENT_TYPES.IS_RECLAIM_EXTENSION_SDK,\n          });\n\n          bgLogger.info({\n            message:\n              \"[BACKGROUND] Starting new verification flow with data: \" + JSON.stringify(data),\n            logLevel: LOG_LEVEL.INFO,\n            type: LOG_TYPES.BACKGROUND,\n            eventType: EVENT_TYPES.VERIFICATION_FLOW_STARTED,\n          });\n\n          ctx.loggerService.startFlushInterval();\n\n          // Concurrency guard\n          if (ctx.activeSessionId && ctx.activeSessionId !== data.sessionId) {\n            // If no managed tabs remain, clear stale guard and continue\n            if (ctx.managedTabs.size === 0) {\n              ctx.activeSessionId = null;\n            } else {\n              bgLogger.error({\n                message: \"[BACKGROUND] Another verification is in progress\",\n                logLevel: LOG_LEVEL.INFO,\n                type: LOG_TYPES.BACKGROUND,\n              });\n              sendResponse({ success: false, error: \"Another verification is in progress\" });\n              break;\n            }\n          }\n          ctx.activeSessionId = data.sessionId || ctx.activeSessionId;\n\n          if (sender.tab && sender.tab.id) {\n            ctx.originalTabId = sender.tab.id;\n          }\n          bgLogger.info({\n            message: \"[BACKGROUND] Starting verification with session id: \" + data.sessionId,\n            logLevel: LOG_LEVEL.INFO,\n            type: LOG_TYPES.BACKGROUND,\n          });\n\n          const result = await sessionManager.startVerification(ctx, data);\n\n          sendResponse({ success: true, result });\n        } else {\n          sendResponse({ success: false, error: \"Action not supported\" });\n        }\n        break;\n      case ctx.MESSAGE_ACTIONS.CANCEL_VERIFICATION:\n        if (\n          source === ctx.MESSAGE_SOURCES.CONTENT_SCRIPT &&\n          target === ctx.MESSAGE_SOURCES.BACKGROUND\n        ) {\n          bgLogger.info({\n            message: \"[BACKGROUND] Cancelling verification with session id: \" + data?.sessionId,\n            logLevel: LOG_LEVEL.INFO,\n            type: LOG_TYPES.BACKGROUND,\n          });\n\n          await sessionManager.cancelSession(ctx, data?.sessionId);\n          sendResponse({ success: true });\n        } else {\n          bgLogger.error({\n            message: \"[BACKGROUND] CANCEL_VERIFICATION: Action not supported\",\n            logLevel: LOG_LEVEL.INFO,\n            type: LOG_TYPES.BACKGROUND,\n          });\n          sendResponse({ success: false, error: \"Action not supported\" });\n        }\n        break;\n      case ctx.MESSAGE_ACTIONS.OFFSCREEN_DOCUMENT_READY:\n        if (source === ctx.MESSAGE_SOURCES.OFFSCREEN && target === ctx.MESSAGE_SOURCES.BACKGROUND) {\n          bgLogger.info({\n            message: \"[BACKGROUND] Offscreen document ready\",\n            logLevel: LOG_LEVEL.INFO,\n            type: LOG_TYPES.BACKGROUND,\n          });\n          sendResponse({ success: true });\n        } else {\n          bgLogger.error({\n            message: \"[BACKGROUND] OFFSCREEN_DOCUMENT_READY: Action not supported\",\n            logLevel: LOG_LEVEL.INFO,\n            type: LOG_TYPES.BACKGROUND,\n          });\n          sendResponse({ success: false, error: \"Action not supported\" });\n        }\n        break;\n      case ctx.MESSAGE_ACTIONS.CLOSE_CURRENT_TAB:\n        if (\n          source === ctx.MESSAGE_SOURCES.CONTENT_SCRIPT &&\n          target === ctx.MESSAGE_SOURCES.BACKGROUND\n        ) {\n          if (sender.tab && sender.tab.id) {\n            chrome.tabs.remove(sender.tab.id, () => {\n              if (chrome.runtime.lastError) {\n                bgLogger.error({\n                  message: \"[BACKGROUND] Error closing tab: \" + chrome.runtime.lastError.message,\n                  logLevel: LOG_LEVEL.INFO,\n                  type: LOG_TYPES.BACKGROUND,\n                });\n                sendResponse({ success: false, error: chrome.runtime.lastError.message });\n              } else {\n                if (ctx.managedTabs.has(sender.tab.id)) {\n                  ctx.managedTabs.delete(sender.tab.id);\n                }\n                bgLogger.info({\n                  message: \"[BACKGROUND] Tab closed\",\n                  logLevel: LOG_LEVEL.INFO,\n                  type: LOG_TYPES.BACKGROUND,\n                });\n                sendResponse({ success: true });\n              }\n            });\n          } else {\n            bgLogger.error({\n              message: \"[BACKGROUND] CLOSE_CURRENT_TAB: No tab ID provided by sender.\",\n              logLevel: LOG_LEVEL.INFO,\n              type: LOG_TYPES.BACKGROUND,\n            });\n            sendResponse({ success: false, error: \"No tab ID found to close.\" });\n          }\n        } else {\n          sendResponse({ success: false, error: \"Action not supported\" });\n        }\n        return true;\n      case ctx.MESSAGE_ACTIONS.FILTERED_REQUEST_FOUND:\n        if (\n          source === ctx.MESSAGE_SOURCES.CONTENT_SCRIPT &&\n          target === ctx.MESSAGE_SOURCES.BACKGROUND\n        ) {\n          if (ctx.filteredRequests.has(data.criteria.requestHash)) {\n            bgLogger.info({\n              message:\n                \"[BACKGROUND] Filtered request found with hash: \" + data.criteria.requestHash,\n              logLevel: LOG_LEVEL.INFO,\n              type: LOG_TYPES.BACKGROUND,\n              eventType: EVENT_TYPES.FILTERED_REQUEST_FOUND,\n            });\n            sendResponse({\n              success: true,\n              result: ctx.filteredRequests.get(data.criteria.requestHash),\n            });\n          } else {\n            ctx.filteredRequests.set(data.criteria.requestHash, data.request);\n            const result = await ctx.processFilteredRequest(\n              data.request,\n              data.criteria,\n              data.sessionId,\n              data.loginUrl,\n            );\n            bgLogger.info({\n              message:\n                \"[BACKGROUND] Filtered request processed with hash: \" + data.criteria.requestHash,\n              logLevel: LOG_LEVEL.INFO,\n              type: LOG_TYPES.BACKGROUND,\n            });\n            sendResponse({ success: true, result });\n          }\n        } else {\n          bgLogger.error({\n            message: \"[BACKGROUND] FILTERED_REQUEST_FOUND: Action not supported\",\n            logLevel: LOG_LEVEL.INFO,\n            type: LOG_TYPES.BACKGROUND,\n          });\n          sendResponse({ success: false, error: \"Action not supported\" });\n        }\n        break;\n      case ctx.MESSAGE_ACTIONS.GET_CURRENT_TAB_ID:\n        if (\n          source === ctx.MESSAGE_SOURCES.CONTENT_SCRIPT &&\n          target === ctx.MESSAGE_SOURCES.BACKGROUND\n        ) {\n          bgLogger.info({\n            message: \"[BACKGROUND] Getting current tab id: \" + sender.tab?.id,\n            logLevel: LOG_LEVEL.INFO,\n            type: LOG_TYPES.BACKGROUND,\n          });\n          sendResponse({ success: true, tabId: sender.tab?.id });\n        } else {\n          bgLogger.error({\n            message: \"[BACKGROUND] GET_CURRENT_TAB_ID: Action not supported\",\n            logLevel: LOG_LEVEL.INFO,\n            type: LOG_TYPES.BACKGROUND,\n          });\n          sendResponse({ success: false, error: \"Action not supported\" });\n        }\n        break;\n      case ctx.MESSAGE_ACTIONS.UPDATE_PUBLIC_DATA:\n        if (sender.tab?.id && ctx.managedTabs.has(sender.tab.id)) {\n          bgLogger.info({\n            message: \"[BACKGROUND] Updating public data: \" + data?.publicData,\n            logLevel: LOG_LEVEL.INFO,\n            type: LOG_TYPES.BACKGROUND,\n          });\n          ctx.publicData = typeof data?.publicData === \"string\" ? data.publicData : null;\n          sendResponse({ success: true });\n        } else {\n          bgLogger.error({\n            message: \"[BACKGROUND] UPDATE_PUBLIC_DATA: Tab is not managed by extension\",\n            logLevel: LOG_LEVEL.INFO,\n            type: LOG_TYPES.BACKGROUND,\n          });\n          sendResponse({ success: false, error: \"Tab is not managed by extension\" });\n        }\n        break;\n      case ctx.MESSAGE_ACTIONS.UPDATE_EXPECT_MANY_CLAIMS: {\n        if (sender.tab?.id && ctx.managedTabs.has(sender.tab.id)) {\n          const turningOff = ctx.expectManyClaims && !data?.expectMany;\n          ctx.expectManyClaims = !!data?.expectMany;\n\n          bgLogger.info({\n            message: \"[BACKGROUND] Updating expect many claims: \" + data?.expectMany,\n            logLevel: LOG_LEVEL.INFO,\n            type: LOG_TYPES.BACKGROUND,\n          });\n\n          // If turning OFF and proofs are already ready, finish now\n          if (turningOff && ctx.generatedProofs.size > 0) {\n            try {\n              bgLogger.info({\n                message: \"[BACKGROUND] Turning off expect many claims, Submitting proofs\",\n                logLevel: LOG_LEVEL.INFO,\n                type: LOG_TYPES.BACKGROUND,\n              });\n              await ctx.submitProofs();\n            } catch {}\n          }\n          sendResponse({ success: true });\n        } else {\n          bgLogger.error({\n            message: \"[BACKGROUND] UPDATE_EXPECT_MANY_CLAIMS: Tab is not managed by extension\",\n            logLevel: LOG_LEVEL.INFO,\n            type: LOG_TYPES.BACKGROUND,\n          });\n          sendResponse({ success: false, error: \"Tab is not managed by extension\" });\n        }\n        break;\n      }\n      case ctx.MESSAGE_ACTIONS.GET_PARAMETERS:\n        if (sender.tab?.id && ctx.managedTabs.has(sender.tab.id)) {\n          bgLogger.info({\n            message: \"[BACKGROUND] Getting parameters: \" + ctx.parameters,\n            logLevel: LOG_LEVEL.INFO,\n            type: LOG_TYPES.BACKGROUND,\n          });\n          sendResponse({ success: true, parameters: ctx.parameters || {} });\n        } else {\n          bgLogger.error({\n            message: \"[BACKGROUND] UPDATE_EXPECT_MANY_CLAIMS: Tab is not managed by extension\",\n            logLevel: LOG_LEVEL.INFO,\n            type: LOG_TYPES.BACKGROUND,\n          });\n          sendResponse({ success: false, error: \"Tab is not managed by extension\" });\n        }\n        break;\n      case ctx.MESSAGE_ACTIONS.REPORT_PROVIDER_ERROR: {\n        if (sender.tab?.id && ctx.managedTabs.has(sender.tab.id)) {\n          ctx.aborted = true;\n          await ctx.failSession(data?.message || \"Provider error\");\n          bgLogger.info({\n            message: \"[BACKGROUND] Provider error reported: \" + data?.message,\n            logLevel: LOG_LEVEL.INFO,\n            type: LOG_TYPES.BACKGROUND,\n          });\n          sendResponse({ success: true });\n        } else {\n          bgLogger.error({\n            message: \"[BACKGROUND] REPORT_PROVIDER_ERROR: Tab is not managed by extension\",\n            logLevel: LOG_LEVEL.INFO,\n            type: LOG_TYPES.BACKGROUND,\n          });\n          sendResponse({ success: false, error: \"Tab is not managed by extension\" });\n        }\n        break;\n      }\n      case ctx.MESSAGE_ACTIONS.REQUEST_CLAIM: {\n        if (\n          source === ctx.MESSAGE_SOURCES.CONTENT_SCRIPT &&\n          target === ctx.MESSAGE_SOURCES.BACKGROUND &&\n          sender.tab?.id &&\n          ctx.managedTabs.has(sender.tab.id)\n        ) {\n          try {\n            const sessId = ctx.sessionId || data.sessionId;\n            if (!sessId) {\n              sendResponse({ success: false, error: \"Session not initialized\" });\n              break;\n            }\n            const result = await ctx.processFilteredRequest(\n              data.request,\n              data.criteria,\n              data.sessionId,\n              data.loginUrl || \"\",\n            );\n\n            bgLogger.info({\n              message: \"[BACKGROUND] Request claim processed: \" + data.requestHash,\n              logLevel: LOG_LEVEL.INFO,\n              type: LOG_TYPES.BACKGROUND,\n            });\n\n            sendResponse({ success: true, result });\n          } catch (e) {\n            bgLogger.error({\n              message: \"[BACKGROUND] Request claim processing failed: \" + e?.message,\n              logLevel: LOG_LEVEL.INFO,\n              type: LOG_TYPES.BACKGROUND,\n            });\n            sendResponse({ success: false, error: e?.message || String(e) });\n          }\n        } else {\n          bgLogger.error({\n            message: \"[BACKGROUND] REQUEST_CLAIM: Tab is not managed by extension\",\n            logLevel: LOG_LEVEL.INFO,\n            type: LOG_TYPES.BACKGROUND,\n          });\n          sendResponse({ success: false, error: \"Tab is not managed by extension\" });\n        }\n        break;\n      }\n      // Add/extend this case in the switch\n      case ctx.MESSAGE_ACTIONS.INJECT_VIA_SCRIPTING: {\n        if (\n          source === ctx.MESSAGE_SOURCES.CONTENT_SCRIPT &&\n          target === ctx.MESSAGE_SOURCES.BACKGROUND &&\n          sender.tab?.id\n        ) {\n          const tabId = sender.tab.id;\n          const op = data?.op;\n\n          try {\n            if (op === \"REPLAY_PAGE_FETCH\") {\n              bgLogger.info({\n                message: \"[BACKGROUND] REPLAY_PAGE_FETCH: Executing script\",\n                logLevel: LOG_LEVEL.INFO,\n                type: LOG_TYPES.BACKGROUND,\n              });\n              await chrome.scripting.executeScript({\n                target: { tabId },\n                world: \"MAIN\",\n                func: (opts) => {\n                  try {\n                    const url = window.location.href;\n\n                    // Prefer XHR to avoid any site reassignments of window.fetch\n                    const xhr = new XMLHttpRequest();\n                    xhr.open(\"GET\", url, true);\n                    xhr.withCredentials = true; // same-origin anyway, keeps cookies\n                    xhr.setRequestHeader(\n                      \"accept\",\n                      \"text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8\",\n                    );\n                    xhr.setRequestHeader(\"accept-language\", \"en-GB,en;q=0.5\");\n                    xhr.setRequestHeader(\"cache-control\", \"no-store\");\n                    // Optional debug marker\n                    xhr.setRequestHeader(\"x-reclaim-replay\", \"1\");\n\n                    xhr.onreadystatechange = function () {\n                      // No-op; interception happens in the patched XHR prototype\n                    };\n                    xhr.send(null);\n\n                    if (opts?.showAlert) {\n                      console.log(\"Replaying via XHR…\", url);\n                    }\n                  } catch (e) {\n                    console.log(\"REPLAY_PAGE_FETCH XHR failed:\", e && e.message);\n                  }\n                },\n                args: [{ showAlert: !!data?.showAlert }],\n              });\n\n              bgLogger.info({\n                message: \"[BACKGROUND] REPLAY_PAGE_FETCH executed in MAIN world (XHR)\",\n                logLevel: LOG_LEVEL.INFO,\n                type: LOG_TYPES.BACKGROUND,\n              });\n              sendResponse({ success: true });\n              break;\n            }\n\n            if (op === \"RUN_CUSTOM_INJECTION\") {\n              const code = String(data?.code || \"\");\n              const results = await chrome.scripting.executeScript({\n                target: { tabId: sender.tab.id },\n                world: \"MAIN\",\n                func: (opts) => {\n                  try {\n                    const code = String(opts?.code || \"\");\n                    if (!code) return { status: \"skipped\", reason: \"no_code\" };\n                    if (window.__reclaimCustomInjectionDone__) {\n                      return { status: \"skipped\", reason: \"already_injected\" };\n                    }\n\n                    // 1) Use page nonce if available (CSP-compliant)\n                    const tryWithNonce = () => {\n                      try {\n                        const nonce = (document.querySelector(\"script[nonce]\") || {}).nonce;\n                        if (!nonce) return false;\n                        const s = document.createElement(\"script\");\n                        s.setAttribute(\"nonce\", nonce);\n                        s.textContent = code;\n                        (document.documentElement || document.head || document).appendChild(s);\n                        s.remove();\n                        return true;\n                      } catch {\n                        return false;\n                      }\n                    };\n\n                    // 2) Trusted Types + nonce (still needs nonce on TT-enforced sites)\n                    const tryWithTT = () => {\n                      try {\n                        if (!window.trustedTypes) return false;\n                        const nonce = (document.querySelector(\"script[nonce]\") || {}).nonce || \"\";\n                        const names = [\n                          \"reclaim-extension-sdk\",\n                          \"reclaim\",\n                          \"default\",\n                          \"policy\",\n                          \"app\",\n                        ];\n                        for (const name of names) {\n                          try {\n                            const policy = window.trustedTypes.createPolicy(name, {\n                              createScript: (s) => s,\n                            });\n                            const s = document.createElement(\"script\");\n                            if (nonce) s.setAttribute(\"nonce\", nonce);\n                            s.text = policy.createScript(code);\n                            (document.documentElement || document.head || document).appendChild(s);\n                            s.remove();\n                            return true;\n                          } catch {}\n                        }\n                        return false;\n                      } catch {\n                        return false;\n                      }\n                    };\n\n                    // 3) Plain inline (last resort; typically blocked)\n                    const tryPlain = () => {\n                      try {\n                        const s = document.createElement(\"script\");\n                        s.textContent = code;\n                        (document.documentElement || document.head || document).appendChild(s);\n                        s.remove();\n                        return true;\n                      } catch {\n                        return false;\n                      }\n                    };\n\n                    const ok =\n                      tryWithNonce() || // best chance\n                      tryWithTT() || // TT with nonce when possible\n                      tryPlain(); // may be blocked\n\n                    if (ok) {\n                      window.__reclaimCustomInjectionDone__ = true;\n                      return { status: \"executed\" };\n                    }\n                    return { status: \"error\", reason: \"all_strategies_failed\" };\n                  } catch (e) {\n                    return { status: \"error\", reason: String(e?.message || e) };\n                  }\n                },\n                args: [{ code }],\n              });\n\n              const result = results?.[0]?.result;\n              bgLogger.info({\n                message: \"[BACKGROUND] RUN_CUSTOM_INJECTION result: \" + JSON.stringify(result),\n                logLevel: LOG_LEVEL.INFO,\n                type: LOG_TYPES.BACKGROUND,\n                meta: { result },\n              });\n              sendResponse({ success: true, result });\n              break;\n            }\n          } catch (e) {\n            bgLogger.error({\n              message: \"[BACKGROUND] INJECT_VIA_SCRIPTING failed: \" + e?.message,\n              logLevel: LOG_LEVEL.INFO,\n              type: LOG_TYPES.BACKGROUND,\n              meta: { e },\n            });\n            sendResponse({ success: false, error: e?.message || String(e) });\n          }\n        } else {\n          sendResponse({ success: false, error: \"Action not supported\" });\n        }\n        break;\n      }\n      default: {\n        bgLogger.error({\n          message: \"[BACKGROUND] DEFAULT: Action not supported\",\n          logLevel: LOG_LEVEL.INFO,\n          type: LOG_TYPES.BACKGROUND,\n        });\n        sendResponse({ success: false, error: \"Action not supported\" });\n      }\n    }\n  } catch (error) {\n    bgLogger.error({\n      message: \"[BACKGROUND] Error handling \" + action + \": \" + error?.message,\n      logLevel: LOG_LEVEL.INFO,\n      type: LOG_TYPES.BACKGROUND,\n      meta: { error },\n    });\n    sendResponse({ success: false, error: error.message });\n  }\n  // Required for async response\n  return true;\n}\n","/**\n * @fileoverview 证明生成队列模块（Background 层）\n *\n * 主要功能：\n * - 将验证流程中收集到的 claim 数据按请求入队，串行执行证明生成，避免并发冲突。\n * - 队列为空时根据 provider 的 requestData 模板判断是否已收集齐所有所需证明，满足则触发提交或恢复会话计时器。\n *\n * 逻辑与流程：\n * 1. 入队：addToProofGenerationQueue 将 { claimData, requestHash } 推入 ctx.proofGenerationQueue；\n *    若当前未在处理队列，则暂停会话计时器并启动 processNextQueueItem。\n * 2. 出队与执行：processNextQueueItem 在未 aborted 且队列非空时，设置 isProcessingQueue，\n *    取队首任务，向 content script 发送 PROOF_GENERATION_STARTED，调用 ctx.generateProof 生成证明。\n * 3. 结果处理：成功则写入 ctx.generatedProofs、发送 PROOF_GENERATION_SUCCESS、重置会话计时器；\n *    失败则调用 ctx.failSession 并返回。finally 中置 isProcessingQueue = false。\n * 4. 队列清空时：若有 requestData 模板，则比较已生成证明数量与模板数量，全部完成则 clearAllTimers 并\n *    setTimeout(submitProofs)；否则 resumeSessionTimer。无模板（手动模式）则直接 clearAllTimers 并 submitProofs。\n * 5. 全程受 ctx.aborted 控制，aborted 时不再处理新任务并提前返回。\n *\n * @module background/proofQueue\n */\n\nimport { LOG_TYPES, LOG_LEVEL, EVENT_TYPES } from \"../utils/logger\";\n\n/**\n * 将一条证明生成任务加入队列；若当前未在处理队列则暂停会话计时器并开始处理队首。\n * @param {object} ctx - 背景脚本上下文（含 proofGenerationQueue、isProcessingQueue、sessionTimerManager 等）\n * @param {object} claimData - 用于生成证明的 claim 数据\n * @param {string} requestHash - 请求哈希，用于标识模板/请求\n */\nexport function addToProofGenerationQueue(ctx, claimData, requestHash) {\n  ctx.proofGenerationQueue.push({\n    claimData,\n    requestHash,\n  });\n\n  if (!ctx.isProcessingQueue) {\n    ctx.sessionTimerManager.pauseSessionTimer();\n    processNextQueueItem(ctx);\n  }\n}\n\n/**\n * 处理队列中的下一个证明生成任务：取队首、通知 content script、调用 generateProof、写回结果或 failSession；\n * 队列清空时根据模板完成情况决定提交证明或恢复会话计时器。\n * @param {object} ctx - 背景脚本上下文\n * @returns {Promise<void>}\n */\nexport async function processNextQueueItem(ctx) {\n  const bgLogger = ctx.bgLogger;\n  bgLogger.setContext({\n    sessionId: ctx.sessionId || \"unknown\",\n    providerId: ctx.providerId || \"unknown\",\n    appId: ctx.appId || \"unknown\",\n    type: LOG_TYPES.BACKGROUND,\n  });\n\n  if (ctx.aborted) {\n    bgLogger.info({\n      message: \"[BACKGROUND] Proof generation queue aborted\",\n      logLevel: LOG_LEVEL.INFO,\n      type: LOG_TYPES.BACKGROUND,\n      eventType: EVENT_TYPES.RECLAIM_VERIFICATION_DISMISSED,\n    });\n    return;\n  }\n\n  if (ctx.isProcessingQueue || ctx.proofGenerationQueue.length === 0) {\n    if (ctx.proofGenerationQueue.length === 0) {\n      const templateCount = Array.isArray(ctx.providerData?.requestData)\n        ? ctx.providerData.requestData.length\n        : 0;\n\n      if (templateCount > 0) {\n        const completedTemplate = ctx.providerData.requestData.filter((rd) =>\n          ctx.generatedProofs.has(rd.requestHash),\n        ).length;\n\n        if (completedTemplate === templateCount) {\n          ctx.sessionTimerManager.clearAllTimers();\n          if (!ctx.expectManyClaims) setTimeout(() => ctx.submitProofs(), 0);\n        } else {\n          ctx.sessionTimerManager.resumeSessionTimer();\n        }\n      } else {\n        // Manual mode: queue is empty → submit whatever we have\n        ctx.sessionTimerManager.clearAllTimers();\n        if (!ctx.expectManyClaims) setTimeout(() => ctx.submitProofs(), 0);\n      }\n      return;\n    }\n    ctx.sessionTimerManager.resumeSessionTimer();\n  }\n\n  ctx.isProcessingQueue = true;\n\n  const task = ctx.proofGenerationQueue.shift();\n\n  try {\n    if (ctx.aborted) {\n      bgLogger.info({\n        message: \"[BACKGROUND] Proof generation aborted\",\n        logLevel: LOG_LEVEL.INFO,\n        type: LOG_TYPES.BACKGROUND,\n        eventType: EVENT_TYPES.PROOF_GENERATION_ABORTED,\n      });\n      return;\n    }\n\n    chrome.tabs.sendMessage(ctx.activeTabId, {\n      action: ctx.MESSAGE_ACTIONS.PROOF_GENERATION_STARTED,\n      source: ctx.MESSAGE_SOURCES.BACKGROUND,\n      target: ctx.MESSAGE_SOURCES.CONTENT_SCRIPT,\n      data: { requestHash: task.requestHash },\n    });\n\n    bgLogger.info({\n      message: \"[BACKGROUND] Proof generation started for request hash: \" + task.requestHash,\n      logLevel: LOG_LEVEL.INFO,\n      type: LOG_TYPES.BACKGROUND,\n    });\n\n    const proofResponseObject = await ctx.generateProof(\n      {\n        ...task.claimData,\n        publicData: ctx.publicData ?? null,\n      },\n      bgLogger,\n    );\n\n    if (ctx.aborted) {\n      bgLogger.info({\n        message: \"[BACKGROUND] Proof generation aborted\",\n        logLevel: LOG_LEVEL.INFO,\n        type: LOG_TYPES.BACKGROUND,\n        eventType: EVENT_TYPES.PROOF_GENERATION_ABORTED,\n      });\n      return;\n    }\n\n    if (!proofResponseObject.success) {\n      bgLogger.error({\n        message:\n          \"[BACKGROUND] Proof generation failed for request hash: \" +\n          task.requestHash +\n          \": \" +\n          proofResponseObject.error,\n        logLevel: LOG_LEVEL.INFO,\n        type: LOG_TYPES.BACKGROUND,\n      });\n      ctx.failSession(\"Proof generation failed: \" + proofResponseObject.error, task.requestHash);\n      return;\n    }\n\n    const proof = proofResponseObject.proof;\n\n    if (proof) {\n      if (!ctx.generatedProofs.has(task.requestHash)) {\n        ctx.generatedProofs.set(task.requestHash, proof);\n      }\n\n      bgLogger.info({\n        message: \"[BACKGROUND] Proof generation successful for request hash: \" + task.requestHash,\n        logLevel: LOG_LEVEL.INFO,\n        type: LOG_TYPES.BACKGROUND,\n      });\n\n      chrome.tabs.sendMessage(ctx.activeTabId, {\n        action: ctx.MESSAGE_ACTIONS.PROOF_GENERATION_SUCCESS,\n        source: ctx.MESSAGE_SOURCES.BACKGROUND,\n        target: ctx.MESSAGE_SOURCES.CONTENT_SCRIPT,\n        data: { requestHash: task.requestHash },\n      });\n\n      ctx.sessionTimerManager.resetSessionTimer();\n    }\n  } catch (error) {\n    bgLogger.error({\n      message:\n        \"[BACKGROUND] Proof generation failed for request hash: \" +\n        task.requestHash +\n        \": \" +\n        error?.message,\n      logLevel: LOG_LEVEL.INFO,\n      type: LOG_TYPES.BACKGROUND,\n    });\n\n    ctx.failSession(\"Proof generation failed: \" + error.message, task.requestHash);\n    return;\n  } finally {\n    ctx.isProcessingQueue = false;\n\n    if (ctx.aborted) return;\n\n    if (ctx.proofGenerationQueue.length > 0) {\n      processNextQueueItem(ctx);\n    } else {\n      const templateCount = Array.isArray(ctx.providerData?.requestData)\n        ? ctx.providerData.requestData.length\n        : 0;\n\n      if (templateCount > 0) {\n        const completedTemplate = ctx.providerData.requestData.filter((rd) =>\n          ctx.generatedProofs.has(rd.requestHash),\n        ).length;\n\n        ctx.sessionTimerManager.clearAllTimers();\n        if (completedTemplate === templateCount) {\n          if (!ctx.expectManyClaims) setTimeout(() => ctx.submitProofs(), 0);\n        } else {\n          ctx.sessionTimerManager.resumeSessionTimer();\n        }\n      } else {\n        // Manual mode: queue is empty → submit whatever we have\n        ctx.sessionTimerManager.clearAllTimers();\n        if (!ctx.expectManyClaims) setTimeout(() => ctx.submitProofs(), 0);\n      }\n    }\n  }\n}\n","/**\n * @fileoverview Cookie Utilities - Cookie 获取与组装工具\n * @description 提供用于获取、过滤和组装指定 URL 的 Cookie 字符串的工具函数，支持标准 Cookie 和分区 Cookie (CHIPS)。\n *\n * 主要功能/逻辑/流程：\n * 1. 获取 Cookie (getCookiesForUrl):\n *    - 核心流程：接收目标 URL，从 Chrome Cookies API 中检索所有相关 Cookie。\n *    - 广度搜索：为了确保不遗漏（特别是被分区或具体子域的 Cookie），它通过多种组合（域名、URL、分区键 PartitionKey）并行查询 Cookie Store。\n *    - 分区支持：特别处理了 Google 的 CHIPS (Cookies Having Independent Partitioned State) 机制，尝试推断 eTLD+1 作为 topLevelSite 进行查询。\n *\n * 2. 过滤与去重:\n *    - 过滤规则 (shouldIncludeCookie)：检查域名匹配 (RFC6265)、路径匹配、Secure 属性与 HTTPS 的对应关系、以及过期时间。\n *    - 智能去重：当存在多个同名 Cookie 时，优先保留更具体的版本（HostOnly > 路径更长 > 过期时间更晚）。\n *\n * 3. 组装输出:\n *    - 按照标准（路径越长越优先）排序，最终拼接成 HTTP 请求头所需的 `Cookie: name=value; ...` 字符串格式。\n */\nimport { LOG_LEVEL, LOG_TYPES } from \"../utils/logger\";\n\nexport async function getCookiesForUrl(url, bgLogger) {\n  try {\n    if (!chrome.cookies || !chrome.cookies.getAll) {\n      bgLogger.info({\n        message: \"[BACKGROUND] Chrome cookies API not available\",\n        logLevel: LOG_LEVEL.INFO,\n        type: LOG_TYPES.BACKGROUND,\n        meta: {\n          url: url,\n        },\n      });\n      return null;\n    }\n\n    const urlObj = new URL(url);\n    const domain = urlObj.hostname;\n    const isHttps = urlObj.protocol === \"https:\";\n    const now = Date.now() / 1000;\n\n    // ---- helpers -----------------------------------------------------------\n\n    // Minimal eTLD+1 guesser (keeps old behavior; avoids dependencies).\n    // Not perfect (e.g., co.uk), but we also try full host as a topLevelSite below.\n    const guessETLDPlusOne = (host) => {\n      const parts = host.split(\".\");\n      if (parts.length <= 2) return host;\n      // Heuristic for common 2-level TLDs; extend if you need more.\n      const sldTlds = new Set([\n        \"co.uk\",\n        \"ac.uk\",\n        \"gov.uk\",\n        \"co.in\",\n        \"com.au\",\n        \"com.br\",\n        \"com.mx\",\n        \"com.sg\",\n      ]);\n      const lastTwo = parts.slice(-2).join(\".\");\n      const lastThree = parts.slice(-3).join(\".\");\n      if (sldTlds.has(lastTwo)) return parts.slice(-3).join(\".\");\n      if (sldTlds.has(lastThree)) return parts.slice(-4).join(\".\");\n      return parts.slice(-2).join(\".\");\n    };\n\n    const makeTopLevelSiteCandidates = (host) => {\n      // schemeful site strings for partitioned cookies\n      const base = guessETLDPlusOne(host);\n      const set = new Set();\n      set.add(`https://${host}`);\n      set.add(`https://${base}`);\n      // a common variant (helps when host is bare apex)\n      set.add(`https://www.${base}`);\n      return [...set];\n    };\n\n    const domainVariants = (host) => {\n      const parts = host.split(\".\");\n      const variants = new Set();\n      variants.add(host);\n      for (let i = 1; i < parts.length; i++) {\n        variants.add(parts.slice(i).join(\".\")); // parent without leading dot (API accepts this)\n        variants.add(\".\" + parts.slice(i).join(\".\")); // for safety—some folks pass dotted filter\n      }\n      return [...variants];\n    };\n\n    const getStores = async () => {\n      try {\n        const stores = await chrome.cookies.getAllCookieStores();\n        return Array.isArray(stores) && stores.length ? stores : [{ id: undefined }];\n      } catch {\n        return [{ id: undefined }];\n      }\n    };\n\n    const safeGetAll = async (details) => {\n      try {\n        return await chrome.cookies.getAll(details);\n      } catch (error) {\n        bgLogger.info({\n          message: \"[BACKGROUND] cookies.getAll failed for details: \",\n          logLevel: LOG_LEVEL.INFO,\n          type: LOG_TYPES.BACKGROUND,\n          meta: {\n            details: details,\n            error: error?.message,\n          },\n        });\n        return [];\n      }\n    };\n\n    // RFC6265-ish domain-match\n    const domainMatches = (reqHost, cookieDomain, hostOnly) => {\n      if (!cookieDomain) return false;\n      if (hostOnly) return reqHost === cookieDomain;\n      // Domain cookie: reqHost == cookieDomain OR endsWith(\".\" + cookieDomain)\n      // Allow cookieDomain with or without leading dot\n      const cd = cookieDomain.startsWith(\".\") ? cookieDomain.slice(1) : cookieDomain;\n      return reqHost === cd || reqHost.endsWith(\".\" + cd);\n    };\n\n    // RFC6265-ish path-match\n    const pathMatches = (reqPath, cookiePath) => {\n      if (!cookiePath || cookiePath === \"/\") return true;\n      // Must be a prefix\n      if (!reqPath.startsWith(cookiePath)) return false;\n      // If cookiePath is a prefix and ends with \"/\", it's fine; if not, next char in reqPath must be \"/\" (or cookiePath == reqPath)\n      if (reqPath.length === cookiePath.length) return true;\n      if (cookiePath.endsWith(\"/\")) return true;\n      return reqPath.charAt(cookiePath.length) === \"/\";\n    };\n\n    // Use caller's shouldIncludeCookie if present; otherwise do a sane default.\n    const defaultShouldIncludeCookie = (cookie) => {\n      // Secure cookies only over https\n      if (cookie.secure && !isHttps) return false;\n      // Expired\n      if (cookie.expirationDate && cookie.expirationDate <= now) return false;\n      // Domain & path checks\n      if (!domainMatches(domain, cookie.domain, cookie.hostOnly)) return false;\n      if (!pathMatches(urlObj.pathname || \"/\", cookie.path)) return false;\n      return true; // We intentionally do NOT enforce sameSite here; caller may inject via header/DNR.\n    };\n\n    const localShouldInclude =\n      typeof shouldIncludeCookie === \"function\"\n        ? (cookie) => shouldIncludeCookie(cookie, urlObj, bgLogger)\n        : defaultShouldIncludeCookie;\n\n    // Choose the \"better\" cookie if we see duplicates (same name+domain+path+partition)\n    const betterCookie = (a, b) => {\n      // Prefer hostOnly\n      if (!!a.hostOnly !== !!b.hostOnly) return a.hostOnly ? a : b;\n      // Longer path\n      if ((a.path?.length || 0) !== (b.path?.length || 0))\n        return (a.path?.length || 0) > (b.path?.length || 0) ? a : b;\n      // Later expiration\n      const aExp = a.expirationDate || 0;\n      const bExp = b.expirationDate || 0;\n      if (aExp !== bExp) return aExp > bExp ? a : b;\n      // Recent access (if available)\n      const aLast = a.lastAccessed || 0;\n      const bLast = b.lastAccessed || 0;\n      if (aLast !== bLast) return aLast > bLast ? a : b;\n      return a; // stable\n    };\n\n    // ---- collect cookies ---------------------------------------------------\n\n    const allCookies = [];\n    const stores = await getStores();\n\n    // Build a list of queries to fan out (avoid exact duplicates)\n    const queries = [];\n    const pushQuery = (q) => {\n      // stringify to de-dupe\n      const key = JSON.stringify(q);\n      if (!queries.some((qq) => JSON.stringify(qq) === key)) queries.push(q);\n    };\n\n    const dVariants = domainVariants(domain);\n    const topLevelSites = makeTopLevelSiteCandidates(domain);\n\n    for (const { id: storeId } of stores) {\n      // Domain-based\n      for (const d of dVariants) pushQuery({ domain: d, storeId });\n      // URL-based\n      pushQuery({ url, storeId });\n\n      // Partitioned (CHIPS) queries: for each domain variant + top-level site\n      for (const d of dVariants) {\n        for (const topLevelSite of topLevelSites) {\n          pushQuery({ domain: d, partitionKey: { topLevelSite }, storeId });\n        }\n      }\n      // Also try URL + partitionKey (sometimes catches cookies missed by domain filter)\n      for (const topLevelSite of topLevelSites) {\n        pushQuery({ url, partitionKey: { topLevelSite }, storeId });\n      }\n    }\n\n    // Execute queries\n    const pages = await Promise.all(queries.map((q) => safeGetAll(q)));\n    for (const list of pages) allCookies.push(...list);\n\n    // ---- filter + dedup ----------------------------------------------------\n\n    // Dedup key includes partition topLevelSite (important for CHIPS)\n    const keyOf = (c) =>\n      [\n        c.name,\n        c.domain || \"\",\n        c.path || \"\",\n        c.partitionKey?.topLevelSite || \"\", // distinguish partitioned vs unpartitioned\n      ].join(\"|\");\n\n    const candidates = new Map();\n    for (const cookie of allCookies) {\n      if (!localShouldInclude(cookie)) continue;\n      const k = keyOf(cookie);\n      const prev = candidates.get(k);\n      candidates.set(k, prev ? betterCookie(prev, cookie) : cookie);\n    }\n\n    const uniqueCookies = [...candidates.values()];\n\n    if (uniqueCookies.length === 0) return null;\n\n    // Sort: longest path first (server selection favors specificity),\n    // then hostOnly, then later expiration.\n    uniqueCookies.sort((a, b) => {\n      const pl = (p) => (p ? p.length : 0);\n      if (pl(a.path) !== pl(b.path)) return pl(b.path) - pl(a.path);\n      if (!!a.hostOnly !== !!b.hostOnly) return a.hostOnly ? -1 : 1;\n      const aExp = a.expirationDate || 0;\n      const bExp = b.expirationDate || 0;\n      return bExp - aExp;\n    });\n\n    // Build header string\n    const cookieStr = uniqueCookies.map((c) => `${c.name}=${c.value}`).join(\"; \");\n    return cookieStr || null;\n  } catch (error) {\n    bgLogger.error({\n      message: \"[BACKGROUND] Error getting cookies for URL: \" + error?.message,\n      logLevel: LOG_LEVEL.INFO,\n      type: LOG_TYPES.BACKGROUND,\n      meta: {\n        error: error?.message,\n      },\n    });\n    return null;\n  }\n}\n\nexport function shouldIncludeCookie(cookie, urlObj, bgLogger) {\n  try {\n    // Check domain match\n    const cookieDomain = cookie.domain.startsWith(\".\") ? cookie.domain.substring(1) : cookie.domain;\n    const requestDomain = urlObj.hostname;\n\n    const domainMatches =\n      requestDomain === cookieDomain ||\n      requestDomain.endsWith(\".\" + cookieDomain) ||\n      (cookie.domain.startsWith(\".\") && requestDomain.endsWith(cookie.domain.substring(1)));\n\n    if (!domainMatches) {\n      return false;\n    }\n\n    // Check path match\n    const cookiePath = cookie.path || \"/\";\n    const requestPath = urlObj.pathname;\n    const pathMatches = requestPath.startsWith(cookiePath);\n\n    if (!pathMatches) {\n      return false;\n    }\n\n    // Check secure flag\n    const isSecureRequest = urlObj.protocol === \"https:\";\n    if (cookie.secure && !isSecureRequest) {\n      return false;\n    }\n\n    // Check if cookie is expired\n    if (cookie.expirationDate && cookie.expirationDate < Date.now() / 1000) {\n      return false;\n    }\n\n    return true;\n  } catch (error) {\n    bgLogger.info({\n      message: \"[BACKGROUND] Error checking cookie inclusion: \" + error?.message,\n      logLevel: LOG_LEVEL.INFO,\n      type: LOG_TYPES.BACKGROUND,\n      meta: {\n        error: error?.message,\n      },\n    });\n    return false;\n  }\n}\n","import \"../utils/polyfills\";\nimport {\n  fetchProviderData,\n  updateSessionStatus,\n  submitProofOnCallback,\n} from \"../utils/fetch-calls\";\nimport { RECLAIM_SESSION_STATUS, MESSAGE_ACTIONS, MESSAGE_SOURCES } from \"../utils/constants\";\nimport { generateProof, formatProof } from \"../utils/proof-generator\";\nimport { createClaimObject } from \"../utils/claim-creator\";\nimport { loggerService, createContextLogger } from \"../utils/logger/LoggerService\";\nimport { EVENT_TYPES, LOG_LEVEL, LOG_TYPES } from \"../utils/logger/constants\";\nimport { SessionTimerManager } from \"../utils/session-timer\";\nimport { debugLogger, DebugLogType } from \"../utils/logger\";\nimport { installOffscreenReadyListener } from \"../utils/offscreen-manager\";\n\nimport * as messageRouter from \"./messageRouter\";\nimport * as sessionManager from \"./sessionManager\";\nimport * as tabManager from \"./tabManager\";\nimport * as proofQueue from \"./proofQueue\";\nimport * as cookieUtils from \"./cookieUtils\";\n\nconst bgLogger = createContextLogger({\n  sessionId: \"unknown\",\n  providerId: \"unknown\",\n  appId: \"unknown\",\n  source: \"reclaim-extension-sdk\",\n});\n\n/**\n * 扩展后台入口：初始化验证会话上下文并注册消息与 Tab 监听。\n *\n * 主要功能：\n * - 安装 offscreen 就绪监听，供 proof 生成使用\n * - 创建并返回 ctx：集中保存当前会话状态（sessionId、providerData、activeTabId、proof 队列等）及依赖（fetch、proof 生成、claim 创建、logger 等）\n * - 从 chrome.storage.local 加载日志配置并监听变更以实时同步\n * - 将 sessionManager 的 failSession、submitProofs 及本文件内的 processFilteredRequest 绑定到 ctx，供 messageRouter 等调用\n * - 注册 chrome.runtime.onMessage，将所有消息交给 messageRouter.handleMessage（处理 START_VERIFICATION、CONTENT_SCRIPT_LOADED、请求过滤/claim/proof 等）\n * - 注册 chrome.tabs.onRemoved：在验证会话进行中若当前 Tab 或所有托管 Tab 被关闭，则调用 failSession 并清理 ctx 中的 tab/会话引用\n *\n * 流程概览：扩展加载 →  background 调用 initBackground() → 得到 ctx，消息与 Tab 监听生效 → 收到 START_VERIFICATION 后由 messageRouter 驱动拉取 provider、开 Tab、过滤请求、创建 claim、排队生成 proof、提交/回调。\n */\nexport default function initBackground() {\n  installOffscreenReadyListener();\n\n  // 用于保存共享状态和依赖关系的上下文对象\n  const ctx = {\n    // State\n    activeTabId: null,\n    providerData: null,\n    parameters: {},\n    providerId: null,\n    appId: null,\n    sessionId: null,\n    callbackUrl: null,\n    publicData: null,\n    aborted: false,\n    expectManyClaims: false,\n    originalTabId: null,\n    managedTabs: new Set(),\n    providerRequestsByHash: new Map(),\n    generatedProofs: new Map(),\n    filteredRequests: new Map(),\n    proofGenerationQueue: [],\n    isProcessingQueue: false,\n    firstRequestReceived: false,\n    initPopupMessage: new Map(),\n    providerDataMessage: new Map(),\n    activeSessionId: null,\n    // Timer\n    sessionTimerManager: new SessionTimerManager(),\n    // Constants and dependencies\n    fetchProviderData,\n    updateSessionStatus,\n    submitProofOnCallback,\n    RECLAIM_SESSION_STATUS,\n    MESSAGE_ACTIONS,\n    MESSAGE_SOURCES,\n    generateProof,\n    formatProof,\n    createClaimObject,\n    loggerService,\n    bgLogger,\n    debugLogger,\n    DebugLogType,\n    // Methods to be set below\n    processFilteredRequest: null,\n    failSession: null,\n    submitProofs: null,\n  };\n\n  bgLogger.setContext({\n    sessionId: ctx.sessionId || \"unknown\",\n    providerId: ctx.providerId || \"unknown\",\n    appId: ctx.appId || \"unknown\",\n    type: LOG_TYPES.BACKGROUND,\n  });\n\n  // Load and live-sync log config\n  try {\n    const { LOG_CONFIG_STORAGE_KEY } = require(\"../utils/logger/constants\");\n    chrome.storage.local.get([LOG_CONFIG_STORAGE_KEY], (res) => {\n      const cfg = res?.[LOG_CONFIG_STORAGE_KEY];\n      if (cfg && typeof cfg === \"object\") ctx.loggerService.setConfig(cfg);\n    });\n    chrome.storage.onChanged.addListener((changes, area) => {\n      if (area === \"local\" && changes[LOG_CONFIG_STORAGE_KEY]) {\n        const newCfg = changes[LOG_CONFIG_STORAGE_KEY].newValue || {};\n        ctx.loggerService.setConfig(newCfg);\n      }\n    });\n  } catch {}\n\n  bgLogger.info({\n    message: \"Background initialized INFO\",\n    logLevel: LOG_LEVEL.INFO,\n    type: LOG_TYPES.BACKGROUND,\n  });\n\n  // Bind sessionManager methods to context\n  ctx.failSession = (...args) => sessionManager.failSession(ctx, ...args);\n  ctx.submitProofs = (...args) => sessionManager.submitProofs(ctx, ...args);\n\n  // Add processFilteredRequest to context (move from class)\n  ctx.processFilteredRequest = async function (request, criteria, sessionId, loginUrl) {\n    try {\n      sessionId = ctx.sessionId || sessionId;\n      if (!sessionId) {\n        ctx.failSession(\"Session not initialized for claim request\", criteria?.requestHash);\n        return { success: false, error: \"Session not initialized\" };\n      }\n      if (!ctx.firstRequestReceived) {\n        ctx.firstRequestReceived = true;\n        ctx.sessionTimerManager.startSessionTimer();\n      }\n\n      bgLogger.setContext({\n        sessionId: ctx.sessionId || \"unknown\",\n        providerId: ctx.providerId || \"unknown\",\n        appId: ctx.appId || \"unknown\",\n        type: LOG_TYPES.BACKGROUND,\n      });\n      bgLogger.info({\n        message: `[BACKGROUND] Filtering request for request hash: ${criteria.requestHash}`,\n        logLevel: LOG_LEVEL.INFO,\n        type: LOG_TYPES.BACKGROUND,\n      });\n\n      const cookies = await cookieUtils.getCookiesForUrl(request.url, ctx.bgLogger);\n      if (cookies) {\n        request.cookieStr = cookies;\n      }\n\n      bgLogger.log({\n        message: `[BACKGROUND] Cookies for URL: ${request.url}`,\n        logLevel: LOG_LEVEL.ALL,\n        type: LOG_TYPES.BACKGROUND,\n        meta: {\n          request: request,\n          criteria: criteria,\n          sessionId: sessionId,\n          loginUrl: loginUrl,\n          cookies: cookies,\n        },\n      });\n\n      chrome.tabs.sendMessage(ctx.activeTabId, {\n        action: ctx.MESSAGE_ACTIONS.CLAIM_CREATION_REQUESTED,\n        source: ctx.MESSAGE_SOURCES.BACKGROUND,\n        target: ctx.MESSAGE_SOURCES.CONTENT_SCRIPT,\n        data: { requestHash: criteria.requestHash },\n      });\n\n      bgLogger.info({\n        message: \"[BACKGROUND] Claim creation requested for request hash: \" + criteria.requestHash,\n        logLevel: LOG_LEVEL.INFO,\n        type: LOG_TYPES.BACKGROUND,\n        eventType: EVENT_TYPES.STARTING_CLAIM_CREATION,\n      });\n\n      let claimData = null;\n      try {\n        const criteriaWithGeo = { ...criteria, geoLocation: ctx.providerData?.geoLocation ?? \"\" };\n        claimData = await ctx.createClaimObject(\n          request,\n          criteriaWithGeo,\n          sessionId,\n          ctx.providerId,\n          loginUrl,\n          ctx.bgLogger,\n        );\n      } catch (error) {\n        bgLogger.error({\n          message: \"[BACKGROUND] Error creating claim object: \" + error.message,\n          logLevel: LOG_LEVEL.INFO,\n          type: LOG_TYPES.BACKGROUND,\n        });\n        chrome.tabs.sendMessage(ctx.activeTabId, {\n          action: ctx.MESSAGE_ACTIONS.CLAIM_CREATION_FAILED,\n          source: ctx.MESSAGE_SOURCES.BACKGROUND,\n          target: ctx.MESSAGE_SOURCES.CONTENT_SCRIPT,\n          data: { requestHash: criteria.requestHash },\n        });\n\n        ctx.failSession(\"Claim creation failed: \" + error.message, criteria.requestHash);\n        return { success: false, error: error.message };\n      }\n\n      if (claimData) {\n        chrome.tabs.sendMessage(ctx.activeTabId, {\n          action: ctx.MESSAGE_ACTIONS.CLAIM_CREATION_SUCCESS,\n          source: ctx.MESSAGE_SOURCES.BACKGROUND,\n          target: ctx.MESSAGE_SOURCES.CONTENT_SCRIPT,\n          data: { requestHash: criteria.requestHash },\n        });\n        bgLogger.info({\n          message:\n            \"[BACKGROUND] Claim Object creation successful for request hash: \" +\n            criteria.requestHash,\n          logLevel: LOG_LEVEL.INFO,\n          type: LOG_TYPES.BACKGROUND,\n        });\n      }\n      const providerRequest = {\n        url: criteria?.url || request?.url || \"\",\n        expectedPageUrl: criteria?.expectedPageUrl || \"\",\n        urlType: criteria?.urlType || \"EXACT\",\n        method: criteria?.method || request?.method || \"GET\",\n        responseMatches: Array.isArray(criteria?.responseMatches) ? criteria.responseMatches : [],\n        responseRedactions: Array.isArray(criteria?.responseRedactions)\n          ? criteria.responseRedactions\n          : [],\n        requestHash: criteria?.requestHash,\n      };\n      if (providerRequest.requestHash) {\n        ctx.providerRequestsByHash.set(providerRequest.requestHash, providerRequest);\n      }\n      proofQueue.addToProofGenerationQueue(ctx, claimData, criteria.requestHash);\n      bgLogger.info({\n        message: \"[BACKGROUND] Proof generation queued for request hash: \" + criteria.requestHash,\n        logLevel: LOG_LEVEL.INFO,\n        type: LOG_TYPES.BACKGROUND,\n      });\n      return { success: true, message: \"Proof generation queued\" };\n    } catch (error) {\n      bgLogger.error({\n        message: \"[BACKGROUND] Error processing filtered request: \" + error.message,\n        logLevel: LOG_LEVEL.INFO,\n        type: LOG_TYPES.BACKGROUND,\n      });\n      ctx.failSession(\"Error processing request: \" + error.message, criteria.requestHash);\n      return { success: false, error: error.message };\n    }\n  };\n\n  // Set up session timer callbacks\n  ctx.sessionTimerManager.setCallbacks(ctx.failSession);\n  ctx.sessionTimerManager.setTimerDuration(30000);\n  // Register message handler\n  chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {\n    messageRouter.handleMessage(ctx, message, sender, sendResponse);\n    return true; // Required for async response\n  });\n\n  // Listen for tab removals to clean up managedTabs\n  chrome.tabs.onRemoved.addListener(async (tabId) => {\n    const wasManaged = ctx.managedTabs.has(tabId);\n    if (wasManaged) ctx.managedTabs.delete(tabId);\n\n    const lostActive = tabId === ctx.activeTabId;\n    const noManagedLeft = ctx.managedTabs.size === 0;\n\n    // If there is an active session and we lost its tab(s), fail immediately.\n    if (ctx.activeSessionId && (lostActive || noManagedLeft) && !ctx.aborted) {\n      ctx.aborted = true;\n      try {\n        bgLogger.error({\n          message: \"[BACKGROUND] Verification tab closed by user\",\n          logLevel: LOG_LEVEL.INFO,\n          type: LOG_TYPES.BACKGROUND,\n          sessionId: ctx.activeSessionId || ctx.sessionId || \"unknown\",\n          providerId: ctx.providerId || \"unknown\",\n          appId: ctx.appId || \"unknown\",\n          eventType: EVENT_TYPES.RECLAIM_VERIFICATION_DISMISSED,\n        });\n        await ctx.failSession(\"Verification tab closed by user\");\n      } catch {}\n    }\n\n    if (lostActive) ctx.activeTabId = null;\n    if (noManagedLeft) {\n      ctx.originalTabId = null;\n      ctx.activeSessionId = null; // clear stale guard\n    }\n  });\n\n  bgLogger.info({\n    message: \"[BACKGROUND] 🚀 Background initialization complete\",\n    logLevel: LOG_LEVEL.INFO,\n    type: LOG_TYPES.BACKGROUND,\n  });\n  return ctx;\n}\n","/**\n * Represents a log entry to be sent to the logging service.\n */\nexport class LogEntry {\n  constructor({\n    sessionId,\n    providerId,\n    appId,\n    logLine,\n    type,\n    eventType,\n    logLevel,\n    source,\n    tabId,\n    url,\n    meta,\n    time = null,\n    deviceId,\n  }) {\n    this.sessionId = sessionId;\n    this.providerId = providerId;\n    this.appId = appId;\n    this.logLine = logLine;\n    this.type = type;\n    this.eventType = eventType;\n    this.logLevel = logLevel;\n    this.source = source;\n    this.tabId = tabId;\n    this.url = url;\n    this.meta = meta || undefined;\n    this.time = time || new Date();\n    this.deviceId = deviceId;\n  }\n\n  toJson() {\n    const json = {\n      logLine: this.logLine,\n      ts: LogEntry.fromDateTimeToTimeStamp(this.time),\n      logLevel: this.logLevel,\n      sessionId: this.sessionId,\n      providerId: this.providerId,\n      appId: this.appId,\n      source: this.source,\n      deviceId: this.deviceId,\n    };\n\n    // Only include optional fields if they exist\n    if (this.type) json.type = this.type;\n    if (this.eventType) json.eventType = this.eventType;\n    if (this.tabId) json.tabId = this.tabId;\n    if (this.url) json.url = this.url;\n    if (this.meta) json.meta = this.meta;\n\n    return json;\n  }\n\n  static fromDateTimeToTimeStamp(dateTime) {\n    const ms = dateTime.getTime();\n    return (ms * 1000000).toString();\n  }\n}\n","import {\n  LOGGING_ENDPOINTS,\n  DEFAULT_LOG_CONFIG,\n  LOG_LEVEL,\n  LOG_LEVEL_MAP,\n  LOG_CONFIG_STORAGE_KEY,\n  DEVICE_ID_STORAGE_KEY,\n} from \"./constants\";\nimport { LogEntry } from \"./LogEntry\";\n\nexport class LoggerService {\n  constructor() {\n    this.logs = [];\n    this.isSending = false;\n    this.maxBatchSize = 20;\n    this.flushInterval = 5000;\n    this.flushIntervalId = null;\n\n    this.config = { ...DEFAULT_LOG_CONFIG };\n    this.deviceId = null;\n\n    // Load and live-sync config from chrome.storage when available\n    try {\n      if (typeof chrome !== \"undefined\" && chrome.storage?.local) {\n        chrome.storage.local.get([LOG_CONFIG_STORAGE_KEY], (res) => {\n          const cfg = res?.[LOG_CONFIG_STORAGE_KEY];\n          if (cfg && typeof cfg === \"object\") {\n            this.setConfig(cfg);\n          }\n        });\n        chrome.storage.onChanged.addListener((changes, area) => {\n          if (area === \"local\" && changes[LOG_CONFIG_STORAGE_KEY]) {\n            const newCfg = changes[LOG_CONFIG_STORAGE_KEY].newValue || {};\n            this.setConfig(newCfg);\n          }\n        });\n      }\n    } catch {}\n\n    this.startFlushInterval();\n  }\n\n  setConfig(partial) {\n    this.config = { ...this.config, ...partial };\n  }\n\n  startFlushInterval() {\n    if (this.flushIntervalId) clearInterval(this.flushIntervalId);\n    this.flushIntervalId = setInterval(() => this.flush(), this.flushInterval);\n  }\n\n  stopFlushInterval() {\n    if (this.flushIntervalId) {\n      clearInterval(this.flushIntervalId);\n      this.flushIntervalId = null;\n    }\n  }\n\n  async getDeviceLoggingId() {\n    if (this.deviceId) return this.deviceId;\n    try {\n      if (typeof chrome !== \"undefined\" && chrome.storage) {\n        const result = await chrome.storage.local.get([DEVICE_ID_STORAGE_KEY]);\n        if (result[DEVICE_ID_STORAGE_KEY]) {\n          this.deviceId = result[DEVICE_ID_STORAGE_KEY];\n          return this.deviceId;\n        }\n      }\n    } catch {}\n    this.deviceId =\n      typeof crypto !== \"undefined\" && crypto.randomUUID ? crypto.randomUUID() : String(Date.now());\n    try {\n      if (typeof chrome !== \"undefined\" && chrome.storage) {\n        await chrome.storage.local.set({ [DEVICE_ID_STORAGE_KEY]: this.deviceId });\n      }\n    } catch {}\n    return this.deviceId;\n  }\n\n  addLog(logEntry) {\n    this.logs.push(logEntry);\n    if (this.logs.length >= this.maxBatchSize) this.flush();\n  }\n\n  shouldLog(requestedLevel) {\n    const configLevel = LOG_LEVEL_MAP[this.config.logLevel] || LOG_LEVEL.INFO;\n\n    // Hierarchical check: request level must be <= config level\n    // If config is INFO (10), only INFO (10) passes\n    // If config is DEBUG (20), INFO (10) and DEBUG (20) pass\n    // If config is ALL (30), everything passes\n    return requestedLevel <= configLevel;\n  }\n\n  emitToConsole(logLevel, message, meta) {\n    const prefix = `[${logLevel}]`;\n    const line = `${prefix} ${message}`;\n    if (meta) {\n      console.log(line, meta);\n    } else {\n      console.log(line);\n    }\n  }\n\n  log({\n    message,\n    logLevel,\n    type,\n    eventType,\n    meta,\n    sessionId,\n    providerId,\n    appId,\n    source,\n    tabId,\n    url,\n  }) {\n    // Validate required fields\n    if (!message || !logLevel) {\n      console.error(\"Logger: message and logLevel are required\");\n      return;\n    }\n\n    // Check if we should log this level\n    if (!this.shouldLog(logLevel)) {\n      return;\n    }\n\n    // Console output\n\n    if (this.config.consoleEnabled) {\n      this.emitToConsole(logLevel, message, meta);\n    }\n\n    // Backend logging\n    const entry = new LogEntry({\n      sessionId: sessionId || \"unknown\",\n      providerId: providerId || \"unknown\",\n      appId: appId || \"unknown\",\n      logLine: message,\n      type,\n      eventType,\n      logLevel,\n      source: source || this.config.source,\n      tabId,\n      url,\n      meta,\n      time: new Date(),\n    });\n    this.addLog(entry);\n  }\n\n  async flush() {\n    if (this.logs.length === 0 || this.isSending) return;\n\n    const logsToSend = [...this.logs];\n    this.logs = [];\n\n    try {\n      this.isSending = true;\n      await this.sendLogs(logsToSend);\n    } catch (error) {\n      console.error(\"Error flushing logs:\", error);\n      this.logs = [...this.logs, ...logsToSend];\n    } finally {\n      this.isSending = false;\n    }\n  }\n\n  async sendLogs(entries) {\n    if (!entries?.length) return;\n\n    const deviceId = await this.getDeviceLoggingId();\n    const formattedLogs = entries.map((e) => {\n      const obj = e.toJson();\n      obj.deviceId = obj.deviceId || deviceId;\n      return obj;\n    });\n\n    const body = JSON.stringify({\n      logs: formattedLogs,\n      source: this.config.source,\n      deviceId,\n    });\n\n    const res = await fetch(LOGGING_ENDPOINTS.DIAGNOSTIC_LOGGING, {\n      method: \"POST\",\n      headers: { \"Content-Type\": \"application/json\" },\n      body,\n    });\n\n    if (!res.ok) {\n      console.error(`Failed to send ${entries.length} logs`, await res.text());\n    }\n  }\n}\n\nexport const loggerService = new LoggerService();\n\n// Create a scoped logger to avoid repeating context\nexport const createContextLogger = (initial = {}) => {\n  const ctx = {\n    sessionId: \"unknown\",\n    providerId: \"unknown\",\n    appId: \"unknown\",\n    source: loggerService.config?.source || \"reclaim-extension-sdk\",\n    ...initial,\n  };\n\n  return {\n    get context() {\n      return { ...ctx };\n    },\n\n    // Update context anytime (partial updates supported)\n    setContext(partial = {}) {\n      Object.assign(ctx, partial);\n    },\n\n    // Main log method - pass object with message, logLevel, and optional fields\n    log(opts) {\n      loggerService.log({ ...ctx, ...opts });\n    },\n\n    // Convenience methods (optional, can be removed if you only want .log())\n    info(opts = {}) {\n      loggerService.log({ ...ctx, logLevel: \"INFO\", ...opts });\n    },\n    debug(opts = {}) {\n      loggerService.log({ ...ctx, logLevel: \"DEBUG\", ...opts });\n    },\n    all(opts = {}) {\n      loggerService.log({ ...ctx, logLevel: \"ALL\", ...opts });\n    },\n    error(opts = {}) {\n      loggerService.log({ ...ctx, logLevel: \"ALL\", ...opts });\n    },\n  };\n};\n","export const LOGGING_ENDPOINTS = {\n  DIAGNOSTIC_LOGGING: \"https://logs.reclaimprotocol.org/api/business-logs/logDump\",\n};\n\nexport const LOG_TYPES = {\n  BACKGROUND: \"reclaim_browser_extension.BackgroundProcess\",\n  CONTENT: \"reclaim_browser_extension.ContentScript\",\n  POPUP: \"reclaim_browser_extension.Popup\",\n  INIT: \"reclaim_browser_extension.Initialization\",\n  VERIFICATION: \"reclaim_browser_extension.Verification\",\n  FETCH_DATA: \"reclaim_browser_extension.FetchData\",\n  PROVIDER_DATA: \"reclaim_browser_extension.ProviderData\",\n  CLAIM_CREATION: \"reclaim_browser_extension.ClaimCreation\",\n  PROOF_GENERATION: \"reclaim_browser_extension.ProofGeneration\",\n  PROOF_SUBMISSION: \"reclaim_browser_extension.ProofSubmission\",\n  PROOF_VERIFICATION: \"reclaim_browser_extension.ProofVerification\",\n  OFFSCREEN: \"reclaim_browser_extension.Offscreen\",\n};\n\nexport const LOG_SOURCES = {\n  BACKGROUND: \"background\",\n  CONTENT: \"content\",\n  OFFSCREEN: \"offscreen\",\n  POPUP: \"popup\",\n  INJECTION: \"injection\",\n};\n\nexport const EVENT_TYPES = {\n  IS_RECLAIM_EXTENSION_SDK: \"IS_RECLAIM_EXTENSION_SDK\",\n  VERIFICATION_FLOW_STARTED: \"VERIFICATION_FLOW_STARTED\",\n  RECLAIM_VERIFICATION_DISMISSED: \"RECLAIM_VERIFICATION_DISMISSED\",\n  RECLAIM_VERIFICATION_PROVIDER_LOAD_EXCEPTION: \"RECLAIM_VERIFICATION_PROVIDER_LOAD_EXCEPTION\",\n  REQUEST_MATCHED: \"REQUEST_MATCHED\",\n  RESPONSE_MATCH_FAILED: \"RESPONSE_MATCH_FAILED\",\n  X_PATH_MATCH_REQUIREMENT_FAILED: \"X_PATH_MATCH_REQUIREMENT_FAILED\",\n  JSON_PATH_MATCH_REQUIREMENT_FAILED: \"JSON_PATH_MATCH_REQUIREMENT_FAILED\",\n  REGEX_MATCH_REQUIREMENT_FAILED: \"REGEX_MATCH_REQUIREMENT_FAILED\",\n  FILTERED_REQUEST_FOUND: \"FILTERED_REQUEST_FOUND\",\n  FILTER_REQUEST_ERROR: \"FILTER_REQUEST_ERROR\",\n  STARTING_CLAIM_CREATION: \"STARTING_CLAIM_CREATION\",\n  CLAIM_CREATION_STARTED: \"CLAIM_CREATION_STARTED\",\n  CLAIM_CREATION_SUCCESS: \"CLAIM_CREATION_SUCCESS\",\n  CLAIM_CREATION_FAILED: \"CLAIM_CREATION_FAILED\",\n  CLAIM_PARAMETER_VALIDATION_FAILED_EXCEPTION: \"CLAIM_PARAMETER_VALIDATION_FAILED_EXCEPTION\",\n  OFFSCREEN_DOCUMENT_READY: \"OFFSCREEN_DOCUMENT_READY\",\n  OFFSCREEN_DOCUMENT_NOT_READY_EXCEPTION: \"OFFSCREEN_DOCUMENT_NOT_READY_EXCEPTION\",\n  PROOF_GENERATION_STARTED: \"PROOF_GENERATION_STARTED\",\n  PROOF_GENERATION_SUCCESS: \"PROOF_GENERATION_SUCCESS\",\n  PROOF_GENERATION_ABORTED: \"PROOF_GENERATION_ABORTED\",\n  PROOF_GENERATION_FAILED: \"PROOF_GENERATION_FAILED\",\n  RESULT_RECEIVED: \"RESULT_RECEIVED\",\n  SUBMITTING_PROOF: \"SUBMITTING_PROOF\",\n  SUBMITTING_PROOF_TO_CALLBACK_URL: \"SUBMITTING_PROOF_TO_CALLBACK_URL\",\n  SUBMITTING_PROOF_TO_CALLBACK_URL_SUCCESS: \"SUBMITTING_PROOF_TO_CALLBACK_URL_SUCCESS\",\n  SUBMITTING_PROOF_TO_CALLBACK_URL_FAILED: \"SUBMITTING_PROOF_TO_CALLBACK_URL_FAILED\",\n  PROOF_SUBMISSION_FAILED: \"PROOF_SUBMISSION_FAILED\",\n  PROOF_SUBMITTED: \"PROOF_SUBMITTED\",\n  VERIFICATION_FLOW_FAILED: \"VERIFICATION_FLOW_FAILED\",\n  TAB_NOT_MANAGED_BY_EXTENSION_EXCEPTION: \"TAB_NOT_MANAGED_BY_EXTENSION_EXCEPTION\",\n  INJECTION_SCRIPT_SET_IN_LOCAL_STORAGE_FAILED: \"INJECTION_SCRIPT_SET_IN_LOCAL_STORAGE_FAILED\",\n  VERIFICATION_POPUP_ERROR: \"VERIFICATION_POPUP_ERROR\",\n  UPDATE_SESSION_STATUS_ERROR: \"UPDATE_SESSION_STATUS_ERROR\",\n};\n\n// Numeric levels for easy threshold checks\nexport const LOG_LEVEL = {\n  INFO: 10,\n  DEBUG: 20,\n  ALL: 30,\n};\n\nexport const LOG_LEVEL_MAP = {\n  INFO: LOG_LEVEL.INFO,\n  DEBUG: LOG_LEVEL.DEBUG,\n  ALL: LOG_LEVEL.ALL,\n};\n\nexport const DEFAULT_LOG_CONFIG = {\n  logLevel: \"INFO\", // \"INFO\" | \"DEBUG\" | \"ALL\" - applies to both console and backend\n  consoleEnabled: false, // Enable/disable console logging\n  source: \"reclaim-extension-sdk\",\n};\n\nexport const LOG_CONFIG_STORAGE_KEY = \"TREX_reclaim_extension_sdk_log_config\";\n\n/** Storage key for device logging id (trex prefix to avoid collision with Reclaim SDK). */\nexport const DEVICE_ID_STORAGE_KEY = \"TREX_reclaim_device_id\";\n","export const BACKEND_URL = \"https://api.reclaimprotocol.org\";\n\n/**\n * Attestor 的 WebSocket 地址：证明生成时 offscreen 里 attestor-core 客户端会连这里，\n * 完成 tunnel → TLS → claim 协议后拿到签名 proof。这是 Reclaim 官方的托管 attestor 服务。\n * 本地联调时改为 \"ws://localhost:8001/ws\" 并先启动 attestor-core。\n * 官方地址：wss://attestor.reclaimprotocol.org/ws\n */\n\nexport const ATTESTOR_WS_URL = \"ws://localhost:8001/ws\";\n\nexport const API_ENDPOINTS = {\n  PROVIDER_URL: (providerId) => `${BACKEND_URL}/api/providers/${providerId}`,\n  SUBMIT_PROOF: (sessionId) => `${BACKEND_URL}/session/${sessionId}/proof`,\n  UPDATE_SESSION_STATUS: () => `${BACKEND_URL}/api/sdk/update/session/`,\n  STATUS_URL: (sessionId) => `${BACKEND_URL}/api/sdk/session/${sessionId}`,\n};\n","/**\n * @typedef {Object} TemplateData\n * @property {string} sessionId - Unique identifier for the session\n * @property {string} providerId - Provider identifier\n * @property {string} applicationId - Application identifier\n * @property {string} signature - Signature for authentication\n * @property {string} timestamp - Timestamp of the request\n * @property {string} callbackUrl - URL to call back after verification\n * @property {string} context - Context data as JSON string\n * @property {Object} parameters - Additional parameters\n * @property {string} redirectUrl - URL to redirect after completion\n * @property {boolean} acceptAiProviders - Whether to accept AI providers\n * @property {string} sdkVersion - SDK version\n * @property {boolean} jsonProofResponse - Whether to return proof as JSON\n */\n\nexport const RECLAIM_SDK_ACTIONS = {\n  CHECK_EXTENSION: \"TREX_RECLAIM_EXTENSION_CHECK\",\n  EXTENSION_RESPONSE: \"TREX_RECLAIM_EXTENSION_RESPONSE\",\n  START_VERIFICATION: \"TREX_RECLAIM_START_VERIFICATION\",\n  VERIFICATION_STARTED: \"TREX_RECLAIM_VERIFICATION_STARTED\",\n  VERIFICATION_COMPLETED: \"TREX_RECLAIM_VERIFICATION_COMPLETED\",\n  VERIFICATION_FAILED: \"TREX_RECLAIM_VERIFICATION_FAILED\",\n  CANCEL_VERIFICATION: \"TREX_RECLAIM_CANCEL_VERIFICATION\",\n  SET_PUBLIC_DATA: \"TREX_RECLAIM_SET_PUBLIC_DATA\",\n  PARAMETERS_UPDATE: \"TREX_RECLAIM_PARAMETERS_UPDATE\",\n  PARAMETERS_GET: \"TREX_RECLAIM_PARAMETERS_GET\",\n  REPORT_PROVIDER_ERROR: \"TREX_RECLAIM_REPORT_PROVIDER_ERROR\",\n  SET_EXPECT_MANY_CLAIMS: \"TREX_RECLAIM_SET_EXPECT_MANY_CLAIMS\",\n  REQUEST_CLAIM: \"TREX_RECLAIM_REQUEST_CLAIM\",\n  SET_LOG_CONFIG: \"TREX_RECLAIM_SET_LOG_CONFIG\",\n};\n\nexport const RECLAIM_SESSION_STATUS = {\n  SESSION_INIT: \"SESSION_INIT\",\n  SESSION_STARTED: \"SESSION_STARTED\",\n  USER_INIT_VERIFICATION: \"USER_INIT_VERIFICATION\",\n  USER_STARTED_VERIFICATION: \"USER_STARTED_VERIFICATION\",\n  PROOF_GENERATION_STARTED: \"PROOF_GENERATION_STARTED\",\n  PROOF_GENERATION_SUCCESS: \"PROOF_GENERATION_SUCCESS\",\n  PROOF_GENERATION_FAILED: \"PROOF_GENERATION_FAILED\",\n  PROOF_SUBMITTED: \"PROOF_SUBMITTED\",\n  PROOF_SUBMISSION_FAILED: \"PROOF_SUBMISSION_FAILED\",\n  PROOF_MANUAL_VERIFICATION_SUBMITED: \"PROOF_MANUAL_VERIFICATION_SUBMITED\",\n};\n\nexport const MESSAGE_SOURCES = {\n  CONTENT_SCRIPT: \"TREX_content-script\",\n  BACKGROUND: \"TREX_background\",\n  OFFSCREEN: \"TREX_offscreen\",\n  INJECTION_SCRIPT: \"TREX_injection-script\",\n};\n\nexport const MESSAGE_ACTIONS = {\n  // Proof generation actions\n  START_VERIFICATION: \"TREX_START_VERIFICATION\",\n  CANCEL_VERIFICATION: \"TREX_CANCEL_VERIFICATION\",\n  GENERATE_PROOF_REQUEST: \"TREX_GENERATE_PROOF_REQUEST\",\n  CLAIM_CREATION_REQUESTED: \"TREX_CLAIM_CREATION_REQUESTED\",\n  CLAIM_CREATION_SUCCESS: \"TREX_CLAIM_CREATION_SUCCESS\",\n  CLAIM_CREATION_FAILED: \"TREX_CLAIM_CREATION_FAILED\",\n  PROOF_GENERATION_STARTED: \"TREX_PROOF_GENERATION_STARTED\",\n  PROOF_GENERATION_SUCCESS: \"TREX_PROOF_GENERATION_SUCCESS\",\n  PROOF_GENERATION_FAILED: \"TREX_PROOF_GENERATION_FAILED\",\n  PROOF_SUBMITTED: \"TREX_PROOF_SUBMITTED\",\n  PROOF_SUBMISSION_FAILED: \"TREX_PROOF_SUBMISSION_FAILED\",\n  GENERATE_PROOF: \"TREX_GENERATE_PROOF\",\n  GENERATED_PROOF_RESPONSE: \"TREX_GENERATED_PROOF_RESPONSE\",\n  GENERATE_CLAIM_ON_ATTESTOR: \"TREX_GENERATE_CLAIM_ON_ATTESTOR\",\n  GET_PRIVATE_KEY: \"TREX_GET_PRIVATE_KEY\",\n  GET_PRIVATE_KEY_RESPONSE: \"TREX_GET_PRIVATE_KEY_RESPONSE\",\n\n  // UI actions\n  SHOW_PROVIDER_VERIFICATION_POPUP: \"TREX_SHOW_PROVIDER_VERIFICATION_POPUP\",\n  OFFSCREEN_DOCUMENT_READY: \"TREX_OFFSCREEN_DOCUMENT_READY\",\n\n  // Offscreen actions\n  GENERATE_PROOF_RESPONSE: \"TREX_GENERATE_PROOF_RESPONSE\",\n  PING_OFFSCREEN: \"TREX_PING_OFFSCREEN\",\n\n  // Background actions\n  CLOSE_CURRENT_TAB: \"TREX_CLOSE_CURRENT_TAB\",\n  GET_CURRENT_TAB_ID: \"TREX_GET_CURRENT_TAB_ID\",\n  // Content script actions\n  REQUEST_PROVIDER_DATA: \"TREX_REQUEST_PROVIDER_DATA\",\n  PROVIDER_DATA_READY: \"TREX_PROVIDER_DATA_READY\",\n  CONTENT_SCRIPT_LOADED: \"TREX_CONTENT_SCRIPT_LOADED\",\n  SHOULD_INITIALIZE: \"TREX_SHOULD_INITIALIZE\",\n  CHECK_IF_MANAGED_TAB: \"TREX_CHECK_IF_MANAGED_TAB\",\n\n  // Interceptor actions\n  FILTERED_REQUEST_FOUND: \"TREX_FILTERED_REQUEST_FOUND\",\n  INTERCEPTED_REQUEST_AND_RESPONSE: \"TREX_INTERCEPTED_REQUEST_AND_RESPONSE\",\n\n  // Injection script actions\n  UPDATE_PUBLIC_DATA: \"TREX_UPDATE_PUBLIC_DATA\",\n  UPDATE_EXPECT_MANY_CLAIMS: \"TREX_UPDATE_EXPECT_MANY_CLAIMS\",\n  GET_PARAMETERS: \"TREX_GET_PARAMETERS\",\n  REPORT_PROVIDER_ERROR: \"TREX_REPORT_PROVIDER_ERROR\",\n  REQUEST_CLAIM: \"TREX_REQUEST_CLAIM\",\n\n  // Injection script actions\n  INJECT_VIA_SCRIPTING: \"TREX_INJECT_VIA_SCRIPTING\",\n\n  // Page ↔ Content/Injection (window.postMessage)\n  GET_PROVIDER_ID: \"TREX_GET_PROVIDER_ID\",\n  PROVIDER_ID_RESPONSE: \"TREX_PROVIDER_ID_RESPONSE\",\n};\n\n/**\n * @typedef {Object} ProviderData\n * @property {string} providerId - Provider ID\n * @property {string} name - Provider name\n * @property {string} description - Provider description\n * @property {string} logoUrl - URL to provider logo\n * @property {boolean} disableRequestReplay - Whether request replay is disabled\n * @property {string} loginUrl - URL to provider login page\n * @property {string} customInjection - Custom injection code\n * @property {boolean} isApproved - Whether provider is approved\n * @property {string} geoLocation - Geo location\n * @property {string} providerType - Provider type\n * @property {boolean} isVerified - Whether provider is verified\n * @property {string} injectionType - Injection type\n * @property {Object} userAgent - User agent info\n * @property {string} userAgent.ios - iOS user agent\n * @property {string} userAgent.android - Android user agent\n * @property {boolean} isActive - Whether provider is active\n * @property {string|null} expectedPageUrl - Expected page URL\n * @property {string|null} pageTitle - Page title\n * @property {string|null} stepsToFollow - Steps to follow\n * @property {number} usedInCount - Number of times used\n * @property {string|null} overseerUid - Overseer UID\n * @property {string|null} overseerNote - Overseer note\n * @property {Array<RequestData>} requestData - Request data\n */\n\n/**\n * @typedef {Object} RequestData\n * @property {string} url - Request URL\n * @property {string} expectedPageUrl - Expected page URL\n * @property {string} urlType - URL type\n * @property {string} method - HTTP method\n * @property {Array<ResponseMatch>} responseMatches - Response matches\n * @property {Array<ResponseRedaction>} responseRedactions - Response redactions\n * @property {BodySniff} bodySniff - Body sniff\n * @property {string} requestHash - Request hash\n * @property {string|null} additionalClientOptions - Additional client options\n */\n\n/**\n * @typedef {Object} ResponseMatch\n * @property {string} value - Match value\n * @property {string} type - Match type\n * @property {boolean} invert - Whether to invert the match\n * @property {string|null} description - Match description\n * @property {number|null} order - Match order\n */\n\n/**\n * @typedef {Object} ResponseRedaction\n * @property {string} xPath - XPath\n * @property {string} jsonPath - JSON path\n * @property {string} regex - Regular expression\n * @property {string} hash - Hash\n */\n\n/**\n * @typedef {Object} BodySniff\n * @property {boolean} enabled - Whether body sniffing is enabled\n * @property {string} template - Body template\n */\n","// Polyfills for browser and service worker environments\nimport { Buffer } from \"buffer\";\nimport process from \"process\";\nimport { debugLogger, DebugLogType } from \"./logger\";\n\n// Skip WebSocket import for content script\n// import { WebSocket } from './websocket-polyfill';\n\n// Define a safe global object that works across environments\nconst getGlobalObject = () => {\n  if (typeof window !== \"undefined\") return window;\n  if (typeof self !== \"undefined\") return self;\n  if (typeof global !== \"undefined\") return global;\n  return Function(\"return this\")();\n};\n\n// Get the global object\nconst global = getGlobalObject();\n\n// Check if we're in a service worker or browser environment\nconst isServiceWorker = typeof window === \"undefined\";\n// Determine if we're in content script context\nconst isContentScript = typeof document !== \"undefined\" && document.contentType !== undefined;\n\n// Make Buffer and process available globally\nglobal.Buffer = global.Buffer || Buffer;\nglobal.process = global.process || process;\n\n// Don't add WebSocket polyfill in content script context\nif (typeof global.WebSocket === \"undefined\" && !isContentScript) {\n  // Dynamically import WebSocket only when needed and not in content script\n  try {\n    const { WebSocket } = require(\"./websocket-polyfill\");\n    global.WebSocket = WebSocket;\n    debugLogger.info(DebugLogType.POLYFILLS, \"WebSocket polyfill added to global\");\n  } catch (e) {\n    debugLogger.warn(DebugLogType.POLYFILLS, \"Failed to load WebSocket polyfill:\", e);\n  }\n} else {\n  if (!isContentScript) {\n    debugLogger.info(DebugLogType.POLYFILLS, \"Using native WebSocket implementation\");\n  } else {\n    debugLogger.info(DebugLogType.POLYFILLS, \"Skipping WebSocket in content script context\");\n  }\n}\n\n// Force browser mode for Node.js compatibility\nif (global.process) {\n  global.process.browser = true;\n}\n\n// Handle Node.js-style require for libraries expecting WebSocket\nif (typeof global.require !== \"function\") {\n  global.require = (moduleName) => {\n    // Return mock implementations for common modules\n    switch (moduleName) {\n      case \"ws\":\n        // Don't return WebSocket in content script context\n        if (isContentScript) {\n          debugLogger.info(DebugLogType.POLYFILLS, \"Blocking ws module in content script\");\n          return {}; // Empty implementation for content script\n        }\n        try {\n          const { WebSocket } = require(\"./websocket-polyfill\");\n          return { WebSocket }; // Return our polyfill for ws\n        } catch (e) {\n          debugLogger.warn(DebugLogType.POLYFILLS, \"Failed to load WebSocket for ws module:\", e);\n          return {};\n        }\n      case \"fs\":\n        return global.fs;\n      case \"path\":\n        return global.path;\n      case \"os\":\n        return global.os;\n      case \"crypto\":\n        return global.crypto;\n      case \"worker_threads\":\n        return {}; // Empty implementation\n      case \"koffi\":\n      case \"re2\":\n        return {}; // Empty implementation\n      default:\n        console.warn(`Mock require called for module: ${moduleName}`);\n        return {};\n    }\n  };\n} else {\n  // Don't override require if it's already defined\n  const originalRequire = global.require;\n  global.require = (moduleName) => {\n    if (moduleName === \"ws\") {\n      // Don't return WebSocket in content script context\n      if (isContentScript) {\n        debugLogger.info(DebugLogType.POLYFILLS, \"Blocking ws module in content script\");\n        return {}; // Empty implementation for content script\n      }\n      try {\n        const { WebSocket } = require(\"./websocket-polyfill\");\n        return { WebSocket }; // Return our polyfill for ws\n      } catch (e) {\n        debugLogger.warn(DebugLogType.POLYFILLS, \"Failed to load WebSocket for ws module:\", e);\n        return {};\n      }\n    }\n    try {\n      return originalRequire(moduleName);\n    } catch (e) {\n      debugLogger.warn(DebugLogType.POLYFILLS, `Failed to require module: ${moduleName}`);\n      return {};\n    }\n  };\n}\n\n// Fix for snarkjs which tries to access process.browser\nif (typeof process !== \"undefined\") {\n  process.browser = true;\n\n  // Add missing process properties that some modules might need\n  if (!process.version) process.version = \"v16.0.0\"; // Mock Node.js version\n  if (!process.cwd) process.cwd = () => \"/\"; // Mock current working directory\n}\n\n// TextEncoder and TextDecoder are available in both browser and service worker\n// if (typeof global.TextEncoder === \"undefined\" && !isServiceWorker) {\n//   const encoding = require(\"text-encoding\");\n//   global.TextEncoder = encoding.TextEncoder;\n//   global.TextDecoder = encoding.TextDecoder;\n// }\n\n// Handle other Node.js-specific functionality\nif (typeof global.global === \"undefined\") {\n  global.global = global;\n}\n\n// Handle crypto.getRandomValues polyfill if needed\nif (typeof global.crypto === \"undefined\") {\n  global.crypto = {};\n}\n\nif (typeof global.crypto.getRandomValues === \"undefined\") {\n  global.crypto.getRandomValues = function (arr) {\n    const bytes = new Uint8Array(arr.length);\n    for (let i = 0; i < bytes.length; i++) {\n      bytes[i] = Math.floor(Math.random() * 256);\n    }\n    return bytes;\n  };\n}\n\n// Handle other potential missing WebCrypto APIs\nif (typeof global.crypto.subtle === \"undefined\") {\n  debugLogger.warn(\n    DebugLogType.POLYFILLS,\n    \"WebCrypto subtle API not available. Some functionality may not work.\",\n  );\n  // Create a minimal fallback for subtle crypto\n  global.crypto.subtle = {\n    digest: async (algorithm, data) => {\n      debugLogger.warn(\n        DebugLogType.POLYFILLS,\n        `Crypto subtle digest (${algorithm}) called with browser fallback`,\n      );\n      // This is just a minimal fallback - not secure for production\n      const hashInt = Array.from(new Uint8Array(data)).reduce(\n        (acc, val) => (acc * 31 + val) & 0xffffffff,\n        0,\n      );\n\n      // Convert to a byte array of appropriate length\n      const result = new Uint8Array(32); // SHA-256 length\n      for (let i = 0; i < 32; i++) {\n        result[i] = (hashInt >> (i * 8)) & 0xff;\n      }\n\n      return result.buffer;\n    },\n  };\n}\n\n// Only add browser-specific polyfills if we're in a browser\nif (!isServiceWorker) {\n  // Mock for Node.js domain module that attestor-core might use\n  if (typeof global.domain === \"undefined\") {\n    global.domain = {\n      create: () => ({\n        run: (fn) => fn(),\n        on: () => {\n          /* Empty function implementation */\n        },\n        bind: (fn) => fn,\n      }),\n    };\n  }\n\n  // Override URL constructor to handle node:url protocol\n  const OriginalURL = global.URL;\n  function CustomURL(url, base) {\n    // Handle node:url protocol\n    if (typeof url === \"string\" && url.startsWith(\"node:\")) {\n      url = url.replace(/^node:/, \"\");\n    }\n    return new OriginalURL(url, base);\n  }\n\n  // Copy prototype and static methods safely\n  CustomURL.prototype = OriginalURL.prototype;\n  try {\n    // Try to copy static properties, but don't fail if they're read-only\n    Object.getOwnPropertyNames(OriginalURL).forEach((prop) => {\n      if (prop !== \"prototype\" && prop !== \"constructor\") {\n        try {\n          CustomURL[prop] = OriginalURL[prop];\n        } catch (e) {\n          // Silently ignore errors for read-only properties\n        }\n      }\n    });\n  } catch (e) {\n    debugLogger.warn(DebugLogType.POLYFILLS, \"Could not copy all URL static properties:\", e);\n  }\n\n  // Set the global URL to our custom implementation\n  try {\n    global.URL = CustomURL;\n  } catch (e) {\n    debugLogger.warn(DebugLogType.POLYFILLS, \"Could not override URL constructor:\", e);\n    // If we can't override the URL constructor, we'll have to live with the original\n  }\n}\n\n// Mock for Node.js module.require which some libraries might use\nif (typeof global.module === \"undefined\") {\n  global.module = { exports: {} };\n}\n\n// Add missing fs functions that might be needed\nglobal.fs = global.fs || {\n  readFileSync: (path) => {\n    debugLogger.warn(DebugLogType.POLYFILLS, `Attempted to readFileSync: ${path}`);\n    throw new Error(\"fs.readFileSync is not available in this environment\");\n  },\n  writeFileSync: (path, data) => {\n    debugLogger.warn(DebugLogType.POLYFILLS, `Attempted to writeFileSync: ${path}`);\n    // No-op\n  },\n  existsSync: (path) => {\n    debugLogger.warn(DebugLogType.POLYFILLS, `Attempted to check if file exists: ${path}`);\n    return false;\n  },\n  promises: {\n    readFile: async (path) => {\n      debugLogger.warn(DebugLogType.POLYFILLS, `Attempted to readFile: ${path}`);\n      throw new Error(\"fs.promises.readFile is not available in this environment\");\n    },\n    writeFile: async (path, data) => {\n      debugLogger.warn(DebugLogType.POLYFILLS, `Attempted to writeFile: ${path}`);\n      // No-op\n    },\n  },\n};\n\n// Add missing os functions\nglobal.os = global.os || {\n  tmpdir: () => \"/tmp\",\n  homedir: () => \"/home/user\",\n  platform: () => \"browser\",\n  type: () => \"Browser\",\n  cpus: () => [{ model: \"Browser CPU\", speed: 1000 }],\n  totalmem: () => 8 * 1024 * 1024 * 1024, // 8GB\n  freemem: () => 4 * 1024 * 1024 * 1024, // 4GB\n};\n\n// Ensure path methods are available\nglobal.path = global.path || {\n  join: (...args) => args.join(\"/\").replace(/\\/+/g, \"/\"),\n  resolve: (...args) => args.join(\"/\").replace(/\\/+/g, \"/\"),\n  dirname: (path) => path.split(\"/\").slice(0, -1).join(\"/\") || \".\",\n  basename: (path, ext) => {\n    let base = path.split(\"/\").pop() || \"\";\n    if (ext && base.endsWith(ext)) {\n      base = base.slice(0, -ext.length);\n    }\n    return base;\n  },\n  extname: (path) => {\n    const base = path.split(\"/\").pop() || \"\";\n    const dotIndex = base.lastIndexOf(\".\");\n    return dotIndex < 0 ? \"\" : base.slice(dotIndex);\n  },\n  sep: \"/\",\n};\n\n// Export for module imports\nexport default {\n  Buffer,\n  process,\n};\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\tid: moduleId,\n\t\tloaded: false,\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Flag the module as loaded\n\tmodule.loaded = true;\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.hmd = (module) => {\n\tmodule = Object.create(module);\n\tif (!module.children) module.children = [];\n\tObject.defineProperty(module, 'exports', {\n\t\tenumerable: true,\n\t\tset: () => {\n\t\t\tthrow new Error('ES Modules may not assign module.exports or exports.*, Use ESM export syntax, instead: ' + module.id);\n\t\t}\n\t});\n\treturn module;\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","function number(n) {\n    if (!Number.isSafeInteger(n) || n < 0)\n        throw new Error(`Wrong positive integer: ${n}`);\n}\nfunction bool(b) {\n    if (typeof b !== 'boolean')\n        throw new Error(`Expected boolean, not ${b}`);\n}\nfunction bytes(b, ...lengths) {\n    if (!(b instanceof Uint8Array))\n        throw new Error('Expected Uint8Array');\n    if (lengths.length > 0 && !lengths.includes(b.length))\n        throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);\n}\nfunction hash(hash) {\n    if (typeof hash !== 'function' || typeof hash.create !== 'function')\n        throw new Error('Hash should be wrapped by utils.wrapConstructor');\n    number(hash.outputLen);\n    number(hash.blockLen);\n}\nfunction exists(instance, checkFinished = true) {\n    if (instance.destroyed)\n        throw new Error('Hash instance has been destroyed');\n    if (checkFinished && instance.finished)\n        throw new Error('Hash#digest() has already been called');\n}\nfunction output(out, instance) {\n    bytes(out);\n    const min = instance.outputLen;\n    if (out.length < min) {\n        throw new Error(`digestInto() expects output buffer of length at least ${min}`);\n    }\n}\nexport { number, bool, bytes, hash, exists, output };\nconst assert = { number, bool, bytes, hash, exists, output };\nexport default assert;\n//# sourceMappingURL=_assert.js.map","const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);\nconst _32n = /* @__PURE__ */ BigInt(32);\n// We are not using BigUint64Array, because they are extremely slow as per 2022\nfunction fromBig(n, le = false) {\n    if (le)\n        return { h: Number(n & U32_MASK64), l: Number((n >> _32n) & U32_MASK64) };\n    return { h: Number((n >> _32n) & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };\n}\nfunction split(lst, le = false) {\n    let Ah = new Uint32Array(lst.length);\n    let Al = new Uint32Array(lst.length);\n    for (let i = 0; i < lst.length; i++) {\n        const { h, l } = fromBig(lst[i], le);\n        [Ah[i], Al[i]] = [h, l];\n    }\n    return [Ah, Al];\n}\nconst toBig = (h, l) => (BigInt(h >>> 0) << _32n) | BigInt(l >>> 0);\n// for Shift in [0, 32)\nconst shrSH = (h, _l, s) => h >>> s;\nconst shrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);\n// Right rotate for Shift in [1, 32)\nconst rotrSH = (h, l, s) => (h >>> s) | (l << (32 - s));\nconst rotrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);\n// Right rotate for Shift in (32, 64), NOTE: 32 is special case.\nconst rotrBH = (h, l, s) => (h << (64 - s)) | (l >>> (s - 32));\nconst rotrBL = (h, l, s) => (h >>> (s - 32)) | (l << (64 - s));\n// Right rotate for shift===32 (just swaps l&h)\nconst rotr32H = (_h, l) => l;\nconst rotr32L = (h, _l) => h;\n// Left rotate for Shift in [1, 32)\nconst rotlSH = (h, l, s) => (h << s) | (l >>> (32 - s));\nconst rotlSL = (h, l, s) => (l << s) | (h >>> (32 - s));\n// Left rotate for Shift in (32, 64), NOTE: 32 is special case.\nconst rotlBH = (h, l, s) => (l << (s - 32)) | (h >>> (64 - s));\nconst rotlBL = (h, l, s) => (h << (s - 32)) | (l >>> (64 - s));\n// JS uses 32-bit signed integers for bitwise operations which means we cannot\n// simple take carry out of low bit sum by shift, we need to use division.\nfunction add(Ah, Al, Bh, Bl) {\n    const l = (Al >>> 0) + (Bl >>> 0);\n    return { h: (Ah + Bh + ((l / 2 ** 32) | 0)) | 0, l: l | 0 };\n}\n// Addition with more than 2 elements\nconst add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);\nconst add3H = (low, Ah, Bh, Ch) => (Ah + Bh + Ch + ((low / 2 ** 32) | 0)) | 0;\nconst add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);\nconst add4H = (low, Ah, Bh, Ch, Dh) => (Ah + Bh + Ch + Dh + ((low / 2 ** 32) | 0)) | 0;\nconst add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);\nconst add5H = (low, Ah, Bh, Ch, Dh, Eh) => (Ah + Bh + Ch + Dh + Eh + ((low / 2 ** 32) | 0)) | 0;\n// prettier-ignore\nexport { fromBig, split, toBig, shrSH, shrSL, rotrSH, rotrSL, rotrBH, rotrBL, rotr32H, rotr32L, rotlSH, rotlSL, rotlBH, rotlBL, add, add3L, add3H, add4L, add4H, add5H, add5L, };\n// prettier-ignore\nconst u64 = {\n    fromBig, split, toBig,\n    shrSH, shrSL,\n    rotrSH, rotrSL, rotrBH, rotrBL,\n    rotr32H, rotr32L,\n    rotlSH, rotlSL, rotlBH, rotlBL,\n    add, add3L, add3H, add4L, add4H, add5H, add5L,\n};\nexport default u64;\n//# sourceMappingURL=_u64.js.map","export const crypto = typeof globalThis === 'object' && 'crypto' in globalThis ? globalThis.crypto : undefined;\n//# sourceMappingURL=crypto.js.map","/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.\n// node.js versions earlier than v19 don't declare it in global scope.\n// For node.js, package.json#exports field mapping rewrites import\n// from `crypto` to `cryptoNode`, which imports native module.\n// Makes the utils un-importable in browsers without a bundler.\n// Once node.js 18 is deprecated, we can just drop the import.\nimport { crypto } from '@noble/hashes/crypto';\nconst u8a = (a) => a instanceof Uint8Array;\n// Cast array to different type\nexport const u8 = (arr) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\nexport const u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));\n// Cast array to view\nexport const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\n// The rotate right (circular right shift) operation for uint32\nexport const rotr = (word, shift) => (word << (32 - shift)) | (word >>> shift);\n// big-endian hardware is rare. Just in case someone still decides to run hashes:\n// early-throw an error because we don't support BE yet.\nexport const isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;\nif (!isLE)\n    throw new Error('Non little-endian hardware is not supported');\nconst hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));\n/**\n * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'\n */\nexport function bytesToHex(bytes) {\n    if (!u8a(bytes))\n        throw new Error('Uint8Array expected');\n    // pre-caching improves the speed 6x\n    let hex = '';\n    for (let i = 0; i < bytes.length; i++) {\n        hex += hexes[bytes[i]];\n    }\n    return hex;\n}\n/**\n * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])\n */\nexport function hexToBytes(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    const len = hex.length;\n    if (len % 2)\n        throw new Error('padded hex string expected, got unpadded hex of length ' + len);\n    const array = new Uint8Array(len / 2);\n    for (let i = 0; i < array.length; i++) {\n        const j = i * 2;\n        const hexByte = hex.slice(j, j + 2);\n        const byte = Number.parseInt(hexByte, 16);\n        if (Number.isNaN(byte) || byte < 0)\n            throw new Error('Invalid byte sequence');\n        array[i] = byte;\n    }\n    return array;\n}\n// There is no setImmediate in browser and setTimeout is slow.\n// call of async fn will return Promise, which will be fullfiled only on\n// next scheduler queue processing step and this is exactly what we need.\nexport const nextTick = async () => { };\n// Returns control to thread each 'tick' ms to avoid blocking\nexport async function asyncLoop(iters, tick, cb) {\n    let ts = Date.now();\n    for (let i = 0; i < iters; i++) {\n        cb(i);\n        // Date.now() is not monotonic, so in case if clock goes backwards we return return control too\n        const diff = Date.now() - ts;\n        if (diff >= 0 && diff < tick)\n            continue;\n        await nextTick();\n        ts += diff;\n    }\n}\n/**\n * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])\n */\nexport function utf8ToBytes(str) {\n    if (typeof str !== 'string')\n        throw new Error(`utf8ToBytes expected string, got ${typeof str}`);\n    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n/**\n * Normalizes (non-hex) string or Uint8Array to Uint8Array.\n * Warning: when Uint8Array is passed, it would NOT get copied.\n * Keep in mind for future mutable operations.\n */\nexport function toBytes(data) {\n    if (typeof data === 'string')\n        data = utf8ToBytes(data);\n    if (!u8a(data))\n        throw new Error(`expected Uint8Array, got ${typeof data}`);\n    return data;\n}\n/**\n * Copies several Uint8Arrays into one.\n */\nexport function concatBytes(...arrays) {\n    const r = new Uint8Array(arrays.reduce((sum, a) => sum + a.length, 0));\n    let pad = 0; // walk through each item, ensure they have proper type\n    arrays.forEach((a) => {\n        if (!u8a(a))\n            throw new Error('Uint8Array expected');\n        r.set(a, pad);\n        pad += a.length;\n    });\n    return r;\n}\n// For runtime check if class implements interface\nexport class Hash {\n    // Safe version that clones internal state\n    clone() {\n        return this._cloneInto();\n    }\n}\nconst toStr = {}.toString;\nexport function checkOpts(defaults, opts) {\n    if (opts !== undefined && toStr.call(opts) !== '[object Object]')\n        throw new Error('Options should be object or undefined');\n    const merged = Object.assign(defaults, opts);\n    return merged;\n}\nexport function wrapConstructor(hashCons) {\n    const hashC = (msg) => hashCons().update(toBytes(msg)).digest();\n    const tmp = hashCons();\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = () => hashCons();\n    return hashC;\n}\nexport function wrapConstructorWithOpts(hashCons) {\n    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\n    const tmp = hashCons({});\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = (opts) => hashCons(opts);\n    return hashC;\n}\nexport function wrapXOFConstructorWithOpts(hashCons) {\n    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\n    const tmp = hashCons({});\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = (opts) => hashCons(opts);\n    return hashC;\n}\n/**\n * Secure PRNG. Uses `crypto.getRandomValues`, which defers to OS.\n */\nexport function randomBytes(bytesLength = 32) {\n    if (crypto && typeof crypto.getRandomValues === 'function') {\n        return crypto.getRandomValues(new Uint8Array(bytesLength));\n    }\n    throw new Error('crypto.getRandomValues must be defined');\n}\n//# sourceMappingURL=utils.js.map","import { bytes, exists, number, output } from './_assert.js';\nimport { rotlBH, rotlBL, rotlSH, rotlSL, split } from './_u64.js';\nimport { Hash, u32, toBytes, wrapConstructor, wrapXOFConstructorWithOpts, } from './utils.js';\n// SHA3 (keccak) is based on a new design: basically, the internal state is bigger than output size.\n// It's called a sponge function.\n// Various per round constants calculations\nconst [SHA3_PI, SHA3_ROTL, _SHA3_IOTA] = [[], [], []];\nconst _0n = /* @__PURE__ */ BigInt(0);\nconst _1n = /* @__PURE__ */ BigInt(1);\nconst _2n = /* @__PURE__ */ BigInt(2);\nconst _7n = /* @__PURE__ */ BigInt(7);\nconst _256n = /* @__PURE__ */ BigInt(256);\nconst _0x71n = /* @__PURE__ */ BigInt(0x71);\nfor (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {\n    // Pi\n    [x, y] = [y, (2 * x + 3 * y) % 5];\n    SHA3_PI.push(2 * (5 * y + x));\n    // Rotational\n    SHA3_ROTL.push((((round + 1) * (round + 2)) / 2) % 64);\n    // Iota\n    let t = _0n;\n    for (let j = 0; j < 7; j++) {\n        R = ((R << _1n) ^ ((R >> _7n) * _0x71n)) % _256n;\n        if (R & _2n)\n            t ^= _1n << ((_1n << /* @__PURE__ */ BigInt(j)) - _1n);\n    }\n    _SHA3_IOTA.push(t);\n}\nconst [SHA3_IOTA_H, SHA3_IOTA_L] = /* @__PURE__ */ split(_SHA3_IOTA, true);\n// Left rotation (without 0, 32, 64)\nconst rotlH = (h, l, s) => (s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s));\nconst rotlL = (h, l, s) => (s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s));\n// Same as keccakf1600, but allows to skip some rounds\nexport function keccakP(s, rounds = 24) {\n    const B = new Uint32Array(5 * 2);\n    // NOTE: all indices are x2 since we store state as u32 instead of u64 (bigints to slow in js)\n    for (let round = 24 - rounds; round < 24; round++) {\n        // Theta θ\n        for (let x = 0; x < 10; x++)\n            B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];\n        for (let x = 0; x < 10; x += 2) {\n            const idx1 = (x + 8) % 10;\n            const idx0 = (x + 2) % 10;\n            const B0 = B[idx0];\n            const B1 = B[idx0 + 1];\n            const Th = rotlH(B0, B1, 1) ^ B[idx1];\n            const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];\n            for (let y = 0; y < 50; y += 10) {\n                s[x + y] ^= Th;\n                s[x + y + 1] ^= Tl;\n            }\n        }\n        // Rho (ρ) and Pi (π)\n        let curH = s[2];\n        let curL = s[3];\n        for (let t = 0; t < 24; t++) {\n            const shift = SHA3_ROTL[t];\n            const Th = rotlH(curH, curL, shift);\n            const Tl = rotlL(curH, curL, shift);\n            const PI = SHA3_PI[t];\n            curH = s[PI];\n            curL = s[PI + 1];\n            s[PI] = Th;\n            s[PI + 1] = Tl;\n        }\n        // Chi (χ)\n        for (let y = 0; y < 50; y += 10) {\n            for (let x = 0; x < 10; x++)\n                B[x] = s[y + x];\n            for (let x = 0; x < 10; x++)\n                s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];\n        }\n        // Iota (ι)\n        s[0] ^= SHA3_IOTA_H[round];\n        s[1] ^= SHA3_IOTA_L[round];\n    }\n    B.fill(0);\n}\nexport class Keccak extends Hash {\n    // NOTE: we accept arguments in bytes instead of bits here.\n    constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {\n        super();\n        this.blockLen = blockLen;\n        this.suffix = suffix;\n        this.outputLen = outputLen;\n        this.enableXOF = enableXOF;\n        this.rounds = rounds;\n        this.pos = 0;\n        this.posOut = 0;\n        this.finished = false;\n        this.destroyed = false;\n        // Can be passed from user as dkLen\n        number(outputLen);\n        // 1600 = 5x5 matrix of 64bit.  1600 bits === 200 bytes\n        if (0 >= this.blockLen || this.blockLen >= 200)\n            throw new Error('Sha3 supports only keccak-f1600 function');\n        this.state = new Uint8Array(200);\n        this.state32 = u32(this.state);\n    }\n    keccak() {\n        keccakP(this.state32, this.rounds);\n        this.posOut = 0;\n        this.pos = 0;\n    }\n    update(data) {\n        exists(this);\n        const { blockLen, state } = this;\n        data = toBytes(data);\n        const len = data.length;\n        for (let pos = 0; pos < len;) {\n            const take = Math.min(blockLen - this.pos, len - pos);\n            for (let i = 0; i < take; i++)\n                state[this.pos++] ^= data[pos++];\n            if (this.pos === blockLen)\n                this.keccak();\n        }\n        return this;\n    }\n    finish() {\n        if (this.finished)\n            return;\n        this.finished = true;\n        const { state, suffix, pos, blockLen } = this;\n        // Do the padding\n        state[pos] ^= suffix;\n        if ((suffix & 0x80) !== 0 && pos === blockLen - 1)\n            this.keccak();\n        state[blockLen - 1] ^= 0x80;\n        this.keccak();\n    }\n    writeInto(out) {\n        exists(this, false);\n        bytes(out);\n        this.finish();\n        const bufferOut = this.state;\n        const { blockLen } = this;\n        for (let pos = 0, len = out.length; pos < len;) {\n            if (this.posOut >= blockLen)\n                this.keccak();\n            const take = Math.min(blockLen - this.posOut, len - pos);\n            out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);\n            this.posOut += take;\n            pos += take;\n        }\n        return out;\n    }\n    xofInto(out) {\n        // Sha3/Keccak usage with XOF is probably mistake, only SHAKE instances can do XOF\n        if (!this.enableXOF)\n            throw new Error('XOF is not possible for this instance');\n        return this.writeInto(out);\n    }\n    xof(bytes) {\n        number(bytes);\n        return this.xofInto(new Uint8Array(bytes));\n    }\n    digestInto(out) {\n        output(out, this);\n        if (this.finished)\n            throw new Error('digest() was already called');\n        this.writeInto(out);\n        this.destroy();\n        return out;\n    }\n    digest() {\n        return this.digestInto(new Uint8Array(this.outputLen));\n    }\n    destroy() {\n        this.destroyed = true;\n        this.state.fill(0);\n    }\n    _cloneInto(to) {\n        const { blockLen, suffix, outputLen, rounds, enableXOF } = this;\n        to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, rounds));\n        to.state32.set(this.state32);\n        to.pos = this.pos;\n        to.posOut = this.posOut;\n        to.finished = this.finished;\n        to.rounds = rounds;\n        // Suffix can change in cSHAKE\n        to.suffix = suffix;\n        to.outputLen = outputLen;\n        to.enableXOF = enableXOF;\n        to.destroyed = this.destroyed;\n        return to;\n    }\n}\nconst gen = (suffix, blockLen, outputLen) => wrapConstructor(() => new Keccak(blockLen, suffix, outputLen));\nexport const sha3_224 = /* @__PURE__ */ gen(0x06, 144, 224 / 8);\n/**\n * SHA3-256 hash function\n * @param message - that would be hashed\n */\nexport const sha3_256 = /* @__PURE__ */ gen(0x06, 136, 256 / 8);\nexport const sha3_384 = /* @__PURE__ */ gen(0x06, 104, 384 / 8);\nexport const sha3_512 = /* @__PURE__ */ gen(0x06, 72, 512 / 8);\nexport const keccak_224 = /* @__PURE__ */ gen(0x01, 144, 224 / 8);\n/**\n * keccak-256 hash function. Different from SHA3-256.\n * @param message - that would be hashed\n */\nexport const keccak_256 = /* @__PURE__ */ gen(0x01, 136, 256 / 8);\nexport const keccak_384 = /* @__PURE__ */ gen(0x01, 104, 384 / 8);\nexport const keccak_512 = /* @__PURE__ */ gen(0x01, 72, 512 / 8);\nconst genShake = (suffix, blockLen, outputLen) => wrapXOFConstructorWithOpts((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === undefined ? outputLen : opts.dkLen, true));\nexport const shake128 = /* @__PURE__ */ genShake(0x1f, 168, 128 / 8);\nexport const shake256 = /* @__PURE__ */ genShake(0x1f, 136, 256 / 8);\n//# sourceMappingURL=sha3.js.map","/* Do NOT modify this file; see /src.ts/_admin/update-version.ts */\n/**\n *  The current version of Ethers.\n */\nexport const version = \"6.15.0\";\n//# sourceMappingURL=_version.js.map","/**\n *  Property helper functions.\n *\n *  @_subsection api/utils:Properties  [about-properties]\n */\nfunction checkType(value, type, name) {\n    const types = type.split(\"|\").map(t => t.trim());\n    for (let i = 0; i < types.length; i++) {\n        switch (type) {\n            case \"any\":\n                return;\n            case \"bigint\":\n            case \"boolean\":\n            case \"number\":\n            case \"string\":\n                if (typeof (value) === type) {\n                    return;\n                }\n        }\n    }\n    const error = new Error(`invalid value for type ${type}`);\n    error.code = \"INVALID_ARGUMENT\";\n    error.argument = `value.${name}`;\n    error.value = value;\n    throw error;\n}\n/**\n *  Resolves to a new object that is a copy of %%value%%, but with all\n *  values resolved.\n */\nexport async function resolveProperties(value) {\n    const keys = Object.keys(value);\n    const results = await Promise.all(keys.map((k) => Promise.resolve(value[k])));\n    return results.reduce((accum, v, index) => {\n        accum[keys[index]] = v;\n        return accum;\n    }, {});\n}\n/**\n *  Assigns the %%values%% to %%target%% as read-only values.\n *\n *  It %%types%% is specified, the values are checked.\n */\nexport function defineProperties(target, values, types) {\n    for (let key in values) {\n        let value = values[key];\n        const type = (types ? types[key] : null);\n        if (type) {\n            checkType(value, type, key);\n        }\n        Object.defineProperty(target, key, { enumerable: true, value, writable: false });\n    }\n}\n//# sourceMappingURL=properties.js.map","/**\n *  All errors in ethers include properties to ensure they are both\n *  human-readable (i.e. ``.message``) and machine-readable (i.e. ``.code``).\n *\n *  The [[isError]] function can be used to check the error ``code`` and\n *  provide a type guard for the properties present on that error interface.\n *\n *  @_section: api/utils/errors:Errors  [about-errors]\n */\nimport { version } from \"../_version.js\";\nimport { defineProperties } from \"./properties.js\";\nfunction stringify(value, seen) {\n    if (value == null) {\n        return \"null\";\n    }\n    if (seen == null) {\n        seen = new Set();\n    }\n    if (typeof (value) === \"object\") {\n        if (seen.has(value)) {\n            return \"[Circular]\";\n        }\n        seen.add(value);\n    }\n    if (Array.isArray(value)) {\n        return \"[ \" + (value.map((v) => stringify(v, seen))).join(\", \") + \" ]\";\n    }\n    if (value instanceof Uint8Array) {\n        const HEX = \"0123456789abcdef\";\n        let result = \"0x\";\n        for (let i = 0; i < value.length; i++) {\n            result += HEX[value[i] >> 4];\n            result += HEX[value[i] & 0xf];\n        }\n        return result;\n    }\n    if (typeof (value) === \"object\" && typeof (value.toJSON) === \"function\") {\n        return stringify(value.toJSON(), seen);\n    }\n    switch (typeof (value)) {\n        case \"boolean\":\n        case \"number\":\n        case \"symbol\":\n            return value.toString();\n        case \"bigint\":\n            return BigInt(value).toString();\n        case \"string\":\n            return JSON.stringify(value);\n        case \"object\": {\n            const keys = Object.keys(value);\n            keys.sort();\n            return \"{ \" + keys.map((k) => `${stringify(k, seen)}: ${stringify(value[k], seen)}`).join(\", \") + \" }\";\n        }\n    }\n    return `[ COULD NOT SERIALIZE ]`;\n}\n/**\n *  Returns true if the %%error%% matches an error thrown by ethers\n *  that matches the error %%code%%.\n *\n *  In TypeScript environments, this can be used to check that %%error%%\n *  matches an EthersError type, which means the expected properties will\n *  be set.\n *\n *  @See [ErrorCodes](api:ErrorCode)\n *  @example\n *    try {\n *      // code....\n *    } catch (e) {\n *      if (isError(e, \"CALL_EXCEPTION\")) {\n *          // The Type Guard has validated this object\n *          console.log(e.data);\n *      }\n *    }\n */\nexport function isError(error, code) {\n    return (error && error.code === code);\n}\n/**\n *  Returns true if %%error%% is a [[CallExceptionError].\n */\nexport function isCallException(error) {\n    return isError(error, \"CALL_EXCEPTION\");\n}\n/**\n *  Returns a new Error configured to the format ethers emits errors, with\n *  the %%message%%, [[api:ErrorCode]] %%code%% and additional properties\n *  for the corresponding EthersError.\n *\n *  Each error in ethers includes the version of ethers, a\n *  machine-readable [[ErrorCode]], and depending on %%code%%, additional\n *  required properties. The error message will also include the %%message%%,\n *  ethers version, %%code%% and all additional properties, serialized.\n */\nexport function makeError(message, code, info) {\n    let shortMessage = message;\n    {\n        const details = [];\n        if (info) {\n            if (\"message\" in info || \"code\" in info || \"name\" in info) {\n                throw new Error(`value will overwrite populated values: ${stringify(info)}`);\n            }\n            for (const key in info) {\n                if (key === \"shortMessage\") {\n                    continue;\n                }\n                const value = (info[key]);\n                //                try {\n                details.push(key + \"=\" + stringify(value));\n                //                } catch (error: any) {\n                //                console.log(\"MMM\", error.message);\n                //                    details.push(key + \"=[could not serialize object]\");\n                //                }\n            }\n        }\n        details.push(`code=${code}`);\n        details.push(`version=${version}`);\n        if (details.length) {\n            message += \" (\" + details.join(\", \") + \")\";\n        }\n    }\n    let error;\n    switch (code) {\n        case \"INVALID_ARGUMENT\":\n            error = new TypeError(message);\n            break;\n        case \"NUMERIC_FAULT\":\n        case \"BUFFER_OVERRUN\":\n            error = new RangeError(message);\n            break;\n        default:\n            error = new Error(message);\n    }\n    defineProperties(error, { code });\n    if (info) {\n        Object.assign(error, info);\n    }\n    if (error.shortMessage == null) {\n        defineProperties(error, { shortMessage });\n    }\n    return error;\n}\n/**\n *  Throws an EthersError with %%message%%, %%code%% and additional error\n *  %%info%% when %%check%% is falsish..\n *\n *  @see [[api:makeError]]\n */\nexport function assert(check, message, code, info) {\n    if (!check) {\n        throw makeError(message, code, info);\n    }\n}\n/**\n *  A simple helper to simply ensuring provided arguments match expected\n *  constraints, throwing if not.\n *\n *  In TypeScript environments, the %%check%% has been asserted true, so\n *  any further code does not need additional compile-time checks.\n */\nexport function assertArgument(check, message, name, value) {\n    assert(check, message, \"INVALID_ARGUMENT\", { argument: name, value: value });\n}\nexport function assertArgumentCount(count, expectedCount, message) {\n    if (message == null) {\n        message = \"\";\n    }\n    if (message) {\n        message = \": \" + message;\n    }\n    assert(count >= expectedCount, \"missing argument\" + message, \"MISSING_ARGUMENT\", {\n        count: count,\n        expectedCount: expectedCount\n    });\n    assert(count <= expectedCount, \"too many arguments\" + message, \"UNEXPECTED_ARGUMENT\", {\n        count: count,\n        expectedCount: expectedCount\n    });\n}\nconst _normalizeForms = [\"NFD\", \"NFC\", \"NFKD\", \"NFKC\"].reduce((accum, form) => {\n    try {\n        // General test for normalize\n        /* c8 ignore start */\n        if (\"test\".normalize(form) !== \"test\") {\n            throw new Error(\"bad\");\n        }\n        ;\n        /* c8 ignore stop */\n        if (form === \"NFD\") {\n            const check = String.fromCharCode(0xe9).normalize(\"NFD\");\n            const expected = String.fromCharCode(0x65, 0x0301);\n            /* c8 ignore start */\n            if (check !== expected) {\n                throw new Error(\"broken\");\n            }\n            /* c8 ignore stop */\n        }\n        accum.push(form);\n    }\n    catch (error) { }\n    return accum;\n}, []);\n/**\n *  Throws if the normalization %%form%% is not supported.\n */\nexport function assertNormalize(form) {\n    assert(_normalizeForms.indexOf(form) >= 0, \"platform missing String.prototype.normalize\", \"UNSUPPORTED_OPERATION\", {\n        operation: \"String.prototype.normalize\", info: { form }\n    });\n}\n/**\n *  Many classes use file-scoped values to guard the constructor,\n *  making it effectively private. This facilitates that pattern\n *  by ensuring the %%givenGaurd%% matches the file-scoped %%guard%%,\n *  throwing if not, indicating the %%className%% if provided.\n */\nexport function assertPrivate(givenGuard, guard, className) {\n    if (className == null) {\n        className = \"\";\n    }\n    if (givenGuard !== guard) {\n        let method = className, operation = \"new\";\n        if (className) {\n            method += \".\";\n            operation += \" \" + className;\n        }\n        assert(false, `private constructor; use ${method}from* methods`, \"UNSUPPORTED_OPERATION\", {\n            operation\n        });\n    }\n}\n//# sourceMappingURL=errors.js.map","/**\n *  Some data helpers.\n *\n *\n *  @_subsection api/utils:Data Helpers  [about-data]\n */\nimport { assert, assertArgument } from \"./errors.js\";\nfunction _getBytes(value, name, copy) {\n    if (value instanceof Uint8Array) {\n        if (copy) {\n            return new Uint8Array(value);\n        }\n        return value;\n    }\n    if (typeof (value) === \"string\" && value.match(/^0x(?:[0-9a-f][0-9a-f])*$/i)) {\n        const result = new Uint8Array((value.length - 2) / 2);\n        let offset = 2;\n        for (let i = 0; i < result.length; i++) {\n            result[i] = parseInt(value.substring(offset, offset + 2), 16);\n            offset += 2;\n        }\n        return result;\n    }\n    assertArgument(false, \"invalid BytesLike value\", name || \"value\", value);\n}\n/**\n *  Get a typed Uint8Array for %%value%%. If already a Uint8Array\n *  the original %%value%% is returned; if a copy is required use\n *  [[getBytesCopy]].\n *\n *  @see: getBytesCopy\n */\nexport function getBytes(value, name) {\n    return _getBytes(value, name, false);\n}\n/**\n *  Get a typed Uint8Array for %%value%%, creating a copy if necessary\n *  to prevent any modifications of the returned value from being\n *  reflected elsewhere.\n *\n *  @see: getBytes\n */\nexport function getBytesCopy(value, name) {\n    return _getBytes(value, name, true);\n}\n/**\n *  Returns true if %%value%% is a valid [[HexString]].\n *\n *  If %%length%% is ``true`` or a //number//, it also checks that\n *  %%value%% is a valid [[DataHexString]] of %%length%% (if a //number//)\n *  bytes of data (e.g. ``0x1234`` is 2 bytes).\n */\nexport function isHexString(value, length) {\n    if (typeof (value) !== \"string\" || !value.match(/^0x[0-9A-Fa-f]*$/)) {\n        return false;\n    }\n    if (typeof (length) === \"number\" && value.length !== 2 + 2 * length) {\n        return false;\n    }\n    if (length === true && (value.length % 2) !== 0) {\n        return false;\n    }\n    return true;\n}\n/**\n *  Returns true if %%value%% is a valid representation of arbitrary\n *  data (i.e. a valid [[DataHexString]] or a Uint8Array).\n */\nexport function isBytesLike(value) {\n    return (isHexString(value, true) || (value instanceof Uint8Array));\n}\nconst HexCharacters = \"0123456789abcdef\";\n/**\n *  Returns a [[DataHexString]] representation of %%data%%.\n */\nexport function hexlify(data) {\n    const bytes = getBytes(data);\n    let result = \"0x\";\n    for (let i = 0; i < bytes.length; i++) {\n        const v = bytes[i];\n        result += HexCharacters[(v & 0xf0) >> 4] + HexCharacters[v & 0x0f];\n    }\n    return result;\n}\n/**\n *  Returns a [[DataHexString]] by concatenating all values\n *  within %%data%%.\n */\nexport function concat(datas) {\n    return \"0x\" + datas.map((d) => hexlify(d).substring(2)).join(\"\");\n}\n/**\n *  Returns the length of %%data%%, in bytes.\n */\nexport function dataLength(data) {\n    if (isHexString(data, true)) {\n        return (data.length - 2) / 2;\n    }\n    return getBytes(data).length;\n}\n/**\n *  Returns a [[DataHexString]] by slicing %%data%% from the %%start%%\n *  offset to the %%end%% offset.\n *\n *  By default %%start%% is 0 and %%end%% is the length of %%data%%.\n */\nexport function dataSlice(data, start, end) {\n    const bytes = getBytes(data);\n    if (end != null && end > bytes.length) {\n        assert(false, \"cannot slice beyond data bounds\", \"BUFFER_OVERRUN\", {\n            buffer: bytes, length: bytes.length, offset: end\n        });\n    }\n    return hexlify(bytes.slice((start == null) ? 0 : start, (end == null) ? bytes.length : end));\n}\n/**\n *  Return the [[DataHexString]] result by stripping all **leading**\n ** zero bytes from %%data%%.\n */\nexport function stripZerosLeft(data) {\n    let bytes = hexlify(data).substring(2);\n    while (bytes.startsWith(\"00\")) {\n        bytes = bytes.substring(2);\n    }\n    return \"0x\" + bytes;\n}\nfunction zeroPad(data, length, left) {\n    const bytes = getBytes(data);\n    assert(length >= bytes.length, \"padding exceeds data length\", \"BUFFER_OVERRUN\", {\n        buffer: new Uint8Array(bytes),\n        length: length,\n        offset: length + 1\n    });\n    const result = new Uint8Array(length);\n    result.fill(0);\n    if (left) {\n        result.set(bytes, length - bytes.length);\n    }\n    else {\n        result.set(bytes, 0);\n    }\n    return hexlify(result);\n}\n/**\n *  Return the [[DataHexString]] of %%data%% padded on the **left**\n *  to %%length%% bytes.\n *\n *  If %%data%% already exceeds %%length%%, a [[BufferOverrunError]] is\n *  thrown.\n *\n *  This pads data the same as **values** are in Solidity\n *  (e.g. ``uint128``).\n */\nexport function zeroPadValue(data, length) {\n    return zeroPad(data, length, true);\n}\n/**\n *  Return the [[DataHexString]] of %%data%% padded on the **right**\n *  to %%length%% bytes.\n *\n *  If %%data%% already exceeds %%length%%, a [[BufferOverrunError]] is\n *  thrown.\n *\n *  This pads data the same as **bytes** are in Solidity\n *  (e.g. ``bytes16``).\n */\nexport function zeroPadBytes(data, length) {\n    return zeroPad(data, length, false);\n}\n//# sourceMappingURL=data.js.map","/**\n *  Cryptographic hashing functions\n *\n *  @_subsection: api/crypto:Hash Functions [about-crypto-hashing]\n */\nimport { keccak_256 } from \"@noble/hashes/sha3\";\nimport { getBytes, hexlify } from \"../utils/index.js\";\nlet locked = false;\nconst _keccak256 = function (data) {\n    return keccak_256(data);\n};\nlet __keccak256 = _keccak256;\n/**\n *  Compute the cryptographic KECCAK256 hash of %%data%%.\n *\n *  The %%data%% **must** be a data representation, to compute the\n *  hash of UTF-8 data use the [[id]] function.\n *\n *  @returns DataHexstring\n *  @example:\n *    keccak256(\"0x\")\n *    //_result:\n *\n *    keccak256(\"0x1337\")\n *    //_result:\n *\n *    keccak256(new Uint8Array([ 0x13, 0x37 ]))\n *    //_result:\n *\n *    // Strings are assumed to be DataHexString, otherwise it will\n *    // throw. To hash UTF-8 data, see the note above.\n *    keccak256(\"Hello World\")\n *    //_error:\n */\nexport function keccak256(_data) {\n    const data = getBytes(_data, \"data\");\n    return hexlify(__keccak256(data));\n}\nkeccak256._ = _keccak256;\nkeccak256.lock = function () { locked = true; };\nkeccak256.register = function (func) {\n    if (locked) {\n        throw new TypeError(\"keccak256 is locked\");\n    }\n    __keccak256 = func;\n};\nObject.freeze(keccak256);\n//# sourceMappingURL=keccak.js.map","import { exists, output } from './_assert.js';\nimport { Hash, createView, toBytes } from './utils.js';\n// Polyfill for Safari 14\nfunction setBigUint64(view, byteOffset, value, isLE) {\n    if (typeof view.setBigUint64 === 'function')\n        return view.setBigUint64(byteOffset, value, isLE);\n    const _32n = BigInt(32);\n    const _u32_max = BigInt(0xffffffff);\n    const wh = Number((value >> _32n) & _u32_max);\n    const wl = Number(value & _u32_max);\n    const h = isLE ? 4 : 0;\n    const l = isLE ? 0 : 4;\n    view.setUint32(byteOffset + h, wh, isLE);\n    view.setUint32(byteOffset + l, wl, isLE);\n}\n// Base SHA2 class (RFC 6234)\nexport class SHA2 extends Hash {\n    constructor(blockLen, outputLen, padOffset, isLE) {\n        super();\n        this.blockLen = blockLen;\n        this.outputLen = outputLen;\n        this.padOffset = padOffset;\n        this.isLE = isLE;\n        this.finished = false;\n        this.length = 0;\n        this.pos = 0;\n        this.destroyed = false;\n        this.buffer = new Uint8Array(blockLen);\n        this.view = createView(this.buffer);\n    }\n    update(data) {\n        exists(this);\n        const { view, buffer, blockLen } = this;\n        data = toBytes(data);\n        const len = data.length;\n        for (let pos = 0; pos < len;) {\n            const take = Math.min(blockLen - this.pos, len - pos);\n            // Fast path: we have at least one block in input, cast it to view and process\n            if (take === blockLen) {\n                const dataView = createView(data);\n                for (; blockLen <= len - pos; pos += blockLen)\n                    this.process(dataView, pos);\n                continue;\n            }\n            buffer.set(data.subarray(pos, pos + take), this.pos);\n            this.pos += take;\n            pos += take;\n            if (this.pos === blockLen) {\n                this.process(view, 0);\n                this.pos = 0;\n            }\n        }\n        this.length += data.length;\n        this.roundClean();\n        return this;\n    }\n    digestInto(out) {\n        exists(this);\n        output(out, this);\n        this.finished = true;\n        // Padding\n        // We can avoid allocation of buffer for padding completely if it\n        // was previously not allocated here. But it won't change performance.\n        const { buffer, view, blockLen, isLE } = this;\n        let { pos } = this;\n        // append the bit '1' to the message\n        buffer[pos++] = 0b10000000;\n        this.buffer.subarray(pos).fill(0);\n        // we have less than padOffset left in buffer, so we cannot put length in current block, need process it and pad again\n        if (this.padOffset > blockLen - pos) {\n            this.process(view, 0);\n            pos = 0;\n        }\n        // Pad until full block byte with zeros\n        for (let i = pos; i < blockLen; i++)\n            buffer[i] = 0;\n        // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that\n        // You need to write around 2 exabytes (u64_max / 8 / (1024**6)) for this to happen.\n        // So we just write lowest 64 bits of that value.\n        setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);\n        this.process(view, 0);\n        const oview = createView(out);\n        const len = this.outputLen;\n        // NOTE: we do division by 4 later, which should be fused in single op with modulo by JIT\n        if (len % 4)\n            throw new Error('_sha2: outputLen should be aligned to 32bit');\n        const outLen = len / 4;\n        const state = this.get();\n        if (outLen > state.length)\n            throw new Error('_sha2: outputLen bigger than state');\n        for (let i = 0; i < outLen; i++)\n            oview.setUint32(4 * i, state[i], isLE);\n    }\n    digest() {\n        const { buffer, outputLen } = this;\n        this.digestInto(buffer);\n        const res = buffer.slice(0, outputLen);\n        this.destroy();\n        return res;\n    }\n    _cloneInto(to) {\n        to || (to = new this.constructor());\n        to.set(...this.get());\n        const { blockLen, buffer, length, finished, destroyed, pos } = this;\n        to.length = length;\n        to.pos = pos;\n        to.finished = finished;\n        to.destroyed = destroyed;\n        if (length % blockLen)\n            to.buffer.set(buffer);\n        return to;\n    }\n}\n//# sourceMappingURL=_sha2.js.map","import { SHA2 } from './_sha2.js';\nimport { rotr, wrapConstructor } from './utils.js';\n// SHA2-256 need to try 2^128 hashes to execute birthday attack.\n// BTC network is doing 2^67 hashes/sec as per early 2023.\n// Choice: a ? b : c\nconst Chi = (a, b, c) => (a & b) ^ (~a & c);\n// Majority function, true if any two inpust is true\nconst Maj = (a, b, c) => (a & b) ^ (a & c) ^ (b & c);\n// Round constants:\n// first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311)\n// prettier-ignore\nconst SHA256_K = /* @__PURE__ */ new Uint32Array([\n    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,\n    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,\n    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,\n    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,\n    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\n    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,\n    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,\n    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2\n]);\n// Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):\n// prettier-ignore\nconst IV = /* @__PURE__ */ new Uint32Array([\n    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19\n]);\n// Temporary buffer, not used to store anything between runs\n// Named this way because it matches specification.\nconst SHA256_W = /* @__PURE__ */ new Uint32Array(64);\nclass SHA256 extends SHA2 {\n    constructor() {\n        super(64, 32, 8, false);\n        // We cannot use array here since array allows indexing by variable\n        // which means optimizer/compiler cannot use registers.\n        this.A = IV[0] | 0;\n        this.B = IV[1] | 0;\n        this.C = IV[2] | 0;\n        this.D = IV[3] | 0;\n        this.E = IV[4] | 0;\n        this.F = IV[5] | 0;\n        this.G = IV[6] | 0;\n        this.H = IV[7] | 0;\n    }\n    get() {\n        const { A, B, C, D, E, F, G, H } = this;\n        return [A, B, C, D, E, F, G, H];\n    }\n    // prettier-ignore\n    set(A, B, C, D, E, F, G, H) {\n        this.A = A | 0;\n        this.B = B | 0;\n        this.C = C | 0;\n        this.D = D | 0;\n        this.E = E | 0;\n        this.F = F | 0;\n        this.G = G | 0;\n        this.H = H | 0;\n    }\n    process(view, offset) {\n        // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array\n        for (let i = 0; i < 16; i++, offset += 4)\n            SHA256_W[i] = view.getUint32(offset, false);\n        for (let i = 16; i < 64; i++) {\n            const W15 = SHA256_W[i - 15];\n            const W2 = SHA256_W[i - 2];\n            const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ (W15 >>> 3);\n            const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >>> 10);\n            SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) | 0;\n        }\n        // Compression function main loop, 64 rounds\n        let { A, B, C, D, E, F, G, H } = this;\n        for (let i = 0; i < 64; i++) {\n            const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);\n            const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;\n            const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);\n            const T2 = (sigma0 + Maj(A, B, C)) | 0;\n            H = G;\n            G = F;\n            F = E;\n            E = (D + T1) | 0;\n            D = C;\n            C = B;\n            B = A;\n            A = (T1 + T2) | 0;\n        }\n        // Add the compressed chunk to the current hash value\n        A = (A + this.A) | 0;\n        B = (B + this.B) | 0;\n        C = (C + this.C) | 0;\n        D = (D + this.D) | 0;\n        E = (E + this.E) | 0;\n        F = (F + this.F) | 0;\n        G = (G + this.G) | 0;\n        H = (H + this.H) | 0;\n        this.set(A, B, C, D, E, F, G, H);\n    }\n    roundClean() {\n        SHA256_W.fill(0);\n    }\n    destroy() {\n        this.set(0, 0, 0, 0, 0, 0, 0, 0);\n        this.buffer.fill(0);\n    }\n}\n// Constants from https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf\nclass SHA224 extends SHA256 {\n    constructor() {\n        super();\n        this.A = 0xc1059ed8 | 0;\n        this.B = 0x367cd507 | 0;\n        this.C = 0x3070dd17 | 0;\n        this.D = 0xf70e5939 | 0;\n        this.E = 0xffc00b31 | 0;\n        this.F = 0x68581511 | 0;\n        this.G = 0x64f98fa7 | 0;\n        this.H = 0xbefa4fa4 | 0;\n        this.outputLen = 28;\n    }\n}\n/**\n * SHA2-256 hash function\n * @param message - data that would be hashed\n */\nexport const sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());\nexport const sha224 = /* @__PURE__ */ wrapConstructor(() => new SHA224());\n//# sourceMappingURL=sha256.js.map","/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// 100 lines of code in the file are duplicated from noble-hashes (utils).\n// This is OK: `abstract` directory does not use noble-hashes.\n// User may opt-in into using different hashing library. This way, noble-hashes\n// won't be included into their bundle.\nconst _0n = BigInt(0);\nconst _1n = BigInt(1);\nconst _2n = BigInt(2);\nconst u8a = (a) => a instanceof Uint8Array;\nconst hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));\n/**\n * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'\n */\nexport function bytesToHex(bytes) {\n    if (!u8a(bytes))\n        throw new Error('Uint8Array expected');\n    // pre-caching improves the speed 6x\n    let hex = '';\n    for (let i = 0; i < bytes.length; i++) {\n        hex += hexes[bytes[i]];\n    }\n    return hex;\n}\nexport function numberToHexUnpadded(num) {\n    const hex = num.toString(16);\n    return hex.length & 1 ? `0${hex}` : hex;\n}\nexport function hexToNumber(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    // Big Endian\n    return BigInt(hex === '' ? '0' : `0x${hex}`);\n}\n/**\n * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])\n */\nexport function hexToBytes(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    const len = hex.length;\n    if (len % 2)\n        throw new Error('padded hex string expected, got unpadded hex of length ' + len);\n    const array = new Uint8Array(len / 2);\n    for (let i = 0; i < array.length; i++) {\n        const j = i * 2;\n        const hexByte = hex.slice(j, j + 2);\n        const byte = Number.parseInt(hexByte, 16);\n        if (Number.isNaN(byte) || byte < 0)\n            throw new Error('Invalid byte sequence');\n        array[i] = byte;\n    }\n    return array;\n}\n// BE: Big Endian, LE: Little Endian\nexport function bytesToNumberBE(bytes) {\n    return hexToNumber(bytesToHex(bytes));\n}\nexport function bytesToNumberLE(bytes) {\n    if (!u8a(bytes))\n        throw new Error('Uint8Array expected');\n    return hexToNumber(bytesToHex(Uint8Array.from(bytes).reverse()));\n}\nexport function numberToBytesBE(n, len) {\n    return hexToBytes(n.toString(16).padStart(len * 2, '0'));\n}\nexport function numberToBytesLE(n, len) {\n    return numberToBytesBE(n, len).reverse();\n}\n// Unpadded, rarely used\nexport function numberToVarBytesBE(n) {\n    return hexToBytes(numberToHexUnpadded(n));\n}\n/**\n * Takes hex string or Uint8Array, converts to Uint8Array.\n * Validates output length.\n * Will throw error for other types.\n * @param title descriptive title for an error e.g. 'private key'\n * @param hex hex string or Uint8Array\n * @param expectedLength optional, will compare to result array's length\n * @returns\n */\nexport function ensureBytes(title, hex, expectedLength) {\n    let res;\n    if (typeof hex === 'string') {\n        try {\n            res = hexToBytes(hex);\n        }\n        catch (e) {\n            throw new Error(`${title} must be valid hex string, got \"${hex}\". Cause: ${e}`);\n        }\n    }\n    else if (u8a(hex)) {\n        // Uint8Array.from() instead of hash.slice() because node.js Buffer\n        // is instance of Uint8Array, and its slice() creates **mutable** copy\n        res = Uint8Array.from(hex);\n    }\n    else {\n        throw new Error(`${title} must be hex string or Uint8Array`);\n    }\n    const len = res.length;\n    if (typeof expectedLength === 'number' && len !== expectedLength)\n        throw new Error(`${title} expected ${expectedLength} bytes, got ${len}`);\n    return res;\n}\n/**\n * Copies several Uint8Arrays into one.\n */\nexport function concatBytes(...arrays) {\n    const r = new Uint8Array(arrays.reduce((sum, a) => sum + a.length, 0));\n    let pad = 0; // walk through each item, ensure they have proper type\n    arrays.forEach((a) => {\n        if (!u8a(a))\n            throw new Error('Uint8Array expected');\n        r.set(a, pad);\n        pad += a.length;\n    });\n    return r;\n}\nexport function equalBytes(b1, b2) {\n    // We don't care about timing attacks here\n    if (b1.length !== b2.length)\n        return false;\n    for (let i = 0; i < b1.length; i++)\n        if (b1[i] !== b2[i])\n            return false;\n    return true;\n}\n/**\n * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])\n */\nexport function utf8ToBytes(str) {\n    if (typeof str !== 'string')\n        throw new Error(`utf8ToBytes expected string, got ${typeof str}`);\n    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n// Bit operations\n/**\n * Calculates amount of bits in a bigint.\n * Same as `n.toString(2).length`\n */\nexport function bitLen(n) {\n    let len;\n    for (len = 0; n > _0n; n >>= _1n, len += 1)\n        ;\n    return len;\n}\n/**\n * Gets single bit at position.\n * NOTE: first bit position is 0 (same as arrays)\n * Same as `!!+Array.from(n.toString(2)).reverse()[pos]`\n */\nexport function bitGet(n, pos) {\n    return (n >> BigInt(pos)) & _1n;\n}\n/**\n * Sets single bit at position.\n */\nexport const bitSet = (n, pos, value) => {\n    return n | ((value ? _1n : _0n) << BigInt(pos));\n};\n/**\n * Calculate mask for N bits. Not using ** operator with bigints because of old engines.\n * Same as BigInt(`0b${Array(i).fill('1').join('')}`)\n */\nexport const bitMask = (n) => (_2n << BigInt(n - 1)) - _1n;\n// DRBG\nconst u8n = (data) => new Uint8Array(data); // creates Uint8Array\nconst u8fr = (arr) => Uint8Array.from(arr); // another shortcut\n/**\n * Minimal HMAC-DRBG from NIST 800-90 for RFC6979 sigs.\n * @returns function that will call DRBG until 2nd arg returns something meaningful\n * @example\n *   const drbg = createHmacDRBG<Key>(32, 32, hmac);\n *   drbg(seed, bytesToKey); // bytesToKey must return Key or undefined\n */\nexport function createHmacDrbg(hashLen, qByteLen, hmacFn) {\n    if (typeof hashLen !== 'number' || hashLen < 2)\n        throw new Error('hashLen must be a number');\n    if (typeof qByteLen !== 'number' || qByteLen < 2)\n        throw new Error('qByteLen must be a number');\n    if (typeof hmacFn !== 'function')\n        throw new Error('hmacFn must be a function');\n    // Step B, Step C: set hashLen to 8*ceil(hlen/8)\n    let v = u8n(hashLen); // Minimal non-full-spec HMAC-DRBG from NIST 800-90 for RFC6979 sigs.\n    let k = u8n(hashLen); // Steps B and C of RFC6979 3.2: set hashLen, in our case always same\n    let i = 0; // Iterations counter, will throw when over 1000\n    const reset = () => {\n        v.fill(1);\n        k.fill(0);\n        i = 0;\n    };\n    const h = (...b) => hmacFn(k, v, ...b); // hmac(k)(v, ...values)\n    const reseed = (seed = u8n()) => {\n        // HMAC-DRBG reseed() function. Steps D-G\n        k = h(u8fr([0x00]), seed); // k = hmac(k || v || 0x00 || seed)\n        v = h(); // v = hmac(k || v)\n        if (seed.length === 0)\n            return;\n        k = h(u8fr([0x01]), seed); // k = hmac(k || v || 0x01 || seed)\n        v = h(); // v = hmac(k || v)\n    };\n    const gen = () => {\n        // HMAC-DRBG generate() function\n        if (i++ >= 1000)\n            throw new Error('drbg: tried 1000 values');\n        let len = 0;\n        const out = [];\n        while (len < qByteLen) {\n            v = h();\n            const sl = v.slice();\n            out.push(sl);\n            len += v.length;\n        }\n        return concatBytes(...out);\n    };\n    const genUntil = (seed, pred) => {\n        reset();\n        reseed(seed); // Steps D-G\n        let res = undefined; // Step H: grind until k is in [1..n-1]\n        while (!(res = pred(gen())))\n            reseed();\n        reset();\n        return res;\n    };\n    return genUntil;\n}\n// Validating curves and fields\nconst validatorFns = {\n    bigint: (val) => typeof val === 'bigint',\n    function: (val) => typeof val === 'function',\n    boolean: (val) => typeof val === 'boolean',\n    string: (val) => typeof val === 'string',\n    stringOrUint8Array: (val) => typeof val === 'string' || val instanceof Uint8Array,\n    isSafeInteger: (val) => Number.isSafeInteger(val),\n    array: (val) => Array.isArray(val),\n    field: (val, object) => object.Fp.isValid(val),\n    hash: (val) => typeof val === 'function' && Number.isSafeInteger(val.outputLen),\n};\n// type Record<K extends string | number | symbol, T> = { [P in K]: T; }\nexport function validateObject(object, validators, optValidators = {}) {\n    const checkField = (fieldName, type, isOptional) => {\n        const checkVal = validatorFns[type];\n        if (typeof checkVal !== 'function')\n            throw new Error(`Invalid validator \"${type}\", expected function`);\n        const val = object[fieldName];\n        if (isOptional && val === undefined)\n            return;\n        if (!checkVal(val, object)) {\n            throw new Error(`Invalid param ${String(fieldName)}=${val} (${typeof val}), expected ${type}`);\n        }\n    };\n    for (const [fieldName, type] of Object.entries(validators))\n        checkField(fieldName, type, false);\n    for (const [fieldName, type] of Object.entries(optValidators))\n        checkField(fieldName, type, true);\n    return object;\n}\n// validate type tests\n// const o: { a: number; b: number; c: number } = { a: 1, b: 5, c: 6 };\n// const z0 = validateObject(o, { a: 'isSafeInteger' }, { c: 'bigint' }); // Ok!\n// // Should fail type-check\n// const z1 = validateObject(o, { a: 'tmp' }, { c: 'zz' });\n// const z2 = validateObject(o, { a: 'isSafeInteger' }, { c: 'zz' });\n// const z3 = validateObject(o, { test: 'boolean', z: 'bug' });\n// const z4 = validateObject(o, { a: 'boolean', z: 'bug' });\n//# sourceMappingURL=utils.js.map","/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// Utilities for modular arithmetics and finite fields\nimport { bitMask, numberToBytesBE, numberToBytesLE, bytesToNumberBE, bytesToNumberLE, ensureBytes, validateObject, } from './utils.js';\n// prettier-ignore\nconst _0n = BigInt(0), _1n = BigInt(1), _2n = BigInt(2), _3n = BigInt(3);\n// prettier-ignore\nconst _4n = BigInt(4), _5n = BigInt(5), _8n = BigInt(8);\n// prettier-ignore\nconst _9n = BigInt(9), _16n = BigInt(16);\n// Calculates a modulo b\nexport function mod(a, b) {\n    const result = a % b;\n    return result >= _0n ? result : b + result;\n}\n/**\n * Efficiently raise num to power and do modular division.\n * Unsafe in some contexts: uses ladder, so can expose bigint bits.\n * @example\n * pow(2n, 6n, 11n) // 64n % 11n == 9n\n */\n// TODO: use field version && remove\nexport function pow(num, power, modulo) {\n    if (modulo <= _0n || power < _0n)\n        throw new Error('Expected power/modulo > 0');\n    if (modulo === _1n)\n        return _0n;\n    let res = _1n;\n    while (power > _0n) {\n        if (power & _1n)\n            res = (res * num) % modulo;\n        num = (num * num) % modulo;\n        power >>= _1n;\n    }\n    return res;\n}\n// Does x ^ (2 ^ power) mod p. pow2(30, 4) == 30 ^ (2 ^ 4)\nexport function pow2(x, power, modulo) {\n    let res = x;\n    while (power-- > _0n) {\n        res *= res;\n        res %= modulo;\n    }\n    return res;\n}\n// Inverses number over modulo\nexport function invert(number, modulo) {\n    if (number === _0n || modulo <= _0n) {\n        throw new Error(`invert: expected positive integers, got n=${number} mod=${modulo}`);\n    }\n    // Euclidean GCD https://brilliant.org/wiki/extended-euclidean-algorithm/\n    // Fermat's little theorem \"CT-like\" version inv(n) = n^(m-2) mod m is 30x slower.\n    let a = mod(number, modulo);\n    let b = modulo;\n    // prettier-ignore\n    let x = _0n, y = _1n, u = _1n, v = _0n;\n    while (a !== _0n) {\n        // JIT applies optimization if those two lines follow each other\n        const q = b / a;\n        const r = b % a;\n        const m = x - u * q;\n        const n = y - v * q;\n        // prettier-ignore\n        b = a, a = r, x = u, y = v, u = m, v = n;\n    }\n    const gcd = b;\n    if (gcd !== _1n)\n        throw new Error('invert: does not exist');\n    return mod(x, modulo);\n}\n/**\n * Tonelli-Shanks square root search algorithm.\n * 1. https://eprint.iacr.org/2012/685.pdf (page 12)\n * 2. Square Roots from 1; 24, 51, 10 to Dan Shanks\n * Will start an infinite loop if field order P is not prime.\n * @param P field order\n * @returns function that takes field Fp (created from P) and number n\n */\nexport function tonelliShanks(P) {\n    // Legendre constant: used to calculate Legendre symbol (a | p),\n    // which denotes the value of a^((p-1)/2) (mod p).\n    // (a | p) ≡ 1    if a is a square (mod p)\n    // (a | p) ≡ -1   if a is not a square (mod p)\n    // (a | p) ≡ 0    if a ≡ 0 (mod p)\n    const legendreC = (P - _1n) / _2n;\n    let Q, S, Z;\n    // Step 1: By factoring out powers of 2 from p - 1,\n    // find q and s such that p - 1 = q*(2^s) with q odd\n    for (Q = P - _1n, S = 0; Q % _2n === _0n; Q /= _2n, S++)\n        ;\n    // Step 2: Select a non-square z such that (z | p) ≡ -1 and set c ≡ zq\n    for (Z = _2n; Z < P && pow(Z, legendreC, P) !== P - _1n; Z++)\n        ;\n    // Fast-path\n    if (S === 1) {\n        const p1div4 = (P + _1n) / _4n;\n        return function tonelliFast(Fp, n) {\n            const root = Fp.pow(n, p1div4);\n            if (!Fp.eql(Fp.sqr(root), n))\n                throw new Error('Cannot find square root');\n            return root;\n        };\n    }\n    // Slow-path\n    const Q1div2 = (Q + _1n) / _2n;\n    return function tonelliSlow(Fp, n) {\n        // Step 0: Check that n is indeed a square: (n | p) should not be ≡ -1\n        if (Fp.pow(n, legendreC) === Fp.neg(Fp.ONE))\n            throw new Error('Cannot find square root');\n        let r = S;\n        // TODO: will fail at Fp2/etc\n        let g = Fp.pow(Fp.mul(Fp.ONE, Z), Q); // will update both x and b\n        let x = Fp.pow(n, Q1div2); // first guess at the square root\n        let b = Fp.pow(n, Q); // first guess at the fudge factor\n        while (!Fp.eql(b, Fp.ONE)) {\n            if (Fp.eql(b, Fp.ZERO))\n                return Fp.ZERO; // https://en.wikipedia.org/wiki/Tonelli%E2%80%93Shanks_algorithm (4. If t = 0, return r = 0)\n            // Find m such b^(2^m)==1\n            let m = 1;\n            for (let t2 = Fp.sqr(b); m < r; m++) {\n                if (Fp.eql(t2, Fp.ONE))\n                    break;\n                t2 = Fp.sqr(t2); // t2 *= t2\n            }\n            // NOTE: r-m-1 can be bigger than 32, need to convert to bigint before shift, otherwise there will be overflow\n            const ge = Fp.pow(g, _1n << BigInt(r - m - 1)); // ge = 2^(r-m-1)\n            g = Fp.sqr(ge); // g = ge * ge\n            x = Fp.mul(x, ge); // x *= ge\n            b = Fp.mul(b, g); // b *= g\n            r = m;\n        }\n        return x;\n    };\n}\nexport function FpSqrt(P) {\n    // NOTE: different algorithms can give different roots, it is up to user to decide which one they want.\n    // For example there is FpSqrtOdd/FpSqrtEven to choice root based on oddness (used for hash-to-curve).\n    // P ≡ 3 (mod 4)\n    // √n = n^((P+1)/4)\n    if (P % _4n === _3n) {\n        // Not all roots possible!\n        // const ORDER =\n        //   0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaabn;\n        // const NUM = 72057594037927816n;\n        const p1div4 = (P + _1n) / _4n;\n        return function sqrt3mod4(Fp, n) {\n            const root = Fp.pow(n, p1div4);\n            // Throw if root**2 != n\n            if (!Fp.eql(Fp.sqr(root), n))\n                throw new Error('Cannot find square root');\n            return root;\n        };\n    }\n    // Atkin algorithm for q ≡ 5 (mod 8), https://eprint.iacr.org/2012/685.pdf (page 10)\n    if (P % _8n === _5n) {\n        const c1 = (P - _5n) / _8n;\n        return function sqrt5mod8(Fp, n) {\n            const n2 = Fp.mul(n, _2n);\n            const v = Fp.pow(n2, c1);\n            const nv = Fp.mul(n, v);\n            const i = Fp.mul(Fp.mul(nv, _2n), v);\n            const root = Fp.mul(nv, Fp.sub(i, Fp.ONE));\n            if (!Fp.eql(Fp.sqr(root), n))\n                throw new Error('Cannot find square root');\n            return root;\n        };\n    }\n    // P ≡ 9 (mod 16)\n    if (P % _16n === _9n) {\n        // NOTE: tonelli is too slow for bls-Fp2 calculations even on start\n        // Means we cannot use sqrt for constants at all!\n        //\n        // const c1 = Fp.sqrt(Fp.negate(Fp.ONE)); //  1. c1 = sqrt(-1) in F, i.e., (c1^2) == -1 in F\n        // const c2 = Fp.sqrt(c1);                //  2. c2 = sqrt(c1) in F, i.e., (c2^2) == c1 in F\n        // const c3 = Fp.sqrt(Fp.negate(c1));     //  3. c3 = sqrt(-c1) in F, i.e., (c3^2) == -c1 in F\n        // const c4 = (P + _7n) / _16n;           //  4. c4 = (q + 7) / 16        # Integer arithmetic\n        // sqrt = (x) => {\n        //   let tv1 = Fp.pow(x, c4);             //  1. tv1 = x^c4\n        //   let tv2 = Fp.mul(c1, tv1);           //  2. tv2 = c1 * tv1\n        //   const tv3 = Fp.mul(c2, tv1);         //  3. tv3 = c2 * tv1\n        //   let tv4 = Fp.mul(c3, tv1);           //  4. tv4 = c3 * tv1\n        //   const e1 = Fp.equals(Fp.square(tv2), x); //  5.  e1 = (tv2^2) == x\n        //   const e2 = Fp.equals(Fp.square(tv3), x); //  6.  e2 = (tv3^2) == x\n        //   tv1 = Fp.cmov(tv1, tv2, e1); //  7. tv1 = CMOV(tv1, tv2, e1)  # Select tv2 if (tv2^2) == x\n        //   tv2 = Fp.cmov(tv4, tv3, e2); //  8. tv2 = CMOV(tv4, tv3, e2)  # Select tv3 if (tv3^2) == x\n        //   const e3 = Fp.equals(Fp.square(tv2), x); //  9.  e3 = (tv2^2) == x\n        //   return Fp.cmov(tv1, tv2, e3); //  10.  z = CMOV(tv1, tv2, e3)  # Select the sqrt from tv1 and tv2\n        // }\n    }\n    // Other cases: Tonelli-Shanks algorithm\n    return tonelliShanks(P);\n}\n// Little-endian check for first LE bit (last BE bit);\nexport const isNegativeLE = (num, modulo) => (mod(num, modulo) & _1n) === _1n;\n// prettier-ignore\nconst FIELD_FIELDS = [\n    'create', 'isValid', 'is0', 'neg', 'inv', 'sqrt', 'sqr',\n    'eql', 'add', 'sub', 'mul', 'pow', 'div',\n    'addN', 'subN', 'mulN', 'sqrN'\n];\nexport function validateField(field) {\n    const initial = {\n        ORDER: 'bigint',\n        MASK: 'bigint',\n        BYTES: 'isSafeInteger',\n        BITS: 'isSafeInteger',\n    };\n    const opts = FIELD_FIELDS.reduce((map, val) => {\n        map[val] = 'function';\n        return map;\n    }, initial);\n    return validateObject(field, opts);\n}\n// Generic field functions\n/**\n * Same as `pow` but for Fp: non-constant-time.\n * Unsafe in some contexts: uses ladder, so can expose bigint bits.\n */\nexport function FpPow(f, num, power) {\n    // Should have same speed as pow for bigints\n    // TODO: benchmark!\n    if (power < _0n)\n        throw new Error('Expected power > 0');\n    if (power === _0n)\n        return f.ONE;\n    if (power === _1n)\n        return num;\n    let p = f.ONE;\n    let d = num;\n    while (power > _0n) {\n        if (power & _1n)\n            p = f.mul(p, d);\n        d = f.sqr(d);\n        power >>= _1n;\n    }\n    return p;\n}\n/**\n * Efficiently invert an array of Field elements.\n * `inv(0)` will return `undefined` here: make sure to throw an error.\n */\nexport function FpInvertBatch(f, nums) {\n    const tmp = new Array(nums.length);\n    // Walk from first to last, multiply them by each other MOD p\n    const lastMultiplied = nums.reduce((acc, num, i) => {\n        if (f.is0(num))\n            return acc;\n        tmp[i] = acc;\n        return f.mul(acc, num);\n    }, f.ONE);\n    // Invert last element\n    const inverted = f.inv(lastMultiplied);\n    // Walk from last to first, multiply them by inverted each other MOD p\n    nums.reduceRight((acc, num, i) => {\n        if (f.is0(num))\n            return acc;\n        tmp[i] = f.mul(acc, tmp[i]);\n        return f.mul(acc, num);\n    }, inverted);\n    return tmp;\n}\nexport function FpDiv(f, lhs, rhs) {\n    return f.mul(lhs, typeof rhs === 'bigint' ? invert(rhs, f.ORDER) : f.inv(rhs));\n}\n// This function returns True whenever the value x is a square in the field F.\nexport function FpIsSquare(f) {\n    const legendreConst = (f.ORDER - _1n) / _2n; // Integer arithmetic\n    return (x) => {\n        const p = f.pow(x, legendreConst);\n        return f.eql(p, f.ZERO) || f.eql(p, f.ONE);\n    };\n}\n// CURVE.n lengths\nexport function nLength(n, nBitLength) {\n    // Bit size, byte size of CURVE.n\n    const _nBitLength = nBitLength !== undefined ? nBitLength : n.toString(2).length;\n    const nByteLength = Math.ceil(_nBitLength / 8);\n    return { nBitLength: _nBitLength, nByteLength };\n}\n/**\n * Initializes a finite field over prime. **Non-primes are not supported.**\n * Do not init in loop: slow. Very fragile: always run a benchmark on a change.\n * Major performance optimizations:\n * * a) denormalized operations like mulN instead of mul\n * * b) same object shape: never add or remove keys\n * * c) Object.freeze\n * @param ORDER prime positive bigint\n * @param bitLen how many bits the field consumes\n * @param isLE (def: false) if encoding / decoding should be in little-endian\n * @param redef optional faster redefinitions of sqrt and other methods\n */\nexport function Field(ORDER, bitLen, isLE = false, redef = {}) {\n    if (ORDER <= _0n)\n        throw new Error(`Expected Field ORDER > 0, got ${ORDER}`);\n    const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen);\n    if (BYTES > 2048)\n        throw new Error('Field lengths over 2048 bytes are not supported');\n    const sqrtP = FpSqrt(ORDER);\n    const f = Object.freeze({\n        ORDER,\n        BITS,\n        BYTES,\n        MASK: bitMask(BITS),\n        ZERO: _0n,\n        ONE: _1n,\n        create: (num) => mod(num, ORDER),\n        isValid: (num) => {\n            if (typeof num !== 'bigint')\n                throw new Error(`Invalid field element: expected bigint, got ${typeof num}`);\n            return _0n <= num && num < ORDER; // 0 is valid element, but it's not invertible\n        },\n        is0: (num) => num === _0n,\n        isOdd: (num) => (num & _1n) === _1n,\n        neg: (num) => mod(-num, ORDER),\n        eql: (lhs, rhs) => lhs === rhs,\n        sqr: (num) => mod(num * num, ORDER),\n        add: (lhs, rhs) => mod(lhs + rhs, ORDER),\n        sub: (lhs, rhs) => mod(lhs - rhs, ORDER),\n        mul: (lhs, rhs) => mod(lhs * rhs, ORDER),\n        pow: (num, power) => FpPow(f, num, power),\n        div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),\n        // Same as above, but doesn't normalize\n        sqrN: (num) => num * num,\n        addN: (lhs, rhs) => lhs + rhs,\n        subN: (lhs, rhs) => lhs - rhs,\n        mulN: (lhs, rhs) => lhs * rhs,\n        inv: (num) => invert(num, ORDER),\n        sqrt: redef.sqrt || ((n) => sqrtP(f, n)),\n        invertBatch: (lst) => FpInvertBatch(f, lst),\n        // TODO: do we really need constant cmov?\n        // We don't have const-time bigints anyway, so probably will be not very useful\n        cmov: (a, b, c) => (c ? b : a),\n        toBytes: (num) => (isLE ? numberToBytesLE(num, BYTES) : numberToBytesBE(num, BYTES)),\n        fromBytes: (bytes) => {\n            if (bytes.length !== BYTES)\n                throw new Error(`Fp.fromBytes: expected ${BYTES}, got ${bytes.length}`);\n            return isLE ? bytesToNumberLE(bytes) : bytesToNumberBE(bytes);\n        },\n    });\n    return Object.freeze(f);\n}\nexport function FpSqrtOdd(Fp, elm) {\n    if (!Fp.isOdd)\n        throw new Error(`Field doesn't have isOdd`);\n    const root = Fp.sqrt(elm);\n    return Fp.isOdd(root) ? root : Fp.neg(root);\n}\nexport function FpSqrtEven(Fp, elm) {\n    if (!Fp.isOdd)\n        throw new Error(`Field doesn't have isOdd`);\n    const root = Fp.sqrt(elm);\n    return Fp.isOdd(root) ? Fp.neg(root) : root;\n}\n/**\n * \"Constant-time\" private key generation utility.\n * Same as mapKeyToField, but accepts less bytes (40 instead of 48 for 32-byte field).\n * Which makes it slightly more biased, less secure.\n * @deprecated use mapKeyToField instead\n */\nexport function hashToPrivateScalar(hash, groupOrder, isLE = false) {\n    hash = ensureBytes('privateHash', hash);\n    const hashLen = hash.length;\n    const minLen = nLength(groupOrder).nByteLength + 8;\n    if (minLen < 24 || hashLen < minLen || hashLen > 1024)\n        throw new Error(`hashToPrivateScalar: expected ${minLen}-1024 bytes of input, got ${hashLen}`);\n    const num = isLE ? bytesToNumberLE(hash) : bytesToNumberBE(hash);\n    return mod(num, groupOrder - _1n) + _1n;\n}\n/**\n * Returns total number of bytes consumed by the field element.\n * For example, 32 bytes for usual 256-bit weierstrass curve.\n * @param fieldOrder number of field elements, usually CURVE.n\n * @returns byte length of field\n */\nexport function getFieldBytesLength(fieldOrder) {\n    if (typeof fieldOrder !== 'bigint')\n        throw new Error('field order must be bigint');\n    const bitLength = fieldOrder.toString(2).length;\n    return Math.ceil(bitLength / 8);\n}\n/**\n * Returns minimal amount of bytes that can be safely reduced\n * by field order.\n * Should be 2^-128 for 128-bit curve such as P256.\n * @param fieldOrder number of field elements, usually CURVE.n\n * @returns byte length of target hash\n */\nexport function getMinHashLength(fieldOrder) {\n    const length = getFieldBytesLength(fieldOrder);\n    return length + Math.ceil(length / 2);\n}\n/**\n * \"Constant-time\" private key generation utility.\n * Can take (n + n/2) or more bytes of uniform input e.g. from CSPRNG or KDF\n * and convert them into private scalar, with the modulo bias being negligible.\n * Needs at least 48 bytes of input for 32-byte private key.\n * https://research.kudelskisecurity.com/2020/07/28/the-definitive-guide-to-modulo-bias-and-how-to-avoid-it/\n * FIPS 186-5, A.2 https://csrc.nist.gov/publications/detail/fips/186/5/final\n * RFC 9380, https://www.rfc-editor.org/rfc/rfc9380#section-5\n * @param hash hash output from SHA3 or a similar function\n * @param groupOrder size of subgroup - (e.g. secp256k1.CURVE.n)\n * @param isLE interpret hash bytes as LE num\n * @returns valid private scalar\n */\nexport function mapHashToField(key, fieldOrder, isLE = false) {\n    const len = key.length;\n    const fieldLen = getFieldBytesLength(fieldOrder);\n    const minLen = getMinHashLength(fieldOrder);\n    // No small numbers: need to understand bias story. No huge numbers: easier to detect JS timings.\n    if (len < 16 || len < minLen || len > 1024)\n        throw new Error(`expected ${minLen}-1024 bytes of input, got ${len}`);\n    const num = isLE ? bytesToNumberBE(key) : bytesToNumberLE(key);\n    // `mod(x, 11)` can sometimes produce 0. `mod(x, 10) + 1` is the same, but no 0\n    const reduced = mod(num, fieldOrder - _1n) + _1n;\n    return isLE ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);\n}\n//# sourceMappingURL=modular.js.map","import { hash as assertHash, bytes as assertBytes, exists as assertExists } from './_assert.js';\nimport { Hash, toBytes } from './utils.js';\n// HMAC (RFC 2104)\nexport class HMAC extends Hash {\n    constructor(hash, _key) {\n        super();\n        this.finished = false;\n        this.destroyed = false;\n        assertHash(hash);\n        const key = toBytes(_key);\n        this.iHash = hash.create();\n        if (typeof this.iHash.update !== 'function')\n            throw new Error('Expected instance of class which extends utils.Hash');\n        this.blockLen = this.iHash.blockLen;\n        this.outputLen = this.iHash.outputLen;\n        const blockLen = this.blockLen;\n        const pad = new Uint8Array(blockLen);\n        // blockLen can be bigger than outputLen\n        pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);\n        for (let i = 0; i < pad.length; i++)\n            pad[i] ^= 0x36;\n        this.iHash.update(pad);\n        // By doing update (processing of first block) of outer hash here we can re-use it between multiple calls via clone\n        this.oHash = hash.create();\n        // Undo internal XOR && apply outer XOR\n        for (let i = 0; i < pad.length; i++)\n            pad[i] ^= 0x36 ^ 0x5c;\n        this.oHash.update(pad);\n        pad.fill(0);\n    }\n    update(buf) {\n        assertExists(this);\n        this.iHash.update(buf);\n        return this;\n    }\n    digestInto(out) {\n        assertExists(this);\n        assertBytes(out, this.outputLen);\n        this.finished = true;\n        this.iHash.digestInto(out);\n        this.oHash.update(out);\n        this.oHash.digestInto(out);\n        this.destroy();\n    }\n    digest() {\n        const out = new Uint8Array(this.oHash.outputLen);\n        this.digestInto(out);\n        return out;\n    }\n    _cloneInto(to) {\n        // Create new instance without calling constructor since key already in state and we don't know it.\n        to || (to = Object.create(Object.getPrototypeOf(this), {}));\n        const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;\n        to = to;\n        to.finished = finished;\n        to.destroyed = destroyed;\n        to.blockLen = blockLen;\n        to.outputLen = outputLen;\n        to.oHash = oHash._cloneInto(to.oHash);\n        to.iHash = iHash._cloneInto(to.iHash);\n        return to;\n    }\n    destroy() {\n        this.destroyed = true;\n        this.oHash.destroy();\n        this.iHash.destroy();\n    }\n}\n/**\n * HMAC: RFC2104 message authentication code.\n * @param hash - function that would be used e.g. sha256\n * @param key - message key\n * @param message - message data\n */\nexport const hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();\nhmac.create = (hash, key) => new HMAC(hash, key);\n//# sourceMappingURL=hmac.js.map","/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// Abelian group utilities\nimport { validateField, nLength } from './modular.js';\nimport { validateObject } from './utils.js';\nconst _0n = BigInt(0);\nconst _1n = BigInt(1);\n// Elliptic curve multiplication of Point by scalar. Fragile.\n// Scalars should always be less than curve order: this should be checked inside of a curve itself.\n// Creates precomputation tables for fast multiplication:\n// - private scalar is split by fixed size windows of W bits\n// - every window point is collected from window's table & added to accumulator\n// - since windows are different, same point inside tables won't be accessed more than once per calc\n// - each multiplication is 'Math.ceil(CURVE_ORDER / 𝑊) + 1' point additions (fixed for any scalar)\n// - +1 window is neccessary for wNAF\n// - wNAF reduces table size: 2x less memory + 2x faster generation, but 10% slower multiplication\n// TODO: Research returning 2d JS array of windows, instead of a single window. This would allow\n// windows to be in different memory locations\nexport function wNAF(c, bits) {\n    const constTimeNegate = (condition, item) => {\n        const neg = item.negate();\n        return condition ? neg : item;\n    };\n    const opts = (W) => {\n        const windows = Math.ceil(bits / W) + 1; // +1, because\n        const windowSize = 2 ** (W - 1); // -1 because we skip zero\n        return { windows, windowSize };\n    };\n    return {\n        constTimeNegate,\n        // non-const time multiplication ladder\n        unsafeLadder(elm, n) {\n            let p = c.ZERO;\n            let d = elm;\n            while (n > _0n) {\n                if (n & _1n)\n                    p = p.add(d);\n                d = d.double();\n                n >>= _1n;\n            }\n            return p;\n        },\n        /**\n         * Creates a wNAF precomputation window. Used for caching.\n         * Default window size is set by `utils.precompute()` and is equal to 8.\n         * Number of precomputed points depends on the curve size:\n         * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:\n         * - 𝑊 is the window size\n         * - 𝑛 is the bitlength of the curve order.\n         * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.\n         * @returns precomputed point tables flattened to a single array\n         */\n        precomputeWindow(elm, W) {\n            const { windows, windowSize } = opts(W);\n            const points = [];\n            let p = elm;\n            let base = p;\n            for (let window = 0; window < windows; window++) {\n                base = p;\n                points.push(base);\n                // =1, because we skip zero\n                for (let i = 1; i < windowSize; i++) {\n                    base = base.add(p);\n                    points.push(base);\n                }\n                p = base.double();\n            }\n            return points;\n        },\n        /**\n         * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.\n         * @param W window size\n         * @param precomputes precomputed tables\n         * @param n scalar (we don't check here, but should be less than curve order)\n         * @returns real and fake (for const-time) points\n         */\n        wNAF(W, precomputes, n) {\n            // TODO: maybe check that scalar is less than group order? wNAF behavious is undefined otherwise\n            // But need to carefully remove other checks before wNAF. ORDER == bits here\n            const { windows, windowSize } = opts(W);\n            let p = c.ZERO;\n            let f = c.BASE;\n            const mask = BigInt(2 ** W - 1); // Create mask with W ones: 0b1111 for W=4 etc.\n            const maxNumber = 2 ** W;\n            const shiftBy = BigInt(W);\n            for (let window = 0; window < windows; window++) {\n                const offset = window * windowSize;\n                // Extract W bits.\n                let wbits = Number(n & mask);\n                // Shift number by W bits.\n                n >>= shiftBy;\n                // If the bits are bigger than max size, we'll split those.\n                // +224 => 256 - 32\n                if (wbits > windowSize) {\n                    wbits -= maxNumber;\n                    n += _1n;\n                }\n                // This code was first written with assumption that 'f' and 'p' will never be infinity point:\n                // since each addition is multiplied by 2 ** W, it cannot cancel each other. However,\n                // there is negate now: it is possible that negated element from low value\n                // would be the same as high element, which will create carry into next window.\n                // It's not obvious how this can fail, but still worth investigating later.\n                // Check if we're onto Zero point.\n                // Add random point inside current window to f.\n                const offset1 = offset;\n                const offset2 = offset + Math.abs(wbits) - 1; // -1 because we skip zero\n                const cond1 = window % 2 !== 0;\n                const cond2 = wbits < 0;\n                if (wbits === 0) {\n                    // The most important part for const-time getPublicKey\n                    f = f.add(constTimeNegate(cond1, precomputes[offset1]));\n                }\n                else {\n                    p = p.add(constTimeNegate(cond2, precomputes[offset2]));\n                }\n            }\n            // JIT-compiler should not eliminate f here, since it will later be used in normalizeZ()\n            // Even if the variable is still unused, there are some checks which will\n            // throw an exception, so compiler needs to prove they won't happen, which is hard.\n            // At this point there is a way to F be infinity-point even if p is not,\n            // which makes it less const-time: around 1 bigint multiply.\n            return { p, f };\n        },\n        wNAFCached(P, precomputesMap, n, transform) {\n            // @ts-ignore\n            const W = P._WINDOW_SIZE || 1;\n            // Calculate precomputes on a first run, reuse them after\n            let comp = precomputesMap.get(P);\n            if (!comp) {\n                comp = this.precomputeWindow(P, W);\n                if (W !== 1) {\n                    precomputesMap.set(P, transform(comp));\n                }\n            }\n            return this.wNAF(W, comp, n);\n        },\n    };\n}\nexport function validateBasic(curve) {\n    validateField(curve.Fp);\n    validateObject(curve, {\n        n: 'bigint',\n        h: 'bigint',\n        Gx: 'field',\n        Gy: 'field',\n    }, {\n        nBitLength: 'isSafeInteger',\n        nByteLength: 'isSafeInteger',\n    });\n    // Set defaults\n    return Object.freeze({\n        ...nLength(curve.n, curve.nBitLength),\n        ...curve,\n        ...{ p: curve.Fp.ORDER },\n    });\n}\n//# sourceMappingURL=curve.js.map","/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// Short Weierstrass curve. The formula is: y² = x³ + ax + b\nimport * as mod from './modular.js';\nimport * as ut from './utils.js';\nimport { ensureBytes } from './utils.js';\nimport { wNAF, validateBasic } from './curve.js';\nfunction validatePointOpts(curve) {\n    const opts = validateBasic(curve);\n    ut.validateObject(opts, {\n        a: 'field',\n        b: 'field',\n    }, {\n        allowedPrivateKeyLengths: 'array',\n        wrapPrivateKey: 'boolean',\n        isTorsionFree: 'function',\n        clearCofactor: 'function',\n        allowInfinityPoint: 'boolean',\n        fromBytes: 'function',\n        toBytes: 'function',\n    });\n    const { endo, Fp, a } = opts;\n    if (endo) {\n        if (!Fp.eql(a, Fp.ZERO)) {\n            throw new Error('Endomorphism can only be defined for Koblitz curves that have a=0');\n        }\n        if (typeof endo !== 'object' ||\n            typeof endo.beta !== 'bigint' ||\n            typeof endo.splitScalar !== 'function') {\n            throw new Error('Expected endomorphism with beta: bigint and splitScalar: function');\n        }\n    }\n    return Object.freeze({ ...opts });\n}\n// ASN.1 DER encoding utilities\nconst { bytesToNumberBE: b2n, hexToBytes: h2b } = ut;\nexport const DER = {\n    // asn.1 DER encoding utils\n    Err: class DERErr extends Error {\n        constructor(m = '') {\n            super(m);\n        }\n    },\n    _parseInt(data) {\n        const { Err: E } = DER;\n        if (data.length < 2 || data[0] !== 0x02)\n            throw new E('Invalid signature integer tag');\n        const len = data[1];\n        const res = data.subarray(2, len + 2);\n        if (!len || res.length !== len)\n            throw new E('Invalid signature integer: wrong length');\n        // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,\n        // since we always use positive integers here. It must always be empty:\n        // - add zero byte if exists\n        // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)\n        if (res[0] & 0b10000000)\n            throw new E('Invalid signature integer: negative');\n        if (res[0] === 0x00 && !(res[1] & 0b10000000))\n            throw new E('Invalid signature integer: unnecessary leading zero');\n        return { d: b2n(res), l: data.subarray(len + 2) }; // d is data, l is left\n    },\n    toSig(hex) {\n        // parse DER signature\n        const { Err: E } = DER;\n        const data = typeof hex === 'string' ? h2b(hex) : hex;\n        if (!(data instanceof Uint8Array))\n            throw new Error('ui8a expected');\n        let l = data.length;\n        if (l < 2 || data[0] != 0x30)\n            throw new E('Invalid signature tag');\n        if (data[1] !== l - 2)\n            throw new E('Invalid signature: incorrect length');\n        const { d: r, l: sBytes } = DER._parseInt(data.subarray(2));\n        const { d: s, l: rBytesLeft } = DER._parseInt(sBytes);\n        if (rBytesLeft.length)\n            throw new E('Invalid signature: left bytes after parsing');\n        return { r, s };\n    },\n    hexFromSig(sig) {\n        // Add leading zero if first byte has negative bit enabled. More details in '_parseInt'\n        const slice = (s) => (Number.parseInt(s[0], 16) & 0b1000 ? '00' + s : s);\n        const h = (num) => {\n            const hex = num.toString(16);\n            return hex.length & 1 ? `0${hex}` : hex;\n        };\n        const s = slice(h(sig.s));\n        const r = slice(h(sig.r));\n        const shl = s.length / 2;\n        const rhl = r.length / 2;\n        const sl = h(shl);\n        const rl = h(rhl);\n        return `30${h(rhl + shl + 4)}02${rl}${r}02${sl}${s}`;\n    },\n};\n// Be friendly to bad ECMAScript parsers by not using bigint literals\n// prettier-ignore\nconst _0n = BigInt(0), _1n = BigInt(1), _2n = BigInt(2), _3n = BigInt(3), _4n = BigInt(4);\nexport function weierstrassPoints(opts) {\n    const CURVE = validatePointOpts(opts);\n    const { Fp } = CURVE; // All curves has same field / group length as for now, but they can differ\n    const toBytes = CURVE.toBytes ||\n        ((_c, point, _isCompressed) => {\n            const a = point.toAffine();\n            return ut.concatBytes(Uint8Array.from([0x04]), Fp.toBytes(a.x), Fp.toBytes(a.y));\n        });\n    const fromBytes = CURVE.fromBytes ||\n        ((bytes) => {\n            // const head = bytes[0];\n            const tail = bytes.subarray(1);\n            // if (head !== 0x04) throw new Error('Only non-compressed encoding is supported');\n            const x = Fp.fromBytes(tail.subarray(0, Fp.BYTES));\n            const y = Fp.fromBytes(tail.subarray(Fp.BYTES, 2 * Fp.BYTES));\n            return { x, y };\n        });\n    /**\n     * y² = x³ + ax + b: Short weierstrass curve formula\n     * @returns y²\n     */\n    function weierstrassEquation(x) {\n        const { a, b } = CURVE;\n        const x2 = Fp.sqr(x); // x * x\n        const x3 = Fp.mul(x2, x); // x2 * x\n        return Fp.add(Fp.add(x3, Fp.mul(x, a)), b); // x3 + a * x + b\n    }\n    // Validate whether the passed curve params are valid.\n    // We check if curve equation works for generator point.\n    // `assertValidity()` won't work: `isTorsionFree()` is not available at this point in bls12-381.\n    // ProjectivePoint class has not been initialized yet.\n    if (!Fp.eql(Fp.sqr(CURVE.Gy), weierstrassEquation(CURVE.Gx)))\n        throw new Error('bad generator point: equation left != right');\n    // Valid group elements reside in range 1..n-1\n    function isWithinCurveOrder(num) {\n        return typeof num === 'bigint' && _0n < num && num < CURVE.n;\n    }\n    function assertGE(num) {\n        if (!isWithinCurveOrder(num))\n            throw new Error('Expected valid bigint: 0 < bigint < curve.n');\n    }\n    // Validates if priv key is valid and converts it to bigint.\n    // Supports options allowedPrivateKeyLengths and wrapPrivateKey.\n    function normPrivateKeyToScalar(key) {\n        const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n } = CURVE;\n        if (lengths && typeof key !== 'bigint') {\n            if (key instanceof Uint8Array)\n                key = ut.bytesToHex(key);\n            // Normalize to hex string, pad. E.g. P521 would norm 130-132 char hex to 132-char bytes\n            if (typeof key !== 'string' || !lengths.includes(key.length))\n                throw new Error('Invalid key');\n            key = key.padStart(nByteLength * 2, '0');\n        }\n        let num;\n        try {\n            num =\n                typeof key === 'bigint'\n                    ? key\n                    : ut.bytesToNumberBE(ensureBytes('private key', key, nByteLength));\n        }\n        catch (error) {\n            throw new Error(`private key must be ${nByteLength} bytes, hex or bigint, not ${typeof key}`);\n        }\n        if (wrapPrivateKey)\n            num = mod.mod(num, n); // disabled by default, enabled for BLS\n        assertGE(num); // num in range [1..N-1]\n        return num;\n    }\n    const pointPrecomputes = new Map();\n    function assertPrjPoint(other) {\n        if (!(other instanceof Point))\n            throw new Error('ProjectivePoint expected');\n    }\n    /**\n     * Projective Point works in 3d / projective (homogeneous) coordinates: (x, y, z) ∋ (x=x/z, y=y/z)\n     * Default Point works in 2d / affine coordinates: (x, y)\n     * We're doing calculations in projective, because its operations don't require costly inversion.\n     */\n    class Point {\n        constructor(px, py, pz) {\n            this.px = px;\n            this.py = py;\n            this.pz = pz;\n            if (px == null || !Fp.isValid(px))\n                throw new Error('x required');\n            if (py == null || !Fp.isValid(py))\n                throw new Error('y required');\n            if (pz == null || !Fp.isValid(pz))\n                throw new Error('z required');\n        }\n        // Does not validate if the point is on-curve.\n        // Use fromHex instead, or call assertValidity() later.\n        static fromAffine(p) {\n            const { x, y } = p || {};\n            if (!p || !Fp.isValid(x) || !Fp.isValid(y))\n                throw new Error('invalid affine point');\n            if (p instanceof Point)\n                throw new Error('projective point not allowed');\n            const is0 = (i) => Fp.eql(i, Fp.ZERO);\n            // fromAffine(x:0, y:0) would produce (x:0, y:0, z:1), but we need (x:0, y:1, z:0)\n            if (is0(x) && is0(y))\n                return Point.ZERO;\n            return new Point(x, y, Fp.ONE);\n        }\n        get x() {\n            return this.toAffine().x;\n        }\n        get y() {\n            return this.toAffine().y;\n        }\n        /**\n         * Takes a bunch of Projective Points but executes only one\n         * inversion on all of them. Inversion is very slow operation,\n         * so this improves performance massively.\n         * Optimization: converts a list of projective points to a list of identical points with Z=1.\n         */\n        static normalizeZ(points) {\n            const toInv = Fp.invertBatch(points.map((p) => p.pz));\n            return points.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);\n        }\n        /**\n         * Converts hash string or Uint8Array to Point.\n         * @param hex short/long ECDSA hex\n         */\n        static fromHex(hex) {\n            const P = Point.fromAffine(fromBytes(ensureBytes('pointHex', hex)));\n            P.assertValidity();\n            return P;\n        }\n        // Multiplies generator point by privateKey.\n        static fromPrivateKey(privateKey) {\n            return Point.BASE.multiply(normPrivateKeyToScalar(privateKey));\n        }\n        // \"Private method\", don't use it directly\n        _setWindowSize(windowSize) {\n            this._WINDOW_SIZE = windowSize;\n            pointPrecomputes.delete(this);\n        }\n        // A point on curve is valid if it conforms to equation.\n        assertValidity() {\n            if (this.is0()) {\n                // (0, 1, 0) aka ZERO is invalid in most contexts.\n                // In BLS, ZERO can be serialized, so we allow it.\n                // (0, 0, 0) is wrong representation of ZERO and is always invalid.\n                if (CURVE.allowInfinityPoint && !Fp.is0(this.py))\n                    return;\n                throw new Error('bad point: ZERO');\n            }\n            // Some 3rd-party test vectors require different wording between here & `fromCompressedHex`\n            const { x, y } = this.toAffine();\n            // Check if x, y are valid field elements\n            if (!Fp.isValid(x) || !Fp.isValid(y))\n                throw new Error('bad point: x or y not FE');\n            const left = Fp.sqr(y); // y²\n            const right = weierstrassEquation(x); // x³ + ax + b\n            if (!Fp.eql(left, right))\n                throw new Error('bad point: equation left != right');\n            if (!this.isTorsionFree())\n                throw new Error('bad point: not in prime-order subgroup');\n        }\n        hasEvenY() {\n            const { y } = this.toAffine();\n            if (Fp.isOdd)\n                return !Fp.isOdd(y);\n            throw new Error(\"Field doesn't support isOdd\");\n        }\n        /**\n         * Compare one point to another.\n         */\n        equals(other) {\n            assertPrjPoint(other);\n            const { px: X1, py: Y1, pz: Z1 } = this;\n            const { px: X2, py: Y2, pz: Z2 } = other;\n            const U1 = Fp.eql(Fp.mul(X1, Z2), Fp.mul(X2, Z1));\n            const U2 = Fp.eql(Fp.mul(Y1, Z2), Fp.mul(Y2, Z1));\n            return U1 && U2;\n        }\n        /**\n         * Flips point to one corresponding to (x, -y) in Affine coordinates.\n         */\n        negate() {\n            return new Point(this.px, Fp.neg(this.py), this.pz);\n        }\n        // Renes-Costello-Batina exception-free doubling formula.\n        // There is 30% faster Jacobian formula, but it is not complete.\n        // https://eprint.iacr.org/2015/1060, algorithm 3\n        // Cost: 8M + 3S + 3*a + 2*b3 + 15add.\n        double() {\n            const { a, b } = CURVE;\n            const b3 = Fp.mul(b, _3n);\n            const { px: X1, py: Y1, pz: Z1 } = this;\n            let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO; // prettier-ignore\n            let t0 = Fp.mul(X1, X1); // step 1\n            let t1 = Fp.mul(Y1, Y1);\n            let t2 = Fp.mul(Z1, Z1);\n            let t3 = Fp.mul(X1, Y1);\n            t3 = Fp.add(t3, t3); // step 5\n            Z3 = Fp.mul(X1, Z1);\n            Z3 = Fp.add(Z3, Z3);\n            X3 = Fp.mul(a, Z3);\n            Y3 = Fp.mul(b3, t2);\n            Y3 = Fp.add(X3, Y3); // step 10\n            X3 = Fp.sub(t1, Y3);\n            Y3 = Fp.add(t1, Y3);\n            Y3 = Fp.mul(X3, Y3);\n            X3 = Fp.mul(t3, X3);\n            Z3 = Fp.mul(b3, Z3); // step 15\n            t2 = Fp.mul(a, t2);\n            t3 = Fp.sub(t0, t2);\n            t3 = Fp.mul(a, t3);\n            t3 = Fp.add(t3, Z3);\n            Z3 = Fp.add(t0, t0); // step 20\n            t0 = Fp.add(Z3, t0);\n            t0 = Fp.add(t0, t2);\n            t0 = Fp.mul(t0, t3);\n            Y3 = Fp.add(Y3, t0);\n            t2 = Fp.mul(Y1, Z1); // step 25\n            t2 = Fp.add(t2, t2);\n            t0 = Fp.mul(t2, t3);\n            X3 = Fp.sub(X3, t0);\n            Z3 = Fp.mul(t2, t1);\n            Z3 = Fp.add(Z3, Z3); // step 30\n            Z3 = Fp.add(Z3, Z3);\n            return new Point(X3, Y3, Z3);\n        }\n        // Renes-Costello-Batina exception-free addition formula.\n        // There is 30% faster Jacobian formula, but it is not complete.\n        // https://eprint.iacr.org/2015/1060, algorithm 1\n        // Cost: 12M + 0S + 3*a + 3*b3 + 23add.\n        add(other) {\n            assertPrjPoint(other);\n            const { px: X1, py: Y1, pz: Z1 } = this;\n            const { px: X2, py: Y2, pz: Z2 } = other;\n            let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO; // prettier-ignore\n            const a = CURVE.a;\n            const b3 = Fp.mul(CURVE.b, _3n);\n            let t0 = Fp.mul(X1, X2); // step 1\n            let t1 = Fp.mul(Y1, Y2);\n            let t2 = Fp.mul(Z1, Z2);\n            let t3 = Fp.add(X1, Y1);\n            let t4 = Fp.add(X2, Y2); // step 5\n            t3 = Fp.mul(t3, t4);\n            t4 = Fp.add(t0, t1);\n            t3 = Fp.sub(t3, t4);\n            t4 = Fp.add(X1, Z1);\n            let t5 = Fp.add(X2, Z2); // step 10\n            t4 = Fp.mul(t4, t5);\n            t5 = Fp.add(t0, t2);\n            t4 = Fp.sub(t4, t5);\n            t5 = Fp.add(Y1, Z1);\n            X3 = Fp.add(Y2, Z2); // step 15\n            t5 = Fp.mul(t5, X3);\n            X3 = Fp.add(t1, t2);\n            t5 = Fp.sub(t5, X3);\n            Z3 = Fp.mul(a, t4);\n            X3 = Fp.mul(b3, t2); // step 20\n            Z3 = Fp.add(X3, Z3);\n            X3 = Fp.sub(t1, Z3);\n            Z3 = Fp.add(t1, Z3);\n            Y3 = Fp.mul(X3, Z3);\n            t1 = Fp.add(t0, t0); // step 25\n            t1 = Fp.add(t1, t0);\n            t2 = Fp.mul(a, t2);\n            t4 = Fp.mul(b3, t4);\n            t1 = Fp.add(t1, t2);\n            t2 = Fp.sub(t0, t2); // step 30\n            t2 = Fp.mul(a, t2);\n            t4 = Fp.add(t4, t2);\n            t0 = Fp.mul(t1, t4);\n            Y3 = Fp.add(Y3, t0);\n            t0 = Fp.mul(t5, t4); // step 35\n            X3 = Fp.mul(t3, X3);\n            X3 = Fp.sub(X3, t0);\n            t0 = Fp.mul(t3, t1);\n            Z3 = Fp.mul(t5, Z3);\n            Z3 = Fp.add(Z3, t0); // step 40\n            return new Point(X3, Y3, Z3);\n        }\n        subtract(other) {\n            return this.add(other.negate());\n        }\n        is0() {\n            return this.equals(Point.ZERO);\n        }\n        wNAF(n) {\n            return wnaf.wNAFCached(this, pointPrecomputes, n, (comp) => {\n                const toInv = Fp.invertBatch(comp.map((p) => p.pz));\n                return comp.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);\n            });\n        }\n        /**\n         * Non-constant-time multiplication. Uses double-and-add algorithm.\n         * It's faster, but should only be used when you don't care about\n         * an exposed private key e.g. sig verification, which works over *public* keys.\n         */\n        multiplyUnsafe(n) {\n            const I = Point.ZERO;\n            if (n === _0n)\n                return I;\n            assertGE(n); // Will throw on 0\n            if (n === _1n)\n                return this;\n            const { endo } = CURVE;\n            if (!endo)\n                return wnaf.unsafeLadder(this, n);\n            // Apply endomorphism\n            let { k1neg, k1, k2neg, k2 } = endo.splitScalar(n);\n            let k1p = I;\n            let k2p = I;\n            let d = this;\n            while (k1 > _0n || k2 > _0n) {\n                if (k1 & _1n)\n                    k1p = k1p.add(d);\n                if (k2 & _1n)\n                    k2p = k2p.add(d);\n                d = d.double();\n                k1 >>= _1n;\n                k2 >>= _1n;\n            }\n            if (k1neg)\n                k1p = k1p.negate();\n            if (k2neg)\n                k2p = k2p.negate();\n            k2p = new Point(Fp.mul(k2p.px, endo.beta), k2p.py, k2p.pz);\n            return k1p.add(k2p);\n        }\n        /**\n         * Constant time multiplication.\n         * Uses wNAF method. Windowed method may be 10% faster,\n         * but takes 2x longer to generate and consumes 2x memory.\n         * Uses precomputes when available.\n         * Uses endomorphism for Koblitz curves.\n         * @param scalar by which the point would be multiplied\n         * @returns New point\n         */\n        multiply(scalar) {\n            assertGE(scalar);\n            let n = scalar;\n            let point, fake; // Fake point is used to const-time mult\n            const { endo } = CURVE;\n            if (endo) {\n                const { k1neg, k1, k2neg, k2 } = endo.splitScalar(n);\n                let { p: k1p, f: f1p } = this.wNAF(k1);\n                let { p: k2p, f: f2p } = this.wNAF(k2);\n                k1p = wnaf.constTimeNegate(k1neg, k1p);\n                k2p = wnaf.constTimeNegate(k2neg, k2p);\n                k2p = new Point(Fp.mul(k2p.px, endo.beta), k2p.py, k2p.pz);\n                point = k1p.add(k2p);\n                fake = f1p.add(f2p);\n            }\n            else {\n                const { p, f } = this.wNAF(n);\n                point = p;\n                fake = f;\n            }\n            // Normalize `z` for both points, but return only real one\n            return Point.normalizeZ([point, fake])[0];\n        }\n        /**\n         * Efficiently calculate `aP + bQ`. Unsafe, can expose private key, if used incorrectly.\n         * Not using Strauss-Shamir trick: precomputation tables are faster.\n         * The trick could be useful if both P and Q are not G (not in our case).\n         * @returns non-zero affine point\n         */\n        multiplyAndAddUnsafe(Q, a, b) {\n            const G = Point.BASE; // No Strauss-Shamir trick: we have 10% faster G precomputes\n            const mul = (P, a // Select faster multiply() method\n            ) => (a === _0n || a === _1n || !P.equals(G) ? P.multiplyUnsafe(a) : P.multiply(a));\n            const sum = mul(this, a).add(mul(Q, b));\n            return sum.is0() ? undefined : sum;\n        }\n        // Converts Projective point to affine (x, y) coordinates.\n        // Can accept precomputed Z^-1 - for example, from invertBatch.\n        // (x, y, z) ∋ (x=x/z, y=y/z)\n        toAffine(iz) {\n            const { px: x, py: y, pz: z } = this;\n            const is0 = this.is0();\n            // If invZ was 0, we return zero point. However we still want to execute\n            // all operations, so we replace invZ with a random number, 1.\n            if (iz == null)\n                iz = is0 ? Fp.ONE : Fp.inv(z);\n            const ax = Fp.mul(x, iz);\n            const ay = Fp.mul(y, iz);\n            const zz = Fp.mul(z, iz);\n            if (is0)\n                return { x: Fp.ZERO, y: Fp.ZERO };\n            if (!Fp.eql(zz, Fp.ONE))\n                throw new Error('invZ was invalid');\n            return { x: ax, y: ay };\n        }\n        isTorsionFree() {\n            const { h: cofactor, isTorsionFree } = CURVE;\n            if (cofactor === _1n)\n                return true; // No subgroups, always torsion-free\n            if (isTorsionFree)\n                return isTorsionFree(Point, this);\n            throw new Error('isTorsionFree() has not been declared for the elliptic curve');\n        }\n        clearCofactor() {\n            const { h: cofactor, clearCofactor } = CURVE;\n            if (cofactor === _1n)\n                return this; // Fast-path\n            if (clearCofactor)\n                return clearCofactor(Point, this);\n            return this.multiplyUnsafe(CURVE.h);\n        }\n        toRawBytes(isCompressed = true) {\n            this.assertValidity();\n            return toBytes(Point, this, isCompressed);\n        }\n        toHex(isCompressed = true) {\n            return ut.bytesToHex(this.toRawBytes(isCompressed));\n        }\n    }\n    Point.BASE = new Point(CURVE.Gx, CURVE.Gy, Fp.ONE);\n    Point.ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ZERO);\n    const _bits = CURVE.nBitLength;\n    const wnaf = wNAF(Point, CURVE.endo ? Math.ceil(_bits / 2) : _bits);\n    // Validate if generator point is on curve\n    return {\n        CURVE,\n        ProjectivePoint: Point,\n        normPrivateKeyToScalar,\n        weierstrassEquation,\n        isWithinCurveOrder,\n    };\n}\nfunction validateOpts(curve) {\n    const opts = validateBasic(curve);\n    ut.validateObject(opts, {\n        hash: 'hash',\n        hmac: 'function',\n        randomBytes: 'function',\n    }, {\n        bits2int: 'function',\n        bits2int_modN: 'function',\n        lowS: 'boolean',\n    });\n    return Object.freeze({ lowS: true, ...opts });\n}\nexport function weierstrass(curveDef) {\n    const CURVE = validateOpts(curveDef);\n    const { Fp, n: CURVE_ORDER } = CURVE;\n    const compressedLen = Fp.BYTES + 1; // e.g. 33 for 32\n    const uncompressedLen = 2 * Fp.BYTES + 1; // e.g. 65 for 32\n    function isValidFieldElement(num) {\n        return _0n < num && num < Fp.ORDER; // 0 is banned since it's not invertible FE\n    }\n    function modN(a) {\n        return mod.mod(a, CURVE_ORDER);\n    }\n    function invN(a) {\n        return mod.invert(a, CURVE_ORDER);\n    }\n    const { ProjectivePoint: Point, normPrivateKeyToScalar, weierstrassEquation, isWithinCurveOrder, } = weierstrassPoints({\n        ...CURVE,\n        toBytes(_c, point, isCompressed) {\n            const a = point.toAffine();\n            const x = Fp.toBytes(a.x);\n            const cat = ut.concatBytes;\n            if (isCompressed) {\n                return cat(Uint8Array.from([point.hasEvenY() ? 0x02 : 0x03]), x);\n            }\n            else {\n                return cat(Uint8Array.from([0x04]), x, Fp.toBytes(a.y));\n            }\n        },\n        fromBytes(bytes) {\n            const len = bytes.length;\n            const head = bytes[0];\n            const tail = bytes.subarray(1);\n            // this.assertValidity() is done inside of fromHex\n            if (len === compressedLen && (head === 0x02 || head === 0x03)) {\n                const x = ut.bytesToNumberBE(tail);\n                if (!isValidFieldElement(x))\n                    throw new Error('Point is not on curve');\n                const y2 = weierstrassEquation(x); // y² = x³ + ax + b\n                let y = Fp.sqrt(y2); // y = y² ^ (p+1)/4\n                const isYOdd = (y & _1n) === _1n;\n                // ECDSA\n                const isHeadOdd = (head & 1) === 1;\n                if (isHeadOdd !== isYOdd)\n                    y = Fp.neg(y);\n                return { x, y };\n            }\n            else if (len === uncompressedLen && head === 0x04) {\n                const x = Fp.fromBytes(tail.subarray(0, Fp.BYTES));\n                const y = Fp.fromBytes(tail.subarray(Fp.BYTES, 2 * Fp.BYTES));\n                return { x, y };\n            }\n            else {\n                throw new Error(`Point of length ${len} was invalid. Expected ${compressedLen} compressed bytes or ${uncompressedLen} uncompressed bytes`);\n            }\n        },\n    });\n    const numToNByteStr = (num) => ut.bytesToHex(ut.numberToBytesBE(num, CURVE.nByteLength));\n    function isBiggerThanHalfOrder(number) {\n        const HALF = CURVE_ORDER >> _1n;\n        return number > HALF;\n    }\n    function normalizeS(s) {\n        return isBiggerThanHalfOrder(s) ? modN(-s) : s;\n    }\n    // slice bytes num\n    const slcNum = (b, from, to) => ut.bytesToNumberBE(b.slice(from, to));\n    /**\n     * ECDSA signature with its (r, s) properties. Supports DER & compact representations.\n     */\n    class Signature {\n        constructor(r, s, recovery) {\n            this.r = r;\n            this.s = s;\n            this.recovery = recovery;\n            this.assertValidity();\n        }\n        // pair (bytes of r, bytes of s)\n        static fromCompact(hex) {\n            const l = CURVE.nByteLength;\n            hex = ensureBytes('compactSignature', hex, l * 2);\n            return new Signature(slcNum(hex, 0, l), slcNum(hex, l, 2 * l));\n        }\n        // DER encoded ECDSA signature\n        // https://bitcoin.stackexchange.com/questions/57644/what-are-the-parts-of-a-bitcoin-transaction-input-script\n        static fromDER(hex) {\n            const { r, s } = DER.toSig(ensureBytes('DER', hex));\n            return new Signature(r, s);\n        }\n        assertValidity() {\n            // can use assertGE here\n            if (!isWithinCurveOrder(this.r))\n                throw new Error('r must be 0 < r < CURVE.n');\n            if (!isWithinCurveOrder(this.s))\n                throw new Error('s must be 0 < s < CURVE.n');\n        }\n        addRecoveryBit(recovery) {\n            return new Signature(this.r, this.s, recovery);\n        }\n        recoverPublicKey(msgHash) {\n            const { r, s, recovery: rec } = this;\n            const h = bits2int_modN(ensureBytes('msgHash', msgHash)); // Truncate hash\n            if (rec == null || ![0, 1, 2, 3].includes(rec))\n                throw new Error('recovery id invalid');\n            const radj = rec === 2 || rec === 3 ? r + CURVE.n : r;\n            if (radj >= Fp.ORDER)\n                throw new Error('recovery id 2 or 3 invalid');\n            const prefix = (rec & 1) === 0 ? '02' : '03';\n            const R = Point.fromHex(prefix + numToNByteStr(radj));\n            const ir = invN(radj); // r^-1\n            const u1 = modN(-h * ir); // -hr^-1\n            const u2 = modN(s * ir); // sr^-1\n            const Q = Point.BASE.multiplyAndAddUnsafe(R, u1, u2); // (sr^-1)R-(hr^-1)G = -(hr^-1)G + (sr^-1)\n            if (!Q)\n                throw new Error('point at infinify'); // unsafe is fine: no priv data leaked\n            Q.assertValidity();\n            return Q;\n        }\n        // Signatures should be low-s, to prevent malleability.\n        hasHighS() {\n            return isBiggerThanHalfOrder(this.s);\n        }\n        normalizeS() {\n            return this.hasHighS() ? new Signature(this.r, modN(-this.s), this.recovery) : this;\n        }\n        // DER-encoded\n        toDERRawBytes() {\n            return ut.hexToBytes(this.toDERHex());\n        }\n        toDERHex() {\n            return DER.hexFromSig({ r: this.r, s: this.s });\n        }\n        // padded bytes of r, then padded bytes of s\n        toCompactRawBytes() {\n            return ut.hexToBytes(this.toCompactHex());\n        }\n        toCompactHex() {\n            return numToNByteStr(this.r) + numToNByteStr(this.s);\n        }\n    }\n    const utils = {\n        isValidPrivateKey(privateKey) {\n            try {\n                normPrivateKeyToScalar(privateKey);\n                return true;\n            }\n            catch (error) {\n                return false;\n            }\n        },\n        normPrivateKeyToScalar: normPrivateKeyToScalar,\n        /**\n         * Produces cryptographically secure private key from random of size\n         * (groupLen + ceil(groupLen / 2)) with modulo bias being negligible.\n         */\n        randomPrivateKey: () => {\n            const length = mod.getMinHashLength(CURVE.n);\n            return mod.mapHashToField(CURVE.randomBytes(length), CURVE.n);\n        },\n        /**\n         * Creates precompute table for an arbitrary EC point. Makes point \"cached\".\n         * Allows to massively speed-up `point.multiply(scalar)`.\n         * @returns cached point\n         * @example\n         * const fast = utils.precompute(8, ProjectivePoint.fromHex(someonesPubKey));\n         * fast.multiply(privKey); // much faster ECDH now\n         */\n        precompute(windowSize = 8, point = Point.BASE) {\n            point._setWindowSize(windowSize);\n            point.multiply(BigInt(3)); // 3 is arbitrary, just need any number here\n            return point;\n        },\n    };\n    /**\n     * Computes public key for a private key. Checks for validity of the private key.\n     * @param privateKey private key\n     * @param isCompressed whether to return compact (default), or full key\n     * @returns Public key, full when isCompressed=false; short when isCompressed=true\n     */\n    function getPublicKey(privateKey, isCompressed = true) {\n        return Point.fromPrivateKey(privateKey).toRawBytes(isCompressed);\n    }\n    /**\n     * Quick and dirty check for item being public key. Does not validate hex, or being on-curve.\n     */\n    function isProbPub(item) {\n        const arr = item instanceof Uint8Array;\n        const str = typeof item === 'string';\n        const len = (arr || str) && item.length;\n        if (arr)\n            return len === compressedLen || len === uncompressedLen;\n        if (str)\n            return len === 2 * compressedLen || len === 2 * uncompressedLen;\n        if (item instanceof Point)\n            return true;\n        return false;\n    }\n    /**\n     * ECDH (Elliptic Curve Diffie Hellman).\n     * Computes shared public key from private key and public key.\n     * Checks: 1) private key validity 2) shared key is on-curve.\n     * Does NOT hash the result.\n     * @param privateA private key\n     * @param publicB different public key\n     * @param isCompressed whether to return compact (default), or full key\n     * @returns shared public key\n     */\n    function getSharedSecret(privateA, publicB, isCompressed = true) {\n        if (isProbPub(privateA))\n            throw new Error('first arg must be private key');\n        if (!isProbPub(publicB))\n            throw new Error('second arg must be public key');\n        const b = Point.fromHex(publicB); // check for being on-curve\n        return b.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);\n    }\n    // RFC6979: ensure ECDSA msg is X bytes and < N. RFC suggests optional truncating via bits2octets.\n    // FIPS 186-4 4.6 suggests the leftmost min(nBitLen, outLen) bits, which matches bits2int.\n    // bits2int can produce res>N, we can do mod(res, N) since the bitLen is the same.\n    // int2octets can't be used; pads small msgs with 0: unacceptatble for trunc as per RFC vectors\n    const bits2int = CURVE.bits2int ||\n        function (bytes) {\n            // For curves with nBitLength % 8 !== 0: bits2octets(bits2octets(m)) !== bits2octets(m)\n            // for some cases, since bytes.length * 8 is not actual bitLength.\n            const num = ut.bytesToNumberBE(bytes); // check for == u8 done here\n            const delta = bytes.length * 8 - CURVE.nBitLength; // truncate to nBitLength leftmost bits\n            return delta > 0 ? num >> BigInt(delta) : num;\n        };\n    const bits2int_modN = CURVE.bits2int_modN ||\n        function (bytes) {\n            return modN(bits2int(bytes)); // can't use bytesToNumberBE here\n        };\n    // NOTE: pads output with zero as per spec\n    const ORDER_MASK = ut.bitMask(CURVE.nBitLength);\n    /**\n     * Converts to bytes. Checks if num in `[0..ORDER_MASK-1]` e.g.: `[0..2^256-1]`.\n     */\n    function int2octets(num) {\n        if (typeof num !== 'bigint')\n            throw new Error('bigint expected');\n        if (!(_0n <= num && num < ORDER_MASK))\n            throw new Error(`bigint expected < 2^${CURVE.nBitLength}`);\n        // works with order, can have different size than numToField!\n        return ut.numberToBytesBE(num, CURVE.nByteLength);\n    }\n    // Steps A, D of RFC6979 3.2\n    // Creates RFC6979 seed; converts msg/privKey to numbers.\n    // Used only in sign, not in verify.\n    // NOTE: we cannot assume here that msgHash has same amount of bytes as curve order, this will be wrong at least for P521.\n    // Also it can be bigger for P224 + SHA256\n    function prepSig(msgHash, privateKey, opts = defaultSigOpts) {\n        if (['recovered', 'canonical'].some((k) => k in opts))\n            throw new Error('sign() legacy options not supported');\n        const { hash, randomBytes } = CURVE;\n        let { lowS, prehash, extraEntropy: ent } = opts; // generates low-s sigs by default\n        if (lowS == null)\n            lowS = true; // RFC6979 3.2: we skip step A, because we already provide hash\n        msgHash = ensureBytes('msgHash', msgHash);\n        if (prehash)\n            msgHash = ensureBytes('prehashed msgHash', hash(msgHash));\n        // We can't later call bits2octets, since nested bits2int is broken for curves\n        // with nBitLength % 8 !== 0. Because of that, we unwrap it here as int2octets call.\n        // const bits2octets = (bits) => int2octets(bits2int_modN(bits))\n        const h1int = bits2int_modN(msgHash);\n        const d = normPrivateKeyToScalar(privateKey); // validate private key, convert to bigint\n        const seedArgs = [int2octets(d), int2octets(h1int)];\n        // extraEntropy. RFC6979 3.6: additional k' (optional).\n        if (ent != null) {\n            // K = HMAC_K(V || 0x00 || int2octets(x) || bits2octets(h1) || k')\n            const e = ent === true ? randomBytes(Fp.BYTES) : ent; // generate random bytes OR pass as-is\n            seedArgs.push(ensureBytes('extraEntropy', e)); // check for being bytes\n        }\n        const seed = ut.concatBytes(...seedArgs); // Step D of RFC6979 3.2\n        const m = h1int; // NOTE: no need to call bits2int second time here, it is inside truncateHash!\n        // Converts signature params into point w r/s, checks result for validity.\n        function k2sig(kBytes) {\n            // RFC 6979 Section 3.2, step 3: k = bits2int(T)\n            const k = bits2int(kBytes); // Cannot use fields methods, since it is group element\n            if (!isWithinCurveOrder(k))\n                return; // Important: all mod() calls here must be done over N\n            const ik = invN(k); // k^-1 mod n\n            const q = Point.BASE.multiply(k).toAffine(); // q = Gk\n            const r = modN(q.x); // r = q.x mod n\n            if (r === _0n)\n                return;\n            // Can use scalar blinding b^-1(bm + bdr) where b ∈ [1,q−1] according to\n            // https://tches.iacr.org/index.php/TCHES/article/view/7337/6509. We've decided against it:\n            // a) dependency on CSPRNG b) 15% slowdown c) doesn't really help since bigints are not CT\n            const s = modN(ik * modN(m + r * d)); // Not using blinding here\n            if (s === _0n)\n                return;\n            let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n); // recovery bit (2 or 3, when q.x > n)\n            let normS = s;\n            if (lowS && isBiggerThanHalfOrder(s)) {\n                normS = normalizeS(s); // if lowS was passed, ensure s is always\n                recovery ^= 1; // // in the bottom half of N\n            }\n            return new Signature(r, normS, recovery); // use normS, not s\n        }\n        return { seed, k2sig };\n    }\n    const defaultSigOpts = { lowS: CURVE.lowS, prehash: false };\n    const defaultVerOpts = { lowS: CURVE.lowS, prehash: false };\n    /**\n     * Signs message hash with a private key.\n     * ```\n     * sign(m, d, k) where\n     *   (x, y) = G × k\n     *   r = x mod n\n     *   s = (m + dr)/k mod n\n     * ```\n     * @param msgHash NOT message. msg needs to be hashed to `msgHash`, or use `prehash`.\n     * @param privKey private key\n     * @param opts lowS for non-malleable sigs. extraEntropy for mixing randomness into k. prehash will hash first arg.\n     * @returns signature with recovery param\n     */\n    function sign(msgHash, privKey, opts = defaultSigOpts) {\n        const { seed, k2sig } = prepSig(msgHash, privKey, opts); // Steps A, D of RFC6979 3.2.\n        const C = CURVE;\n        const drbg = ut.createHmacDrbg(C.hash.outputLen, C.nByteLength, C.hmac);\n        return drbg(seed, k2sig); // Steps B, C, D, E, F, G\n    }\n    // Enable precomputes. Slows down first publicKey computation by 20ms.\n    Point.BASE._setWindowSize(8);\n    // utils.precompute(8, ProjectivePoint.BASE)\n    /**\n     * Verifies a signature against message hash and public key.\n     * Rejects lowS signatures by default: to override,\n     * specify option `{lowS: false}`. Implements section 4.1.4 from https://www.secg.org/sec1-v2.pdf:\n     *\n     * ```\n     * verify(r, s, h, P) where\n     *   U1 = hs^-1 mod n\n     *   U2 = rs^-1 mod n\n     *   R = U1⋅G - U2⋅P\n     *   mod(R.x, n) == r\n     * ```\n     */\n    function verify(signature, msgHash, publicKey, opts = defaultVerOpts) {\n        const sg = signature;\n        msgHash = ensureBytes('msgHash', msgHash);\n        publicKey = ensureBytes('publicKey', publicKey);\n        if ('strict' in opts)\n            throw new Error('options.strict was renamed to lowS');\n        const { lowS, prehash } = opts;\n        let _sig = undefined;\n        let P;\n        try {\n            if (typeof sg === 'string' || sg instanceof Uint8Array) {\n                // Signature can be represented in 2 ways: compact (2*nByteLength) & DER (variable-length).\n                // Since DER can also be 2*nByteLength bytes, we check for it first.\n                try {\n                    _sig = Signature.fromDER(sg);\n                }\n                catch (derError) {\n                    if (!(derError instanceof DER.Err))\n                        throw derError;\n                    _sig = Signature.fromCompact(sg);\n                }\n            }\n            else if (typeof sg === 'object' && typeof sg.r === 'bigint' && typeof sg.s === 'bigint') {\n                const { r, s } = sg;\n                _sig = new Signature(r, s);\n            }\n            else {\n                throw new Error('PARSE');\n            }\n            P = Point.fromHex(publicKey);\n        }\n        catch (error) {\n            if (error.message === 'PARSE')\n                throw new Error(`signature must be Signature instance, Uint8Array or hex string`);\n            return false;\n        }\n        if (lowS && _sig.hasHighS())\n            return false;\n        if (prehash)\n            msgHash = CURVE.hash(msgHash);\n        const { r, s } = _sig;\n        const h = bits2int_modN(msgHash); // Cannot use fields methods, since it is group element\n        const is = invN(s); // s^-1\n        const u1 = modN(h * is); // u1 = hs^-1 mod n\n        const u2 = modN(r * is); // u2 = rs^-1 mod n\n        const R = Point.BASE.multiplyAndAddUnsafe(P, u1, u2)?.toAffine(); // R = u1⋅G + u2⋅P\n        if (!R)\n            return false;\n        const v = modN(R.x);\n        return v === r;\n    }\n    return {\n        CURVE,\n        getPublicKey,\n        getSharedSecret,\n        sign,\n        verify,\n        ProjectivePoint: Point,\n        Signature,\n        utils,\n    };\n}\n/**\n * Implementation of the Shallue and van de Woestijne method for any weierstrass curve.\n * TODO: check if there is a way to merge this with uvRatio in Edwards; move to modular.\n * b = True and y = sqrt(u / v) if (u / v) is square in F, and\n * b = False and y = sqrt(Z * (u / v)) otherwise.\n * @param Fp\n * @param Z\n * @returns\n */\nexport function SWUFpSqrtRatio(Fp, Z) {\n    // Generic implementation\n    const q = Fp.ORDER;\n    let l = _0n;\n    for (let o = q - _1n; o % _2n === _0n; o /= _2n)\n        l += _1n;\n    const c1 = l; // 1. c1, the largest integer such that 2^c1 divides q - 1.\n    // We need 2n ** c1 and 2n ** (c1-1). We can't use **; but we can use <<.\n    // 2n ** c1 == 2n << (c1-1)\n    const _2n_pow_c1_1 = _2n << (c1 - _1n - _1n);\n    const _2n_pow_c1 = _2n_pow_c1_1 * _2n;\n    const c2 = (q - _1n) / _2n_pow_c1; // 2. c2 = (q - 1) / (2^c1)  # Integer arithmetic\n    const c3 = (c2 - _1n) / _2n; // 3. c3 = (c2 - 1) / 2            # Integer arithmetic\n    const c4 = _2n_pow_c1 - _1n; // 4. c4 = 2^c1 - 1                # Integer arithmetic\n    const c5 = _2n_pow_c1_1; // 5. c5 = 2^(c1 - 1)                  # Integer arithmetic\n    const c6 = Fp.pow(Z, c2); // 6. c6 = Z^c2\n    const c7 = Fp.pow(Z, (c2 + _1n) / _2n); // 7. c7 = Z^((c2 + 1) / 2)\n    let sqrtRatio = (u, v) => {\n        let tv1 = c6; // 1. tv1 = c6\n        let tv2 = Fp.pow(v, c4); // 2. tv2 = v^c4\n        let tv3 = Fp.sqr(tv2); // 3. tv3 = tv2^2\n        tv3 = Fp.mul(tv3, v); // 4. tv3 = tv3 * v\n        let tv5 = Fp.mul(u, tv3); // 5. tv5 = u * tv3\n        tv5 = Fp.pow(tv5, c3); // 6. tv5 = tv5^c3\n        tv5 = Fp.mul(tv5, tv2); // 7. tv5 = tv5 * tv2\n        tv2 = Fp.mul(tv5, v); // 8. tv2 = tv5 * v\n        tv3 = Fp.mul(tv5, u); // 9. tv3 = tv5 * u\n        let tv4 = Fp.mul(tv3, tv2); // 10. tv4 = tv3 * tv2\n        tv5 = Fp.pow(tv4, c5); // 11. tv5 = tv4^c5\n        let isQR = Fp.eql(tv5, Fp.ONE); // 12. isQR = tv5 == 1\n        tv2 = Fp.mul(tv3, c7); // 13. tv2 = tv3 * c7\n        tv5 = Fp.mul(tv4, tv1); // 14. tv5 = tv4 * tv1\n        tv3 = Fp.cmov(tv2, tv3, isQR); // 15. tv3 = CMOV(tv2, tv3, isQR)\n        tv4 = Fp.cmov(tv5, tv4, isQR); // 16. tv4 = CMOV(tv5, tv4, isQR)\n        // 17. for i in (c1, c1 - 1, ..., 2):\n        for (let i = c1; i > _1n; i--) {\n            let tv5 = i - _2n; // 18.    tv5 = i - 2\n            tv5 = _2n << (tv5 - _1n); // 19.    tv5 = 2^tv5\n            let tvv5 = Fp.pow(tv4, tv5); // 20.    tv5 = tv4^tv5\n            const e1 = Fp.eql(tvv5, Fp.ONE); // 21.    e1 = tv5 == 1\n            tv2 = Fp.mul(tv3, tv1); // 22.    tv2 = tv3 * tv1\n            tv1 = Fp.mul(tv1, tv1); // 23.    tv1 = tv1 * tv1\n            tvv5 = Fp.mul(tv4, tv1); // 24.    tv5 = tv4 * tv1\n            tv3 = Fp.cmov(tv2, tv3, e1); // 25.    tv3 = CMOV(tv2, tv3, e1)\n            tv4 = Fp.cmov(tvv5, tv4, e1); // 26.    tv4 = CMOV(tv5, tv4, e1)\n        }\n        return { isValid: isQR, value: tv3 };\n    };\n    if (Fp.ORDER % _4n === _3n) {\n        // sqrt_ratio_3mod4(u, v)\n        const c1 = (Fp.ORDER - _3n) / _4n; // 1. c1 = (q - 3) / 4     # Integer arithmetic\n        const c2 = Fp.sqrt(Fp.neg(Z)); // 2. c2 = sqrt(-Z)\n        sqrtRatio = (u, v) => {\n            let tv1 = Fp.sqr(v); // 1. tv1 = v^2\n            const tv2 = Fp.mul(u, v); // 2. tv2 = u * v\n            tv1 = Fp.mul(tv1, tv2); // 3. tv1 = tv1 * tv2\n            let y1 = Fp.pow(tv1, c1); // 4. y1 = tv1^c1\n            y1 = Fp.mul(y1, tv2); // 5. y1 = y1 * tv2\n            const y2 = Fp.mul(y1, c2); // 6. y2 = y1 * c2\n            const tv3 = Fp.mul(Fp.sqr(y1), v); // 7. tv3 = y1^2; 8. tv3 = tv3 * v\n            const isQR = Fp.eql(tv3, u); // 9. isQR = tv3 == u\n            let y = Fp.cmov(y2, y1, isQR); // 10. y = CMOV(y2, y1, isQR)\n            return { isValid: isQR, value: y }; // 11. return (isQR, y) isQR ? y : y*c2\n        };\n    }\n    // No curves uses that\n    // if (Fp.ORDER % _8n === _5n) // sqrt_ratio_5mod8\n    return sqrtRatio;\n}\n/**\n * Simplified Shallue-van de Woestijne-Ulas Method\n * https://www.rfc-editor.org/rfc/rfc9380#section-6.6.2\n */\nexport function mapToCurveSimpleSWU(Fp, opts) {\n    mod.validateField(Fp);\n    if (!Fp.isValid(opts.A) || !Fp.isValid(opts.B) || !Fp.isValid(opts.Z))\n        throw new Error('mapToCurveSimpleSWU: invalid opts');\n    const sqrtRatio = SWUFpSqrtRatio(Fp, opts.Z);\n    if (!Fp.isOdd)\n        throw new Error('Fp.isOdd is not implemented!');\n    // Input: u, an element of F.\n    // Output: (x, y), a point on E.\n    return (u) => {\n        // prettier-ignore\n        let tv1, tv2, tv3, tv4, tv5, tv6, x, y;\n        tv1 = Fp.sqr(u); // 1.  tv1 = u^2\n        tv1 = Fp.mul(tv1, opts.Z); // 2.  tv1 = Z * tv1\n        tv2 = Fp.sqr(tv1); // 3.  tv2 = tv1^2\n        tv2 = Fp.add(tv2, tv1); // 4.  tv2 = tv2 + tv1\n        tv3 = Fp.add(tv2, Fp.ONE); // 5.  tv3 = tv2 + 1\n        tv3 = Fp.mul(tv3, opts.B); // 6.  tv3 = B * tv3\n        tv4 = Fp.cmov(opts.Z, Fp.neg(tv2), !Fp.eql(tv2, Fp.ZERO)); // 7.  tv4 = CMOV(Z, -tv2, tv2 != 0)\n        tv4 = Fp.mul(tv4, opts.A); // 8.  tv4 = A * tv4\n        tv2 = Fp.sqr(tv3); // 9.  tv2 = tv3^2\n        tv6 = Fp.sqr(tv4); // 10. tv6 = tv4^2\n        tv5 = Fp.mul(tv6, opts.A); // 11. tv5 = A * tv6\n        tv2 = Fp.add(tv2, tv5); // 12. tv2 = tv2 + tv5\n        tv2 = Fp.mul(tv2, tv3); // 13. tv2 = tv2 * tv3\n        tv6 = Fp.mul(tv6, tv4); // 14. tv6 = tv6 * tv4\n        tv5 = Fp.mul(tv6, opts.B); // 15. tv5 = B * tv6\n        tv2 = Fp.add(tv2, tv5); // 16. tv2 = tv2 + tv5\n        x = Fp.mul(tv1, tv3); // 17.   x = tv1 * tv3\n        const { isValid, value } = sqrtRatio(tv2, tv6); // 18. (is_gx1_square, y1) = sqrt_ratio(tv2, tv6)\n        y = Fp.mul(tv1, u); // 19.   y = tv1 * u  -> Z * u^3 * y1\n        y = Fp.mul(y, value); // 20.   y = y * y1\n        x = Fp.cmov(x, tv3, isValid); // 21.   x = CMOV(x, tv3, is_gx1_square)\n        y = Fp.cmov(y, value, isValid); // 22.   y = CMOV(y, y1, is_gx1_square)\n        const e1 = Fp.isOdd(u) === Fp.isOdd(y); // 23.  e1 = sgn0(u) == sgn0(y)\n        y = Fp.cmov(Fp.neg(y), y, e1); // 24.   y = CMOV(-y, y, e1)\n        x = Fp.div(x, tv4); // 25.   x = x / tv4\n        return { x, y };\n    };\n}\n//# sourceMappingURL=weierstrass.js.map","/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { hmac } from '@noble/hashes/hmac';\nimport { concatBytes, randomBytes } from '@noble/hashes/utils';\nimport { weierstrass } from './abstract/weierstrass.js';\n// connects noble-curves to noble-hashes\nexport function getHash(hash) {\n    return {\n        hash,\n        hmac: (key, ...msgs) => hmac(hash, key, concatBytes(...msgs)),\n        randomBytes,\n    };\n}\nexport function createCurve(curveDef, defHash) {\n    const create = (hash) => weierstrass({ ...curveDef, ...getHash(hash) });\n    return Object.freeze({ ...create(defHash), create });\n}\n//# sourceMappingURL=_shortw_utils.js.map","/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { sha256 } from '@noble/hashes/sha256';\nimport { randomBytes } from '@noble/hashes/utils';\nimport { Field, mod, pow2 } from './abstract/modular.js';\nimport { mapToCurveSimpleSWU } from './abstract/weierstrass.js';\nimport { bytesToNumberBE, concatBytes, ensureBytes, numberToBytesBE } from './abstract/utils.js';\nimport { createHasher, isogenyMap } from './abstract/hash-to-curve.js';\nimport { createCurve } from './_shortw_utils.js';\nconst secp256k1P = BigInt('0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f');\nconst secp256k1N = BigInt('0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141');\nconst _1n = BigInt(1);\nconst _2n = BigInt(2);\nconst divNearest = (a, b) => (a + b / _2n) / b;\n/**\n * √n = n^((p+1)/4) for fields p = 3 mod 4. We unwrap the loop and multiply bit-by-bit.\n * (P+1n/4n).toString(2) would produce bits [223x 1, 0, 22x 1, 4x 0, 11, 00]\n */\nfunction sqrtMod(y) {\n    const P = secp256k1P;\n    // prettier-ignore\n    const _3n = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);\n    // prettier-ignore\n    const _23n = BigInt(23), _44n = BigInt(44), _88n = BigInt(88);\n    const b2 = (y * y * y) % P; // x^3, 11\n    const b3 = (b2 * b2 * y) % P; // x^7\n    const b6 = (pow2(b3, _3n, P) * b3) % P;\n    const b9 = (pow2(b6, _3n, P) * b3) % P;\n    const b11 = (pow2(b9, _2n, P) * b2) % P;\n    const b22 = (pow2(b11, _11n, P) * b11) % P;\n    const b44 = (pow2(b22, _22n, P) * b22) % P;\n    const b88 = (pow2(b44, _44n, P) * b44) % P;\n    const b176 = (pow2(b88, _88n, P) * b88) % P;\n    const b220 = (pow2(b176, _44n, P) * b44) % P;\n    const b223 = (pow2(b220, _3n, P) * b3) % P;\n    const t1 = (pow2(b223, _23n, P) * b22) % P;\n    const t2 = (pow2(t1, _6n, P) * b2) % P;\n    const root = pow2(t2, _2n, P);\n    if (!Fp.eql(Fp.sqr(root), y))\n        throw new Error('Cannot find square root');\n    return root;\n}\nconst Fp = Field(secp256k1P, undefined, undefined, { sqrt: sqrtMod });\nexport const secp256k1 = createCurve({\n    a: BigInt(0),\n    b: BigInt(7),\n    Fp,\n    n: secp256k1N,\n    // Base point (x, y) aka generator point\n    Gx: BigInt('55066263022277343669578718895168534326250603453777594175500187360389116729240'),\n    Gy: BigInt('32670510020758816978083085130507043184471273380659243275938904335757337482424'),\n    h: BigInt(1),\n    lowS: true,\n    /**\n     * secp256k1 belongs to Koblitz curves: it has efficiently computable endomorphism.\n     * Endomorphism uses 2x less RAM, speeds up precomputation by 2x and ECDH / key recovery by 20%.\n     * For precomputed wNAF it trades off 1/2 init time & 1/3 ram for 20% perf hit.\n     * Explanation: https://gist.github.com/paulmillr/eb670806793e84df628a7c434a873066\n     */\n    endo: {\n        beta: BigInt('0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee'),\n        splitScalar: (k) => {\n            const n = secp256k1N;\n            const a1 = BigInt('0x3086d221a7d46bcde86c90e49284eb15');\n            const b1 = -_1n * BigInt('0xe4437ed6010e88286f547fa90abfe4c3');\n            const a2 = BigInt('0x114ca50f7a8e2f3f657c1108d9d44cfd8');\n            const b2 = a1;\n            const POW_2_128 = BigInt('0x100000000000000000000000000000000'); // (2n**128n).toString(16)\n            const c1 = divNearest(b2 * k, n);\n            const c2 = divNearest(-b1 * k, n);\n            let k1 = mod(k - c1 * a1 - c2 * a2, n);\n            let k2 = mod(-c1 * b1 - c2 * b2, n);\n            const k1neg = k1 > POW_2_128;\n            const k2neg = k2 > POW_2_128;\n            if (k1neg)\n                k1 = n - k1;\n            if (k2neg)\n                k2 = n - k2;\n            if (k1 > POW_2_128 || k2 > POW_2_128) {\n                throw new Error('splitScalar: Endomorphism failed, k=' + k);\n            }\n            return { k1neg, k1, k2neg, k2 };\n        },\n    },\n}, sha256);\n// Schnorr signatures are superior to ECDSA from above. Below is Schnorr-specific BIP0340 code.\n// https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki\nconst _0n = BigInt(0);\nconst fe = (x) => typeof x === 'bigint' && _0n < x && x < secp256k1P;\nconst ge = (x) => typeof x === 'bigint' && _0n < x && x < secp256k1N;\n/** An object mapping tags to their tagged hash prefix of [SHA256(tag) | SHA256(tag)] */\nconst TAGGED_HASH_PREFIXES = {};\nfunction taggedHash(tag, ...messages) {\n    let tagP = TAGGED_HASH_PREFIXES[tag];\n    if (tagP === undefined) {\n        const tagH = sha256(Uint8Array.from(tag, (c) => c.charCodeAt(0)));\n        tagP = concatBytes(tagH, tagH);\n        TAGGED_HASH_PREFIXES[tag] = tagP;\n    }\n    return sha256(concatBytes(tagP, ...messages));\n}\n// ECDSA compact points are 33-byte. Schnorr is 32: we strip first byte 0x02 or 0x03\nconst pointToBytes = (point) => point.toRawBytes(true).slice(1);\nconst numTo32b = (n) => numberToBytesBE(n, 32);\nconst modP = (x) => mod(x, secp256k1P);\nconst modN = (x) => mod(x, secp256k1N);\nconst Point = secp256k1.ProjectivePoint;\nconst GmulAdd = (Q, a, b) => Point.BASE.multiplyAndAddUnsafe(Q, a, b);\n// Calculate point, scalar and bytes\nfunction schnorrGetExtPubKey(priv) {\n    let d_ = secp256k1.utils.normPrivateKeyToScalar(priv); // same method executed in fromPrivateKey\n    let p = Point.fromPrivateKey(d_); // P = d'⋅G; 0 < d' < n check is done inside\n    const scalar = p.hasEvenY() ? d_ : modN(-d_);\n    return { scalar: scalar, bytes: pointToBytes(p) };\n}\n/**\n * lift_x from BIP340. Convert 32-byte x coordinate to elliptic curve point.\n * @returns valid point checked for being on-curve\n */\nfunction lift_x(x) {\n    if (!fe(x))\n        throw new Error('bad x: need 0 < x < p'); // Fail if x ≥ p.\n    const xx = modP(x * x);\n    const c = modP(xx * x + BigInt(7)); // Let c = x³ + 7 mod p.\n    let y = sqrtMod(c); // Let y = c^(p+1)/4 mod p.\n    if (y % _2n !== _0n)\n        y = modP(-y); // Return the unique point P such that x(P) = x and\n    const p = new Point(x, y, _1n); // y(P) = y if y mod 2 = 0 or y(P) = p-y otherwise.\n    p.assertValidity();\n    return p;\n}\n/**\n * Create tagged hash, convert it to bigint, reduce modulo-n.\n */\nfunction challenge(...args) {\n    return modN(bytesToNumberBE(taggedHash('BIP0340/challenge', ...args)));\n}\n/**\n * Schnorr public key is just `x` coordinate of Point as per BIP340.\n */\nfunction schnorrGetPublicKey(privateKey) {\n    return schnorrGetExtPubKey(privateKey).bytes; // d'=int(sk). Fail if d'=0 or d'≥n. Ret bytes(d'⋅G)\n}\n/**\n * Creates Schnorr signature as per BIP340. Verifies itself before returning anything.\n * auxRand is optional and is not the sole source of k generation: bad CSPRNG won't be dangerous.\n */\nfunction schnorrSign(message, privateKey, auxRand = randomBytes(32)) {\n    const m = ensureBytes('message', message);\n    const { bytes: px, scalar: d } = schnorrGetExtPubKey(privateKey); // checks for isWithinCurveOrder\n    const a = ensureBytes('auxRand', auxRand, 32); // Auxiliary random data a: a 32-byte array\n    const t = numTo32b(d ^ bytesToNumberBE(taggedHash('BIP0340/aux', a))); // Let t be the byte-wise xor of bytes(d) and hash/aux(a)\n    const rand = taggedHash('BIP0340/nonce', t, px, m); // Let rand = hash/nonce(t || bytes(P) || m)\n    const k_ = modN(bytesToNumberBE(rand)); // Let k' = int(rand) mod n\n    if (k_ === _0n)\n        throw new Error('sign failed: k is zero'); // Fail if k' = 0.\n    const { bytes: rx, scalar: k } = schnorrGetExtPubKey(k_); // Let R = k'⋅G.\n    const e = challenge(rx, px, m); // Let e = int(hash/challenge(bytes(R) || bytes(P) || m)) mod n.\n    const sig = new Uint8Array(64); // Let sig = bytes(R) || bytes((k + ed) mod n).\n    sig.set(rx, 0);\n    sig.set(numTo32b(modN(k + e * d)), 32);\n    // If Verify(bytes(P), m, sig) (see below) returns failure, abort\n    if (!schnorrVerify(sig, m, px))\n        throw new Error('sign: Invalid signature produced');\n    return sig;\n}\n/**\n * Verifies Schnorr signature.\n * Will swallow errors & return false except for initial type validation of arguments.\n */\nfunction schnorrVerify(signature, message, publicKey) {\n    const sig = ensureBytes('signature', signature, 64);\n    const m = ensureBytes('message', message);\n    const pub = ensureBytes('publicKey', publicKey, 32);\n    try {\n        const P = lift_x(bytesToNumberBE(pub)); // P = lift_x(int(pk)); fail if that fails\n        const r = bytesToNumberBE(sig.subarray(0, 32)); // Let r = int(sig[0:32]); fail if r ≥ p.\n        if (!fe(r))\n            return false;\n        const s = bytesToNumberBE(sig.subarray(32, 64)); // Let s = int(sig[32:64]); fail if s ≥ n.\n        if (!ge(s))\n            return false;\n        const e = challenge(numTo32b(r), pointToBytes(P), m); // int(challenge(bytes(r)||bytes(P)||m))%n\n        const R = GmulAdd(P, s, modN(-e)); // R = s⋅G - e⋅P\n        if (!R || !R.hasEvenY() || R.toAffine().x !== r)\n            return false; // -eP == (n-e)P\n        return true; // Fail if is_infinite(R) / not has_even_y(R) / x(R) ≠ r.\n    }\n    catch (error) {\n        return false;\n    }\n}\nexport const schnorr = /* @__PURE__ */ (() => ({\n    getPublicKey: schnorrGetPublicKey,\n    sign: schnorrSign,\n    verify: schnorrVerify,\n    utils: {\n        randomPrivateKey: secp256k1.utils.randomPrivateKey,\n        lift_x,\n        pointToBytes,\n        numberToBytesBE,\n        bytesToNumberBE,\n        taggedHash,\n        mod,\n    },\n}))();\nconst isoMap = /* @__PURE__ */ (() => isogenyMap(Fp, [\n    // xNum\n    [\n        '0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa8c7',\n        '0x7d3d4c80bc321d5b9f315cea7fd44c5d595d2fc0bf63b92dfff1044f17c6581',\n        '0x534c328d23f234e6e2a413deca25caece4506144037c40314ecbd0b53d9dd262',\n        '0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa88c',\n    ],\n    // xDen\n    [\n        '0xd35771193d94918a9ca34ccbb7b640dd86cd409542f8487d9fe6b745781eb49b',\n        '0xedadc6f64383dc1df7c4b2d51b54225406d36b641f5e41bbc52a56612a8c6d14',\n        '0x0000000000000000000000000000000000000000000000000000000000000001', // LAST 1\n    ],\n    // yNum\n    [\n        '0x4bda12f684bda12f684bda12f684bda12f684bda12f684bda12f684b8e38e23c',\n        '0xc75e0c32d5cb7c0fa9d0a54b12a0a6d5647ab046d686da6fdffc90fc201d71a3',\n        '0x29a6194691f91a73715209ef6512e576722830a201be2018a765e85a9ecee931',\n        '0x2f684bda12f684bda12f684bda12f684bda12f684bda12f684bda12f38e38d84',\n    ],\n    // yDen\n    [\n        '0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffff93b',\n        '0x7a06534bb8bdb49fd5e9e6632722c2989467c1bfc8e8d978dfb425d2685c2573',\n        '0x6484aa716545ca2cf3a70c3fa8fe337e0a3d21162f0d6299a7bf8192bfd2a76f',\n        '0x0000000000000000000000000000000000000000000000000000000000000001', // LAST 1\n    ],\n].map((i) => i.map((j) => BigInt(j)))))();\nconst mapSWU = /* @__PURE__ */ (() => mapToCurveSimpleSWU(Fp, {\n    A: BigInt('0x3f8731abdd661adca08a5558f0f5d272e953d363cb6f0e5d405447c01a444533'),\n    B: BigInt('1771'),\n    Z: Fp.create(BigInt('-11')),\n}))();\nconst htf = /* @__PURE__ */ (() => createHasher(secp256k1.ProjectivePoint, (scalars) => {\n    const { x, y } = mapSWU(Fp.create(scalars[0]));\n    return isoMap(x, y);\n}, {\n    DST: 'secp256k1_XMD:SHA-256_SSWU_RO_',\n    encodeDST: 'secp256k1_XMD:SHA-256_SSWU_NU_',\n    p: Fp.ORDER,\n    m: 1,\n    k: 128,\n    expand: 'xmd',\n    hash: sha256,\n}))();\nexport const hashToCurve = /* @__PURE__ */ (() => htf.hashToCurve)();\nexport const encodeToCurve = /* @__PURE__ */ (() => htf.encodeToCurve)();\n//# sourceMappingURL=secp256k1.js.map","/**\n *  Some mathematic operations.\n *\n *  @_subsection: api/utils:Math Helpers  [about-maths]\n */\nimport { hexlify, isBytesLike } from \"./data.js\";\nimport { assert, assertArgument } from \"./errors.js\";\nconst BN_0 = BigInt(0);\nconst BN_1 = BigInt(1);\n//const BN_Max256 = (BN_1 << BigInt(256)) - BN_1;\n// IEEE 754 support 53-bits of mantissa\nconst maxValue = 0x1fffffffffffff;\n/**\n *  Convert %%value%% from a twos-compliment representation of %%width%%\n *  bits to its value.\n *\n *  If the highest bit is ``1``, the result will be negative.\n */\nexport function fromTwos(_value, _width) {\n    const value = getUint(_value, \"value\");\n    const width = BigInt(getNumber(_width, \"width\"));\n    assert((value >> width) === BN_0, \"overflow\", \"NUMERIC_FAULT\", {\n        operation: \"fromTwos\", fault: \"overflow\", value: _value\n    });\n    // Top bit set; treat as a negative value\n    if (value >> (width - BN_1)) {\n        const mask = (BN_1 << width) - BN_1;\n        return -(((~value) & mask) + BN_1);\n    }\n    return value;\n}\n/**\n *  Convert %%value%% to a twos-compliment representation of\n *  %%width%% bits.\n *\n *  The result will always be positive.\n */\nexport function toTwos(_value, _width) {\n    let value = getBigInt(_value, \"value\");\n    const width = BigInt(getNumber(_width, \"width\"));\n    const limit = (BN_1 << (width - BN_1));\n    if (value < BN_0) {\n        value = -value;\n        assert(value <= limit, \"too low\", \"NUMERIC_FAULT\", {\n            operation: \"toTwos\", fault: \"overflow\", value: _value\n        });\n        const mask = (BN_1 << width) - BN_1;\n        return ((~value) & mask) + BN_1;\n    }\n    else {\n        assert(value < limit, \"too high\", \"NUMERIC_FAULT\", {\n            operation: \"toTwos\", fault: \"overflow\", value: _value\n        });\n    }\n    return value;\n}\n/**\n *  Mask %%value%% with a bitmask of %%bits%% ones.\n */\nexport function mask(_value, _bits) {\n    const value = getUint(_value, \"value\");\n    const bits = BigInt(getNumber(_bits, \"bits\"));\n    return value & ((BN_1 << bits) - BN_1);\n}\n/**\n *  Gets a BigInt from %%value%%. If it is an invalid value for\n *  a BigInt, then an ArgumentError will be thrown for %%name%%.\n */\nexport function getBigInt(value, name) {\n    switch (typeof (value)) {\n        case \"bigint\": return value;\n        case \"number\":\n            assertArgument(Number.isInteger(value), \"underflow\", name || \"value\", value);\n            assertArgument(value >= -maxValue && value <= maxValue, \"overflow\", name || \"value\", value);\n            return BigInt(value);\n        case \"string\":\n            try {\n                if (value === \"\") {\n                    throw new Error(\"empty string\");\n                }\n                if (value[0] === \"-\" && value[1] !== \"-\") {\n                    return -BigInt(value.substring(1));\n                }\n                return BigInt(value);\n            }\n            catch (e) {\n                assertArgument(false, `invalid BigNumberish string: ${e.message}`, name || \"value\", value);\n            }\n    }\n    assertArgument(false, \"invalid BigNumberish value\", name || \"value\", value);\n}\n/**\n *  Returns %%value%% as a bigint, validating it is valid as a bigint\n *  value and that it is positive.\n */\nexport function getUint(value, name) {\n    const result = getBigInt(value, name);\n    assert(result >= BN_0, \"unsigned value cannot be negative\", \"NUMERIC_FAULT\", {\n        fault: \"overflow\", operation: \"getUint\", value\n    });\n    return result;\n}\nconst Nibbles = \"0123456789abcdef\";\n/*\n * Converts %%value%% to a BigInt. If %%value%% is a Uint8Array, it\n * is treated as Big Endian data.\n */\nexport function toBigInt(value) {\n    if (value instanceof Uint8Array) {\n        let result = \"0x0\";\n        for (const v of value) {\n            result += Nibbles[v >> 4];\n            result += Nibbles[v & 0x0f];\n        }\n        return BigInt(result);\n    }\n    return getBigInt(value);\n}\n/**\n *  Gets a //number// from %%value%%. If it is an invalid value for\n *  a //number//, then an ArgumentError will be thrown for %%name%%.\n */\nexport function getNumber(value, name) {\n    switch (typeof (value)) {\n        case \"bigint\":\n            assertArgument(value >= -maxValue && value <= maxValue, \"overflow\", name || \"value\", value);\n            return Number(value);\n        case \"number\":\n            assertArgument(Number.isInteger(value), \"underflow\", name || \"value\", value);\n            assertArgument(value >= -maxValue && value <= maxValue, \"overflow\", name || \"value\", value);\n            return value;\n        case \"string\":\n            try {\n                if (value === \"\") {\n                    throw new Error(\"empty string\");\n                }\n                return getNumber(BigInt(value), name);\n            }\n            catch (e) {\n                assertArgument(false, `invalid numeric string: ${e.message}`, name || \"value\", value);\n            }\n    }\n    assertArgument(false, \"invalid numeric value\", name || \"value\", value);\n}\n/**\n *  Converts %%value%% to a number. If %%value%% is a Uint8Array, it\n *  is treated as Big Endian data. Throws if the value is not safe.\n */\nexport function toNumber(value) {\n    return getNumber(toBigInt(value));\n}\n/**\n *  Converts %%value%% to a Big Endian hexstring, optionally padded to\n *  %%width%% bytes.\n */\nexport function toBeHex(_value, _width) {\n    const value = getUint(_value, \"value\");\n    let result = value.toString(16);\n    if (_width == null) {\n        // Ensure the value is of even length\n        if (result.length % 2) {\n            result = \"0\" + result;\n        }\n    }\n    else {\n        const width = getNumber(_width, \"width\");\n        assert(width * 2 >= result.length, `value exceeds width (${width} bytes)`, \"NUMERIC_FAULT\", {\n            operation: \"toBeHex\",\n            fault: \"overflow\",\n            value: _value\n        });\n        // Pad the value to the required width\n        while (result.length < (width * 2)) {\n            result = \"0\" + result;\n        }\n    }\n    return \"0x\" + result;\n}\n/**\n *  Converts %%value%% to a Big Endian Uint8Array.\n */\nexport function toBeArray(_value) {\n    const value = getUint(_value, \"value\");\n    if (value === BN_0) {\n        return new Uint8Array([]);\n    }\n    let hex = value.toString(16);\n    if (hex.length % 2) {\n        hex = \"0\" + hex;\n    }\n    const result = new Uint8Array(hex.length / 2);\n    for (let i = 0; i < result.length; i++) {\n        const offset = i * 2;\n        result[i] = parseInt(hex.substring(offset, offset + 2), 16);\n    }\n    return result;\n}\n/**\n *  Returns a [[HexString]] for %%value%% safe to use as a //Quantity//.\n *\n *  A //Quantity// does not have and leading 0 values unless the value is\n *  the literal value `0x0`. This is most commonly used for JSSON-RPC\n *  numeric values.\n */\nexport function toQuantity(value) {\n    let result = hexlify(isBytesLike(value) ? value : toBeArray(value)).substring(2);\n    while (result.startsWith(\"0\")) {\n        result = result.substring(1);\n    }\n    if (result === \"\") {\n        result = \"0\";\n    }\n    return \"0x\" + result;\n}\n//# sourceMappingURL=maths.js.map","/**\n *  A constant for the zero hash.\n *\n *  (**i.e.** ``\"0x0000000000000000000000000000000000000000000000000000000000000000\"``)\n */\nexport const ZeroHash = \"0x0000000000000000000000000000000000000000000000000000000000000000\";\n//# sourceMappingURL=hashes.js.map","import { ZeroHash } from \"../constants/index.js\";\nimport { concat, dataLength, getBigInt, getBytes, getNumber, hexlify, toBeArray, isHexString, zeroPadValue, assertArgument, assertPrivate } from \"../utils/index.js\";\n// Constants\nconst BN_0 = BigInt(0);\nconst BN_1 = BigInt(1);\nconst BN_2 = BigInt(2);\nconst BN_27 = BigInt(27);\nconst BN_28 = BigInt(28);\nconst BN_35 = BigInt(35);\nconst _guard = {};\nfunction toUint256(value) {\n    return zeroPadValue(toBeArray(value), 32);\n}\n/**\n *  A Signature  @TODO\n *\n *\n *  @_docloc: api/crypto:Signing\n */\nexport class Signature {\n    #r;\n    #s;\n    #v;\n    #networkV;\n    /**\n     *  The ``r`` value for a signature.\n     *\n     *  This represents the ``x`` coordinate of a \"reference\" or\n     *  challenge point, from which the ``y`` can be computed.\n     */\n    get r() { return this.#r; }\n    set r(value) {\n        assertArgument(dataLength(value) === 32, \"invalid r\", \"value\", value);\n        this.#r = hexlify(value);\n    }\n    /**\n     *  The ``s`` value for a signature.\n     */\n    get s() {\n        assertArgument(parseInt(this.#s.substring(0, 3)) < 8, \"non-canonical s; use ._s\", \"s\", this.#s);\n        return this.#s;\n    }\n    set s(_value) {\n        assertArgument(dataLength(_value) === 32, \"invalid s\", \"value\", _value);\n        this.#s = hexlify(_value);\n    }\n    /**\n     *  Return the s value, unchecked for EIP-2 compliance.\n     *\n     *  This should generally not be used and is for situations where\n     *  a non-canonical S value might be relevant, such as Frontier blocks\n     *  that were mined prior to EIP-2 or invalid Authorization List\n     *  signatures.\n     */\n    get _s() { return this.#s; }\n    /**\n     *  Returns true if the Signature is valid for [[link-eip-2]] signatures.\n     */\n    isValid() {\n        return (parseInt(this.#s.substring(0, 3)) < 8);\n    }\n    /**\n     *  The ``v`` value for a signature.\n     *\n     *  Since a given ``x`` value for ``r`` has two possible values for\n     *  its correspondin ``y``, the ``v`` indicates which of the two ``y``\n     *  values to use.\n     *\n     *  It is normalized to the values ``27`` or ``28`` for legacy\n     *  purposes.\n     */\n    get v() { return this.#v; }\n    set v(value) {\n        const v = getNumber(value, \"value\");\n        assertArgument(v === 27 || v === 28, \"invalid v\", \"v\", value);\n        this.#v = v;\n    }\n    /**\n     *  The EIP-155 ``v`` for legacy transactions. For non-legacy\n     *  transactions, this value is ``null``.\n     */\n    get networkV() { return this.#networkV; }\n    /**\n     *  The chain ID for EIP-155 legacy transactions. For non-legacy\n     *  transactions, this value is ``null``.\n     */\n    get legacyChainId() {\n        const v = this.networkV;\n        if (v == null) {\n            return null;\n        }\n        return Signature.getChainId(v);\n    }\n    /**\n     *  The ``yParity`` for the signature.\n     *\n     *  See ``v`` for more details on how this value is used.\n     */\n    get yParity() {\n        return (this.v === 27) ? 0 : 1;\n    }\n    /**\n     *  The [[link-eip-2098]] compact representation of the ``yParity``\n     *  and ``s`` compacted into a single ``bytes32``.\n     */\n    get yParityAndS() {\n        // The EIP-2098 compact representation\n        const yParityAndS = getBytes(this.s);\n        if (this.yParity) {\n            yParityAndS[0] |= 0x80;\n        }\n        return hexlify(yParityAndS);\n    }\n    /**\n     *  The [[link-eip-2098]] compact representation.\n     */\n    get compactSerialized() {\n        return concat([this.r, this.yParityAndS]);\n    }\n    /**\n     *  The serialized representation.\n     */\n    get serialized() {\n        return concat([this.r, this.s, (this.yParity ? \"0x1c\" : \"0x1b\")]);\n    }\n    /**\n     *  @private\n     */\n    constructor(guard, r, s, v) {\n        assertPrivate(guard, _guard, \"Signature\");\n        this.#r = r;\n        this.#s = s;\n        this.#v = v;\n        this.#networkV = null;\n    }\n    [Symbol.for('nodejs.util.inspect.custom')]() {\n        return `Signature { r: \"${this.r}\", s: \"${this._s}\"${this.isValid() ? \"\" : ', valid: \"false\"'}, yParity: ${this.yParity}, networkV: ${this.networkV} }`;\n    }\n    /**\n     *  Returns a new identical [[Signature]].\n     */\n    clone() {\n        const clone = new Signature(_guard, this.r, this._s, this.v);\n        if (this.networkV) {\n            clone.#networkV = this.networkV;\n        }\n        return clone;\n    }\n    /**\n     *  Returns a representation that is compatible with ``JSON.stringify``.\n     */\n    toJSON() {\n        const networkV = this.networkV;\n        return {\n            _type: \"signature\",\n            networkV: ((networkV != null) ? networkV.toString() : null),\n            r: this.r, s: this._s, v: this.v,\n        };\n    }\n    /**\n     *  Compute the chain ID from the ``v`` in a legacy EIP-155 transactions.\n     *\n     *  @example:\n     *    Signature.getChainId(45)\n     *    //_result:\n     *\n     *    Signature.getChainId(46)\n     *    //_result:\n     */\n    static getChainId(v) {\n        const bv = getBigInt(v, \"v\");\n        // The v is not an EIP-155 v, so it is the unspecified chain ID\n        if ((bv == BN_27) || (bv == BN_28)) {\n            return BN_0;\n        }\n        // Bad value for an EIP-155 v\n        assertArgument(bv >= BN_35, \"invalid EIP-155 v\", \"v\", v);\n        return (bv - BN_35) / BN_2;\n    }\n    /**\n     *  Compute the ``v`` for a chain ID for a legacy EIP-155 transactions.\n     *\n     *  Legacy transactions which use [[link-eip-155]] hijack the ``v``\n     *  property to include the chain ID.\n     *\n     *  @example:\n     *    Signature.getChainIdV(5, 27)\n     *    //_result:\n     *\n     *    Signature.getChainIdV(5, 28)\n     *    //_result:\n     *\n     */\n    static getChainIdV(chainId, v) {\n        return (getBigInt(chainId) * BN_2) + BigInt(35 + v - 27);\n    }\n    /**\n     *  Compute the normalized legacy transaction ``v`` from a ``yParirty``,\n     *  a legacy transaction ``v`` or a legacy [[link-eip-155]] transaction.\n     *\n     *  @example:\n     *    // The values 0 and 1 imply v is actually yParity\n     *    Signature.getNormalizedV(0)\n     *    //_result:\n     *\n     *    // Legacy non-EIP-1559 transaction (i.e. 27 or 28)\n     *    Signature.getNormalizedV(27)\n     *    //_result:\n     *\n     *    // Legacy EIP-155 transaction (i.e. >= 35)\n     *    Signature.getNormalizedV(46)\n     *    //_result:\n     *\n     *    // Invalid values throw\n     *    Signature.getNormalizedV(5)\n     *    //_error:\n     */\n    static getNormalizedV(v) {\n        const bv = getBigInt(v);\n        if (bv === BN_0 || bv === BN_27) {\n            return 27;\n        }\n        if (bv === BN_1 || bv === BN_28) {\n            return 28;\n        }\n        assertArgument(bv >= BN_35, \"invalid v\", \"v\", v);\n        // Otherwise, EIP-155 v means odd is 27 and even is 28\n        return (bv & BN_1) ? 27 : 28;\n    }\n    /**\n     *  Creates a new [[Signature]].\n     *\n     *  If no %%sig%% is provided, a new [[Signature]] is created\n     *  with default values.\n     *\n     *  If %%sig%% is a string, it is parsed.\n     */\n    static from(sig) {\n        function assertError(check, message) {\n            assertArgument(check, message, \"signature\", sig);\n        }\n        ;\n        if (sig == null) {\n            return new Signature(_guard, ZeroHash, ZeroHash, 27);\n        }\n        if (typeof (sig) === \"string\") {\n            const bytes = getBytes(sig, \"signature\");\n            if (bytes.length === 64) {\n                const r = hexlify(bytes.slice(0, 32));\n                const s = bytes.slice(32, 64);\n                const v = (s[0] & 0x80) ? 28 : 27;\n                s[0] &= 0x7f;\n                return new Signature(_guard, r, hexlify(s), v);\n            }\n            if (bytes.length === 65) {\n                const r = hexlify(bytes.slice(0, 32));\n                const s = hexlify(bytes.slice(32, 64));\n                const v = Signature.getNormalizedV(bytes[64]);\n                return new Signature(_guard, r, s, v);\n            }\n            assertError(false, \"invalid raw signature length\");\n        }\n        if (sig instanceof Signature) {\n            return sig.clone();\n        }\n        // Get r\n        const _r = sig.r;\n        assertError(_r != null, \"missing r\");\n        const r = toUint256(_r);\n        // Get s; by any means necessary (we check consistency below)\n        const s = (function (s, yParityAndS) {\n            if (s != null) {\n                return toUint256(s);\n            }\n            if (yParityAndS != null) {\n                assertError(isHexString(yParityAndS, 32), \"invalid yParityAndS\");\n                const bytes = getBytes(yParityAndS);\n                bytes[0] &= 0x7f;\n                return hexlify(bytes);\n            }\n            assertError(false, \"missing s\");\n        })(sig.s, sig.yParityAndS);\n        // Get v; by any means necessary (we check consistency below)\n        const { networkV, v } = (function (_v, yParityAndS, yParity) {\n            if (_v != null) {\n                const v = getBigInt(_v);\n                return {\n                    networkV: ((v >= BN_35) ? v : undefined),\n                    v: Signature.getNormalizedV(v)\n                };\n            }\n            if (yParityAndS != null) {\n                assertError(isHexString(yParityAndS, 32), \"invalid yParityAndS\");\n                return { v: ((getBytes(yParityAndS)[0] & 0x80) ? 28 : 27) };\n            }\n            if (yParity != null) {\n                switch (getNumber(yParity, \"sig.yParity\")) {\n                    case 0: return { v: 27 };\n                    case 1: return { v: 28 };\n                }\n                assertError(false, \"invalid yParity\");\n            }\n            assertError(false, \"missing v\");\n        })(sig.v, sig.yParityAndS, sig.yParity);\n        const result = new Signature(_guard, r, s, v);\n        if (networkV) {\n            result.#networkV = networkV;\n        }\n        // If multiple of v, yParity, yParityAndS we given, check they match\n        assertError(sig.yParity == null || getNumber(sig.yParity, \"sig.yParity\") === result.yParity, \"yParity mismatch\");\n        assertError(sig.yParityAndS == null || sig.yParityAndS === result.yParityAndS, \"yParityAndS mismatch\");\n        return result;\n    }\n}\n//# sourceMappingURL=signature.js.map","/**\n *  Add details about signing here.\n *\n *  @_subsection: api/crypto:Signing  [about-signing]\n */\nimport { secp256k1 } from \"@noble/curves/secp256k1\";\nimport { concat, dataLength, getBytes, getBytesCopy, hexlify, toBeHex, assertArgument } from \"../utils/index.js\";\nimport { Signature } from \"./signature.js\";\n/**\n *  A **SigningKey** provides high-level access to the elliptic curve\n *  cryptography (ECC) operations and key management.\n */\nexport class SigningKey {\n    #privateKey;\n    /**\n     *  Creates a new **SigningKey** for %%privateKey%%.\n     */\n    constructor(privateKey) {\n        assertArgument(dataLength(privateKey) === 32, \"invalid private key\", \"privateKey\", \"[REDACTED]\");\n        this.#privateKey = hexlify(privateKey);\n    }\n    /**\n     *  The private key.\n     */\n    get privateKey() { return this.#privateKey; }\n    /**\n     *  The uncompressed public key.\n     *\n     * This will always begin with the prefix ``0x04`` and be 132\n     * characters long (the ``0x`` prefix and 130 hexadecimal nibbles).\n     */\n    get publicKey() { return SigningKey.computePublicKey(this.#privateKey); }\n    /**\n     *  The compressed public key.\n     *\n     *  This will always begin with either the prefix ``0x02`` or ``0x03``\n     *  and be 68 characters long (the ``0x`` prefix and 33 hexadecimal\n     *  nibbles)\n     */\n    get compressedPublicKey() { return SigningKey.computePublicKey(this.#privateKey, true); }\n    /**\n     *  Return the signature of the signed %%digest%%.\n     */\n    sign(digest) {\n        assertArgument(dataLength(digest) === 32, \"invalid digest length\", \"digest\", digest);\n        const sig = secp256k1.sign(getBytesCopy(digest), getBytesCopy(this.#privateKey), {\n            lowS: true\n        });\n        return Signature.from({\n            r: toBeHex(sig.r, 32),\n            s: toBeHex(sig.s, 32),\n            v: (sig.recovery ? 0x1c : 0x1b)\n        });\n    }\n    /**\n     *  Returns the [[link-wiki-ecdh]] shared secret between this\n     *  private key and the %%other%% key.\n     *\n     *  The %%other%% key may be any type of key, a raw public key,\n     *  a compressed/uncompressed pubic key or aprivate key.\n     *\n     *  Best practice is usually to use a cryptographic hash on the\n     *  returned value before using it as a symetric secret.\n     *\n     *  @example:\n     *    sign1 = new SigningKey(id(\"some-secret-1\"))\n     *    sign2 = new SigningKey(id(\"some-secret-2\"))\n     *\n     *    // Notice that privA.computeSharedSecret(pubB)...\n     *    sign1.computeSharedSecret(sign2.publicKey)\n     *    //_result:\n     *\n     *    // ...is equal to privB.computeSharedSecret(pubA).\n     *    sign2.computeSharedSecret(sign1.publicKey)\n     *    //_result:\n     */\n    computeSharedSecret(other) {\n        const pubKey = SigningKey.computePublicKey(other);\n        return hexlify(secp256k1.getSharedSecret(getBytesCopy(this.#privateKey), getBytes(pubKey), false));\n    }\n    /**\n     *  Compute the public key for %%key%%, optionally %%compressed%%.\n     *\n     *  The %%key%% may be any type of key, a raw public key, a\n     *  compressed/uncompressed public key or private key.\n     *\n     *  @example:\n     *    sign = new SigningKey(id(\"some-secret\"));\n     *\n     *    // Compute the uncompressed public key for a private key\n     *    SigningKey.computePublicKey(sign.privateKey)\n     *    //_result:\n     *\n     *    // Compute the compressed public key for a private key\n     *    SigningKey.computePublicKey(sign.privateKey, true)\n     *    //_result:\n     *\n     *    // Compute the uncompressed public key\n     *    SigningKey.computePublicKey(sign.publicKey, false);\n     *    //_result:\n     *\n     *    // Compute the Compressed a public key\n     *    SigningKey.computePublicKey(sign.publicKey, true);\n     *    //_result:\n     */\n    static computePublicKey(key, compressed) {\n        let bytes = getBytes(key, \"key\");\n        // private key\n        if (bytes.length === 32) {\n            const pubKey = secp256k1.getPublicKey(bytes, !!compressed);\n            return hexlify(pubKey);\n        }\n        // raw public key; use uncompressed key with 0x04 prefix\n        if (bytes.length === 64) {\n            const pub = new Uint8Array(65);\n            pub[0] = 0x04;\n            pub.set(bytes, 1);\n            bytes = pub;\n        }\n        const point = secp256k1.ProjectivePoint.fromHex(bytes);\n        return hexlify(point.toRawBytes(compressed));\n    }\n    /**\n     *  Returns the public key for the private key which produced the\n     *  %%signature%% for the given %%digest%%.\n     *\n     *  @example:\n     *    key = new SigningKey(id(\"some-secret\"))\n     *    digest = id(\"hello world\")\n     *    sig = key.sign(digest)\n     *\n     *    // Notice the signer public key...\n     *    key.publicKey\n     *    //_result:\n     *\n     *    // ...is equal to the recovered public key\n     *    SigningKey.recoverPublicKey(digest, sig)\n     *    //_result:\n     *\n     */\n    static recoverPublicKey(digest, signature) {\n        assertArgument(dataLength(digest) === 32, \"invalid digest length\", \"digest\", digest);\n        const sig = Signature.from(signature);\n        let secpSig = secp256k1.Signature.fromCompact(getBytesCopy(concat([sig.r, sig.s])));\n        secpSig = secpSig.addRecoveryBit(sig.yParity);\n        const pubKey = secpSig.recoverPublicKey(getBytesCopy(digest));\n        assertArgument(pubKey != null, \"invalid signature for digest\", \"signature\", signature);\n        return \"0x\" + pubKey.toHex(false);\n    }\n    /**\n     *  Returns the point resulting from adding the ellipic curve points\n     *  %%p0%% and %%p1%%.\n     *\n     *  This is not a common function most developers should require, but\n     *  can be useful for certain privacy-specific techniques.\n     *\n     *  For example, it is used by [[HDNodeWallet]] to compute child\n     *  addresses from parent public keys and chain codes.\n     */\n    static addPoints(p0, p1, compressed) {\n        const pub0 = secp256k1.ProjectivePoint.fromHex(SigningKey.computePublicKey(p0).substring(2));\n        const pub1 = secp256k1.ProjectivePoint.fromHex(SigningKey.computePublicKey(p1).substring(2));\n        return \"0x\" + pub0.add(pub1).toHex(!!compressed);\n    }\n}\n//# sourceMappingURL=signing-key.js.map","import { keccak256 } from \"../crypto/index.js\";\nimport { getBytes, assertArgument } from \"../utils/index.js\";\nconst BN_0 = BigInt(0);\nconst BN_36 = BigInt(36);\nfunction getChecksumAddress(address) {\n    //    if (!isHexString(address, 20)) {\n    //        logger.throwArgumentError(\"invalid address\", \"address\", address);\n    //    }\n    address = address.toLowerCase();\n    const chars = address.substring(2).split(\"\");\n    const expanded = new Uint8Array(40);\n    for (let i = 0; i < 40; i++) {\n        expanded[i] = chars[i].charCodeAt(0);\n    }\n    const hashed = getBytes(keccak256(expanded));\n    for (let i = 0; i < 40; i += 2) {\n        if ((hashed[i >> 1] >> 4) >= 8) {\n            chars[i] = chars[i].toUpperCase();\n        }\n        if ((hashed[i >> 1] & 0x0f) >= 8) {\n            chars[i + 1] = chars[i + 1].toUpperCase();\n        }\n    }\n    return \"0x\" + chars.join(\"\");\n}\n// See: https://en.wikipedia.org/wiki/International_Bank_Account_Number\n// Create lookup table\nconst ibanLookup = {};\nfor (let i = 0; i < 10; i++) {\n    ibanLookup[String(i)] = String(i);\n}\nfor (let i = 0; i < 26; i++) {\n    ibanLookup[String.fromCharCode(65 + i)] = String(10 + i);\n}\n// How many decimal digits can we process? (for 64-bit float, this is 15)\n// i.e. Math.floor(Math.log10(Number.MAX_SAFE_INTEGER));\nconst safeDigits = 15;\nfunction ibanChecksum(address) {\n    address = address.toUpperCase();\n    address = address.substring(4) + address.substring(0, 2) + \"00\";\n    let expanded = address.split(\"\").map((c) => { return ibanLookup[c]; }).join(\"\");\n    // Javascript can handle integers safely up to 15 (decimal) digits\n    while (expanded.length >= safeDigits) {\n        let block = expanded.substring(0, safeDigits);\n        expanded = parseInt(block, 10) % 97 + expanded.substring(block.length);\n    }\n    let checksum = String(98 - (parseInt(expanded, 10) % 97));\n    while (checksum.length < 2) {\n        checksum = \"0\" + checksum;\n    }\n    return checksum;\n}\n;\nconst Base36 = (function () {\n    ;\n    const result = {};\n    for (let i = 0; i < 36; i++) {\n        const key = \"0123456789abcdefghijklmnopqrstuvwxyz\"[i];\n        result[key] = BigInt(i);\n    }\n    return result;\n})();\nfunction fromBase36(value) {\n    value = value.toLowerCase();\n    let result = BN_0;\n    for (let i = 0; i < value.length; i++) {\n        result = result * BN_36 + Base36[value[i]];\n    }\n    return result;\n}\n/**\n *  Returns a normalized and checksumed address for %%address%%.\n *  This accepts non-checksum addresses, checksum addresses and\n *  [[getIcapAddress]] formats.\n *\n *  The checksum in Ethereum uses the capitalization (upper-case\n *  vs lower-case) of the characters within an address to encode\n *  its checksum, which offers, on average, a checksum of 15-bits.\n *\n *  If %%address%% contains both upper-case and lower-case, it is\n *  assumed to already be a checksum address and its checksum is\n *  validated, and if the address fails its expected checksum an\n *  error is thrown.\n *\n *  If you wish the checksum of %%address%% to be ignore, it should\n *  be converted to lower-case (i.e. ``.toLowercase()``) before\n *  being passed in. This should be a very rare situation though,\n *  that you wish to bypass the safegaurds in place to protect\n *  against an address that has been incorrectly copied from another\n *  source.\n *\n *  @example:\n *    // Adds the checksum (via upper-casing specific letters)\n *    getAddress(\"0x8ba1f109551bd432803012645ac136ddd64dba72\")\n *    //_result:\n *\n *    // Converts ICAP address and adds checksum\n *    getAddress(\"XE65GB6LDNXYOFTX0NSV3FUWKOWIXAMJK36\");\n *    //_result:\n *\n *    // Throws an error if an address contains mixed case,\n *    // but the checksum fails\n *    getAddress(\"0x8Ba1f109551bD432803012645Ac136ddd64DBA72\")\n *    //_error:\n */\nexport function getAddress(address) {\n    assertArgument(typeof (address) === \"string\", \"invalid address\", \"address\", address);\n    if (address.match(/^(0x)?[0-9a-fA-F]{40}$/)) {\n        // Missing the 0x prefix\n        if (!address.startsWith(\"0x\")) {\n            address = \"0x\" + address;\n        }\n        const result = getChecksumAddress(address);\n        // It is a checksummed address with a bad checksum\n        assertArgument(!address.match(/([A-F].*[a-f])|([a-f].*[A-F])/) || result === address, \"bad address checksum\", \"address\", address);\n        return result;\n    }\n    // Maybe ICAP? (we only support direct mode)\n    if (address.match(/^XE[0-9]{2}[0-9A-Za-z]{30,31}$/)) {\n        // It is an ICAP address with a bad checksum\n        assertArgument(address.substring(2, 4) === ibanChecksum(address), \"bad icap checksum\", \"address\", address);\n        let result = fromBase36(address.substring(4)).toString(16);\n        while (result.length < 40) {\n            result = \"0\" + result;\n        }\n        return getChecksumAddress(\"0x\" + result);\n    }\n    assertArgument(false, \"invalid address\", \"address\", address);\n}\n/**\n *  The [ICAP Address format](link-icap) format is an early checksum\n *  format which attempts to be compatible with the banking\n *  industry [IBAN format](link-wiki-iban) for bank accounts.\n *\n *  It is no longer common or a recommended format.\n *\n *  @example:\n *    getIcapAddress(\"0x8ba1f109551bd432803012645ac136ddd64dba72\");\n *    //_result:\n *\n *    getIcapAddress(\"XE65GB6LDNXYOFTX0NSV3FUWKOWIXAMJK36\");\n *    //_result:\n *\n *    // Throws an error if the ICAP checksum is wrong\n *    getIcapAddress(\"XE65GB6LDNXYOFTX0NSV3FUWKOWIXAMJK37\");\n *    //_error:\n */\nexport function getIcapAddress(address) {\n    //let base36 = _base16To36(getAddress(address).substring(2)).toUpperCase();\n    let base36 = BigInt(getAddress(address)).toString(36).toUpperCase();\n    while (base36.length < 30) {\n        base36 = \"0\" + base36;\n    }\n    return \"XE\" + ibanChecksum(\"XE00\" + base36) + base36;\n}\n//# sourceMappingURL=address.js.map","import { assert, assertArgument } from \"../utils/index.js\";\nimport { getAddress } from \"./address.js\";\n/**\n *  Returns true if %%value%% is an object which implements the\n *  [[Addressable]] interface.\n *\n *  @example:\n *    // Wallets and AbstractSigner sub-classes\n *    isAddressable(Wallet.createRandom())\n *    //_result:\n *\n *    // Contracts\n *    contract = new Contract(\"dai.tokens.ethers.eth\", [ ], provider)\n *    isAddressable(contract)\n *    //_result:\n */\nexport function isAddressable(value) {\n    return (value && typeof (value.getAddress) === \"function\");\n}\n/**\n *  Returns true if %%value%% is a valid address.\n *\n *  @example:\n *    // Valid address\n *    isAddress(\"0x8ba1f109551bD432803012645Ac136ddd64DBA72\")\n *    //_result:\n *\n *    // Valid ICAP address\n *    isAddress(\"XE65GB6LDNXYOFTX0NSV3FUWKOWIXAMJK36\")\n *    //_result:\n *\n *    // Invalid checksum\n *    isAddress(\"0x8Ba1f109551bD432803012645Ac136ddd64DBa72\")\n *    //_result:\n *\n *    // Invalid ICAP checksum\n *    isAddress(\"0x8Ba1f109551bD432803012645Ac136ddd64DBA72\")\n *    //_result:\n *\n *    // Not an address (an ENS name requires a provided and an\n *    // asynchronous API to access)\n *    isAddress(\"ricmoo.eth\")\n *    //_result:\n */\nexport function isAddress(value) {\n    try {\n        getAddress(value);\n        return true;\n    }\n    catch (error) { }\n    return false;\n}\nasync function checkAddress(target, promise) {\n    const result = await promise;\n    if (result == null || result === \"0x0000000000000000000000000000000000000000\") {\n        assert(typeof (target) !== \"string\", \"unconfigured name\", \"UNCONFIGURED_NAME\", { value: target });\n        assertArgument(false, \"invalid AddressLike value; did not resolve to a value address\", \"target\", target);\n    }\n    return getAddress(result);\n}\n/**\n *  Resolves to an address for the %%target%%, which may be any\n *  supported address type, an [[Addressable]] or a Promise which\n *  resolves to an address.\n *\n *  If an ENS name is provided, but that name has not been correctly\n *  configured a [[UnconfiguredNameError]] is thrown.\n *\n *  @example:\n *    addr = \"0x6B175474E89094C44Da98b954EedeAC495271d0F\"\n *\n *    // Addresses are return synchronously\n *    resolveAddress(addr, provider)\n *    //_result:\n *\n *    // Address promises are resolved asynchronously\n *    resolveAddress(Promise.resolve(addr))\n *    //_result:\n *\n *    // ENS names are resolved asynchronously\n *    resolveAddress(\"dai.tokens.ethers.eth\", provider)\n *    //_result:\n *\n *    // Addressable objects are resolved asynchronously\n *    contract = new Contract(addr, [ ])\n *    resolveAddress(contract, provider)\n *    //_result:\n *\n *    // Unconfigured ENS names reject\n *    resolveAddress(\"nothing-here.ricmoo.eth\", provider)\n *    //_error:\n *\n *    // ENS names require a NameResolver object passed in\n *    // (notice the provider was omitted)\n *    resolveAddress(\"nothing-here.ricmoo.eth\")\n *    //_error:\n */\nexport function resolveAddress(target, resolver) {\n    if (typeof (target) === \"string\") {\n        if (target.match(/^0x[0-9a-f]{40}$/i)) {\n            return getAddress(target);\n        }\n        assert(resolver != null, \"ENS resolution requires a provider\", \"UNSUPPORTED_OPERATION\", { operation: \"resolveName\" });\n        return checkAddress(target, resolver.resolveName(target));\n    }\n    else if (isAddressable(target)) {\n        return checkAddress(target, target.getAddress());\n    }\n    else if (target && typeof (target.then) === \"function\") {\n        return checkAddress(target, target);\n    }\n    assertArgument(false, \"unsupported addressable value\", \"target\", target);\n}\n//# sourceMappingURL=checks.js.map","/**\n *  Using strings in Ethereum (or any security-basd system) requires\n *  additional care. These utilities attempt to mitigate some of the\n *  safety issues as well as provide the ability to recover and analyse\n *  strings.\n *\n *  @_subsection api/utils:Strings and UTF-8  [about-strings]\n */\nimport { getBytes } from \"./data.js\";\nimport { assertArgument, assertNormalize } from \"./errors.js\";\nfunction errorFunc(reason, offset, bytes, output, badCodepoint) {\n    assertArgument(false, `invalid codepoint at offset ${offset}; ${reason}`, \"bytes\", bytes);\n}\nfunction ignoreFunc(reason, offset, bytes, output, badCodepoint) {\n    // If there is an invalid prefix (including stray continuation), skip any additional continuation bytes\n    if (reason === \"BAD_PREFIX\" || reason === \"UNEXPECTED_CONTINUE\") {\n        let i = 0;\n        for (let o = offset + 1; o < bytes.length; o++) {\n            if (bytes[o] >> 6 !== 0x02) {\n                break;\n            }\n            i++;\n        }\n        return i;\n    }\n    // This byte runs us past the end of the string, so just jump to the end\n    // (but the first byte was read already read and therefore skipped)\n    if (reason === \"OVERRUN\") {\n        return bytes.length - offset - 1;\n    }\n    // Nothing to skip\n    return 0;\n}\nfunction replaceFunc(reason, offset, bytes, output, badCodepoint) {\n    // Overlong representations are otherwise \"valid\" code points; just non-deistingtished\n    if (reason === \"OVERLONG\") {\n        assertArgument(typeof (badCodepoint) === \"number\", \"invalid bad code point for replacement\", \"badCodepoint\", badCodepoint);\n        output.push(badCodepoint);\n        return 0;\n    }\n    // Put the replacement character into the output\n    output.push(0xfffd);\n    // Otherwise, process as if ignoring errors\n    return ignoreFunc(reason, offset, bytes, output, badCodepoint);\n}\n/**\n *  A handful of popular, built-in UTF-8 error handling strategies.\n *\n *  **``\"error\"``** - throws on ANY illegal UTF-8 sequence or\n *  non-canonical (overlong) codepoints (this is the default)\n *\n *  **``\"ignore\"``** - silently drops any illegal UTF-8 sequence\n *  and accepts non-canonical (overlong) codepoints\n *\n *  **``\"replace\"``** - replace any illegal UTF-8 sequence with the\n *  UTF-8 replacement character (i.e. ``\"\\\\ufffd\"``) and accepts\n *  non-canonical (overlong) codepoints\n *\n *  @returns: Record<\"error\" | \"ignore\" | \"replace\", Utf8ErrorFunc>\n */\nexport const Utf8ErrorFuncs = Object.freeze({\n    error: errorFunc,\n    ignore: ignoreFunc,\n    replace: replaceFunc\n});\n// http://stackoverflow.com/questions/13356493/decode-utf-8-with-javascript#13691499\nfunction getUtf8CodePoints(_bytes, onError) {\n    if (onError == null) {\n        onError = Utf8ErrorFuncs.error;\n    }\n    const bytes = getBytes(_bytes, \"bytes\");\n    const result = [];\n    let i = 0;\n    // Invalid bytes are ignored\n    while (i < bytes.length) {\n        const c = bytes[i++];\n        // 0xxx xxxx\n        if (c >> 7 === 0) {\n            result.push(c);\n            continue;\n        }\n        // Multibyte; how many bytes left for this character?\n        let extraLength = null;\n        let overlongMask = null;\n        // 110x xxxx 10xx xxxx\n        if ((c & 0xe0) === 0xc0) {\n            extraLength = 1;\n            overlongMask = 0x7f;\n            // 1110 xxxx 10xx xxxx 10xx xxxx\n        }\n        else if ((c & 0xf0) === 0xe0) {\n            extraLength = 2;\n            overlongMask = 0x7ff;\n            // 1111 0xxx 10xx xxxx 10xx xxxx 10xx xxxx\n        }\n        else if ((c & 0xf8) === 0xf0) {\n            extraLength = 3;\n            overlongMask = 0xffff;\n        }\n        else {\n            if ((c & 0xc0) === 0x80) {\n                i += onError(\"UNEXPECTED_CONTINUE\", i - 1, bytes, result);\n            }\n            else {\n                i += onError(\"BAD_PREFIX\", i - 1, bytes, result);\n            }\n            continue;\n        }\n        // Do we have enough bytes in our data?\n        if (i - 1 + extraLength >= bytes.length) {\n            i += onError(\"OVERRUN\", i - 1, bytes, result);\n            continue;\n        }\n        // Remove the length prefix from the char\n        let res = c & ((1 << (8 - extraLength - 1)) - 1);\n        for (let j = 0; j < extraLength; j++) {\n            let nextChar = bytes[i];\n            // Invalid continuation byte\n            if ((nextChar & 0xc0) != 0x80) {\n                i += onError(\"MISSING_CONTINUE\", i, bytes, result);\n                res = null;\n                break;\n            }\n            ;\n            res = (res << 6) | (nextChar & 0x3f);\n            i++;\n        }\n        // See above loop for invalid continuation byte\n        if (res === null) {\n            continue;\n        }\n        // Maximum code point\n        if (res > 0x10ffff) {\n            i += onError(\"OUT_OF_RANGE\", i - 1 - extraLength, bytes, result, res);\n            continue;\n        }\n        // Reserved for UTF-16 surrogate halves\n        if (res >= 0xd800 && res <= 0xdfff) {\n            i += onError(\"UTF16_SURROGATE\", i - 1 - extraLength, bytes, result, res);\n            continue;\n        }\n        // Check for overlong sequences (more bytes than needed)\n        if (res <= overlongMask) {\n            i += onError(\"OVERLONG\", i - 1 - extraLength, bytes, result, res);\n            continue;\n        }\n        result.push(res);\n    }\n    return result;\n}\n// http://stackoverflow.com/questions/18729405/how-to-convert-utf8-string-to-byte-array\n/**\n *  Returns the UTF-8 byte representation of %%str%%.\n *\n *  If %%form%% is specified, the string is normalized.\n */\nexport function toUtf8Bytes(str, form) {\n    assertArgument(typeof (str) === \"string\", \"invalid string value\", \"str\", str);\n    if (form != null) {\n        assertNormalize(form);\n        str = str.normalize(form);\n    }\n    let result = [];\n    for (let i = 0; i < str.length; i++) {\n        const c = str.charCodeAt(i);\n        if (c < 0x80) {\n            result.push(c);\n        }\n        else if (c < 0x800) {\n            result.push((c >> 6) | 0xc0);\n            result.push((c & 0x3f) | 0x80);\n        }\n        else if ((c & 0xfc00) == 0xd800) {\n            i++;\n            const c2 = str.charCodeAt(i);\n            assertArgument(i < str.length && ((c2 & 0xfc00) === 0xdc00), \"invalid surrogate pair\", \"str\", str);\n            // Surrogate Pair\n            const pair = 0x10000 + ((c & 0x03ff) << 10) + (c2 & 0x03ff);\n            result.push((pair >> 18) | 0xf0);\n            result.push(((pair >> 12) & 0x3f) | 0x80);\n            result.push(((pair >> 6) & 0x3f) | 0x80);\n            result.push((pair & 0x3f) | 0x80);\n        }\n        else {\n            result.push((c >> 12) | 0xe0);\n            result.push(((c >> 6) & 0x3f) | 0x80);\n            result.push((c & 0x3f) | 0x80);\n        }\n    }\n    return new Uint8Array(result);\n}\n;\n//export \nfunction _toUtf8String(codePoints) {\n    return codePoints.map((codePoint) => {\n        if (codePoint <= 0xffff) {\n            return String.fromCharCode(codePoint);\n        }\n        codePoint -= 0x10000;\n        return String.fromCharCode((((codePoint >> 10) & 0x3ff) + 0xd800), ((codePoint & 0x3ff) + 0xdc00));\n    }).join(\"\");\n}\n/**\n *  Returns the string represented by the UTF-8 data %%bytes%%.\n *\n *  When %%onError%% function is specified, it is called on UTF-8\n *  errors allowing recovery using the [[Utf8ErrorFunc]] API.\n *  (default: [error](Utf8ErrorFuncs))\n */\nexport function toUtf8String(bytes, onError) {\n    return _toUtf8String(getUtf8CodePoints(bytes, onError));\n}\n/**\n *  Returns the UTF-8 code-points for %%str%%.\n *\n *  If %%form%% is specified, the string is normalized.\n */\nexport function toUtf8CodePoints(str, form) {\n    return getUtf8CodePoints(toUtf8Bytes(str, form));\n}\n//# sourceMappingURL=utf8.js.map","import { keccak256 } from \"../crypto/index.js\";\nimport { MessagePrefix } from \"../constants/index.js\";\nimport { recoverAddress } from \"../transaction/index.js\";\nimport { concat, toUtf8Bytes } from \"../utils/index.js\";\n/**\n *  Computes the [[link-eip-191]] personal-sign message digest to sign.\n *\n *  This prefixes the message with [[MessagePrefix]] and the decimal length\n *  of %%message%% and computes the [[keccak256]] digest.\n *\n *  If %%message%% is a string, it is converted to its UTF-8 bytes\n *  first. To compute the digest of a [[DataHexString]], it must be converted\n *  to [bytes](getBytes).\n *\n *  @example:\n *    hashMessage(\"Hello World\")\n *    //_result:\n *\n *    // Hashes the SIX (6) string characters, i.e.\n *    // [ \"0\", \"x\", \"4\", \"2\", \"4\", \"3\" ]\n *    hashMessage(\"0x4243\")\n *    //_result:\n *\n *    // Hashes the TWO (2) bytes [ 0x42, 0x43 ]...\n *    hashMessage(getBytes(\"0x4243\"))\n *    //_result:\n *\n *    // ...which is equal to using data\n *    hashMessage(new Uint8Array([ 0x42, 0x43 ]))\n *    //_result:\n *\n */\nexport function hashMessage(message) {\n    if (typeof (message) === \"string\") {\n        message = toUtf8Bytes(message);\n    }\n    return keccak256(concat([\n        toUtf8Bytes(MessagePrefix),\n        toUtf8Bytes(String(message.length)),\n        message\n    ]));\n}\n/**\n *  Return the address of the private key that produced\n *  the signature %%sig%% during signing for %%message%%.\n */\nexport function verifyMessage(message, sig) {\n    const digest = hashMessage(message);\n    return recoverAddress(digest, sig);\n}\n//# sourceMappingURL=message.js.map","// NFKC (composed)             // (decomposed)\n/**\n *  A constant for the ether symbol (normalized using NFKC).\n *\n *  (**i.e.** ``\"\\\\u039e\"``)\n */\nexport const EtherSymbol = \"\\u039e\"; // \"\\uD835\\uDF63\";\n/**\n *  A constant for the [[link-eip-191]] personal message prefix.\n *\n *  (**i.e.** ``\"\\\\x19Ethereum Signed Message:\\\\n\"``)\n */\nexport const MessagePrefix = \"\\x19Ethereum Signed Message:\\n\";\n//# sourceMappingURL=strings.js.map","//See: https://github.com/ethereum/wiki/wiki/RLP\nimport { getBytes } from \"./data.js\";\nfunction arrayifyInteger(value) {\n    const result = [];\n    while (value) {\n        result.unshift(value & 0xff);\n        value >>= 8;\n    }\n    return result;\n}\nfunction _encode(object) {\n    if (Array.isArray(object)) {\n        let payload = [];\n        object.forEach(function (child) {\n            payload = payload.concat(_encode(child));\n        });\n        if (payload.length <= 55) {\n            payload.unshift(0xc0 + payload.length);\n            return payload;\n        }\n        const length = arrayifyInteger(payload.length);\n        length.unshift(0xf7 + length.length);\n        return length.concat(payload);\n    }\n    const data = Array.prototype.slice.call(getBytes(object, \"object\"));\n    if (data.length === 1 && data[0] <= 0x7f) {\n        return data;\n    }\n    else if (data.length <= 55) {\n        data.unshift(0x80 + data.length);\n        return data;\n    }\n    const length = arrayifyInteger(data.length);\n    length.unshift(0xb7 + length.length);\n    return length.concat(data);\n}\nconst nibbles = \"0123456789abcdef\";\n/**\n *  Encodes %%object%% as an RLP-encoded [[DataHexString]].\n */\nexport function encodeRlp(object) {\n    let result = \"0x\";\n    for (const v of _encode(object)) {\n        result += nibbles[v >> 4];\n        result += nibbles[v & 0xf];\n    }\n    return result;\n}\n//# sourceMappingURL=rlp-encode.js.map","import { getAddress } from \"../address/index.js\";\nimport { keccak256 } from \"../crypto/index.js\";\nimport { recoverAddress } from \"../transaction/index.js\";\nimport { assertArgument, concat, encodeRlp, toBeArray } from \"../utils/index.js\";\n/**\n *  Computes the [[link-eip-7702]] authorization digest to sign.\n */\nexport function hashAuthorization(auth) {\n    assertArgument(typeof (auth.address) === \"string\", \"invalid address for hashAuthorization\", \"auth.address\", auth);\n    return keccak256(concat([\n        \"0x05\", encodeRlp([\n            (auth.chainId != null) ? toBeArray(auth.chainId) : \"0x\",\n            getAddress(auth.address),\n            (auth.nonce != null) ? toBeArray(auth.nonce) : \"0x\",\n        ])\n    ]));\n}\n/**\n *  Return the address of the private key that produced\n *  the signature %%sig%% during signing for %%message%%.\n */\nexport function verifyAuthorization(auth, sig) {\n    return recoverAddress(hashAuthorization(auth), sig);\n}\n//# sourceMappingURL=authorization.js.map","import { keccak256 } from \"../crypto/index.js\";\nimport { toUtf8Bytes } from \"../utils/index.js\";\n/**\n *  A simple hashing function which operates on UTF-8 strings to\n *  compute an 32-byte identifier.\n *\n *  This simply computes the [UTF-8 bytes](toUtf8Bytes) and computes\n *  the [[keccak256]].\n *\n *  @example:\n *    id(\"hello world\")\n *    //_result:\n */\nexport function id(value) {\n    return keccak256(toUtf8Bytes(value));\n}\n//# sourceMappingURL=id.js.map","//import { TypedDataDomain, TypedDataField } from \"@ethersproject/providerabstract-signer\";\nimport { getAddress } from \"../address/index.js\";\nimport { keccak256 } from \"../crypto/index.js\";\nimport { recoverAddress } from \"../transaction/index.js\";\nimport { concat, defineProperties, getBigInt, getBytes, hexlify, isHexString, mask, toBeHex, toQuantity, toTwos, zeroPadValue, assertArgument } from \"../utils/index.js\";\nimport { id } from \"./id.js\";\nconst padding = new Uint8Array(32);\npadding.fill(0);\nconst BN__1 = BigInt(-1);\nconst BN_0 = BigInt(0);\nconst BN_1 = BigInt(1);\nconst BN_MAX_UINT256 = BigInt(\"0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\");\n;\n;\nfunction hexPadRight(value) {\n    const bytes = getBytes(value);\n    const padOffset = bytes.length % 32;\n    if (padOffset) {\n        return concat([bytes, padding.slice(padOffset)]);\n    }\n    return hexlify(bytes);\n}\nconst hexTrue = toBeHex(BN_1, 32);\nconst hexFalse = toBeHex(BN_0, 32);\nconst domainFieldTypes = {\n    name: \"string\",\n    version: \"string\",\n    chainId: \"uint256\",\n    verifyingContract: \"address\",\n    salt: \"bytes32\"\n};\nconst domainFieldNames = [\n    \"name\", \"version\", \"chainId\", \"verifyingContract\", \"salt\"\n];\nfunction checkString(key) {\n    return function (value) {\n        assertArgument(typeof (value) === \"string\", `invalid domain value for ${JSON.stringify(key)}`, `domain.${key}`, value);\n        return value;\n    };\n}\nconst domainChecks = {\n    name: checkString(\"name\"),\n    version: checkString(\"version\"),\n    chainId: function (_value) {\n        const value = getBigInt(_value, \"domain.chainId\");\n        assertArgument(value >= 0, \"invalid chain ID\", \"domain.chainId\", _value);\n        if (Number.isSafeInteger(value)) {\n            return Number(value);\n        }\n        return toQuantity(value);\n    },\n    verifyingContract: function (value) {\n        try {\n            return getAddress(value).toLowerCase();\n        }\n        catch (error) { }\n        assertArgument(false, `invalid domain value \"verifyingContract\"`, \"domain.verifyingContract\", value);\n    },\n    salt: function (value) {\n        const bytes = getBytes(value, \"domain.salt\");\n        assertArgument(bytes.length === 32, `invalid domain value \"salt\"`, \"domain.salt\", value);\n        return hexlify(bytes);\n    }\n};\nfunction getBaseEncoder(type) {\n    // intXX and uintXX\n    {\n        const match = type.match(/^(u?)int(\\d+)$/);\n        if (match) {\n            const signed = (match[1] === \"\");\n            const width = parseInt(match[2]);\n            assertArgument(width % 8 === 0 && width !== 0 && width <= 256 && match[2] === String(width), \"invalid numeric width\", \"type\", type);\n            const boundsUpper = mask(BN_MAX_UINT256, signed ? (width - 1) : width);\n            const boundsLower = signed ? ((boundsUpper + BN_1) * BN__1) : BN_0;\n            return function (_value) {\n                const value = getBigInt(_value, \"value\");\n                assertArgument(value >= boundsLower && value <= boundsUpper, `value out-of-bounds for ${type}`, \"value\", value);\n                return toBeHex(signed ? toTwos(value, 256) : value, 32);\n            };\n        }\n    }\n    // bytesXX\n    {\n        const match = type.match(/^bytes(\\d+)$/);\n        if (match) {\n            const width = parseInt(match[1]);\n            assertArgument(width !== 0 && width <= 32 && match[1] === String(width), \"invalid bytes width\", \"type\", type);\n            return function (value) {\n                const bytes = getBytes(value);\n                assertArgument(bytes.length === width, `invalid length for ${type}`, \"value\", value);\n                return hexPadRight(value);\n            };\n        }\n    }\n    switch (type) {\n        case \"address\": return function (value) {\n            return zeroPadValue(getAddress(value), 32);\n        };\n        case \"bool\": return function (value) {\n            return ((!value) ? hexFalse : hexTrue);\n        };\n        case \"bytes\": return function (value) {\n            return keccak256(value);\n        };\n        case \"string\": return function (value) {\n            return id(value);\n        };\n    }\n    return null;\n}\nfunction encodeType(name, fields) {\n    return `${name}(${fields.map(({ name, type }) => (type + \" \" + name)).join(\",\")})`;\n}\n// foo[][3] => { base: \"foo\", index: \"[][3]\", array: {\n//     base: \"foo\", prefix: \"foo[]\", count: 3 } }\nfunction splitArray(type) {\n    const match = type.match(/^([^\\x5b]*)((\\x5b\\d*\\x5d)*)(\\x5b(\\d*)\\x5d)$/);\n    if (match) {\n        return {\n            base: match[1],\n            index: (match[2] + match[4]),\n            array: {\n                base: match[1],\n                prefix: (match[1] + match[2]),\n                count: (match[5] ? parseInt(match[5]) : -1),\n            }\n        };\n    }\n    return { base: type };\n}\n/**\n *  A **TypedDataEncode** prepares and encodes [[link-eip-712]] payloads\n *  for signed typed data.\n *\n *  This is useful for those that wish to compute various components of a\n *  typed data hash, primary types, or sub-components, but generally the\n *  higher level [[Signer-signTypedData]] is more useful.\n */\nexport class TypedDataEncoder {\n    /**\n     *  The primary type for the structured [[types]].\n     *\n     *  This is derived automatically from the [[types]], since no\n     *  recursion is possible, once the DAG for the types is consturcted\n     *  internally, the primary type must be the only remaining type with\n     *  no parent nodes.\n     */\n    primaryType;\n    #types;\n    /**\n     *  The types.\n     */\n    get types() {\n        return JSON.parse(this.#types);\n    }\n    #fullTypes;\n    #encoderCache;\n    /**\n     *  Create a new **TypedDataEncoder** for %%types%%.\n     *\n     *  This performs all necessary checking that types are valid and\n     *  do not violate the [[link-eip-712]] structural constraints as\n     *  well as computes the [[primaryType]].\n     */\n    constructor(_types) {\n        this.#fullTypes = new Map();\n        this.#encoderCache = new Map();\n        // Link struct types to their direct child structs\n        const links = new Map();\n        // Link structs to structs which contain them as a child\n        const parents = new Map();\n        // Link all subtypes within a given struct\n        const subtypes = new Map();\n        const types = {};\n        Object.keys(_types).forEach((type) => {\n            types[type] = _types[type].map(({ name, type }) => {\n                // Normalize the base type (unless name conflict)\n                let { base, index } = splitArray(type);\n                if (base === \"int\" && !_types[\"int\"]) {\n                    base = \"int256\";\n                }\n                if (base === \"uint\" && !_types[\"uint\"]) {\n                    base = \"uint256\";\n                }\n                return { name, type: (base + (index || \"\")) };\n            });\n            links.set(type, new Set());\n            parents.set(type, []);\n            subtypes.set(type, new Set());\n        });\n        this.#types = JSON.stringify(types);\n        for (const name in types) {\n            const uniqueNames = new Set();\n            for (const field of types[name]) {\n                // Check each field has a unique name\n                assertArgument(!uniqueNames.has(field.name), `duplicate variable name ${JSON.stringify(field.name)} in ${JSON.stringify(name)}`, \"types\", _types);\n                uniqueNames.add(field.name);\n                // Get the base type (drop any array specifiers)\n                const baseType = splitArray(field.type).base;\n                assertArgument(baseType !== name, `circular type reference to ${JSON.stringify(baseType)}`, \"types\", _types);\n                // Is this a base encoding type?\n                const encoder = getBaseEncoder(baseType);\n                if (encoder) {\n                    continue;\n                }\n                assertArgument(parents.has(baseType), `unknown type ${JSON.stringify(baseType)}`, \"types\", _types);\n                // Add linkage\n                parents.get(baseType).push(name);\n                links.get(name).add(baseType);\n            }\n        }\n        // Deduce the primary type\n        const primaryTypes = Array.from(parents.keys()).filter((n) => (parents.get(n).length === 0));\n        assertArgument(primaryTypes.length !== 0, \"missing primary type\", \"types\", _types);\n        assertArgument(primaryTypes.length === 1, `ambiguous primary types or unused types: ${primaryTypes.map((t) => (JSON.stringify(t))).join(\", \")}`, \"types\", _types);\n        defineProperties(this, { primaryType: primaryTypes[0] });\n        // Check for circular type references\n        function checkCircular(type, found) {\n            assertArgument(!found.has(type), `circular type reference to ${JSON.stringify(type)}`, \"types\", _types);\n            found.add(type);\n            for (const child of links.get(type)) {\n                if (!parents.has(child)) {\n                    continue;\n                }\n                // Recursively check children\n                checkCircular(child, found);\n                // Mark all ancestors as having this decendant\n                for (const subtype of found) {\n                    subtypes.get(subtype).add(child);\n                }\n            }\n            found.delete(type);\n        }\n        checkCircular(this.primaryType, new Set());\n        // Compute each fully describe type\n        for (const [name, set] of subtypes) {\n            const st = Array.from(set);\n            st.sort();\n            this.#fullTypes.set(name, encodeType(name, types[name]) + st.map((t) => encodeType(t, types[t])).join(\"\"));\n        }\n    }\n    /**\n     *  Returnthe encoder for the specific %%type%%.\n     */\n    getEncoder(type) {\n        let encoder = this.#encoderCache.get(type);\n        if (!encoder) {\n            encoder = this.#getEncoder(type);\n            this.#encoderCache.set(type, encoder);\n        }\n        return encoder;\n    }\n    #getEncoder(type) {\n        // Basic encoder type (address, bool, uint256, etc)\n        {\n            const encoder = getBaseEncoder(type);\n            if (encoder) {\n                return encoder;\n            }\n        }\n        // Array\n        const array = splitArray(type).array;\n        if (array) {\n            const subtype = array.prefix;\n            const subEncoder = this.getEncoder(subtype);\n            return (value) => {\n                assertArgument(array.count === -1 || array.count === value.length, `array length mismatch; expected length ${array.count}`, \"value\", value);\n                let result = value.map(subEncoder);\n                if (this.#fullTypes.has(subtype)) {\n                    result = result.map(keccak256);\n                }\n                return keccak256(concat(result));\n            };\n        }\n        // Struct\n        const fields = this.types[type];\n        if (fields) {\n            const encodedType = id(this.#fullTypes.get(type));\n            return (value) => {\n                const values = fields.map(({ name, type }) => {\n                    const result = this.getEncoder(type)(value[name]);\n                    if (this.#fullTypes.has(type)) {\n                        return keccak256(result);\n                    }\n                    return result;\n                });\n                values.unshift(encodedType);\n                return concat(values);\n            };\n        }\n        assertArgument(false, `unknown type: ${type}`, \"type\", type);\n    }\n    /**\n     *  Return the full type for %%name%%.\n     */\n    encodeType(name) {\n        const result = this.#fullTypes.get(name);\n        assertArgument(result, `unknown type: ${JSON.stringify(name)}`, \"name\", name);\n        return result;\n    }\n    /**\n     *  Return the encoded %%value%% for the %%type%%.\n     */\n    encodeData(type, value) {\n        return this.getEncoder(type)(value);\n    }\n    /**\n     *  Returns the hash of %%value%% for the type of %%name%%.\n     */\n    hashStruct(name, value) {\n        return keccak256(this.encodeData(name, value));\n    }\n    /**\n     *  Return the fulled encoded %%value%% for the [[types]].\n     */\n    encode(value) {\n        return this.encodeData(this.primaryType, value);\n    }\n    /**\n     *  Return the hash of the fully encoded %%value%% for the [[types]].\n     */\n    hash(value) {\n        return this.hashStruct(this.primaryType, value);\n    }\n    /**\n     *  @_ignore:\n     */\n    _visit(type, value, callback) {\n        // Basic encoder type (address, bool, uint256, etc)\n        {\n            const encoder = getBaseEncoder(type);\n            if (encoder) {\n                return callback(type, value);\n            }\n        }\n        // Array\n        const array = splitArray(type).array;\n        if (array) {\n            assertArgument(array.count === -1 || array.count === value.length, `array length mismatch; expected length ${array.count}`, \"value\", value);\n            return value.map((v) => this._visit(array.prefix, v, callback));\n        }\n        // Struct\n        const fields = this.types[type];\n        if (fields) {\n            return fields.reduce((accum, { name, type }) => {\n                accum[name] = this._visit(type, value[name], callback);\n                return accum;\n            }, {});\n        }\n        assertArgument(false, `unknown type: ${type}`, \"type\", type);\n    }\n    /**\n     *  Call %%calback%% for each value in %%value%%, passing the type and\n     *  component within %%value%%.\n     *\n     *  This is useful for replacing addresses or other transformation that\n     *  may be desired on each component, based on its type.\n     */\n    visit(value, callback) {\n        return this._visit(this.primaryType, value, callback);\n    }\n    /**\n     *  Create a new **TypedDataEncoder** for %%types%%.\n     */\n    static from(types) {\n        return new TypedDataEncoder(types);\n    }\n    /**\n     *  Return the primary type for %%types%%.\n     */\n    static getPrimaryType(types) {\n        return TypedDataEncoder.from(types).primaryType;\n    }\n    /**\n     *  Return the hashed struct for %%value%% using %%types%% and %%name%%.\n     */\n    static hashStruct(name, types, value) {\n        return TypedDataEncoder.from(types).hashStruct(name, value);\n    }\n    /**\n     *  Return the domain hash for %%domain%%.\n     */\n    static hashDomain(domain) {\n        const domainFields = [];\n        for (const name in domain) {\n            if (domain[name] == null) {\n                continue;\n            }\n            const type = domainFieldTypes[name];\n            assertArgument(type, `invalid typed-data domain key: ${JSON.stringify(name)}`, \"domain\", domain);\n            domainFields.push({ name, type });\n        }\n        domainFields.sort((a, b) => {\n            return domainFieldNames.indexOf(a.name) - domainFieldNames.indexOf(b.name);\n        });\n        return TypedDataEncoder.hashStruct(\"EIP712Domain\", { EIP712Domain: domainFields }, domain);\n    }\n    /**\n     *  Return the fully encoded [[link-eip-712]] %%value%% for %%types%% with %%domain%%.\n     */\n    static encode(domain, types, value) {\n        return concat([\n            \"0x1901\",\n            TypedDataEncoder.hashDomain(domain),\n            TypedDataEncoder.from(types).hash(value)\n        ]);\n    }\n    /**\n     *  Return the hash of the fully encoded [[link-eip-712]] %%value%% for %%types%% with %%domain%%.\n     */\n    static hash(domain, types, value) {\n        return keccak256(TypedDataEncoder.encode(domain, types, value));\n    }\n    // Replaces all address types with ENS names with their looked up address\n    /**\n     * Resolves to the value from resolving all addresses in %%value%% for\n     * %%types%% and the %%domain%%.\n     */\n    static async resolveNames(domain, types, value, resolveName) {\n        // Make a copy to isolate it from the object passed in\n        domain = Object.assign({}, domain);\n        // Allow passing null to ignore value\n        for (const key in domain) {\n            if (domain[key] == null) {\n                delete domain[key];\n            }\n        }\n        // Look up all ENS names\n        const ensCache = {};\n        // Do we need to look up the domain's verifyingContract?\n        if (domain.verifyingContract && !isHexString(domain.verifyingContract, 20)) {\n            ensCache[domain.verifyingContract] = \"0x\";\n        }\n        // We are going to use the encoder to visit all the base values\n        const encoder = TypedDataEncoder.from(types);\n        // Get a list of all the addresses\n        encoder.visit(value, (type, value) => {\n            if (type === \"address\" && !isHexString(value, 20)) {\n                ensCache[value] = \"0x\";\n            }\n            return value;\n        });\n        // Lookup each name\n        for (const name in ensCache) {\n            ensCache[name] = await resolveName(name);\n        }\n        // Replace the domain verifyingContract if needed\n        if (domain.verifyingContract && ensCache[domain.verifyingContract]) {\n            domain.verifyingContract = ensCache[domain.verifyingContract];\n        }\n        // Replace all ENS names with their address\n        value = encoder.visit(value, (type, value) => {\n            if (type === \"address\" && ensCache[value]) {\n                return ensCache[value];\n            }\n            return value;\n        });\n        return { domain, value };\n    }\n    /**\n     *  Returns the JSON-encoded payload expected by nodes which implement\n     *  the JSON-RPC [[link-eip-712]] method.\n     */\n    static getPayload(domain, types, value) {\n        // Validate the domain fields\n        TypedDataEncoder.hashDomain(domain);\n        // Derive the EIP712Domain Struct reference type\n        const domainValues = {};\n        const domainTypes = [];\n        domainFieldNames.forEach((name) => {\n            const value = domain[name];\n            if (value == null) {\n                return;\n            }\n            domainValues[name] = domainChecks[name](value);\n            domainTypes.push({ name, type: domainFieldTypes[name] });\n        });\n        const encoder = TypedDataEncoder.from(types);\n        // Get the normalized types\n        types = encoder.types;\n        const typesWithDomain = Object.assign({}, types);\n        assertArgument(typesWithDomain.EIP712Domain == null, \"types must not contain EIP712Domain type\", \"types.EIP712Domain\", types);\n        typesWithDomain.EIP712Domain = domainTypes;\n        // Validate the data structures and types\n        encoder.encode(value);\n        return {\n            types: typesWithDomain,\n            domain: domainValues,\n            primaryType: encoder.primaryType,\n            message: encoder.visit(value, (type, value) => {\n                // bytes\n                if (type.match(/^bytes(\\d*)/)) {\n                    return hexlify(getBytes(value));\n                }\n                // uint or int\n                if (type.match(/^u?int/)) {\n                    return getBigInt(value).toString();\n                }\n                switch (type) {\n                    case \"address\":\n                        return value.toLowerCase();\n                    case \"bool\":\n                        return !!value;\n                    case \"string\":\n                        assertArgument(typeof (value) === \"string\", \"invalid string\", \"value\", value);\n                        return value;\n                }\n                assertArgument(false, \"unsupported type\", \"type\", type);\n            })\n        };\n    }\n}\n/**\n *  Compute the address used to sign the typed data for the %%signature%%.\n */\nexport function verifyTypedData(domain, types, value, signature) {\n    return recoverAddress(TypedDataEncoder.hash(domain, types, value), signature);\n}\n//# sourceMappingURL=typed-data.js.map","/**\n *  A constant for the zero address.\n *\n *  (**i.e.** ``\"0x0000000000000000000000000000000000000000\"``)\n */\nexport const ZeroAddress = \"0x0000000000000000000000000000000000000000\";\n//# sourceMappingURL=addresses.js.map","import { hash as assertHash, number as assertNumber } from './_assert.js';\nimport { hmac } from './hmac.js';\nimport { createView, toBytes, checkOpts, asyncLoop } from './utils.js';\n// Common prologue and epilogue for sync/async functions\nfunction pbkdf2Init(hash, _password, _salt, _opts) {\n    assertHash(hash);\n    const opts = checkOpts({ dkLen: 32, asyncTick: 10 }, _opts);\n    const { c, dkLen, asyncTick } = opts;\n    assertNumber(c);\n    assertNumber(dkLen);\n    assertNumber(asyncTick);\n    if (c < 1)\n        throw new Error('PBKDF2: iterations (c) should be >= 1');\n    const password = toBytes(_password);\n    const salt = toBytes(_salt);\n    // DK = PBKDF2(PRF, Password, Salt, c, dkLen);\n    const DK = new Uint8Array(dkLen);\n    // U1 = PRF(Password, Salt + INT_32_BE(i))\n    const PRF = hmac.create(hash, password);\n    const PRFSalt = PRF._cloneInto().update(salt);\n    return { c, dkLen, asyncTick, DK, PRF, PRFSalt };\n}\nfunction pbkdf2Output(PRF, PRFSalt, DK, prfW, u) {\n    PRF.destroy();\n    PRFSalt.destroy();\n    if (prfW)\n        prfW.destroy();\n    u.fill(0);\n    return DK;\n}\n/**\n * PBKDF2-HMAC: RFC 2898 key derivation function\n * @param hash - hash function that would be used e.g. sha256\n * @param password - password from which a derived key is generated\n * @param salt - cryptographic salt\n * @param opts - {c, dkLen} where c is work factor and dkLen is output message size\n */\nexport function pbkdf2(hash, password, salt, opts) {\n    const { c, dkLen, DK, PRF, PRFSalt } = pbkdf2Init(hash, password, salt, opts);\n    let prfW; // Working copy\n    const arr = new Uint8Array(4);\n    const view = createView(arr);\n    const u = new Uint8Array(PRF.outputLen);\n    // DK = T1 + T2 + ⋯ + Tdklen/hlen\n    for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {\n        // Ti = F(Password, Salt, c, i)\n        const Ti = DK.subarray(pos, pos + PRF.outputLen);\n        view.setInt32(0, ti, false);\n        // F(Password, Salt, c, i) = U1 ^ U2 ^ ⋯ ^ Uc\n        // U1 = PRF(Password, Salt + INT_32_BE(i))\n        (prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);\n        Ti.set(u.subarray(0, Ti.length));\n        for (let ui = 1; ui < c; ui++) {\n            // Uc = PRF(Password, Uc−1)\n            PRF._cloneInto(prfW).update(u).digestInto(u);\n            for (let i = 0; i < Ti.length; i++)\n                Ti[i] ^= u[i];\n        }\n    }\n    return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);\n}\nexport async function pbkdf2Async(hash, password, salt, opts) {\n    const { c, dkLen, asyncTick, DK, PRF, PRFSalt } = pbkdf2Init(hash, password, salt, opts);\n    let prfW; // Working copy\n    const arr = new Uint8Array(4);\n    const view = createView(arr);\n    const u = new Uint8Array(PRF.outputLen);\n    // DK = T1 + T2 + ⋯ + Tdklen/hlen\n    for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {\n        // Ti = F(Password, Salt, c, i)\n        const Ti = DK.subarray(pos, pos + PRF.outputLen);\n        view.setInt32(0, ti, false);\n        // F(Password, Salt, c, i) = U1 ^ U2 ^ ⋯ ^ Uc\n        // U1 = PRF(Password, Salt + INT_32_BE(i))\n        (prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);\n        Ti.set(u.subarray(0, Ti.length));\n        await asyncLoop(c - 1, asyncTick, () => {\n            // Uc = PRF(Password, Uc−1)\n            PRF._cloneInto(prfW).update(u).digestInto(u);\n            for (let i = 0; i < Ti.length; i++)\n                Ti[i] ^= u[i];\n        });\n    }\n    return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);\n}\n//# sourceMappingURL=pbkdf2.js.map","import { SHA2 } from './_sha2.js';\nimport u64 from './_u64.js';\nimport { wrapConstructor } from './utils.js';\n// Round contants (first 32 bits of the fractional parts of the cube roots of the first 80 primes 2..409):\n// prettier-ignore\nconst [SHA512_Kh, SHA512_Kl] = /* @__PURE__ */ (() => u64.split([\n    '0x428a2f98d728ae22', '0x7137449123ef65cd', '0xb5c0fbcfec4d3b2f', '0xe9b5dba58189dbbc',\n    '0x3956c25bf348b538', '0x59f111f1b605d019', '0x923f82a4af194f9b', '0xab1c5ed5da6d8118',\n    '0xd807aa98a3030242', '0x12835b0145706fbe', '0x243185be4ee4b28c', '0x550c7dc3d5ffb4e2',\n    '0x72be5d74f27b896f', '0x80deb1fe3b1696b1', '0x9bdc06a725c71235', '0xc19bf174cf692694',\n    '0xe49b69c19ef14ad2', '0xefbe4786384f25e3', '0x0fc19dc68b8cd5b5', '0x240ca1cc77ac9c65',\n    '0x2de92c6f592b0275', '0x4a7484aa6ea6e483', '0x5cb0a9dcbd41fbd4', '0x76f988da831153b5',\n    '0x983e5152ee66dfab', '0xa831c66d2db43210', '0xb00327c898fb213f', '0xbf597fc7beef0ee4',\n    '0xc6e00bf33da88fc2', '0xd5a79147930aa725', '0x06ca6351e003826f', '0x142929670a0e6e70',\n    '0x27b70a8546d22ffc', '0x2e1b21385c26c926', '0x4d2c6dfc5ac42aed', '0x53380d139d95b3df',\n    '0x650a73548baf63de', '0x766a0abb3c77b2a8', '0x81c2c92e47edaee6', '0x92722c851482353b',\n    '0xa2bfe8a14cf10364', '0xa81a664bbc423001', '0xc24b8b70d0f89791', '0xc76c51a30654be30',\n    '0xd192e819d6ef5218', '0xd69906245565a910', '0xf40e35855771202a', '0x106aa07032bbd1b8',\n    '0x19a4c116b8d2d0c8', '0x1e376c085141ab53', '0x2748774cdf8eeb99', '0x34b0bcb5e19b48a8',\n    '0x391c0cb3c5c95a63', '0x4ed8aa4ae3418acb', '0x5b9cca4f7763e373', '0x682e6ff3d6b2b8a3',\n    '0x748f82ee5defb2fc', '0x78a5636f43172f60', '0x84c87814a1f0ab72', '0x8cc702081a6439ec',\n    '0x90befffa23631e28', '0xa4506cebde82bde9', '0xbef9a3f7b2c67915', '0xc67178f2e372532b',\n    '0xca273eceea26619c', '0xd186b8c721c0c207', '0xeada7dd6cde0eb1e', '0xf57d4f7fee6ed178',\n    '0x06f067aa72176fba', '0x0a637dc5a2c898a6', '0x113f9804bef90dae', '0x1b710b35131c471b',\n    '0x28db77f523047d84', '0x32caab7b40c72493', '0x3c9ebe0a15c9bebc', '0x431d67c49c100d4c',\n    '0x4cc5d4becb3e42b6', '0x597f299cfc657e2a', '0x5fcb6fab3ad6faec', '0x6c44198c4a475817'\n].map(n => BigInt(n))))();\n// Temporary buffer, not used to store anything between runs\nconst SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);\nconst SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);\nexport class SHA512 extends SHA2 {\n    constructor() {\n        super(128, 64, 16, false);\n        // We cannot use array here since array allows indexing by variable which means optimizer/compiler cannot use registers.\n        // Also looks cleaner and easier to verify with spec.\n        // Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):\n        // h -- high 32 bits, l -- low 32 bits\n        this.Ah = 0x6a09e667 | 0;\n        this.Al = 0xf3bcc908 | 0;\n        this.Bh = 0xbb67ae85 | 0;\n        this.Bl = 0x84caa73b | 0;\n        this.Ch = 0x3c6ef372 | 0;\n        this.Cl = 0xfe94f82b | 0;\n        this.Dh = 0xa54ff53a | 0;\n        this.Dl = 0x5f1d36f1 | 0;\n        this.Eh = 0x510e527f | 0;\n        this.El = 0xade682d1 | 0;\n        this.Fh = 0x9b05688c | 0;\n        this.Fl = 0x2b3e6c1f | 0;\n        this.Gh = 0x1f83d9ab | 0;\n        this.Gl = 0xfb41bd6b | 0;\n        this.Hh = 0x5be0cd19 | 0;\n        this.Hl = 0x137e2179 | 0;\n    }\n    // prettier-ignore\n    get() {\n        const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;\n        return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];\n    }\n    // prettier-ignore\n    set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {\n        this.Ah = Ah | 0;\n        this.Al = Al | 0;\n        this.Bh = Bh | 0;\n        this.Bl = Bl | 0;\n        this.Ch = Ch | 0;\n        this.Cl = Cl | 0;\n        this.Dh = Dh | 0;\n        this.Dl = Dl | 0;\n        this.Eh = Eh | 0;\n        this.El = El | 0;\n        this.Fh = Fh | 0;\n        this.Fl = Fl | 0;\n        this.Gh = Gh | 0;\n        this.Gl = Gl | 0;\n        this.Hh = Hh | 0;\n        this.Hl = Hl | 0;\n    }\n    process(view, offset) {\n        // Extend the first 16 words into the remaining 64 words w[16..79] of the message schedule array\n        for (let i = 0; i < 16; i++, offset += 4) {\n            SHA512_W_H[i] = view.getUint32(offset);\n            SHA512_W_L[i] = view.getUint32((offset += 4));\n        }\n        for (let i = 16; i < 80; i++) {\n            // s0 := (w[i-15] rightrotate 1) xor (w[i-15] rightrotate 8) xor (w[i-15] rightshift 7)\n            const W15h = SHA512_W_H[i - 15] | 0;\n            const W15l = SHA512_W_L[i - 15] | 0;\n            const s0h = u64.rotrSH(W15h, W15l, 1) ^ u64.rotrSH(W15h, W15l, 8) ^ u64.shrSH(W15h, W15l, 7);\n            const s0l = u64.rotrSL(W15h, W15l, 1) ^ u64.rotrSL(W15h, W15l, 8) ^ u64.shrSL(W15h, W15l, 7);\n            // s1 := (w[i-2] rightrotate 19) xor (w[i-2] rightrotate 61) xor (w[i-2] rightshift 6)\n            const W2h = SHA512_W_H[i - 2] | 0;\n            const W2l = SHA512_W_L[i - 2] | 0;\n            const s1h = u64.rotrSH(W2h, W2l, 19) ^ u64.rotrBH(W2h, W2l, 61) ^ u64.shrSH(W2h, W2l, 6);\n            const s1l = u64.rotrSL(W2h, W2l, 19) ^ u64.rotrBL(W2h, W2l, 61) ^ u64.shrSL(W2h, W2l, 6);\n            // SHA256_W[i] = s0 + s1 + SHA256_W[i - 7] + SHA256_W[i - 16];\n            const SUMl = u64.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);\n            const SUMh = u64.add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);\n            SHA512_W_H[i] = SUMh | 0;\n            SHA512_W_L[i] = SUMl | 0;\n        }\n        let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;\n        // Compression function main loop, 80 rounds\n        for (let i = 0; i < 80; i++) {\n            // S1 := (e rightrotate 14) xor (e rightrotate 18) xor (e rightrotate 41)\n            const sigma1h = u64.rotrSH(Eh, El, 14) ^ u64.rotrSH(Eh, El, 18) ^ u64.rotrBH(Eh, El, 41);\n            const sigma1l = u64.rotrSL(Eh, El, 14) ^ u64.rotrSL(Eh, El, 18) ^ u64.rotrBL(Eh, El, 41);\n            //const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;\n            const CHIh = (Eh & Fh) ^ (~Eh & Gh);\n            const CHIl = (El & Fl) ^ (~El & Gl);\n            // T1 = H + sigma1 + Chi(E, F, G) + SHA512_K[i] + SHA512_W[i]\n            // prettier-ignore\n            const T1ll = u64.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);\n            const T1h = u64.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);\n            const T1l = T1ll | 0;\n            // S0 := (a rightrotate 28) xor (a rightrotate 34) xor (a rightrotate 39)\n            const sigma0h = u64.rotrSH(Ah, Al, 28) ^ u64.rotrBH(Ah, Al, 34) ^ u64.rotrBH(Ah, Al, 39);\n            const sigma0l = u64.rotrSL(Ah, Al, 28) ^ u64.rotrBL(Ah, Al, 34) ^ u64.rotrBL(Ah, Al, 39);\n            const MAJh = (Ah & Bh) ^ (Ah & Ch) ^ (Bh & Ch);\n            const MAJl = (Al & Bl) ^ (Al & Cl) ^ (Bl & Cl);\n            Hh = Gh | 0;\n            Hl = Gl | 0;\n            Gh = Fh | 0;\n            Gl = Fl | 0;\n            Fh = Eh | 0;\n            Fl = El | 0;\n            ({ h: Eh, l: El } = u64.add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));\n            Dh = Ch | 0;\n            Dl = Cl | 0;\n            Ch = Bh | 0;\n            Cl = Bl | 0;\n            Bh = Ah | 0;\n            Bl = Al | 0;\n            const All = u64.add3L(T1l, sigma0l, MAJl);\n            Ah = u64.add3H(All, T1h, sigma0h, MAJh);\n            Al = All | 0;\n        }\n        // Add the compressed chunk to the current hash value\n        ({ h: Ah, l: Al } = u64.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));\n        ({ h: Bh, l: Bl } = u64.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));\n        ({ h: Ch, l: Cl } = u64.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));\n        ({ h: Dh, l: Dl } = u64.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));\n        ({ h: Eh, l: El } = u64.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));\n        ({ h: Fh, l: Fl } = u64.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));\n        ({ h: Gh, l: Gl } = u64.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));\n        ({ h: Hh, l: Hl } = u64.add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));\n        this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);\n    }\n    roundClean() {\n        SHA512_W_H.fill(0);\n        SHA512_W_L.fill(0);\n    }\n    destroy() {\n        this.buffer.fill(0);\n        this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);\n    }\n}\nclass SHA512_224 extends SHA512 {\n    constructor() {\n        super();\n        // h -- high 32 bits, l -- low 32 bits\n        this.Ah = 0x8c3d37c8 | 0;\n        this.Al = 0x19544da2 | 0;\n        this.Bh = 0x73e19966 | 0;\n        this.Bl = 0x89dcd4d6 | 0;\n        this.Ch = 0x1dfab7ae | 0;\n        this.Cl = 0x32ff9c82 | 0;\n        this.Dh = 0x679dd514 | 0;\n        this.Dl = 0x582f9fcf | 0;\n        this.Eh = 0x0f6d2b69 | 0;\n        this.El = 0x7bd44da8 | 0;\n        this.Fh = 0x77e36f73 | 0;\n        this.Fl = 0x04c48942 | 0;\n        this.Gh = 0x3f9d85a8 | 0;\n        this.Gl = 0x6a1d36c8 | 0;\n        this.Hh = 0x1112e6ad | 0;\n        this.Hl = 0x91d692a1 | 0;\n        this.outputLen = 28;\n    }\n}\nclass SHA512_256 extends SHA512 {\n    constructor() {\n        super();\n        // h -- high 32 bits, l -- low 32 bits\n        this.Ah = 0x22312194 | 0;\n        this.Al = 0xfc2bf72c | 0;\n        this.Bh = 0x9f555fa3 | 0;\n        this.Bl = 0xc84c64c2 | 0;\n        this.Ch = 0x2393b86b | 0;\n        this.Cl = 0x6f53b151 | 0;\n        this.Dh = 0x96387719 | 0;\n        this.Dl = 0x5940eabd | 0;\n        this.Eh = 0x96283ee2 | 0;\n        this.El = 0xa88effe3 | 0;\n        this.Fh = 0xbe5e1e25 | 0;\n        this.Fl = 0x53863992 | 0;\n        this.Gh = 0x2b0199fc | 0;\n        this.Gl = 0x2c85b8aa | 0;\n        this.Hh = 0x0eb72ddc | 0;\n        this.Hl = 0x81c52ca2 | 0;\n        this.outputLen = 32;\n    }\n}\nclass SHA384 extends SHA512 {\n    constructor() {\n        super();\n        // h -- high 32 bits, l -- low 32 bits\n        this.Ah = 0xcbbb9d5d | 0;\n        this.Al = 0xc1059ed8 | 0;\n        this.Bh = 0x629a292a | 0;\n        this.Bl = 0x367cd507 | 0;\n        this.Ch = 0x9159015a | 0;\n        this.Cl = 0x3070dd17 | 0;\n        this.Dh = 0x152fecd8 | 0;\n        this.Dl = 0xf70e5939 | 0;\n        this.Eh = 0x67332667 | 0;\n        this.El = 0xffc00b31 | 0;\n        this.Fh = 0x8eb44a87 | 0;\n        this.Fl = 0x68581511 | 0;\n        this.Gh = 0xdb0c2e0d | 0;\n        this.Gl = 0x64f98fa7 | 0;\n        this.Hh = 0x47b5481d | 0;\n        this.Hl = 0xbefa4fa4 | 0;\n        this.outputLen = 48;\n    }\n}\nexport const sha512 = /* @__PURE__ */ wrapConstructor(() => new SHA512());\nexport const sha512_224 = /* @__PURE__ */ wrapConstructor(() => new SHA512_224());\nexport const sha512_256 = /* @__PURE__ */ wrapConstructor(() => new SHA512_256());\nexport const sha384 = /* @__PURE__ */ wrapConstructor(() => new SHA384());\n//# sourceMappingURL=sha512.js.map","/* Browser Crypto Shims */\nimport { hmac } from \"@noble/hashes/hmac\";\nimport { pbkdf2 } from \"@noble/hashes/pbkdf2\";\nimport { sha256 } from \"@noble/hashes/sha256\";\nimport { sha512 } from \"@noble/hashes/sha512\";\nimport { assert, assertArgument } from \"../utils/index.js\";\nfunction getGlobal() {\n    if (typeof self !== 'undefined') {\n        return self;\n    }\n    if (typeof window !== 'undefined') {\n        return window;\n    }\n    if (typeof global !== 'undefined') {\n        return global;\n    }\n    throw new Error('unable to locate global object');\n}\n;\nconst anyGlobal = getGlobal();\nconst crypto = anyGlobal.crypto || anyGlobal.msCrypto;\nexport function createHash(algo) {\n    switch (algo) {\n        case \"sha256\": return sha256.create();\n        case \"sha512\": return sha512.create();\n    }\n    assertArgument(false, \"invalid hashing algorithm name\", \"algorithm\", algo);\n}\nexport function createHmac(_algo, key) {\n    const algo = ({ sha256, sha512 }[_algo]);\n    assertArgument(algo != null, \"invalid hmac algorithm\", \"algorithm\", _algo);\n    return hmac.create(algo, key);\n}\nexport function pbkdf2Sync(password, salt, iterations, keylen, _algo) {\n    const algo = ({ sha256, sha512 }[_algo]);\n    assertArgument(algo != null, \"invalid pbkdf2 algorithm\", \"algorithm\", _algo);\n    return pbkdf2(algo, password, salt, { c: iterations, dkLen: keylen });\n}\nexport function randomBytes(length) {\n    assert(crypto != null, \"platform does not support secure random numbers\", \"UNSUPPORTED_OPERATION\", {\n        operation: \"randomBytes\"\n    });\n    assertArgument(Number.isInteger(length) && length > 0 && length <= 1024, \"invalid length\", \"length\", length);\n    const result = new Uint8Array(length);\n    crypto.getRandomValues(result);\n    return result;\n}\n//# sourceMappingURL=crypto-browser.js.map","import { createHash } from \"./crypto.js\";\nimport { getBytes, hexlify } from \"../utils/index.js\";\nconst _sha256 = function (data) {\n    return createHash(\"sha256\").update(data).digest();\n};\nconst _sha512 = function (data) {\n    return createHash(\"sha512\").update(data).digest();\n};\nlet __sha256 = _sha256;\nlet __sha512 = _sha512;\nlet locked256 = false, locked512 = false;\n/**\n *  Compute the cryptographic SHA2-256 hash of %%data%%.\n *\n *  @_docloc: api/crypto:Hash Functions\n *  @returns DataHexstring\n *\n *  @example:\n *    sha256(\"0x\")\n *    //_result:\n *\n *    sha256(\"0x1337\")\n *    //_result:\n *\n *    sha256(new Uint8Array([ 0x13, 0x37 ]))\n *    //_result:\n *\n */\nexport function sha256(_data) {\n    const data = getBytes(_data, \"data\");\n    return hexlify(__sha256(data));\n}\nsha256._ = _sha256;\nsha256.lock = function () { locked256 = true; };\nsha256.register = function (func) {\n    if (locked256) {\n        throw new Error(\"sha256 is locked\");\n    }\n    __sha256 = func;\n};\nObject.freeze(sha256);\n/**\n *  Compute the cryptographic SHA2-512 hash of %%data%%.\n *\n *  @_docloc: api/crypto:Hash Functions\n *  @returns DataHexstring\n *\n *  @example:\n *    sha512(\"0x\")\n *    //_result:\n *\n *    sha512(\"0x1337\")\n *    //_result:\n *\n *    sha512(new Uint8Array([ 0x13, 0x37 ]))\n *    //_result:\n */\nexport function sha512(_data) {\n    const data = getBytes(_data, \"data\");\n    return hexlify(__sha512(data));\n}\nsha512._ = _sha512;\nsha512.lock = function () { locked512 = true; };\nsha512.register = function (func) {\n    if (locked512) {\n        throw new Error(\"sha512 is locked\");\n    }\n    __sha512 = func;\n};\nObject.freeze(sha256);\n//# sourceMappingURL=sha2.js.map","//See: https://github.com/ethereum/wiki/wiki/RLP\nimport { hexlify } from \"./data.js\";\nimport { assert, assertArgument } from \"./errors.js\";\nimport { getBytes } from \"./data.js\";\nfunction hexlifyByte(value) {\n    let result = value.toString(16);\n    while (result.length < 2) {\n        result = \"0\" + result;\n    }\n    return \"0x\" + result;\n}\nfunction unarrayifyInteger(data, offset, length) {\n    let result = 0;\n    for (let i = 0; i < length; i++) {\n        result = (result * 256) + data[offset + i];\n    }\n    return result;\n}\nfunction _decodeChildren(data, offset, childOffset, length) {\n    const result = [];\n    while (childOffset < offset + 1 + length) {\n        const decoded = _decode(data, childOffset);\n        result.push(decoded.result);\n        childOffset += decoded.consumed;\n        assert(childOffset <= offset + 1 + length, \"child data too short\", \"BUFFER_OVERRUN\", {\n            buffer: data, length, offset\n        });\n    }\n    return { consumed: (1 + length), result: result };\n}\n// returns { consumed: number, result: Object }\nfunction _decode(data, offset) {\n    assert(data.length !== 0, \"data too short\", \"BUFFER_OVERRUN\", {\n        buffer: data, length: 0, offset: 1\n    });\n    const checkOffset = (offset) => {\n        assert(offset <= data.length, \"data short segment too short\", \"BUFFER_OVERRUN\", {\n            buffer: data, length: data.length, offset\n        });\n    };\n    // Array with extra length prefix\n    if (data[offset] >= 0xf8) {\n        const lengthLength = data[offset] - 0xf7;\n        checkOffset(offset + 1 + lengthLength);\n        const length = unarrayifyInteger(data, offset + 1, lengthLength);\n        checkOffset(offset + 1 + lengthLength + length);\n        return _decodeChildren(data, offset, offset + 1 + lengthLength, lengthLength + length);\n    }\n    else if (data[offset] >= 0xc0) {\n        const length = data[offset] - 0xc0;\n        checkOffset(offset + 1 + length);\n        return _decodeChildren(data, offset, offset + 1, length);\n    }\n    else if (data[offset] >= 0xb8) {\n        const lengthLength = data[offset] - 0xb7;\n        checkOffset(offset + 1 + lengthLength);\n        const length = unarrayifyInteger(data, offset + 1, lengthLength);\n        checkOffset(offset + 1 + lengthLength + length);\n        const result = hexlify(data.slice(offset + 1 + lengthLength, offset + 1 + lengthLength + length));\n        return { consumed: (1 + lengthLength + length), result: result };\n    }\n    else if (data[offset] >= 0x80) {\n        const length = data[offset] - 0x80;\n        checkOffset(offset + 1 + length);\n        const result = hexlify(data.slice(offset + 1, offset + 1 + length));\n        return { consumed: (1 + length), result: result };\n    }\n    return { consumed: 1, result: hexlifyByte(data[offset]) };\n}\n/**\n *  Decodes %%data%% into the structured data it represents.\n */\nexport function decodeRlp(_data) {\n    const data = getBytes(_data, \"data\");\n    const decoded = _decode(data, 0);\n    assertArgument(decoded.consumed === data.length, \"unexpected junk after rlp payload\", \"data\", _data);\n    return decoded.result;\n}\n//# sourceMappingURL=rlp-decode.js.map","import { getAddress } from \"../address/index.js\";\nimport { assertArgument, isHexString } from \"../utils/index.js\";\nfunction accessSetify(addr, storageKeys) {\n    return {\n        address: getAddress(addr),\n        storageKeys: storageKeys.map((storageKey, index) => {\n            assertArgument(isHexString(storageKey, 32), \"invalid slot\", `storageKeys[${index}]`, storageKey);\n            return storageKey.toLowerCase();\n        })\n    };\n}\n/**\n *  Returns a [[AccessList]] from any ethers-supported access-list structure.\n */\nexport function accessListify(value) {\n    if (Array.isArray(value)) {\n        return value.map((set, index) => {\n            if (Array.isArray(set)) {\n                assertArgument(set.length === 2, \"invalid slot set\", `value[${index}]`, set);\n                return accessSetify(set[0], set[1]);\n            }\n            assertArgument(set != null && typeof (set) === \"object\", \"invalid address-slot set\", \"value\", value);\n            return accessSetify(set.address, set.storageKeys);\n        });\n    }\n    assertArgument(value != null && typeof (value) === \"object\", \"invalid access list\", \"value\", value);\n    const result = Object.keys(value).map((addr) => {\n        const storageKeys = value[addr].reduce((accum, storageKey) => {\n            accum[storageKey] = true;\n            return accum;\n        }, {});\n        return accessSetify(addr, Object.keys(storageKeys).sort());\n    });\n    result.sort((a, b) => (a.address.localeCompare(b.address)));\n    return result;\n}\n//# sourceMappingURL=accesslist.js.map","import { getAddress } from \"../address/index.js\";\nimport { keccak256, SigningKey } from \"../crypto/index.js\";\n/**\n *  Returns the address for the %%key%%.\n *\n *  The key may be any standard form of public key or a private key.\n */\nexport function computeAddress(key) {\n    let pubkey;\n    if (typeof (key) === \"string\") {\n        pubkey = SigningKey.computePublicKey(key, false);\n    }\n    else {\n        pubkey = key.publicKey;\n    }\n    return getAddress(keccak256(\"0x\" + pubkey.substring(4)).substring(26));\n}\n/**\n *  Returns the recovered address for the private key that was\n *  used to sign %%digest%% that resulted in %%signature%%.\n */\nexport function recoverAddress(digest, signature) {\n    return computeAddress(SigningKey.recoverPublicKey(digest, signature));\n}\n//# sourceMappingURL=address.js.map","import { getAddress } from \"../address/index.js\";\nimport { ZeroAddress } from \"../constants/addresses.js\";\nimport { keccak256, sha256, Signature, SigningKey } from \"../crypto/index.js\";\nimport { concat, decodeRlp, encodeRlp, getBytes, getBigInt, getNumber, hexlify, assert, assertArgument, isBytesLike, isHexString, toBeArray, zeroPadValue } from \"../utils/index.js\";\nimport { accessListify } from \"./accesslist.js\";\nimport { authorizationify } from \"./authorization.js\";\nimport { recoverAddress } from \"./address.js\";\nconst BN_0 = BigInt(0);\nconst BN_2 = BigInt(2);\nconst BN_27 = BigInt(27);\nconst BN_28 = BigInt(28);\nconst BN_35 = BigInt(35);\nconst BN_MAX_UINT = BigInt(\"0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\");\nconst BLOB_SIZE = 4096 * 32;\nfunction getKzgLibrary(kzg) {\n    const blobToKzgCommitment = (blob) => {\n        if (\"computeBlobProof\" in kzg) {\n            // micro-ecc-signer; check for computeBlobProof since this API\n            // expects a string while the kzg-wasm below expects a Unit8Array\n            if (\"blobToKzgCommitment\" in kzg && typeof (kzg.blobToKzgCommitment) === \"function\") {\n                return getBytes(kzg.blobToKzgCommitment(hexlify(blob)));\n            }\n        }\n        else if (\"blobToKzgCommitment\" in kzg && typeof (kzg.blobToKzgCommitment) === \"function\") {\n            // kzg-wasm <0.5.0; blobToKzgCommitment(Uint8Array) => Uint8Array\n            return getBytes(kzg.blobToKzgCommitment(blob));\n        }\n        // kzg-wasm >= 0.5.0; blobToKZGCommitment(string) => string\n        if (\"blobToKZGCommitment\" in kzg && typeof (kzg.blobToKZGCommitment) === \"function\") {\n            return getBytes(kzg.blobToKZGCommitment(hexlify(blob)));\n        }\n        assertArgument(false, \"unsupported KZG library\", \"kzg\", kzg);\n    };\n    const computeBlobKzgProof = (blob, commitment) => {\n        // micro-ecc-signer\n        if (\"computeBlobProof\" in kzg && typeof (kzg.computeBlobProof) === \"function\") {\n            return getBytes(kzg.computeBlobProof(hexlify(blob), hexlify(commitment)));\n        }\n        // kzg-wasm <0.5.0; computeBlobKzgProof(Uint8Array, Uint8Array) => Uint8Array\n        if (\"computeBlobKzgProof\" in kzg && typeof (kzg.computeBlobKzgProof) === \"function\") {\n            return kzg.computeBlobKzgProof(blob, commitment);\n        }\n        // kzg-wasm >= 0.5.0; computeBlobKZGProof(string, string) => string\n        if (\"computeBlobKZGProof\" in kzg && typeof (kzg.computeBlobKZGProof) === \"function\") {\n            return getBytes(kzg.computeBlobKZGProof(hexlify(blob), hexlify(commitment)));\n        }\n        assertArgument(false, \"unsupported KZG library\", \"kzg\", kzg);\n    };\n    return { blobToKzgCommitment, computeBlobKzgProof };\n}\nfunction getVersionedHash(version, hash) {\n    let versioned = version.toString(16);\n    while (versioned.length < 2) {\n        versioned = \"0\" + versioned;\n    }\n    versioned += sha256(hash).substring(4);\n    return \"0x\" + versioned;\n}\nfunction handleAddress(value) {\n    if (value === \"0x\") {\n        return null;\n    }\n    return getAddress(value);\n}\nfunction handleAccessList(value, param) {\n    try {\n        return accessListify(value);\n    }\n    catch (error) {\n        assertArgument(false, error.message, param, value);\n    }\n}\nfunction handleAuthorizationList(value, param) {\n    try {\n        if (!Array.isArray(value)) {\n            throw new Error(\"authorizationList: invalid array\");\n        }\n        const result = [];\n        for (let i = 0; i < value.length; i++) {\n            const auth = value[i];\n            if (!Array.isArray(auth)) {\n                throw new Error(`authorization[${i}]: invalid array`);\n            }\n            if (auth.length !== 6) {\n                throw new Error(`authorization[${i}]: wrong length`);\n            }\n            if (!auth[1]) {\n                throw new Error(`authorization[${i}]: null address`);\n            }\n            result.push({\n                address: handleAddress(auth[1]),\n                nonce: handleUint(auth[2], \"nonce\"),\n                chainId: handleUint(auth[0], \"chainId\"),\n                signature: Signature.from({\n                    yParity: handleNumber(auth[3], \"yParity\"),\n                    r: zeroPadValue(auth[4], 32),\n                    s: zeroPadValue(auth[5], 32)\n                })\n            });\n        }\n        return result;\n    }\n    catch (error) {\n        assertArgument(false, error.message, param, value);\n    }\n}\nfunction handleNumber(_value, param) {\n    if (_value === \"0x\") {\n        return 0;\n    }\n    return getNumber(_value, param);\n}\nfunction handleUint(_value, param) {\n    if (_value === \"0x\") {\n        return BN_0;\n    }\n    const value = getBigInt(_value, param);\n    assertArgument(value <= BN_MAX_UINT, \"value exceeds uint size\", param, value);\n    return value;\n}\nfunction formatNumber(_value, name) {\n    const value = getBigInt(_value, \"value\");\n    const result = toBeArray(value);\n    assertArgument(result.length <= 32, `value too large`, `tx.${name}`, value);\n    return result;\n}\nfunction formatAccessList(value) {\n    return accessListify(value).map((set) => [set.address, set.storageKeys]);\n}\nfunction formatAuthorizationList(value) {\n    return value.map((a) => {\n        return [\n            formatNumber(a.chainId, \"chainId\"),\n            a.address,\n            formatNumber(a.nonce, \"nonce\"),\n            formatNumber(a.signature.yParity, \"yParity\"),\n            toBeArray(a.signature.r),\n            toBeArray(a.signature.s)\n        ];\n    });\n}\nfunction formatHashes(value, param) {\n    assertArgument(Array.isArray(value), `invalid ${param}`, \"value\", value);\n    for (let i = 0; i < value.length; i++) {\n        assertArgument(isHexString(value[i], 32), \"invalid ${ param } hash\", `value[${i}]`, value[i]);\n    }\n    return value;\n}\nfunction _parseLegacy(data) {\n    const fields = decodeRlp(data);\n    assertArgument(Array.isArray(fields) && (fields.length === 9 || fields.length === 6), \"invalid field count for legacy transaction\", \"data\", data);\n    const tx = {\n        type: 0,\n        nonce: handleNumber(fields[0], \"nonce\"),\n        gasPrice: handleUint(fields[1], \"gasPrice\"),\n        gasLimit: handleUint(fields[2], \"gasLimit\"),\n        to: handleAddress(fields[3]),\n        value: handleUint(fields[4], \"value\"),\n        data: hexlify(fields[5]),\n        chainId: BN_0\n    };\n    // Legacy unsigned transaction\n    if (fields.length === 6) {\n        return tx;\n    }\n    const v = handleUint(fields[6], \"v\");\n    const r = handleUint(fields[7], \"r\");\n    const s = handleUint(fields[8], \"s\");\n    if (r === BN_0 && s === BN_0) {\n        // EIP-155 unsigned transaction\n        tx.chainId = v;\n    }\n    else {\n        // Compute the EIP-155 chain ID (or 0 for legacy)\n        let chainId = (v - BN_35) / BN_2;\n        if (chainId < BN_0) {\n            chainId = BN_0;\n        }\n        tx.chainId = chainId;\n        // Signed Legacy Transaction\n        assertArgument(chainId !== BN_0 || (v === BN_27 || v === BN_28), \"non-canonical legacy v\", \"v\", fields[6]);\n        tx.signature = Signature.from({\n            r: zeroPadValue(fields[7], 32),\n            s: zeroPadValue(fields[8], 32),\n            v\n        });\n        //tx.hash = keccak256(data);\n    }\n    return tx;\n}\nfunction _serializeLegacy(tx, sig) {\n    const fields = [\n        formatNumber(tx.nonce, \"nonce\"),\n        formatNumber(tx.gasPrice || 0, \"gasPrice\"),\n        formatNumber(tx.gasLimit, \"gasLimit\"),\n        (tx.to || \"0x\"),\n        formatNumber(tx.value, \"value\"),\n        tx.data,\n    ];\n    let chainId = BN_0;\n    if (tx.chainId != BN_0) {\n        // A chainId was provided; if non-zero we'll use EIP-155\n        chainId = getBigInt(tx.chainId, \"tx.chainId\");\n        // We have a chainId in the tx and an EIP-155 v in the signature,\n        // make sure they agree with each other\n        assertArgument(!sig || sig.networkV == null || sig.legacyChainId === chainId, \"tx.chainId/sig.v mismatch\", \"sig\", sig);\n    }\n    else if (tx.signature) {\n        // No explicit chainId, but EIP-155 have a derived implicit chainId\n        const legacy = tx.signature.legacyChainId;\n        if (legacy != null) {\n            chainId = legacy;\n        }\n    }\n    // Requesting an unsigned transaction\n    if (!sig) {\n        // We have an EIP-155 transaction (chainId was specified and non-zero)\n        if (chainId !== BN_0) {\n            fields.push(toBeArray(chainId));\n            fields.push(\"0x\");\n            fields.push(\"0x\");\n        }\n        return encodeRlp(fields);\n    }\n    // @TODO: We should probably check that tx.signature, chainId, and sig\n    //        match but that logic could break existing code, so schedule\n    //        this for the next major bump.\n    // Compute the EIP-155 v\n    let v = BigInt(27 + sig.yParity);\n    if (chainId !== BN_0) {\n        v = Signature.getChainIdV(chainId, sig.v);\n    }\n    else if (BigInt(sig.v) !== v) {\n        assertArgument(false, \"tx.chainId/sig.v mismatch\", \"sig\", sig);\n    }\n    // Add the signature\n    fields.push(toBeArray(v));\n    fields.push(toBeArray(sig.r));\n    fields.push(toBeArray(sig.s));\n    return encodeRlp(fields);\n}\nfunction _parseEipSignature(tx, fields) {\n    let yParity;\n    try {\n        yParity = handleNumber(fields[0], \"yParity\");\n        if (yParity !== 0 && yParity !== 1) {\n            throw new Error(\"bad yParity\");\n        }\n    }\n    catch (error) {\n        assertArgument(false, \"invalid yParity\", \"yParity\", fields[0]);\n    }\n    const r = zeroPadValue(fields[1], 32);\n    const s = zeroPadValue(fields[2], 32);\n    const signature = Signature.from({ r, s, yParity });\n    tx.signature = signature;\n}\nfunction _parseEip1559(data) {\n    const fields = decodeRlp(getBytes(data).slice(1));\n    assertArgument(Array.isArray(fields) && (fields.length === 9 || fields.length === 12), \"invalid field count for transaction type: 2\", \"data\", hexlify(data));\n    const tx = {\n        type: 2,\n        chainId: handleUint(fields[0], \"chainId\"),\n        nonce: handleNumber(fields[1], \"nonce\"),\n        maxPriorityFeePerGas: handleUint(fields[2], \"maxPriorityFeePerGas\"),\n        maxFeePerGas: handleUint(fields[3], \"maxFeePerGas\"),\n        gasPrice: null,\n        gasLimit: handleUint(fields[4], \"gasLimit\"),\n        to: handleAddress(fields[5]),\n        value: handleUint(fields[6], \"value\"),\n        data: hexlify(fields[7]),\n        accessList: handleAccessList(fields[8], \"accessList\"),\n    };\n    // Unsigned EIP-1559 Transaction\n    if (fields.length === 9) {\n        return tx;\n    }\n    //tx.hash = keccak256(data);\n    _parseEipSignature(tx, fields.slice(9));\n    return tx;\n}\nfunction _serializeEip1559(tx, sig) {\n    const fields = [\n        formatNumber(tx.chainId, \"chainId\"),\n        formatNumber(tx.nonce, \"nonce\"),\n        formatNumber(tx.maxPriorityFeePerGas || 0, \"maxPriorityFeePerGas\"),\n        formatNumber(tx.maxFeePerGas || 0, \"maxFeePerGas\"),\n        formatNumber(tx.gasLimit, \"gasLimit\"),\n        (tx.to || \"0x\"),\n        formatNumber(tx.value, \"value\"),\n        tx.data,\n        formatAccessList(tx.accessList || [])\n    ];\n    if (sig) {\n        fields.push(formatNumber(sig.yParity, \"yParity\"));\n        fields.push(toBeArray(sig.r));\n        fields.push(toBeArray(sig.s));\n    }\n    return concat([\"0x02\", encodeRlp(fields)]);\n}\nfunction _parseEip2930(data) {\n    const fields = decodeRlp(getBytes(data).slice(1));\n    assertArgument(Array.isArray(fields) && (fields.length === 8 || fields.length === 11), \"invalid field count for transaction type: 1\", \"data\", hexlify(data));\n    const tx = {\n        type: 1,\n        chainId: handleUint(fields[0], \"chainId\"),\n        nonce: handleNumber(fields[1], \"nonce\"),\n        gasPrice: handleUint(fields[2], \"gasPrice\"),\n        gasLimit: handleUint(fields[3], \"gasLimit\"),\n        to: handleAddress(fields[4]),\n        value: handleUint(fields[5], \"value\"),\n        data: hexlify(fields[6]),\n        accessList: handleAccessList(fields[7], \"accessList\")\n    };\n    // Unsigned EIP-2930 Transaction\n    if (fields.length === 8) {\n        return tx;\n    }\n    //tx.hash = keccak256(data);\n    _parseEipSignature(tx, fields.slice(8));\n    return tx;\n}\nfunction _serializeEip2930(tx, sig) {\n    const fields = [\n        formatNumber(tx.chainId, \"chainId\"),\n        formatNumber(tx.nonce, \"nonce\"),\n        formatNumber(tx.gasPrice || 0, \"gasPrice\"),\n        formatNumber(tx.gasLimit, \"gasLimit\"),\n        (tx.to || \"0x\"),\n        formatNumber(tx.value, \"value\"),\n        tx.data,\n        formatAccessList(tx.accessList || [])\n    ];\n    if (sig) {\n        fields.push(formatNumber(sig.yParity, \"recoveryParam\"));\n        fields.push(toBeArray(sig.r));\n        fields.push(toBeArray(sig.s));\n    }\n    return concat([\"0x01\", encodeRlp(fields)]);\n}\nfunction _parseEip4844(data) {\n    let fields = decodeRlp(getBytes(data).slice(1));\n    let typeName = \"3\";\n    let blobs = null;\n    // Parse the network format\n    if (fields.length === 4 && Array.isArray(fields[0])) {\n        typeName = \"3 (network format)\";\n        const fBlobs = fields[1], fCommits = fields[2], fProofs = fields[3];\n        assertArgument(Array.isArray(fBlobs), \"invalid network format: blobs not an array\", \"fields[1]\", fBlobs);\n        assertArgument(Array.isArray(fCommits), \"invalid network format: commitments not an array\", \"fields[2]\", fCommits);\n        assertArgument(Array.isArray(fProofs), \"invalid network format: proofs not an array\", \"fields[3]\", fProofs);\n        assertArgument(fBlobs.length === fCommits.length, \"invalid network format: blobs/commitments length mismatch\", \"fields\", fields);\n        assertArgument(fBlobs.length === fProofs.length, \"invalid network format: blobs/proofs length mismatch\", \"fields\", fields);\n        blobs = [];\n        for (let i = 0; i < fields[1].length; i++) {\n            blobs.push({\n                data: fBlobs[i],\n                commitment: fCommits[i],\n                proof: fProofs[i],\n            });\n        }\n        fields = fields[0];\n    }\n    assertArgument(Array.isArray(fields) && (fields.length === 11 || fields.length === 14), `invalid field count for transaction type: ${typeName}`, \"data\", hexlify(data));\n    const tx = {\n        type: 3,\n        chainId: handleUint(fields[0], \"chainId\"),\n        nonce: handleNumber(fields[1], \"nonce\"),\n        maxPriorityFeePerGas: handleUint(fields[2], \"maxPriorityFeePerGas\"),\n        maxFeePerGas: handleUint(fields[3], \"maxFeePerGas\"),\n        gasPrice: null,\n        gasLimit: handleUint(fields[4], \"gasLimit\"),\n        to: handleAddress(fields[5]),\n        value: handleUint(fields[6], \"value\"),\n        data: hexlify(fields[7]),\n        accessList: handleAccessList(fields[8], \"accessList\"),\n        maxFeePerBlobGas: handleUint(fields[9], \"maxFeePerBlobGas\"),\n        blobVersionedHashes: fields[10]\n    };\n    if (blobs) {\n        tx.blobs = blobs;\n    }\n    assertArgument(tx.to != null, `invalid address for transaction type: ${typeName}`, \"data\", data);\n    assertArgument(Array.isArray(tx.blobVersionedHashes), \"invalid blobVersionedHashes: must be an array\", \"data\", data);\n    for (let i = 0; i < tx.blobVersionedHashes.length; i++) {\n        assertArgument(isHexString(tx.blobVersionedHashes[i], 32), `invalid blobVersionedHash at index ${i}: must be length 32`, \"data\", data);\n    }\n    // Unsigned EIP-4844 Transaction\n    if (fields.length === 11) {\n        return tx;\n    }\n    // @TODO: Do we need to do this? This is only called internally\n    // and used to verify hashes; it might save time to not do this\n    //tx.hash = keccak256(concat([ \"0x03\", encodeRlp(fields) ]));\n    _parseEipSignature(tx, fields.slice(11));\n    return tx;\n}\nfunction _serializeEip4844(tx, sig, blobs) {\n    const fields = [\n        formatNumber(tx.chainId, \"chainId\"),\n        formatNumber(tx.nonce, \"nonce\"),\n        formatNumber(tx.maxPriorityFeePerGas || 0, \"maxPriorityFeePerGas\"),\n        formatNumber(tx.maxFeePerGas || 0, \"maxFeePerGas\"),\n        formatNumber(tx.gasLimit, \"gasLimit\"),\n        (tx.to || ZeroAddress),\n        formatNumber(tx.value, \"value\"),\n        tx.data,\n        formatAccessList(tx.accessList || []),\n        formatNumber(tx.maxFeePerBlobGas || 0, \"maxFeePerBlobGas\"),\n        formatHashes(tx.blobVersionedHashes || [], \"blobVersionedHashes\")\n    ];\n    if (sig) {\n        fields.push(formatNumber(sig.yParity, \"yParity\"));\n        fields.push(toBeArray(sig.r));\n        fields.push(toBeArray(sig.s));\n        // We have blobs; return the network wrapped format\n        if (blobs) {\n            return concat([\n                \"0x03\",\n                encodeRlp([\n                    fields,\n                    blobs.map((b) => b.data),\n                    blobs.map((b) => b.commitment),\n                    blobs.map((b) => b.proof),\n                ])\n            ]);\n        }\n    }\n    return concat([\"0x03\", encodeRlp(fields)]);\n}\nfunction _parseEip7702(data) {\n    const fields = decodeRlp(getBytes(data).slice(1));\n    assertArgument(Array.isArray(fields) && (fields.length === 10 || fields.length === 13), \"invalid field count for transaction type: 4\", \"data\", hexlify(data));\n    const tx = {\n        type: 4,\n        chainId: handleUint(fields[0], \"chainId\"),\n        nonce: handleNumber(fields[1], \"nonce\"),\n        maxPriorityFeePerGas: handleUint(fields[2], \"maxPriorityFeePerGas\"),\n        maxFeePerGas: handleUint(fields[3], \"maxFeePerGas\"),\n        gasPrice: null,\n        gasLimit: handleUint(fields[4], \"gasLimit\"),\n        to: handleAddress(fields[5]),\n        value: handleUint(fields[6], \"value\"),\n        data: hexlify(fields[7]),\n        accessList: handleAccessList(fields[8], \"accessList\"),\n        authorizationList: handleAuthorizationList(fields[9], \"authorizationList\"),\n    };\n    // Unsigned EIP-7702 Transaction\n    if (fields.length === 10) {\n        return tx;\n    }\n    _parseEipSignature(tx, fields.slice(10));\n    return tx;\n}\nfunction _serializeEip7702(tx, sig) {\n    const fields = [\n        formatNumber(tx.chainId, \"chainId\"),\n        formatNumber(tx.nonce, \"nonce\"),\n        formatNumber(tx.maxPriorityFeePerGas || 0, \"maxPriorityFeePerGas\"),\n        formatNumber(tx.maxFeePerGas || 0, \"maxFeePerGas\"),\n        formatNumber(tx.gasLimit, \"gasLimit\"),\n        (tx.to || \"0x\"),\n        formatNumber(tx.value, \"value\"),\n        tx.data,\n        formatAccessList(tx.accessList || []),\n        formatAuthorizationList(tx.authorizationList || [])\n    ];\n    if (sig) {\n        fields.push(formatNumber(sig.yParity, \"yParity\"));\n        fields.push(toBeArray(sig.r));\n        fields.push(toBeArray(sig.s));\n    }\n    return concat([\"0x04\", encodeRlp(fields)]);\n}\n/**\n *  A **Transaction** describes an operation to be executed on\n *  Ethereum by an Externally Owned Account (EOA). It includes\n *  who (the [[to]] address), what (the [[data]]) and how much (the\n *  [[value]] in ether) the operation should entail.\n *\n *  @example:\n *    tx = new Transaction()\n *    //_result:\n *\n *    tx.data = \"0x1234\";\n *    //_result:\n */\nexport class Transaction {\n    #type;\n    #to;\n    #data;\n    #nonce;\n    #gasLimit;\n    #gasPrice;\n    #maxPriorityFeePerGas;\n    #maxFeePerGas;\n    #value;\n    #chainId;\n    #sig;\n    #accessList;\n    #maxFeePerBlobGas;\n    #blobVersionedHashes;\n    #kzg;\n    #blobs;\n    #auths;\n    /**\n     *  The transaction type.\n     *\n     *  If null, the type will be automatically inferred based on\n     *  explicit properties.\n     */\n    get type() { return this.#type; }\n    set type(value) {\n        switch (value) {\n            case null:\n                this.#type = null;\n                break;\n            case 0:\n            case \"legacy\":\n                this.#type = 0;\n                break;\n            case 1:\n            case \"berlin\":\n            case \"eip-2930\":\n                this.#type = 1;\n                break;\n            case 2:\n            case \"london\":\n            case \"eip-1559\":\n                this.#type = 2;\n                break;\n            case 3:\n            case \"cancun\":\n            case \"eip-4844\":\n                this.#type = 3;\n                break;\n            case 4:\n            case \"pectra\":\n            case \"eip-7702\":\n                this.#type = 4;\n                break;\n            default:\n                assertArgument(false, \"unsupported transaction type\", \"type\", value);\n        }\n    }\n    /**\n     *  The name of the transaction type.\n     */\n    get typeName() {\n        switch (this.type) {\n            case 0: return \"legacy\";\n            case 1: return \"eip-2930\";\n            case 2: return \"eip-1559\";\n            case 3: return \"eip-4844\";\n            case 4: return \"eip-7702\";\n        }\n        return null;\n    }\n    /**\n     *  The ``to`` address for the transaction or ``null`` if the\n     *  transaction is an ``init`` transaction.\n     */\n    get to() {\n        const value = this.#to;\n        if (value == null && this.type === 3) {\n            return ZeroAddress;\n        }\n        return value;\n    }\n    set to(value) {\n        this.#to = (value == null) ? null : getAddress(value);\n    }\n    /**\n     *  The transaction nonce.\n     */\n    get nonce() { return this.#nonce; }\n    set nonce(value) { this.#nonce = getNumber(value, \"value\"); }\n    /**\n     *  The gas limit.\n     */\n    get gasLimit() { return this.#gasLimit; }\n    set gasLimit(value) { this.#gasLimit = getBigInt(value); }\n    /**\n     *  The gas price.\n     *\n     *  On legacy networks this defines the fee that will be paid. On\n     *  EIP-1559 networks, this should be ``null``.\n     */\n    get gasPrice() {\n        const value = this.#gasPrice;\n        if (value == null && (this.type === 0 || this.type === 1)) {\n            return BN_0;\n        }\n        return value;\n    }\n    set gasPrice(value) {\n        this.#gasPrice = (value == null) ? null : getBigInt(value, \"gasPrice\");\n    }\n    /**\n     *  The maximum priority fee per unit of gas to pay. On legacy\n     *  networks this should be ``null``.\n     */\n    get maxPriorityFeePerGas() {\n        const value = this.#maxPriorityFeePerGas;\n        if (value == null) {\n            if (this.type === 2 || this.type === 3) {\n                return BN_0;\n            }\n            return null;\n        }\n        return value;\n    }\n    set maxPriorityFeePerGas(value) {\n        this.#maxPriorityFeePerGas = (value == null) ? null : getBigInt(value, \"maxPriorityFeePerGas\");\n    }\n    /**\n     *  The maximum total fee per unit of gas to pay. On legacy\n     *  networks this should be ``null``.\n     */\n    get maxFeePerGas() {\n        const value = this.#maxFeePerGas;\n        if (value == null) {\n            if (this.type === 2 || this.type === 3) {\n                return BN_0;\n            }\n            return null;\n        }\n        return value;\n    }\n    set maxFeePerGas(value) {\n        this.#maxFeePerGas = (value == null) ? null : getBigInt(value, \"maxFeePerGas\");\n    }\n    /**\n     *  The transaction data. For ``init`` transactions this is the\n     *  deployment code.\n     */\n    get data() { return this.#data; }\n    set data(value) { this.#data = hexlify(value); }\n    /**\n     *  The amount of ether (in wei) to send in this transactions.\n     */\n    get value() { return this.#value; }\n    set value(value) {\n        this.#value = getBigInt(value, \"value\");\n    }\n    /**\n     *  The chain ID this transaction is valid on.\n     */\n    get chainId() { return this.#chainId; }\n    set chainId(value) { this.#chainId = getBigInt(value); }\n    /**\n     *  If signed, the signature for this transaction.\n     */\n    get signature() { return this.#sig || null; }\n    set signature(value) {\n        this.#sig = (value == null) ? null : Signature.from(value);\n    }\n    /**\n     *  The access list.\n     *\n     *  An access list permits discounted (but pre-paid) access to\n     *  bytecode and state variable access within contract execution.\n     */\n    get accessList() {\n        const value = this.#accessList || null;\n        if (value == null) {\n            if (this.type === 1 || this.type === 2 || this.type === 3) {\n                // @TODO: in v7, this should assign the value or become\n                // a live object itself, otherwise mutation is inconsistent\n                return [];\n            }\n            return null;\n        }\n        return value;\n    }\n    set accessList(value) {\n        this.#accessList = (value == null) ? null : accessListify(value);\n    }\n    get authorizationList() {\n        const value = this.#auths || null;\n        if (value == null) {\n            if (this.type === 4) {\n                // @TODO: in v7, this should become a live object itself,\n                // otherwise mutation is inconsistent\n                return [];\n            }\n        }\n        return value;\n    }\n    set authorizationList(auths) {\n        this.#auths = (auths == null) ? null : auths.map((a) => authorizationify(a));\n    }\n    /**\n     *  The max fee per blob gas for Cancun transactions.\n     */\n    get maxFeePerBlobGas() {\n        const value = this.#maxFeePerBlobGas;\n        if (value == null && this.type === 3) {\n            return BN_0;\n        }\n        return value;\n    }\n    set maxFeePerBlobGas(value) {\n        this.#maxFeePerBlobGas = (value == null) ? null : getBigInt(value, \"maxFeePerBlobGas\");\n    }\n    /**\n     *  The BLOb versioned hashes for Cancun transactions.\n     */\n    get blobVersionedHashes() {\n        // @TODO: Mutation is inconsistent; if unset, the returned value\n        // cannot mutate the object, if set it can\n        let value = this.#blobVersionedHashes;\n        if (value == null && this.type === 3) {\n            return [];\n        }\n        return value;\n    }\n    set blobVersionedHashes(value) {\n        if (value != null) {\n            assertArgument(Array.isArray(value), \"blobVersionedHashes must be an Array\", \"value\", value);\n            value = value.slice();\n            for (let i = 0; i < value.length; i++) {\n                assertArgument(isHexString(value[i], 32), \"invalid blobVersionedHash\", `value[${i}]`, value[i]);\n            }\n        }\n        this.#blobVersionedHashes = value;\n    }\n    /**\n     *  The BLObs for the Transaction, if any.\n     *\n     *  If ``blobs`` is non-``null``, then the [[seriailized]]\n     *  will return the network formatted sidecar, otherwise it\n     *  will return the standard [[link-eip-2718]] payload. The\n     *  [[unsignedSerialized]] is unaffected regardless.\n     *\n     *  When setting ``blobs``, either fully valid [[Blob]] objects\n     *  may be specified (i.e. correctly padded, with correct\n     *  committments and proofs) or a raw [[BytesLike]] may\n     *  be provided.\n     *\n     *  If raw [[BytesLike]] are provided, the [[kzg]] property **must**\n     *  be already set. The blob will be correctly padded and the\n     *  [[KzgLibrary]] will be used to compute the committment and\n     *  proof for the blob.\n     *\n     *  A BLOb is a sequence of field elements, each of which must\n     *  be within the BLS field modulo, so some additional processing\n     *  may be required to encode arbitrary data to ensure each 32 byte\n     *  field is within the valid range.\n     *\n     *  Setting this automatically populates [[blobVersionedHashes]],\n     *  overwriting any existing values. Setting this to ``null``\n     *  does **not** remove the [[blobVersionedHashes]], leaving them\n     *  present.\n     */\n    get blobs() {\n        if (this.#blobs == null) {\n            return null;\n        }\n        return this.#blobs.map((b) => Object.assign({}, b));\n    }\n    set blobs(_blobs) {\n        if (_blobs == null) {\n            this.#blobs = null;\n            return;\n        }\n        const blobs = [];\n        const versionedHashes = [];\n        for (let i = 0; i < _blobs.length; i++) {\n            const blob = _blobs[i];\n            if (isBytesLike(blob)) {\n                assert(this.#kzg, \"adding a raw blob requires a KZG library\", \"UNSUPPORTED_OPERATION\", {\n                    operation: \"set blobs()\"\n                });\n                let data = getBytes(blob);\n                assertArgument(data.length <= BLOB_SIZE, \"blob is too large\", `blobs[${i}]`, blob);\n                // Pad blob if necessary\n                if (data.length !== BLOB_SIZE) {\n                    const padded = new Uint8Array(BLOB_SIZE);\n                    padded.set(data);\n                    data = padded;\n                }\n                const commit = this.#kzg.blobToKzgCommitment(data);\n                const proof = hexlify(this.#kzg.computeBlobKzgProof(data, commit));\n                blobs.push({\n                    data: hexlify(data),\n                    commitment: hexlify(commit),\n                    proof\n                });\n                versionedHashes.push(getVersionedHash(1, commit));\n            }\n            else {\n                const commit = hexlify(blob.commitment);\n                blobs.push({\n                    data: hexlify(blob.data),\n                    commitment: commit,\n                    proof: hexlify(blob.proof)\n                });\n                versionedHashes.push(getVersionedHash(1, commit));\n            }\n        }\n        this.#blobs = blobs;\n        this.#blobVersionedHashes = versionedHashes;\n    }\n    get kzg() { return this.#kzg; }\n    set kzg(kzg) {\n        if (kzg == null) {\n            this.#kzg = null;\n        }\n        else {\n            this.#kzg = getKzgLibrary(kzg);\n        }\n    }\n    /**\n     *  Creates a new Transaction with default values.\n     */\n    constructor() {\n        this.#type = null;\n        this.#to = null;\n        this.#nonce = 0;\n        this.#gasLimit = BN_0;\n        this.#gasPrice = null;\n        this.#maxPriorityFeePerGas = null;\n        this.#maxFeePerGas = null;\n        this.#data = \"0x\";\n        this.#value = BN_0;\n        this.#chainId = BN_0;\n        this.#sig = null;\n        this.#accessList = null;\n        this.#maxFeePerBlobGas = null;\n        this.#blobVersionedHashes = null;\n        this.#kzg = null;\n        this.#blobs = null;\n        this.#auths = null;\n    }\n    /**\n     *  The transaction hash, if signed. Otherwise, ``null``.\n     */\n    get hash() {\n        if (this.signature == null) {\n            return null;\n        }\n        return keccak256(this.#getSerialized(true, false));\n    }\n    /**\n     *  The pre-image hash of this transaction.\n     *\n     *  This is the digest that a [[Signer]] must sign to authorize\n     *  this transaction.\n     */\n    get unsignedHash() {\n        return keccak256(this.unsignedSerialized);\n    }\n    /**\n     *  The sending address, if signed. Otherwise, ``null``.\n     */\n    get from() {\n        if (this.signature == null) {\n            return null;\n        }\n        return recoverAddress(this.unsignedHash, this.signature);\n    }\n    /**\n     *  The public key of the sender, if signed. Otherwise, ``null``.\n     */\n    get fromPublicKey() {\n        if (this.signature == null) {\n            return null;\n        }\n        return SigningKey.recoverPublicKey(this.unsignedHash, this.signature);\n    }\n    /**\n     *  Returns true if signed.\n     *\n     *  This provides a Type Guard that properties requiring a signed\n     *  transaction are non-null.\n     */\n    isSigned() {\n        return this.signature != null;\n    }\n    #getSerialized(signed, sidecar) {\n        assert(!signed || this.signature != null, \"cannot serialize unsigned transaction; maybe you meant .unsignedSerialized\", \"UNSUPPORTED_OPERATION\", { operation: \".serialized\" });\n        const sig = signed ? this.signature : null;\n        switch (this.inferType()) {\n            case 0:\n                return _serializeLegacy(this, sig);\n            case 1:\n                return _serializeEip2930(this, sig);\n            case 2:\n                return _serializeEip1559(this, sig);\n            case 3:\n                return _serializeEip4844(this, sig, sidecar ? this.blobs : null);\n            case 4:\n                return _serializeEip7702(this, sig);\n        }\n        assert(false, \"unsupported transaction type\", \"UNSUPPORTED_OPERATION\", { operation: \".serialized\" });\n    }\n    /**\n     *  The serialized transaction.\n     *\n     *  This throws if the transaction is unsigned. For the pre-image,\n     *  use [[unsignedSerialized]].\n     */\n    get serialized() {\n        return this.#getSerialized(true, true);\n    }\n    /**\n     *  The transaction pre-image.\n     *\n     *  The hash of this is the digest which needs to be signed to\n     *  authorize this transaction.\n     */\n    get unsignedSerialized() {\n        return this.#getSerialized(false, false);\n    }\n    /**\n     *  Return the most \"likely\" type; currently the highest\n     *  supported transaction type.\n     */\n    inferType() {\n        const types = this.inferTypes();\n        // Prefer London (EIP-1559) over Cancun (BLOb)\n        if (types.indexOf(2) >= 0) {\n            return 2;\n        }\n        // Return the highest inferred type\n        return (types.pop());\n    }\n    /**\n     *  Validates the explicit properties and returns a list of compatible\n     *  transaction types.\n     */\n    inferTypes() {\n        // Checks that there are no conflicting properties set\n        const hasGasPrice = this.gasPrice != null;\n        const hasFee = (this.maxFeePerGas != null || this.maxPriorityFeePerGas != null);\n        const hasAccessList = (this.accessList != null);\n        const hasBlob = (this.#maxFeePerBlobGas != null || this.#blobVersionedHashes);\n        //if (hasGasPrice && hasFee) {\n        //    throw new Error(\"transaction cannot have gasPrice and maxFeePerGas\");\n        //}\n        if (this.maxFeePerGas != null && this.maxPriorityFeePerGas != null) {\n            assert(this.maxFeePerGas >= this.maxPriorityFeePerGas, \"priorityFee cannot be more than maxFee\", \"BAD_DATA\", { value: this });\n        }\n        //if (this.type === 2 && hasGasPrice) {\n        //    throw new Error(\"eip-1559 transaction cannot have gasPrice\");\n        //}\n        assert(!hasFee || (this.type !== 0 && this.type !== 1), \"transaction type cannot have maxFeePerGas or maxPriorityFeePerGas\", \"BAD_DATA\", { value: this });\n        assert(this.type !== 0 || !hasAccessList, \"legacy transaction cannot have accessList\", \"BAD_DATA\", { value: this });\n        const types = [];\n        // Explicit type\n        if (this.type != null) {\n            types.push(this.type);\n        }\n        else {\n            if (this.authorizationList && this.authorizationList.length) {\n                types.push(4);\n            }\n            else if (hasFee) {\n                types.push(2);\n            }\n            else if (hasGasPrice) {\n                types.push(1);\n                if (!hasAccessList) {\n                    types.push(0);\n                }\n            }\n            else if (hasAccessList) {\n                types.push(1);\n                types.push(2);\n            }\n            else if (hasBlob && this.to) {\n                types.push(3);\n            }\n            else {\n                types.push(0);\n                types.push(1);\n                types.push(2);\n                types.push(3);\n            }\n        }\n        types.sort();\n        return types;\n    }\n    /**\n     *  Returns true if this transaction is a legacy transaction (i.e.\n     *  ``type === 0``).\n     *\n     *  This provides a Type Guard that the related properties are\n     *  non-null.\n     */\n    isLegacy() {\n        return (this.type === 0);\n    }\n    /**\n     *  Returns true if this transaction is berlin hardform transaction (i.e.\n     *  ``type === 1``).\n     *\n     *  This provides a Type Guard that the related properties are\n     *  non-null.\n     */\n    isBerlin() {\n        return (this.type === 1);\n    }\n    /**\n     *  Returns true if this transaction is london hardform transaction (i.e.\n     *  ``type === 2``).\n     *\n     *  This provides a Type Guard that the related properties are\n     *  non-null.\n     */\n    isLondon() {\n        return (this.type === 2);\n    }\n    /**\n     *  Returns true if this transaction is an [[link-eip-4844]] BLOB\n     *  transaction.\n     *\n     *  This provides a Type Guard that the related properties are\n     *  non-null.\n     */\n    isCancun() {\n        return (this.type === 3);\n    }\n    /**\n     *  Create a copy of this transaciton.\n     */\n    clone() {\n        return Transaction.from(this);\n    }\n    /**\n     *  Return a JSON-friendly object.\n     */\n    toJSON() {\n        const s = (v) => {\n            if (v == null) {\n                return null;\n            }\n            return v.toString();\n        };\n        return {\n            type: this.type,\n            to: this.to,\n            //            from: this.from,\n            data: this.data,\n            nonce: this.nonce,\n            gasLimit: s(this.gasLimit),\n            gasPrice: s(this.gasPrice),\n            maxPriorityFeePerGas: s(this.maxPriorityFeePerGas),\n            maxFeePerGas: s(this.maxFeePerGas),\n            value: s(this.value),\n            chainId: s(this.chainId),\n            sig: this.signature ? this.signature.toJSON() : null,\n            accessList: this.accessList\n        };\n    }\n    /**\n     *  Create a **Transaction** from a serialized transaction or a\n     *  Transaction-like object.\n     */\n    static from(tx) {\n        if (tx == null) {\n            return new Transaction();\n        }\n        if (typeof (tx) === \"string\") {\n            const payload = getBytes(tx);\n            if (payload[0] >= 0x7f) { // @TODO: > vs >= ??\n                return Transaction.from(_parseLegacy(payload));\n            }\n            switch (payload[0]) {\n                case 1: return Transaction.from(_parseEip2930(payload));\n                case 2: return Transaction.from(_parseEip1559(payload));\n                case 3: return Transaction.from(_parseEip4844(payload));\n                case 4: return Transaction.from(_parseEip7702(payload));\n            }\n            assert(false, \"unsupported transaction type\", \"UNSUPPORTED_OPERATION\", { operation: \"from\" });\n        }\n        const result = new Transaction();\n        if (tx.type != null) {\n            result.type = tx.type;\n        }\n        if (tx.to != null) {\n            result.to = tx.to;\n        }\n        if (tx.nonce != null) {\n            result.nonce = tx.nonce;\n        }\n        if (tx.gasLimit != null) {\n            result.gasLimit = tx.gasLimit;\n        }\n        if (tx.gasPrice != null) {\n            result.gasPrice = tx.gasPrice;\n        }\n        if (tx.maxPriorityFeePerGas != null) {\n            result.maxPriorityFeePerGas = tx.maxPriorityFeePerGas;\n        }\n        if (tx.maxFeePerGas != null) {\n            result.maxFeePerGas = tx.maxFeePerGas;\n        }\n        if (tx.maxFeePerBlobGas != null) {\n            result.maxFeePerBlobGas = tx.maxFeePerBlobGas;\n        }\n        if (tx.data != null) {\n            result.data = tx.data;\n        }\n        if (tx.value != null) {\n            result.value = tx.value;\n        }\n        if (tx.chainId != null) {\n            result.chainId = tx.chainId;\n        }\n        if (tx.signature != null) {\n            result.signature = Signature.from(tx.signature);\n        }\n        if (tx.accessList != null) {\n            result.accessList = tx.accessList;\n        }\n        if (tx.authorizationList != null) {\n            result.authorizationList = tx.authorizationList;\n        }\n        // This will get overwritten by blobs, if present\n        if (tx.blobVersionedHashes != null) {\n            result.blobVersionedHashes = tx.blobVersionedHashes;\n        }\n        // Make sure we assign the kzg before assigning blobs, which\n        // require the library in the event raw blob data is provided.\n        if (tx.kzg != null) {\n            result.kzg = tx.kzg;\n        }\n        if (tx.blobs != null) {\n            result.blobs = tx.blobs;\n        }\n        if (tx.hash != null) {\n            assertArgument(result.isSigned(), \"unsigned transaction cannot define '.hash'\", \"tx\", tx);\n            assertArgument(result.hash === tx.hash, \"hash mismatch\", \"tx\", tx);\n        }\n        if (tx.from != null) {\n            assertArgument(result.isSigned(), \"unsigned transaction cannot define '.from'\", \"tx\", tx);\n            assertArgument(result.from.toLowerCase() === (tx.from || \"\").toLowerCase(), \"from mismatch\", \"tx\", tx);\n        }\n        return result;\n    }\n}\n//# sourceMappingURL=transaction.js.map","import { getAddress } from \"../address/index.js\";\nimport { Signature } from \"../crypto/index.js\";\nimport { getBigInt } from \"../utils/index.js\";\nexport function authorizationify(auth) {\n    return {\n        address: getAddress(auth.address),\n        nonce: getBigInt((auth.nonce != null) ? auth.nonce : 0),\n        chainId: getBigInt((auth.chainId != null) ? auth.chainId : 0),\n        signature: Signature.from(auth.signature)\n    };\n}\n//# sourceMappingURL=authorization.js.map","//import { resolveAddress } from \"@ethersproject/address\";\nimport { defineProperties, getBigInt, getNumber, hexlify, isBytesLike, resolveProperties, assert, assertArgument, isError, makeError } from \"../utils/index.js\";\nimport { accessListify } from \"../transaction/index.js\";\nconst BN_0 = BigInt(0);\n// -----------------------\nfunction getValue(value) {\n    if (value == null) {\n        return null;\n    }\n    return value;\n}\nfunction toJson(value) {\n    if (value == null) {\n        return null;\n    }\n    return value.toString();\n}\n// @TODO? <T extends FeeData = { }> implements Required<T>\n/**\n *  A **FeeData** wraps all the fee-related values associated with\n *  the network.\n */\nexport class FeeData {\n    /**\n     *  The gas price for legacy networks.\n     */\n    gasPrice;\n    /**\n     *  The maximum fee to pay per gas.\n     *\n     *  The base fee per gas is defined by the network and based on\n     *  congestion, increasing the cost during times of heavy load\n     *  and lowering when less busy.\n     *\n     *  The actual fee per gas will be the base fee for the block\n     *  and the priority fee, up to the max fee per gas.\n     *\n     *  This will be ``null`` on legacy networks (i.e. [pre-EIP-1559](link-eip-1559))\n     */\n    maxFeePerGas;\n    /**\n     *  The additional amout to pay per gas to encourage a validator\n     *  to include the transaction.\n     *\n     *  The purpose of this is to compensate the validator for the\n     *  adjusted risk for including a given transaction.\n     *\n     *  This will be ``null`` on legacy networks (i.e. [pre-EIP-1559](link-eip-1559))\n     */\n    maxPriorityFeePerGas;\n    /**\n     *  Creates a new FeeData for %%gasPrice%%, %%maxFeePerGas%% and\n     *  %%maxPriorityFeePerGas%%.\n     */\n    constructor(gasPrice, maxFeePerGas, maxPriorityFeePerGas) {\n        defineProperties(this, {\n            gasPrice: getValue(gasPrice),\n            maxFeePerGas: getValue(maxFeePerGas),\n            maxPriorityFeePerGas: getValue(maxPriorityFeePerGas)\n        });\n    }\n    /**\n     *  Returns a JSON-friendly value.\n     */\n    toJSON() {\n        const { gasPrice, maxFeePerGas, maxPriorityFeePerGas } = this;\n        return {\n            _type: \"FeeData\",\n            gasPrice: toJson(gasPrice),\n            maxFeePerGas: toJson(maxFeePerGas),\n            maxPriorityFeePerGas: toJson(maxPriorityFeePerGas),\n        };\n    }\n}\n;\n/**\n *  Returns a copy of %%req%% with all properties coerced to their strict\n *  types.\n */\nexport function copyRequest(req) {\n    const result = {};\n    // These could be addresses, ENS names or Addressables\n    if (req.to) {\n        result.to = req.to;\n    }\n    if (req.from) {\n        result.from = req.from;\n    }\n    if (req.data) {\n        result.data = hexlify(req.data);\n    }\n    const bigIntKeys = \"chainId,gasLimit,gasPrice,maxFeePerBlobGas,maxFeePerGas,maxPriorityFeePerGas,value\".split(/,/);\n    for (const key of bigIntKeys) {\n        if (!(key in req) || req[key] == null) {\n            continue;\n        }\n        result[key] = getBigInt(req[key], `request.${key}`);\n    }\n    const numberKeys = \"type,nonce\".split(/,/);\n    for (const key of numberKeys) {\n        if (!(key in req) || req[key] == null) {\n            continue;\n        }\n        result[key] = getNumber(req[key], `request.${key}`);\n    }\n    if (req.accessList) {\n        result.accessList = accessListify(req.accessList);\n    }\n    if (req.authorizationList) {\n        result.authorizationList = req.authorizationList.slice();\n    }\n    if (\"blockTag\" in req) {\n        result.blockTag = req.blockTag;\n    }\n    if (\"enableCcipRead\" in req) {\n        result.enableCcipRead = !!req.enableCcipRead;\n    }\n    if (\"customData\" in req) {\n        result.customData = req.customData;\n    }\n    if (\"blobVersionedHashes\" in req && req.blobVersionedHashes) {\n        result.blobVersionedHashes = req.blobVersionedHashes.slice();\n    }\n    if (\"kzg\" in req) {\n        result.kzg = req.kzg;\n    }\n    if (\"blobs\" in req && req.blobs) {\n        result.blobs = req.blobs.map((b) => {\n            if (isBytesLike(b)) {\n                return hexlify(b);\n            }\n            return Object.assign({}, b);\n        });\n    }\n    return result;\n}\n/**\n *  A **Block** represents the data associated with a full block on\n *  Ethereum.\n */\nexport class Block {\n    /**\n     *  The provider connected to the block used to fetch additional details\n     *  if necessary.\n     */\n    provider;\n    /**\n     *  The block number, sometimes called the block height. This is a\n     *  sequential number that is one higher than the parent block.\n     */\n    number;\n    /**\n     *  The block hash.\n     *\n     *  This hash includes all properties, so can be safely used to identify\n     *  an exact set of block properties.\n     */\n    hash;\n    /**\n     *  The timestamp for this block, which is the number of seconds since\n     *  epoch that this block was included.\n     */\n    timestamp;\n    /**\n     *  The block hash of the parent block.\n     */\n    parentHash;\n    /**\n     *  The hash tree root of the parent beacon block for the given\n     *  execution block. See [[link-eip-4788]].\n     */\n    parentBeaconBlockRoot;\n    /**\n     *  The nonce.\n     *\n     *  On legacy networks, this is the random number inserted which\n     *  permitted the difficulty target to be reached.\n     */\n    nonce;\n    /**\n     *  The difficulty target.\n     *\n     *  On legacy networks, this is the proof-of-work target required\n     *  for a block to meet the protocol rules to be included.\n     *\n     *  On modern networks, this is a random number arrived at using\n     *  randao.  @TODO: Find links?\n     */\n    difficulty;\n    /**\n     *  The total gas limit for this block.\n     */\n    gasLimit;\n    /**\n     *  The total gas used in this block.\n     */\n    gasUsed;\n    /**\n     *  The root hash for the global state after applying changes\n     *  in this block.\n     */\n    stateRoot;\n    /**\n     *  The hash of the transaction receipts trie.\n     */\n    receiptsRoot;\n    /**\n     *  The total amount of blob gas consumed by the transactions\n     *  within the block. See [[link-eip-4844]].\n     */\n    blobGasUsed;\n    /**\n     *  The running total of blob gas consumed in excess of the\n     *  target, prior to the block. See [[link-eip-4844]].\n     */\n    excessBlobGas;\n    /**\n     *  The miner coinbase address, wihch receives any subsidies for\n     *  including this block.\n     */\n    miner;\n    /**\n     *  The latest RANDAO mix of the post beacon state of\n     *  the previous block.\n     */\n    prevRandao;\n    /**\n     *  Any extra data the validator wished to include.\n     */\n    extraData;\n    /**\n     *  The base fee per gas that all transactions in this block were\n     *  charged.\n     *\n     *  This adjusts after each block, depending on how congested the network\n     *  is.\n     */\n    baseFeePerGas;\n    #transactions;\n    /**\n     *  Create a new **Block** object.\n     *\n     *  This should generally not be necessary as the unless implementing a\n     *  low-level library.\n     */\n    constructor(block, provider) {\n        this.#transactions = block.transactions.map((tx) => {\n            if (typeof (tx) !== \"string\") {\n                return new TransactionResponse(tx, provider);\n            }\n            return tx;\n        });\n        defineProperties(this, {\n            provider,\n            hash: getValue(block.hash),\n            number: block.number,\n            timestamp: block.timestamp,\n            parentHash: block.parentHash,\n            parentBeaconBlockRoot: block.parentBeaconBlockRoot,\n            nonce: block.nonce,\n            difficulty: block.difficulty,\n            gasLimit: block.gasLimit,\n            gasUsed: block.gasUsed,\n            blobGasUsed: block.blobGasUsed,\n            excessBlobGas: block.excessBlobGas,\n            miner: block.miner,\n            prevRandao: getValue(block.prevRandao),\n            extraData: block.extraData,\n            baseFeePerGas: getValue(block.baseFeePerGas),\n            stateRoot: block.stateRoot,\n            receiptsRoot: block.receiptsRoot,\n        });\n    }\n    /**\n     *  Returns the list of transaction hashes, in the order\n     *  they were executed within the block.\n     */\n    get transactions() {\n        return this.#transactions.map((tx) => {\n            if (typeof (tx) === \"string\") {\n                return tx;\n            }\n            return tx.hash;\n        });\n    }\n    /**\n     *  Returns the complete transactions, in the order they\n     *  were executed within the block.\n     *\n     *  This is only available for blocks which prefetched\n     *  transactions, by passing ``true`` to %%prefetchTxs%%\n     *  into [[Provider-getBlock]].\n     */\n    get prefetchedTransactions() {\n        const txs = this.#transactions.slice();\n        // Doesn't matter...\n        if (txs.length === 0) {\n            return [];\n        }\n        // Make sure we prefetched the transactions\n        assert(typeof (txs[0]) === \"object\", \"transactions were not prefetched with block request\", \"UNSUPPORTED_OPERATION\", {\n            operation: \"transactionResponses()\"\n        });\n        return txs;\n    }\n    /**\n     *  Returns a JSON-friendly value.\n     */\n    toJSON() {\n        const { baseFeePerGas, difficulty, extraData, gasLimit, gasUsed, hash, miner, prevRandao, nonce, number, parentHash, parentBeaconBlockRoot, stateRoot, receiptsRoot, timestamp, transactions } = this;\n        return {\n            _type: \"Block\",\n            baseFeePerGas: toJson(baseFeePerGas),\n            difficulty: toJson(difficulty),\n            extraData,\n            gasLimit: toJson(gasLimit),\n            gasUsed: toJson(gasUsed),\n            blobGasUsed: toJson(this.blobGasUsed),\n            excessBlobGas: toJson(this.excessBlobGas),\n            hash, miner, prevRandao, nonce, number, parentHash, timestamp,\n            parentBeaconBlockRoot, stateRoot, receiptsRoot,\n            transactions,\n        };\n    }\n    [Symbol.iterator]() {\n        let index = 0;\n        const txs = this.transactions;\n        return {\n            next: () => {\n                if (index < this.length) {\n                    return {\n                        value: txs[index++], done: false\n                    };\n                }\n                return { value: undefined, done: true };\n            }\n        };\n    }\n    /**\n     *  The number of transactions in this block.\n     */\n    get length() { return this.#transactions.length; }\n    /**\n     *  The [[link-js-date]] this block was included at.\n     */\n    get date() {\n        if (this.timestamp == null) {\n            return null;\n        }\n        return new Date(this.timestamp * 1000);\n    }\n    /**\n     *  Get the transaction at %%indexe%% within this block.\n     */\n    async getTransaction(indexOrHash) {\n        // Find the internal value by its index or hash\n        let tx = undefined;\n        if (typeof (indexOrHash) === \"number\") {\n            tx = this.#transactions[indexOrHash];\n        }\n        else {\n            const hash = indexOrHash.toLowerCase();\n            for (const v of this.#transactions) {\n                if (typeof (v) === \"string\") {\n                    if (v !== hash) {\n                        continue;\n                    }\n                    tx = v;\n                    break;\n                }\n                else {\n                    if (v.hash !== hash) {\n                        continue;\n                    }\n                    tx = v;\n                    break;\n                }\n            }\n        }\n        if (tx == null) {\n            throw new Error(\"no such tx\");\n        }\n        if (typeof (tx) === \"string\") {\n            return (await this.provider.getTransaction(tx));\n        }\n        else {\n            return tx;\n        }\n    }\n    /**\n     *  If a **Block** was fetched with a request to include the transactions\n     *  this will allow synchronous access to those transactions.\n     *\n     *  If the transactions were not prefetched, this will throw.\n     */\n    getPrefetchedTransaction(indexOrHash) {\n        const txs = this.prefetchedTransactions;\n        if (typeof (indexOrHash) === \"number\") {\n            return txs[indexOrHash];\n        }\n        indexOrHash = indexOrHash.toLowerCase();\n        for (const tx of txs) {\n            if (tx.hash === indexOrHash) {\n                return tx;\n            }\n        }\n        assertArgument(false, \"no matching transaction\", \"indexOrHash\", indexOrHash);\n    }\n    /**\n     *  Returns true if this block been mined. This provides a type guard\n     *  for all properties on a [[MinedBlock]].\n     */\n    isMined() { return !!this.hash; }\n    /**\n     *  Returns true if this block is an [[link-eip-2930]] block.\n     */\n    isLondon() {\n        return !!this.baseFeePerGas;\n    }\n    /**\n     *  @_ignore:\n     */\n    orphanedEvent() {\n        if (!this.isMined()) {\n            throw new Error(\"\");\n        }\n        return createOrphanedBlockFilter(this);\n    }\n}\n//////////////////////\n// Log\n/**\n *  A **Log** in Ethereum represents an event that has been included in a\n *  transaction using the ``LOG*`` opcodes, which are most commonly used by\n *  Solidity's emit for announcing events.\n */\nexport class Log {\n    /**\n     *  The provider connected to the log used to fetch additional details\n     *  if necessary.\n     */\n    provider;\n    /**\n     *  The transaction hash of the transaction this log occurred in. Use the\n     *  [[Log-getTransaction]] to get the [[TransactionResponse]].\n     */\n    transactionHash;\n    /**\n     *  The block hash of the block this log occurred in. Use the\n     *  [[Log-getBlock]] to get the [[Block]].\n     */\n    blockHash;\n    /**\n     *  The block number of the block this log occurred in. It is preferred\n     *  to use the [[Block-hash]] when fetching the related [[Block]],\n     *  since in the case of an orphaned block, the block at that height may\n     *  have changed.\n     */\n    blockNumber;\n    /**\n     *  If the **Log** represents a block that was removed due to an orphaned\n     *  block, this will be true.\n     *\n     *  This can only happen within an orphan event listener.\n     */\n    removed;\n    /**\n     *  The address of the contract that emitted this log.\n     */\n    address;\n    /**\n     *  The data included in this log when it was emitted.\n     */\n    data;\n    /**\n     *  The indexed topics included in this log when it was emitted.\n     *\n     *  All topics are included in the bloom filters, so they can be\n     *  efficiently filtered using the [[Provider-getLogs]] method.\n     */\n    topics;\n    /**\n     *  The index within the block this log occurred at. This is generally\n     *  not useful to developers, but can be used with the various roots\n     *  to proof inclusion within a block.\n     */\n    index;\n    /**\n     *  The index within the transaction of this log.\n     */\n    transactionIndex;\n    /**\n     *  @_ignore:\n     */\n    constructor(log, provider) {\n        this.provider = provider;\n        const topics = Object.freeze(log.topics.slice());\n        defineProperties(this, {\n            transactionHash: log.transactionHash,\n            blockHash: log.blockHash,\n            blockNumber: log.blockNumber,\n            removed: log.removed,\n            address: log.address,\n            data: log.data,\n            topics,\n            index: log.index,\n            transactionIndex: log.transactionIndex,\n        });\n    }\n    /**\n     *  Returns a JSON-compatible object.\n     */\n    toJSON() {\n        const { address, blockHash, blockNumber, data, index, removed, topics, transactionHash, transactionIndex } = this;\n        return {\n            _type: \"log\",\n            address, blockHash, blockNumber, data, index,\n            removed, topics, transactionHash, transactionIndex\n        };\n    }\n    /**\n     *  Returns the block that this log occurred in.\n     */\n    async getBlock() {\n        const block = await this.provider.getBlock(this.blockHash);\n        assert(!!block, \"failed to find transaction\", \"UNKNOWN_ERROR\", {});\n        return block;\n    }\n    /**\n     *  Returns the transaction that this log occurred in.\n     */\n    async getTransaction() {\n        const tx = await this.provider.getTransaction(this.transactionHash);\n        assert(!!tx, \"failed to find transaction\", \"UNKNOWN_ERROR\", {});\n        return tx;\n    }\n    /**\n     *  Returns the transaction receipt fot the transaction that this\n     *  log occurred in.\n     */\n    async getTransactionReceipt() {\n        const receipt = await this.provider.getTransactionReceipt(this.transactionHash);\n        assert(!!receipt, \"failed to find transaction receipt\", \"UNKNOWN_ERROR\", {});\n        return receipt;\n    }\n    /**\n     *  @_ignore:\n     */\n    removedEvent() {\n        return createRemovedLogFilter(this);\n    }\n}\n//////////////////////\n// Transaction Receipt\n/*\nexport interface LegacyTransactionReceipt {\n    byzantium: false;\n    status: null;\n    root: string;\n}\n\nexport interface ByzantiumTransactionReceipt {\n    byzantium: true;\n    status: number;\n    root: null;\n}\n*/\n/**\n *  A **TransactionReceipt** includes additional information about a\n *  transaction that is only available after it has been mined.\n */\nexport class TransactionReceipt {\n    /**\n     *  The provider connected to the log used to fetch additional details\n     *  if necessary.\n     */\n    provider;\n    /**\n     *  The address the transaction was sent to.\n     */\n    to;\n    /**\n     *  The sender of the transaction.\n     */\n    from;\n    /**\n     *  The address of the contract if the transaction was directly\n     *  responsible for deploying one.\n     *\n     *  This is non-null **only** if the ``to`` is empty and the ``data``\n     *  was successfully executed as initcode.\n     */\n    contractAddress;\n    /**\n     *  The transaction hash.\n     */\n    hash;\n    /**\n     *  The index of this transaction within the block transactions.\n     */\n    index;\n    /**\n     *  The block hash of the [[Block]] this transaction was included in.\n     */\n    blockHash;\n    /**\n     *  The block number of the [[Block]] this transaction was included in.\n     */\n    blockNumber;\n    /**\n     *  The bloom filter bytes that represent all logs that occurred within\n     *  this transaction. This is generally not useful for most developers,\n     *  but can be used to validate the included logs.\n     */\n    logsBloom;\n    /**\n     *  The actual amount of gas used by this transaction.\n     *\n     *  When creating a transaction, the amount of gas that will be used can\n     *  only be approximated, but the sender must pay the gas fee for the\n     *  entire gas limit. After the transaction, the difference is refunded.\n     */\n    gasUsed;\n    /**\n     *  The gas used for BLObs. See [[link-eip-4844]].\n     */\n    blobGasUsed;\n    /**\n     *  The amount of gas used by all transactions within the block for this\n     *  and all transactions with a lower ``index``.\n     *\n     *  This is generally not useful for developers but can be used to\n     *  validate certain aspects of execution.\n     */\n    cumulativeGasUsed;\n    /**\n     *  The actual gas price used during execution.\n     *\n     *  Due to the complexity of [[link-eip-1559]] this value can only\n     *  be caluclated after the transaction has been mined, snce the base\n     *  fee is protocol-enforced.\n     */\n    gasPrice;\n    /**\n     *  The price paid per BLOB in gas. See [[link-eip-4844]].\n     */\n    blobGasPrice;\n    /**\n     *  The [[link-eip-2718]] transaction type.\n     */\n    type;\n    //readonly byzantium!: boolean;\n    /**\n     *  The status of this transaction, indicating success (i.e. ``1``) or\n     *  a revert (i.e. ``0``).\n     *\n     *  This is available in post-byzantium blocks, but some backends may\n     *  backfill this value.\n     */\n    status;\n    /**\n     *  The root hash of this transaction.\n     *\n     *  This is no present and was only included in pre-byzantium blocks, but\n     *  could be used to validate certain parts of the receipt.\n     */\n    root;\n    #logs;\n    /**\n     *  @_ignore:\n     */\n    constructor(tx, provider) {\n        this.#logs = Object.freeze(tx.logs.map((log) => {\n            return new Log(log, provider);\n        }));\n        let gasPrice = BN_0;\n        if (tx.effectiveGasPrice != null) {\n            gasPrice = tx.effectiveGasPrice;\n        }\n        else if (tx.gasPrice != null) {\n            gasPrice = tx.gasPrice;\n        }\n        defineProperties(this, {\n            provider,\n            to: tx.to,\n            from: tx.from,\n            contractAddress: tx.contractAddress,\n            hash: tx.hash,\n            index: tx.index,\n            blockHash: tx.blockHash,\n            blockNumber: tx.blockNumber,\n            logsBloom: tx.logsBloom,\n            gasUsed: tx.gasUsed,\n            cumulativeGasUsed: tx.cumulativeGasUsed,\n            blobGasUsed: tx.blobGasUsed,\n            gasPrice,\n            blobGasPrice: tx.blobGasPrice,\n            type: tx.type,\n            //byzantium: tx.byzantium,\n            status: tx.status,\n            root: tx.root\n        });\n    }\n    /**\n     *  The logs for this transaction.\n     */\n    get logs() { return this.#logs; }\n    /**\n     *  Returns a JSON-compatible representation.\n     */\n    toJSON() {\n        const { to, from, contractAddress, hash, index, blockHash, blockNumber, logsBloom, logs, //byzantium, \n        status, root } = this;\n        return {\n            _type: \"TransactionReceipt\",\n            blockHash, blockNumber,\n            //byzantium, \n            contractAddress,\n            cumulativeGasUsed: toJson(this.cumulativeGasUsed),\n            from,\n            gasPrice: toJson(this.gasPrice),\n            blobGasUsed: toJson(this.blobGasUsed),\n            blobGasPrice: toJson(this.blobGasPrice),\n            gasUsed: toJson(this.gasUsed),\n            hash, index, logs, logsBloom, root, status, to\n        };\n    }\n    /**\n     *  @_ignore:\n     */\n    get length() { return this.logs.length; }\n    [Symbol.iterator]() {\n        let index = 0;\n        return {\n            next: () => {\n                if (index < this.length) {\n                    return { value: this.logs[index++], done: false };\n                }\n                return { value: undefined, done: true };\n            }\n        };\n    }\n    /**\n     *  The total fee for this transaction, in wei.\n     */\n    get fee() {\n        return this.gasUsed * this.gasPrice;\n    }\n    /**\n     *  Resolves to the block this transaction occurred in.\n     */\n    async getBlock() {\n        const block = await this.provider.getBlock(this.blockHash);\n        if (block == null) {\n            throw new Error(\"TODO\");\n        }\n        return block;\n    }\n    /**\n     *  Resolves to the transaction this transaction occurred in.\n     */\n    async getTransaction() {\n        const tx = await this.provider.getTransaction(this.hash);\n        if (tx == null) {\n            throw new Error(\"TODO\");\n        }\n        return tx;\n    }\n    /**\n     *  Resolves to the return value of the execution of this transaction.\n     *\n     *  Support for this feature is limited, as it requires an archive node\n     *  with the ``debug_`` or ``trace_`` API enabled.\n     */\n    async getResult() {\n        return (await this.provider.getTransactionResult(this.hash));\n    }\n    /**\n     *  Resolves to the number of confirmations this transaction has.\n     */\n    async confirmations() {\n        return (await this.provider.getBlockNumber()) - this.blockNumber + 1;\n    }\n    /**\n     *  @_ignore:\n     */\n    removedEvent() {\n        return createRemovedTransactionFilter(this);\n    }\n    /**\n     *  @_ignore:\n     */\n    reorderedEvent(other) {\n        assert(!other || other.isMined(), \"unmined 'other' transction cannot be orphaned\", \"UNSUPPORTED_OPERATION\", { operation: \"reorderedEvent(other)\" });\n        return createReorderedTransactionFilter(this, other);\n    }\n}\n/**\n *  A **TransactionResponse** includes all properties about a transaction\n *  that was sent to the network, which may or may not be included in a\n *  block.\n *\n *  The [[TransactionResponse-isMined]] can be used to check if the\n *  transaction has been mined as well as type guard that the otherwise\n *  possibly ``null`` properties are defined.\n */\nexport class TransactionResponse {\n    /**\n     *  The provider this is connected to, which will influence how its\n     *  methods will resolve its async inspection methods.\n     */\n    provider;\n    /**\n     *  The block number of the block that this transaction was included in.\n     *\n     *  This is ``null`` for pending transactions.\n     */\n    blockNumber;\n    /**\n     *  The blockHash of the block that this transaction was included in.\n     *\n     *  This is ``null`` for pending transactions.\n     */\n    blockHash;\n    /**\n     *  The index within the block that this transaction resides at.\n     */\n    index;\n    /**\n     *  The transaction hash.\n     */\n    hash;\n    /**\n     *  The [[link-eip-2718]] transaction envelope type. This is\n     *  ``0`` for legacy transactions types.\n     */\n    type;\n    /**\n     *  The receiver of this transaction.\n     *\n     *  If ``null``, then the transaction is an initcode transaction.\n     *  This means the result of executing the [[data]] will be deployed\n     *  as a new contract on chain (assuming it does not revert) and the\n     *  address may be computed using [[getCreateAddress]].\n     */\n    to;\n    /**\n     *  The sender of this transaction. It is implicitly computed\n     *  from the transaction pre-image hash (as the digest) and the\n     *  [[signature]] using ecrecover.\n     */\n    from;\n    /**\n     *  The nonce, which is used to prevent replay attacks and offer\n     *  a method to ensure transactions from a given sender are explicitly\n     *  ordered.\n     *\n     *  When sending a transaction, this must be equal to the number of\n     *  transactions ever sent by [[from]].\n     */\n    nonce;\n    /**\n     *  The maximum units of gas this transaction can consume. If execution\n     *  exceeds this, the entries transaction is reverted and the sender\n     *  is charged for the full amount, despite not state changes being made.\n     */\n    gasLimit;\n    /**\n     *  The gas price can have various values, depending on the network.\n     *\n     *  In modern networks, for transactions that are included this is\n     *  the //effective gas price// (the fee per gas that was actually\n     *  charged), while for transactions that have not been included yet\n     *  is the [[maxFeePerGas]].\n     *\n     *  For legacy transactions, or transactions on legacy networks, this\n     *  is the fee that will be charged per unit of gas the transaction\n     *  consumes.\n     */\n    gasPrice;\n    /**\n     *  The maximum priority fee (per unit of gas) to allow a\n     *  validator to charge the sender. This is inclusive of the\n     *  [[maxFeeFeePerGas]].\n     */\n    maxPriorityFeePerGas;\n    /**\n     *  The maximum fee (per unit of gas) to allow this transaction\n     *  to charge the sender.\n     */\n    maxFeePerGas;\n    /**\n     *  The [[link-eip-4844]] max fee per BLOb gas.\n     */\n    maxFeePerBlobGas;\n    /**\n     *  The data.\n     */\n    data;\n    /**\n     *  The value, in wei. Use [[formatEther]] to format this value\n     *  as ether.\n     */\n    value;\n    /**\n     *  The chain ID.\n     */\n    chainId;\n    /**\n     *  The signature.\n     */\n    signature;\n    /**\n     *  The [[link-eip-2930]] access list for transaction types that\n     *  support it, otherwise ``null``.\n     */\n    accessList;\n    /**\n     *  The [[link-eip-4844]] BLOb versioned hashes.\n     */\n    blobVersionedHashes;\n    /**\n     *  The [[link-eip-7702]] authorizations (if any).\n     */\n    authorizationList;\n    #startBlock;\n    /**\n     *  @_ignore:\n     */\n    constructor(tx, provider) {\n        this.provider = provider;\n        this.blockNumber = (tx.blockNumber != null) ? tx.blockNumber : null;\n        this.blockHash = (tx.blockHash != null) ? tx.blockHash : null;\n        this.hash = tx.hash;\n        this.index = tx.index;\n        this.type = tx.type;\n        this.from = tx.from;\n        this.to = tx.to || null;\n        this.gasLimit = tx.gasLimit;\n        this.nonce = tx.nonce;\n        this.data = tx.data;\n        this.value = tx.value;\n        this.gasPrice = tx.gasPrice;\n        this.maxPriorityFeePerGas = (tx.maxPriorityFeePerGas != null) ? tx.maxPriorityFeePerGas : null;\n        this.maxFeePerGas = (tx.maxFeePerGas != null) ? tx.maxFeePerGas : null;\n        this.maxFeePerBlobGas = (tx.maxFeePerBlobGas != null) ? tx.maxFeePerBlobGas : null;\n        this.chainId = tx.chainId;\n        this.signature = tx.signature;\n        this.accessList = (tx.accessList != null) ? tx.accessList : null;\n        this.blobVersionedHashes = (tx.blobVersionedHashes != null) ? tx.blobVersionedHashes : null;\n        this.authorizationList = (tx.authorizationList != null) ? tx.authorizationList : null;\n        this.#startBlock = -1;\n    }\n    /**\n     *  Returns a JSON-compatible representation of this transaction.\n     */\n    toJSON() {\n        const { blockNumber, blockHash, index, hash, type, to, from, nonce, data, signature, accessList, blobVersionedHashes } = this;\n        return {\n            _type: \"TransactionResponse\",\n            accessList, blockNumber, blockHash,\n            blobVersionedHashes,\n            chainId: toJson(this.chainId),\n            data, from,\n            gasLimit: toJson(this.gasLimit),\n            gasPrice: toJson(this.gasPrice),\n            hash,\n            maxFeePerGas: toJson(this.maxFeePerGas),\n            maxPriorityFeePerGas: toJson(this.maxPriorityFeePerGas),\n            maxFeePerBlobGas: toJson(this.maxFeePerBlobGas),\n            nonce, signature, to, index, type,\n            value: toJson(this.value),\n        };\n    }\n    /**\n     *  Resolves to the Block that this transaction was included in.\n     *\n     *  This will return null if the transaction has not been included yet.\n     */\n    async getBlock() {\n        let blockNumber = this.blockNumber;\n        if (blockNumber == null) {\n            const tx = await this.getTransaction();\n            if (tx) {\n                blockNumber = tx.blockNumber;\n            }\n        }\n        if (blockNumber == null) {\n            return null;\n        }\n        const block = this.provider.getBlock(blockNumber);\n        if (block == null) {\n            throw new Error(\"TODO\");\n        }\n        return block;\n    }\n    /**\n     *  Resolves to this transaction being re-requested from the\n     *  provider. This can be used if you have an unmined transaction\n     *  and wish to get an up-to-date populated instance.\n     */\n    async getTransaction() {\n        return this.provider.getTransaction(this.hash);\n    }\n    /**\n     *  Resolve to the number of confirmations this transaction has.\n     */\n    async confirmations() {\n        if (this.blockNumber == null) {\n            const { tx, blockNumber } = await resolveProperties({\n                tx: this.getTransaction(),\n                blockNumber: this.provider.getBlockNumber()\n            });\n            // Not mined yet...\n            if (tx == null || tx.blockNumber == null) {\n                return 0;\n            }\n            return blockNumber - tx.blockNumber + 1;\n        }\n        const blockNumber = await this.provider.getBlockNumber();\n        return blockNumber - this.blockNumber + 1;\n    }\n    /**\n     *  Resolves once this transaction has been mined and has\n     *  %%confirms%% blocks including it (default: ``1``) with an\n     *  optional %%timeout%%.\n     *\n     *  This can resolve to ``null`` only if %%confirms%% is ``0``\n     *  and the transaction has not been mined, otherwise this will\n     *  wait until enough confirmations have completed.\n     */\n    async wait(_confirms, _timeout) {\n        const confirms = (_confirms == null) ? 1 : _confirms;\n        const timeout = (_timeout == null) ? 0 : _timeout;\n        let startBlock = this.#startBlock;\n        let nextScan = -1;\n        let stopScanning = (startBlock === -1) ? true : false;\n        const checkReplacement = async () => {\n            // Get the current transaction count for this sender\n            if (stopScanning) {\n                return null;\n            }\n            const { blockNumber, nonce } = await resolveProperties({\n                blockNumber: this.provider.getBlockNumber(),\n                nonce: this.provider.getTransactionCount(this.from)\n            });\n            // No transaction or our nonce has not been mined yet; but we\n            // can start scanning later when we do start\n            if (nonce < this.nonce) {\n                startBlock = blockNumber;\n                return;\n            }\n            // We were mined; no replacement\n            if (stopScanning) {\n                return null;\n            }\n            const mined = await this.getTransaction();\n            if (mined && mined.blockNumber != null) {\n                return;\n            }\n            // We were replaced; start scanning for that transaction\n            // Starting to scan; look back a few extra blocks for safety\n            if (nextScan === -1) {\n                nextScan = startBlock - 3;\n                if (nextScan < this.#startBlock) {\n                    nextScan = this.#startBlock;\n                }\n            }\n            while (nextScan <= blockNumber) {\n                // Get the next block to scan\n                if (stopScanning) {\n                    return null;\n                }\n                const block = await this.provider.getBlock(nextScan, true);\n                // This should not happen; but we'll try again shortly\n                if (block == null) {\n                    return;\n                }\n                // We were mined; no replacement\n                for (const hash of block) {\n                    if (hash === this.hash) {\n                        return;\n                    }\n                }\n                // Search for the transaction that replaced us\n                for (let i = 0; i < block.length; i++) {\n                    const tx = await block.getTransaction(i);\n                    if (tx.from === this.from && tx.nonce === this.nonce) {\n                        // Get the receipt\n                        if (stopScanning) {\n                            return null;\n                        }\n                        const receipt = await this.provider.getTransactionReceipt(tx.hash);\n                        // This should not happen; but we'll try again shortly\n                        if (receipt == null) {\n                            return;\n                        }\n                        // We will retry this on the next block (this case could be optimized)\n                        if ((blockNumber - receipt.blockNumber + 1) < confirms) {\n                            return;\n                        }\n                        // The reason we were replaced\n                        let reason = \"replaced\";\n                        if (tx.data === this.data && tx.to === this.to && tx.value === this.value) {\n                            reason = \"repriced\";\n                        }\n                        else if (tx.data === \"0x\" && tx.from === tx.to && tx.value === BN_0) {\n                            reason = \"cancelled\";\n                        }\n                        assert(false, \"transaction was replaced\", \"TRANSACTION_REPLACED\", {\n                            cancelled: (reason === \"replaced\" || reason === \"cancelled\"),\n                            reason,\n                            replacement: tx.replaceableTransaction(startBlock),\n                            hash: tx.hash,\n                            receipt\n                        });\n                    }\n                }\n                nextScan++;\n            }\n            return;\n        };\n        const checkReceipt = (receipt) => {\n            if (receipt == null || receipt.status !== 0) {\n                return receipt;\n            }\n            assert(false, \"transaction execution reverted\", \"CALL_EXCEPTION\", {\n                action: \"sendTransaction\",\n                data: null, reason: null, invocation: null, revert: null,\n                transaction: {\n                    to: receipt.to,\n                    from: receipt.from,\n                    data: \"\" // @TODO: in v7, split out sendTransaction properties\n                }, receipt\n            });\n        };\n        const receipt = await this.provider.getTransactionReceipt(this.hash);\n        if (confirms === 0) {\n            return checkReceipt(receipt);\n        }\n        if (receipt) {\n            if (confirms === 1 || (await receipt.confirmations()) >= confirms) {\n                return checkReceipt(receipt);\n            }\n        }\n        else {\n            // Check for a replacement; throws if a replacement was found\n            await checkReplacement();\n            // Allow null only when the confirms is 0\n            if (confirms === 0) {\n                return null;\n            }\n        }\n        const waiter = new Promise((resolve, reject) => {\n            // List of things to cancel when we have a result (one way or the other)\n            const cancellers = [];\n            const cancel = () => { cancellers.forEach((c) => c()); };\n            // On cancel, stop scanning for replacements\n            cancellers.push(() => { stopScanning = true; });\n            // Set up any timeout requested\n            if (timeout > 0) {\n                const timer = setTimeout(() => {\n                    cancel();\n                    reject(makeError(\"wait for transaction timeout\", \"TIMEOUT\"));\n                }, timeout);\n                cancellers.push(() => { clearTimeout(timer); });\n            }\n            const txListener = async (receipt) => {\n                // Done; return it!\n                if ((await receipt.confirmations()) >= confirms) {\n                    cancel();\n                    try {\n                        resolve(checkReceipt(receipt));\n                    }\n                    catch (error) {\n                        reject(error);\n                    }\n                }\n            };\n            cancellers.push(() => { this.provider.off(this.hash, txListener); });\n            this.provider.on(this.hash, txListener);\n            // We support replacement detection; start checking\n            if (startBlock >= 0) {\n                const replaceListener = async () => {\n                    try {\n                        // Check for a replacement; this throws only if one is found\n                        await checkReplacement();\n                    }\n                    catch (error) {\n                        // We were replaced (with enough confirms); re-throw the error\n                        if (isError(error, \"TRANSACTION_REPLACED\")) {\n                            cancel();\n                            reject(error);\n                            return;\n                        }\n                    }\n                    // Rescheudle a check on the next block\n                    if (!stopScanning) {\n                        this.provider.once(\"block\", replaceListener);\n                    }\n                };\n                cancellers.push(() => { this.provider.off(\"block\", replaceListener); });\n                this.provider.once(\"block\", replaceListener);\n            }\n        });\n        return await waiter;\n    }\n    /**\n     *  Returns ``true`` if this transaction has been included.\n     *\n     *  This is effective only as of the time the TransactionResponse\n     *  was instantiated. To get up-to-date information, use\n     *  [[getTransaction]].\n     *\n     *  This provides a Type Guard that this transaction will have\n     *  non-null property values for properties that are null for\n     *  unmined transactions.\n     */\n    isMined() {\n        return (this.blockHash != null);\n    }\n    /**\n     *  Returns true if the transaction is a legacy (i.e. ``type == 0``)\n     *  transaction.\n     *\n     *  This provides a Type Guard that this transaction will have\n     *  the ``null``-ness for hardfork-specific properties set correctly.\n     */\n    isLegacy() {\n        return (this.type === 0);\n    }\n    /**\n     *  Returns true if the transaction is a Berlin (i.e. ``type == 1``)\n     *  transaction. See [[link-eip-2070]].\n     *\n     *  This provides a Type Guard that this transaction will have\n     *  the ``null``-ness for hardfork-specific properties set correctly.\n     */\n    isBerlin() {\n        return (this.type === 1);\n    }\n    /**\n     *  Returns true if the transaction is a London (i.e. ``type == 2``)\n     *  transaction. See [[link-eip-1559]].\n     *\n     *  This provides a Type Guard that this transaction will have\n     *  the ``null``-ness for hardfork-specific properties set correctly.\n     */\n    isLondon() {\n        return (this.type === 2);\n    }\n    /**\n     *  Returns true if hte transaction is a Cancun (i.e. ``type == 3``)\n     *  transaction. See [[link-eip-4844]].\n     */\n    isCancun() {\n        return (this.type === 3);\n    }\n    /**\n     *  Returns a filter which can be used to listen for orphan events\n     *  that evict this transaction.\n     */\n    removedEvent() {\n        assert(this.isMined(), \"unmined transaction canot be orphaned\", \"UNSUPPORTED_OPERATION\", { operation: \"removeEvent()\" });\n        return createRemovedTransactionFilter(this);\n    }\n    /**\n     *  Returns a filter which can be used to listen for orphan events\n     *  that re-order this event against %%other%%.\n     */\n    reorderedEvent(other) {\n        assert(this.isMined(), \"unmined transaction canot be orphaned\", \"UNSUPPORTED_OPERATION\", { operation: \"removeEvent()\" });\n        assert(!other || other.isMined(), \"unmined 'other' transaction canot be orphaned\", \"UNSUPPORTED_OPERATION\", { operation: \"removeEvent()\" });\n        return createReorderedTransactionFilter(this, other);\n    }\n    /**\n     *  Returns a new TransactionResponse instance which has the ability to\n     *  detect (and throw an error) if the transaction is replaced, which\n     *  will begin scanning at %%startBlock%%.\n     *\n     *  This should generally not be used by developers and is intended\n     *  primarily for internal use. Setting an incorrect %%startBlock%% can\n     *  have devastating performance consequences if used incorrectly.\n     */\n    replaceableTransaction(startBlock) {\n        assertArgument(Number.isInteger(startBlock) && startBlock >= 0, \"invalid startBlock\", \"startBlock\", startBlock);\n        const tx = new TransactionResponse(this, this.provider);\n        tx.#startBlock = startBlock;\n        return tx;\n    }\n}\nfunction createOrphanedBlockFilter(block) {\n    return { orphan: \"drop-block\", hash: block.hash, number: block.number };\n}\nfunction createReorderedTransactionFilter(tx, other) {\n    return { orphan: \"reorder-transaction\", tx, other };\n}\nfunction createRemovedTransactionFilter(tx) {\n    return { orphan: \"drop-transaction\", tx };\n}\nfunction createRemovedLogFilter(log) {\n    return { orphan: \"drop-log\", log: {\n            transactionHash: log.transactionHash,\n            blockHash: log.blockHash,\n            blockNumber: log.blockNumber,\n            address: log.address,\n            data: log.data,\n            topics: Object.freeze(log.topics.slice()),\n            index: log.index\n        } };\n}\n//# sourceMappingURL=provider.js.map","/**\n *  Generally the [[Wallet]] and [[JsonRpcSigner]] and their sub-classes\n *  are sufficent for most developers, but this is provided to\n *  fascilitate more complex Signers.\n *\n *  @_section: api/providers/abstract-signer: Subclassing Signer [abstract-signer]\n */\nimport { resolveAddress } from \"../address/index.js\";\nimport { Transaction } from \"../transaction/index.js\";\nimport { defineProperties, getBigInt, resolveProperties, assert, assertArgument } from \"../utils/index.js\";\nimport { copyRequest } from \"./provider.js\";\nfunction checkProvider(signer, operation) {\n    if (signer.provider) {\n        return signer.provider;\n    }\n    assert(false, \"missing provider\", \"UNSUPPORTED_OPERATION\", { operation });\n}\nasync function populate(signer, tx) {\n    let pop = copyRequest(tx);\n    if (pop.to != null) {\n        pop.to = resolveAddress(pop.to, signer);\n    }\n    if (pop.from != null) {\n        const from = pop.from;\n        pop.from = Promise.all([\n            signer.getAddress(),\n            resolveAddress(from, signer)\n        ]).then(([address, from]) => {\n            assertArgument(address.toLowerCase() === from.toLowerCase(), \"transaction from mismatch\", \"tx.from\", from);\n            return address;\n        });\n    }\n    else {\n        pop.from = signer.getAddress();\n    }\n    return await resolveProperties(pop);\n}\n/**\n *  An **AbstractSigner** includes most of teh functionality required\n *  to get a [[Signer]] working as expected, but requires a few\n *  Signer-specific methods be overridden.\n *\n */\nexport class AbstractSigner {\n    /**\n     *  The provider this signer is connected to.\n     */\n    provider;\n    /**\n     *  Creates a new Signer connected to %%provider%%.\n     */\n    constructor(provider) {\n        defineProperties(this, { provider: (provider || null) });\n    }\n    async getNonce(blockTag) {\n        return checkProvider(this, \"getTransactionCount\").getTransactionCount(await this.getAddress(), blockTag);\n    }\n    async populateCall(tx) {\n        const pop = await populate(this, tx);\n        return pop;\n    }\n    async populateTransaction(tx) {\n        const provider = checkProvider(this, \"populateTransaction\");\n        const pop = await populate(this, tx);\n        if (pop.nonce == null) {\n            pop.nonce = await this.getNonce(\"pending\");\n        }\n        if (pop.gasLimit == null) {\n            pop.gasLimit = await this.estimateGas(pop);\n        }\n        // Populate the chain ID\n        const network = await (this.provider).getNetwork();\n        if (pop.chainId != null) {\n            const chainId = getBigInt(pop.chainId);\n            assertArgument(chainId === network.chainId, \"transaction chainId mismatch\", \"tx.chainId\", tx.chainId);\n        }\n        else {\n            pop.chainId = network.chainId;\n        }\n        // Do not allow mixing pre-eip-1559 and eip-1559 properties\n        const hasEip1559 = (pop.maxFeePerGas != null || pop.maxPriorityFeePerGas != null);\n        if (pop.gasPrice != null && (pop.type === 2 || hasEip1559)) {\n            assertArgument(false, \"eip-1559 transaction do not support gasPrice\", \"tx\", tx);\n        }\n        else if ((pop.type === 0 || pop.type === 1) && hasEip1559) {\n            assertArgument(false, \"pre-eip-1559 transaction do not support maxFeePerGas/maxPriorityFeePerGas\", \"tx\", tx);\n        }\n        if ((pop.type === 2 || pop.type == null) && (pop.maxFeePerGas != null && pop.maxPriorityFeePerGas != null)) {\n            // Fully-formed EIP-1559 transaction (skip getFeeData)\n            pop.type = 2;\n        }\n        else if (pop.type === 0 || pop.type === 1) {\n            // Explicit Legacy or EIP-2930 transaction\n            // We need to get fee data to determine things\n            const feeData = await provider.getFeeData();\n            assert(feeData.gasPrice != null, \"network does not support gasPrice\", \"UNSUPPORTED_OPERATION\", {\n                operation: \"getGasPrice\"\n            });\n            // Populate missing gasPrice\n            if (pop.gasPrice == null) {\n                pop.gasPrice = feeData.gasPrice;\n            }\n        }\n        else {\n            // We need to get fee data to determine things\n            const feeData = await provider.getFeeData();\n            if (pop.type == null) {\n                // We need to auto-detect the intended type of this transaction...\n                if (feeData.maxFeePerGas != null && feeData.maxPriorityFeePerGas != null) {\n                    // The network supports EIP-1559!\n                    // Upgrade transaction from null to eip-1559\n                    if (pop.authorizationList && pop.authorizationList.length) {\n                        pop.type = 4;\n                    }\n                    else {\n                        pop.type = 2;\n                    }\n                    if (pop.gasPrice != null) {\n                        // Using legacy gasPrice property on an eip-1559 network,\n                        // so use gasPrice as both fee properties\n                        const gasPrice = pop.gasPrice;\n                        delete pop.gasPrice;\n                        pop.maxFeePerGas = gasPrice;\n                        pop.maxPriorityFeePerGas = gasPrice;\n                    }\n                    else {\n                        // Populate missing fee data\n                        if (pop.maxFeePerGas == null) {\n                            pop.maxFeePerGas = feeData.maxFeePerGas;\n                        }\n                        if (pop.maxPriorityFeePerGas == null) {\n                            pop.maxPriorityFeePerGas = feeData.maxPriorityFeePerGas;\n                        }\n                    }\n                }\n                else if (feeData.gasPrice != null) {\n                    // Network doesn't support EIP-1559...\n                    // ...but they are trying to use EIP-1559 properties\n                    assert(!hasEip1559, \"network does not support EIP-1559\", \"UNSUPPORTED_OPERATION\", {\n                        operation: \"populateTransaction\"\n                    });\n                    // Populate missing fee data\n                    if (pop.gasPrice == null) {\n                        pop.gasPrice = feeData.gasPrice;\n                    }\n                    // Explicitly set untyped transaction to legacy\n                    // @TODO: Maybe this shold allow type 1?\n                    pop.type = 0;\n                }\n                else {\n                    // getFeeData has failed us.\n                    assert(false, \"failed to get consistent fee data\", \"UNSUPPORTED_OPERATION\", {\n                        operation: \"signer.getFeeData\"\n                    });\n                }\n            }\n            else if (pop.type === 2 || pop.type === 3 || pop.type === 4) {\n                // Explicitly using EIP-1559 or EIP-4844\n                // Populate missing fee data\n                if (pop.maxFeePerGas == null) {\n                    pop.maxFeePerGas = feeData.maxFeePerGas;\n                }\n                if (pop.maxPriorityFeePerGas == null) {\n                    pop.maxPriorityFeePerGas = feeData.maxPriorityFeePerGas;\n                }\n            }\n        }\n        //@TOOD: Don't await all over the place; save them up for\n        // the end for better batching\n        return await resolveProperties(pop);\n    }\n    async populateAuthorization(_auth) {\n        const auth = Object.assign({}, _auth);\n        // Add a chain ID if not explicitly set to 0\n        if (auth.chainId == null) {\n            auth.chainId = (await checkProvider(this, \"getNetwork\").getNetwork()).chainId;\n        }\n        // @TODO: Take chain ID into account when populating noce?\n        if (auth.nonce == null) {\n            auth.nonce = await this.getNonce();\n        }\n        return auth;\n    }\n    async estimateGas(tx) {\n        return checkProvider(this, \"estimateGas\").estimateGas(await this.populateCall(tx));\n    }\n    async call(tx) {\n        return checkProvider(this, \"call\").call(await this.populateCall(tx));\n    }\n    async resolveName(name) {\n        const provider = checkProvider(this, \"resolveName\");\n        return await provider.resolveName(name);\n    }\n    async sendTransaction(tx) {\n        const provider = checkProvider(this, \"sendTransaction\");\n        const pop = await this.populateTransaction(tx);\n        delete pop.from;\n        const txObj = Transaction.from(pop);\n        return await provider.broadcastTransaction(await this.signTransaction(txObj));\n    }\n    // @TODO: in v7 move this to be abstract\n    authorize(authorization) {\n        assert(false, \"authorization not implemented for this signer\", \"UNSUPPORTED_OPERATION\", { operation: \"authorize\" });\n    }\n}\n/**\n *  A **VoidSigner** is a class deisgned to allow an address to be used\n *  in any API which accepts a Signer, but for which there are no\n *  credentials available to perform any actual signing.\n *\n *  This for example allow impersonating an account for the purpose of\n *  static calls or estimating gas, but does not allow sending transactions.\n */\nexport class VoidSigner extends AbstractSigner {\n    /**\n     *  The signer address.\n     */\n    address;\n    /**\n     *  Creates a new **VoidSigner** with %%address%% attached to\n     *  %%provider%%.\n     */\n    constructor(address, provider) {\n        super(provider);\n        defineProperties(this, { address });\n    }\n    async getAddress() { return this.address; }\n    connect(provider) {\n        return new VoidSigner(this.address, provider);\n    }\n    #throwUnsupported(suffix, operation) {\n        assert(false, `VoidSigner cannot sign ${suffix}`, \"UNSUPPORTED_OPERATION\", { operation });\n    }\n    async signTransaction(tx) {\n        this.#throwUnsupported(\"transactions\", \"signTransaction\");\n    }\n    async signMessage(message) {\n        this.#throwUnsupported(\"messages\", \"signMessage\");\n    }\n    async signTypedData(domain, types, value) {\n        this.#throwUnsupported(\"typed-data\", \"signTypedData\");\n    }\n}\n//# sourceMappingURL=abstract-signer.js.map","import { getAddress, resolveAddress } from \"../address/index.js\";\nimport { hashAuthorization, hashMessage, TypedDataEncoder } from \"../hash/index.js\";\nimport { AbstractSigner, copyRequest } from \"../providers/index.js\";\nimport { computeAddress, Transaction } from \"../transaction/index.js\";\nimport { defineProperties, getBigInt, resolveProperties, assert, assertArgument } from \"../utils/index.js\";\n/**\n *  The **BaseWallet** is a stream-lined implementation of a\n *  [[Signer]] that operates with a private key.\n *\n *  It is preferred to use the [[Wallet]] class, as it offers\n *  additional functionality and simplifies loading a variety\n *  of JSON formats, Mnemonic Phrases, etc.\n *\n *  This class may be of use for those attempting to implement\n *  a minimal Signer.\n */\nexport class BaseWallet extends AbstractSigner {\n    /**\n     *  The wallet address.\n     */\n    address;\n    #signingKey;\n    /**\n     *  Creates a new BaseWallet for %%privateKey%%, optionally\n     *  connected to %%provider%%.\n     *\n     *  If %%provider%% is not specified, only offline methods can\n     *  be used.\n     */\n    constructor(privateKey, provider) {\n        super(provider);\n        assertArgument(privateKey && typeof (privateKey.sign) === \"function\", \"invalid private key\", \"privateKey\", \"[ REDACTED ]\");\n        this.#signingKey = privateKey;\n        const address = computeAddress(this.signingKey.publicKey);\n        defineProperties(this, { address });\n    }\n    // Store private values behind getters to reduce visibility\n    // in console.log\n    /**\n     *  The [[SigningKey]] used for signing payloads.\n     */\n    get signingKey() { return this.#signingKey; }\n    /**\n     *  The private key for this wallet.\n     */\n    get privateKey() { return this.signingKey.privateKey; }\n    async getAddress() { return this.address; }\n    connect(provider) {\n        return new BaseWallet(this.#signingKey, provider);\n    }\n    async signTransaction(tx) {\n        tx = copyRequest(tx);\n        // Replace any Addressable or ENS name with an address\n        const { to, from } = await resolveProperties({\n            to: (tx.to ? resolveAddress(tx.to, this) : undefined),\n            from: (tx.from ? resolveAddress(tx.from, this) : undefined)\n        });\n        if (to != null) {\n            tx.to = to;\n        }\n        if (from != null) {\n            tx.from = from;\n        }\n        if (tx.from != null) {\n            assertArgument(getAddress((tx.from)) === this.address, \"transaction from address mismatch\", \"tx.from\", tx.from);\n            delete tx.from;\n        }\n        // Build the transaction\n        const btx = Transaction.from(tx);\n        btx.signature = this.signingKey.sign(btx.unsignedHash);\n        return btx.serialized;\n    }\n    async signMessage(message) {\n        return this.signMessageSync(message);\n    }\n    // @TODO: Add a secialized signTx and signTyped sync that enforces\n    // all parameters are known?\n    /**\n     *  Returns the signature for %%message%% signed with this wallet.\n     */\n    signMessageSync(message) {\n        return this.signingKey.sign(hashMessage(message)).serialized;\n    }\n    /**\n     *  Returns the Authorization for %%auth%%.\n     */\n    authorizeSync(auth) {\n        assertArgument(typeof (auth.address) === \"string\", \"invalid address for authorizeSync\", \"auth.address\", auth);\n        const signature = this.signingKey.sign(hashAuthorization(auth));\n        return Object.assign({}, {\n            address: getAddress(auth.address),\n            nonce: getBigInt(auth.nonce || 0),\n            chainId: getBigInt(auth.chainId || 0),\n        }, { signature });\n    }\n    /**\n     *  Resolves to the Authorization for %%auth%%.\n     */\n    async authorize(auth) {\n        auth = Object.assign({}, auth, {\n            address: await resolveAddress(auth.address, this)\n        });\n        return this.authorizeSync(await this.populateAuthorization(auth));\n    }\n    async signTypedData(domain, types, value) {\n        // Populate any ENS names\n        const populated = await TypedDataEncoder.resolveNames(domain, types, value, async (name) => {\n            // @TODO: this should use resolveName; addresses don't\n            //        need a provider\n            assert(this.provider != null, \"cannot resolve ENS names without a provider\", \"UNSUPPORTED_OPERATION\", {\n                operation: \"resolveName\",\n                info: { name }\n            });\n            const address = await this.provider.resolveName(name);\n            assert(address != null, \"unconfigured ENS name\", \"UNCONFIGURED_NAME\", {\n                value: name\n            });\n            return address;\n        });\n        return this.signingKey.sign(TypedDataEncoder.hash(populated.domain, types, populated.value)).serialized;\n    }\n}\n//# sourceMappingURL=base-wallet.js.map","/**\n *  An **HMAC** enables verification that a given key was used\n *  to authenticate a payload.\n *\n *  See: [[link-wiki-hmac]]\n *\n *  @_subsection: api/crypto:HMAC  [about-hmac]\n */\nimport { createHmac } from \"./crypto.js\";\nimport { getBytes, hexlify } from \"../utils/index.js\";\nlet locked = false;\nconst _computeHmac = function (algorithm, key, data) {\n    return createHmac(algorithm, key).update(data).digest();\n};\nlet __computeHmac = _computeHmac;\n/**\n *  Return the HMAC for %%data%% using the %%key%% key with the underlying\n *  %%algo%% used for compression.\n *\n *  @example:\n *    key = id(\"some-secret\")\n *\n *    // Compute the HMAC\n *    computeHmac(\"sha256\", key, \"0x1337\")\n *    //_result:\n *\n *    // To compute the HMAC of UTF-8 data, the data must be\n *    // converted to UTF-8 bytes\n *    computeHmac(\"sha256\", key, toUtf8Bytes(\"Hello World\"))\n *    //_result:\n *\n */\nexport function computeHmac(algorithm, _key, _data) {\n    const key = getBytes(_key, \"key\");\n    const data = getBytes(_data, \"data\");\n    return hexlify(__computeHmac(algorithm, key, data));\n}\ncomputeHmac._ = _computeHmac;\ncomputeHmac.lock = function () { locked = true; };\ncomputeHmac.register = function (func) {\n    if (locked) {\n        throw new Error(\"computeHmac is locked\");\n    }\n    __computeHmac = func;\n};\nObject.freeze(computeHmac);\n//# sourceMappingURL=hmac.js.map","import { SHA2 } from './_sha2.js';\nimport { wrapConstructor } from './utils.js';\n// https://homes.esat.kuleuven.be/~bosselae/ripemd160.html\n// https://homes.esat.kuleuven.be/~bosselae/ripemd160/pdf/AB-9601/AB-9601.pdf\nconst Rho = /* @__PURE__ */ new Uint8Array([7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8]);\nconst Id = /* @__PURE__ */ Uint8Array.from({ length: 16 }, (_, i) => i);\nconst Pi = /* @__PURE__ */ Id.map((i) => (9 * i + 5) % 16);\nlet idxL = [Id];\nlet idxR = [Pi];\nfor (let i = 0; i < 4; i++)\n    for (let j of [idxL, idxR])\n        j.push(j[i].map((k) => Rho[k]));\nconst shifts = /* @__PURE__ */ [\n    [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8],\n    [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7],\n    [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9],\n    [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6],\n    [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5],\n].map((i) => new Uint8Array(i));\nconst shiftsL = /* @__PURE__ */ idxL.map((idx, i) => idx.map((j) => shifts[i][j]));\nconst shiftsR = /* @__PURE__ */ idxR.map((idx, i) => idx.map((j) => shifts[i][j]));\nconst Kl = /* @__PURE__ */ new Uint32Array([\n    0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e,\n]);\nconst Kr = /* @__PURE__ */ new Uint32Array([\n    0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000,\n]);\n// The rotate left (circular left shift) operation for uint32\nconst rotl = (word, shift) => (word << shift) | (word >>> (32 - shift));\n// It's called f() in spec.\nfunction f(group, x, y, z) {\n    if (group === 0)\n        return x ^ y ^ z;\n    else if (group === 1)\n        return (x & y) | (~x & z);\n    else if (group === 2)\n        return (x | ~y) ^ z;\n    else if (group === 3)\n        return (x & z) | (y & ~z);\n    else\n        return x ^ (y | ~z);\n}\n// Temporary buffer, not used to store anything between runs\nconst BUF = /* @__PURE__ */ new Uint32Array(16);\nexport class RIPEMD160 extends SHA2 {\n    constructor() {\n        super(64, 20, 8, true);\n        this.h0 = 0x67452301 | 0;\n        this.h1 = 0xefcdab89 | 0;\n        this.h2 = 0x98badcfe | 0;\n        this.h3 = 0x10325476 | 0;\n        this.h4 = 0xc3d2e1f0 | 0;\n    }\n    get() {\n        const { h0, h1, h2, h3, h4 } = this;\n        return [h0, h1, h2, h3, h4];\n    }\n    set(h0, h1, h2, h3, h4) {\n        this.h0 = h0 | 0;\n        this.h1 = h1 | 0;\n        this.h2 = h2 | 0;\n        this.h3 = h3 | 0;\n        this.h4 = h4 | 0;\n    }\n    process(view, offset) {\n        for (let i = 0; i < 16; i++, offset += 4)\n            BUF[i] = view.getUint32(offset, true);\n        // prettier-ignore\n        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;\n        // Instead of iterating 0 to 80, we split it into 5 groups\n        // And use the groups in constants, functions, etc. Much simpler\n        for (let group = 0; group < 5; group++) {\n            const rGroup = 4 - group;\n            const hbl = Kl[group], hbr = Kr[group]; // prettier-ignore\n            const rl = idxL[group], rr = idxR[group]; // prettier-ignore\n            const sl = shiftsL[group], sr = shiftsR[group]; // prettier-ignore\n            for (let i = 0; i < 16; i++) {\n                const tl = (rotl(al + f(group, bl, cl, dl) + BUF[rl[i]] + hbl, sl[i]) + el) | 0;\n                al = el, el = dl, dl = rotl(cl, 10) | 0, cl = bl, bl = tl; // prettier-ignore\n            }\n            // 2 loops are 10% faster\n            for (let i = 0; i < 16; i++) {\n                const tr = (rotl(ar + f(rGroup, br, cr, dr) + BUF[rr[i]] + hbr, sr[i]) + er) | 0;\n                ar = er, er = dr, dr = rotl(cr, 10) | 0, cr = br, br = tr; // prettier-ignore\n            }\n        }\n        // Add the compressed chunk to the current hash value\n        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);\n    }\n    roundClean() {\n        BUF.fill(0);\n    }\n    destroy() {\n        this.destroyed = true;\n        this.buffer.fill(0);\n        this.set(0, 0, 0, 0, 0);\n    }\n}\n/**\n * RIPEMD-160 - a hash function from 1990s.\n * @param message - msg that would be hashed\n */\nexport const ripemd160 = /* @__PURE__ */ wrapConstructor(() => new RIPEMD160());\n//# sourceMappingURL=ripemd160.js.map","import { ripemd160 as noble_ripemd160 } from \"@noble/hashes/ripemd160\";\nimport { getBytes, hexlify } from \"../utils/index.js\";\nlet locked = false;\nconst _ripemd160 = function (data) {\n    return noble_ripemd160(data);\n};\nlet __ripemd160 = _ripemd160;\n/**\n *  Compute the cryptographic RIPEMD-160 hash of %%data%%.\n *\n *  @_docloc: api/crypto:Hash Functions\n *  @returns DataHexstring\n *\n *  @example:\n *    ripemd160(\"0x\")\n *    //_result:\n *\n *    ripemd160(\"0x1337\")\n *    //_result:\n *\n *    ripemd160(new Uint8Array([ 0x13, 0x37 ]))\n *    //_result:\n *\n */\nexport function ripemd160(_data) {\n    const data = getBytes(_data, \"data\");\n    return hexlify(__ripemd160(data));\n}\nripemd160._ = _ripemd160;\nripemd160.lock = function () { locked = true; };\nripemd160.register = function (func) {\n    if (locked) {\n        throw new TypeError(\"ripemd160 is locked\");\n    }\n    __ripemd160 = func;\n};\nObject.freeze(ripemd160);\n//# sourceMappingURL=ripemd160.js.map","/**\n *  A **Cryptographically Secure Random Value** is one that has been\n *  generated with additional care take to prevent side-channels\n *  from allowing others to detect it and prevent others from through\n *  coincidence generate the same values.\n *\n *  @_subsection: api/crypto:Random Values  [about-crypto-random]\n */\nimport { randomBytes as crypto_random } from \"./crypto.js\";\nlet locked = false;\nconst _randomBytes = function (length) {\n    return new Uint8Array(crypto_random(length));\n};\nlet __randomBytes = _randomBytes;\n/**\n *  Return %%length%% bytes of cryptographically secure random data.\n *\n *  @example:\n *    randomBytes(8)\n *    //_result:\n */\nexport function randomBytes(length) {\n    return __randomBytes(length);\n}\nrandomBytes._ = _randomBytes;\nrandomBytes.lock = function () { locked = true; };\nrandomBytes.register = function (func) {\n    if (locked) {\n        throw new Error(\"randomBytes is locked\");\n    }\n    __randomBytes = func;\n};\nObject.freeze(randomBytes);\n//# sourceMappingURL=random.js.map","/**\n *  The [Base58 Encoding](link-base58) scheme allows a **numeric** value\n *  to be encoded as a compact string using a radix of 58 using only\n *  alpha-numeric characters. Confusingly similar characters are omitted\n *  (i.e. ``\"l0O\"``).\n *\n *  Note that Base58 encodes a **numeric** value, not arbitrary bytes,\n *  since any zero-bytes on the left would get removed. To mitigate this\n *  issue most schemes that use Base58 choose specific high-order values\n *  to ensure non-zero prefixes.\n *\n *  @_subsection: api/utils:Base58 Encoding [about-base58]\n */\nimport { getBytes } from \"./data.js\";\nimport { assertArgument } from \"./errors.js\";\nimport { toBigInt } from \"./maths.js\";\nconst Alphabet = \"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz\";\nlet Lookup = null;\nfunction getAlpha(letter) {\n    if (Lookup == null) {\n        Lookup = {};\n        for (let i = 0; i < Alphabet.length; i++) {\n            Lookup[Alphabet[i]] = BigInt(i);\n        }\n    }\n    const result = Lookup[letter];\n    assertArgument(result != null, `invalid base58 value`, \"letter\", letter);\n    return result;\n}\nconst BN_0 = BigInt(0);\nconst BN_58 = BigInt(58);\n/**\n *  Encode %%value%% as a Base58-encoded string.\n */\nexport function encodeBase58(_value) {\n    const bytes = getBytes(_value);\n    let value = toBigInt(bytes);\n    let result = \"\";\n    while (value) {\n        result = Alphabet[Number(value % BN_58)] + result;\n        value /= BN_58;\n    }\n    // Account for leading padding zeros\n    for (let i = 0; i < bytes.length; i++) {\n        if (bytes[i]) {\n            break;\n        }\n        result = Alphabet[0] + result;\n    }\n    return result;\n}\n/**\n *  Decode the Base58-encoded %%value%%.\n */\nexport function decodeBase58(value) {\n    let result = BN_0;\n    for (let i = 0; i < value.length; i++) {\n        result *= BN_58;\n        result += getAlpha(value[i]);\n    }\n    return result;\n}\n//# sourceMappingURL=base58.js.map","import { assertArgument } from \"../utils/index.js\";\nconst subsChrs = \" !#$%&'()*+,-./<=>?@[]^_`{|}~\";\nconst Word = /^[a-z]*$/i;\nfunction unfold(words, sep) {\n    let initial = 97;\n    return words.reduce((accum, word) => {\n        if (word === sep) {\n            initial++;\n        }\n        else if (word.match(Word)) {\n            accum.push(String.fromCharCode(initial) + word);\n        }\n        else {\n            initial = 97;\n            accum.push(word);\n        }\n        return accum;\n    }, []);\n}\n/**\n *  @_ignore\n */\nexport function decode(data, subs) {\n    // Replace all the substitutions with their expanded form\n    for (let i = subsChrs.length - 1; i >= 0; i--) {\n        data = data.split(subsChrs[i]).join(subs.substring(2 * i, 2 * i + 2));\n    }\n    // Get all tle clumps; each suffix, first-increment and second-increment\n    const clumps = [];\n    const leftover = data.replace(/(:|([0-9])|([A-Z][a-z]*))/g, (all, item, semi, word) => {\n        if (semi) {\n            for (let i = parseInt(semi); i >= 0; i--) {\n                clumps.push(\";\");\n            }\n        }\n        else {\n            clumps.push(item.toLowerCase());\n        }\n        return \"\";\n    });\n    /* c8 ignore start */\n    if (leftover) {\n        throw new Error(`leftovers: ${JSON.stringify(leftover)}`);\n    }\n    /* c8 ignore stop */\n    return unfold(unfold(clumps, \";\"), \":\");\n}\n/**\n *  @_ignore\n */\nexport function decodeOwl(data) {\n    assertArgument(data[0] === \"0\", \"unsupported auwl data\", \"data\", data);\n    return decode(data.substring(1 + 2 * subsChrs.length), data.substring(1, 1 + 2 * subsChrs.length));\n}\n//# sourceMappingURL=decode-owl.js.map","import { defineProperties } from \"../utils/index.js\";\n/**\n *  A Wordlist represents a collection of language-specific\n *  words used to encode and devoce [[link-bip-39]] encoded data\n *  by mapping words to 11-bit values and vice versa.\n */\nexport class Wordlist {\n    locale;\n    /**\n     *  Creates a new Wordlist instance.\n     *\n     *  Sub-classes MUST call this if they provide their own constructor,\n     *  passing in the locale string of the language.\n     *\n     *  Generally there is no need to create instances of a Wordlist,\n     *  since each language-specific Wordlist creates an instance and\n     *  there is no state kept internally, so they are safe to share.\n     */\n    constructor(locale) {\n        defineProperties(this, { locale });\n    }\n    /**\n     *  Sub-classes may override this to provide a language-specific\n     *  method for spliting %%phrase%% into individual words.\n     *\n     *  By default, %%phrase%% is split using any sequences of\n     *  white-space as defined by regular expressions (i.e. ``/\\s+/``).\n     */\n    split(phrase) {\n        return phrase.toLowerCase().split(/\\s+/g);\n    }\n    /**\n     *  Sub-classes may override this to provider a language-specific\n     *  method for joining %%words%% into a phrase.\n     *\n     *  By default, %%words%% are joined by a single space.\n     */\n    join(words) {\n        return words.join(\" \");\n    }\n}\n//# sourceMappingURL=wordlist.js.map","// Use the encode-latin.js script to create the necessary\n// data files to be consumed by this class\nimport { id } from \"../hash/index.js\";\nimport { assertArgument } from \"../utils/index.js\";\nimport { decodeOwl } from \"./decode-owl.js\";\nimport { Wordlist } from \"./wordlist.js\";\n/**\n *  An OWL format Wordlist is an encoding method that exploits\n *  the general locality of alphabetically sorted words to\n *  achieve a simple but effective means of compression.\n *\n *  This class is generally not useful to most developers as\n *  it is used mainly internally to keep Wordlists for languages\n *  based on ASCII-7 small.\n *\n *  If necessary, there are tools within the ``generation/`` folder\n *  to create the necessary data.\n */\nexport class WordlistOwl extends Wordlist {\n    #data;\n    #checksum;\n    /**\n     *  Creates a new Wordlist for %%locale%% using the OWL %%data%%\n     *  and validated against the %%checksum%%.\n     */\n    constructor(locale, data, checksum) {\n        super(locale);\n        this.#data = data;\n        this.#checksum = checksum;\n        this.#words = null;\n    }\n    /**\n     *  The OWL-encoded data.\n     */\n    get _data() { return this.#data; }\n    /**\n     *  Decode all the words for the wordlist.\n     */\n    _decodeWords() {\n        return decodeOwl(this.#data);\n    }\n    #words;\n    #loadWords() {\n        if (this.#words == null) {\n            const words = this._decodeWords();\n            // Verify the computed list matches the official list\n            const checksum = id(words.join(\"\\n\") + \"\\n\");\n            /* c8 ignore start */\n            if (checksum !== this.#checksum) {\n                throw new Error(`BIP39 Wordlist for ${this.locale} FAILED`);\n            }\n            /* c8 ignore stop */\n            this.#words = words;\n        }\n        return this.#words;\n    }\n    getWord(index) {\n        const words = this.#loadWords();\n        assertArgument(index >= 0 && index < words.length, `invalid word index: ${index}`, \"index\", index);\n        return words[index];\n    }\n    getWordIndex(word) {\n        return this.#loadWords().indexOf(word);\n    }\n}\n//# sourceMappingURL=wordlist-owl.js.map","import { WordlistOwl } from \"./wordlist-owl.js\";\nconst words = \"0erleonalorenseinceregesticitStanvetearctssi#ch2Athck&tneLl0And#Il.yLeOutO=S|S%b/ra@SurdU'0Ce[Cid|CountCu'Hie=IdOu,-Qui*Ro[TT]T%T*[Tu$0AptDD-tD*[Ju,M.UltV<)Vi)0Rob-0FairF%dRaid0A(EEntRee0Ead0MRRp%tS!_rmBumCoholErtI&LLeyLowMo,O}PhaReadySoT Ways0A>urAz(gOngOuntU'd0Aly,Ch%Ci|G G!GryIm$K!Noun)Nu$O` Sw T&naTiqueXietyY1ArtOlogyPe?P!Pro=Ril1ChCt-EaEnaGueMMedM%MyOundR<+Re,Ri=RowTTefa@Ti,Tw%k0KPe@SaultSetSi,SumeThma0H!>OmTa{T&dT.udeTra@0Ct]D.Gu,NtTh%ToTumn0Era+OcadoOid0AkeA*AyEsomeFulKw?d0Is:ByChel%C#D+GL<)Lc#y~MbooN<aNn RRelyRga(R*lSeS-SketTt!3A^AnAutyCau'ComeEfF%eG(Ha=H(dLie=LowLtN^Nef./TrayTt Twe&Y#d3Cyc!DKeNdOlogyRdR`Tt _{AdeAmeAnketA,EakE[IndOodO[omOu'UeUrUsh_rdAtDyIlMbNeNusOkO,Rd R(gRrowSsTtomUn)XY_{etA(AndA[A=EadEezeI{Id+IefIghtIngIskOccoliOk&OnzeOomO` OwnUsh2Bb!DdyD+tFf$oIldLbLkL!tNd!Nk Rd&Rg R,SS(e[SyTt Y Zz:Bba+B(B!CtusGeKe~LmM aMpNN$N)lNdyNn#NoeNvasNy#Pab!P.$Pta(RRb#RdRgoRpetRryRtSeShS(o/!Su$TT$ogT^Teg%yTt!UghtU'Ut]Ve3Il(gL yM|NsusNturyRe$Rta(_irAlkAmp]An+AosApt Ar+A'AtEapE{Ee'EfErryE,I{&IefIldIm}yOi)Oo'R#-U{!UnkUrn0G?Nnam#Rc!Tiz&TyVil_imApArifyAwAyE<ErkEv I{I|IffImbIn-IpO{OgO'O`OudOwnUbUmpU, Ut^_^A,C#utDeFfeeIlInL!@L%LumnMb(eMeMf%tM-Mm#Mp<yNc tNdu@NfirmNg*[N}@Nsid NtrolNv()OkOlPp PyR$ReRnR*@/Tt#U^UntryUp!Ur'Us(V Yo>_{Ad!AftAmA}AshAt AwlAzyEamEd.EekEwI{etImeIspIt-OpO[Ou^OwdUci$UelUi'Umb!Un^UshYY,$2BeLtu*PPbo?dRiousRr|Rta(R=Sh]/omTe3C!:DMa+MpN)Ng R(gShUght WnY3AlBa>BrisCadeCemb CideCl(eC%a>C*a'ErF&'F(eFyG*eLayLiv M<dMi'Ni$Nti,NyP?tP&dPos.P`PutyRi=ScribeS tSignSkSpair/royTailTe@VelopVi)Vo>3AgramAlAm#dAryCeE'lEtFf G.$Gn.yLemmaNn NosaurRe@RtSag*eScov Sea'ShSmi[S%d Splay/<)V tVideV%)Zzy5Ct%Cum|G~Lph(Ma(Na>NkeyN%OrSeUb!Ve_ftAg#AmaA,-AwEamE[IftIllInkIpI=OpUmY2CkMbNeR(g/T^Ty1Arf1Nam-:G G!RlyRnR`Sily/Sy1HoOlogyOnomy0GeItUca>1F%t0G1GhtTh 2BowD E@r-Eg<tEm|Eph<tEvat%I>Se0B?kBodyBra)Er+Ot]PloyPow Pty0Ab!A@DD![D%'EmyErgyF%)Ga+G(eH<)JoyLi,OughR-hRollSu*T Ti*TryVelope1Isode0U$Uip0AA'OdeOs]R%Upt0CapeSayS&)Ta>0Ern$H-s1Id&)IlOkeOl=1A@Amp!Ce[Ch<+C.eCludeCu'Ecu>Erci'Hau,Hib.I!I,ItOt-P<dPe@Pi*Pla(Po'P*[T&dTra0EEbrow:Br-CeCultyDeIntI`~L'MeMilyMousNNcyNtasyRmSh]TT$Th TigueUltV%.e3Atu*Bru?yD $EEdElMa!N)/iv$T^V W3B Ct]EldGu*LeLmLt N$NdNeNg NishReRmR,Sc$ShTT}[X_gAmeAshAtAv%EeIghtIpOatO{O%Ow UidUshY_mCusGIlLd~owOdOtR)Re,R+tRkRtu}RumRw?dSsil/ UndX_gi!AmeEqu|EshI&dIn+OgOntO,OwnOz&U.2ElNNnyRna)RyTu*:D+tInLaxy~ yMePRa+Rba+Rd&Rl-Rm|SSpTeTh U+Ze3N $NiusN*Nt!Nu(e/u*2O,0AntFtGg!Ng RaffeRlVe_dAn)A*A[IdeImp'ObeOomOryO=OwUe_tDde[LdOdO'RillaSpelSsipV nWn_bA)A(AntApeA[Av.yEatE&IdIefItOc yOupOwUnt_rdE[IdeIltIt?N3M:B.IrLfMm M, NdPpyRb%RdRshR=,TVeWkZ?d3AdAl`ArtAvyD+hogIght~oLmetLpNRo3Dd&Gh~NtPRe/%y5BbyCkeyLdLeLiday~owMeNeyOdPeRnRr%R'Sp.$/TelUrV 5BGeM<Mb!M%Nd*dNgryNtRd!RryRtSb<d3Brid:1EOn0EaEntifyLe2N%e4LLeg$L}[0A+Ita>M&'Mu}Pa@Po'Pro=Pul'0ChCludeComeC*a'DexD-a>Do%Du,ryF<tFl-tF%mHa!H .Iti$Je@JuryMa>N Noc|PutQuiryS<eSe@SideSpi*/$lTa@T e,ToVe,V.eVol=3On0L<dOla>Sue0Em1Ory:CketGu?RZz3AlousAns~yWel9BInKeUr}yY5D+I)MpNg!Ni%Nk/:Ng?oo3EnEpT^upY3CkDD}yNdNgdomSsTT^&TeTt&Wi4EeIfeO{Ow:BBelB%Dd DyKeMpNgua+PtopR+T T(UghUndryVaWWnWsu.Y Zy3Ad AfArnA=Ctu*FtGG$G&dIsu*M#NdNg`NsOp?dSs#Tt Vel3ArB tyBr?yC&'FeFtGhtKeMbM.NkOnQuid/Tt!VeZ?d5AdAnB, C$CkG-NelyNgOpTt yUdUn+VeY$5CkyGga+Mb N?N^Xury3R-s:Ch(eDG-G}tIdIlInJ%KeMm$NNa+Nda>NgoNs]Nu$P!Rb!R^Rg(R(eRketRria+SkSs/ T^T i$ThTrixTt XimumZe3AdowAnAsu*AtCh<-D$DiaLodyLtMb M%yNt]NuRcyR+R.RryShSsa+T$Thod3Dd!DnightLk~]M-NdNimumN%Nu>Rac!Rr%S ySs/akeXXedXtu*5Bi!DelDifyMM|N.%NkeyN, N`OnR$ReRn(gSqu.oTh T]T%Unta(U'VeVie5ChFf(LeLtiplySc!SeumShroomS-/Tu$3Self/ yTh:I=MePk(Rrow/yT]Tu*3ArCkEdGati=G!@I` PhewR=/TTw%kUtr$V WsXt3CeGht5B!I'M(eeOd!Rm$R`SeTab!TeTh(gTi)VelW5C!?Mb R'T:K0EyJe@Li+Scu*S =Ta(Vious0CurE<Tob 0Or1FF Fi)T&2L1Ay0DI=Ymp-0It0CeEI#L(eLy1EnEraIn]Po'T]1An+B.Ch?dD D(?yG<I|Ig($Ph<0Tr-h0H 0Tdo%T TputTside0AlEnEr0NN 0Yg&0/ 0O}:CtDd!GeIrLa)LmNdaNelN-N` P RadeR|RkRrotRtySsT^ThTi|TrolTt nU'VeYm|3A)AnutArAs<tL-<NN$tyNcilOp!Pp Rfe@Rm.Rs#T2O}OtoRa'Ys-$0AnoCn-Ctu*E)GGe#~LotNkO} Pe/olT^Zza_)A}tA,-A>AyEa'Ed+U{UgUn+2EmEtIntL?LeLi)NdNyOlPul?Rt]S.]Ssib!/TatoTt yV tyWd W _@i)Ai'Ed-tEf Epa*Es|EttyEv|I)IdeIm?yIntI%.yIs#Iva>IzeOb!mO)[Odu)Of.OgramOje@Omo>OofOp tyOsp O>@OudOvide2Bl-Dd(g~LpL'Mpk(N^PilPpyR^a'R.yRpo'R'ShTZz!3Ramid:99Al.yAntumArt E,]I{ItIzO>:Bb.Cco#CeCkD?DioIlInI'~yMpN^NdomN+PidReTeTh V&WZ%3AdyAlAs#BelBuildC$lCei=CipeC%dCyc!Du)F!@F%mFu'G]G*tGul?Je@LaxLea'LiefLyMa(Memb M(dMo=Nd NewNtOp&PairPeatPla)P%tQui*ScueSemb!Si,Sour)Sp#'SultTi*T*atTurnUn]Ve$ViewW?d2Y`m0BBb#CeChDeD+F!GhtGidNgOtPp!SkTu$V$V 5AdA,BotBu,CketM<)OfOkieOmSeTa>UghUndU>Y$5Bb DeGLeNNwayR$:DDd!D}[FeIlLadLm#L#LtLu>MeMp!NdTisfyToshiU)Usa+VeY1A!AnA*Att E}HemeHoolI&)I[%sOrp]OutRapRe&RiptRub1AAr^As#AtC#dC*tCt]Cur.yEdEkGm|Le@~M(?Ni%N'Nt&)RiesRvi)Ss]Tt!TupV&_dowAftAllowA*EdEllEriffIeldIftI}IpIv O{OeOotOpOrtOuld O=RimpRugUff!Y0Bl(gCkDeE+GhtGnL|Lk~yLv Mil?Mp!N)NgR&/ Tua>XZe1A>Et^IIllInIrtUll0AbAmEepEnd I)IdeIghtImOg<OtOwUsh0AllArtI!OkeOo`0A{AkeApIffOw0ApCc Ci$CkDaFtL?Ldi LidLut]L=Me#eNgOnRryRtUlUndUpUr)U`0A)A*Ati$AwnEakEci$EedEllEndH eI)Id IkeInIr.L.OilOns%O#OrtOtRayReadR(gY0Ua*UeezeUir*l_b!AdiumAffA+AirsAmpAndArtA>AyEakEelEmEpE*oI{IllIngO{Oma^O}OolOryO=Ra>gyReetRikeR#gRugg!Ud|UffUmb!Y!0Bje@Bm.BwayC)[ChDd&Ff G?G+,ItMm NNnyN'tP PplyP*meReRfa)R+Rpri'RroundR=ySpe@/a(1AllowAmpApArmE?EetIftImIngIt^Ord1MbolMptomRup/em:B!Ck!GIlL|LkNkPeR+tSk/eTtooXi3A^Am~NN<tNnisNtRm/Xt_nkAtEmeEnE%yE*EyIngIsOughtReeRi=RowUmbUnd 0CketDeG LtMb MeNyPRedSsueT!5A,BaccoDayDdl EGe` I!tK&MatoM%rowNeNgueNightOlO`PP-Pp!R^RnadoRtoi'SsT$Uri,W?dW WnY_{AdeAff-Ag-A(Ansf ApAshA=lAyEatEeEndI$IbeI{Igg ImIpOphyOub!U{UeUlyUmpetU,U`Y2BeIt]Mb!NaN}lRkeyRnRt!1El=EntyI)InI,O1PeP-$:5Ly5B*lla0Ab!Awa*C!Cov D DoFairFoldHappyIf%mIqueItIv 'KnownLo{TilUsu$Veil1Da>GradeHoldOnP Set1B<Ge0A+EEdEfulE![U$0Il.y:C<tCuumGueLidL!yL=NNishP%Rious/Ult3H-!L=tNd%Ntu*NueRbRifyRs]RyS'lT <3Ab!Br<tCiousCt%yDeoEw~a+Nta+Ol(Rtu$RusSaS.Su$T$Vid5C$I)IdLc<oLumeTeYa+:GeG#ItLk~LnutNtRfa*RmRri%ShSp/eT VeY3Al`Ap#ArA'lA` BDd(gEk&dIrdLcome/T_!AtEatEelEnE*IpIsp 0DeD`FeLd~NNdowNeNgNkNn Nt ReSdomSeShT}[5LfM<Nd OdOlRdRkRldRryR`_pE{E,!I,I>Ong::Rd3Ar~ow9UUngU`:3BraRo9NeO\";\nconst checksum = \"0x3c8acc1e7b08d8e76f9fda015ef48dc8c710a73cb7e0f77b2c18a9b5a7adde60\";\nlet wordlist = null;\n/**\n *  The [[link-bip39-en]] for [mnemonic phrases](link-bip-39).\n *\n *  @_docloc: api/wordlists\n */\nexport class LangEn extends WordlistOwl {\n    /**\n     *  Creates a new instance of the English language Wordlist.\n     *\n     *  This should be unnecessary most of the time as the exported\n     *  [[langEn]] should suffice.\n     *\n     *  @_ignore:\n     */\n    constructor() { super(\"en\", words, checksum); }\n    /**\n     *  Returns a singleton instance of a ``LangEn``, creating it\n     *  if this is the first time being called.\n     */\n    static wordlist() {\n        if (wordlist == null) {\n            wordlist = new LangEn();\n        }\n        return wordlist;\n    }\n}\n//# sourceMappingURL=lang-en.js.map","/**\n *  A **Password-Based Key-Derivation Function** is designed to create\n *  a sequence of bytes suitible as a **key** from a human-rememberable\n *  password.\n *\n *  @_subsection: api/crypto:Passwords  [about-pbkdf]\n */\nimport { pbkdf2Sync } from \"./crypto.js\";\nimport { getBytes, hexlify } from \"../utils/index.js\";\nlet locked = false;\nconst _pbkdf2 = function (password, salt, iterations, keylen, algo) {\n    return pbkdf2Sync(password, salt, iterations, keylen, algo);\n};\nlet __pbkdf2 = _pbkdf2;\n/**\n *  Return the [[link-pbkdf2]] for %%keylen%% bytes for %%password%% using\n *  the %%salt%% and using %%iterations%% of %%algo%%.\n *\n *  This PBKDF is outdated and should not be used in new projects, but is\n *  required to decrypt older files.\n *\n *  @example:\n *    // The password must be converted to bytes, and it is generally\n *    // best practices to ensure the string has been normalized. Many\n *    // formats explicitly indicate the normalization form to use.\n *    password = \"hello\"\n *    passwordBytes = toUtf8Bytes(password, \"NFKC\")\n *\n *    salt = id(\"some-salt\")\n *\n *    // Compute the PBKDF2\n *    pbkdf2(passwordBytes, salt, 1024, 16, \"sha256\")\n *    //_result:\n */\nexport function pbkdf2(_password, _salt, iterations, keylen, algo) {\n    const password = getBytes(_password, \"password\");\n    const salt = getBytes(_salt, \"salt\");\n    return hexlify(__pbkdf2(password, salt, iterations, keylen, algo));\n}\npbkdf2._ = _pbkdf2;\npbkdf2.lock = function () { locked = true; };\npbkdf2.register = function (func) {\n    if (locked) {\n        throw new Error(\"pbkdf2 is locked\");\n    }\n    __pbkdf2 = func;\n};\nObject.freeze(pbkdf2);\n//# sourceMappingURL=pbkdf2.js.map","import { pbkdf2, sha256 } from \"../crypto/index.js\";\nimport { defineProperties, getBytes, hexlify, assertNormalize, assertPrivate, assertArgument, toUtf8Bytes } from \"../utils/index.js\";\nimport { LangEn } from \"../wordlists/lang-en.js\";\n// Returns a byte with the MSB bits set\nfunction getUpperMask(bits) {\n    return ((1 << bits) - 1) << (8 - bits) & 0xff;\n}\n// Returns a byte with the LSB bits set\nfunction getLowerMask(bits) {\n    return ((1 << bits) - 1) & 0xff;\n}\nfunction mnemonicToEntropy(mnemonic, wordlist) {\n    assertNormalize(\"NFKD\");\n    if (wordlist == null) {\n        wordlist = LangEn.wordlist();\n    }\n    const words = wordlist.split(mnemonic);\n    assertArgument((words.length % 3) === 0 && words.length >= 12 && words.length <= 24, \"invalid mnemonic length\", \"mnemonic\", \"[ REDACTED ]\");\n    const entropy = new Uint8Array(Math.ceil(11 * words.length / 8));\n    let offset = 0;\n    for (let i = 0; i < words.length; i++) {\n        let index = wordlist.getWordIndex(words[i].normalize(\"NFKD\"));\n        assertArgument(index >= 0, `invalid mnemonic word at index ${i}`, \"mnemonic\", \"[ REDACTED ]\");\n        for (let bit = 0; bit < 11; bit++) {\n            if (index & (1 << (10 - bit))) {\n                entropy[offset >> 3] |= (1 << (7 - (offset % 8)));\n            }\n            offset++;\n        }\n    }\n    const entropyBits = 32 * words.length / 3;\n    const checksumBits = words.length / 3;\n    const checksumMask = getUpperMask(checksumBits);\n    const checksum = getBytes(sha256(entropy.slice(0, entropyBits / 8)))[0] & checksumMask;\n    assertArgument(checksum === (entropy[entropy.length - 1] & checksumMask), \"invalid mnemonic checksum\", \"mnemonic\", \"[ REDACTED ]\");\n    return hexlify(entropy.slice(0, entropyBits / 8));\n}\nfunction entropyToMnemonic(entropy, wordlist) {\n    assertArgument((entropy.length % 4) === 0 && entropy.length >= 16 && entropy.length <= 32, \"invalid entropy size\", \"entropy\", \"[ REDACTED ]\");\n    if (wordlist == null) {\n        wordlist = LangEn.wordlist();\n    }\n    const indices = [0];\n    let remainingBits = 11;\n    for (let i = 0; i < entropy.length; i++) {\n        // Consume the whole byte (with still more to go)\n        if (remainingBits > 8) {\n            indices[indices.length - 1] <<= 8;\n            indices[indices.length - 1] |= entropy[i];\n            remainingBits -= 8;\n            // This byte will complete an 11-bit index\n        }\n        else {\n            indices[indices.length - 1] <<= remainingBits;\n            indices[indices.length - 1] |= entropy[i] >> (8 - remainingBits);\n            // Start the next word\n            indices.push(entropy[i] & getLowerMask(8 - remainingBits));\n            remainingBits += 3;\n        }\n    }\n    // Compute the checksum bits\n    const checksumBits = entropy.length / 4;\n    const checksum = parseInt(sha256(entropy).substring(2, 4), 16) & getUpperMask(checksumBits);\n    // Shift the checksum into the word indices\n    indices[indices.length - 1] <<= checksumBits;\n    indices[indices.length - 1] |= (checksum >> (8 - checksumBits));\n    return wordlist.join(indices.map((index) => wordlist.getWord(index)));\n}\nconst _guard = {};\n/**\n *  A **Mnemonic** wraps all properties required to compute [[link-bip-39]]\n *  seeds and convert between phrases and entropy.\n */\nexport class Mnemonic {\n    /**\n     *  The mnemonic phrase of 12, 15, 18, 21 or 24 words.\n     *\n     *  Use the [[wordlist]] ``split`` method to get the individual words.\n     */\n    phrase;\n    /**\n     *  The password used for this mnemonic. If no password is used this\n     *  is the empty string (i.e. ``\"\"``) as per the specification.\n     */\n    password;\n    /**\n     *  The wordlist for this mnemonic.\n     */\n    wordlist;\n    /**\n     *  The underlying entropy which the mnemonic encodes.\n     */\n    entropy;\n    /**\n     *  @private\n     */\n    constructor(guard, entropy, phrase, password, wordlist) {\n        if (password == null) {\n            password = \"\";\n        }\n        if (wordlist == null) {\n            wordlist = LangEn.wordlist();\n        }\n        assertPrivate(guard, _guard, \"Mnemonic\");\n        defineProperties(this, { phrase, password, wordlist, entropy });\n    }\n    /**\n     *  Returns the seed for the mnemonic.\n     */\n    computeSeed() {\n        const salt = toUtf8Bytes(\"mnemonic\" + this.password, \"NFKD\");\n        return pbkdf2(toUtf8Bytes(this.phrase, \"NFKD\"), salt, 2048, 64, \"sha512\");\n    }\n    /**\n     *  Creates a new Mnemonic for the %%phrase%%.\n     *\n     *  The default %%password%% is the empty string and the default\n     *  wordlist is the [English wordlists](LangEn).\n     */\n    static fromPhrase(phrase, password, wordlist) {\n        // Normalize the case and space; throws if invalid\n        const entropy = mnemonicToEntropy(phrase, wordlist);\n        phrase = entropyToMnemonic(getBytes(entropy), wordlist);\n        return new Mnemonic(_guard, entropy, phrase, password, wordlist);\n    }\n    /**\n     *  Create a new **Mnemonic** from the %%entropy%%.\n     *\n     *  The default %%password%% is the empty string and the default\n     *  wordlist is the [English wordlists](LangEn).\n     */\n    static fromEntropy(_entropy, password, wordlist) {\n        const entropy = getBytes(_entropy, \"entropy\");\n        const phrase = entropyToMnemonic(entropy, wordlist);\n        return new Mnemonic(_guard, hexlify(entropy), phrase, password, wordlist);\n    }\n    /**\n     *  Returns the phrase for %%mnemonic%%.\n     */\n    static entropyToPhrase(_entropy, wordlist) {\n        const entropy = getBytes(_entropy, \"entropy\");\n        return entropyToMnemonic(entropy, wordlist);\n    }\n    /**\n     *  Returns the entropy for %%phrase%%.\n     */\n    static phraseToEntropy(phrase, wordlist) {\n        return mnemonicToEntropy(phrase, wordlist);\n    }\n    /**\n     *  Returns true if %%phrase%% is a valid [[link-bip-39]] phrase.\n     *\n     *  This checks all the provided words belong to the %%wordlist%%,\n     *  that the length is valid and the checksum is correct.\n     */\n    static isValidMnemonic(phrase, wordlist) {\n        try {\n            mnemonicToEntropy(phrase, wordlist);\n            return true;\n        }\n        catch (error) { }\n        return false;\n    }\n}\n//# sourceMappingURL=mnemonic.js.map","/*! MIT License. Copyright 2015-2022 Richard Moore <me@ricmoo.com>. See LICENSE.txt. */\nvar __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar _AES_key, _AES_Kd, _AES_Ke;\n// Number of rounds by keysize\nconst numberOfRounds = { 16: 10, 24: 12, 32: 14 };\n// Round constant words\nconst rcon = [0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91];\n// S-box and Inverse S-box (S is for Substitution)\nconst S = [0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76, 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75, 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8, 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb, 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a, 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16];\nconst Si = [0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb, 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e, 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25, 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92, 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84, 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06, 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73, 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e, 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4, 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f, 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61, 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d];\n// Transformations for encryption\nconst T1 = [0xc66363a5, 0xf87c7c84, 0xee777799, 0xf67b7b8d, 0xfff2f20d, 0xd66b6bbd, 0xde6f6fb1, 0x91c5c554, 0x60303050, 0x02010103, 0xce6767a9, 0x562b2b7d, 0xe7fefe19, 0xb5d7d762, 0x4dababe6, 0xec76769a, 0x8fcaca45, 0x1f82829d, 0x89c9c940, 0xfa7d7d87, 0xeffafa15, 0xb25959eb, 0x8e4747c9, 0xfbf0f00b, 0x41adadec, 0xb3d4d467, 0x5fa2a2fd, 0x45afafea, 0x239c9cbf, 0x53a4a4f7, 0xe4727296, 0x9bc0c05b, 0x75b7b7c2, 0xe1fdfd1c, 0x3d9393ae, 0x4c26266a, 0x6c36365a, 0x7e3f3f41, 0xf5f7f702, 0x83cccc4f, 0x6834345c, 0x51a5a5f4, 0xd1e5e534, 0xf9f1f108, 0xe2717193, 0xabd8d873, 0x62313153, 0x2a15153f, 0x0804040c, 0x95c7c752, 0x46232365, 0x9dc3c35e, 0x30181828, 0x379696a1, 0x0a05050f, 0x2f9a9ab5, 0x0e070709, 0x24121236, 0x1b80809b, 0xdfe2e23d, 0xcdebeb26, 0x4e272769, 0x7fb2b2cd, 0xea75759f, 0x1209091b, 0x1d83839e, 0x582c2c74, 0x341a1a2e, 0x361b1b2d, 0xdc6e6eb2, 0xb45a5aee, 0x5ba0a0fb, 0xa45252f6, 0x763b3b4d, 0xb7d6d661, 0x7db3b3ce, 0x5229297b, 0xdde3e33e, 0x5e2f2f71, 0x13848497, 0xa65353f5, 0xb9d1d168, 0x00000000, 0xc1eded2c, 0x40202060, 0xe3fcfc1f, 0x79b1b1c8, 0xb65b5bed, 0xd46a6abe, 0x8dcbcb46, 0x67bebed9, 0x7239394b, 0x944a4ade, 0x984c4cd4, 0xb05858e8, 0x85cfcf4a, 0xbbd0d06b, 0xc5efef2a, 0x4faaaae5, 0xedfbfb16, 0x864343c5, 0x9a4d4dd7, 0x66333355, 0x11858594, 0x8a4545cf, 0xe9f9f910, 0x04020206, 0xfe7f7f81, 0xa05050f0, 0x783c3c44, 0x259f9fba, 0x4ba8a8e3, 0xa25151f3, 0x5da3a3fe, 0x804040c0, 0x058f8f8a, 0x3f9292ad, 0x219d9dbc, 0x70383848, 0xf1f5f504, 0x63bcbcdf, 0x77b6b6c1, 0xafdada75, 0x42212163, 0x20101030, 0xe5ffff1a, 0xfdf3f30e, 0xbfd2d26d, 0x81cdcd4c, 0x180c0c14, 0x26131335, 0xc3ecec2f, 0xbe5f5fe1, 0x359797a2, 0x884444cc, 0x2e171739, 0x93c4c457, 0x55a7a7f2, 0xfc7e7e82, 0x7a3d3d47, 0xc86464ac, 0xba5d5de7, 0x3219192b, 0xe6737395, 0xc06060a0, 0x19818198, 0x9e4f4fd1, 0xa3dcdc7f, 0x44222266, 0x542a2a7e, 0x3b9090ab, 0x0b888883, 0x8c4646ca, 0xc7eeee29, 0x6bb8b8d3, 0x2814143c, 0xa7dede79, 0xbc5e5ee2, 0x160b0b1d, 0xaddbdb76, 0xdbe0e03b, 0x64323256, 0x743a3a4e, 0x140a0a1e, 0x924949db, 0x0c06060a, 0x4824246c, 0xb85c5ce4, 0x9fc2c25d, 0xbdd3d36e, 0x43acacef, 0xc46262a6, 0x399191a8, 0x319595a4, 0xd3e4e437, 0xf279798b, 0xd5e7e732, 0x8bc8c843, 0x6e373759, 0xda6d6db7, 0x018d8d8c, 0xb1d5d564, 0x9c4e4ed2, 0x49a9a9e0, 0xd86c6cb4, 0xac5656fa, 0xf3f4f407, 0xcfeaea25, 0xca6565af, 0xf47a7a8e, 0x47aeaee9, 0x10080818, 0x6fbabad5, 0xf0787888, 0x4a25256f, 0x5c2e2e72, 0x381c1c24, 0x57a6a6f1, 0x73b4b4c7, 0x97c6c651, 0xcbe8e823, 0xa1dddd7c, 0xe874749c, 0x3e1f1f21, 0x964b4bdd, 0x61bdbddc, 0x0d8b8b86, 0x0f8a8a85, 0xe0707090, 0x7c3e3e42, 0x71b5b5c4, 0xcc6666aa, 0x904848d8, 0x06030305, 0xf7f6f601, 0x1c0e0e12, 0xc26161a3, 0x6a35355f, 0xae5757f9, 0x69b9b9d0, 0x17868691, 0x99c1c158, 0x3a1d1d27, 0x279e9eb9, 0xd9e1e138, 0xebf8f813, 0x2b9898b3, 0x22111133, 0xd26969bb, 0xa9d9d970, 0x078e8e89, 0x339494a7, 0x2d9b9bb6, 0x3c1e1e22, 0x15878792, 0xc9e9e920, 0x87cece49, 0xaa5555ff, 0x50282878, 0xa5dfdf7a, 0x038c8c8f, 0x59a1a1f8, 0x09898980, 0x1a0d0d17, 0x65bfbfda, 0xd7e6e631, 0x844242c6, 0xd06868b8, 0x824141c3, 0x299999b0, 0x5a2d2d77, 0x1e0f0f11, 0x7bb0b0cb, 0xa85454fc, 0x6dbbbbd6, 0x2c16163a];\nconst T2 = [0xa5c66363, 0x84f87c7c, 0x99ee7777, 0x8df67b7b, 0x0dfff2f2, 0xbdd66b6b, 0xb1de6f6f, 0x5491c5c5, 0x50603030, 0x03020101, 0xa9ce6767, 0x7d562b2b, 0x19e7fefe, 0x62b5d7d7, 0xe64dabab, 0x9aec7676, 0x458fcaca, 0x9d1f8282, 0x4089c9c9, 0x87fa7d7d, 0x15effafa, 0xebb25959, 0xc98e4747, 0x0bfbf0f0, 0xec41adad, 0x67b3d4d4, 0xfd5fa2a2, 0xea45afaf, 0xbf239c9c, 0xf753a4a4, 0x96e47272, 0x5b9bc0c0, 0xc275b7b7, 0x1ce1fdfd, 0xae3d9393, 0x6a4c2626, 0x5a6c3636, 0x417e3f3f, 0x02f5f7f7, 0x4f83cccc, 0x5c683434, 0xf451a5a5, 0x34d1e5e5, 0x08f9f1f1, 0x93e27171, 0x73abd8d8, 0x53623131, 0x3f2a1515, 0x0c080404, 0x5295c7c7, 0x65462323, 0x5e9dc3c3, 0x28301818, 0xa1379696, 0x0f0a0505, 0xb52f9a9a, 0x090e0707, 0x36241212, 0x9b1b8080, 0x3ddfe2e2, 0x26cdebeb, 0x694e2727, 0xcd7fb2b2, 0x9fea7575, 0x1b120909, 0x9e1d8383, 0x74582c2c, 0x2e341a1a, 0x2d361b1b, 0xb2dc6e6e, 0xeeb45a5a, 0xfb5ba0a0, 0xf6a45252, 0x4d763b3b, 0x61b7d6d6, 0xce7db3b3, 0x7b522929, 0x3edde3e3, 0x715e2f2f, 0x97138484, 0xf5a65353, 0x68b9d1d1, 0x00000000, 0x2cc1eded, 0x60402020, 0x1fe3fcfc, 0xc879b1b1, 0xedb65b5b, 0xbed46a6a, 0x468dcbcb, 0xd967bebe, 0x4b723939, 0xde944a4a, 0xd4984c4c, 0xe8b05858, 0x4a85cfcf, 0x6bbbd0d0, 0x2ac5efef, 0xe54faaaa, 0x16edfbfb, 0xc5864343, 0xd79a4d4d, 0x55663333, 0x94118585, 0xcf8a4545, 0x10e9f9f9, 0x06040202, 0x81fe7f7f, 0xf0a05050, 0x44783c3c, 0xba259f9f, 0xe34ba8a8, 0xf3a25151, 0xfe5da3a3, 0xc0804040, 0x8a058f8f, 0xad3f9292, 0xbc219d9d, 0x48703838, 0x04f1f5f5, 0xdf63bcbc, 0xc177b6b6, 0x75afdada, 0x63422121, 0x30201010, 0x1ae5ffff, 0x0efdf3f3, 0x6dbfd2d2, 0x4c81cdcd, 0x14180c0c, 0x35261313, 0x2fc3ecec, 0xe1be5f5f, 0xa2359797, 0xcc884444, 0x392e1717, 0x5793c4c4, 0xf255a7a7, 0x82fc7e7e, 0x477a3d3d, 0xacc86464, 0xe7ba5d5d, 0x2b321919, 0x95e67373, 0xa0c06060, 0x98198181, 0xd19e4f4f, 0x7fa3dcdc, 0x66442222, 0x7e542a2a, 0xab3b9090, 0x830b8888, 0xca8c4646, 0x29c7eeee, 0xd36bb8b8, 0x3c281414, 0x79a7dede, 0xe2bc5e5e, 0x1d160b0b, 0x76addbdb, 0x3bdbe0e0, 0x56643232, 0x4e743a3a, 0x1e140a0a, 0xdb924949, 0x0a0c0606, 0x6c482424, 0xe4b85c5c, 0x5d9fc2c2, 0x6ebdd3d3, 0xef43acac, 0xa6c46262, 0xa8399191, 0xa4319595, 0x37d3e4e4, 0x8bf27979, 0x32d5e7e7, 0x438bc8c8, 0x596e3737, 0xb7da6d6d, 0x8c018d8d, 0x64b1d5d5, 0xd29c4e4e, 0xe049a9a9, 0xb4d86c6c, 0xfaac5656, 0x07f3f4f4, 0x25cfeaea, 0xafca6565, 0x8ef47a7a, 0xe947aeae, 0x18100808, 0xd56fbaba, 0x88f07878, 0x6f4a2525, 0x725c2e2e, 0x24381c1c, 0xf157a6a6, 0xc773b4b4, 0x5197c6c6, 0x23cbe8e8, 0x7ca1dddd, 0x9ce87474, 0x213e1f1f, 0xdd964b4b, 0xdc61bdbd, 0x860d8b8b, 0x850f8a8a, 0x90e07070, 0x427c3e3e, 0xc471b5b5, 0xaacc6666, 0xd8904848, 0x05060303, 0x01f7f6f6, 0x121c0e0e, 0xa3c26161, 0x5f6a3535, 0xf9ae5757, 0xd069b9b9, 0x91178686, 0x5899c1c1, 0x273a1d1d, 0xb9279e9e, 0x38d9e1e1, 0x13ebf8f8, 0xb32b9898, 0x33221111, 0xbbd26969, 0x70a9d9d9, 0x89078e8e, 0xa7339494, 0xb62d9b9b, 0x223c1e1e, 0x92158787, 0x20c9e9e9, 0x4987cece, 0xffaa5555, 0x78502828, 0x7aa5dfdf, 0x8f038c8c, 0xf859a1a1, 0x80098989, 0x171a0d0d, 0xda65bfbf, 0x31d7e6e6, 0xc6844242, 0xb8d06868, 0xc3824141, 0xb0299999, 0x775a2d2d, 0x111e0f0f, 0xcb7bb0b0, 0xfca85454, 0xd66dbbbb, 0x3a2c1616];\nconst T3 = [0x63a5c663, 0x7c84f87c, 0x7799ee77, 0x7b8df67b, 0xf20dfff2, 0x6bbdd66b, 0x6fb1de6f, 0xc55491c5, 0x30506030, 0x01030201, 0x67a9ce67, 0x2b7d562b, 0xfe19e7fe, 0xd762b5d7, 0xabe64dab, 0x769aec76, 0xca458fca, 0x829d1f82, 0xc94089c9, 0x7d87fa7d, 0xfa15effa, 0x59ebb259, 0x47c98e47, 0xf00bfbf0, 0xadec41ad, 0xd467b3d4, 0xa2fd5fa2, 0xafea45af, 0x9cbf239c, 0xa4f753a4, 0x7296e472, 0xc05b9bc0, 0xb7c275b7, 0xfd1ce1fd, 0x93ae3d93, 0x266a4c26, 0x365a6c36, 0x3f417e3f, 0xf702f5f7, 0xcc4f83cc, 0x345c6834, 0xa5f451a5, 0xe534d1e5, 0xf108f9f1, 0x7193e271, 0xd873abd8, 0x31536231, 0x153f2a15, 0x040c0804, 0xc75295c7, 0x23654623, 0xc35e9dc3, 0x18283018, 0x96a13796, 0x050f0a05, 0x9ab52f9a, 0x07090e07, 0x12362412, 0x809b1b80, 0xe23ddfe2, 0xeb26cdeb, 0x27694e27, 0xb2cd7fb2, 0x759fea75, 0x091b1209, 0x839e1d83, 0x2c74582c, 0x1a2e341a, 0x1b2d361b, 0x6eb2dc6e, 0x5aeeb45a, 0xa0fb5ba0, 0x52f6a452, 0x3b4d763b, 0xd661b7d6, 0xb3ce7db3, 0x297b5229, 0xe33edde3, 0x2f715e2f, 0x84971384, 0x53f5a653, 0xd168b9d1, 0x00000000, 0xed2cc1ed, 0x20604020, 0xfc1fe3fc, 0xb1c879b1, 0x5bedb65b, 0x6abed46a, 0xcb468dcb, 0xbed967be, 0x394b7239, 0x4ade944a, 0x4cd4984c, 0x58e8b058, 0xcf4a85cf, 0xd06bbbd0, 0xef2ac5ef, 0xaae54faa, 0xfb16edfb, 0x43c58643, 0x4dd79a4d, 0x33556633, 0x85941185, 0x45cf8a45, 0xf910e9f9, 0x02060402, 0x7f81fe7f, 0x50f0a050, 0x3c44783c, 0x9fba259f, 0xa8e34ba8, 0x51f3a251, 0xa3fe5da3, 0x40c08040, 0x8f8a058f, 0x92ad3f92, 0x9dbc219d, 0x38487038, 0xf504f1f5, 0xbcdf63bc, 0xb6c177b6, 0xda75afda, 0x21634221, 0x10302010, 0xff1ae5ff, 0xf30efdf3, 0xd26dbfd2, 0xcd4c81cd, 0x0c14180c, 0x13352613, 0xec2fc3ec, 0x5fe1be5f, 0x97a23597, 0x44cc8844, 0x17392e17, 0xc45793c4, 0xa7f255a7, 0x7e82fc7e, 0x3d477a3d, 0x64acc864, 0x5de7ba5d, 0x192b3219, 0x7395e673, 0x60a0c060, 0x81981981, 0x4fd19e4f, 0xdc7fa3dc, 0x22664422, 0x2a7e542a, 0x90ab3b90, 0x88830b88, 0x46ca8c46, 0xee29c7ee, 0xb8d36bb8, 0x143c2814, 0xde79a7de, 0x5ee2bc5e, 0x0b1d160b, 0xdb76addb, 0xe03bdbe0, 0x32566432, 0x3a4e743a, 0x0a1e140a, 0x49db9249, 0x060a0c06, 0x246c4824, 0x5ce4b85c, 0xc25d9fc2, 0xd36ebdd3, 0xacef43ac, 0x62a6c462, 0x91a83991, 0x95a43195, 0xe437d3e4, 0x798bf279, 0xe732d5e7, 0xc8438bc8, 0x37596e37, 0x6db7da6d, 0x8d8c018d, 0xd564b1d5, 0x4ed29c4e, 0xa9e049a9, 0x6cb4d86c, 0x56faac56, 0xf407f3f4, 0xea25cfea, 0x65afca65, 0x7a8ef47a, 0xaee947ae, 0x08181008, 0xbad56fba, 0x7888f078, 0x256f4a25, 0x2e725c2e, 0x1c24381c, 0xa6f157a6, 0xb4c773b4, 0xc65197c6, 0xe823cbe8, 0xdd7ca1dd, 0x749ce874, 0x1f213e1f, 0x4bdd964b, 0xbddc61bd, 0x8b860d8b, 0x8a850f8a, 0x7090e070, 0x3e427c3e, 0xb5c471b5, 0x66aacc66, 0x48d89048, 0x03050603, 0xf601f7f6, 0x0e121c0e, 0x61a3c261, 0x355f6a35, 0x57f9ae57, 0xb9d069b9, 0x86911786, 0xc15899c1, 0x1d273a1d, 0x9eb9279e, 0xe138d9e1, 0xf813ebf8, 0x98b32b98, 0x11332211, 0x69bbd269, 0xd970a9d9, 0x8e89078e, 0x94a73394, 0x9bb62d9b, 0x1e223c1e, 0x87921587, 0xe920c9e9, 0xce4987ce, 0x55ffaa55, 0x28785028, 0xdf7aa5df, 0x8c8f038c, 0xa1f859a1, 0x89800989, 0x0d171a0d, 0xbfda65bf, 0xe631d7e6, 0x42c68442, 0x68b8d068, 0x41c38241, 0x99b02999, 0x2d775a2d, 0x0f111e0f, 0xb0cb7bb0, 0x54fca854, 0xbbd66dbb, 0x163a2c16];\nconst T4 = [0x6363a5c6, 0x7c7c84f8, 0x777799ee, 0x7b7b8df6, 0xf2f20dff, 0x6b6bbdd6, 0x6f6fb1de, 0xc5c55491, 0x30305060, 0x01010302, 0x6767a9ce, 0x2b2b7d56, 0xfefe19e7, 0xd7d762b5, 0xababe64d, 0x76769aec, 0xcaca458f, 0x82829d1f, 0xc9c94089, 0x7d7d87fa, 0xfafa15ef, 0x5959ebb2, 0x4747c98e, 0xf0f00bfb, 0xadadec41, 0xd4d467b3, 0xa2a2fd5f, 0xafafea45, 0x9c9cbf23, 0xa4a4f753, 0x727296e4, 0xc0c05b9b, 0xb7b7c275, 0xfdfd1ce1, 0x9393ae3d, 0x26266a4c, 0x36365a6c, 0x3f3f417e, 0xf7f702f5, 0xcccc4f83, 0x34345c68, 0xa5a5f451, 0xe5e534d1, 0xf1f108f9, 0x717193e2, 0xd8d873ab, 0x31315362, 0x15153f2a, 0x04040c08, 0xc7c75295, 0x23236546, 0xc3c35e9d, 0x18182830, 0x9696a137, 0x05050f0a, 0x9a9ab52f, 0x0707090e, 0x12123624, 0x80809b1b, 0xe2e23ddf, 0xebeb26cd, 0x2727694e, 0xb2b2cd7f, 0x75759fea, 0x09091b12, 0x83839e1d, 0x2c2c7458, 0x1a1a2e34, 0x1b1b2d36, 0x6e6eb2dc, 0x5a5aeeb4, 0xa0a0fb5b, 0x5252f6a4, 0x3b3b4d76, 0xd6d661b7, 0xb3b3ce7d, 0x29297b52, 0xe3e33edd, 0x2f2f715e, 0x84849713, 0x5353f5a6, 0xd1d168b9, 0x00000000, 0xeded2cc1, 0x20206040, 0xfcfc1fe3, 0xb1b1c879, 0x5b5bedb6, 0x6a6abed4, 0xcbcb468d, 0xbebed967, 0x39394b72, 0x4a4ade94, 0x4c4cd498, 0x5858e8b0, 0xcfcf4a85, 0xd0d06bbb, 0xefef2ac5, 0xaaaae54f, 0xfbfb16ed, 0x4343c586, 0x4d4dd79a, 0x33335566, 0x85859411, 0x4545cf8a, 0xf9f910e9, 0x02020604, 0x7f7f81fe, 0x5050f0a0, 0x3c3c4478, 0x9f9fba25, 0xa8a8e34b, 0x5151f3a2, 0xa3a3fe5d, 0x4040c080, 0x8f8f8a05, 0x9292ad3f, 0x9d9dbc21, 0x38384870, 0xf5f504f1, 0xbcbcdf63, 0xb6b6c177, 0xdada75af, 0x21216342, 0x10103020, 0xffff1ae5, 0xf3f30efd, 0xd2d26dbf, 0xcdcd4c81, 0x0c0c1418, 0x13133526, 0xecec2fc3, 0x5f5fe1be, 0x9797a235, 0x4444cc88, 0x1717392e, 0xc4c45793, 0xa7a7f255, 0x7e7e82fc, 0x3d3d477a, 0x6464acc8, 0x5d5de7ba, 0x19192b32, 0x737395e6, 0x6060a0c0, 0x81819819, 0x4f4fd19e, 0xdcdc7fa3, 0x22226644, 0x2a2a7e54, 0x9090ab3b, 0x8888830b, 0x4646ca8c, 0xeeee29c7, 0xb8b8d36b, 0x14143c28, 0xdede79a7, 0x5e5ee2bc, 0x0b0b1d16, 0xdbdb76ad, 0xe0e03bdb, 0x32325664, 0x3a3a4e74, 0x0a0a1e14, 0x4949db92, 0x06060a0c, 0x24246c48, 0x5c5ce4b8, 0xc2c25d9f, 0xd3d36ebd, 0xacacef43, 0x6262a6c4, 0x9191a839, 0x9595a431, 0xe4e437d3, 0x79798bf2, 0xe7e732d5, 0xc8c8438b, 0x3737596e, 0x6d6db7da, 0x8d8d8c01, 0xd5d564b1, 0x4e4ed29c, 0xa9a9e049, 0x6c6cb4d8, 0x5656faac, 0xf4f407f3, 0xeaea25cf, 0x6565afca, 0x7a7a8ef4, 0xaeaee947, 0x08081810, 0xbabad56f, 0x787888f0, 0x25256f4a, 0x2e2e725c, 0x1c1c2438, 0xa6a6f157, 0xb4b4c773, 0xc6c65197, 0xe8e823cb, 0xdddd7ca1, 0x74749ce8, 0x1f1f213e, 0x4b4bdd96, 0xbdbddc61, 0x8b8b860d, 0x8a8a850f, 0x707090e0, 0x3e3e427c, 0xb5b5c471, 0x6666aacc, 0x4848d890, 0x03030506, 0xf6f601f7, 0x0e0e121c, 0x6161a3c2, 0x35355f6a, 0x5757f9ae, 0xb9b9d069, 0x86869117, 0xc1c15899, 0x1d1d273a, 0x9e9eb927, 0xe1e138d9, 0xf8f813eb, 0x9898b32b, 0x11113322, 0x6969bbd2, 0xd9d970a9, 0x8e8e8907, 0x9494a733, 0x9b9bb62d, 0x1e1e223c, 0x87879215, 0xe9e920c9, 0xcece4987, 0x5555ffaa, 0x28287850, 0xdfdf7aa5, 0x8c8c8f03, 0xa1a1f859, 0x89898009, 0x0d0d171a, 0xbfbfda65, 0xe6e631d7, 0x4242c684, 0x6868b8d0, 0x4141c382, 0x9999b029, 0x2d2d775a, 0x0f0f111e, 0xb0b0cb7b, 0x5454fca8, 0xbbbbd66d, 0x16163a2c];\n// Transformations for decryption\nconst T5 = [0x51f4a750, 0x7e416553, 0x1a17a4c3, 0x3a275e96, 0x3bab6bcb, 0x1f9d45f1, 0xacfa58ab, 0x4be30393, 0x2030fa55, 0xad766df6, 0x88cc7691, 0xf5024c25, 0x4fe5d7fc, 0xc52acbd7, 0x26354480, 0xb562a38f, 0xdeb15a49, 0x25ba1b67, 0x45ea0e98, 0x5dfec0e1, 0xc32f7502, 0x814cf012, 0x8d4697a3, 0x6bd3f9c6, 0x038f5fe7, 0x15929c95, 0xbf6d7aeb, 0x955259da, 0xd4be832d, 0x587421d3, 0x49e06929, 0x8ec9c844, 0x75c2896a, 0xf48e7978, 0x99583e6b, 0x27b971dd, 0xbee14fb6, 0xf088ad17, 0xc920ac66, 0x7dce3ab4, 0x63df4a18, 0xe51a3182, 0x97513360, 0x62537f45, 0xb16477e0, 0xbb6bae84, 0xfe81a01c, 0xf9082b94, 0x70486858, 0x8f45fd19, 0x94de6c87, 0x527bf8b7, 0xab73d323, 0x724b02e2, 0xe31f8f57, 0x6655ab2a, 0xb2eb2807, 0x2fb5c203, 0x86c57b9a, 0xd33708a5, 0x302887f2, 0x23bfa5b2, 0x02036aba, 0xed16825c, 0x8acf1c2b, 0xa779b492, 0xf307f2f0, 0x4e69e2a1, 0x65daf4cd, 0x0605bed5, 0xd134621f, 0xc4a6fe8a, 0x342e539d, 0xa2f355a0, 0x058ae132, 0xa4f6eb75, 0x0b83ec39, 0x4060efaa, 0x5e719f06, 0xbd6e1051, 0x3e218af9, 0x96dd063d, 0xdd3e05ae, 0x4de6bd46, 0x91548db5, 0x71c45d05, 0x0406d46f, 0x605015ff, 0x1998fb24, 0xd6bde997, 0x894043cc, 0x67d99e77, 0xb0e842bd, 0x07898b88, 0xe7195b38, 0x79c8eedb, 0xa17c0a47, 0x7c420fe9, 0xf8841ec9, 0x00000000, 0x09808683, 0x322bed48, 0x1e1170ac, 0x6c5a724e, 0xfd0efffb, 0x0f853856, 0x3daed51e, 0x362d3927, 0x0a0fd964, 0x685ca621, 0x9b5b54d1, 0x24362e3a, 0x0c0a67b1, 0x9357e70f, 0xb4ee96d2, 0x1b9b919e, 0x80c0c54f, 0x61dc20a2, 0x5a774b69, 0x1c121a16, 0xe293ba0a, 0xc0a02ae5, 0x3c22e043, 0x121b171d, 0x0e090d0b, 0xf28bc7ad, 0x2db6a8b9, 0x141ea9c8, 0x57f11985, 0xaf75074c, 0xee99ddbb, 0xa37f60fd, 0xf701269f, 0x5c72f5bc, 0x44663bc5, 0x5bfb7e34, 0x8b432976, 0xcb23c6dc, 0xb6edfc68, 0xb8e4f163, 0xd731dcca, 0x42638510, 0x13972240, 0x84c61120, 0x854a247d, 0xd2bb3df8, 0xaef93211, 0xc729a16d, 0x1d9e2f4b, 0xdcb230f3, 0x0d8652ec, 0x77c1e3d0, 0x2bb3166c, 0xa970b999, 0x119448fa, 0x47e96422, 0xa8fc8cc4, 0xa0f03f1a, 0x567d2cd8, 0x223390ef, 0x87494ec7, 0xd938d1c1, 0x8ccaa2fe, 0x98d40b36, 0xa6f581cf, 0xa57ade28, 0xdab78e26, 0x3fadbfa4, 0x2c3a9de4, 0x5078920d, 0x6a5fcc9b, 0x547e4662, 0xf68d13c2, 0x90d8b8e8, 0x2e39f75e, 0x82c3aff5, 0x9f5d80be, 0x69d0937c, 0x6fd52da9, 0xcf2512b3, 0xc8ac993b, 0x10187da7, 0xe89c636e, 0xdb3bbb7b, 0xcd267809, 0x6e5918f4, 0xec9ab701, 0x834f9aa8, 0xe6956e65, 0xaaffe67e, 0x21bccf08, 0xef15e8e6, 0xbae79bd9, 0x4a6f36ce, 0xea9f09d4, 0x29b07cd6, 0x31a4b2af, 0x2a3f2331, 0xc6a59430, 0x35a266c0, 0x744ebc37, 0xfc82caa6, 0xe090d0b0, 0x33a7d815, 0xf104984a, 0x41ecdaf7, 0x7fcd500e, 0x1791f62f, 0x764dd68d, 0x43efb04d, 0xccaa4d54, 0xe49604df, 0x9ed1b5e3, 0x4c6a881b, 0xc12c1fb8, 0x4665517f, 0x9d5eea04, 0x018c355d, 0xfa877473, 0xfb0b412e, 0xb3671d5a, 0x92dbd252, 0xe9105633, 0x6dd64713, 0x9ad7618c, 0x37a10c7a, 0x59f8148e, 0xeb133c89, 0xcea927ee, 0xb761c935, 0xe11ce5ed, 0x7a47b13c, 0x9cd2df59, 0x55f2733f, 0x1814ce79, 0x73c737bf, 0x53f7cdea, 0x5ffdaa5b, 0xdf3d6f14, 0x7844db86, 0xcaaff381, 0xb968c43e, 0x3824342c, 0xc2a3405f, 0x161dc372, 0xbce2250c, 0x283c498b, 0xff0d9541, 0x39a80171, 0x080cb3de, 0xd8b4e49c, 0x6456c190, 0x7bcb8461, 0xd532b670, 0x486c5c74, 0xd0b85742];\nconst T6 = [0x5051f4a7, 0x537e4165, 0xc31a17a4, 0x963a275e, 0xcb3bab6b, 0xf11f9d45, 0xabacfa58, 0x934be303, 0x552030fa, 0xf6ad766d, 0x9188cc76, 0x25f5024c, 0xfc4fe5d7, 0xd7c52acb, 0x80263544, 0x8fb562a3, 0x49deb15a, 0x6725ba1b, 0x9845ea0e, 0xe15dfec0, 0x02c32f75, 0x12814cf0, 0xa38d4697, 0xc66bd3f9, 0xe7038f5f, 0x9515929c, 0xebbf6d7a, 0xda955259, 0x2dd4be83, 0xd3587421, 0x2949e069, 0x448ec9c8, 0x6a75c289, 0x78f48e79, 0x6b99583e, 0xdd27b971, 0xb6bee14f, 0x17f088ad, 0x66c920ac, 0xb47dce3a, 0x1863df4a, 0x82e51a31, 0x60975133, 0x4562537f, 0xe0b16477, 0x84bb6bae, 0x1cfe81a0, 0x94f9082b, 0x58704868, 0x198f45fd, 0x8794de6c, 0xb7527bf8, 0x23ab73d3, 0xe2724b02, 0x57e31f8f, 0x2a6655ab, 0x07b2eb28, 0x032fb5c2, 0x9a86c57b, 0xa5d33708, 0xf2302887, 0xb223bfa5, 0xba02036a, 0x5ced1682, 0x2b8acf1c, 0x92a779b4, 0xf0f307f2, 0xa14e69e2, 0xcd65daf4, 0xd50605be, 0x1fd13462, 0x8ac4a6fe, 0x9d342e53, 0xa0a2f355, 0x32058ae1, 0x75a4f6eb, 0x390b83ec, 0xaa4060ef, 0x065e719f, 0x51bd6e10, 0xf93e218a, 0x3d96dd06, 0xaedd3e05, 0x464de6bd, 0xb591548d, 0x0571c45d, 0x6f0406d4, 0xff605015, 0x241998fb, 0x97d6bde9, 0xcc894043, 0x7767d99e, 0xbdb0e842, 0x8807898b, 0x38e7195b, 0xdb79c8ee, 0x47a17c0a, 0xe97c420f, 0xc9f8841e, 0x00000000, 0x83098086, 0x48322bed, 0xac1e1170, 0x4e6c5a72, 0xfbfd0eff, 0x560f8538, 0x1e3daed5, 0x27362d39, 0x640a0fd9, 0x21685ca6, 0xd19b5b54, 0x3a24362e, 0xb10c0a67, 0x0f9357e7, 0xd2b4ee96, 0x9e1b9b91, 0x4f80c0c5, 0xa261dc20, 0x695a774b, 0x161c121a, 0x0ae293ba, 0xe5c0a02a, 0x433c22e0, 0x1d121b17, 0x0b0e090d, 0xadf28bc7, 0xb92db6a8, 0xc8141ea9, 0x8557f119, 0x4caf7507, 0xbbee99dd, 0xfda37f60, 0x9ff70126, 0xbc5c72f5, 0xc544663b, 0x345bfb7e, 0x768b4329, 0xdccb23c6, 0x68b6edfc, 0x63b8e4f1, 0xcad731dc, 0x10426385, 0x40139722, 0x2084c611, 0x7d854a24, 0xf8d2bb3d, 0x11aef932, 0x6dc729a1, 0x4b1d9e2f, 0xf3dcb230, 0xec0d8652, 0xd077c1e3, 0x6c2bb316, 0x99a970b9, 0xfa119448, 0x2247e964, 0xc4a8fc8c, 0x1aa0f03f, 0xd8567d2c, 0xef223390, 0xc787494e, 0xc1d938d1, 0xfe8ccaa2, 0x3698d40b, 0xcfa6f581, 0x28a57ade, 0x26dab78e, 0xa43fadbf, 0xe42c3a9d, 0x0d507892, 0x9b6a5fcc, 0x62547e46, 0xc2f68d13, 0xe890d8b8, 0x5e2e39f7, 0xf582c3af, 0xbe9f5d80, 0x7c69d093, 0xa96fd52d, 0xb3cf2512, 0x3bc8ac99, 0xa710187d, 0x6ee89c63, 0x7bdb3bbb, 0x09cd2678, 0xf46e5918, 0x01ec9ab7, 0xa8834f9a, 0x65e6956e, 0x7eaaffe6, 0x0821bccf, 0xe6ef15e8, 0xd9bae79b, 0xce4a6f36, 0xd4ea9f09, 0xd629b07c, 0xaf31a4b2, 0x312a3f23, 0x30c6a594, 0xc035a266, 0x37744ebc, 0xa6fc82ca, 0xb0e090d0, 0x1533a7d8, 0x4af10498, 0xf741ecda, 0x0e7fcd50, 0x2f1791f6, 0x8d764dd6, 0x4d43efb0, 0x54ccaa4d, 0xdfe49604, 0xe39ed1b5, 0x1b4c6a88, 0xb8c12c1f, 0x7f466551, 0x049d5eea, 0x5d018c35, 0x73fa8774, 0x2efb0b41, 0x5ab3671d, 0x5292dbd2, 0x33e91056, 0x136dd647, 0x8c9ad761, 0x7a37a10c, 0x8e59f814, 0x89eb133c, 0xeecea927, 0x35b761c9, 0xede11ce5, 0x3c7a47b1, 0x599cd2df, 0x3f55f273, 0x791814ce, 0xbf73c737, 0xea53f7cd, 0x5b5ffdaa, 0x14df3d6f, 0x867844db, 0x81caaff3, 0x3eb968c4, 0x2c382434, 0x5fc2a340, 0x72161dc3, 0x0cbce225, 0x8b283c49, 0x41ff0d95, 0x7139a801, 0xde080cb3, 0x9cd8b4e4, 0x906456c1, 0x617bcb84, 0x70d532b6, 0x74486c5c, 0x42d0b857];\nconst T7 = [0xa75051f4, 0x65537e41, 0xa4c31a17, 0x5e963a27, 0x6bcb3bab, 0x45f11f9d, 0x58abacfa, 0x03934be3, 0xfa552030, 0x6df6ad76, 0x769188cc, 0x4c25f502, 0xd7fc4fe5, 0xcbd7c52a, 0x44802635, 0xa38fb562, 0x5a49deb1, 0x1b6725ba, 0x0e9845ea, 0xc0e15dfe, 0x7502c32f, 0xf012814c, 0x97a38d46, 0xf9c66bd3, 0x5fe7038f, 0x9c951592, 0x7aebbf6d, 0x59da9552, 0x832dd4be, 0x21d35874, 0x692949e0, 0xc8448ec9, 0x896a75c2, 0x7978f48e, 0x3e6b9958, 0x71dd27b9, 0x4fb6bee1, 0xad17f088, 0xac66c920, 0x3ab47dce, 0x4a1863df, 0x3182e51a, 0x33609751, 0x7f456253, 0x77e0b164, 0xae84bb6b, 0xa01cfe81, 0x2b94f908, 0x68587048, 0xfd198f45, 0x6c8794de, 0xf8b7527b, 0xd323ab73, 0x02e2724b, 0x8f57e31f, 0xab2a6655, 0x2807b2eb, 0xc2032fb5, 0x7b9a86c5, 0x08a5d337, 0x87f23028, 0xa5b223bf, 0x6aba0203, 0x825ced16, 0x1c2b8acf, 0xb492a779, 0xf2f0f307, 0xe2a14e69, 0xf4cd65da, 0xbed50605, 0x621fd134, 0xfe8ac4a6, 0x539d342e, 0x55a0a2f3, 0xe132058a, 0xeb75a4f6, 0xec390b83, 0xefaa4060, 0x9f065e71, 0x1051bd6e, 0x8af93e21, 0x063d96dd, 0x05aedd3e, 0xbd464de6, 0x8db59154, 0x5d0571c4, 0xd46f0406, 0x15ff6050, 0xfb241998, 0xe997d6bd, 0x43cc8940, 0x9e7767d9, 0x42bdb0e8, 0x8b880789, 0x5b38e719, 0xeedb79c8, 0x0a47a17c, 0x0fe97c42, 0x1ec9f884, 0x00000000, 0x86830980, 0xed48322b, 0x70ac1e11, 0x724e6c5a, 0xfffbfd0e, 0x38560f85, 0xd51e3dae, 0x3927362d, 0xd9640a0f, 0xa621685c, 0x54d19b5b, 0x2e3a2436, 0x67b10c0a, 0xe70f9357, 0x96d2b4ee, 0x919e1b9b, 0xc54f80c0, 0x20a261dc, 0x4b695a77, 0x1a161c12, 0xba0ae293, 0x2ae5c0a0, 0xe0433c22, 0x171d121b, 0x0d0b0e09, 0xc7adf28b, 0xa8b92db6, 0xa9c8141e, 0x198557f1, 0x074caf75, 0xddbbee99, 0x60fda37f, 0x269ff701, 0xf5bc5c72, 0x3bc54466, 0x7e345bfb, 0x29768b43, 0xc6dccb23, 0xfc68b6ed, 0xf163b8e4, 0xdccad731, 0x85104263, 0x22401397, 0x112084c6, 0x247d854a, 0x3df8d2bb, 0x3211aef9, 0xa16dc729, 0x2f4b1d9e, 0x30f3dcb2, 0x52ec0d86, 0xe3d077c1, 0x166c2bb3, 0xb999a970, 0x48fa1194, 0x642247e9, 0x8cc4a8fc, 0x3f1aa0f0, 0x2cd8567d, 0x90ef2233, 0x4ec78749, 0xd1c1d938, 0xa2fe8cca, 0x0b3698d4, 0x81cfa6f5, 0xde28a57a, 0x8e26dab7, 0xbfa43fad, 0x9de42c3a, 0x920d5078, 0xcc9b6a5f, 0x4662547e, 0x13c2f68d, 0xb8e890d8, 0xf75e2e39, 0xaff582c3, 0x80be9f5d, 0x937c69d0, 0x2da96fd5, 0x12b3cf25, 0x993bc8ac, 0x7da71018, 0x636ee89c, 0xbb7bdb3b, 0x7809cd26, 0x18f46e59, 0xb701ec9a, 0x9aa8834f, 0x6e65e695, 0xe67eaaff, 0xcf0821bc, 0xe8e6ef15, 0x9bd9bae7, 0x36ce4a6f, 0x09d4ea9f, 0x7cd629b0, 0xb2af31a4, 0x23312a3f, 0x9430c6a5, 0x66c035a2, 0xbc37744e, 0xcaa6fc82, 0xd0b0e090, 0xd81533a7, 0x984af104, 0xdaf741ec, 0x500e7fcd, 0xf62f1791, 0xd68d764d, 0xb04d43ef, 0x4d54ccaa, 0x04dfe496, 0xb5e39ed1, 0x881b4c6a, 0x1fb8c12c, 0x517f4665, 0xea049d5e, 0x355d018c, 0x7473fa87, 0x412efb0b, 0x1d5ab367, 0xd25292db, 0x5633e910, 0x47136dd6, 0x618c9ad7, 0x0c7a37a1, 0x148e59f8, 0x3c89eb13, 0x27eecea9, 0xc935b761, 0xe5ede11c, 0xb13c7a47, 0xdf599cd2, 0x733f55f2, 0xce791814, 0x37bf73c7, 0xcdea53f7, 0xaa5b5ffd, 0x6f14df3d, 0xdb867844, 0xf381caaf, 0xc43eb968, 0x342c3824, 0x405fc2a3, 0xc372161d, 0x250cbce2, 0x498b283c, 0x9541ff0d, 0x017139a8, 0xb3de080c, 0xe49cd8b4, 0xc1906456, 0x84617bcb, 0xb670d532, 0x5c74486c, 0x5742d0b8];\nconst T8 = [0xf4a75051, 0x4165537e, 0x17a4c31a, 0x275e963a, 0xab6bcb3b, 0x9d45f11f, 0xfa58abac, 0xe303934b, 0x30fa5520, 0x766df6ad, 0xcc769188, 0x024c25f5, 0xe5d7fc4f, 0x2acbd7c5, 0x35448026, 0x62a38fb5, 0xb15a49de, 0xba1b6725, 0xea0e9845, 0xfec0e15d, 0x2f7502c3, 0x4cf01281, 0x4697a38d, 0xd3f9c66b, 0x8f5fe703, 0x929c9515, 0x6d7aebbf, 0x5259da95, 0xbe832dd4, 0x7421d358, 0xe0692949, 0xc9c8448e, 0xc2896a75, 0x8e7978f4, 0x583e6b99, 0xb971dd27, 0xe14fb6be, 0x88ad17f0, 0x20ac66c9, 0xce3ab47d, 0xdf4a1863, 0x1a3182e5, 0x51336097, 0x537f4562, 0x6477e0b1, 0x6bae84bb, 0x81a01cfe, 0x082b94f9, 0x48685870, 0x45fd198f, 0xde6c8794, 0x7bf8b752, 0x73d323ab, 0x4b02e272, 0x1f8f57e3, 0x55ab2a66, 0xeb2807b2, 0xb5c2032f, 0xc57b9a86, 0x3708a5d3, 0x2887f230, 0xbfa5b223, 0x036aba02, 0x16825ced, 0xcf1c2b8a, 0x79b492a7, 0x07f2f0f3, 0x69e2a14e, 0xdaf4cd65, 0x05bed506, 0x34621fd1, 0xa6fe8ac4, 0x2e539d34, 0xf355a0a2, 0x8ae13205, 0xf6eb75a4, 0x83ec390b, 0x60efaa40, 0x719f065e, 0x6e1051bd, 0x218af93e, 0xdd063d96, 0x3e05aedd, 0xe6bd464d, 0x548db591, 0xc45d0571, 0x06d46f04, 0x5015ff60, 0x98fb2419, 0xbde997d6, 0x4043cc89, 0xd99e7767, 0xe842bdb0, 0x898b8807, 0x195b38e7, 0xc8eedb79, 0x7c0a47a1, 0x420fe97c, 0x841ec9f8, 0x00000000, 0x80868309, 0x2bed4832, 0x1170ac1e, 0x5a724e6c, 0x0efffbfd, 0x8538560f, 0xaed51e3d, 0x2d392736, 0x0fd9640a, 0x5ca62168, 0x5b54d19b, 0x362e3a24, 0x0a67b10c, 0x57e70f93, 0xee96d2b4, 0x9b919e1b, 0xc0c54f80, 0xdc20a261, 0x774b695a, 0x121a161c, 0x93ba0ae2, 0xa02ae5c0, 0x22e0433c, 0x1b171d12, 0x090d0b0e, 0x8bc7adf2, 0xb6a8b92d, 0x1ea9c814, 0xf1198557, 0x75074caf, 0x99ddbbee, 0x7f60fda3, 0x01269ff7, 0x72f5bc5c, 0x663bc544, 0xfb7e345b, 0x4329768b, 0x23c6dccb, 0xedfc68b6, 0xe4f163b8, 0x31dccad7, 0x63851042, 0x97224013, 0xc6112084, 0x4a247d85, 0xbb3df8d2, 0xf93211ae, 0x29a16dc7, 0x9e2f4b1d, 0xb230f3dc, 0x8652ec0d, 0xc1e3d077, 0xb3166c2b, 0x70b999a9, 0x9448fa11, 0xe9642247, 0xfc8cc4a8, 0xf03f1aa0, 0x7d2cd856, 0x3390ef22, 0x494ec787, 0x38d1c1d9, 0xcaa2fe8c, 0xd40b3698, 0xf581cfa6, 0x7ade28a5, 0xb78e26da, 0xadbfa43f, 0x3a9de42c, 0x78920d50, 0x5fcc9b6a, 0x7e466254, 0x8d13c2f6, 0xd8b8e890, 0x39f75e2e, 0xc3aff582, 0x5d80be9f, 0xd0937c69, 0xd52da96f, 0x2512b3cf, 0xac993bc8, 0x187da710, 0x9c636ee8, 0x3bbb7bdb, 0x267809cd, 0x5918f46e, 0x9ab701ec, 0x4f9aa883, 0x956e65e6, 0xffe67eaa, 0xbccf0821, 0x15e8e6ef, 0xe79bd9ba, 0x6f36ce4a, 0x9f09d4ea, 0xb07cd629, 0xa4b2af31, 0x3f23312a, 0xa59430c6, 0xa266c035, 0x4ebc3774, 0x82caa6fc, 0x90d0b0e0, 0xa7d81533, 0x04984af1, 0xecdaf741, 0xcd500e7f, 0x91f62f17, 0x4dd68d76, 0xefb04d43, 0xaa4d54cc, 0x9604dfe4, 0xd1b5e39e, 0x6a881b4c, 0x2c1fb8c1, 0x65517f46, 0x5eea049d, 0x8c355d01, 0x877473fa, 0x0b412efb, 0x671d5ab3, 0xdbd25292, 0x105633e9, 0xd647136d, 0xd7618c9a, 0xa10c7a37, 0xf8148e59, 0x133c89eb, 0xa927eece, 0x61c935b7, 0x1ce5ede1, 0x47b13c7a, 0xd2df599c, 0xf2733f55, 0x14ce7918, 0xc737bf73, 0xf7cdea53, 0xfdaa5b5f, 0x3d6f14df, 0x44db8678, 0xaff381ca, 0x68c43eb9, 0x24342c38, 0xa3405fc2, 0x1dc37216, 0xe2250cbc, 0x3c498b28, 0x0d9541ff, 0xa8017139, 0x0cb3de08, 0xb4e49cd8, 0x56c19064, 0xcb84617b, 0x32b670d5, 0x6c5c7448, 0xb85742d0];\n// Transformations for decryption key expansion\nconst U1 = [0x00000000, 0x0e090d0b, 0x1c121a16, 0x121b171d, 0x3824342c, 0x362d3927, 0x24362e3a, 0x2a3f2331, 0x70486858, 0x7e416553, 0x6c5a724e, 0x62537f45, 0x486c5c74, 0x4665517f, 0x547e4662, 0x5a774b69, 0xe090d0b0, 0xee99ddbb, 0xfc82caa6, 0xf28bc7ad, 0xd8b4e49c, 0xd6bde997, 0xc4a6fe8a, 0xcaaff381, 0x90d8b8e8, 0x9ed1b5e3, 0x8ccaa2fe, 0x82c3aff5, 0xa8fc8cc4, 0xa6f581cf, 0xb4ee96d2, 0xbae79bd9, 0xdb3bbb7b, 0xd532b670, 0xc729a16d, 0xc920ac66, 0xe31f8f57, 0xed16825c, 0xff0d9541, 0xf104984a, 0xab73d323, 0xa57ade28, 0xb761c935, 0xb968c43e, 0x9357e70f, 0x9d5eea04, 0x8f45fd19, 0x814cf012, 0x3bab6bcb, 0x35a266c0, 0x27b971dd, 0x29b07cd6, 0x038f5fe7, 0x0d8652ec, 0x1f9d45f1, 0x119448fa, 0x4be30393, 0x45ea0e98, 0x57f11985, 0x59f8148e, 0x73c737bf, 0x7dce3ab4, 0x6fd52da9, 0x61dc20a2, 0xad766df6, 0xa37f60fd, 0xb16477e0, 0xbf6d7aeb, 0x955259da, 0x9b5b54d1, 0x894043cc, 0x87494ec7, 0xdd3e05ae, 0xd33708a5, 0xc12c1fb8, 0xcf2512b3, 0xe51a3182, 0xeb133c89, 0xf9082b94, 0xf701269f, 0x4de6bd46, 0x43efb04d, 0x51f4a750, 0x5ffdaa5b, 0x75c2896a, 0x7bcb8461, 0x69d0937c, 0x67d99e77, 0x3daed51e, 0x33a7d815, 0x21bccf08, 0x2fb5c203, 0x058ae132, 0x0b83ec39, 0x1998fb24, 0x1791f62f, 0x764dd68d, 0x7844db86, 0x6a5fcc9b, 0x6456c190, 0x4e69e2a1, 0x4060efaa, 0x527bf8b7, 0x5c72f5bc, 0x0605bed5, 0x080cb3de, 0x1a17a4c3, 0x141ea9c8, 0x3e218af9, 0x302887f2, 0x223390ef, 0x2c3a9de4, 0x96dd063d, 0x98d40b36, 0x8acf1c2b, 0x84c61120, 0xaef93211, 0xa0f03f1a, 0xb2eb2807, 0xbce2250c, 0xe6956e65, 0xe89c636e, 0xfa877473, 0xf48e7978, 0xdeb15a49, 0xd0b85742, 0xc2a3405f, 0xccaa4d54, 0x41ecdaf7, 0x4fe5d7fc, 0x5dfec0e1, 0x53f7cdea, 0x79c8eedb, 0x77c1e3d0, 0x65daf4cd, 0x6bd3f9c6, 0x31a4b2af, 0x3fadbfa4, 0x2db6a8b9, 0x23bfa5b2, 0x09808683, 0x07898b88, 0x15929c95, 0x1b9b919e, 0xa17c0a47, 0xaf75074c, 0xbd6e1051, 0xb3671d5a, 0x99583e6b, 0x97513360, 0x854a247d, 0x8b432976, 0xd134621f, 0xdf3d6f14, 0xcd267809, 0xc32f7502, 0xe9105633, 0xe7195b38, 0xf5024c25, 0xfb0b412e, 0x9ad7618c, 0x94de6c87, 0x86c57b9a, 0x88cc7691, 0xa2f355a0, 0xacfa58ab, 0xbee14fb6, 0xb0e842bd, 0xea9f09d4, 0xe49604df, 0xf68d13c2, 0xf8841ec9, 0xd2bb3df8, 0xdcb230f3, 0xcea927ee, 0xc0a02ae5, 0x7a47b13c, 0x744ebc37, 0x6655ab2a, 0x685ca621, 0x42638510, 0x4c6a881b, 0x5e719f06, 0x5078920d, 0x0a0fd964, 0x0406d46f, 0x161dc372, 0x1814ce79, 0x322bed48, 0x3c22e043, 0x2e39f75e, 0x2030fa55, 0xec9ab701, 0xe293ba0a, 0xf088ad17, 0xfe81a01c, 0xd4be832d, 0xdab78e26, 0xc8ac993b, 0xc6a59430, 0x9cd2df59, 0x92dbd252, 0x80c0c54f, 0x8ec9c844, 0xa4f6eb75, 0xaaffe67e, 0xb8e4f163, 0xb6edfc68, 0x0c0a67b1, 0x02036aba, 0x10187da7, 0x1e1170ac, 0x342e539d, 0x3a275e96, 0x283c498b, 0x26354480, 0x7c420fe9, 0x724b02e2, 0x605015ff, 0x6e5918f4, 0x44663bc5, 0x4a6f36ce, 0x587421d3, 0x567d2cd8, 0x37a10c7a, 0x39a80171, 0x2bb3166c, 0x25ba1b67, 0x0f853856, 0x018c355d, 0x13972240, 0x1d9e2f4b, 0x47e96422, 0x49e06929, 0x5bfb7e34, 0x55f2733f, 0x7fcd500e, 0x71c45d05, 0x63df4a18, 0x6dd64713, 0xd731dcca, 0xd938d1c1, 0xcb23c6dc, 0xc52acbd7, 0xef15e8e6, 0xe11ce5ed, 0xf307f2f0, 0xfd0efffb, 0xa779b492, 0xa970b999, 0xbb6bae84, 0xb562a38f, 0x9f5d80be, 0x91548db5, 0x834f9aa8, 0x8d4697a3];\nconst U2 = [0x00000000, 0x0b0e090d, 0x161c121a, 0x1d121b17, 0x2c382434, 0x27362d39, 0x3a24362e, 0x312a3f23, 0x58704868, 0x537e4165, 0x4e6c5a72, 0x4562537f, 0x74486c5c, 0x7f466551, 0x62547e46, 0x695a774b, 0xb0e090d0, 0xbbee99dd, 0xa6fc82ca, 0xadf28bc7, 0x9cd8b4e4, 0x97d6bde9, 0x8ac4a6fe, 0x81caaff3, 0xe890d8b8, 0xe39ed1b5, 0xfe8ccaa2, 0xf582c3af, 0xc4a8fc8c, 0xcfa6f581, 0xd2b4ee96, 0xd9bae79b, 0x7bdb3bbb, 0x70d532b6, 0x6dc729a1, 0x66c920ac, 0x57e31f8f, 0x5ced1682, 0x41ff0d95, 0x4af10498, 0x23ab73d3, 0x28a57ade, 0x35b761c9, 0x3eb968c4, 0x0f9357e7, 0x049d5eea, 0x198f45fd, 0x12814cf0, 0xcb3bab6b, 0xc035a266, 0xdd27b971, 0xd629b07c, 0xe7038f5f, 0xec0d8652, 0xf11f9d45, 0xfa119448, 0x934be303, 0x9845ea0e, 0x8557f119, 0x8e59f814, 0xbf73c737, 0xb47dce3a, 0xa96fd52d, 0xa261dc20, 0xf6ad766d, 0xfda37f60, 0xe0b16477, 0xebbf6d7a, 0xda955259, 0xd19b5b54, 0xcc894043, 0xc787494e, 0xaedd3e05, 0xa5d33708, 0xb8c12c1f, 0xb3cf2512, 0x82e51a31, 0x89eb133c, 0x94f9082b, 0x9ff70126, 0x464de6bd, 0x4d43efb0, 0x5051f4a7, 0x5b5ffdaa, 0x6a75c289, 0x617bcb84, 0x7c69d093, 0x7767d99e, 0x1e3daed5, 0x1533a7d8, 0x0821bccf, 0x032fb5c2, 0x32058ae1, 0x390b83ec, 0x241998fb, 0x2f1791f6, 0x8d764dd6, 0x867844db, 0x9b6a5fcc, 0x906456c1, 0xa14e69e2, 0xaa4060ef, 0xb7527bf8, 0xbc5c72f5, 0xd50605be, 0xde080cb3, 0xc31a17a4, 0xc8141ea9, 0xf93e218a, 0xf2302887, 0xef223390, 0xe42c3a9d, 0x3d96dd06, 0x3698d40b, 0x2b8acf1c, 0x2084c611, 0x11aef932, 0x1aa0f03f, 0x07b2eb28, 0x0cbce225, 0x65e6956e, 0x6ee89c63, 0x73fa8774, 0x78f48e79, 0x49deb15a, 0x42d0b857, 0x5fc2a340, 0x54ccaa4d, 0xf741ecda, 0xfc4fe5d7, 0xe15dfec0, 0xea53f7cd, 0xdb79c8ee, 0xd077c1e3, 0xcd65daf4, 0xc66bd3f9, 0xaf31a4b2, 0xa43fadbf, 0xb92db6a8, 0xb223bfa5, 0x83098086, 0x8807898b, 0x9515929c, 0x9e1b9b91, 0x47a17c0a, 0x4caf7507, 0x51bd6e10, 0x5ab3671d, 0x6b99583e, 0x60975133, 0x7d854a24, 0x768b4329, 0x1fd13462, 0x14df3d6f, 0x09cd2678, 0x02c32f75, 0x33e91056, 0x38e7195b, 0x25f5024c, 0x2efb0b41, 0x8c9ad761, 0x8794de6c, 0x9a86c57b, 0x9188cc76, 0xa0a2f355, 0xabacfa58, 0xb6bee14f, 0xbdb0e842, 0xd4ea9f09, 0xdfe49604, 0xc2f68d13, 0xc9f8841e, 0xf8d2bb3d, 0xf3dcb230, 0xeecea927, 0xe5c0a02a, 0x3c7a47b1, 0x37744ebc, 0x2a6655ab, 0x21685ca6, 0x10426385, 0x1b4c6a88, 0x065e719f, 0x0d507892, 0x640a0fd9, 0x6f0406d4, 0x72161dc3, 0x791814ce, 0x48322bed, 0x433c22e0, 0x5e2e39f7, 0x552030fa, 0x01ec9ab7, 0x0ae293ba, 0x17f088ad, 0x1cfe81a0, 0x2dd4be83, 0x26dab78e, 0x3bc8ac99, 0x30c6a594, 0x599cd2df, 0x5292dbd2, 0x4f80c0c5, 0x448ec9c8, 0x75a4f6eb, 0x7eaaffe6, 0x63b8e4f1, 0x68b6edfc, 0xb10c0a67, 0xba02036a, 0xa710187d, 0xac1e1170, 0x9d342e53, 0x963a275e, 0x8b283c49, 0x80263544, 0xe97c420f, 0xe2724b02, 0xff605015, 0xf46e5918, 0xc544663b, 0xce4a6f36, 0xd3587421, 0xd8567d2c, 0x7a37a10c, 0x7139a801, 0x6c2bb316, 0x6725ba1b, 0x560f8538, 0x5d018c35, 0x40139722, 0x4b1d9e2f, 0x2247e964, 0x2949e069, 0x345bfb7e, 0x3f55f273, 0x0e7fcd50, 0x0571c45d, 0x1863df4a, 0x136dd647, 0xcad731dc, 0xc1d938d1, 0xdccb23c6, 0xd7c52acb, 0xe6ef15e8, 0xede11ce5, 0xf0f307f2, 0xfbfd0eff, 0x92a779b4, 0x99a970b9, 0x84bb6bae, 0x8fb562a3, 0xbe9f5d80, 0xb591548d, 0xa8834f9a, 0xa38d4697];\nconst U3 = [0x00000000, 0x0d0b0e09, 0x1a161c12, 0x171d121b, 0x342c3824, 0x3927362d, 0x2e3a2436, 0x23312a3f, 0x68587048, 0x65537e41, 0x724e6c5a, 0x7f456253, 0x5c74486c, 0x517f4665, 0x4662547e, 0x4b695a77, 0xd0b0e090, 0xddbbee99, 0xcaa6fc82, 0xc7adf28b, 0xe49cd8b4, 0xe997d6bd, 0xfe8ac4a6, 0xf381caaf, 0xb8e890d8, 0xb5e39ed1, 0xa2fe8cca, 0xaff582c3, 0x8cc4a8fc, 0x81cfa6f5, 0x96d2b4ee, 0x9bd9bae7, 0xbb7bdb3b, 0xb670d532, 0xa16dc729, 0xac66c920, 0x8f57e31f, 0x825ced16, 0x9541ff0d, 0x984af104, 0xd323ab73, 0xde28a57a, 0xc935b761, 0xc43eb968, 0xe70f9357, 0xea049d5e, 0xfd198f45, 0xf012814c, 0x6bcb3bab, 0x66c035a2, 0x71dd27b9, 0x7cd629b0, 0x5fe7038f, 0x52ec0d86, 0x45f11f9d, 0x48fa1194, 0x03934be3, 0x0e9845ea, 0x198557f1, 0x148e59f8, 0x37bf73c7, 0x3ab47dce, 0x2da96fd5, 0x20a261dc, 0x6df6ad76, 0x60fda37f, 0x77e0b164, 0x7aebbf6d, 0x59da9552, 0x54d19b5b, 0x43cc8940, 0x4ec78749, 0x05aedd3e, 0x08a5d337, 0x1fb8c12c, 0x12b3cf25, 0x3182e51a, 0x3c89eb13, 0x2b94f908, 0x269ff701, 0xbd464de6, 0xb04d43ef, 0xa75051f4, 0xaa5b5ffd, 0x896a75c2, 0x84617bcb, 0x937c69d0, 0x9e7767d9, 0xd51e3dae, 0xd81533a7, 0xcf0821bc, 0xc2032fb5, 0xe132058a, 0xec390b83, 0xfb241998, 0xf62f1791, 0xd68d764d, 0xdb867844, 0xcc9b6a5f, 0xc1906456, 0xe2a14e69, 0xefaa4060, 0xf8b7527b, 0xf5bc5c72, 0xbed50605, 0xb3de080c, 0xa4c31a17, 0xa9c8141e, 0x8af93e21, 0x87f23028, 0x90ef2233, 0x9de42c3a, 0x063d96dd, 0x0b3698d4, 0x1c2b8acf, 0x112084c6, 0x3211aef9, 0x3f1aa0f0, 0x2807b2eb, 0x250cbce2, 0x6e65e695, 0x636ee89c, 0x7473fa87, 0x7978f48e, 0x5a49deb1, 0x5742d0b8, 0x405fc2a3, 0x4d54ccaa, 0xdaf741ec, 0xd7fc4fe5, 0xc0e15dfe, 0xcdea53f7, 0xeedb79c8, 0xe3d077c1, 0xf4cd65da, 0xf9c66bd3, 0xb2af31a4, 0xbfa43fad, 0xa8b92db6, 0xa5b223bf, 0x86830980, 0x8b880789, 0x9c951592, 0x919e1b9b, 0x0a47a17c, 0x074caf75, 0x1051bd6e, 0x1d5ab367, 0x3e6b9958, 0x33609751, 0x247d854a, 0x29768b43, 0x621fd134, 0x6f14df3d, 0x7809cd26, 0x7502c32f, 0x5633e910, 0x5b38e719, 0x4c25f502, 0x412efb0b, 0x618c9ad7, 0x6c8794de, 0x7b9a86c5, 0x769188cc, 0x55a0a2f3, 0x58abacfa, 0x4fb6bee1, 0x42bdb0e8, 0x09d4ea9f, 0x04dfe496, 0x13c2f68d, 0x1ec9f884, 0x3df8d2bb, 0x30f3dcb2, 0x27eecea9, 0x2ae5c0a0, 0xb13c7a47, 0xbc37744e, 0xab2a6655, 0xa621685c, 0x85104263, 0x881b4c6a, 0x9f065e71, 0x920d5078, 0xd9640a0f, 0xd46f0406, 0xc372161d, 0xce791814, 0xed48322b, 0xe0433c22, 0xf75e2e39, 0xfa552030, 0xb701ec9a, 0xba0ae293, 0xad17f088, 0xa01cfe81, 0x832dd4be, 0x8e26dab7, 0x993bc8ac, 0x9430c6a5, 0xdf599cd2, 0xd25292db, 0xc54f80c0, 0xc8448ec9, 0xeb75a4f6, 0xe67eaaff, 0xf163b8e4, 0xfc68b6ed, 0x67b10c0a, 0x6aba0203, 0x7da71018, 0x70ac1e11, 0x539d342e, 0x5e963a27, 0x498b283c, 0x44802635, 0x0fe97c42, 0x02e2724b, 0x15ff6050, 0x18f46e59, 0x3bc54466, 0x36ce4a6f, 0x21d35874, 0x2cd8567d, 0x0c7a37a1, 0x017139a8, 0x166c2bb3, 0x1b6725ba, 0x38560f85, 0x355d018c, 0x22401397, 0x2f4b1d9e, 0x642247e9, 0x692949e0, 0x7e345bfb, 0x733f55f2, 0x500e7fcd, 0x5d0571c4, 0x4a1863df, 0x47136dd6, 0xdccad731, 0xd1c1d938, 0xc6dccb23, 0xcbd7c52a, 0xe8e6ef15, 0xe5ede11c, 0xf2f0f307, 0xfffbfd0e, 0xb492a779, 0xb999a970, 0xae84bb6b, 0xa38fb562, 0x80be9f5d, 0x8db59154, 0x9aa8834f, 0x97a38d46];\nconst U4 = [0x00000000, 0x090d0b0e, 0x121a161c, 0x1b171d12, 0x24342c38, 0x2d392736, 0x362e3a24, 0x3f23312a, 0x48685870, 0x4165537e, 0x5a724e6c, 0x537f4562, 0x6c5c7448, 0x65517f46, 0x7e466254, 0x774b695a, 0x90d0b0e0, 0x99ddbbee, 0x82caa6fc, 0x8bc7adf2, 0xb4e49cd8, 0xbde997d6, 0xa6fe8ac4, 0xaff381ca, 0xd8b8e890, 0xd1b5e39e, 0xcaa2fe8c, 0xc3aff582, 0xfc8cc4a8, 0xf581cfa6, 0xee96d2b4, 0xe79bd9ba, 0x3bbb7bdb, 0x32b670d5, 0x29a16dc7, 0x20ac66c9, 0x1f8f57e3, 0x16825ced, 0x0d9541ff, 0x04984af1, 0x73d323ab, 0x7ade28a5, 0x61c935b7, 0x68c43eb9, 0x57e70f93, 0x5eea049d, 0x45fd198f, 0x4cf01281, 0xab6bcb3b, 0xa266c035, 0xb971dd27, 0xb07cd629, 0x8f5fe703, 0x8652ec0d, 0x9d45f11f, 0x9448fa11, 0xe303934b, 0xea0e9845, 0xf1198557, 0xf8148e59, 0xc737bf73, 0xce3ab47d, 0xd52da96f, 0xdc20a261, 0x766df6ad, 0x7f60fda3, 0x6477e0b1, 0x6d7aebbf, 0x5259da95, 0x5b54d19b, 0x4043cc89, 0x494ec787, 0x3e05aedd, 0x3708a5d3, 0x2c1fb8c1, 0x2512b3cf, 0x1a3182e5, 0x133c89eb, 0x082b94f9, 0x01269ff7, 0xe6bd464d, 0xefb04d43, 0xf4a75051, 0xfdaa5b5f, 0xc2896a75, 0xcb84617b, 0xd0937c69, 0xd99e7767, 0xaed51e3d, 0xa7d81533, 0xbccf0821, 0xb5c2032f, 0x8ae13205, 0x83ec390b, 0x98fb2419, 0x91f62f17, 0x4dd68d76, 0x44db8678, 0x5fcc9b6a, 0x56c19064, 0x69e2a14e, 0x60efaa40, 0x7bf8b752, 0x72f5bc5c, 0x05bed506, 0x0cb3de08, 0x17a4c31a, 0x1ea9c814, 0x218af93e, 0x2887f230, 0x3390ef22, 0x3a9de42c, 0xdd063d96, 0xd40b3698, 0xcf1c2b8a, 0xc6112084, 0xf93211ae, 0xf03f1aa0, 0xeb2807b2, 0xe2250cbc, 0x956e65e6, 0x9c636ee8, 0x877473fa, 0x8e7978f4, 0xb15a49de, 0xb85742d0, 0xa3405fc2, 0xaa4d54cc, 0xecdaf741, 0xe5d7fc4f, 0xfec0e15d, 0xf7cdea53, 0xc8eedb79, 0xc1e3d077, 0xdaf4cd65, 0xd3f9c66b, 0xa4b2af31, 0xadbfa43f, 0xb6a8b92d, 0xbfa5b223, 0x80868309, 0x898b8807, 0x929c9515, 0x9b919e1b, 0x7c0a47a1, 0x75074caf, 0x6e1051bd, 0x671d5ab3, 0x583e6b99, 0x51336097, 0x4a247d85, 0x4329768b, 0x34621fd1, 0x3d6f14df, 0x267809cd, 0x2f7502c3, 0x105633e9, 0x195b38e7, 0x024c25f5, 0x0b412efb, 0xd7618c9a, 0xde6c8794, 0xc57b9a86, 0xcc769188, 0xf355a0a2, 0xfa58abac, 0xe14fb6be, 0xe842bdb0, 0x9f09d4ea, 0x9604dfe4, 0x8d13c2f6, 0x841ec9f8, 0xbb3df8d2, 0xb230f3dc, 0xa927eece, 0xa02ae5c0, 0x47b13c7a, 0x4ebc3774, 0x55ab2a66, 0x5ca62168, 0x63851042, 0x6a881b4c, 0x719f065e, 0x78920d50, 0x0fd9640a, 0x06d46f04, 0x1dc37216, 0x14ce7918, 0x2bed4832, 0x22e0433c, 0x39f75e2e, 0x30fa5520, 0x9ab701ec, 0x93ba0ae2, 0x88ad17f0, 0x81a01cfe, 0xbe832dd4, 0xb78e26da, 0xac993bc8, 0xa59430c6, 0xd2df599c, 0xdbd25292, 0xc0c54f80, 0xc9c8448e, 0xf6eb75a4, 0xffe67eaa, 0xe4f163b8, 0xedfc68b6, 0x0a67b10c, 0x036aba02, 0x187da710, 0x1170ac1e, 0x2e539d34, 0x275e963a, 0x3c498b28, 0x35448026, 0x420fe97c, 0x4b02e272, 0x5015ff60, 0x5918f46e, 0x663bc544, 0x6f36ce4a, 0x7421d358, 0x7d2cd856, 0xa10c7a37, 0xa8017139, 0xb3166c2b, 0xba1b6725, 0x8538560f, 0x8c355d01, 0x97224013, 0x9e2f4b1d, 0xe9642247, 0xe0692949, 0xfb7e345b, 0xf2733f55, 0xcd500e7f, 0xc45d0571, 0xdf4a1863, 0xd647136d, 0x31dccad7, 0x38d1c1d9, 0x23c6dccb, 0x2acbd7c5, 0x15e8e6ef, 0x1ce5ede1, 0x07f2f0f3, 0x0efffbfd, 0x79b492a7, 0x70b999a9, 0x6bae84bb, 0x62a38fb5, 0x5d80be9f, 0x548db591, 0x4f9aa883, 0x4697a38d];\nfunction convertToInt32(bytes) {\n    const result = [];\n    for (let i = 0; i < bytes.length; i += 4) {\n        result.push((bytes[i] << 24) | (bytes[i + 1] << 16) | (bytes[i + 2] << 8) | bytes[i + 3]);\n    }\n    return result;\n}\nexport class AES {\n    get key() { return __classPrivateFieldGet(this, _AES_key, \"f\").slice(); }\n    constructor(key) {\n        _AES_key.set(this, void 0);\n        _AES_Kd.set(this, void 0);\n        _AES_Ke.set(this, void 0);\n        if (!(this instanceof AES)) {\n            throw Error('AES must be instanitated with `new`');\n        }\n        __classPrivateFieldSet(this, _AES_key, new Uint8Array(key), \"f\");\n        const rounds = numberOfRounds[this.key.length];\n        if (rounds == null) {\n            throw new TypeError('invalid key size (must be 16, 24 or 32 bytes)');\n        }\n        // encryption round keys\n        __classPrivateFieldSet(this, _AES_Ke, [], \"f\");\n        // decryption round keys\n        __classPrivateFieldSet(this, _AES_Kd, [], \"f\");\n        for (let i = 0; i <= rounds; i++) {\n            __classPrivateFieldGet(this, _AES_Ke, \"f\").push([0, 0, 0, 0]);\n            __classPrivateFieldGet(this, _AES_Kd, \"f\").push([0, 0, 0, 0]);\n        }\n        const roundKeyCount = (rounds + 1) * 4;\n        const KC = this.key.length / 4;\n        // convert the key into ints\n        const tk = convertToInt32(this.key);\n        // copy values into round key arrays\n        let index;\n        for (let i = 0; i < KC; i++) {\n            index = i >> 2;\n            __classPrivateFieldGet(this, _AES_Ke, \"f\")[index][i % 4] = tk[i];\n            __classPrivateFieldGet(this, _AES_Kd, \"f\")[rounds - index][i % 4] = tk[i];\n        }\n        // key expansion (fips-197 section 5.2)\n        let rconpointer = 0;\n        let t = KC, tt;\n        while (t < roundKeyCount) {\n            tt = tk[KC - 1];\n            tk[0] ^= ((S[(tt >> 16) & 0xFF] << 24) ^\n                (S[(tt >> 8) & 0xFF] << 16) ^\n                (S[tt & 0xFF] << 8) ^\n                S[(tt >> 24) & 0xFF] ^\n                (rcon[rconpointer] << 24));\n            rconpointer += 1;\n            // key expansion (for non-256 bit)\n            if (KC != 8) {\n                for (let i = 1; i < KC; i++) {\n                    tk[i] ^= tk[i - 1];\n                }\n                // key expansion for 256-bit keys is \"slightly different\" (fips-197)\n            }\n            else {\n                for (let i = 1; i < (KC / 2); i++) {\n                    tk[i] ^= tk[i - 1];\n                }\n                tt = tk[(KC / 2) - 1];\n                tk[KC / 2] ^= (S[tt & 0xFF] ^\n                    (S[(tt >> 8) & 0xFF] << 8) ^\n                    (S[(tt >> 16) & 0xFF] << 16) ^\n                    (S[(tt >> 24) & 0xFF] << 24));\n                for (let i = (KC / 2) + 1; i < KC; i++) {\n                    tk[i] ^= tk[i - 1];\n                }\n            }\n            // copy values into round key arrays\n            let i = 0, r, c;\n            while (i < KC && t < roundKeyCount) {\n                r = t >> 2;\n                c = t % 4;\n                __classPrivateFieldGet(this, _AES_Ke, \"f\")[r][c] = tk[i];\n                __classPrivateFieldGet(this, _AES_Kd, \"f\")[rounds - r][c] = tk[i++];\n                t++;\n            }\n        }\n        // inverse-cipher-ify the decryption round key (fips-197 section 5.3)\n        for (let r = 1; r < rounds; r++) {\n            for (let c = 0; c < 4; c++) {\n                tt = __classPrivateFieldGet(this, _AES_Kd, \"f\")[r][c];\n                __classPrivateFieldGet(this, _AES_Kd, \"f\")[r][c] = (U1[(tt >> 24) & 0xFF] ^\n                    U2[(tt >> 16) & 0xFF] ^\n                    U3[(tt >> 8) & 0xFF] ^\n                    U4[tt & 0xFF]);\n            }\n        }\n    }\n    encrypt(plaintext) {\n        if (plaintext.length != 16) {\n            throw new TypeError('invalid plaintext size (must be 16 bytes)');\n        }\n        const rounds = __classPrivateFieldGet(this, _AES_Ke, \"f\").length - 1;\n        const a = [0, 0, 0, 0];\n        // convert plaintext to (ints ^ key)\n        let t = convertToInt32(plaintext);\n        for (let i = 0; i < 4; i++) {\n            t[i] ^= __classPrivateFieldGet(this, _AES_Ke, \"f\")[0][i];\n        }\n        // apply round transforms\n        for (let r = 1; r < rounds; r++) {\n            for (let i = 0; i < 4; i++) {\n                a[i] = (T1[(t[i] >> 24) & 0xff] ^\n                    T2[(t[(i + 1) % 4] >> 16) & 0xff] ^\n                    T3[(t[(i + 2) % 4] >> 8) & 0xff] ^\n                    T4[t[(i + 3) % 4] & 0xff] ^\n                    __classPrivateFieldGet(this, _AES_Ke, \"f\")[r][i]);\n            }\n            t = a.slice();\n        }\n        // the last round is special\n        const result = new Uint8Array(16);\n        let tt = 0;\n        for (let i = 0; i < 4; i++) {\n            tt = __classPrivateFieldGet(this, _AES_Ke, \"f\")[rounds][i];\n            result[4 * i] = (S[(t[i] >> 24) & 0xff] ^ (tt >> 24)) & 0xff;\n            result[4 * i + 1] = (S[(t[(i + 1) % 4] >> 16) & 0xff] ^ (tt >> 16)) & 0xff;\n            result[4 * i + 2] = (S[(t[(i + 2) % 4] >> 8) & 0xff] ^ (tt >> 8)) & 0xff;\n            result[4 * i + 3] = (S[t[(i + 3) % 4] & 0xff] ^ tt) & 0xff;\n        }\n        return result;\n    }\n    decrypt(ciphertext) {\n        if (ciphertext.length != 16) {\n            throw new TypeError('invalid ciphertext size (must be 16 bytes)');\n        }\n        const rounds = __classPrivateFieldGet(this, _AES_Kd, \"f\").length - 1;\n        const a = [0, 0, 0, 0];\n        // convert plaintext to (ints ^ key)\n        let t = convertToInt32(ciphertext);\n        for (let i = 0; i < 4; i++) {\n            t[i] ^= __classPrivateFieldGet(this, _AES_Kd, \"f\")[0][i];\n        }\n        // apply round transforms\n        for (let r = 1; r < rounds; r++) {\n            for (let i = 0; i < 4; i++) {\n                a[i] = (T5[(t[i] >> 24) & 0xff] ^\n                    T6[(t[(i + 3) % 4] >> 16) & 0xff] ^\n                    T7[(t[(i + 2) % 4] >> 8) & 0xff] ^\n                    T8[t[(i + 1) % 4] & 0xff] ^\n                    __classPrivateFieldGet(this, _AES_Kd, \"f\")[r][i]);\n            }\n            t = a.slice();\n        }\n        // the last round is special\n        const result = new Uint8Array(16);\n        let tt = 0;\n        for (let i = 0; i < 4; i++) {\n            tt = __classPrivateFieldGet(this, _AES_Kd, \"f\")[rounds][i];\n            result[4 * i] = (Si[(t[i] >> 24) & 0xff] ^ (tt >> 24)) & 0xff;\n            result[4 * i + 1] = (Si[(t[(i + 3) % 4] >> 16) & 0xff] ^ (tt >> 16)) & 0xff;\n            result[4 * i + 2] = (Si[(t[(i + 2) % 4] >> 8) & 0xff] ^ (tt >> 8)) & 0xff;\n            result[4 * i + 3] = (Si[t[(i + 1) % 4] & 0xff] ^ tt) & 0xff;\n        }\n        return result;\n    }\n}\n_AES_key = new WeakMap(), _AES_Kd = new WeakMap(), _AES_Ke = new WeakMap();\n//# sourceMappingURL=aes.js.map","import { AES } from \"./aes.js\";\nexport class ModeOfOperation {\n    constructor(name, key, cls) {\n        if (cls && !(this instanceof cls)) {\n            throw new Error(`${name} must be instantiated with \"new\"`);\n        }\n        Object.defineProperties(this, {\n            aes: { enumerable: true, value: new AES(key) },\n            name: { enumerable: true, value: name }\n        });\n    }\n}\n//# sourceMappingURL=mode.js.map","// Cipher Block Chaining\nvar __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar _CBC_iv, _CBC_lastBlock;\nimport { ModeOfOperation } from \"./mode.js\";\nexport class CBC extends ModeOfOperation {\n    constructor(key, iv) {\n        super(\"ECC\", key, CBC);\n        _CBC_iv.set(this, void 0);\n        _CBC_lastBlock.set(this, void 0);\n        if (iv) {\n            if (iv.length % 16) {\n                throw new TypeError(\"invalid iv size (must be 16 bytes)\");\n            }\n            __classPrivateFieldSet(this, _CBC_iv, new Uint8Array(iv), \"f\");\n        }\n        else {\n            __classPrivateFieldSet(this, _CBC_iv, new Uint8Array(16), \"f\");\n        }\n        __classPrivateFieldSet(this, _CBC_lastBlock, this.iv, \"f\");\n    }\n    get iv() { return new Uint8Array(__classPrivateFieldGet(this, _CBC_iv, \"f\")); }\n    encrypt(plaintext) {\n        if (plaintext.length % 16) {\n            throw new TypeError(\"invalid plaintext size (must be multiple of 16 bytes)\");\n        }\n        const ciphertext = new Uint8Array(plaintext.length);\n        for (let i = 0; i < plaintext.length; i += 16) {\n            for (let j = 0; j < 16; j++) {\n                __classPrivateFieldGet(this, _CBC_lastBlock, \"f\")[j] ^= plaintext[i + j];\n            }\n            __classPrivateFieldSet(this, _CBC_lastBlock, this.aes.encrypt(__classPrivateFieldGet(this, _CBC_lastBlock, \"f\")), \"f\");\n            ciphertext.set(__classPrivateFieldGet(this, _CBC_lastBlock, \"f\"), i);\n        }\n        return ciphertext;\n    }\n    decrypt(ciphertext) {\n        if (ciphertext.length % 16) {\n            throw new TypeError(\"invalid ciphertext size (must be multiple of 16 bytes)\");\n        }\n        const plaintext = new Uint8Array(ciphertext.length);\n        for (let i = 0; i < ciphertext.length; i += 16) {\n            const block = this.aes.decrypt(ciphertext.subarray(i, i + 16));\n            for (let j = 0; j < 16; j++) {\n                plaintext[i + j] = block[j] ^ __classPrivateFieldGet(this, _CBC_lastBlock, \"f\")[j];\n                __classPrivateFieldGet(this, _CBC_lastBlock, \"f\")[j] = ciphertext[i + j];\n            }\n        }\n        return plaintext;\n    }\n}\n_CBC_iv = new WeakMap(), _CBC_lastBlock = new WeakMap();\n//# sourceMappingURL=mode-cbc.js.map","// Cipher Feedback\nvar __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar _CFB_instances, _CFB_iv, _CFB_shiftRegister, _CFB_shift;\nimport { ModeOfOperation } from \"./mode.js\";\nexport class CFB extends ModeOfOperation {\n    constructor(key, iv, segmentSize = 8) {\n        super(\"CFB\", key, CFB);\n        _CFB_instances.add(this);\n        _CFB_iv.set(this, void 0);\n        _CFB_shiftRegister.set(this, void 0);\n        // This library currently only handles byte-aligned segmentSize\n        if (!Number.isInteger(segmentSize) || (segmentSize % 8)) {\n            throw new TypeError(\"invalid segmentSize\");\n        }\n        Object.defineProperties(this, {\n            segmentSize: { enumerable: true, value: segmentSize }\n        });\n        if (iv) {\n            if (iv.length % 16) {\n                throw new TypeError(\"invalid iv size (must be 16 bytes)\");\n            }\n            __classPrivateFieldSet(this, _CFB_iv, new Uint8Array(iv), \"f\");\n        }\n        else {\n            __classPrivateFieldSet(this, _CFB_iv, new Uint8Array(16), \"f\");\n        }\n        __classPrivateFieldSet(this, _CFB_shiftRegister, this.iv, \"f\");\n    }\n    get iv() { return new Uint8Array(__classPrivateFieldGet(this, _CFB_iv, \"f\")); }\n    encrypt(plaintext) {\n        if (8 * plaintext.length % this.segmentSize) {\n            throw new TypeError(\"invalid plaintext size (must be multiple of segmentSize bytes)\");\n        }\n        const segmentSize = this.segmentSize / 8;\n        const ciphertext = new Uint8Array(plaintext);\n        for (let i = 0; i < ciphertext.length; i += segmentSize) {\n            const xorSegment = this.aes.encrypt(__classPrivateFieldGet(this, _CFB_shiftRegister, \"f\"));\n            for (let j = 0; j < segmentSize; j++) {\n                ciphertext[i + j] ^= xorSegment[j];\n            }\n            __classPrivateFieldGet(this, _CFB_instances, \"m\", _CFB_shift).call(this, ciphertext.subarray(i));\n        }\n        return ciphertext;\n    }\n    decrypt(ciphertext) {\n        if (8 * ciphertext.length % this.segmentSize) {\n            throw new TypeError(\"invalid ciphertext size (must be multiple of segmentSize bytes)\");\n        }\n        const segmentSize = this.segmentSize / 8;\n        const plaintext = new Uint8Array(ciphertext);\n        for (let i = 0; i < plaintext.length; i += segmentSize) {\n            const xorSegment = this.aes.encrypt(__classPrivateFieldGet(this, _CFB_shiftRegister, \"f\"));\n            for (let j = 0; j < segmentSize; j++) {\n                plaintext[i + j] ^= xorSegment[j];\n            }\n            __classPrivateFieldGet(this, _CFB_instances, \"m\", _CFB_shift).call(this, ciphertext.subarray(i));\n        }\n        return plaintext;\n    }\n}\n_CFB_iv = new WeakMap(), _CFB_shiftRegister = new WeakMap(), _CFB_instances = new WeakSet(), _CFB_shift = function _CFB_shift(data) {\n    const segmentSize = this.segmentSize / 8;\n    // Shift the register\n    __classPrivateFieldGet(this, _CFB_shiftRegister, \"f\").set(__classPrivateFieldGet(this, _CFB_shiftRegister, \"f\").subarray(segmentSize));\n    __classPrivateFieldGet(this, _CFB_shiftRegister, \"f\").set(data.subarray(0, segmentSize), 16 - segmentSize);\n};\n//# sourceMappingURL=mode-cfb.js.map","// Counter Mode\nvar __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar _CTR_remaining, _CTR_remainingIndex, _CTR_counter;\nimport { ModeOfOperation } from \"./mode.js\";\nexport class CTR extends ModeOfOperation {\n    constructor(key, initialValue) {\n        super(\"CTR\", key, CTR);\n        // Remaining bytes for the one-time pad\n        _CTR_remaining.set(this, void 0);\n        _CTR_remainingIndex.set(this, void 0);\n        // The current counter\n        _CTR_counter.set(this, void 0);\n        __classPrivateFieldSet(this, _CTR_counter, new Uint8Array(16), \"f\");\n        __classPrivateFieldGet(this, _CTR_counter, \"f\").fill(0);\n        __classPrivateFieldSet(this, _CTR_remaining, __classPrivateFieldGet(this, _CTR_counter, \"f\"), \"f\"); // This will be discarded immediately\n        __classPrivateFieldSet(this, _CTR_remainingIndex, 16, \"f\");\n        if (initialValue == null) {\n            initialValue = 1;\n        }\n        if (typeof (initialValue) === \"number\") {\n            this.setCounterValue(initialValue);\n        }\n        else {\n            this.setCounterBytes(initialValue);\n        }\n    }\n    get counter() { return new Uint8Array(__classPrivateFieldGet(this, _CTR_counter, \"f\")); }\n    setCounterValue(value) {\n        if (!Number.isInteger(value) || value < 0 || value > Number.MAX_SAFE_INTEGER) {\n            throw new TypeError(\"invalid counter initial integer value\");\n        }\n        for (let index = 15; index >= 0; --index) {\n            __classPrivateFieldGet(this, _CTR_counter, \"f\")[index] = value % 256;\n            value = Math.floor(value / 256);\n        }\n    }\n    setCounterBytes(value) {\n        if (value.length !== 16) {\n            throw new TypeError(\"invalid counter initial Uint8Array value length\");\n        }\n        __classPrivateFieldGet(this, _CTR_counter, \"f\").set(value);\n    }\n    increment() {\n        for (let i = 15; i >= 0; i--) {\n            if (__classPrivateFieldGet(this, _CTR_counter, \"f\")[i] === 255) {\n                __classPrivateFieldGet(this, _CTR_counter, \"f\")[i] = 0;\n            }\n            else {\n                __classPrivateFieldGet(this, _CTR_counter, \"f\")[i]++;\n                break;\n            }\n        }\n    }\n    encrypt(plaintext) {\n        var _a, _b;\n        const crypttext = new Uint8Array(plaintext);\n        for (let i = 0; i < crypttext.length; i++) {\n            if (__classPrivateFieldGet(this, _CTR_remainingIndex, \"f\") === 16) {\n                __classPrivateFieldSet(this, _CTR_remaining, this.aes.encrypt(__classPrivateFieldGet(this, _CTR_counter, \"f\")), \"f\");\n                __classPrivateFieldSet(this, _CTR_remainingIndex, 0, \"f\");\n                this.increment();\n            }\n            crypttext[i] ^= __classPrivateFieldGet(this, _CTR_remaining, \"f\")[__classPrivateFieldSet(this, _CTR_remainingIndex, (_b = __classPrivateFieldGet(this, _CTR_remainingIndex, \"f\"), _a = _b++, _b), \"f\"), _a];\n        }\n        return crypttext;\n    }\n    decrypt(ciphertext) {\n        return this.encrypt(ciphertext);\n    }\n}\n_CTR_remaining = new WeakMap(), _CTR_remainingIndex = new WeakMap(), _CTR_counter = new WeakMap();\n//# sourceMappingURL=mode-ctr.js.map","// Output Feedback\nvar __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar _OFB_iv, _OFB_lastPrecipher, _OFB_lastPrecipherIndex;\nimport { ModeOfOperation } from \"./mode.js\";\nexport class OFB extends ModeOfOperation {\n    constructor(key, iv) {\n        super(\"OFB\", key, OFB);\n        _OFB_iv.set(this, void 0);\n        _OFB_lastPrecipher.set(this, void 0);\n        _OFB_lastPrecipherIndex.set(this, void 0);\n        if (iv) {\n            if (iv.length % 16) {\n                throw new TypeError(\"invalid iv size (must be 16 bytes)\");\n            }\n            __classPrivateFieldSet(this, _OFB_iv, new Uint8Array(iv), \"f\");\n        }\n        else {\n            __classPrivateFieldSet(this, _OFB_iv, new Uint8Array(16), \"f\");\n        }\n        __classPrivateFieldSet(this, _OFB_lastPrecipher, this.iv, \"f\");\n        __classPrivateFieldSet(this, _OFB_lastPrecipherIndex, 16, \"f\");\n    }\n    get iv() { return new Uint8Array(__classPrivateFieldGet(this, _OFB_iv, \"f\")); }\n    encrypt(plaintext) {\n        var _a, _b;\n        if (plaintext.length % 16) {\n            throw new TypeError(\"invalid plaintext size (must be multiple of 16 bytes)\");\n        }\n        const ciphertext = new Uint8Array(plaintext);\n        for (let i = 0; i < ciphertext.length; i++) {\n            if (__classPrivateFieldGet(this, _OFB_lastPrecipherIndex, \"f\") === 16) {\n                __classPrivateFieldSet(this, _OFB_lastPrecipher, this.aes.encrypt(__classPrivateFieldGet(this, _OFB_lastPrecipher, \"f\")), \"f\");\n                __classPrivateFieldSet(this, _OFB_lastPrecipherIndex, 0, \"f\");\n            }\n            ciphertext[i] ^= __classPrivateFieldGet(this, _OFB_lastPrecipher, \"f\")[__classPrivateFieldSet(this, _OFB_lastPrecipherIndex, (_b = __classPrivateFieldGet(this, _OFB_lastPrecipherIndex, \"f\"), _a = _b++, _b), \"f\"), _a];\n        }\n        return ciphertext;\n    }\n    decrypt(ciphertext) {\n        if (ciphertext.length % 16) {\n            throw new TypeError(\"invalid ciphertext size (must be multiple of 16 bytes)\");\n        }\n        return this.encrypt(ciphertext);\n    }\n}\n_OFB_iv = new WeakMap(), _OFB_lastPrecipher = new WeakMap(), _OFB_lastPrecipherIndex = new WeakMap();\n//# sourceMappingURL=mode-ofb.js.map","import { number as assertNumber } from './_assert.js';\nimport { sha256 } from './sha256.js';\nimport { pbkdf2 } from './pbkdf2.js';\nimport { asyncLoop, checkOpts, u32 } from './utils.js';\n// RFC 7914 Scrypt KDF\n// Left rotate for uint32\nconst rotl = (a, b) => (a << b) | (a >>> (32 - b));\n// The main Scrypt loop: uses Salsa extensively.\n// Six versions of the function were tried, this is the fastest one.\n// prettier-ignore\nfunction XorAndSalsa(prev, pi, input, ii, out, oi) {\n    // Based on https://cr.yp.to/salsa20.html\n    // Xor blocks\n    let y00 = prev[pi++] ^ input[ii++], y01 = prev[pi++] ^ input[ii++];\n    let y02 = prev[pi++] ^ input[ii++], y03 = prev[pi++] ^ input[ii++];\n    let y04 = prev[pi++] ^ input[ii++], y05 = prev[pi++] ^ input[ii++];\n    let y06 = prev[pi++] ^ input[ii++], y07 = prev[pi++] ^ input[ii++];\n    let y08 = prev[pi++] ^ input[ii++], y09 = prev[pi++] ^ input[ii++];\n    let y10 = prev[pi++] ^ input[ii++], y11 = prev[pi++] ^ input[ii++];\n    let y12 = prev[pi++] ^ input[ii++], y13 = prev[pi++] ^ input[ii++];\n    let y14 = prev[pi++] ^ input[ii++], y15 = prev[pi++] ^ input[ii++];\n    // Save state to temporary variables (salsa)\n    let x00 = y00, x01 = y01, x02 = y02, x03 = y03, x04 = y04, x05 = y05, x06 = y06, x07 = y07, x08 = y08, x09 = y09, x10 = y10, x11 = y11, x12 = y12, x13 = y13, x14 = y14, x15 = y15;\n    // Main loop (salsa)\n    for (let i = 0; i < 8; i += 2) {\n        x04 ^= rotl(x00 + x12 | 0, 7);\n        x08 ^= rotl(x04 + x00 | 0, 9);\n        x12 ^= rotl(x08 + x04 | 0, 13);\n        x00 ^= rotl(x12 + x08 | 0, 18);\n        x09 ^= rotl(x05 + x01 | 0, 7);\n        x13 ^= rotl(x09 + x05 | 0, 9);\n        x01 ^= rotl(x13 + x09 | 0, 13);\n        x05 ^= rotl(x01 + x13 | 0, 18);\n        x14 ^= rotl(x10 + x06 | 0, 7);\n        x02 ^= rotl(x14 + x10 | 0, 9);\n        x06 ^= rotl(x02 + x14 | 0, 13);\n        x10 ^= rotl(x06 + x02 | 0, 18);\n        x03 ^= rotl(x15 + x11 | 0, 7);\n        x07 ^= rotl(x03 + x15 | 0, 9);\n        x11 ^= rotl(x07 + x03 | 0, 13);\n        x15 ^= rotl(x11 + x07 | 0, 18);\n        x01 ^= rotl(x00 + x03 | 0, 7);\n        x02 ^= rotl(x01 + x00 | 0, 9);\n        x03 ^= rotl(x02 + x01 | 0, 13);\n        x00 ^= rotl(x03 + x02 | 0, 18);\n        x06 ^= rotl(x05 + x04 | 0, 7);\n        x07 ^= rotl(x06 + x05 | 0, 9);\n        x04 ^= rotl(x07 + x06 | 0, 13);\n        x05 ^= rotl(x04 + x07 | 0, 18);\n        x11 ^= rotl(x10 + x09 | 0, 7);\n        x08 ^= rotl(x11 + x10 | 0, 9);\n        x09 ^= rotl(x08 + x11 | 0, 13);\n        x10 ^= rotl(x09 + x08 | 0, 18);\n        x12 ^= rotl(x15 + x14 | 0, 7);\n        x13 ^= rotl(x12 + x15 | 0, 9);\n        x14 ^= rotl(x13 + x12 | 0, 13);\n        x15 ^= rotl(x14 + x13 | 0, 18);\n    }\n    // Write output (salsa)\n    out[oi++] = (y00 + x00) | 0;\n    out[oi++] = (y01 + x01) | 0;\n    out[oi++] = (y02 + x02) | 0;\n    out[oi++] = (y03 + x03) | 0;\n    out[oi++] = (y04 + x04) | 0;\n    out[oi++] = (y05 + x05) | 0;\n    out[oi++] = (y06 + x06) | 0;\n    out[oi++] = (y07 + x07) | 0;\n    out[oi++] = (y08 + x08) | 0;\n    out[oi++] = (y09 + x09) | 0;\n    out[oi++] = (y10 + x10) | 0;\n    out[oi++] = (y11 + x11) | 0;\n    out[oi++] = (y12 + x12) | 0;\n    out[oi++] = (y13 + x13) | 0;\n    out[oi++] = (y14 + x14) | 0;\n    out[oi++] = (y15 + x15) | 0;\n}\nfunction BlockMix(input, ii, out, oi, r) {\n    // The block B is r 128-byte chunks (which is equivalent of 2r 64-byte chunks)\n    let head = oi + 0;\n    let tail = oi + 16 * r;\n    for (let i = 0; i < 16; i++)\n        out[tail + i] = input[ii + (2 * r - 1) * 16 + i]; // X ← B[2r−1]\n    for (let i = 0; i < r; i++, head += 16, ii += 16) {\n        // We write odd & even Yi at same time. Even: 0bXXXXX0 Odd:  0bXXXXX1\n        XorAndSalsa(out, tail, input, ii, out, head); // head[i] = Salsa(blockIn[2*i] ^ tail[i-1])\n        if (i > 0)\n            tail += 16; // First iteration overwrites tmp value in tail\n        XorAndSalsa(out, head, input, (ii += 16), out, tail); // tail[i] = Salsa(blockIn[2*i+1] ^ head[i])\n    }\n}\n// Common prologue and epilogue for sync/async functions\nfunction scryptInit(password, salt, _opts) {\n    // Maxmem - 1GB+1KB by default\n    const opts = checkOpts({\n        dkLen: 32,\n        asyncTick: 10,\n        maxmem: 1024 ** 3 + 1024,\n    }, _opts);\n    const { N, r, p, dkLen, asyncTick, maxmem, onProgress } = opts;\n    assertNumber(N);\n    assertNumber(r);\n    assertNumber(p);\n    assertNumber(dkLen);\n    assertNumber(asyncTick);\n    assertNumber(maxmem);\n    if (onProgress !== undefined && typeof onProgress !== 'function')\n        throw new Error('progressCb should be function');\n    const blockSize = 128 * r;\n    const blockSize32 = blockSize / 4;\n    if (N <= 1 || (N & (N - 1)) !== 0 || N >= 2 ** (blockSize / 8) || N > 2 ** 32) {\n        // NOTE: we limit N to be less than 2**32 because of 32 bit variant of Integrify function\n        // There is no JS engines that allows alocate more than 4GB per single Uint8Array for now, but can change in future.\n        throw new Error('Scrypt: N must be larger than 1, a power of 2, less than 2^(128 * r / 8) and less than 2^32');\n    }\n    if (p < 0 || p > ((2 ** 32 - 1) * 32) / blockSize) {\n        throw new Error('Scrypt: p must be a positive integer less than or equal to ((2^32 - 1) * 32) / (128 * r)');\n    }\n    if (dkLen < 0 || dkLen > (2 ** 32 - 1) * 32) {\n        throw new Error('Scrypt: dkLen should be positive integer less than or equal to (2^32 - 1) * 32');\n    }\n    const memUsed = blockSize * (N + p);\n    if (memUsed > maxmem) {\n        throw new Error(`Scrypt: parameters too large, ${memUsed} (128 * r * (N + p)) > ${maxmem} (maxmem)`);\n    }\n    // [B0...Bp−1] ← PBKDF2HMAC-SHA256(Passphrase, Salt, 1, blockSize*ParallelizationFactor)\n    // Since it has only one iteration there is no reason to use async variant\n    const B = pbkdf2(sha256, password, salt, { c: 1, dkLen: blockSize * p });\n    const B32 = u32(B);\n    // Re-used between parallel iterations. Array(iterations) of B\n    const V = u32(new Uint8Array(blockSize * N));\n    const tmp = u32(new Uint8Array(blockSize));\n    let blockMixCb = () => { };\n    if (onProgress) {\n        const totalBlockMix = 2 * N * p;\n        // Invoke callback if progress changes from 10.01 to 10.02\n        // Allows to draw smooth progress bar on up to 8K screen\n        const callbackPer = Math.max(Math.floor(totalBlockMix / 10000), 1);\n        let blockMixCnt = 0;\n        blockMixCb = () => {\n            blockMixCnt++;\n            if (onProgress && (!(blockMixCnt % callbackPer) || blockMixCnt === totalBlockMix))\n                onProgress(blockMixCnt / totalBlockMix);\n        };\n    }\n    return { N, r, p, dkLen, blockSize32, V, B32, B, tmp, blockMixCb, asyncTick };\n}\nfunction scryptOutput(password, dkLen, B, V, tmp) {\n    const res = pbkdf2(sha256, password, B, { c: 1, dkLen });\n    B.fill(0);\n    V.fill(0);\n    tmp.fill(0);\n    return res;\n}\n/**\n * Scrypt KDF from RFC 7914.\n * @param password - pass\n * @param salt - salt\n * @param opts - parameters\n * - `N` is cpu/mem work factor (power of 2 e.g. 2**18)\n * - `r` is block size (8 is common), fine-tunes sequential memory read size and performance\n * - `p` is parallelization factor (1 is common)\n * - `dkLen` is output key length in bytes e.g. 32.\n * - `asyncTick` - (default: 10) max time in ms for which async function can block execution\n * - `maxmem` - (default: `1024 ** 3 + 1024` aka 1GB+1KB). A limit that the app could use for scrypt\n * - `onProgress` - callback function that would be executed for progress report\n * @returns Derived key\n */\nexport function scrypt(password, salt, opts) {\n    const { N, r, p, dkLen, blockSize32, V, B32, B, tmp, blockMixCb } = scryptInit(password, salt, opts);\n    for (let pi = 0; pi < p; pi++) {\n        const Pi = blockSize32 * pi;\n        for (let i = 0; i < blockSize32; i++)\n            V[i] = B32[Pi + i]; // V[0] = B[i]\n        for (let i = 0, pos = 0; i < N - 1; i++) {\n            BlockMix(V, pos, V, (pos += blockSize32), r); // V[i] = BlockMix(V[i-1]);\n            blockMixCb();\n        }\n        BlockMix(V, (N - 1) * blockSize32, B32, Pi, r); // Process last element\n        blockMixCb();\n        for (let i = 0; i < N; i++) {\n            // First u32 of the last 64-byte block (u32 is LE)\n            const j = B32[Pi + blockSize32 - 16] % N; // j = Integrify(X) % iterations\n            for (let k = 0; k < blockSize32; k++)\n                tmp[k] = B32[Pi + k] ^ V[j * blockSize32 + k]; // tmp = B ^ V[j]\n            BlockMix(tmp, 0, B32, Pi, r); // B = BlockMix(B ^ V[j])\n            blockMixCb();\n        }\n    }\n    return scryptOutput(password, dkLen, B, V, tmp);\n}\n/**\n * Scrypt KDF from RFC 7914.\n */\nexport async function scryptAsync(password, salt, opts) {\n    const { N, r, p, dkLen, blockSize32, V, B32, B, tmp, blockMixCb, asyncTick } = scryptInit(password, salt, opts);\n    for (let pi = 0; pi < p; pi++) {\n        const Pi = blockSize32 * pi;\n        for (let i = 0; i < blockSize32; i++)\n            V[i] = B32[Pi + i]; // V[0] = B[i]\n        let pos = 0;\n        await asyncLoop(N - 1, asyncTick, () => {\n            BlockMix(V, pos, V, (pos += blockSize32), r); // V[i] = BlockMix(V[i-1]);\n            blockMixCb();\n        });\n        BlockMix(V, (N - 1) * blockSize32, B32, Pi, r); // Process last element\n        blockMixCb();\n        await asyncLoop(N, asyncTick, () => {\n            // First u32 of the last 64-byte block (u32 is LE)\n            const j = B32[Pi + blockSize32 - 16] % N; // j = Integrify(X) % iterations\n            for (let k = 0; k < blockSize32; k++)\n                tmp[k] = B32[Pi + k] ^ V[j * blockSize32 + k]; // tmp = B ^ V[j]\n            BlockMix(tmp, 0, B32, Pi, r); // B = BlockMix(B ^ V[j])\n            blockMixCb();\n        });\n    }\n    return scryptOutput(password, dkLen, B, V, tmp);\n}\n//# sourceMappingURL=scrypt.js.map","import { scrypt as _nobleSync, scryptAsync as _nobleAsync } from \"@noble/hashes/scrypt\";\nimport { getBytes, hexlify as H } from \"../utils/index.js\";\nlet lockedSync = false, lockedAsync = false;\nconst _scryptAsync = async function (passwd, salt, N, r, p, dkLen, onProgress) {\n    return await _nobleAsync(passwd, salt, { N, r, p, dkLen, onProgress });\n};\nconst _scryptSync = function (passwd, salt, N, r, p, dkLen) {\n    return _nobleSync(passwd, salt, { N, r, p, dkLen });\n};\nlet __scryptAsync = _scryptAsync;\nlet __scryptSync = _scryptSync;\n/**\n *  The [[link-wiki-scrypt]] uses a memory and cpu hard method of\n *  derivation to increase the resource cost to brute-force a password\n *  for a given key.\n *\n *  This means this algorithm is intentionally slow, and can be tuned to\n *  become slower. As computation and memory speed improve over time,\n *  increasing the difficulty maintains the cost of an attacker.\n *\n *  For example, if a target time of 5 seconds is used, a legitimate user\n *  which knows their password requires only 5 seconds to unlock their\n *  account. A 6 character password has 68 billion possibilities, which\n *  would require an attacker to invest over 10,000 years of CPU time. This\n *  is of course a crude example (as password generally aren't random),\n *  but demonstrates to value of imposing large costs to decryption.\n *\n *  For this reason, if building a UI which involved decrypting or\n *  encrypting datsa using scrypt, it is recommended to use a\n *  [[ProgressCallback]] (as event short periods can seem lik an eternity\n *  if the UI freezes). Including the phrase //\"decrypting\"// in the UI\n *  can also help, assuring the user their waiting is for a good reason.\n *\n *  @_docloc: api/crypto:Passwords\n *\n *  @example:\n *    // The password must be converted to bytes, and it is generally\n *    // best practices to ensure the string has been normalized. Many\n *    // formats explicitly indicate the normalization form to use.\n *    password = \"hello\"\n *    passwordBytes = toUtf8Bytes(password, \"NFKC\")\n *\n *    salt = id(\"some-salt\")\n *\n *    // Compute the scrypt\n *    scrypt(passwordBytes, salt, 1024, 8, 1, 16)\n *    //_result:\n */\nexport async function scrypt(_passwd, _salt, N, r, p, dkLen, progress) {\n    const passwd = getBytes(_passwd, \"passwd\");\n    const salt = getBytes(_salt, \"salt\");\n    return H(await __scryptAsync(passwd, salt, N, r, p, dkLen, progress));\n}\nscrypt._ = _scryptAsync;\nscrypt.lock = function () { lockedAsync = true; };\nscrypt.register = function (func) {\n    if (lockedAsync) {\n        throw new Error(\"scrypt is locked\");\n    }\n    __scryptAsync = func;\n};\nObject.freeze(scrypt);\n/**\n *  Provides a synchronous variant of [[scrypt]].\n *\n *  This will completely lock up and freeze the UI in a browser and will\n *  prevent any event loop from progressing. For this reason, it is\n *  preferred to use the [async variant](scrypt).\n *\n *  @_docloc: api/crypto:Passwords\n *\n *  @example:\n *    // The password must be converted to bytes, and it is generally\n *    // best practices to ensure the string has been normalized. Many\n *    // formats explicitly indicate the normalization form to use.\n *    password = \"hello\"\n *    passwordBytes = toUtf8Bytes(password, \"NFKC\")\n *\n *    salt = id(\"some-salt\")\n *\n *    // Compute the scrypt\n *    scryptSync(passwordBytes, salt, 1024, 8, 1, 16)\n *    //_result:\n */\nexport function scryptSync(_passwd, _salt, N, r, p, dkLen) {\n    const passwd = getBytes(_passwd, \"passwd\");\n    const salt = getBytes(_salt, \"salt\");\n    return H(__scryptSync(passwd, salt, N, r, p, dkLen));\n}\nscryptSync._ = _scryptSync;\nscryptSync.lock = function () { lockedSync = true; };\nscryptSync.register = function (func) {\n    if (lockedSync) {\n        throw new Error(\"scryptSync is locked\");\n    }\n    __scryptSync = func;\n};\nObject.freeze(scryptSync);\n//# sourceMappingURL=scrypt.js.map","/**\n *  Explain UUID and link to RFC here.\n *\n *  @_subsection: api/utils:UUID  [about-uuid]\n */\nimport { getBytes, hexlify } from \"./data.js\";\n/**\n *  Returns the version 4 [[link-uuid]] for the %%randomBytes%%.\n *\n *  @see: https://www.ietf.org/rfc/rfc4122.txt (Section 4.4)\n */\nexport function uuidV4(randomBytes) {\n    const bytes = getBytes(randomBytes, \"randomBytes\");\n    // Section: 4.1.3:\n    // - time_hi_and_version[12:16] = 0b0100\n    bytes[6] = (bytes[6] & 0x0f) | 0x40;\n    // Section 4.4\n    // - clock_seq_hi_and_reserved[6] = 0b0\n    // - clock_seq_hi_and_reserved[7] = 0b1\n    bytes[8] = (bytes[8] & 0x3f) | 0x80;\n    const value = hexlify(bytes);\n    return [\n        value.substring(2, 10),\n        value.substring(10, 14),\n        value.substring(14, 18),\n        value.substring(18, 22),\n        value.substring(22, 34),\n    ].join(\"-\");\n}\n//# sourceMappingURL=uuid.js.map","/**\n *  @_ignore\n */\nimport { getBytesCopy, assertArgument, toUtf8Bytes } from \"../utils/index.js\";\nexport function looseArrayify(hexString) {\n    if (typeof (hexString) === \"string\" && !hexString.startsWith(\"0x\")) {\n        hexString = \"0x\" + hexString;\n    }\n    return getBytesCopy(hexString);\n}\nexport function zpad(value, length) {\n    value = String(value);\n    while (value.length < length) {\n        value = '0' + value;\n    }\n    return value;\n}\nexport function getPassword(password) {\n    if (typeof (password) === 'string') {\n        return toUtf8Bytes(password, \"NFKC\");\n    }\n    return getBytesCopy(password);\n}\nexport function spelunk(object, _path) {\n    const match = _path.match(/^([a-z0-9$_.-]*)(:([a-z]+))?(!)?$/i);\n    assertArgument(match != null, \"invalid path\", \"path\", _path);\n    const path = match[1];\n    const type = match[3];\n    const reqd = (match[4] === \"!\");\n    let cur = object;\n    for (const comp of path.toLowerCase().split('.')) {\n        // Search for a child object with a case-insensitive matching key\n        if (Array.isArray(cur)) {\n            if (!comp.match(/^[0-9]+$/)) {\n                break;\n            }\n            cur = cur[parseInt(comp)];\n        }\n        else if (typeof (cur) === \"object\") {\n            let found = null;\n            for (const key in cur) {\n                if (key.toLowerCase() === comp) {\n                    found = cur[key];\n                    break;\n                }\n            }\n            cur = found;\n        }\n        else {\n            cur = null;\n        }\n        if (cur == null) {\n            break;\n        }\n    }\n    assertArgument(!reqd || cur != null, \"missing required value\", \"path\", path);\n    if (type && cur != null) {\n        if (type === \"int\") {\n            if (typeof (cur) === \"string\" && cur.match(/^-?[0-9]+$/)) {\n                return parseInt(cur);\n            }\n            else if (Number.isSafeInteger(cur)) {\n                return cur;\n            }\n        }\n        if (type === \"number\") {\n            if (typeof (cur) === \"string\" && cur.match(/^-?[0-9.]*$/)) {\n                return parseFloat(cur);\n            }\n        }\n        if (type === \"data\") {\n            if (typeof (cur) === \"string\") {\n                return looseArrayify(cur);\n            }\n        }\n        if (type === \"array\" && Array.isArray(cur)) {\n            return cur;\n        }\n        if (type === typeof (cur)) {\n            return cur;\n        }\n        assertArgument(false, `wrong type found for ${type} `, \"path\", path);\n    }\n    return cur;\n}\n/*\nexport function follow(object: any, path: string): null | string {\n    let currentChild = object;\n\n    for (const comp of path.toLowerCase().split('/')) {\n\n        // Search for a child object with a case-insensitive matching key\n        let matchingChild = null;\n        for (const key in currentChild) {\n             if (key.toLowerCase() === comp) {\n                 matchingChild = currentChild[key];\n                 break;\n             }\n        }\n\n        if (matchingChild === null) { return null; }\n\n        currentChild = matchingChild;\n    }\n\n    return currentChild;\n}\n\n// \"path/to/something:type!\"\nexport function followRequired(data: any, path: string): string {\n    const value = follow(data, path);\n    if (value != null) { return value; }\n    return logger.throwArgumentError(\"invalid value\", `data:${ path }`,\n    JSON.stringify(data));\n}\n*/\n// See: https://www.ietf.org/rfc/rfc4122.txt (Section 4.4)\n/*\nexport function uuidV4(randomBytes: BytesLike): string {\n    const bytes = getBytes(randomBytes, \"randomBytes\");\n\n    // Section: 4.1.3:\n    // - time_hi_and_version[12:16] = 0b0100\n    bytes[6] = (bytes[6] & 0x0f) | 0x40;\n\n    // Section 4.4\n    // - clock_seq_hi_and_reserved[6] = 0b0\n    // - clock_seq_hi_and_reserved[7] = 0b1\n    bytes[8] = (bytes[8] & 0x3f) | 0x80;\n\n    const value = hexlify(bytes);\n\n    return [\n       value.substring(2, 10),\n       value.substring(10, 14),\n       value.substring(14, 18),\n       value.substring(18, 22),\n       value.substring(22, 34),\n    ].join(\"-\");\n}\n*/\n//# sourceMappingURL=utils.js.map","/**\n *  The JSON Wallet formats allow a simple way to store the private\n *  keys needed in Ethereum along with related information and allows\n *  for extensible forms of encryption.\n *\n *  These utilities facilitate decrypting and encrypting the most common\n *  JSON Wallet formats.\n *\n *  @_subsection: api/wallet:JSON Wallets  [json-wallets]\n */\nimport { CTR } from \"aes-js\";\nimport { getAddress } from \"../address/index.js\";\nimport { keccak256, pbkdf2, randomBytes, scrypt, scryptSync } from \"../crypto/index.js\";\nimport { computeAddress } from \"../transaction/index.js\";\nimport { concat, getBytes, hexlify, uuidV4, assert, assertArgument } from \"../utils/index.js\";\nimport { getPassword, spelunk, zpad } from \"./utils.js\";\nimport { version } from \"../_version.js\";\nconst defaultPath = \"m/44'/60'/0'/0/0\";\n/**\n *  Returns true if %%json%% is a valid JSON Keystore Wallet.\n */\nexport function isKeystoreJson(json) {\n    try {\n        const data = JSON.parse(json);\n        const version = ((data.version != null) ? parseInt(data.version) : 0);\n        if (version === 3) {\n            return true;\n        }\n    }\n    catch (error) { }\n    return false;\n}\nfunction decrypt(data, key, ciphertext) {\n    const cipher = spelunk(data, \"crypto.cipher:string\");\n    if (cipher === \"aes-128-ctr\") {\n        const iv = spelunk(data, \"crypto.cipherparams.iv:data!\");\n        const aesCtr = new CTR(key, iv);\n        return hexlify(aesCtr.decrypt(ciphertext));\n    }\n    assert(false, \"unsupported cipher\", \"UNSUPPORTED_OPERATION\", {\n        operation: \"decrypt\"\n    });\n}\nfunction getAccount(data, _key) {\n    const key = getBytes(_key);\n    const ciphertext = spelunk(data, \"crypto.ciphertext:data!\");\n    const computedMAC = hexlify(keccak256(concat([key.slice(16, 32), ciphertext]))).substring(2);\n    assertArgument(computedMAC === spelunk(data, \"crypto.mac:string!\").toLowerCase(), \"incorrect password\", \"password\", \"[ REDACTED ]\");\n    const privateKey = decrypt(data, key.slice(0, 16), ciphertext);\n    const address = computeAddress(privateKey);\n    if (data.address) {\n        let check = data.address.toLowerCase();\n        if (!check.startsWith(\"0x\")) {\n            check = \"0x\" + check;\n        }\n        assertArgument(getAddress(check) === address, \"keystore address/privateKey mismatch\", \"address\", data.address);\n    }\n    const account = { address, privateKey };\n    // Version 0.1 x-ethers metadata must contain an encrypted mnemonic phrase\n    const version = spelunk(data, \"x-ethers.version:string\");\n    if (version === \"0.1\") {\n        const mnemonicKey = key.slice(32, 64);\n        const mnemonicCiphertext = spelunk(data, \"x-ethers.mnemonicCiphertext:data!\");\n        const mnemonicIv = spelunk(data, \"x-ethers.mnemonicCounter:data!\");\n        const mnemonicAesCtr = new CTR(mnemonicKey, mnemonicIv);\n        account.mnemonic = {\n            path: (spelunk(data, \"x-ethers.path:string\") || defaultPath),\n            locale: (spelunk(data, \"x-ethers.locale:string\") || \"en\"),\n            entropy: hexlify(getBytes(mnemonicAesCtr.decrypt(mnemonicCiphertext)))\n        };\n    }\n    return account;\n}\nfunction getDecryptKdfParams(data) {\n    const kdf = spelunk(data, \"crypto.kdf:string\");\n    if (kdf && typeof (kdf) === \"string\") {\n        if (kdf.toLowerCase() === \"scrypt\") {\n            const salt = spelunk(data, \"crypto.kdfparams.salt:data!\");\n            const N = spelunk(data, \"crypto.kdfparams.n:int!\");\n            const r = spelunk(data, \"crypto.kdfparams.r:int!\");\n            const p = spelunk(data, \"crypto.kdfparams.p:int!\");\n            // Make sure N is a power of 2\n            assertArgument(N > 0 && (N & (N - 1)) === 0, \"invalid kdf.N\", \"kdf.N\", N);\n            assertArgument(r > 0 && p > 0, \"invalid kdf\", \"kdf\", kdf);\n            const dkLen = spelunk(data, \"crypto.kdfparams.dklen:int!\");\n            assertArgument(dkLen === 32, \"invalid kdf.dklen\", \"kdf.dflen\", dkLen);\n            return { name: \"scrypt\", salt, N, r, p, dkLen: 64 };\n        }\n        else if (kdf.toLowerCase() === \"pbkdf2\") {\n            const salt = spelunk(data, \"crypto.kdfparams.salt:data!\");\n            const prf = spelunk(data, \"crypto.kdfparams.prf:string!\");\n            const algorithm = prf.split(\"-\").pop();\n            assertArgument(algorithm === \"sha256\" || algorithm === \"sha512\", \"invalid kdf.pdf\", \"kdf.pdf\", prf);\n            const count = spelunk(data, \"crypto.kdfparams.c:int!\");\n            const dkLen = spelunk(data, \"crypto.kdfparams.dklen:int!\");\n            assertArgument(dkLen === 32, \"invalid kdf.dklen\", \"kdf.dklen\", dkLen);\n            return { name: \"pbkdf2\", salt, count, dkLen, algorithm };\n        }\n    }\n    assertArgument(false, \"unsupported key-derivation function\", \"kdf\", kdf);\n}\n/**\n *  Returns the account details for the JSON Keystore Wallet %%json%%\n *  using %%password%%.\n *\n *  It is preferred to use the [async version](decryptKeystoreJson)\n *  instead, which allows a [[ProgressCallback]] to keep the user informed\n *  as to the decryption status.\n *\n *  This method will block the event loop (freezing all UI) until decryption\n *  is complete, which can take quite some time, depending on the wallet\n *  paramters and platform.\n */\nexport function decryptKeystoreJsonSync(json, _password) {\n    const data = JSON.parse(json);\n    const password = getPassword(_password);\n    const params = getDecryptKdfParams(data);\n    if (params.name === \"pbkdf2\") {\n        const { salt, count, dkLen, algorithm } = params;\n        const key = pbkdf2(password, salt, count, dkLen, algorithm);\n        return getAccount(data, key);\n    }\n    assert(params.name === \"scrypt\", \"cannot be reached\", \"UNKNOWN_ERROR\", { params });\n    const { salt, N, r, p, dkLen } = params;\n    const key = scryptSync(password, salt, N, r, p, dkLen);\n    return getAccount(data, key);\n}\nfunction stall(duration) {\n    return new Promise((resolve) => { setTimeout(() => { resolve(); }, duration); });\n}\n/**\n *  Resolves to the decrypted JSON Keystore Wallet %%json%% using the\n *  %%password%%.\n *\n *  If provided, %%progress%% will be called periodically during the\n *  decrpytion to provide feedback, and if the function returns\n *  ``false`` will halt decryption.\n *\n *  The %%progressCallback%% will **always** receive ``0`` before\n *  decryption begins and ``1`` when complete.\n */\nexport async function decryptKeystoreJson(json, _password, progress) {\n    const data = JSON.parse(json);\n    const password = getPassword(_password);\n    const params = getDecryptKdfParams(data);\n    if (params.name === \"pbkdf2\") {\n        if (progress) {\n            progress(0);\n            await stall(0);\n        }\n        const { salt, count, dkLen, algorithm } = params;\n        const key = pbkdf2(password, salt, count, dkLen, algorithm);\n        if (progress) {\n            progress(1);\n            await stall(0);\n        }\n        return getAccount(data, key);\n    }\n    assert(params.name === \"scrypt\", \"cannot be reached\", \"UNKNOWN_ERROR\", { params });\n    const { salt, N, r, p, dkLen } = params;\n    const key = await scrypt(password, salt, N, r, p, dkLen, progress);\n    return getAccount(data, key);\n}\nfunction getEncryptKdfParams(options) {\n    // Check/generate the salt\n    const salt = (options.salt != null) ? getBytes(options.salt, \"options.salt\") : randomBytes(32);\n    // Override the scrypt password-based key derivation function parameters\n    let N = (1 << 17), r = 8, p = 1;\n    if (options.scrypt) {\n        if (options.scrypt.N) {\n            N = options.scrypt.N;\n        }\n        if (options.scrypt.r) {\n            r = options.scrypt.r;\n        }\n        if (options.scrypt.p) {\n            p = options.scrypt.p;\n        }\n    }\n    assertArgument(typeof (N) === \"number\" && N > 0 && Number.isSafeInteger(N) && (BigInt(N) & BigInt(N - 1)) === BigInt(0), \"invalid scrypt N parameter\", \"options.N\", N);\n    assertArgument(typeof (r) === \"number\" && r > 0 && Number.isSafeInteger(r), \"invalid scrypt r parameter\", \"options.r\", r);\n    assertArgument(typeof (p) === \"number\" && p > 0 && Number.isSafeInteger(p), \"invalid scrypt p parameter\", \"options.p\", p);\n    return { name: \"scrypt\", dkLen: 32, salt, N, r, p };\n}\nfunction _encryptKeystore(key, kdf, account, options) {\n    const privateKey = getBytes(account.privateKey, \"privateKey\");\n    // Override initialization vector\n    const iv = (options.iv != null) ? getBytes(options.iv, \"options.iv\") : randomBytes(16);\n    assertArgument(iv.length === 16, \"invalid options.iv length\", \"options.iv\", options.iv);\n    // Override the uuid\n    const uuidRandom = (options.uuid != null) ? getBytes(options.uuid, \"options.uuid\") : randomBytes(16);\n    assertArgument(uuidRandom.length === 16, \"invalid options.uuid length\", \"options.uuid\", options.iv);\n    // This will be used to encrypt the wallet (as per Web3 secret storage)\n    // - 32 bytes   As normal for the Web3 secret storage (derivedKey, macPrefix)\n    // - 32 bytes   AES key to encrypt mnemonic with (required here to be Ethers Wallet)\n    const derivedKey = key.slice(0, 16);\n    const macPrefix = key.slice(16, 32);\n    // Encrypt the private key\n    const aesCtr = new CTR(derivedKey, iv);\n    const ciphertext = getBytes(aesCtr.encrypt(privateKey));\n    // Compute the message authentication code, used to check the password\n    const mac = keccak256(concat([macPrefix, ciphertext]));\n    // See: https://github.com/ethereum/wiki/wiki/Web3-Secret-Storage-Definition\n    const data = {\n        address: account.address.substring(2).toLowerCase(),\n        id: uuidV4(uuidRandom),\n        version: 3,\n        Crypto: {\n            cipher: \"aes-128-ctr\",\n            cipherparams: {\n                iv: hexlify(iv).substring(2),\n            },\n            ciphertext: hexlify(ciphertext).substring(2),\n            kdf: \"scrypt\",\n            kdfparams: {\n                salt: hexlify(kdf.salt).substring(2),\n                n: kdf.N,\n                dklen: 32,\n                p: kdf.p,\n                r: kdf.r\n            },\n            mac: mac.substring(2)\n        }\n    };\n    // If we have a mnemonic, encrypt it into the JSON wallet\n    if (account.mnemonic) {\n        const client = (options.client != null) ? options.client : `ethers/${version}`;\n        const path = account.mnemonic.path || defaultPath;\n        const locale = account.mnemonic.locale || \"en\";\n        const mnemonicKey = key.slice(32, 64);\n        const entropy = getBytes(account.mnemonic.entropy, \"account.mnemonic.entropy\");\n        const mnemonicIv = randomBytes(16);\n        const mnemonicAesCtr = new CTR(mnemonicKey, mnemonicIv);\n        const mnemonicCiphertext = getBytes(mnemonicAesCtr.encrypt(entropy));\n        const now = new Date();\n        const timestamp = (now.getUTCFullYear() + \"-\" +\n            zpad(now.getUTCMonth() + 1, 2) + \"-\" +\n            zpad(now.getUTCDate(), 2) + \"T\" +\n            zpad(now.getUTCHours(), 2) + \"-\" +\n            zpad(now.getUTCMinutes(), 2) + \"-\" +\n            zpad(now.getUTCSeconds(), 2) + \".0Z\");\n        const gethFilename = (\"UTC--\" + timestamp + \"--\" + data.address);\n        data[\"x-ethers\"] = {\n            client, gethFilename, path, locale,\n            mnemonicCounter: hexlify(mnemonicIv).substring(2),\n            mnemonicCiphertext: hexlify(mnemonicCiphertext).substring(2),\n            version: \"0.1\"\n        };\n    }\n    return JSON.stringify(data);\n}\n/**\n *  Return the JSON Keystore Wallet for %%account%% encrypted with\n *  %%password%%.\n *\n *  The %%options%% can be used to tune the password-based key\n *  derivation function parameters, explicitly set the random values\n *  used. Any provided [[ProgressCallback]] is ignord.\n */\nexport function encryptKeystoreJsonSync(account, password, options) {\n    if (options == null) {\n        options = {};\n    }\n    const passwordBytes = getPassword(password);\n    const kdf = getEncryptKdfParams(options);\n    const key = scryptSync(passwordBytes, kdf.salt, kdf.N, kdf.r, kdf.p, 64);\n    return _encryptKeystore(getBytes(key), kdf, account, options);\n}\n/**\n *  Resolved to the JSON Keystore Wallet for %%account%% encrypted\n *  with %%password%%.\n *\n *  The %%options%% can be used to tune the password-based key\n *  derivation function parameters, explicitly set the random values\n *  used and provide a [[ProgressCallback]] to receive periodic updates\n *  on the completion status..\n */\nexport async function encryptKeystoreJson(account, password, options) {\n    if (options == null) {\n        options = {};\n    }\n    const passwordBytes = getPassword(password);\n    const kdf = getEncryptKdfParams(options);\n    const key = await scrypt(passwordBytes, kdf.salt, kdf.N, kdf.r, kdf.p, 64, options.progressCallback);\n    return _encryptKeystore(getBytes(key), kdf, account, options);\n}\n//# sourceMappingURL=json-keystore.js.map","/**\n *  Explain HD Wallets..\n *\n *  @_subsection: api/wallet:HD Wallets  [hd-wallets]\n */\nimport { computeHmac, randomBytes, ripemd160, SigningKey, sha256 } from \"../crypto/index.js\";\nimport { VoidSigner } from \"../providers/index.js\";\nimport { computeAddress } from \"../transaction/index.js\";\nimport { concat, dataSlice, decodeBase58, defineProperties, encodeBase58, getBytes, hexlify, isBytesLike, getNumber, toBeArray, toBigInt, toBeHex, assertPrivate, assert, assertArgument } from \"../utils/index.js\";\nimport { LangEn } from \"../wordlists/lang-en.js\";\nimport { BaseWallet } from \"./base-wallet.js\";\nimport { Mnemonic } from \"./mnemonic.js\";\nimport { encryptKeystoreJson, encryptKeystoreJsonSync, } from \"./json-keystore.js\";\n/**\n *  The default derivation path for Ethereum HD Nodes. (i.e. ``\"m/44'/60'/0'/0/0\"``)\n */\nexport const defaultPath = \"m/44'/60'/0'/0/0\";\n// \"Bitcoin seed\"\nconst MasterSecret = new Uint8Array([66, 105, 116, 99, 111, 105, 110, 32, 115, 101, 101, 100]);\nconst HardenedBit = 0x80000000;\nconst N = BigInt(\"0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141\");\nconst Nibbles = \"0123456789abcdef\";\nfunction zpad(value, length) {\n    let result = \"\";\n    while (value) {\n        result = Nibbles[value % 16] + result;\n        value = Math.trunc(value / 16);\n    }\n    while (result.length < length * 2) {\n        result = \"0\" + result;\n    }\n    return \"0x\" + result;\n}\nfunction encodeBase58Check(_value) {\n    const value = getBytes(_value);\n    const check = dataSlice(sha256(sha256(value)), 0, 4);\n    const bytes = concat([value, check]);\n    return encodeBase58(bytes);\n}\nconst _guard = {};\nfunction ser_I(index, chainCode, publicKey, privateKey) {\n    const data = new Uint8Array(37);\n    if (index & HardenedBit) {\n        assert(privateKey != null, \"cannot derive child of neutered node\", \"UNSUPPORTED_OPERATION\", {\n            operation: \"deriveChild\"\n        });\n        // Data = 0x00 || ser_256(k_par)\n        data.set(getBytes(privateKey), 1);\n    }\n    else {\n        // Data = ser_p(point(k_par))\n        data.set(getBytes(publicKey));\n    }\n    // Data += ser_32(i)\n    for (let i = 24; i >= 0; i -= 8) {\n        data[33 + (i >> 3)] = ((index >> (24 - i)) & 0xff);\n    }\n    const I = getBytes(computeHmac(\"sha512\", chainCode, data));\n    return { IL: I.slice(0, 32), IR: I.slice(32) };\n}\nfunction derivePath(node, path) {\n    const components = path.split(\"/\");\n    assertArgument(components.length > 0, \"invalid path\", \"path\", path);\n    if (components[0] === \"m\") {\n        assertArgument(node.depth === 0, `cannot derive root path (i.e. path starting with \"m/\") for a node at non-zero depth ${node.depth}`, \"path\", path);\n        components.shift();\n    }\n    let result = node;\n    for (let i = 0; i < components.length; i++) {\n        const component = components[i];\n        if (component.match(/^[0-9]+'$/)) {\n            const index = parseInt(component.substring(0, component.length - 1));\n            assertArgument(index < HardenedBit, \"invalid path index\", `path[${i}]`, component);\n            result = result.deriveChild(HardenedBit + index);\n        }\n        else if (component.match(/^[0-9]+$/)) {\n            const index = parseInt(component);\n            assertArgument(index < HardenedBit, \"invalid path index\", `path[${i}]`, component);\n            result = result.deriveChild(index);\n        }\n        else {\n            assertArgument(false, \"invalid path component\", `path[${i}]`, component);\n        }\n    }\n    return result;\n}\n/**\n *  An **HDNodeWallet** is a [[Signer]] backed by the private key derived\n *  from an HD Node using the [[link-bip-32]] stantard.\n *\n *  An HD Node forms a hierarchal structure with each HD Node having a\n *  private key and the ability to derive child HD Nodes, defined by\n *  a path indicating the index of each child.\n */\nexport class HDNodeWallet extends BaseWallet {\n    /**\n     *  The compressed public key.\n     */\n    publicKey;\n    /**\n     *  The fingerprint.\n     *\n     *  A fingerprint allows quick qay to detect parent and child nodes,\n     *  but developers should be prepared to deal with collisions as it\n     *  is only 4 bytes.\n     */\n    fingerprint;\n    /**\n     *  The parent fingerprint.\n     */\n    parentFingerprint;\n    /**\n     *  The mnemonic used to create this HD Node, if available.\n     *\n     *  Sources such as extended keys do not encode the mnemonic, in\n     *  which case this will be ``null``.\n     */\n    mnemonic;\n    /**\n     *  The chaincode, which is effectively a public key used\n     *  to derive children.\n     */\n    chainCode;\n    /**\n     *  The derivation path of this wallet.\n     *\n     *  Since extended keys do not provide full path details, this\n     *  may be ``null``, if instantiated from a source that does not\n     *  encode it.\n     */\n    path;\n    /**\n     *  The child index of this wallet. Values over ``2 *\\* 31`` indicate\n     *  the node is hardened.\n     */\n    index;\n    /**\n     *  The depth of this wallet, which is the number of components\n     *  in its path.\n     */\n    depth;\n    /**\n     *  @private\n     */\n    constructor(guard, signingKey, parentFingerprint, chainCode, path, index, depth, mnemonic, provider) {\n        super(signingKey, provider);\n        assertPrivate(guard, _guard, \"HDNodeWallet\");\n        defineProperties(this, { publicKey: signingKey.compressedPublicKey });\n        const fingerprint = dataSlice(ripemd160(sha256(this.publicKey)), 0, 4);\n        defineProperties(this, {\n            parentFingerprint, fingerprint,\n            chainCode, path, index, depth\n        });\n        defineProperties(this, { mnemonic });\n    }\n    connect(provider) {\n        return new HDNodeWallet(_guard, this.signingKey, this.parentFingerprint, this.chainCode, this.path, this.index, this.depth, this.mnemonic, provider);\n    }\n    #account() {\n        const account = { address: this.address, privateKey: this.privateKey };\n        const m = this.mnemonic;\n        if (this.path && m && m.wordlist.locale === \"en\" && m.password === \"\") {\n            account.mnemonic = {\n                path: this.path,\n                locale: \"en\",\n                entropy: m.entropy\n            };\n        }\n        return account;\n    }\n    /**\n     *  Resolves to a [JSON Keystore Wallet](json-wallets) encrypted with\n     *  %%password%%.\n     *\n     *  If %%progressCallback%% is specified, it will receive periodic\n     *  updates as the encryption process progreses.\n     */\n    async encrypt(password, progressCallback) {\n        return await encryptKeystoreJson(this.#account(), password, { progressCallback });\n    }\n    /**\n     *  Returns a [JSON Keystore Wallet](json-wallets) encryped with\n     *  %%password%%.\n     *\n     *  It is preferred to use the [async version](encrypt) instead,\n     *  which allows a [[ProgressCallback]] to keep the user informed.\n     *\n     *  This method will block the event loop (freezing all UI) until\n     *  it is complete, which may be a non-trivial duration.\n     */\n    encryptSync(password) {\n        return encryptKeystoreJsonSync(this.#account(), password);\n    }\n    /**\n     *  The extended key.\n     *\n     *  This key will begin with the prefix ``xpriv`` and can be used to\n     *  reconstruct this HD Node to derive its children.\n     */\n    get extendedKey() {\n        // We only support the mainnet values for now, but if anyone needs\n        // testnet values, let me know. I believe current sentiment is that\n        // we should always use mainnet, and use BIP-44 to derive the network\n        //   - Mainnet: public=0x0488B21E, private=0x0488ADE4\n        //   - Testnet: public=0x043587CF, private=0x04358394\n        assert(this.depth < 256, \"Depth too deep\", \"UNSUPPORTED_OPERATION\", { operation: \"extendedKey\" });\n        return encodeBase58Check(concat([\n            \"0x0488ADE4\", zpad(this.depth, 1), this.parentFingerprint,\n            zpad(this.index, 4), this.chainCode,\n            concat([\"0x00\", this.privateKey])\n        ]));\n    }\n    /**\n     *  Returns true if this wallet has a path, providing a Type Guard\n     *  that the path is non-null.\n     */\n    hasPath() { return (this.path != null); }\n    /**\n     *  Returns a neutered HD Node, which removes the private details\n     *  of an HD Node.\n     *\n     *  A neutered node has no private key, but can be used to derive\n     *  child addresses and other public data about the HD Node.\n     */\n    neuter() {\n        return new HDNodeVoidWallet(_guard, this.address, this.publicKey, this.parentFingerprint, this.chainCode, this.path, this.index, this.depth, this.provider);\n    }\n    /**\n     *  Return the child for %%index%%.\n     */\n    deriveChild(_index) {\n        const index = getNumber(_index, \"index\");\n        assertArgument(index <= 0xffffffff, \"invalid index\", \"index\", index);\n        // Base path\n        let path = this.path;\n        if (path) {\n            path += \"/\" + (index & ~HardenedBit);\n            if (index & HardenedBit) {\n                path += \"'\";\n            }\n        }\n        const { IR, IL } = ser_I(index, this.chainCode, this.publicKey, this.privateKey);\n        const ki = new SigningKey(toBeHex((toBigInt(IL) + BigInt(this.privateKey)) % N, 32));\n        return new HDNodeWallet(_guard, ki, this.fingerprint, hexlify(IR), path, index, this.depth + 1, this.mnemonic, this.provider);\n    }\n    /**\n     *  Return the HDNode for %%path%% from this node.\n     */\n    derivePath(path) {\n        return derivePath(this, path);\n    }\n    static #fromSeed(_seed, mnemonic) {\n        assertArgument(isBytesLike(_seed), \"invalid seed\", \"seed\", \"[REDACTED]\");\n        const seed = getBytes(_seed, \"seed\");\n        assertArgument(seed.length >= 16 && seed.length <= 64, \"invalid seed\", \"seed\", \"[REDACTED]\");\n        const I = getBytes(computeHmac(\"sha512\", MasterSecret, seed));\n        const signingKey = new SigningKey(hexlify(I.slice(0, 32)));\n        return new HDNodeWallet(_guard, signingKey, \"0x00000000\", hexlify(I.slice(32)), \"m\", 0, 0, mnemonic, null);\n    }\n    /**\n     *  Creates a new HD Node from %%extendedKey%%.\n     *\n     *  If the %%extendedKey%% will either have a prefix or ``xpub`` or\n     *  ``xpriv``, returning a neutered HD Node ([[HDNodeVoidWallet]])\n     *  or full HD Node ([[HDNodeWallet) respectively.\n     */\n    static fromExtendedKey(extendedKey) {\n        const bytes = toBeArray(decodeBase58(extendedKey)); // @TODO: redact\n        assertArgument(bytes.length === 82 || encodeBase58Check(bytes.slice(0, 78)) === extendedKey, \"invalid extended key\", \"extendedKey\", \"[ REDACTED ]\");\n        const depth = bytes[4];\n        const parentFingerprint = hexlify(bytes.slice(5, 9));\n        const index = parseInt(hexlify(bytes.slice(9, 13)).substring(2), 16);\n        const chainCode = hexlify(bytes.slice(13, 45));\n        const key = bytes.slice(45, 78);\n        switch (hexlify(bytes.slice(0, 4))) {\n            // Public Key\n            case \"0x0488b21e\":\n            case \"0x043587cf\": {\n                const publicKey = hexlify(key);\n                return new HDNodeVoidWallet(_guard, computeAddress(publicKey), publicKey, parentFingerprint, chainCode, null, index, depth, null);\n            }\n            // Private Key\n            case \"0x0488ade4\":\n            case \"0x04358394 \":\n                if (key[0] !== 0) {\n                    break;\n                }\n                return new HDNodeWallet(_guard, new SigningKey(key.slice(1)), parentFingerprint, chainCode, null, index, depth, null, null);\n        }\n        assertArgument(false, \"invalid extended key prefix\", \"extendedKey\", \"[ REDACTED ]\");\n    }\n    /**\n     *  Creates a new random HDNode.\n     */\n    static createRandom(password, path, wordlist) {\n        if (password == null) {\n            password = \"\";\n        }\n        if (path == null) {\n            path = defaultPath;\n        }\n        if (wordlist == null) {\n            wordlist = LangEn.wordlist();\n        }\n        const mnemonic = Mnemonic.fromEntropy(randomBytes(16), password, wordlist);\n        return HDNodeWallet.#fromSeed(mnemonic.computeSeed(), mnemonic).derivePath(path);\n    }\n    /**\n     *  Create an HD Node from %%mnemonic%%.\n     */\n    static fromMnemonic(mnemonic, path) {\n        if (!path) {\n            path = defaultPath;\n        }\n        return HDNodeWallet.#fromSeed(mnemonic.computeSeed(), mnemonic).derivePath(path);\n    }\n    /**\n     *  Creates an HD Node from a mnemonic %%phrase%%.\n     */\n    static fromPhrase(phrase, password, path, wordlist) {\n        if (password == null) {\n            password = \"\";\n        }\n        if (path == null) {\n            path = defaultPath;\n        }\n        if (wordlist == null) {\n            wordlist = LangEn.wordlist();\n        }\n        const mnemonic = Mnemonic.fromPhrase(phrase, password, wordlist);\n        return HDNodeWallet.#fromSeed(mnemonic.computeSeed(), mnemonic).derivePath(path);\n    }\n    /**\n     *  Creates an HD Node from a %%seed%%.\n     */\n    static fromSeed(seed) {\n        return HDNodeWallet.#fromSeed(seed, null);\n    }\n}\n/**\n *  A **HDNodeVoidWallet** cannot sign, but provides access to\n *  the children nodes of a [[link-bip-32]] HD wallet addresses.\n *\n *  The can be created by using an extended ``xpub`` key to\n *  [[HDNodeWallet_fromExtendedKey]] or by\n *  [nuetering](HDNodeWallet-neuter) a [[HDNodeWallet]].\n */\nexport class HDNodeVoidWallet extends VoidSigner {\n    /**\n     *  The compressed public key.\n     */\n    publicKey;\n    /**\n     *  The fingerprint.\n     *\n     *  A fingerprint allows quick qay to detect parent and child nodes,\n     *  but developers should be prepared to deal with collisions as it\n     *  is only 4 bytes.\n     */\n    fingerprint;\n    /**\n     *  The parent node fingerprint.\n     */\n    parentFingerprint;\n    /**\n     *  The chaincode, which is effectively a public key used\n     *  to derive children.\n     */\n    chainCode;\n    /**\n     *  The derivation path of this wallet.\n     *\n     *  Since extended keys do not provider full path details, this\n     *  may be ``null``, if instantiated from a source that does not\n     *  enocde it.\n     */\n    path;\n    /**\n     *  The child index of this wallet. Values over ``2 *\\* 31`` indicate\n     *  the node is hardened.\n     */\n    index;\n    /**\n     *  The depth of this wallet, which is the number of components\n     *  in its path.\n     */\n    depth;\n    /**\n     *  @private\n     */\n    constructor(guard, address, publicKey, parentFingerprint, chainCode, path, index, depth, provider) {\n        super(address, provider);\n        assertPrivate(guard, _guard, \"HDNodeVoidWallet\");\n        defineProperties(this, { publicKey });\n        const fingerprint = dataSlice(ripemd160(sha256(publicKey)), 0, 4);\n        defineProperties(this, {\n            publicKey, fingerprint, parentFingerprint, chainCode, path, index, depth\n        });\n    }\n    connect(provider) {\n        return new HDNodeVoidWallet(_guard, this.address, this.publicKey, this.parentFingerprint, this.chainCode, this.path, this.index, this.depth, provider);\n    }\n    /**\n     *  The extended key.\n     *\n     *  This key will begin with the prefix ``xpub`` and can be used to\n     *  reconstruct this neutered key to derive its children addresses.\n     */\n    get extendedKey() {\n        // We only support the mainnet values for now, but if anyone needs\n        // testnet values, let me know. I believe current sentiment is that\n        // we should always use mainnet, and use BIP-44 to derive the network\n        //   - Mainnet: public=0x0488B21E, private=0x0488ADE4\n        //   - Testnet: public=0x043587CF, private=0x04358394\n        assert(this.depth < 256, \"Depth too deep\", \"UNSUPPORTED_OPERATION\", { operation: \"extendedKey\" });\n        return encodeBase58Check(concat([\n            \"0x0488B21E\",\n            zpad(this.depth, 1),\n            this.parentFingerprint,\n            zpad(this.index, 4),\n            this.chainCode,\n            this.publicKey,\n        ]));\n    }\n    /**\n     *  Returns true if this wallet has a path, providing a Type Guard\n     *  that the path is non-null.\n     */\n    hasPath() { return (this.path != null); }\n    /**\n     *  Return the child for %%index%%.\n     */\n    deriveChild(_index) {\n        const index = getNumber(_index, \"index\");\n        assertArgument(index <= 0xffffffff, \"invalid index\", \"index\", index);\n        // Base path\n        let path = this.path;\n        if (path) {\n            path += \"/\" + (index & ~HardenedBit);\n            if (index & HardenedBit) {\n                path += \"'\";\n            }\n        }\n        const { IR, IL } = ser_I(index, this.chainCode, this.publicKey, null);\n        const Ki = SigningKey.addPoints(IL, this.publicKey, true);\n        const address = computeAddress(Ki);\n        return new HDNodeVoidWallet(_guard, address, Ki, this.fingerprint, hexlify(IR), path, index, this.depth + 1, this.provider);\n    }\n    /**\n     *  Return the signer for %%path%% from this node.\n     */\n    derivePath(path) {\n        return derivePath(this, path);\n    }\n}\n/*\nexport class HDNodeWalletManager {\n    #root: HDNodeWallet;\n\n    constructor(phrase: string, password?: null | string, path?: null | string, locale?: null | Wordlist) {\n        if (password == null) { password = \"\"; }\n        if (path == null) { path = \"m/44'/60'/0'/0\"; }\n        if (locale == null) { locale = LangEn.wordlist(); }\n        this.#root = HDNodeWallet.fromPhrase(phrase, password, path, locale);\n    }\n\n    getSigner(index?: number): HDNodeWallet {\n        return this.#root.deriveChild((index == null) ? 0: index);\n    }\n}\n*/\n/**\n *  Returns the [[link-bip-32]] path for the account at %%index%%.\n *\n *  This is the pattern used by wallets like Ledger.\n *\n *  There is also an [alternate pattern](getIndexedAccountPath) used by\n *  some software.\n */\nexport function getAccountPath(_index) {\n    const index = getNumber(_index, \"index\");\n    assertArgument(index >= 0 && index < HardenedBit, \"invalid account index\", \"index\", index);\n    return `m/44'/60'/${index}'/0/0`;\n}\n/**\n *  Returns the path using an alternative pattern for deriving accounts,\n *  at %%index%%.\n *\n *  This derivation path uses the //index// component rather than the\n *  //account// component to derive sequential accounts.\n *\n *  This is the pattern used by wallets like MetaMask.\n */\nexport function getIndexedAccountPath(_index) {\n    const index = getNumber(_index, \"index\");\n    assertArgument(index >= 0 && index < HardenedBit, \"invalid account index\", \"index\", index);\n    return `m/44'/60'/0'/0/${index}`;\n}\n//# sourceMappingURL=hdwallet.js.map","/**\n *  @_subsection: api/wallet:JSON Wallets  [json-wallets]\n */\nimport { CBC, pkcs7Strip } from \"aes-js\";\nimport { getAddress } from \"../address/index.js\";\nimport { pbkdf2 } from \"../crypto/index.js\";\nimport { id } from \"../hash/index.js\";\nimport { getBytes, assertArgument } from \"../utils/index.js\";\nimport { getPassword, looseArrayify, spelunk } from \"./utils.js\";\n/**\n *  Returns true if %%json%% is a valid JSON Crowdsale wallet.\n */\nexport function isCrowdsaleJson(json) {\n    try {\n        const data = JSON.parse(json);\n        if (data.encseed) {\n            return true;\n        }\n    }\n    catch (error) { }\n    return false;\n}\n// See: https://github.com/ethereum/pyethsaletool\n/**\n *  Before Ethereum launched, it was necessary to create a wallet\n *  format for backers to use, which would be used to receive ether\n *  as a reward for contributing to the project.\n *\n *  The [[link-crowdsale]] format is now obsolete, but it is still\n *  useful to support and the additional code is fairly trivial as\n *  all the primitives required are used through core portions of\n *  the library.\n */\nexport function decryptCrowdsaleJson(json, _password) {\n    const data = JSON.parse(json);\n    const password = getPassword(_password);\n    // Ethereum Address\n    const address = getAddress(spelunk(data, \"ethaddr:string!\"));\n    // Encrypted Seed\n    const encseed = looseArrayify(spelunk(data, \"encseed:string!\"));\n    assertArgument(encseed && (encseed.length % 16) === 0, \"invalid encseed\", \"json\", json);\n    const key = getBytes(pbkdf2(password, password, 2000, 32, \"sha256\")).slice(0, 16);\n    const iv = encseed.slice(0, 16);\n    const encryptedSeed = encseed.slice(16);\n    // Decrypt the seed\n    const aesCbc = new CBC(key, iv);\n    const seed = pkcs7Strip(getBytes(aesCbc.decrypt(encryptedSeed)));\n    // This wallet format is weird... Convert the binary encoded hex to a string.\n    let seedHex = \"\";\n    for (let i = 0; i < seed.length; i++) {\n        seedHex += String.fromCharCode(seed[i]);\n    }\n    return { address, privateKey: id(seedHex) };\n}\n//# sourceMappingURL=json-crowdsale.js.map","export function pkcs7Pad(data) {\n    const padder = 16 - (data.length % 16);\n    const result = new Uint8Array(data.length + padder);\n    result.set(data);\n    for (let i = data.length; i < result.length; i++) {\n        result[i] = padder;\n    }\n    return result;\n}\nexport function pkcs7Strip(data) {\n    if (data.length < 16) {\n        throw new TypeError('PKCS#7 invalid length');\n    }\n    const padder = data[data.length - 1];\n    if (padder > 16) {\n        throw new TypeError('PKCS#7 padding byte out of range');\n    }\n    const length = data.length - padder;\n    for (let i = 0; i < padder; i++) {\n        if (data[length + i] !== padder) {\n            throw new TypeError('PKCS#7 invalid padding byte');\n        }\n    }\n    return new Uint8Array(data.subarray(0, length));\n}\n//# sourceMappingURL=padding.js.map","import { SigningKey } from \"../crypto/index.js\";\nimport { assertArgument } from \"../utils/index.js\";\nimport { BaseWallet } from \"./base-wallet.js\";\nimport { HDNodeWallet } from \"./hdwallet.js\";\nimport { decryptCrowdsaleJson, isCrowdsaleJson } from \"./json-crowdsale.js\";\nimport { decryptKeystoreJson, decryptKeystoreJsonSync, encryptKeystoreJson, encryptKeystoreJsonSync, isKeystoreJson } from \"./json-keystore.js\";\nimport { Mnemonic } from \"./mnemonic.js\";\nfunction stall(duration) {\n    return new Promise((resolve) => { setTimeout(() => { resolve(); }, duration); });\n}\n/**\n *  A **Wallet** manages a single private key which is used to sign\n *  transactions, messages and other common payloads.\n *\n *  This class is generally the main entry point for developers\n *  that wish to use a private key directly, as it can create\n *  instances from a large variety of common sources, including\n *  raw private key, [[link-bip-39]] mnemonics and encrypte JSON\n *  wallets.\n */\nexport class Wallet extends BaseWallet {\n    /**\n     *  Create a new wallet for the private %%key%%, optionally connected\n     *  to %%provider%%.\n     */\n    constructor(key, provider) {\n        if (typeof (key) === \"string\" && !key.startsWith(\"0x\")) {\n            key = \"0x\" + key;\n        }\n        let signingKey = (typeof (key) === \"string\") ? new SigningKey(key) : key;\n        super(signingKey, provider);\n    }\n    connect(provider) {\n        return new Wallet(this.signingKey, provider);\n    }\n    /**\n     *  Resolves to a [JSON Keystore Wallet](json-wallets) encrypted with\n     *  %%password%%.\n     *\n     *  If %%progressCallback%% is specified, it will receive periodic\n     *  updates as the encryption process progreses.\n     */\n    async encrypt(password, progressCallback) {\n        const account = { address: this.address, privateKey: this.privateKey };\n        return await encryptKeystoreJson(account, password, { progressCallback });\n    }\n    /**\n     *  Returns a [JSON Keystore Wallet](json-wallets) encryped with\n     *  %%password%%.\n     *\n     *  It is preferred to use the [async version](encrypt) instead,\n     *  which allows a [[ProgressCallback]] to keep the user informed.\n     *\n     *  This method will block the event loop (freezing all UI) until\n     *  it is complete, which may be a non-trivial duration.\n     */\n    encryptSync(password) {\n        const account = { address: this.address, privateKey: this.privateKey };\n        return encryptKeystoreJsonSync(account, password);\n    }\n    static #fromAccount(account) {\n        assertArgument(account, \"invalid JSON wallet\", \"json\", \"[ REDACTED ]\");\n        if (\"mnemonic\" in account && account.mnemonic && account.mnemonic.locale === \"en\") {\n            const mnemonic = Mnemonic.fromEntropy(account.mnemonic.entropy);\n            const wallet = HDNodeWallet.fromMnemonic(mnemonic, account.mnemonic.path);\n            if (wallet.address === account.address && wallet.privateKey === account.privateKey) {\n                return wallet;\n            }\n            console.log(\"WARNING: JSON mismatch address/privateKey != mnemonic; fallback onto private key\");\n        }\n        const wallet = new Wallet(account.privateKey);\n        assertArgument(wallet.address === account.address, \"address/privateKey mismatch\", \"json\", \"[ REDACTED ]\");\n        return wallet;\n    }\n    /**\n     *  Creates (asynchronously) a **Wallet** by decrypting the %%json%%\n     *  with %%password%%.\n     *\n     *  If %%progress%% is provided, it is called periodically during\n     *  decryption so that any UI can be updated.\n     */\n    static async fromEncryptedJson(json, password, progress) {\n        let account = null;\n        if (isKeystoreJson(json)) {\n            account = await decryptKeystoreJson(json, password, progress);\n        }\n        else if (isCrowdsaleJson(json)) {\n            if (progress) {\n                progress(0);\n                await stall(0);\n            }\n            account = decryptCrowdsaleJson(json, password);\n            if (progress) {\n                progress(1);\n                await stall(0);\n            }\n        }\n        return Wallet.#fromAccount(account);\n    }\n    /**\n     *  Creates a **Wallet** by decrypting the %%json%% with %%password%%.\n     *\n     *  The [[fromEncryptedJson]] method is preferred, as this method\n     *  will lock up and freeze the UI during decryption, which may take\n     *  some time.\n     */\n    static fromEncryptedJsonSync(json, password) {\n        let account = null;\n        if (isKeystoreJson(json)) {\n            account = decryptKeystoreJsonSync(json, password);\n        }\n        else if (isCrowdsaleJson(json)) {\n            account = decryptCrowdsaleJson(json, password);\n        }\n        else {\n            assertArgument(false, \"invalid JSON wallet\", \"json\", \"[ REDACTED ]\");\n        }\n        return Wallet.#fromAccount(account);\n    }\n    /**\n     *  Creates a new random [[HDNodeWallet]] using the available\n     *  [cryptographic random source](randomBytes).\n     *\n     *  If there is no crytographic random source, this will throw.\n     */\n    static createRandom(provider) {\n        const wallet = HDNodeWallet.createRandom();\n        if (provider) {\n            return wallet.connect(provider);\n        }\n        return wallet;\n    }\n    /**\n     *  Creates a [[HDNodeWallet]] for %%phrase%%.\n     */\n    static fromPhrase(phrase, provider) {\n        const wallet = HDNodeWallet.fromPhrase(phrase);\n        if (provider) {\n            return wallet.connect(provider);\n        }\n        return wallet;\n    }\n}\n//# sourceMappingURL=wallet.js.map","import \"./utils/polyfills\";\nimport { Wallet, keccak256, getBytes } from \"ethers\";\nimport initBackground from \"./background/background\";\nimport {\n  BACKEND_URL,\n  API_ENDPOINTS,\n  RECLAIM_SDK_ACTIONS,\n  MESSAGE_ACTIONS,\n  MESSAGE_SOURCES,\n} from \"./utils/constants\";\nimport { loggerService } from \"./utils/logger/LoggerService\";\n\n// 用于序列化扩展会话的全局验证队列（后台为单会话） (background is single-session)\n\nconst _verificationQueue = [];\nlet _queueRunning = false;\n// eslint-disable-next-line no-undef\nconst SDK_VERSION = __SDK_VERSION__;\n\n// 将验证任务添加到队列并触发队列处理\nfunction _enqueueVerification(task) {\n  return new Promise((resolve, reject) => {\n    _verificationQueue.push({ task, resolve, reject });\n    _drainQueue();\n  });\n}\n\n// 处理队列中的下一个验证任务\nasync function _drainQueue() {\n  if (_queueRunning) return;\n  const next = _verificationQueue.shift();\n  if (!next) return;\n  _queueRunning = true;\n  try {\n    const result = await next.task();\n    next.resolve(result);\n  } catch (e) {\n    next.reject(e);\n  } finally {\n    _queueRunning = false;\n    _drainQueue();\n  }\n}\n\n// ReclaimExtensionProofRequest 类\n/**\n * 单次验证请求实例：负责会话配置、事件监听、与 Content/Background 的通信桥接。\n * 运行环境分为 extension（扩展 popup/options 页）与 web（第三方网页），通信方式不同。\n */\nclass ReclaimExtensionProofRequest {\n  constructor(applicationId, providerId, options = {}) {\n    // ---------- 会话与配置字段 ----------\n    this.applicationId = applicationId;\n    this.providerId = providerId;\n    this.sessionId = \"\";\n    this.signature = \"\";\n    this.timestamp = Date.now().toString();\n    this.parameters = {};\n    this.context = { contextAddress: \"0x0\", contextMessage: \"sample context\" };\n    this.redirectUrl = \"\";\n    this.sdkVersion = `ext-${SDK_VERSION}`;\n    this.resolvedProviderVersion = \"\";\n    this.jsonProofResponse = false;\n    this.extensionID = options.extensionID || \"\";\n    this.providerVersion = options.providerVersion || \"\";\n    this.acceptAiProviders = !!options.acceptAiProviders;\n    this.callbackUrl = options.callbackUrl || \"\";\n\n    this._backgroundInitialized = false;\n    this._ctx = null;\n\n    // ---------- 事件：started / completed / error / progress ----------\n    this._listeners = {\n      started: new Set(),\n      completed: new Set(),\n      error: new Set(),\n      progress: new Set(),\n    };\n    this._boundWindowListener = this._handleWindowMessage.bind(this);\n    window.addEventListener(\"message\", this._boundWindowListener);\n\n    // ---------- 运行模式：根据当前页面协议判断是扩展内页还是第三方网页 ----------\n    this._mode =\n      typeof chrome !== \"undefined\" && chrome.runtime && location?.protocol === \"chrome-extension:\"\n        ? \"extension\"\n        : \"web\";\n    // extension 模式：直接监听 chrome.runtime.onMessage，接收 Background 广播的 PROOF_SUBMITTED / 失败\n    if (this._mode === \"extension\") {\n      this._boundChromeHandler = (message) => {\n        const { action, data, error } = message || {};\n        const messageId = data?.sessionId;\n        if (this.sessionId && this.sessionId !== messageId) return;\n        if (action === MESSAGE_ACTIONS.PROOF_SUBMITTED) {\n          const proofs = data?.formattedProofs || data?.proof || data;\n          this._emit(\"completed\", proofs);\n        } else if (\n          action === MESSAGE_ACTIONS.PROOF_SUBMISSION_FAILED ||\n          action === MESSAGE_ACTIONS.PROOF_GENERATION_FAILED\n        ) {\n          this._emit(\"error\", error || new Error(\"Verification failed\"));\n        }\n      };\n      try {\n        chrome.runtime.onMessage.addListener(this._boundChromeHandler);\n      } catch {}\n    }\n  }\n\n  /**\n   * 创建并初始化一次验证请求：校验参数 → 构造实例 → 签名 → 后端创建会话。\n   * 调用方需先 init 再 startVerification；fromConfig 用于服务端下发的配置反序列化。\n   */\n  static async init(applicationId, appSecret, providerId, options = {}) {\n    if (!applicationId || typeof applicationId !== \"string\") {\n      throw new Error(\"applicationId must be a non-empty string\");\n    }\n    if (!appSecret || typeof appSecret !== \"string\") {\n      throw new Error(\"appSecret must be a non-empty string\");\n    }\n    if (!providerId || typeof providerId !== \"string\") {\n      throw new Error(\"providerId must be a non-empty string\");\n    }\n\n    const instance = new ReclaimExtensionProofRequest(applicationId, providerId, options);\n\n    // 对规范化的 { providerId, timestamp } 做 keccak256 后用 appSecret 对应私钥签名，供后端校验\n    const canonical = `{\"providerId\":\"${providerId}\",\"timestamp\":\"${instance.timestamp}\"}`;\n    const hash = keccak256(new TextEncoder().encode(canonical));\n    const wallet = new Wallet(appSecret);\n    const signature = await wallet.signMessage(getBytes(hash));\n    instance.signature = signature;\n\n    // 调用后端 /api/sdk/init/session/ 创建会话，拿到 sessionId 与 resolvedProviderVersion\n    const initRes = await instance._initSession({\n      providerId,\n      appId: applicationId,\n      timestamp: instance.timestamp,\n      signature,\n      versionNumber: instance.providerVersion || \"\",\n    });\n    instance.sessionId = initRes.sessionId || \"\";\n    instance.resolvedProviderVersion = initRes.resolvedProviderVersion || \"\";\n    console.log(\"调用后端 /api/sdk/init/session/ 拿到的结果是 :\", initRes);\n    return instance;\n  }\n\n  /** 从 JSON 字符串或对象反序列化为实例，常用于服务端下发配置、网页端不暴露 appSecret 的场景 */\n  static fromJsonString(json, options = {}) {\n    const cfg = typeof json === \"string\" ? JSON.parse(json) : json;\n    return this.fromConfig(cfg, options);\n  }\n\n  /** 从配置对象还原实例：sessionId、signature、callbackUrl 等均从 config 填充，sdkVersion 保持 ext-* 不信任入参 */\n  static fromConfig(config, options = {}) {\n    if (!config || typeof config !== \"object\") throw new Error(\"invalid config\");\n    const instance = new ReclaimExtensionProofRequest(\n      String(config.applicationId || \"\"),\n      String(config.providerId || \"\"),\n      options || {},\n    );\n\n    instance.sessionId = String(config.sessionId || \"\");\n    instance.signature = String(config.signature || \"\");\n    instance.timestamp = String(config.timeStamp || config.timestamp || Date.now());\n    instance.parameters = config.parameters || {};\n    instance.context = config.context || instance.context;\n    instance.callbackUrl = String(config.appCallbackUrl || config.callbackUrl || \"\");\n    instance.jsonProofResponse = !!(config.jsonProofResponse ?? instance.jsonProofResponse);\n    instance.resolvedProviderVersion = String(config.resolvedProviderVersion || \"\");\n    instance.providerVersion = String(config.providerVersion || \"\");\n    instance.redirectUrl = String(config.redirectUrl || \"\");\n    instance.acceptAiProviders = !!(\n      config.acceptAiProviders ??\n      config.options?.acceptAiProviders ??\n      instance.acceptAiProviders\n    );\n\n    if (options?.extensionID) instance.extensionID = String(options.extensionID);\n\n    // sdkVersion 保持构造函数中的 ext-<version>，不采用 config 中的值，防止伪造\n    return instance;\n  }\n\n  // ---------- 配置辅助：callback / redirect / context / parameters / statusUrl ----------\n  setAppCallbackUrl(url, jsonProofResponse = false) {\n    if (!url || typeof url !== \"string\") throw new Error(\"callbackUrl must be a non-empty string\");\n    this.callbackUrl = url;\n    this.jsonProofResponse = !!jsonProofResponse;\n  }\n\n  setRedirectUrl(url) {\n    if (!url || typeof url !== \"string\") throw new Error(\"redirectUrl must be a non-empty string\");\n    this.redirectUrl = url;\n  }\n\n  addContext(address, message) {\n    if (!address || !message) throw new Error(\"Both address and message are required\");\n    this.context = { contextAddress: String(address), contextMessage: String(message) };\n  }\n\n  setParams(params) {\n    if (!params || typeof params !== \"object\") throw new Error(\"params must be an object\");\n    this.parameters = { ...this.parameters, ...params };\n  }\n\n  /** 返回当前会话的状态查询 URL（后端 /api/sdk/session/:sessionId） */\n  getStatusUrl() {\n    if (!this.sessionId) throw new Error(\"Session not initialized\");\n\n    console.log(\"getStatusUrl is :\", API_ENDPOINTS.STATUS_URL(this.sessionId));\n    return API_ENDPOINTS.STATUS_URL(this.sessionId);\n  }\n\n  // ---------- 事件订阅：on 返回取消订阅函数 ----------\n  on(event, cb) {\n    if (!this._listeners[event]) throw new Error(`Unknown event: ${event}`);\n    this._listeners[event].add(cb);\n    return () => this.off(event, cb);\n  }\n  off(event, cb) {\n    if (!this._listeners[event]) return;\n    this._listeners[event].delete(cb);\n  }\n\n  /**\n   * 对外 API：开始验证。先进入全局队列串行执行（Background 单会话），再执行 _startVerificationInternal。\n   * 返回的 Promise 在收到 completed 时 resolve(proofs)，收到 error 时 reject。\n   */\n  async startVerification() {\n    return _enqueueVerification(() => this._startVerificationInternal());\n  }\n\n  /**\n   * 取消当前验证：通过 postMessage 通知 Content（再转 Background 执行 cancelSession），\n   * 等待 error 事件（Content 收到 PROOF_GENERATION_FAILED 后 postMessage VERIFICATION_FAILED）或超时。\n   */\n  async cancel(timeoutMs = 5000) {\n    if (!this.sessionId) return;\n    return new Promise((resolve) => {\n      let done = false;\n      const offErr = this.on(\"error\", () => {\n        if (!done) {\n          done = true;\n          offErr();\n          resolve(true);\n        }\n      });\n      // 向页面广播取消，由注入的 Content Script 转发给 Background\n      window.postMessage(\n        {\n          action: RECLAIM_SDK_ACTIONS.CANCEL_VERIFICATION,\n          messageId: this.sessionId,\n          extensionID: this.extensionID,\n        },\n        \"*\",\n      );\n      setTimeout(() => {\n        if (!done) {\n          offErr();\n          resolve(false);\n        }\n      }, timeoutMs);\n    });\n  }\n\n  /**\n   * 内部：组装 templateData，根据 _mode 选择通信方式，返回一个由 completed/error 事件驱动的 Promise。\n   * - extension：chrome.runtime.sendMessage 发给 Background，started 由回调里 _emit。\n   * - web：window.postMessage 发给页面内 Content Script（需 extensionID），started/completed/error 由 _handleWindowMessage 收到 Content 转发后 _emit。\n   */\n  async _startVerificationInternal() {\n    if (!this.sessionId) throw new Error(\"Session not initialized\");\n    if (!this.signature) throw new Error(\"Signature not set\");\n\n    const templateData = {\n      sessionId: this.sessionId,\n      providerId: this.providerId,\n      applicationId: this.applicationId,\n      signature: this.signature,\n      timestamp: this.timestamp,\n      callbackUrl: this.callbackUrl || \"\",\n      context: JSON.stringify(this.context || {}),\n      parameters: this.parameters || {},\n      redirectUrl: this.redirectUrl || \"\",\n      acceptAiProviders: !!this.acceptAiProviders,\n      sdkVersion: this.sdkVersion,\n      providerVersion: this.providerVersion || \"\",\n      resolvedProviderVersion: this.resolvedProviderVersion || \"\",\n      jsonProofResponse: !!this.jsonProofResponse,\n    };\n\n    const messageId = this.sessionId;\n\n    // 一次性 Promise：completed 时 resolve(payload)，error 时 reject(err)，并移除本次注册的监听\n    return new Promise((resolve, reject) => {\n      const offStarted = this.on(\"started\", () => {});\n      const offCompleted = this.on(\"completed\", (payload) => {\n        cleanup();\n        resolve(payload);\n      });\n      const offError = this.on(\"error\", (err) => {\n        cleanup();\n        reject(err);\n      });\n      const cleanup = () => {\n        offStarted && offStarted();\n        offCompleted && offCompleted();\n        offError && offError();\n      };\n      console.log(\"templateData is :\", templateData);\n      console.log(\"_mode is :\", this._mode);\n      if (this._mode === \"extension\") {\n        try {\n          chrome.runtime.sendMessage(\n            {\n              action: MESSAGE_ACTIONS.START_VERIFICATION,\n              source: MESSAGE_SOURCES.CONTENT_SCRIPT,\n              target: MESSAGE_SOURCES.BACKGROUND,\n              data: templateData,\n            },\n            (resp) => {\n              if (resp && resp.success)\n                this._emit(\"started\", { sessionId: this.sessionId, messageId });\n            },\n          );\n        } catch (e) {\n          this._emit(\"error\", e instanceof Error ? e : new Error(String(e)));\n        }\n      } else {\n        // 网页环境：必须传 extensionID，由页面内 Content Script 根据 extensionID 校验后转发给 Background\n        if (!this.extensionID) {\n          this._emit(\"error\", new Error(\"extensionID is required when running on a web page\"));\n          return;\n        }\n        window.postMessage(\n          {\n            action: RECLAIM_SDK_ACTIONS.START_VERIFICATION,\n            messageId,\n            data: templateData,\n            extensionID: this.extensionID,\n          },\n          \"*\",\n        );\n      }\n    });\n  }\n\n  /** 移除 window 与 chrome.runtime 的监听，并清空所有事件回调，避免泄漏 */\n  dispose() {\n    window.removeEventListener(\"message\", this._boundWindowListener);\n    if (this._boundChromeHandler && chrome?.runtime?.onMessage?.removeListener) {\n      try {\n        chrome.runtime.onMessage.removeListener(this._boundChromeHandler);\n      } catch {}\n    }\n    this._listeners.started.clear();\n    this._listeners.completed.clear();\n    this._listeners.error.clear();\n    this._listeners.progress.clear();\n  }\n\n  /** 调用后端 /api/sdk/init/session/ 创建会话，返回 { sessionId, resolvedProviderVersion } 等 */\n  async _initSession(payload) {\n    const res = await fetch(`${BACKEND_URL}/api/sdk/init/session/`, {\n      method: \"POST\",\n      headers: { \"Content-Type\": \"application/json\" },\n      body: JSON.stringify(payload),\n    });\n    const data = await res.json().catch(() => ({}));\n    if (!res.ok) throw new Error(data?.message || \"Failed to initialize session\");\n    return data;\n  }\n\n  /** 向当前实例已订阅的 event 回调派发 payload */\n  _emit(event, payload) {\n    if (!this._listeners[event]) return;\n    for (const cb of this._listeners[event]) {\n      try {\n        cb(payload);\n      } catch (_) {}\n    }\n  }\n\n  /**\n   * 处理来自同源 window 的 postMessage：Content Script 会把 VERIFICATION_STARTED / COMPLETED / FAILED 转发到页面，\n   * 这里根据 messageId 过滤是否为本会话，再 _emit 对应事件（web 模式下 started/completed/error 均由此驱动）。\n   */\n  _handleWindowMessage(event) {\n    if (event.source !== window) return;\n    const { action, messageId, data, error } = event.data || {};\n    const isForMe = !this.sessionId || this.sessionId === messageId;\n    if (!isForMe) return;\n\n    if (action === RECLAIM_SDK_ACTIONS.VERIFICATION_COMPLETED) {\n      const proofs = data?.proofs || data?.formattedProofs || data;\n      this._emit(\"completed\", proofs);\n      return;\n    }\n    if (action === RECLAIM_SDK_ACTIONS.VERIFICATION_FAILED) {\n      this._emit(\"error\", error || new Error(\"Verification failed\"));\n      return;\n    }\n    if (action === RECLAIM_SDK_ACTIONS.VERIFICATION_STARTED) {\n      this._emit(\"started\", { sessionId: this.sessionId, messageId });\n      return;\n    }\n  }\n}\n\n//  对外 SDK 单例\nclass ReclaimExtensionSDK {\n  constructor() {\n    this._backgroundInitialized = false;\n    this._ctx = null;\n    this._mode =\n      typeof chrome !== \"undefined\" && chrome.runtime && location?.protocol === \"chrome-extension:\"\n        ? \"extension\"\n        : \"web\";\n  }\n\n  // Must be called from the consumer's own background service worker.\n  initializeBackground() {\n    if (this._backgroundInitialized) return this._ctx;\n    try {\n      const ctx = initBackground();\n      this._backgroundInitialized = true;\n      this._ctx = ctx;\n      return ctx;\n    } catch (error) {\n      throw error;\n    }\n  }\n\n  // 检查扩展程序是否已安装且与扩展ID匹配\n  isExtensionInstalled({ extensionID, timeout = 500 } = {}) {\n    return new Promise((resolve) => {\n      const messageId = `reclaim-check-${Date.now()}`;\n      const handler = (event) => {\n        if (\n          event.source === window &&\n          event.data?.action === RECLAIM_SDK_ACTIONS.EXTENSION_RESPONSE &&\n          event.data?.messageId === messageId\n        ) {\n          window.removeEventListener(\"message\", handler);\n          resolve(!!event.data.installed);\n        }\n      };\n      window.addEventListener(\"message\", handler);\n      window.postMessage(\n        { action: RECLAIM_SDK_ACTIONS.CHECK_EXTENSION, extensionID, messageId },\n        \"*\",\n      );\n      setTimeout(() => {\n        window.removeEventListener(\"message\", handler);\n        resolve(false);\n      }, timeout);\n    });\n  }\n\n  getVersion() {\n    return SDK_VERSION;\n  }\n\n  // 主要API：为每个请求创建一个实例\n  async init(applicationId, appSecret, providerId, options = {}) {\n    return await ReclaimExtensionProofRequest.init(applicationId, appSecret, providerId, options);\n  }\n\n  fromJsonString(json, options = {}) {\n    return ReclaimExtensionProofRequest.fromJsonString(json, options);\n  }\n\n  /**\n   * 设置日志配置并持久化存储\n   * 扩展环境下直接存储到 chrome.storage，网页环境下通过 postMessage 委托给 content script\n   */\n  setLogConfig(config, extensionID) {\n    loggerService.setConfig(config);\n\n    // 在扩展上下文中，持久化到存储（传播到所有上下文）\n    try {\n      if (this._mode === \"extension\" && typeof chrome !== \"undefined\" && chrome.storage?.local) {\n        const { LOG_CONFIG_STORAGE_KEY } = require(\"./utils/logger/constants\");\n        chrome.storage.local.set({\n          [LOG_CONFIG_STORAGE_KEY]: { ...loggerService.config, ...config },\n        });\n        return;\n      }\n    } catch {}\n\n    // 在网页上下文中，要求内容脚本持久化它\n    window.postMessage(\n      {\n        action: RECLAIM_SDK_ACTIONS.SET_LOG_CONFIG,\n        extensionID,\n        data: { config },\n      },\n      \"*\",\n    );\n  }\n\n  getLogConfig() {\n    return loggerService.config;\n  }\n}\n\nexport const trexReclaimExtensionSDK = new ReclaimExtensionSDK();\n/** @deprecated Use trexReclaimExtensionSDK. Kept for backward compatibility. */\nexport const reclaimExtensionSDK = trexReclaimExtensionSDK;\nexport { ReclaimExtensionProofRequest as TrexExtensionProofRequest };\nexport default ReclaimExtensionSDK;\n"],"names":["DebugLogType","Object","freeze","BACKGROUND","CONTENT","POPUP","INIT","VERIFICATION","FETCH","PROVIDER","CLAIM","PROOF","OFFSCREEN","POLYFILLS","SESSION_TIMER","debugLogger","DebugLogger","_classCallCheck","this","enabled","allowedTypes","Set","key","value","typesArray","Array","isArray","clear","type","_console","size","has","color","typeColor","_len","arguments","length","args","_key","console","log","apply","concat","_console2","_len2","_key2","info","_console3","_len3","_key3","warn","_console4","_len4","_key4","error","level","undefined","colors","background","content","popup","init","verification","fetch","provider","claim","proof","offscreen","polyfills","baseColor","keys","find","k","toLowerCase","includes","process","env","disable","enable","exports","read","buffer","offset","isLE","mLen","nBytes","e","m","eLen","eMax","eBias","nBits","i","d","s","NaN","Infinity","Math","pow","write","c","rt","abs","isNaN","floor","LN2","base64","ieee754","customInspectSymbol","Symbol","Buffer","K_MAX_LENGTH","createBuffer","RangeError","buf","Uint8Array","setPrototypeOf","prototype","arg","encodingOrOffset","TypeError","allocUnsafe","from","string","encoding","isEncoding","byteLength","actual","slice","fromString","ArrayBuffer","isView","arrayView","isInstance","copy","fromArrayBuffer","byteOffset","fromArrayLike","fromArrayView","SharedArrayBuffer","valueOf","b","obj","isBuffer","len","checked","numberIsNaN","data","fromObject","toPrimitive","assertSize","array","toString","mustMatch","loweredCase","utf8ToBytes","base64ToBytes","slowToString","start","end","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","n","bidirectionalIndexOf","val","dir","arrayIndexOf","indexOf","call","lastIndexOf","arr","indexSize","arrLength","valLength","String","readUInt16BE","foundIndex","found","j","hexWrite","Number","remaining","strLen","parsed","parseInt","substr","utf8Write","blitBuffer","asciiWrite","str","byteArray","push","charCodeAt","asciiToBytes","base64Write","ucs2Write","units","hi","lo","utf16leToBytes","fromByteArray","min","res","firstByte","codePoint","bytesPerSequence","secondByte","thirdByte","fourthByte","tempCodePoint","codePoints","MAX_ARGUMENTS_LENGTH","fromCharCode","decodeCodePointsArray","TYPED_ARRAY_SUPPORT","proto","foo","typedArraySupport","defineProperty","enumerable","get","poolSize","alloc","fill","allocUnsafeSlow","_isBuffer","compare","a","x","y","list","pos","set","swap16","swap32","swap64","toLocaleString","equals","inspect","max","replace","trim","target","thisStart","thisEnd","thisCopy","targetCopy","isFinite","Error","toJSON","_arr","ret","out","hexSliceLookupTable","bytes","checkOffset","ext","checkInt","wrtBigUInt64LE","checkIntBI","BigInt","wrtBigUInt64BE","checkIEEE754","writeFloat","littleEndian","noAssert","writeDouble","newBuf","subarray","readUintLE","readUIntLE","mul","readUintBE","readUIntBE","readUint8","readUInt8","readUint16LE","readUInt16LE","readUint16BE","readUint32LE","readUInt32LE","readUint32BE","readUInt32BE","readBigUInt64LE","defineBigIntMethod","validateNumber","first","last","boundsError","readBigUInt64BE","readIntLE","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readBigInt64LE","readBigInt64BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUintLE","writeUIntLE","writeUintBE","writeUIntBE","writeUint8","writeUInt8","writeUint16LE","writeUInt16LE","writeUint16BE","writeUInt16BE","writeUint32LE","writeUInt32LE","writeUint32BE","writeUInt32BE","writeBigUInt64LE","writeBigUInt64BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeBigInt64LE","writeBigInt64BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","copyWithin","code","errors","E","sym","getMessage","Base","constructor","super","writable","configurable","name","stack","message","addNumericalSeparator","range","ERR_OUT_OF_RANGE","checkBounds","ERR_INVALID_ARG_TYPE","ERR_BUFFER_OUT_OF_BOUNDS","input","msg","received","isInteger","INVALID_BASE64_RE","leadSurrogate","toByteArray","split","base64clean","src","dst","alphabet","table","i16","fn","BufferBigIntNotDefined","WebSocketPolyfill","window","_createClass","url","protocols","_this3","readyState","setTimeout","onclose","reason","Promise","reject","_BrowserWebSocket","_this","_callSuper","addEventListener","event","onerror","onopen","onmessage","_inherits","_this2","resolve","send","WebSocket","module","t","r","iterator","o","toStringTag","Generator","u","create","_regeneratorDefine2","f","p","G","v","bind","l","done","GeneratorFunction","GeneratorFunctionPrototype","getPrototypeOf","__proto__","displayName","_regenerator","w","_invoke","asyncGeneratorStep","then","getUserLocationBasedOnIp","_ref","_callee","_data$country_code","response","countryCode","_t","_context","json","status","_next","_throw","b64","lens","getLens","validLen","placeHoldersLen","tmp","Arr","_byteLength","curByte","revLookup","uint8","extraBytes","parts","maxChunkLength","len2","encodeChunk","lookup","join","tripletToBase64","num","output","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","defaultClearTimeout","runTimeout","fun","clearTimeout","currentQueue","queue","draining","queueIndex","cleanUpNextTick","drainQueue","timeout","run","marker","runClearTimeout","Item","noop","nextTick","title","browser","argv","version","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","umask","_asyncToGenerator","fetchProviderData","providerId","sessionId","appId","logger","createContextLogger","source","LOG_TYPES","FETCH_DATA","API_ENDPOINTS","PROVIDER_URL","ok","JSON","stringify","logLevel","LOG_LEVEL","INFO","providers","ERROR","eventType","EVENT_TYPES","RECLAIM_PROVIDER_DATA_FETCH_ERROR","_x","_x2","_x3","updateSessionStatus","_ref2","_callee2","_t2","_context2","UPDATE_SESSION_STATUS","method","headers","body","UPDATE_SESSION_STATUS_ERROR","_x4","_x5","_x6","_x7","submitProofOnCallback","_ref3","_callee3","proofs","submitUrl","jsonStringOfProofs","urlEncodedProofs","_t3","_context3","encodeURIComponent","text","RECLAIM_SESSION_STATUS","PROOF_SUBMISSION_FAILED","SUBMITTING_PROOF_TO_CALLBACK_URL_SUCCESS","PROOF_SUBMITTED","_x8","_x9","_x0","_x1","_x10","offscreenLogger","offscreenReady","offscreenDocTimeout","offscreenCreationPromise","offscreenGlobalListener","action","MESSAGE_ACTIONS","OFFSCREEN_DOCUMENT_READY","MESSAGE_SOURCES","installOffscreenReadyListener","chrome","runtime","onMessage","hasListener","setupOffscreenReadyListener","createOffscreenDocumentInternal","_createOffscreenDocumentInternal","offscreenUrl","getURL","meta","createDocument","reasons","justification","waitForOffscreenReadyInternal","_waitForOffscreenReadyInternal","timeoutMs","_args2","sendMessage","PING_OFFSCREEN","listener","localTimeoutId","ensureOffscreenDocument","_ensureOffscreenDocument","getContexts","contextTypes","closeDocument","closeOffscreenDocument","_closeOffscreenDocument","_callee4","_context4","generateProof","claimData","bgLogger","proofLogger","setContext","applicationId","messageTimeout","success","messageListener","GENERATE_PROOF_RESPONSE","_response$proof","_response$proof2","all","ALL","embeddedErr","GENERATE_PROOF","lastError","formatProof","requestData","_proof$publicData","identifier","signatures","toHexString","claimSignature","witnesses","id","attestorAddress","ATTESTOR_WS_URL","taskId","publicData","providerRequest","signatureObject","hexString","values","map","byte","padStart","Jsep","addUnaryOp","op_name","max_unop_len","unary_ops","addBinaryOp","precedence","isRightAssociative","max_binop_len","binary_ops","right_associative","add","delete","addIdentifierChar","char","additional_identifier_chars","addLiteral","literal_name","literal_value","literals","removeUnaryOp","getMaxKeyLen","removeAllUnaryOps","removeIdentifierChar","removeBinaryOp","removeAllBinaryOps","removeLiteral","removeAllLiterals","expr","charAt","index","parse","isDecimalDigit","ch","binaryPrecedence","op_val","isIdentifierStart","isIdentifierPart","throwError","description","runHook","node","hooks","context","searchHook","callback","gobbleSpaces","SPACE_CODE","TAB_CODE","LF_CODE","CR_CODE","nodes","gobbleExpressions","COMPOUND","untilICode","ch_i","SEMCOL_CODE","COMMA_CODE","gobbleExpression","gobbleBinaryExpression","gobbleBinaryOp","to_check","tc_len","hasOwnProperty","biop","prec","biop_info","left","right","cur_biop","gobbleToken","right_a","comparePrev","prev","pop","BINARY_EXP","operator","PERIOD_CODE","gobbleNumericLiteral","SQUOTE_CODE","DQUOTE_CODE","gobbleStringLiteral","OBRACK_CODE","gobbleArray","argument","UNARY_EXP","prefix","gobbleIdentifier","LITERAL","raw","this_str","THIS_EXP","OPAREN_CODE","gobbleGroup","gobbleTokenProperty","QUMARK_CODE","optional","MEMBER_EXP","computed","object","property","CBRACK_CODE","CALL_EXP","gobbleArguments","CPAREN_CODE","callee","chCode","number","parseFloat","startIndex","quote","closed","substring","IDENTIFIER","termination","separator_count","SEQUENCE_EXP","expressions","ARRAY_EXP","elements","forEach","assign","plugins","jsep","registered","register","plugin","COLON_CODE","stdClassProps","getOwnPropertyNames","filter","prop","ternary","test","consequent","alternate","newTest","patternIndex","inCharSet","pattern","flags","RegExp","assignmentOperators","updateOperators","assignmentPrecedence","updateNodeTypes","updateBinariesToAssignments","op","some","BLOCKED_PROTO_PROPERTIES","SafeEval","evalAst","ast","subs","evalBinaryExpression","evalCompound","evalConditionalExpression","evalIdentifier","evalLiteral","evalMemberExpression","evalUnaryExpression","evalArrayExpression","evalCallExpression","evalAssignmentExpression","SyntaxError","hasOwn","ReferenceError","result","typeof","el","func","item","unshift","NewError","avoidNew","JSONPath","opts","otherTypeCallback","optObj","path","resultType","flatten","wrap","sandbox","eval","ignoreEvalErrors","parent","parentProperty","autostart","evaluate","currParent","currParentProperty","currResultType","currEval","currSandbox","currOtherTypeCallback","toPathString","exprList","toPathArray","shift","_hasParentSelector","_trace","ea","isParentSelector","hasArrExpr","reduce","rslt","valOrPath","_getPreferredOutput","pointer","toPointer","_handleCallback","fullRetObj","preferredOutput","parentPropName","literalPriority","retObj","loc","addRet","elems","_walk","_slice","safeLoc","nested","exec","npath","nvalue","_eval","at","addType","valueType","locProp","part","rett","tl","tt","splice","step","_v","_vname","_$_parentProperty","_$_parent","_$_property","_$_root","_$_v","containsPath","_$_path","scriptCacheKey","cache","script","replaceAll","safeVm","Script","vm","CurrEval","runInNewContext","pathArr","subx","$0","$1","ups","exp","match","keyMap","funcs","conditionCb","il","moveToAnotherArray","vr","fString","lastStatementEnd","Function","getValueFromJsonPath","jsonData","jsonPath","results","finalResult","getValueFromXPath","htmlString","xPath","element","regex","convertTemplateToRegex","template","_step","parameters","escapedTemplate","allVars","paramRegex","variables","getTemplateVariables","unsubstitutedVars","_iterator","_createForOfIteratorHelper","param","replacement","endsWith","err","extractDynamicParamNames","extractParamsFromUrl","urlTemplate","actualUrl","paramValues","paramNames","extractParamsFromBody","bodyTemplate","actualBody","extractParamsFromResponse","responseText","responseMatches","responseRedactions","isJson","trimmed","startsWith","isJsonFormat","jsonText","safeJsonParse","redaction","matchingRedaction","extractedValue","regexMatch","_typeof","CLAIM_CREATION","CLAIM_PARAMETER_VALIDATION_FAILED_EXCEPTION","separateParams","publicParams","secretParams","entries","_slicedToArray","ownKeys","getOwnPropertySymbols","getOwnPropertyDescriptor","_objectSpread","_defineProperty","getOwnPropertyDescriptors","defineProperties","_toPrimitive","_toPropertyKey","_arrayWithHoles","next","_iterableToArrayLimit","_arrayLikeToArray","_unsupportedIterableToArray","_nonIterableRest","generateChromeAndroidUserAgent","chromeMajorVersion","isMobile","chromeVersionString","mobileToken","getPrivateKeyFromOffscreen","callTimeout","sender","GET_PRIVATE_KEY_RESPONSE","privateKey","GET_PRIVATE_KEY","createClaimObject","request","providerData","_providerData$bodySni2","_providerData$geoLoca","loginUrl","userAgent","PUBLIC_HEADERS","params","publicHeaders","secretHeaders","_providerData$bodySni","allParamValues","_separateParams","secretParamValues","ownerPrivateKey","geoLocation","claimObject","_args","CLAIM_CREATION_STARTED","OFFSCREEN_DOCUMENT_NOT_READY_EXCEPTION","navigator","urlType","Referer","referer","origin","lowerKey","bodySniff","cookieStr","extractedParams","invert","cleanedRedaction","_ref4","_ref5","responseSelections","selection","cleanedSelection","additionalClientOptions","CLAIM_CREATION_FAILED","client","CLAIM_CREATION_SUCCESS","SessionTimerManager","sessionTimer","sessionTimerDuration","sessionTimerPaused","sessionTimerRemainingTime","sessionTimerStartTime","onSessionTimeout","sessionTimeoutCallback","clearSessionTimer","Date","now","startSessionTimer","elapsedTime","sessionDuration","startVerification","_startVerification","ctx","templateData","providerUrl","callbackUrl","generatedProofs","Map","filteredRequests","initPopupMessage","providerDataMessage","providerRequestsByHash","aborted","sessionTimerManager","clearAllTimers","firstRequestReceived","tabs","tab","_ctx$providerData","_ctx$providerData2","_ctx$providerData3","activeTabId","managedTabs","providerName","dataRequired","verificationConfig","popupMessage","SHOW_PROVIDER_VERIFICATION_POPUP","CONTENT_SCRIPT","PROVIDER_DATA_READY","USER_STARTED_VERIFICATION","activeSessionId","failSession","_failSession","errorMessage","requestHash","_t4","VERIFICATION_FLOW_FAILED","PROOF_GENERATION_FAILED","originalTabId","proofGenerationQueue","isProcessingQueue","submitProofs","_submitProofs","_callee5","_ctx$providerData4","hasTemplateList","completedTemplate","formattedProofs","templateHashes","rd","_iterator2","_step2","_step2$value","hash","_proof","finalProofs","submitted","_t5","_t6","_t7","_t9","_t0","_t1","_t11","_context5","expectManyClaims","expectedPageUrl","fp","_ctx$publicData","SUBMITTING_PROOF","SUBMITTING_PROOF_TO_CALLBACK_URL","SUBMITTING_PROOF_TO_CALLBACK_URL_FAILED","PROOF_GENERATION_SUCCESS","update","active","cancelSession","_cancelSession","_callee7","_t12","_t13","_t14","_t15","_t16","_t17","_context7","RECLAIM_VERIFICATION_DISMISSED","_callee6","_context6","remove","_handleMessage","sendResponse","_sender$tab6","_sender$tab8","_sender$tab","isManaged","pendingMessage","_pendingMessage","_sender$tab2","_sender$tab3","_isManaged","_result","_sender$tab4","_sender$tab5","_sender$tab7","turningOff","_sender$tab9","_sender$tab0","_result2","_sender$tab1","tabId","_results$","_result3","CONTENT_SCRIPT_LOADED","REQUEST_PROVIDER_DATA","CHECK_IF_MANAGED_TAB","START_VERIFICATION","CANCEL_VERIFICATION","CLOSE_CURRENT_TAB","FILTERED_REQUEST_FOUND","GET_CURRENT_TAB_ID","UPDATE_PUBLIC_DATA","UPDATE_EXPECT_MANY_CLAIMS","GET_PARAMETERS","REPORT_PROVIDER_ERROR","REQUEST_CLAIM","INJECT_VIA_SCRIPTING","SHOULD_INITIALIZE","shouldInitialize","VERIFICATION_POPUP_ERROR","RECLAIM_VERIFICATION_PROVIDER_LOAD_EXCEPTION","IS_RECLAIM_EXTENSION_SDK","VERIFICATION_FLOW_STARTED","loggerService","startFlushInterval","sessionManager","criteria","processFilteredRequest","expectMany","scripting","executeScript","world","location","href","xhr","XMLHttpRequest","open","withCredentials","setRequestHeader","onreadystatechange","showAlert","__reclaimCustomInjectionDone__","nonce","document","querySelector","createElement","setAttribute","textContent","documentElement","head","appendChild","_unused2","tryWithNonce","trustedTypes","_i","_names","policy","createPolicy","createScript","_unused3","_unused4","tryWithTT","_unused5","tryPlain","addToProofGenerationQueue","pauseSessionTimer","processNextQueueItem","_processNextQueueItem","templateCount","task","proofResponseObject","_templateCount","_completedTemplate","resumeSessionTimer","PROOF_GENERATION_ABORTED","PROOF_GENERATION_STARTED","resetSessionTimer","_toConsumableArray","_arrayWithoutHoles","_iterableToArray","_nonIterableSpread","getCookiesForUrl","_getCookiesForUrl","urlObj","domain","isHttps","guessETLDPlusOne","makeTopLevelSiteCandidates","domainVariants","getStores","safeGetAll","domainMatches","pathMatches","localShouldInclude","betterCookie","allCookies","stores","queries","pushQuery","dVariants","topLevelSites","storeId","_iterator3","_step3","_iterator4","_step4","_d","_iterator6","_step6","topLevelSite","_iterator5","_step5","_topLevelSite","pages","keyOf","candidates","_allCookies","cookie","uniqueCookies","cookies","getAll","URL","hostname","protocol","host","sldTlds","lastTwo","lastThree","base","variants","_stores","getAllCookieStores","details","reqHost","cookieDomain","hostOnly","cd","reqPath","cookiePath","shouldIncludeCookie","_a$path","_b$path","_a$path2","_b$path2","aExp","expirationDate","bExp","aLast","lastAccessed","bLast","q","qq","partitionKey","_c$partitionKey","sort","pl","requestDomain","pathname","isSecureRequest","secure","initBackground","LOG_CONFIG_STORAGE_KEY","require","storage","local","cfg","setConfig","onChanged","changes","area","newCfg","newValue","_unused","_ctx$providerData$geo","criteriaWithGeo","cookieUtils","CLAIM_CREATION_REQUESTED","STARTING_CLAIM_CREATION","proofQueue","setCallbacks","setTimerDuration","messageRouter","onRemoved","lostActive","noManagedLeft","LogEntry","logLine","_ref$time","time","deviceId","dateTime","getTime","ts","fromDateTimeToTimeStamp","_defineProperties","LoggerService","logs","isSending","maxBatchSize","flushInterval","flushIntervalId","config","DEFAULT_LOG_CONFIG","_chrome$storage","partial","clearInterval","setInterval","flush","_getDeviceLoggingId","DEVICE_ID_STORAGE_KEY","crypto","randomUUID","logEntry","requestedLevel","LOG_LEVEL_MAP","line","shouldLog","consoleEnabled","emitToConsole","entry","addLog","_flush","logsToSend","sendLogs","_sendLogs","formattedLogs","getDeviceLoggingId","toJson","LOGGING_ENDPOINTS","DIAGNOSTIC_LOGGING","_loggerService$config","initial","debug","PROVIDER_DATA","PROOF_GENERATION","PROOF_SUBMISSION","PROOF_VERIFICATION","LOG_SOURCES","INJECTION","REQUEST_MATCHED","RESPONSE_MATCH_FAILED","X_PATH_MATCH_REQUIREMENT_FAILED","JSON_PATH_MATCH_REQUIREMENT_FAILED","REGEX_MATCH_REQUIREMENT_FAILED","FILTER_REQUEST_ERROR","RESULT_RECEIVED","TAB_NOT_MANAGED_BY_EXTENSION_EXCEPTION","INJECTION_SCRIPT_SET_IN_LOCAL_STORAGE_FAILED","DEBUG","BACKEND_URL","SUBMIT_PROOF","STATUS_URL","RECLAIM_SDK_ACTIONS","CHECK_EXTENSION","EXTENSION_RESPONSE","VERIFICATION_STARTED","VERIFICATION_COMPLETED","VERIFICATION_FAILED","SET_PUBLIC_DATA","PARAMETERS_UPDATE","PARAMETERS_GET","SET_EXPECT_MANY_CLAIMS","SET_LOG_CONFIG","SESSION_INIT","SESSION_STARTED","USER_INIT_VERIFICATION","PROOF_MANUAL_VERIFICATION_SUBMITED","INJECTION_SCRIPT","GENERATE_PROOF_REQUEST","GENERATED_PROOF_RESPONSE","GENERATE_CLAIM_ON_ATTESTOR","INTERCEPTED_REQUEST_AND_RESPONSE","GET_PROVIDER_ID","PROVIDER_ID_RESPONSE","_digest","_writeFile","_readFile","global","self","isServiceWorker","isContentScript","contentType","moduleName","fs","os","originalRequire","getRandomValues","random","subtle","digest","algorithm","hashInt","acc","CustomURL","OriginalURL","readFileSync","writeFileSync","existsSync","promises","readFile","writeFile","tmpdir","homedir","platform","cpus","model","speed","totalmem","freemem","dirname","basename","extname","dotIndex","sep","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","loaded","__webpack_modules__","getter","__esModule","definition","hmd","children","isSafeInteger","lengths","outputLen","blockLen","exists","instance","checkFinished","destroyed","finished","U32_MASK64","_32n","fromBig","le","h","lst","Ah","Uint32Array","Al","rotlSH","rotlSL","rotlBH","rotlBL","toBig","shrSH","_l","shrSL","rotrSH","rotrSL","rotrBH","rotrBL","rotr32H","_h","rotr32L","Bh","Bl","add3L","Cl","add3H","low","Ch","add4L","Dl","add4H","Dh","add5H","Eh","add5L","El","globalThis","u8a","u32","DataView","rotr","word","async","iters","tick","cb","diff","toBytes","TextEncoder","encode","Hash","clone","_cloneInto","toStr","checkOpts","defaults","hashCons","hashC","bytesLength","SHA3_PI","SHA3_ROTL","_SHA3_IOTA","_0n","_1n","_2n","_7n","_256n","_0x71n","round","R","SHA3_IOTA_H","SHA3_IOTA_L","rotlH","rotlL","Keccak","suffix","enableXOF","rounds","posOut","state","state32","keccak","B","idx1","idx0","B0","B1","Th","Tl","curH","curL","PI","keccakP","take","finish","writeInto","bufferOut","xofInto","xof","digestInto","destroy","to","gen","keccak_256","checkType","types","resolveProperties","accum","seen","HEX","makeError","shortMessage","check","_normalizeForms","form","normalize","assertNormalize","operation","assertPrivate","givenGuard","guard","className","_getBytes","getBytesCopy","isHexString","isBytesLike","HexCharacters","hexlify","datas","dataLength","dataSlice","zeroPad","zeroPadValue","locked","_keccak256","__keccak256","keccak256","_data","_","lock","SHA2","padOffset","view","dataView","roundClean","setBigUint64","_u32_max","wh","wl","setUint32","oview","outLen","Chi","Maj","SHA256_K","IV","SHA256_W","SHA256","A","C","D","F","H","getUint32","W15","W2","s0","s1","T1","T2","hex","hexToNumber","hexByte","reverse","numberToBytesLE","expectedLength","arrays","sum","pad","bitMask","u8n","u8fr","createHmacDrbg","hashLen","qByteLen","hmacFn","reset","reseed","seed","sl","pred","validatorFns","bigint","function","boolean","stringOrUint8Array","field","Fp","isValid","validateObject","validators","optValidators","checkField","fieldName","isOptional","checkVal","_3n","_4n","_5n","_8n","power","modulo","pow2","FpSqrt","P","p1div4","root","eql","sqr","c1","n2","nv","ONE","legendreC","Q","S","Z","Q1div2","neg","g","ZERO","t2","ge","tonelliShanks","FIELD_FIELDS","nLength","nBitLength","_nBitLength","nByteLength","ceil","getFieldBytesLength","fieldOrder","bitLength","getMinHashLength","HMAC","iHash","oHash","hmac","validateBasic","curve","ORDER","MASK","BYTES","BITS","Gx","Gy","b2n","h2b","DER","Err","_parseInt","toSig","sBytes","rBytesLeft","hexFromSig","sig","shl","rhl","rl","weierstrassPoints","CURVE","allowedPrivateKeyLengths","wrapPrivateKey","isTorsionFree","clearCofactor","allowInfinityPoint","fromBytes","endo","beta","splitScalar","validatePointOpts","_c","point","_isCompressed","toAffine","tail","weierstrassEquation","x2","x3","isWithinCurveOrder","assertGE","normPrivateKeyToScalar","pointPrecomputes","assertPrjPoint","other","Point","px","py","pz","fromAffine","is0","normalizeZ","points","toInv","invertBatch","fromHex","assertValidity","fromPrivateKey","BASE","multiply","_setWindowSize","windowSize","_WINDOW_SIZE","hasEvenY","isOdd","X1","Y1","Z1","X2","Y2","Z2","U1","U2","negate","double","b3","X3","Y3","Z3","t0","t1","t3","t4","t5","subtract","wNAF","wnaf","wNAFCached","comp","multiplyUnsafe","I","unsafeLadder","k1neg","k1","k2neg","k2","k1p","k2p","scalar","fake","f1p","f2p","constTimeNegate","multiplyAndAddUnsafe","iz","z","inv","ax","ay","zz","cofactor","toRawBytes","isCompressed","toHex","_bits","bits","condition","W","windows","elm","precomputeWindow","precomputes","mask","maxNumber","shiftBy","wbits","offset1","offset2","cond1","cond2","precomputesMap","transform","ProjectivePoint","weierstrass","curveDef","randomBytes","bits2int","bits2int_modN","lowS","validateOpts","compressedLen","uncompressedLen","modN","CURVE_ORDER","invN","cat","y2","sqrt","numToNByteStr","isBiggerThanHalfOrder","slcNum","Signature","recovery","fromCompact","fromDER","addRecoveryBit","recoverPublicKey","msgHash","rec","radj","ir","u1","u2","hasHighS","normalizeS","toDERRawBytes","toDERHex","toCompactRawBytes","toCompactHex","utils","isValidPrivateKey","randomPrivateKey","fieldLen","minLen","reduced","precompute","isProbPub","delta","ORDER_MASK","int2octets","prepSig","defaultSigOpts","prehash","extraEntropy","ent","h1int","seedArgs","k2sig","kBytes","ik","normS","defaultVerOpts","getPublicKey","getSharedSecret","privateA","publicB","sign","privKey","drbg","verify","signature","publicKey","sg","_sig","derError","is","getHash","msgs","secp256k1P","secp256k1N","divNearest","sqrtMod","_6n","_11n","_22n","_23n","_44n","_88n","b2","b6","b9","b11","b22","b44","b88","b176","b220","b223","bitLen","redef","sqrtP","lhs","rhs","FpPow","div","sqrN","addN","subN","mulN","nums","lastMultiplied","inverted","reduceRight","FpInvertBatch","cmov","Field","secp256k1","defHash","createCurve","a1","b1","a2","POW_2_128","c2","BN_0","BN_1","maxValue","getBigInt","getUint","fault","Nibbles","toBigInt","toBeHex","_value","_width","width","toBeArray","ZeroHash","BN_2","BN_27","BN_28","BN_35","_guard","toUint256","_s","networkV","legacyChainId","getChainId","yParity","yParityAndS","compactSerialized","serialized","for","_type","bv","getChainIdV","chainId","getNormalizedV","assertError","_r","SigningKey","computePublicKey","compressedPublicKey","computeSharedSecret","pubKey","compressed","pub","secpSig","addPoints","p0","p1","pub0","pub1","BN_36","getChecksumAddress","address","chars","expanded","hashed","toUpperCase","ibanLookup","ibanChecksum","block","checksum","Base36","fromBase36","checkAddress","promise","resolveAddress","resolver","resolveName","getAddress","ignoreFunc","badCodepoint","ignore","toUtf8Bytes","pair","hashMessage","arrayifyInteger","_encode","payload","child","nibbles","encodeRlp","hashAuthorization","auth","padding","BN__1","BN_MAX_UINT256","hexTrue","hexFalse","domainFieldTypes","verifyingContract","salt","domainFieldNames","checkString","domainChecks","toQuantity","getBaseEncoder","signed","boundsUpper","boundsLower","toTwos","hexPadRight","encodeType","fields","splitArray","count","TypedDataEncoder","primaryType","_types","links","parents","subtypes","uniqueNames","baseType","primaryTypes","checkCircular","subtype","st","getEncoder","encoder","subEncoder","encodedType","encodeData","hashStruct","_visit","visit","getPrimaryType","hashDomain","domainFields","EIP712Domain","resolveNames","ensCache","getPayload","domainValues","domainTypes","typesWithDomain","ZeroAddress","pbkdf2Init","_password","_salt","_opts","dkLen","asyncTick","password","DK","PRF","PRFSalt","pbkdf2Output","prfW","pbkdf2","ti","Ti","setInt32","ui","SHA512_Kh","SHA512_Kl","SHA512_W_H","SHA512_W_L","SHA512","Fh","Fl","Gh","Gl","Hh","Hl","W15h","W15l","s0h","s0l","W2h","W2l","s1h","s1l","SUMl","SUMh","sigma1h","sigma1l","CHIh","CHIl","T1ll","T1h","T1l","sigma0h","sigma0l","MAJh","MAJl","All","sha512","anyGlobal","getGlobal","msCrypto","createHash","algo","_sha256","_sha512","__sha256","__sha512","locked256","locked512","hexlifyByte","unarrayifyInteger","_decodeChildren","childOffset","decoded","_decode","consumed","lengthLength","decodeRlp","accessSetify","addr","storageKeys","storageKey","accessListify","localeCompare","computeAddress","pubkey","BN_MAX_UINT","BLOB_SIZE","getVersionedHash","versioned","handleAddress","handleAccessList","handleAuthorizationList","handleUint","handleNumber","formatNumber","formatAccessList","formatHashes","_parseEipSignature","tx","Transaction","typeName","gasLimit","gasPrice","maxPriorityFeePerGas","maxFeePerGas","accessList","authorizationList","auths","authorizationify","maxFeePerBlobGas","blobVersionedHashes","blobs","_blobs","versionedHashes","blob","padded","commit","blobToKzgCommitment","computeBlobKzgProof","commitment","kzg","blobToKZGCommitment","computeBlobProof","computeBlobKZGProof","getKzgLibrary","unsignedHash","unsignedSerialized","fromPublicKey","isSigned","sidecar","inferType","legacy","_serializeLegacy","_serializeEip2930","_serializeEip1559","_serializeEip4844","_serializeEip7702","inferTypes","hasGasPrice","hasFee","hasAccessList","hasBlob","isLegacy","isBerlin","isLondon","isCancun","_parseLegacy","_parseEip2930","_parseEip1559","fBlobs","fCommits","fProofs","_parseEip4844","_parseEip7702","copyRequest","req","bigIntKeys","numberKeys","blockTag","enableCcipRead","customData","checkProvider","signer","populate","AbstractSigner","getNonce","getTransactionCount","populateCall","populateTransaction","estimateGas","network","getNetwork","hasEip1559","feeData","getFeeData","populateAuthorization","_auth","sendTransaction","txObj","broadcastTransaction","signTransaction","authorize","authorization","VoidSigner","connect","signMessage","signTypedData","BaseWallet","signingKey","btx","signMessageSync","authorizeSync","populated","_computeHmac","_algo","sha256","createHmac","__computeHmac","computeHmac","Rho","Id","idxL","idxR","shifts","shiftsL","idx","shiftsR","Kl","Kr","rotl","group","BUF","RIPEMD160","h0","h1","h2","h3","h4","al","ar","bl","br","cl","cr","dl","dr","er","rGroup","hbl","hbr","rr","sr","tr","ripemd160","_ripemd160","__ripemd160","_randomBytes","__randomBytes","Alphabet","Lookup","getAlpha","letter","BN_58","subsChrs","Word","unfold","words","decodeOwl","clumps","leftover","semi","decode","Wordlist","locale","phrase","WordlistOwl","_decodeWords","getWord","getWordIndex","wordlist","LangEn","_pbkdf2","iterations","keylen","pbkdf2Sync","__pbkdf2","getUpperMask","getLowerMask","mnemonicToEntropy","mnemonic","entropy","bit","entropyBits","checksumMask","entropyToMnemonic","indices","remainingBits","checksumBits","Mnemonic","computeSeed","fromPhrase","fromEntropy","_entropy","entropyToPhrase","phraseToEntropy","isValidMnemonic","_AES_key","_AES_Kd","_AES_Ke","__classPrivateFieldGet","receiver","kind","__classPrivateFieldSet","numberOfRounds","rcon","Si","T3","T4","T5","T6","T7","T8","U3","U4","convertToInt32","AES","roundKeyCount","KC","tk","rconpointer","encrypt","plaintext","decrypt","ciphertext","WeakMap","ModeOfOperation","cls","aes","_CBC_iv","_CBC_lastBlock","CBC","iv","_CFB_shiftRegister","WeakSet","_CTR_remaining","_CTR_remainingIndex","_CTR_counter","CTR","initialValue","setCounterValue","setCounterBytes","counter","MAX_SAFE_INTEGER","increment","_a","_b","crypttext","XorAndSalsa","pi","ii","oi","y00","y01","y02","y03","y04","y05","y06","y07","y08","y09","y10","y11","y12","y13","y14","y15","x00","x01","x02","x03","x04","x05","x06","x07","x08","x09","x10","x11","x12","x13","x14","x15","BlockMix","scryptInit","maxmem","N","onProgress","blockSize","blockSize32","memUsed","B32","V","blockMixCb","totalBlockMix","callbackPer","blockMixCnt","scryptOutput","lockedSync","lockedAsync","_scryptAsync","passwd","Pi","_scryptSync","__scryptAsync","__scryptSync","_passwd","progress","scryptSync","uuidV4","looseArrayify","zpad","getPassword","spelunk","_path","reqd","cur","defaultPath","isKeystoreJson","getAccount","account","mnemonicKey","mnemonicCiphertext","mnemonicIv","mnemonicAesCtr","getDecryptKdfParams","kdf","prf","stall","duration","getEncryptKdfParams","options","scrypt","_encryptKeystore","uuidRandom","uuid","derivedKey","macPrefix","mac","Crypto","cipher","cipherparams","kdfparams","dklen","gethFilename","getUTCFullYear","getUTCMonth","getUTCDate","getUTCHours","getUTCMinutes","getUTCSeconds","mnemonicCounter","encryptKeystoreJsonSync","passwordBytes","encryptKeystoreJson","progressCallback","MasterSecret","HardenedBit","trunc","encodeBase58Check","encodeBase58","ser_I","chainCode","IL","IR","derivePath","components","depth","component","deriveChild","HDNodeWallet","fingerprint","parentFingerprint","encryptSync","extendedKey","hasPath","neuter","HDNodeVoidWallet","_index","ki","_seed","fromExtendedKey","decodeBase58","createRandom","fromMnemonic","fromSeed","Ki","isCrowdsaleJson","encseed","decryptCrowdsaleJson","encryptedSeed","padder","pkcs7Strip","seedHex","Wallet","wallet","fromEncryptedJson","decryptKeystoreJson","fromEncryptedJsonSync","decryptKeystoreJsonSync","_verificationQueue","_queueRunning","SDK_VERSION","__SDK_VERSION__","_enqueueVerification","_drainQueue","_drainQueue2","ReclaimExtensionProofRequest","_location","timestamp","contextAddress","contextMessage","redirectUrl","sdkVersion","resolvedProviderVersion","jsonProofResponse","extensionID","providerVersion","acceptAiProviders","_backgroundInitialized","_ctx","_listeners","started","completed","_boundWindowListener","_handleWindowMessage","_mode","_boundChromeHandler","messageId","_emit","_startVerificationInternal","_cancel","_this4","offErr","postMessage","_startVerificationInternal2","_this5","offStarted","offCompleted","cleanup","offError","resp","_chrome","removeEventListener","_initSession2","_init","appSecret","canonical","initRes","_args5","getBytes","_initSession","versionNumber","fromConfig","_config$jsonProofResp","_config$acceptAiProvi","_config$options","timeStamp","appCallbackUrl","ReclaimExtensionSDK","_location2","_ref4$timeout","handler","_event$data","_event$data2","installed","_init2","_args6","fromJsonString","trexReclaimExtensionSDK","reclaimExtensionSDK"],"sourceRoot":""}