@shutter-network/shutter-sdk
Version:
TypeScript SDK for interacting with the Shutter crypto library, providing encryption, decryption, and utilities.
1,269 lines (1,268 loc) • 111 kB
JavaScript
"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// src/crypto/blst/blst.js
var require_blst = __commonJS({
"src/crypto/blst/blst.js"(exports2, module2) {
"use strict";
var blst = typeof blst != "undefined" ? blst : {};
var ENVIRONMENT_IS_WEB = typeof window == "object";
var ENVIRONMENT_IS_WORKER = typeof importScripts == "function";
var ENVIRONMENT_IS_NODE = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string";
var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
if (blst["ENVIRONMENT"]) {
throw new Error(
"blst.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -sENVIRONMENT=web or -sENVIRONMENT=node)"
);
}
if (ENVIRONMENT_IS_NODE) {
}
var moduleOverrides = Object.assign({}, blst);
var arguments_ = [];
var thisProgram = "./this.program";
var quit_ = (status, toThrow) => {
throw toThrow;
};
var scriptDirectory = "";
function locateFile(path) {
if (blst["locateFile"]) {
return blst["locateFile"](path, scriptDirectory);
}
return scriptDirectory + path;
}
var read_;
var readAsync;
var readBinary;
if (ENVIRONMENT_IS_NODE) {
if (typeof process == "undefined" || !process.release || process.release.name !== "node")
throw new Error(
"not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)"
);
nodeVersion = process.versions.node;
numericVersion = nodeVersion.split(".").slice(0, 3);
numericVersion = numericVersion[0] * 1e4 + numericVersion[1] * 100 + numericVersion[2].split("-")[0] * 1;
minVersion = 16e4;
if (numericVersion < 16e4) {
throw new Error(
"This emscripten-generated code requires node v16.0.0 (detected v" + nodeVersion + ")"
);
}
fs = require("fs");
nodePath = require("path");
scriptDirectory = __dirname + "/";
read_ = (filename, binary) => {
filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
return fs.readFileSync(filename, binary ? void 0 : "utf8");
};
readBinary = (filename) => {
var ret = read_(filename, true);
if (!ret.buffer) {
ret = new Uint8Array(ret);
}
assert(ret.buffer);
return ret;
};
readAsync = (filename, onload, onerror, binary = true) => {
filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
fs.readFile(filename, binary ? void 0 : "utf8", (err2, data) => {
if (err2) onerror(err2);
else onload(binary ? data.buffer : data);
});
};
if (!blst["thisProgram"] && process.argv.length > 1) {
thisProgram = process.argv[1].replace(/\\/g, "/");
}
arguments_ = process.argv.slice(2);
if (typeof module2 != "undefined") {
module2["exports"] = blst;
}
process.on("uncaughtException", (ex) => {
if (ex !== "unwind" && !(ex instanceof ExitStatus) && !(ex.context instanceof ExitStatus)) {
throw ex;
}
});
quit_ = (status, toThrow) => {
process.exitCode = status;
throw toThrow;
};
} else if (ENVIRONMENT_IS_SHELL) {
if (typeof process == "object" && typeof require === "function" || typeof window == "object" || typeof importScripts == "function")
throw new Error(
"not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)"
);
} else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
if (ENVIRONMENT_IS_WORKER) {
scriptDirectory = self.location.href;
} else if (typeof document != "undefined" && document.currentScript) {
scriptDirectory = document.currentScript.src;
}
if (scriptDirectory.startsWith("blob:")) {
scriptDirectory = "";
} else {
scriptDirectory = scriptDirectory.substr(
0,
scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1
);
}
if (!(typeof window == "object" || typeof importScripts == "function"))
throw new Error(
"not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)"
);
{
read_ = (url) => {
var xhr = new XMLHttpRequest();
xhr.open("GET", url, false);
xhr.send(null);
return xhr.responseText;
};
if (ENVIRONMENT_IS_WORKER) {
readBinary = (url) => {
var xhr = new XMLHttpRequest();
xhr.open("GET", url, false);
xhr.responseType = "arraybuffer";
xhr.send(null);
return new Uint8Array(
/** @type{!ArrayBuffer} */
xhr.response
);
};
}
readAsync = (url, onload, onerror) => {
if (isFileURI(url)) {
var xhr = new XMLHttpRequest();
xhr.open("GET", url, true);
xhr.responseType = "arraybuffer";
xhr.onload = () => {
if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
onload(xhr.response);
return;
}
onerror();
};
xhr.onerror = onerror;
xhr.send(null);
return;
}
fetch(url, { credentials: "same-origin" }).then((response) => {
if (response.ok) {
return response.arrayBuffer();
}
return Promise.reject(new Error(response.status + " : " + response.url));
}).then(onload, onerror);
};
}
} else {
throw new Error("environment detection error");
}
var nodeVersion;
var numericVersion;
var minVersion;
var fs;
var nodePath;
var out = blst["print"] || console.log.bind(console);
var err = blst["printErr"] || console.error.bind(console);
Object.assign(blst, moduleOverrides);
moduleOverrides = null;
checkIncomingModuleAPI();
if (blst["arguments"]) arguments_ = blst["arguments"];
legacyModuleProp("arguments", "arguments_");
if (blst["thisProgram"]) thisProgram = blst["thisProgram"];
legacyModuleProp("thisProgram", "thisProgram");
if (blst["quit"]) quit_ = blst["quit"];
legacyModuleProp("quit", "quit_");
assert(
typeof blst["memoryInitializerPrefixURL"] == "undefined",
"blst.memoryInitializerPrefixURL option was removed, use blst.locateFile instead"
);
assert(
typeof blst["pthreadMainPrefixURL"] == "undefined",
"blst.pthreadMainPrefixURL option was removed, use blst.locateFile instead"
);
assert(
typeof blst["cdInitializerPrefixURL"] == "undefined",
"blst.cdInitializerPrefixURL option was removed, use blst.locateFile instead"
);
assert(
typeof blst["filePackagePrefixURL"] == "undefined",
"blst.filePackagePrefixURL option was removed, use blst.locateFile instead"
);
assert(typeof blst["read"] == "undefined", "blst.read option was removed (modify read_ in JS)");
assert(
typeof blst["readAsync"] == "undefined",
"blst.readAsync option was removed (modify readAsync in JS)"
);
assert(
typeof blst["readBinary"] == "undefined",
"blst.readBinary option was removed (modify readBinary in JS)"
);
assert(
typeof blst["setWindowTitle"] == "undefined",
"blst.setWindowTitle option was removed (modify emscripten_set_window_title in JS)"
);
assert(
typeof blst["TOTAL_MEMORY"] == "undefined",
"blst.TOTAL_MEMORY has been renamed blst.INITIAL_MEMORY"
);
legacyModuleProp("asm", "wasmExports");
legacyModuleProp("read", "read_");
legacyModuleProp("readAsync", "readAsync");
legacyModuleProp("readBinary", "readBinary");
legacyModuleProp("setWindowTitle", "setWindowTitle");
assert(
!ENVIRONMENT_IS_SHELL,
"shell environment detected but not enabled at build time. Add `shell` to `-sENVIRONMENT` to enable."
);
var wasmBinary;
if (blst["wasmBinary"]) wasmBinary = blst["wasmBinary"];
legacyModuleProp("wasmBinary", "wasmBinary");
if (typeof WebAssembly != "object") {
err("no native wasm support detected");
}
var wasmMemory;
var ABORT = false;
var EXITSTATUS;
function assert(condition, text) {
if (!condition) {
abort("Assertion failed" + (text ? ": " + text : ""));
}
}
var HEAP8;
var HEAPU8;
var HEAP16;
var HEAPU16;
var HEAP32;
var HEAPU32;
var HEAPF32;
var HEAPF64;
function updateMemoryViews() {
var b = wasmMemory.buffer;
blst["HEAP8"] = HEAP8 = new Int8Array(b);
blst["HEAP16"] = HEAP16 = new Int16Array(b);
blst["HEAPU8"] = HEAPU8 = new Uint8Array(b);
blst["HEAPU16"] = HEAPU16 = new Uint16Array(b);
blst["HEAP32"] = HEAP32 = new Int32Array(b);
blst["HEAPU32"] = HEAPU32 = new Uint32Array(b);
blst["HEAPF32"] = HEAPF32 = new Float32Array(b);
blst["HEAPF64"] = HEAPF64 = new Float64Array(b);
}
assert(
!blst["STACK_SIZE"],
"STACK_SIZE can no longer be set at runtime. Use -sSTACK_SIZE at link time"
);
assert(
typeof Int32Array != "undefined" && typeof Float64Array !== "undefined" && Int32Array.prototype.subarray != void 0 && Int32Array.prototype.set != void 0,
"JS engine does not provide full typed array support"
);
assert(
!blst["wasmMemory"],
"Use of `wasmMemory` detected. Use -sIMPORTED_MEMORY to define wasmMemory externally"
);
assert(
!blst["INITIAL_MEMORY"],
"Detected runtime INITIAL_MEMORY setting. Use -sIMPORTED_MEMORY to define wasmMemory dynamically"
);
function writeStackCookie() {
var max = _emscripten_stack_get_end();
assert((max & 3) == 0);
if (max == 0) {
max += 4;
}
HEAPU32[max >> 2] = 34821223;
HEAPU32[max + 4 >> 2] = 2310721022;
HEAPU32[0 >> 2] = 1668509029;
}
function checkStackCookie() {
if (ABORT) return;
var max = _emscripten_stack_get_end();
if (max == 0) {
max += 4;
}
var cookie1 = HEAPU32[max >> 2];
var cookie2 = HEAPU32[max + 4 >> 2];
if (cookie1 != 34821223 || cookie2 != 2310721022) {
abort(
`Stack overflow! Stack cookie has been overwritten at ${ptrToString(max)}, expected hex dwords 0x89BACDFE and 0x2135467, but received ${ptrToString(cookie2)} ${ptrToString(cookie1)}`
);
}
if (HEAPU32[0 >> 2] != 1668509029) {
abort("Runtime error: The application has corrupted its heap memory area (address zero)!");
}
}
(function() {
var h16 = new Int16Array(1);
var h8 = new Int8Array(h16.buffer);
h16[0] = 25459;
if (h8[0] !== 115 || h8[1] !== 99)
throw "Runtime error: expected the system to be little-endian! (Run with -sSUPPORT_BIG_ENDIAN to bypass)";
})();
var __ATPRERUN__ = [];
var __ATINIT__ = [];
var __ATPOSTRUN__ = [];
var runtimeInitialized = false;
function preRun() {
if (blst["preRun"]) {
if (typeof blst["preRun"] == "function") blst["preRun"] = [blst["preRun"]];
while (blst["preRun"].length) {
addOnPreRun(blst["preRun"].shift());
}
}
callRuntimeCallbacks(__ATPRERUN__);
}
function initRuntime() {
assert(!runtimeInitialized);
runtimeInitialized = true;
checkStackCookie();
callRuntimeCallbacks(__ATINIT__);
}
function postRun() {
checkStackCookie();
if (blst["postRun"]) {
if (typeof blst["postRun"] == "function") blst["postRun"] = [blst["postRun"]];
while (blst["postRun"].length) {
addOnPostRun(blst["postRun"].shift());
}
}
callRuntimeCallbacks(__ATPOSTRUN__);
}
function addOnPreRun(cb) {
__ATPRERUN__.unshift(cb);
}
function addOnInit(cb) {
__ATINIT__.unshift(cb);
}
function addOnPostRun(cb) {
__ATPOSTRUN__.unshift(cb);
}
assert(
Math.imul,
"This browser does not support Math.imul(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill"
);
assert(
Math.fround,
"This browser does not support Math.fround(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill"
);
assert(
Math.clz32,
"This browser does not support Math.clz32(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill"
);
assert(
Math.trunc,
"This browser does not support Math.trunc(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill"
);
var runDependencies = 0;
var runDependencyWatcher = null;
var dependenciesFulfilled = null;
var runDependencyTracking = {};
function addRunDependency(id) {
runDependencies++;
blst["monitorRunDependencies"]?.(runDependencies);
if (id) {
assert(!runDependencyTracking[id]);
runDependencyTracking[id] = 1;
if (runDependencyWatcher === null && typeof setInterval != "undefined") {
runDependencyWatcher = setInterval(() => {
if (ABORT) {
clearInterval(runDependencyWatcher);
runDependencyWatcher = null;
return;
}
var shown = false;
for (var dep in runDependencyTracking) {
if (!shown) {
shown = true;
err("still waiting on run dependencies:");
}
err(`dependency: ${dep}`);
}
if (shown) {
err("(end of list)");
}
}, 1e4);
}
} else {
err("warning: run dependency added without ID");
}
}
function removeRunDependency(id) {
runDependencies--;
blst["monitorRunDependencies"]?.(runDependencies);
if (id) {
assert(runDependencyTracking[id]);
delete runDependencyTracking[id];
} else {
err("warning: run dependency removed without ID");
}
if (runDependencies == 0) {
if (runDependencyWatcher !== null) {
clearInterval(runDependencyWatcher);
runDependencyWatcher = null;
}
if (dependenciesFulfilled) {
var callback = dependenciesFulfilled;
dependenciesFulfilled = null;
callback();
}
}
}
function abort(what) {
blst["onAbort"]?.(what);
what = "Aborted(" + what + ")";
err(what);
ABORT = true;
EXITSTATUS = 1;
var e = new WebAssembly.RuntimeError(what);
throw e;
}
var FS = {
error() {
abort(
"Filesystem support (FS) was not included. The problem is that you are using files from JS, but files were not used from C/C++, so filesystem support was not auto-included. You can force-include filesystem support with -sFORCE_FILESYSTEM"
);
},
init() {
FS.error();
},
createDataFile() {
FS.error();
},
createPreloadedFile() {
FS.error();
},
createLazyFile() {
FS.error();
},
open() {
FS.error();
},
mkdev() {
FS.error();
},
registerDevice() {
FS.error();
},
analyzePath() {
FS.error();
},
ErrnoError() {
FS.error();
}
};
blst["FS_createDataFile"] = FS.createDataFile;
blst["FS_createPreloadedFile"] = FS.createPreloadedFile;
var dataURIPrefix = "data:application/octet-stream;base64,";
var isDataURI = (filename) => filename.startsWith(dataURIPrefix);
var isFileURI = (filename) => filename.startsWith("file://");
function createExportWrapper(name, nargs) {
return (...args) => {
assert(runtimeInitialized, `native function \`${name}\` called before runtime initialization`);
var f = wasmExports[name];
assert(f, `exported native function \`${name}\` not found`);
assert(
args.length <= nargs,
`native function \`${name}\` called with ${args.length} args but expects ${nargs}`
);
return f(...args);
};
}
var EmscriptenEH = class extends Error {
};
var CppException = class extends EmscriptenEH {
constructor(excPtr) {
super(excPtr);
this.excPtr = excPtr;
const excInfo = getExceptionMessage(excPtr);
this.name = excInfo[0];
this.message = excInfo[1];
}
};
function findWasmBinary() {
var f = "blst.wasm";
if (!isDataURI(f)) {
return locateFile(f);
}
return f;
}
var wasmBinaryFile;
function getBinarySync(file) {
if (file == wasmBinaryFile && wasmBinary) {
return new Uint8Array(wasmBinary);
}
if (readBinary) {
return readBinary(file);
}
throw "both async and sync fetching of the wasm failed";
}
function getBinaryPromise(binaryFile) {
if (!wasmBinary) {
return new Promise((resolve, reject) => {
readAsync(
binaryFile,
(response) => resolve(new Uint8Array(
/** @type{!ArrayBuffer} */
response
)),
(error) => {
try {
resolve(getBinarySync(binaryFile));
} catch (e) {
reject(e);
}
}
);
});
}
return Promise.resolve().then(() => getBinarySync(binaryFile));
}
function instantiateArrayBuffer(binaryFile, imports, receiver) {
return getBinaryPromise(binaryFile).then((binary) => {
return WebAssembly.instantiate(binary, imports);
}).then(receiver, (reason) => {
err(`failed to asynchronously prepare wasm: ${reason}`);
if (isFileURI(wasmBinaryFile)) {
err(
`warning: Loading from a file URI (${wasmBinaryFile}) is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing`
);
}
abort(reason);
});
}
function instantiateAsync(binary, binaryFile, imports, callback) {
if (!binary && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(binaryFile) && // Don't use streaming for file:// delivered objects in a webview, fetch them synchronously.
!isFileURI(binaryFile) && // Avoid instantiateStreaming() on Node.js environment for now, as while
// Node.js v18.1.0 implements it, it does not have a full fetch()
// implementation yet.
//
// Reference:
// https://github.com/emscripten-core/emscripten/pull/16917
!ENVIRONMENT_IS_NODE && typeof fetch == "function") {
return fetch(binaryFile, { credentials: "same-origin" }).then((response) => {
var result = WebAssembly.instantiateStreaming(response, imports);
return result.then(callback, function(reason) {
err(`wasm streaming compile failed: ${reason}`);
err("falling back to ArrayBuffer instantiation");
return instantiateArrayBuffer(binaryFile, imports, callback);
});
});
}
return instantiateArrayBuffer(binaryFile, imports, callback);
}
function getWasmImports() {
return {
env: wasmImports,
wasi_snapshot_preview1: wasmImports
};
}
function createWasm() {
var info = getWasmImports();
function receiveInstance(instance, module3) {
wasmExports = instance.exports;
wasmMemory = wasmExports["memory"];
assert(wasmMemory, "memory not found in wasm exports");
updateMemoryViews();
wasmTable = wasmExports["__indirect_function_table"];
assert(wasmTable, "table not found in wasm exports");
addOnInit(wasmExports["__wasm_call_ctors"]);
removeRunDependency("wasm-instantiate");
return wasmExports;
}
addRunDependency("wasm-instantiate");
var trueModule = blst;
function receiveInstantiationResult(result) {
assert(
blst === trueModule,
"the blst object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?"
);
trueModule = null;
receiveInstance(result["instance"]);
}
if (blst["instantiateWasm"]) {
try {
return blst["instantiateWasm"](info, receiveInstance);
} catch (e) {
err(`blst.instantiateWasm callback failed with error: ${e}`);
return false;
}
}
if (!wasmBinaryFile) wasmBinaryFile = findWasmBinary();
instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult);
return {};
}
function legacyModuleProp(prop, newName, incoming = true) {
if (!Object.getOwnPropertyDescriptor(blst, prop)) {
Object.defineProperty(blst, prop, {
configurable: true,
get() {
let extra = incoming ? " (the initial value can be provided on blst, but after startup the value is only looked for on a local variable of that name)" : "";
abort(`\`blst.${prop}\` has been replaced by \`${newName}\`` + extra);
}
});
}
}
function ignoredModuleProp(prop) {
if (Object.getOwnPropertyDescriptor(blst, prop)) {
abort(`\`blst.${prop}\` was supplied but \`${prop}\` not included in INCOMING_MODULE_JS_API`);
}
}
function isExportedByForceFilesystem(name) {
return name === "FS_createPath" || name === "FS_createDataFile" || name === "FS_createPreloadedFile" || name === "FS_unlink" || name === "addRunDependency" || // The old FS has some functionality that WasmFS lacks.
name === "FS_createLazyFile" || name === "FS_createDevice" || name === "removeRunDependency";
}
function missingGlobal(sym, msg) {
if (typeof globalThis != "undefined") {
Object.defineProperty(globalThis, sym, {
configurable: true,
get() {
warnOnce(`\`${sym}\` is not longer defined by emscripten. ${msg}`);
return void 0;
}
});
}
}
missingGlobal("buffer", "Please use HEAP8.buffer or wasmMemory.buffer");
missingGlobal("asm", "Please use wasmExports instead");
function missingLibrarySymbol(sym) {
if (typeof globalThis != "undefined" && !Object.getOwnPropertyDescriptor(globalThis, sym)) {
Object.defineProperty(globalThis, sym, {
configurable: true,
get() {
var msg = `\`${sym}\` is a library symbol and not included by default; add it to your library.js __deps or to DEFAULT_LIBRARY_FUNCS_TO_INCLUDE on the command line`;
var librarySymbol = sym;
if (!librarySymbol.startsWith("_")) {
librarySymbol = "$" + sym;
}
msg += ` (e.g. -sDEFAULT_LIBRARY_FUNCS_TO_INCLUDE='${librarySymbol}')`;
if (isExportedByForceFilesystem(sym)) {
msg += ". Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you";
}
warnOnce(msg);
return void 0;
}
});
}
unexportedRuntimeSymbol(sym);
}
function unexportedRuntimeSymbol(sym) {
if (!Object.getOwnPropertyDescriptor(blst, sym)) {
Object.defineProperty(blst, sym, {
configurable: true,
get() {
var msg = `'${sym}' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the Emscripten FAQ)`;
if (isExportedByForceFilesystem(sym)) {
msg += ". Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you";
}
abort(msg);
}
});
}
}
function blst_exception(code) {
throw new Error(BLST_ERROR_str[code]);
}
function ExitStatus(status) {
this.name = "ExitStatus";
this.message = `Program terminated with exit(${status})`;
this.status = status;
}
var callRuntimeCallbacks = (callbacks) => {
while (callbacks.length > 0) {
callbacks.shift()(blst);
}
};
var lengthBytesUTF8 = (str) => {
var len = 0;
for (var i = 0; i < str.length; ++i) {
var c = str.charCodeAt(i);
if (c <= 127) {
len++;
} else if (c <= 2047) {
len += 2;
} else if (c >= 55296 && c <= 57343) {
len += 4;
++i;
} else {
len += 3;
}
}
return len;
};
var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {
assert(typeof str === "string", `stringToUTF8Array expects a string (got ${typeof str})`);
if (!(maxBytesToWrite > 0)) return 0;
var startIdx = outIdx;
var endIdx = outIdx + maxBytesToWrite - 1;
for (var i = 0; i < str.length; ++i) {
var u = str.charCodeAt(i);
if (u >= 55296 && u <= 57343) {
var u1 = str.charCodeAt(++i);
u = 65536 + ((u & 1023) << 10) | u1 & 1023;
}
if (u <= 127) {
if (outIdx >= endIdx) break;
heap[outIdx++] = u;
} else if (u <= 2047) {
if (outIdx + 1 >= endIdx) break;
heap[outIdx++] = 192 | u >> 6;
heap[outIdx++] = 128 | u & 63;
} else if (u <= 65535) {
if (outIdx + 2 >= endIdx) break;
heap[outIdx++] = 224 | u >> 12;
heap[outIdx++] = 128 | u >> 6 & 63;
heap[outIdx++] = 128 | u & 63;
} else {
if (outIdx + 3 >= endIdx) break;
if (u > 1114111)
warnOnce(
"Invalid Unicode code point " + ptrToString(u) + " encountered when serializing a JS string to a UTF-8 string in wasm memory! (Valid unicode code points should be in range 0-0x10FFFF)."
);
heap[outIdx++] = 240 | u >> 18;
heap[outIdx++] = 128 | u >> 12 & 63;
heap[outIdx++] = 128 | u >> 6 & 63;
heap[outIdx++] = 128 | u & 63;
}
}
heap[outIdx] = 0;
return outIdx - startIdx;
};
function intArrayFromString(stringy, dontAddNull, length) {
var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1;
var u8array = new Array(len);
var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);
if (dontAddNull) u8array.length = numBytesWritten;
return u8array;
}
var noExitRuntime = blst["noExitRuntime"] || true;
var ptrToString = (ptr) => {
assert(typeof ptr === "number");
ptr >>>= 0;
return "0x" + ptr.toString(16).padStart(8, "0");
};
var stackRestore = (val) => __emscripten_stack_restore(val);
var stackSave = () => _emscripten_stack_get_current();
var warnOnce = (text) => {
warnOnce.shown ||= {};
if (!warnOnce.shown[text]) {
warnOnce.shown[text] = 1;
if (ENVIRONMENT_IS_NODE) text = "warning: " + text;
err(text);
}
};
var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : void 0;
var UTF8ArrayToString = (heapOrArray, idx, maxBytesToRead) => {
var endIdx = idx + maxBytesToRead;
var endPtr = idx;
while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;
if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
}
var str = "";
while (idx < endPtr) {
var u0 = heapOrArray[idx++];
if (!(u0 & 128)) {
str += String.fromCharCode(u0);
continue;
}
var u1 = heapOrArray[idx++] & 63;
if ((u0 & 224) == 192) {
str += String.fromCharCode((u0 & 31) << 6 | u1);
continue;
}
var u2 = heapOrArray[idx++] & 63;
if ((u0 & 240) == 224) {
u0 = (u0 & 15) << 12 | u1 << 6 | u2;
} else {
if ((u0 & 248) != 240)
warnOnce(
"Invalid UTF-8 leading byte " + ptrToString(u0) + " encountered when deserializing a UTF-8 string in wasm memory to a JS string!"
);
u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heapOrArray[idx++] & 63;
}
if (u0 < 65536) {
str += String.fromCharCode(u0);
} else {
var ch = u0 - 65536;
str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
}
}
return str;
};
var UTF8ToString = (ptr, maxBytesToRead) => {
assert(typeof ptr == "number", `UTF8ToString expects a number (got ${typeof ptr})`);
return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
};
var ___assert_fail = (condition, filename, line, func) => {
abort(
`Assertion failed: ${UTF8ToString(condition)}, at: ` + [
filename ? UTF8ToString(filename) : "unknown filename",
line,
func ? UTF8ToString(func) : "unknown function"
]
);
};
var exceptionCaught = [];
var uncaughtExceptionCount = 0;
var ___cxa_begin_catch = (ptr) => {
var info = new ExceptionInfo(ptr);
if (!info.get_caught()) {
info.set_caught(true);
uncaughtExceptionCount--;
}
info.set_rethrown(false);
exceptionCaught.push(info);
___cxa_increment_exception_refcount(info.excPtr);
return info.get_exception_ptr();
};
var exceptionLast = 0;
var ___cxa_end_catch = () => {
_setThrew(0, 0);
assert(exceptionCaught.length > 0);
var info = exceptionCaught.pop();
___cxa_decrement_exception_refcount(info.excPtr);
exceptionLast = 0;
};
var ExceptionInfo = class {
// excPtr - Thrown object pointer to wrap. Metadata pointer is calculated from it.
constructor(excPtr) {
this.excPtr = excPtr;
this.ptr = excPtr - 24;
}
set_type(type) {
HEAPU32[this.ptr + 4 >> 2] = type;
}
get_type() {
return HEAPU32[this.ptr + 4 >> 2];
}
set_destructor(destructor) {
HEAPU32[this.ptr + 8 >> 2] = destructor;
}
get_destructor() {
return HEAPU32[this.ptr + 8 >> 2];
}
set_caught(caught) {
caught = caught ? 1 : 0;
HEAP8[this.ptr + 12] = caught;
}
get_caught() {
return HEAP8[this.ptr + 12] != 0;
}
set_rethrown(rethrown) {
rethrown = rethrown ? 1 : 0;
HEAP8[this.ptr + 13] = rethrown;
}
get_rethrown() {
return HEAP8[this.ptr + 13] != 0;
}
// Initialize native structure fields. Should be called once after allocated.
init(type, destructor) {
this.set_adjusted_ptr(0);
this.set_type(type);
this.set_destructor(destructor);
}
set_adjusted_ptr(adjustedPtr) {
HEAPU32[this.ptr + 16 >> 2] = adjustedPtr;
}
get_adjusted_ptr() {
return HEAPU32[this.ptr + 16 >> 2];
}
// Get pointer which is expected to be received by catch clause in C++ code. It may be adjusted
// when the pointer is casted to some of the exception object base classes (e.g. when virtual
// inheritance is used). When a pointer is thrown this method should return the thrown pointer
// itself.
get_exception_ptr() {
var isPointer = ___cxa_is_pointer_type(this.get_type());
if (isPointer) {
return HEAPU32[this.excPtr >> 2];
}
var adjusted = this.get_adjusted_ptr();
if (adjusted !== 0) return adjusted;
return this.excPtr;
}
};
var ___resumeException = (ptr) => {
if (!exceptionLast) {
exceptionLast = new CppException(ptr);
}
throw exceptionLast;
};
var setTempRet0 = (val) => __emscripten_tempret_set(val);
var findMatchingCatch = (args) => {
var thrown = exceptionLast?.excPtr;
if (!thrown) {
setTempRet0(0);
return 0;
}
var info = new ExceptionInfo(thrown);
info.set_adjusted_ptr(thrown);
var thrownType = info.get_type();
if (!thrownType) {
setTempRet0(0);
return thrown;
}
for (var caughtType of args) {
if (caughtType === 0 || caughtType === thrownType) {
break;
}
var adjusted_ptr_addr = info.ptr + 16;
if (___cxa_can_catch(caughtType, thrownType, adjusted_ptr_addr)) {
setTempRet0(caughtType);
return thrown;
}
}
setTempRet0(thrownType);
return thrown;
};
var ___cxa_find_matching_catch_2 = () => findMatchingCatch([]);
var ___cxa_find_matching_catch_3 = (arg0) => findMatchingCatch([arg0]);
var ___cxa_throw = (ptr, type, destructor) => {
var info = new ExceptionInfo(ptr);
info.init(type, destructor);
exceptionLast = new CppException(ptr);
uncaughtExceptionCount++;
throw exceptionLast;
};
var __abort_js = () => {
abort("native code called abort()");
};
var __emscripten_memcpy_js = (dest, src, num) => HEAPU8.copyWithin(dest, src, src + num);
var abortOnCannotGrowMemory = (requestedSize) => {
abort(
`Cannot enlarge memory arrays to size ${requestedSize} bytes (OOM). Either (1) compile with -sINITIAL_MEMORY=X with X higher than the current value ${HEAP8.length}, (2) compile with -sALLOW_MEMORY_GROWTH which allows increasing the size at runtime, or (3) if you want malloc to return NULL (0) instead of this abort, compile with -sABORTING_MALLOC=0`
);
};
var _emscripten_resize_heap = (requestedSize) => {
var oldSize = HEAPU8.length;
requestedSize >>>= 0;
abortOnCannotGrowMemory(requestedSize);
};
var _fd_close = (fd) => {
abort("fd_close called without SYSCALLS_REQUIRE_FILESYSTEM");
};
var convertI32PairToI53Checked = (lo, hi) => {
assert(lo == lo >>> 0 || lo == (lo | 0));
assert(hi === (hi | 0));
return hi + 2097152 >>> 0 < 4194305 - !!lo ? (lo >>> 0) + hi * 4294967296 : NaN;
};
function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {
var offset = convertI32PairToI53Checked(offset_low, offset_high);
return 70;
}
var printCharBuffers = [null, [], []];
var printChar = (stream, curr) => {
var buffer = printCharBuffers[stream];
assert(buffer);
if (curr === 0 || curr === 10) {
(stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0));
buffer.length = 0;
} else {
buffer.push(curr);
}
};
var _fd_write = (fd, iov, iovcnt, pnum) => {
var num = 0;
for (var i = 0; i < iovcnt; i++) {
var ptr = HEAPU32[iov >> 2];
var len = HEAPU32[iov + 4 >> 2];
iov += 8;
for (var j = 0; j < len; j++) {
printChar(fd, HEAPU8[ptr + j]);
}
num += len;
}
HEAPU32[pnum >> 2] = num;
return 0;
};
var _llvm_eh_typeid_for = (type) => type;
var alignMemory = (size, alignment) => {
assert(alignment, "alignment argument is required");
return Math.ceil(size / alignment) * alignment;
};
var wasmTableMirror = [];
var wasmTable;
var getWasmTableEntry = (funcPtr) => {
var func = wasmTableMirror[funcPtr];
if (!func) {
if (funcPtr >= wasmTableMirror.length) wasmTableMirror.length = funcPtr + 1;
wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr);
}
assert(
wasmTable.get(funcPtr) == func,
"JavaScript-side Wasm function table mirror is out of date!"
);
return func;
};
var incrementExceptionRefcount = (ptr) => ___cxa_increment_exception_refcount(ptr);
blst["incrementExceptionRefcount"] = incrementExceptionRefcount;
var decrementExceptionRefcount = (ptr) => ___cxa_decrement_exception_refcount(ptr);
blst["decrementExceptionRefcount"] = decrementExceptionRefcount;
var stackAlloc = (sz) => __emscripten_stack_alloc(sz);
var getExceptionMessageCommon = (ptr) => {
var sp = stackSave();
var type_addr_addr = stackAlloc(4);
var message_addr_addr = stackAlloc(4);
___get_exception_message(ptr, type_addr_addr, message_addr_addr);
var type_addr = HEAPU32[type_addr_addr >> 2];
var message_addr = HEAPU32[message_addr_addr >> 2];
var type = UTF8ToString(type_addr);
_free(type_addr);
var message;
if (message_addr) {
message = UTF8ToString(message_addr);
_free(message_addr);
}
stackRestore(sp);
return [type, message];
};
var getExceptionMessage = (ptr) => getExceptionMessageCommon(ptr);
blst["getExceptionMessage"] = getExceptionMessage;
function checkIncomingModuleAPI() {
ignoredModuleProp("fetchSettings");
}
var wasmImports = {
/** @export */
__assert_fail: ___assert_fail,
/** @export */
__cxa_begin_catch: ___cxa_begin_catch,
/** @export */
__cxa_end_catch: ___cxa_end_catch,
/** @export */
__cxa_find_matching_catch_2: ___cxa_find_matching_catch_2,
/** @export */
__cxa_find_matching_catch_3: ___cxa_find_matching_catch_3,
/** @export */
__cxa_throw: ___cxa_throw,
/** @export */
__resumeException: ___resumeException,
/** @export */
_abort_js: __abort_js,
/** @export */
_emscripten_memcpy_js: __emscripten_memcpy_js,
/** @export */
blst_exception,
/** @export */
emscripten_resize_heap: _emscripten_resize_heap,
/** @export */
fd_close: _fd_close,
/** @export */
fd_seek: _fd_seek,
/** @export */
fd_write: _fd_write,
/** @export */
invoke_ii,
/** @export */
invoke_iii,
/** @export */
invoke_iiii,
/** @export */
invoke_iiiii,
/** @export */
invoke_iiiiiii,
/** @export */
invoke_iiiiiiiii,
/** @export */
invoke_v,
/** @export */
invoke_vi,
/** @export */
invoke_vii,
/** @export */
invoke_viii,
/** @export */
invoke_viiii,
/** @export */
llvm_eh_typeid_for: _llvm_eh_typeid_for
};
var wasmExports = createWasm();
var ___wasm_call_ctors = createExportWrapper("__wasm_call_ctors", 0);
var _webidl_free = blst["_webidl_free"] = createExportWrapper("webidl_free", 1);
var _free = blst["_free"] = createExportWrapper("free", 1);
var _webidl_malloc = blst["_webidl_malloc"] = createExportWrapper("webidl_malloc", 1);
var _malloc = blst["_malloc"] = createExportWrapper("malloc", 1);
var _emscripten_bind_VoidPtr___destroy___0 = blst["_emscripten_bind_VoidPtr___destroy___0"] = createExportWrapper("emscripten_bind_VoidPtr___destroy___0", 1);
var _const_G1 = blst["_const_G1"] = createExportWrapper("const_G1", 0);
var _const_G2 = blst["_const_G2"] = createExportWrapper("const_G2", 0);
var _const_NEG_G1 = blst["_const_NEG_G1"] = createExportWrapper("const_NEG_G1", 0);
var _const_NEG_G2 = blst["_const_NEG_G2"] = createExportWrapper("const_NEG_G2", 0);
var _SecretKey_0 = blst["_SecretKey_0"] = createExportWrapper("SecretKey_0", 0);
var _SecretKey__destroy__0 = blst["_SecretKey__destroy__0"] = createExportWrapper(
"SecretKey__destroy__0",
1
);
var _SecretKey_keygen_3 = blst["_SecretKey_keygen_3"] = createExportWrapper(
"SecretKey_keygen_3",
4
);
var _SecretKey_derive_master_eip2333_2 = blst["_SecretKey_derive_master_eip2333_2"] = createExportWrapper("SecretKey_derive_master_eip2333_2", 3);
var _SecretKey_derive_child_eip2333_2 = blst["_SecretKey_derive_child_eip2333_2"] = createExportWrapper("SecretKey_derive_child_eip2333_2", 3);
var _SecretKey_from_bendian_1 = blst["_SecretKey_from_bendian_1"] = createExportWrapper(
"SecretKey_from_bendian_1",
2
);
var _SecretKey_from_lendian_1 = blst["_SecretKey_from_lendian_1"] = createExportWrapper(
"SecretKey_from_lendian_1",
2
);
var _SecretKey_to_bendian_0 = blst["_SecretKey_to_bendian_0"] = createExportWrapper(
"SecretKey_to_bendian_0",
1
);
var _SecretKey_to_lendian_0 = blst["_SecretKey_to_lendian_0"] = createExportWrapper(
"SecretKey_to_lendian_0",
1
);
var _Scalar_0 = blst["_Scalar_0"] = createExportWrapper("Scalar_0", 0);
var _Scalar_2 = blst["_Scalar_2"] = createExportWrapper("Scalar_2", 2);
var _Scalar_3 = blst["_Scalar_3"] = createExportWrapper("Scalar_3", 3);
var _Scalar__destroy__0 = blst["_Scalar__destroy__0"] = createExportWrapper(
"Scalar__destroy__0",
1
);
var _Scalar_hash_to_3 = blst["_Scalar_hash_to_3"] = createExportWrapper("Scalar_hash_to_3", 4);
var _Scalar_dup_0 = blst["_Scalar_dup_0"] = createExportWrapper("Scalar_dup_0", 1);
var _Scalar_from_bendian_2 = blst["_Scalar_from_bendian_2"] = createExportWrapper(
"Scalar_from_bendian_2",
3
);
var _Scalar_from_lendian_2 = blst["_Scalar_from_lendian_2"] = createExportWrapper(
"Scalar_from_lendian_2",
3
);
var _Scalar_to_bendian_0 = blst["_Scalar_to_bendian_0"] = createExportWrapper(
"Scalar_to_bendian_0",
1
);
var _Scalar_to_lendian_0 = blst["_Scalar_to_lendian_0"] = createExportWrapper(
"Scalar_to_lendian_0",
1
);
var _Scalar_add_1 = blst["_Scalar_add_1"] = createExportWrapper("Scalar_add_1", 2);
var _Scalar_sub_1 = blst["_Scalar_sub_1"] = createExportWrapper("Scalar_sub_1", 2);
var _Scalar_mul_1 = blst["_Scalar_mul_1"] = createExportWrapper("Scalar_mul_1", 2);
var _Scalar_inverse_0 = blst["_Scalar_inverse_0"] = createExportWrapper("Scalar_inverse_0", 1);
var _PT_p_affine_1 = blst["_PT_p_affine_1"] = createExportWrapper("PT_p_affine_1", 1);
var _PT_q_affine_1 = blst["_PT_q_affine_1"] = createExportWrapper("PT_q_affine_1", 1);
var _PT_pq_affine_2 = blst["_PT_pq_affine_2"] = createExportWrapper("PT_pq_affine_2", 2);
var _PT_pq_2 = blst["_PT_pq_2"] = createExportWrapper("PT_pq_2", 2);
var _PT__destroy__0 = blst["_PT__destroy__0"] = createExportWrapper("PT__destroy__0", 1);
var _PT_dup_0 = blst["_PT_dup_0"] = createExportWrapper("PT_dup_0", 1);
var _PT_is_one_0 = blst["_PT_is_one_0"] = createExportWrapper("PT_is_one_0", 1);
var _PT_is_equal_1 = blst["_PT_is_equal_1"] = createExportWrapper("PT_is_equal_1", 2);
var _PT_sqr_0 = blst["_PT_sqr_0"] = createExportWrapper("PT_sqr_0", 1);
var _PT_mul_1 = blst["_PT_mul_1"] = createExportWrapper("PT_mul_1", 2);
var _PT_final_exp_0 = blst["_PT_final_exp_0"] = createExportWrapper("PT_final_exp_0", 1);
var _PT_in_group_0 = blst["_PT_in_group_0"] = createExportWrapper("PT_in_group_0", 1);
var _PT_to_bendian_0 = blst["_PT_to_bendian_0"] = createExportWrapper("PT_to_bendian_0", 1);
var _PT_finalverify_2 = blst["_PT_finalverify_2"] = createExportWrapper("PT_finalverify_2", 2);
var _PT_one_0 = blst["_PT_one_0"] = createExportWrapper("PT_one_0", 0);
var _Pairing_2 = blst["_Pairing_2"] = createExportWrapper("Pairing_2", 2);
var _Pairing__destroy__0 = blst["_Pairing__destroy__0"] = createExportWrapper(
"Pairing__destroy__0",
1
);
var _Pairing_commit_0 = blst["_Pairing_commit_0"] = createExportWrapper("Pairing_commit_0", 1);
var _Pairing_sizeof_0 = blst["_Pairing_sizeof_0"] = createExportWrapper("Pairing_sizeof_0", 0);
var _Pairing_merge_1 = blst["_Pairing_merge_1"] = createExportWrapper("Pairing_merge_1", 2);
var _Pairing_finalverify_1 = blst["_Pairing_finalverify_1"] = createExportWrapper(
"Pairing_finalverify_1",
2
);
var _Pairing_raw_aggregate_2 = blst["_Pairing_raw_aggregate_2"] = createExportWrapper(
"Pairing_raw_aggregate_2",
3
);
var _Pairing_as_fp12_0 = blst["_Pairing_as_fp12_0"] = createExportWrapper("Pairing_as_fp12_0", 1);
var _P1_Affine_0 = blst["_P1_Affine_0"] = createExportWrapper("P1_Affine_0", 0);
var _P1_Affine_1 = blst["_P1_Affine_1"] = createExportWrapper("P1_Affine_1", 1);
var _P1_Affine_2 = blst["_P1_Affine_2"] = createExportWrapper("P1_Affine_2", 2);
var _P1_Affine__destroy__0 = blst["_P1_Affine__destroy__0"] = createExportWrapper(
"P1_Affine__destroy__0",
1
);
var _P1_Affine_dup_0 = blst["_P1_Affine_dup_0"] = createExportWrapper("P1_Affine_dup_0", 1);
var _P1_Affine_to_jacobian_0 = blst["_P1_Affine_to_jacobian_0"] = createExportWrapper(
"P1_Affine_to_jacobian_0",
1
);
var _P1_Affine_serialize_0 = blst["_P1_Affine_serialize_0"] = createExportWrapper(
"P1_Affine_serialize_0",
1
);
var _P1_Affine_compress_0 = blst["_P1_Affine_compress_0"] = createExportWrapper(
"P1_Affine_compress_0",
1
);
var _P1_Affine_on_curve_0 = blst["_P1_Affine_on_curve_0"] = createExportWrapper(
"P1_Affine_on_curve_0",
1
);
var _P1_Affine_in_group_0 = blst["_P1_Affine_in_group_0"] = createExportWrapper(
"P1_Affine_in_group_0",
1
);
var _P1_Affine_is_inf_0 = blst["_P1_Affine_is_inf_0"] = createExportWrapper(
"P1_Affine_is_inf_0",
1
);
var _P1_Affine_is_equal_1 = blst["_P1_Affine_is_equal_1"] = createExportWrapper(
"P1_Affine_is_equal_1",
2
);
var _P1_Affine_core_verify_7 = blst["_P1_Affine_core_verify_7"] = createExportWrapper(
"P1_Affine_core_verify_7",
8
);
var _P1_Affine_generator_0 = blst["_P1_Affine_generator_0"] = createExportWrapper(
"P1_Affine_generator_0",
0
);
var _P1_0 = blst["_P1_0"] = createExportWrapper("P1_0", 0);
var _P1_affine_1 = blst["_P1_affine_1"] = createExportWrapper("P1_affine_1", 1);
var _P1_secretkey_1 = blst["_P1_secretkey_1"] = createExportWrapper("P1_secretkey_1", 1);
var _P1_2 = blst["_P1_2"] = createExportWrapper("P1_2", 2);
var _P1__destroy__0 = blst["_P1__destroy__0"] = createExportWrapper("P1__destroy__0", 1);
var _P1_dup_0 = blst["_P1_dup_0"] = createExportWrapper("P1_dup_0", 1);
var _P1_to_affine_0 = blst["_P1_to_affine_0"] = createExportWrapper("P1_to_affine_0", 1);
var _P1_serialize_0 = blst["_P1_serialize_0"] = createExportWrapper("P1_serialize_0", 1);
var _P1_compress_0 = blst["_P1_compress_0"] = createExportWrapper("P1_compress_0", 1);
var _P1_on_curve_0 = blst["_P1_on_curve_0"] = createExportWrapper("P1_on_curve_0", 1);
var _P1_in_group_0 = blst["_P1_in_group_0"] = createExportWrapper("P1_in_group_0", 1);
var _P1_is_inf_0 = blst["_P1_is_inf_0"] = createExportWrapper("P1_is_inf_0", 1);
var _P1_is_equal_1 = blst["_P1_is_equal_1"] = createExportWrapper("P1_is_equal_1", 2);
var _P1_aggregate_1 = blst["_P1_aggregate_1"] = createExportWrapper("P1_aggregate_1", 2);
var _P1_sign_with_1 = blst["_P1_sign_with_1"] = createExportWrapper("P1_sign_with_1", 2);
var _P1_hash_to_5 = blst["_P1_hash_to_5"] = createExportWrapper("P1_hash_to_5", 6);
var _P1_encode_to_5 = blst["_P1_encode_to_5"] = createExportWrapper("P1_encode_to_5", 6);
var _P1_mult_1 = blst["_P1_mult_1"] = createExportWrapper("P1_mult_1", 2);
var _P1_mult_2 = blst["_P1_mult_2"] = createExportWrapper("P1_mult_2", 3);
var _P1_cneg_1 = blst["_P1_cneg_1"] = createExportWrapper("P1_cneg_1", 2);
var _P1_add_1 = blst["_P1_add_1"] = createExportWrapper("P1_add_1", 2);
var _P1_add_affine_1 = blst["_P1_add_affine_1"] = createExportWrapper("P1_add_affine_1", 2);
var _P1_dbl_0 = blst["_P1_dbl_0"] = createExportWrapper("P1_dbl_0", 1);
var _P1_generator_0 = blst["_P1_generator_0"] = createExportWrapper("P1_generator_0", 0);
var _Pairing_aggregate_pk_in_g1_6 = blst["_Pairing_aggregate_pk_in_g1_6"] = createExportWra