quantum-resistant-rustykey 0.4.1 → 0.6.0

package/dist/index.mjs

@@ -0,0 +1,2404 @@
+//#region src/vendor/mlkem.js
+async function MLKEM768Module(moduleArg = {}) {
+	var moduleRtn;
+	var Module = moduleArg;
+	var ENVIRONMENT_IS_WEB = typeof window == "object";
+	var ENVIRONMENT_IS_WORKER = typeof WorkerGlobalScope != "undefined";
+	typeof process == "object" && process.versions?.node && process.type;
+	var _scriptName = import.meta.url, readBinary;
+	if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+		try {
+			new URL(".", _scriptName).href;
+		} catch {}
+		if (ENVIRONMENT_IS_WORKER) readBinary = (url) => {
+			var xhr = new XMLHttpRequest();
+			xhr.open("GET", url, false);
+			xhr.responseType = "arraybuffer";
+			xhr.send(null);
+			return new Uint8Array(xhr.response);
+		};
+	}
+	console.log.bind(console);
+	var err = console.error.bind(console);
+	var wasmBinary;
+	var ABORT = false;
+	var readyPromiseResolve, readyPromiseReject;
+	var wasmMemory, HEAP8, HEAP16, HEAP32, HEAPU32, HEAPF32, HEAPF64, HEAP64;
+	var runtimeInitialized = false;
+	function updateMemoryViews() {
+		var b = wasmMemory.buffer;
+		Module["HEAP8"] = HEAP8 = new Int8Array(b);
+		HEAP16 = new Int16Array(b);
+		Module["HEAPU8"] = new Uint8Array(b);
+		new Uint16Array(b);
+		HEAP32 = new Int32Array(b);
+		HEAPU32 = new Uint32Array(b);
+		HEAPF32 = new Float32Array(b);
+		HEAPF64 = new Float64Array(b);
+		HEAP64 = new BigInt64Array(b);
+		new BigUint64Array(b);
+	}
+	function preRun() {}
+	function initRuntime() {
+		runtimeInitialized = true;
+		wasmExports["b"]();
+	}
+	function postRun() {}
+	function abort(what) {
+		what = "Aborted(" + what + ")";
+		err(what);
+		ABORT = true;
+		what += ". Build with -sASSERTIONS for more info.";
+		var e = new WebAssembly.RuntimeError(what);
+		readyPromiseReject?.(e);
+		throw e;
+	}
+	var wasmBinaryFile;
+	function findWasmBinary() {
+		return base64Decode("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");
+	}
+	function getBinarySync(file) {
+		if (ArrayBuffer.isView(file)) return file;
+		if (readBinary) return readBinary(file);
+		throw "both async and sync fetching of the wasm failed";
+	}
+	async function getWasmBinary(binaryFile) {
+		return getBinarySync(binaryFile);
+	}
+	async function instantiateArrayBuffer(binaryFile, imports) {
+		try {
+			var binary = await getWasmBinary(binaryFile);
+			return await WebAssembly.instantiate(binary, imports);
+		} catch (reason) {
+			err(`failed to asynchronously prepare wasm: ${reason}`);
+			abort(reason);
+		}
+	}
+	async function instantiateAsync(binary, binaryFile, imports) {
+		return instantiateArrayBuffer(binaryFile, imports);
+	}
+	function getWasmImports() {
+		return { a: wasmImports };
+	}
+	async function createWasm() {
+		function receiveInstance(instance, module) {
+			wasmExports = instance.exports;
+			wasmMemory = wasmExports["a"];
+			updateMemoryViews();
+			assignWasmExports(wasmExports);
+			return wasmExports;
+		}
+		function receiveInstantiationResult(result2) {
+			return receiveInstance(result2["instance"]);
+		}
+		var info = getWasmImports();
+		wasmBinaryFile ??= findWasmBinary();
+		return receiveInstantiationResult(await instantiateAsync(wasmBinary, wasmBinaryFile, info));
+	}
+	var base64Decode = (b64) => {
+		var b1, b2, i2 = 0, j = 0, bLength = b64.length;
+		var output = new Uint8Array((bLength * 3 >> 2) - (b64[bLength - 2] == "=") - (b64[bLength - 1] == "="));
+		for (; i2 < bLength; i2 += 4, j += 3) {
+			b1 = base64ReverseLookup[b64.charCodeAt(i2 + 1)];
+			b2 = base64ReverseLookup[b64.charCodeAt(i2 + 2)];
+			output[j] = base64ReverseLookup[b64.charCodeAt(i2)] << 2 | b1 >> 4;
+			output[j + 1] = b1 << 4 | b2 >> 2;
+			output[j + 2] = b2 << 6 | base64ReverseLookup[b64.charCodeAt(i2 + 3)];
+		}
+		return output;
+	};
+	function getValue(ptr, type = "i8") {
+		if (type.endsWith("*")) type = "*";
+		switch (type) {
+			case "i1": return HEAP8[ptr];
+			case "i8": return HEAP8[ptr];
+			case "i16": return HEAP16[ptr >> 1];
+			case "i32": return HEAP32[ptr >> 2];
+			case "i64": return HEAP64[ptr >> 3];
+			case "float": return HEAPF32[ptr >> 2];
+			case "double": return HEAPF64[ptr >> 3];
+			case "*": return HEAPU32[ptr >> 2];
+			default: abort(`invalid type for getValue: ${type}`);
+		}
+	}
+	function setValue(ptr, value, type = "i8") {
+		if (type.endsWith("*")) type = "*";
+		switch (type) {
+			case "i1":
+				HEAP8[ptr] = value;
+				break;
+			case "i8":
+				HEAP8[ptr] = value;
+				break;
+			case "i16":
+				HEAP16[ptr >> 1] = value;
+				break;
+			case "i32":
+				HEAP32[ptr >> 2] = value;
+				break;
+			case "i64":
+				HEAP64[ptr >> 3] = BigInt(value);
+				break;
+			case "float":
+				HEAPF32[ptr >> 2] = value;
+				break;
+			case "double":
+				HEAPF64[ptr >> 3] = value;
+				break;
+			case "*":
+				HEAPU32[ptr >> 2] = value;
+				break;
+			default: abort(`invalid type for setValue: ${type}`);
+		}
+	}
+	var stackRestore = (val) => __emscripten_stack_restore(val);
+	var stackSave = () => _emscripten_stack_get_current();
+	var stackAlloc = (sz) => __emscripten_stack_alloc(sz);
+	for (var base64ReverseLookup = new Uint8Array(123), i = 25; i >= 0; --i) {
+		base64ReverseLookup[48 + i] = 52 + i;
+		base64ReverseLookup[65 + i] = i;
+		base64ReverseLookup[97 + i] = 26 + i;
+	}
+	base64ReverseLookup[43] = 62;
+	base64ReverseLookup[47] = 63;
+	Module["stackSave"] = stackSave;
+	Module["stackRestore"] = stackRestore;
+	Module["stackAlloc"] = stackAlloc;
+	Module["setValue"] = setValue;
+	Module["getValue"] = getValue;
+	var __emscripten_stack_restore, __emscripten_stack_alloc, _emscripten_stack_get_current;
+	function assignWasmExports(wasmExports2) {
+		Module["_mlkem768_keypair_derand"] = wasmExports2["c"];
+		Module["_mlkem768_enc_derand"] = wasmExports2["d"];
+		Module["_mlkem768_dec"] = wasmExports2["e"];
+		__emscripten_stack_restore = wasmExports2["f"];
+		__emscripten_stack_alloc = wasmExports2["g"];
+		_emscripten_stack_get_current = wasmExports2["h"];
+	}
+	var wasmImports = {};
+	function run() {
+		preRun();
+		function doRun() {
+			Module["calledRun"] = true;
+			if (ABORT) return;
+			initRuntime();
+			readyPromiseResolve?.(Module);
+			postRun();
+		}
+		doRun();
+	}
+	var wasmExports = await createWasm();
+	run();
+	if (runtimeInitialized) moduleRtn = Module;
+	else moduleRtn = new Promise((resolve, reject) => {
+		readyPromiseResolve = resolve;
+		readyPromiseReject = reject;
+	});
+	return moduleRtn;
+}
+var wasm_module_default = MLKEM768Module;
+var ALGORITHM_NAME = "ML-KEM-768";
+var JWK_ALG = "MLKEM768";
+var KEY_USAGES = [
+	"encapsulateKey",
+	"encapsulateBits",
+	"decapsulateKey",
+	"decapsulateBits"
+];
+var MlKemOperationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "OperationError";
+	}
+};
+var MlKemInvalidAccessError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "InvalidAccessError";
+	}
+};
+var MlKemNotSupportedError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "NotSupportedError";
+	}
+};
+var MlKemDataError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "DataError";
+	}
+};
+var internalKeyData = /* @__PURE__ */ new WeakMap();
+function getInternalKeyData(key) {
+	const keyData = internalKeyData.get(key);
+	if (!keyData) throw new TypeError("Unknown key object");
+	return keyData;
+}
+var cleanupRegistry = new FinalizationRegistry((keyData) => {
+	keyData.publicKeyData.fill(0);
+	keyData.privateSeedData?.fill(0);
+	keyData.privateSecretKeyData?.fill(0);
+});
+function getPublicKeyDataRef(key) {
+	const keyData = getInternalKeyData(key);
+	if (!keyData.publicKeyData) throw new MlKemOperationError("Failed to get public key data");
+	return keyData.publicKeyData;
+}
+function getPrivateKeyDataRef(key) {
+	const keyData = getInternalKeyData(key);
+	if (!keyData.privateSeedData || !keyData.privateSecretKeyData) throw new MlKemOperationError("Failed to get private key data");
+	return keyData;
+}
+var noClone = Symbol("CryptoKey created by mlkem-wasm cannot be cloned");
+var keyIdKey = "_mlkem_wasm";
+var emptyToJSON = () => ({});
+function createKeyObject(type, extractable, usages, keyData) {
+	const key = {
+		type,
+		extractable,
+		algorithm: Object.freeze({ name: ALGORITHM_NAME }),
+		usages: Object.freeze(Array.from(usages)),
+		[keyIdKey]: noClone
+	};
+	Object.defineProperty(key, "toJSON", {
+		value: emptyToJSON,
+		writable: false,
+		enumerable: false,
+		configurable: false
+	});
+	Object.setPrototypeOf(key, CryptoKey.prototype);
+	internalKeyData.set(key, keyData);
+	cleanupRegistry.register(key, keyData);
+	return Object.freeze(key);
+}
+function createPublicKey(publicKeyData, usages) {
+	return createKeyObject("public", true, usages, { publicKeyData });
+}
+function createPrivateKey(publicKeyData, privateSeedData, privateSecretKeyData, extractable, usages) {
+	return createKeyObject("private", extractable, usages, {
+		publicKeyData,
+		privateSeedData,
+		privateSecretKeyData
+	});
+}
+function _isSupportedCryptoKey(key) {
+	return key instanceof CryptoKey && keyIdKey in key && key[keyIdKey] == noClone && internalKeyData.has(key);
+}
+function toBase64url(data) {
+	return btoa(String.fromCharCode(...data)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function fromBase64url(base64url) {
+	const base64 = base64url.replace(/-/g, "+").replace(/_/g, "/");
+	const binary = atob(base64 + "===".slice((base64.length + 3) % 4));
+	return Uint8Array.from(binary, (c) => c.charCodeAt(0));
+}
+var PUBLICKEY_BYTES = 1184;
+var SECRETKEY_BYTES = 2400;
+var CIPHERTEXT_BYTES = 1088;
+var SHARED_SECRET_BYTES = 32;
+var KEYPAIR_RANDOM_BYTES = 64;
+var ENC_RANDOM_BYTES = 32;
+var _module;
+async function getModule() {
+	if (!_module) _module = await wasm_module_default();
+	return _module;
+}
+var getRandomValues = crypto.getRandomValues.bind(crypto);
+function checkAlgorithm(algorithm) {
+	if ((typeof algorithm === "string" ? algorithm.toUpperCase() : typeof algorithm === "object" && algorithm !== null && "name" in algorithm && typeof algorithm.name === "string" ? algorithm.name.toUpperCase() : null) !== ALGORITHM_NAME) throw new TypeError("Unsupported algorithm");
+}
+async function internalGenerateKeyPair(coins) {
+	const module = await getModule();
+	const stackSave = module.stackSave();
+	try {
+		const pkPtr = module.stackAlloc(PUBLICKEY_BYTES);
+		const skPtr = module.stackAlloc(SECRETKEY_BYTES);
+		const coinsPtr = module.stackAlloc(KEYPAIR_RANDOM_BYTES);
+		module.HEAPU8.set(coins, coinsPtr);
+		if (module._mlkem768_keypair_derand(pkPtr, skPtr, coinsPtr) !== 0) throw new MlKemOperationError("Key generation failed");
+		const rawPublicKey = new Uint8Array(PUBLICKEY_BYTES);
+		const rawSecretKey = new Uint8Array(SECRETKEY_BYTES);
+		const rawSeed = new Uint8Array(coins);
+		rawPublicKey.set(module.HEAPU8.subarray(pkPtr, pkPtr + PUBLICKEY_BYTES));
+		rawSecretKey.set(module.HEAPU8.subarray(skPtr, skPtr + SECRETKEY_BYTES));
+		module.HEAPU8.fill(0, pkPtr, pkPtr + PUBLICKEY_BYTES);
+		module.HEAPU8.fill(0, skPtr, skPtr + SECRETKEY_BYTES);
+		module.HEAPU8.fill(0, coinsPtr, coinsPtr + KEYPAIR_RANDOM_BYTES);
+		return {
+			rawPublicKey,
+			rawSecretKey,
+			rawSeed
+		};
+	} finally {
+		module.stackRestore(stackSave);
+	}
+}
+async function generateKey(keyAlgorithm, extractable, usages) {
+	checkAlgorithm(keyAlgorithm);
+	if (!Array.isArray(usages) || usages.some((usage) => !KEY_USAGES.includes(usage))) throw new SyntaxError("Invalid key usages");
+	const { rawPublicKey, rawSecretKey, rawSeed } = await internalGenerateKeyPair(getRandomValues(new Uint8Array(KEYPAIR_RANDOM_BYTES)));
+	return {
+		publicKey: createPublicKey(rawPublicKey, usages.filter((usage) => usage === "encapsulateKey" || usage === "encapsulateBits")),
+		privateKey: createPrivateKey(rawPublicKey, rawSeed, rawSecretKey, extractable, usages.filter((usage) => usage === "decapsulateKey" || usage === "decapsulateBits"))
+	};
+}
+async function exportKey(format, key) {
+	if (!(key instanceof CryptoKey)) throw new TypeError("Expected key to be an instance of CryptoKey");
+	checkAlgorithm(key.algorithm);
+	if (!key.extractable) throw new MlKemOperationError("Key is not extractable");
+	if (format === "spki") {
+		if (key.type !== "public") throw new TypeError("Expected key type to be 'public'");
+		return rawToDer(MLKEM768_SPKI, getPublicKeyDataRef(key)).buffer;
+	}
+	if (format === "pkcs8") {
+		if (key.type !== "private") throw new MlKemInvalidAccessError("Expected key type to be 'private'");
+		return rawToDer(MLKEM768_PKCS8, getPrivateKeyDataRef(key).privateSeedData).buffer;
+	}
+	if (format === "raw-public") {
+		if (key.type !== "public") throw new TypeError("Expected key type to be 'public'");
+		return new Uint8Array(getPublicKeyDataRef(key)).buffer;
+	}
+	if (format === "raw-seed") {
+		if (key.type !== "private") throw new MlKemInvalidAccessError("Expected key type to be 'private'");
+		return new Uint8Array(getPrivateKeyDataRef(key).privateSeedData).buffer;
+	}
+	if (format === "jwk") {
+		const jwk = {
+			kty: "AKP",
+			alg: JWK_ALG,
+			pub: toBase64url(getPublicKeyDataRef(key))
+		};
+		if (key.type === "private") jwk.priv = toBase64url(getPrivateKeyDataRef(key).privateSeedData);
+		jwk.key_ops = key.usages;
+		jwk.ext = key.extractable;
+		return jwk;
+	}
+	throw new MlKemNotSupportedError("Format not supported");
+}
+function bufferSourcetoUint8Array(value) {
+	if (ArrayBuffer.isView(value) && value.buffer instanceof ArrayBuffer) return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+	else if (value instanceof ArrayBuffer) return new Uint8Array(value);
+	else throw new TypeError("Value must be a BufferSource");
+}
+function bufferSourcetoUint8ArrayCopy(value) {
+	return bufferSourcetoUint8Array(value).slice();
+}
+var MLKEM768_SPKI = {
+	fullLength: 1206,
+	prefix: new Uint8Array([
+		48,
+		130,
+		4,
+		178,
+		48,
+		11,
+		6,
+		9,
+		96,
+		134,
+		72,
+		1,
+		101,
+		3,
+		4,
+		4,
+		2,
+		3,
+		130,
+		4,
+		161,
+		0
+	])
+};
+var MLKEM768_PKCS8 = {
+	fullLength: 86,
+	prefix: new Uint8Array([
+		48,
+		84,
+		2,
+		1,
+		0,
+		48,
+		11,
+		6,
+		9,
+		96,
+		134,
+		72,
+		1,
+		101,
+		3,
+		4,
+		4,
+		2,
+		4,
+		66,
+		128,
+		64
+	])
+};
+function bytesEqual(a, b) {
+	if (a.length !== b.length) return false;
+	let diff = 0;
+	for (let i = 0; i < a.length; i++) diff |= a[i] ^ b[i];
+	return diff === 0;
+}
+function derToRaw(encoding, der) {
+	if (der.length !== encoding.fullLength) throw new MlKemDataError("Invalid encoding");
+	if (!bytesEqual(der.subarray(0, encoding.prefix.length), encoding.prefix)) throw new MlKemNotSupportedError("Unsupported encoding");
+	return der.slice(encoding.prefix.length);
+}
+function rawToDer(encoding, raw) {
+	const der = new Uint8Array(encoding.fullLength);
+	der.set(encoding.prefix);
+	der.set(raw, encoding.prefix.length);
+	return der;
+}
+async function importKey(format, keyData, algorithm, extractable, usages) {
+	checkAlgorithm(algorithm);
+	if (format === "spki") {
+		if (!Array.isArray(usages) || usages.some((usage) => usage !== "encapsulateKey" && usage !== "encapsulateBits")) throw new SyntaxError("Invalid key usages for public key");
+		const data = derToRaw(MLKEM768_SPKI, bufferSourcetoUint8Array(keyData));
+		if (data.length !== PUBLICKEY_BYTES) throw new MlKemDataError("Invalid key length");
+		return createPublicKey(data, usages);
+	}
+	if (format === "pkcs8") {
+		if (!Array.isArray(usages) || usages.some((usage) => usage !== "decapsulateKey" && usage !== "decapsulateBits")) throw new SyntaxError("Invalid key usages for private key");
+		const data = derToRaw(MLKEM768_PKCS8, bufferSourcetoUint8Array(keyData));
+		if (data.length !== KEYPAIR_RANDOM_BYTES) throw new MlKemDataError("Invalid key length");
+		const { rawPublicKey, rawSecretKey, rawSeed } = await internalGenerateKeyPair(data);
+		return createPrivateKey(rawPublicKey, rawSeed, rawSecretKey, extractable, usages);
+	}
+	if (format === "raw-public") {
+		if (!Array.isArray(usages) || usages.some((usage) => usage !== "encapsulateKey" && usage !== "encapsulateBits")) throw new SyntaxError("Invalid key usages for public key");
+		return createPublicKey(bufferSourcetoUint8ArrayCopy(keyData), usages);
+	}
+	if (format === "raw-seed") {
+		if (!Array.isArray(usages) || usages.some((usage) => usage !== "decapsulateKey" && usage !== "decapsulateBits")) throw new SyntaxError("Invalid key usages for private key");
+		const data = bufferSourcetoUint8ArrayCopy(keyData);
+		if (data.length !== KEYPAIR_RANDOM_BYTES) throw new MlKemDataError("Invalid key length");
+		const { rawPublicKey, rawSecretKey, rawSeed } = await internalGenerateKeyPair(data);
+		return createPrivateKey(rawPublicKey, rawSeed, rawSecretKey, extractable, usages);
+	}
+	if (format === "jwk") {
+		if (typeof keyData !== "object" || keyData === null) throw new MlKemDataError("Expected keyData to be a JsonWebKey dictionary");
+		const jwk = keyData;
+		if (jwk.priv && usages.some((usage) => usage !== "decapsulateKey" && usage !== "decapsulateBits")) throw new SyntaxError("Invalid key usages for private key");
+		if (!jwk.priv && usages.some((usage) => usage !== "encapsulateKey" && usage !== "encapsulateBits")) throw new SyntaxError("Invalid key usages for public key");
+		if (jwk.kty !== "AKP") throw new MlKemDataError("Invalid key type");
+		if (jwk.alg !== JWK_ALG && jwk.alg !== "ML-KEM-768+A192KW") throw new MlKemDataError("Invalid algorithm");
+		if (usages.length > 0 && jwk.use && jwk.use !== "enc") throw new MlKemDataError("Invalid key usage");
+		if (jwk.key_ops && Array.isArray(jwk.key_ops) && !Array.prototype.every.call(jwk.key_ops, (op) => KEY_USAGES.includes(op)) || !Array.isArray(jwk.key_ops)) throw new MlKemDataError("Invalid key operations");
+		if (jwk.ext === false && extractable) throw new MlKemDataError("Invalid key extractability");
+		if (jwk.priv) try {
+			const seedData = fromBase64url(jwk.priv);
+			if (seedData.length !== KEYPAIR_RANDOM_BYTES) throw new MlKemDataError("Invalid private key length");
+			const { rawPublicKey, rawSecretKey, rawSeed } = await internalGenerateKeyPair(seedData);
+			const key = createPrivateKey(rawPublicKey, rawSeed, rawSecretKey, extractable, usages);
+			if (toBase64url(rawPublicKey) !== jwk.pub) throw new MlKemDataError("Invalid public key data");
+			return key;
+		} catch {
+			throw new MlKemDataError("Invalid private key format");
+		}
+		else try {
+			const publicKeyData = fromBase64url(jwk.pub);
+			if (publicKeyData.length !== PUBLICKEY_BYTES) throw new MlKemDataError("Invalid public key data");
+			return createPublicKey(publicKeyData, usages);
+		} catch {
+			throw new MlKemDataError("Invalid public key format");
+		}
+	}
+	throw new MlKemNotSupportedError("Unsupported key format");
+}
+async function getPublicKey(key, usages) {
+	if (!(key instanceof CryptoKey)) throw new TypeError("Expected key to be an instance of CryptoKey");
+	checkAlgorithm(key.algorithm);
+	if (key.type !== "private") throw new MlKemInvalidAccessError("Expected key type to be 'private'");
+	if (!Array.isArray(usages) || usages.some((usage) => usage !== "encapsulateKey" && usage !== "encapsulateBits")) throw new SyntaxError("Invalid key usages");
+	const keyData = getInternalKeyData(key);
+	if (!keyData.publicKeyData) throw new MlKemOperationError("Failed to get public key data");
+	return createPublicKey(new Uint8Array(keyData.publicKeyData), usages);
+}
+async function internalEncapsulate(algorithm, encapsulationKey, usage) {
+	const module = await getModule();
+	checkAlgorithm(algorithm);
+	if (!(encapsulationKey instanceof CryptoKey) || encapsulationKey.type !== "public") throw new MlKemInvalidAccessError("Expected publicKey to be an instance of MlKemCryptoKey with type 'public'");
+	if (!encapsulationKey.usages.includes(usage)) throw new MlKemInvalidAccessError(`Key usages don't include '${usage}'`);
+	const publicKeyData = getPublicKeyDataRef(encapsulationKey);
+	if (publicKeyData.length !== PUBLICKEY_BYTES) throw new MlKemOperationError("Invalid public key length");
+	const coins = getRandomValues(new Uint8Array(ENC_RANDOM_BYTES));
+	const stackSave = module.stackSave();
+	try {
+		const pkPtr = module.stackAlloc(PUBLICKEY_BYTES);
+		const ctPtr = module.stackAlloc(CIPHERTEXT_BYTES);
+		const ssPtr = module.stackAlloc(SHARED_SECRET_BYTES);
+		const coinsPtr = module.stackAlloc(ENC_RANDOM_BYTES);
+		module.HEAPU8.set(publicKeyData, pkPtr);
+		module.HEAPU8.set(coins, coinsPtr);
+		if (module._mlkem768_enc_derand(ctPtr, ssPtr, pkPtr, coinsPtr) !== 0) throw new MlKemOperationError("Encapsulation failed");
+		const ciphertext = new Uint8Array(CIPHERTEXT_BYTES);
+		const sharedKey = new Uint8Array(SHARED_SECRET_BYTES);
+		ciphertext.set(module.HEAPU8.subarray(ctPtr, ctPtr + CIPHERTEXT_BYTES));
+		sharedKey.set(module.HEAPU8.subarray(ssPtr, ssPtr + SHARED_SECRET_BYTES));
+		module.HEAPU8.fill(0, ctPtr, ctPtr + CIPHERTEXT_BYTES);
+		module.HEAPU8.fill(0, ssPtr, ssPtr + SHARED_SECRET_BYTES);
+		module.HEAPU8.fill(0, pkPtr, pkPtr + PUBLICKEY_BYTES);
+		module.HEAPU8.fill(0, coinsPtr, coinsPtr + ENC_RANDOM_BYTES);
+		return {
+			ciphertext: ciphertext.buffer,
+			sharedKey: sharedKey.buffer
+		};
+	} finally {
+		module.stackRestore(stackSave);
+	}
+}
+async function encapsulateBits(algorithm, encapsulationKey) {
+	return internalEncapsulate(algorithm, encapsulationKey, "encapsulateBits");
+}
+async function encapsulateKey(encapsulationAlgorithm, encapsulationKey, sharedKeyAlgorithm, extractable, usages) {
+	const { sharedKey: sharedKeyBits, ciphertext } = await internalEncapsulate(encapsulationAlgorithm, encapsulationKey, "encapsulateKey");
+	return {
+		sharedKey: await crypto.subtle.importKey("raw", sharedKeyBits, sharedKeyAlgorithm, extractable, usages),
+		ciphertext
+	};
+}
+async function internalDecapsulate(algorithm, decapsulationKey, ciphertext, usage) {
+	const module = await getModule();
+	checkAlgorithm(algorithm);
+	if (!(decapsulationKey instanceof CryptoKey) || decapsulationKey.type !== "private") throw new MlKemInvalidAccessError("Expected key to be an instance of MlKemCryptoKey with type 'private'");
+	if (!decapsulationKey.usages.includes(usage)) throw new MlKemInvalidAccessError(`Key usages don't include '${usage}'`);
+	const secretKeyData = getPrivateKeyDataRef(decapsulationKey).privateSecretKeyData;
+	if (!secretKeyData || secretKeyData.length !== SECRETKEY_BYTES) throw new Error("Invalid secret key length");
+	const ct = bufferSourcetoUint8Array(ciphertext);
+	if (ct.length !== CIPHERTEXT_BYTES) throw new MlKemOperationError("Invalid ciphertext length");
+	const stackSave = module.stackSave();
+	try {
+		const ctPtr = module.stackAlloc(CIPHERTEXT_BYTES);
+		const skPtr = module.stackAlloc(SECRETKEY_BYTES);
+		const ssPtr = module.stackAlloc(SHARED_SECRET_BYTES);
+		module.HEAPU8.set(ct, ctPtr);
+		module.HEAPU8.set(secretKeyData, skPtr);
+		if (module._mlkem768_dec(ssPtr, ctPtr, skPtr) !== 0) throw new MlKemOperationError("Decapsulation failed");
+		const sharedKey = new Uint8Array(SHARED_SECRET_BYTES);
+		sharedKey.set(module.HEAPU8.subarray(ssPtr, ssPtr + SHARED_SECRET_BYTES));
+		module.HEAPU8.fill(0, ctPtr, ctPtr + CIPHERTEXT_BYTES);
+		module.HEAPU8.fill(0, skPtr, skPtr + SECRETKEY_BYTES);
+		module.HEAPU8.fill(0, ssPtr, ssPtr + SHARED_SECRET_BYTES);
+		return sharedKey.buffer;
+	} finally {
+		module.stackRestore(stackSave);
+	}
+}
+async function decapsulateBits(decapsulationAlgorithm, decapsulationKey, ciphertext) {
+	return internalDecapsulate(decapsulationAlgorithm, decapsulationKey, ciphertext, "decapsulateBits");
+}
+async function decapsulateKey(decapsulationAlgorithm, decapsulationKey, ciphertext, sharedKeyAlgorithm, extractable, usages) {
+	const sharedKeyBits = await internalDecapsulate(decapsulationAlgorithm, decapsulationKey, ciphertext, "decapsulateKey");
+	return await crypto.subtle.importKey("raw", sharedKeyBits, sharedKeyAlgorithm, extractable, usages);
+}
+var mlkem_default = {
+	generateKey,
+	exportKey,
+	importKey,
+	getPublicKey,
+	encapsulateBits,
+	encapsulateKey,
+	decapsulateBits,
+	decapsulateKey,
+	_isSupportedCryptoKey
+};
+//#endregion
+//#region src/kyber_crystals_wasm_engine.js
+var kyber_crystals_wasm_engine = (async function(moduleArg = {}) {
+	var moduleRtn;
+	var Module = moduleArg;
+	var readyPromiseResolve, readyPromiseReject;
+	var readyPromise = new Promise((resolve, reject) => {
+		readyPromiseResolve = resolve;
+		readyPromiseReject = reject;
+	});
+	var ENVIRONMENT_IS_WEB = typeof window == "object";
+	var ENVIRONMENT_IS_WORKER = typeof WorkerGlobalScope != "undefined";
+	var ENVIRONMENT_IS_NODE = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string" && process.type != "renderer";
+	if (ENVIRONMENT_IS_NODE) {
+		const { createRequire } = await import("module");
+		var require = createRequire(import.meta.url);
+	}
+	var thisProgram = "./this.program";
+	var quit_ = (status, toThrow) => {
+		throw toThrow;
+	};
+	var _scriptName = import.meta.url;
+	var scriptDirectory = "";
+	function locateFile(path) {
+		if (Module["locateFile"]) return Module["locateFile"](path, scriptDirectory);
+		return scriptDirectory + path;
+	}
+	var readAsync, readBinary;
+	if (ENVIRONMENT_IS_NODE) {
+		var fs = require("fs");
+		var nodePath = require("path");
+		if (_scriptName.startsWith("file:")) scriptDirectory = nodePath.dirname(require("url").fileURLToPath(_scriptName)) + "/";
+		readBinary = (filename) => {
+			filename = isFileURI(filename) ? new URL(filename) : filename;
+			return fs.readFileSync(filename);
+		};
+		readAsync = async (filename, binary = true) => {
+			filename = isFileURI(filename) ? new URL(filename) : filename;
+			return fs.readFileSync(filename, binary ? void 0 : "utf8");
+		};
+		if (process.argv.length > 1) thisProgram = process.argv[1].replace(/\\/g, "/");
+		process.argv.slice(2);
+		quit_ = (status, toThrow) => {
+			process.exitCode = status;
+			throw toThrow;
+		};
+	} else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+		try {
+			scriptDirectory = new URL(".", _scriptName).href;
+		} catch {}
+		if (ENVIRONMENT_IS_WORKER) readBinary = (url) => {
+			var xhr = new XMLHttpRequest();
+			xhr.open("GET", url, false);
+			xhr.responseType = "arraybuffer";
+			xhr.send(null);
+			return new Uint8Array(xhr.response);
+		};
+		readAsync = async (url) => {
+			var response = await fetch(url, { credentials: "same-origin" });
+			if (response.ok) return response.arrayBuffer();
+			throw new Error(response.status + " : " + response.url);
+		};
+	}
+	console.log.bind(console);
+	var err = console.error.bind(console);
+	var wasmBinary;
+	var wasmMemory;
+	var ABORT = false;
+	var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAP64, HEAPU64, HEAPF64;
+	var isFileURI = (filename) => filename.startsWith("file://");
+	function updateMemoryViews() {
+		var b = wasmMemory.buffer;
+		HEAP8 = new Int8Array(b);
+		HEAP16 = new Int16Array(b);
+		HEAPU8 = new Uint8Array(b);
+		HEAPU16 = new Uint16Array(b);
+		HEAP32 = new Int32Array(b);
+		HEAPU32 = new Uint32Array(b);
+		HEAPF32 = new Float32Array(b);
+		HEAPF64 = new Float64Array(b);
+		HEAP64 = new BigInt64Array(b);
+		HEAPU64 = new BigUint64Array(b);
+	}
+	function preRun() {
+		if (Module["preRun"]) {
+			if (typeof Module["preRun"] == "function") Module["preRun"] = [Module["preRun"]];
+			while (Module["preRun"].length) addOnPreRun(Module["preRun"].shift());
+		}
+		callRuntimeCallbacks(onPreRuns);
+	}
+	function initRuntime() {
+		wasmExports["x"]();
+	}
+	function postRun() {
+		if (Module["postRun"]) {
+			if (typeof Module["postRun"] == "function") Module["postRun"] = [Module["postRun"]];
+			while (Module["postRun"].length) addOnPostRun(Module["postRun"].shift());
+		}
+		callRuntimeCallbacks(onPostRuns);
+	}
+	var runDependencies = 0;
+	var dependenciesFulfilled = null;
+	function addRunDependency(id) {
+		runDependencies++;
+		Module["monitorRunDependencies"]?.(runDependencies);
+	}
+	function removeRunDependency(id) {
+		runDependencies--;
+		Module["monitorRunDependencies"]?.(runDependencies);
+		if (runDependencies == 0) {
+			if (dependenciesFulfilled) {
+				var callback = dependenciesFulfilled;
+				dependenciesFulfilled = null;
+				callback();
+			}
+		}
+	}
+	function abort(what) {
+		Module["onAbort"]?.(what);
+		what = "Aborted(" + what + ")";
+		err(what);
+		ABORT = true;
+		what += ". Build with -sASSERTIONS for more info.";
+		var e = new WebAssembly.RuntimeError(what);
+		readyPromiseReject(e);
+		throw e;
+	}
+	var wasmBinaryFile;
+	function findWasmBinary() {
+		if (Module["locateFile"]) return locateFile("kyber_crystals_wasm_engine.wasm");
+		return new URL("kyber_crystals_wasm_engine.wasm", import.meta.url).href;
+	}
+	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";
+	}
+	async function getWasmBinary(binaryFile) {
+		if (!wasmBinary) try {
+			var response = await readAsync(binaryFile);
+			return new Uint8Array(response);
+		} catch {}
+		return getBinarySync(binaryFile);
+	}
+	async function instantiateArrayBuffer(binaryFile, imports) {
+		try {
+			var binary = await getWasmBinary(binaryFile);
+			return await WebAssembly.instantiate(binary, imports);
+		} catch (reason) {
+			err(`failed to asynchronously prepare wasm: ${reason}`);
+			abort(reason);
+		}
+	}
+	async function instantiateAsync(binary, binaryFile, imports) {
+		if (!binary && typeof WebAssembly.instantiateStreaming == "function" && !ENVIRONMENT_IS_NODE) try {
+			var response = fetch(binaryFile, { credentials: "same-origin" });
+			return await WebAssembly.instantiateStreaming(response, imports);
+		} catch (reason) {
+			err(`wasm streaming compile failed: ${reason}`);
+			err("falling back to ArrayBuffer instantiation");
+		}
+		return instantiateArrayBuffer(binaryFile, imports);
+	}
+	function getWasmImports() {
+		return { a: wasmImports };
+	}
+	async function createWasm() {
+		function receiveInstance(instance, module) {
+			wasmExports = instance.exports;
+			wasmMemory = wasmExports["w"];
+			updateMemoryViews();
+			wasmTable = wasmExports["y"];
+			removeRunDependency("wasm-instantiate");
+			return wasmExports;
+		}
+		addRunDependency("wasm-instantiate");
+		function receiveInstantiationResult(result) {
+			return receiveInstance(result["instance"]);
+		}
+		var info = getWasmImports();
+		if (Module["instantiateWasm"]) return new Promise((resolve, reject) => {
+			Module["instantiateWasm"](info, (mod, inst) => {
+				resolve(receiveInstance(mod, inst));
+			});
+		});
+		wasmBinaryFile ??= findWasmBinary();
+		try {
+			return receiveInstantiationResult(await instantiateAsync(wasmBinary, wasmBinaryFile, info));
+		} catch (e) {
+			readyPromiseReject(e);
+			return Promise.reject(e);
+		}
+	}
+	class ExitStatus {
+		name = "ExitStatus";
+		constructor(status) {
+			this.message = `Program terminated with exit(${status})`;
+			this.status = status;
+		}
+	}
+	var callRuntimeCallbacks = (callbacks) => {
+		while (callbacks.length > 0) callbacks.shift()(Module);
+	};
+	var onPostRuns = [];
+	var addOnPostRun = (cb) => onPostRuns.push(cb);
+	var onPreRuns = [];
+	var addOnPreRun = (cb) => onPreRuns.push(cb);
+	var noExitRuntime = true;
+	var stackRestore = (val) => __emscripten_stack_restore(val);
+	var stackSave = () => _emscripten_stack_get_current();
+	class ExceptionInfo {
+		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;
+		}
+		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];
+		}
+	}
+	var exceptionLast = 0;
+	var uncaughtExceptionCount = 0;
+	var ___cxa_throw = (ptr, type, destructor) => {
+		new ExceptionInfo(ptr).init(type, destructor);
+		exceptionLast = ptr;
+		uncaughtExceptionCount++;
+		throw exceptionLast;
+	};
+	var __abort_js = () => abort("");
+	var embindRepr = (v) => {
+		if (v === null) return "null";
+		var t = typeof v;
+		if (t === "object" || t === "array" || t === "function") return v.toString();
+		else return "" + v;
+	};
+	var embind_init_charCodes = () => {
+		var codes = new Array(256);
+		for (var i = 0; i < 256; ++i) codes[i] = String.fromCharCode(i);
+		embind_charCodes = codes;
+	};
+	var embind_charCodes;
+	var readLatin1String = (ptr) => {
+		var ret = "";
+		var c = ptr;
+		while (HEAPU8[c]) ret += embind_charCodes[HEAPU8[c++]];
+		return ret;
+	};
+	var awaitingDependencies = {};
+	var registeredTypes = {};
+	var typeDependencies = {};
+	var BindingError = Module["BindingError"] = class BindingError extends Error {
+		constructor(message) {
+			super(message);
+			this.name = "BindingError";
+		}
+	};
+	var throwBindingError = (message) => {
+		throw new BindingError(message);
+	};
+	function sharedRegisterType(rawType, registeredInstance, options = {}) {
+		var name = registeredInstance.name;
+		if (!rawType) throwBindingError(`type "${name}" must have a positive integer typeid pointer`);
+		if (registeredTypes.hasOwnProperty(rawType)) if (options.ignoreDuplicateRegistrations) return;
+		else throwBindingError(`Cannot register type '${name}' twice`);
+		registeredTypes[rawType] = registeredInstance;
+		delete typeDependencies[rawType];
+		if (awaitingDependencies.hasOwnProperty(rawType)) {
+			var callbacks = awaitingDependencies[rawType];
+			delete awaitingDependencies[rawType];
+			callbacks.forEach((cb) => cb());
+		}
+	}
+	function registerType(rawType, registeredInstance, options = {}) {
+		return sharedRegisterType(rawType, registeredInstance, options);
+	}
+	var integerReadValueFromPointer = (name, width, signed) => {
+		switch (width) {
+			case 1: return signed ? (pointer) => HEAP8[pointer] : (pointer) => HEAPU8[pointer];
+			case 2: return signed ? (pointer) => HEAP16[pointer >> 1] : (pointer) => HEAPU16[pointer >> 1];
+			case 4: return signed ? (pointer) => HEAP32[pointer >> 2] : (pointer) => HEAPU32[pointer >> 2];
+			case 8: return signed ? (pointer) => HEAP64[pointer >> 3] : (pointer) => HEAPU64[pointer >> 3];
+			default: throw new TypeError(`invalid integer width (${width}): ${name}`);
+		}
+	};
+	var __embind_register_bigint = (primitiveType, name, size, minRange, maxRange) => {
+		name = readLatin1String(name);
+		var isUnsignedType = name.indexOf("u") != -1;
+		if (isUnsignedType) maxRange = (1n << 64n) - 1n;
+		registerType(primitiveType, {
+			name,
+			fromWireType: (value) => value,
+			toWireType: function(destructors, value) {
+				if (typeof value != "bigint" && typeof value != "number") throw new TypeError(`Cannot convert "${embindRepr(value)}" to ${this.name}`);
+				if (typeof value == "number") value = BigInt(value);
+				return value;
+			},
+			argPackAdvance: GenericWireTypeSize,
+			readValueFromPointer: integerReadValueFromPointer(name, size, !isUnsignedType),
+			destructorFunction: null
+		});
+	};
+	var GenericWireTypeSize = 8;
+	var __embind_register_bool = (rawType, name, trueValue, falseValue) => {
+		name = readLatin1String(name);
+		registerType(rawType, {
+			name,
+			fromWireType: function(wt) {
+				return !!wt;
+			},
+			toWireType: function(destructors, o) {
+				return o ? trueValue : falseValue;
+			},
+			argPackAdvance: GenericWireTypeSize,
+			readValueFromPointer: function(pointer) {
+				return this["fromWireType"](HEAPU8[pointer]);
+			},
+			destructorFunction: null
+		});
+	};
+	var shallowCopyInternalPointer = (o) => ({
+		count: o.count,
+		deleteScheduled: o.deleteScheduled,
+		preservePointerOnDelete: o.preservePointerOnDelete,
+		ptr: o.ptr,
+		ptrType: o.ptrType,
+		smartPtr: o.smartPtr,
+		smartPtrType: o.smartPtrType
+	});
+	var throwInstanceAlreadyDeleted = (obj) => {
+		function getInstanceTypeName(handle) {
+			return handle.$$.ptrType.registeredClass.name;
+		}
+		throwBindingError(getInstanceTypeName(obj) + " instance already deleted");
+	};
+	var finalizationRegistry = false;
+	var detachFinalizer = (handle) => {};
+	var runDestructor = ($$) => {
+		if ($$.smartPtr) $$.smartPtrType.rawDestructor($$.smartPtr);
+		else $$.ptrType.registeredClass.rawDestructor($$.ptr);
+	};
+	var releaseClassHandle = ($$) => {
+		$$.count.value -= 1;
+		if (0 === $$.count.value) runDestructor($$);
+	};
+	var attachFinalizer = (handle) => {
+		if ("undefined" === typeof FinalizationRegistry) {
+			attachFinalizer = (handle) => handle;
+			return handle;
+		}
+		finalizationRegistry = new FinalizationRegistry((info) => {
+			releaseClassHandle(info.$$);
+		});
+		attachFinalizer = (handle) => {
+			var $$ = handle.$$;
+			if (!!$$.smartPtr) {
+				var info = { $$ };
+				finalizationRegistry.register(handle, info, handle);
+			}
+			return handle;
+		};
+		detachFinalizer = (handle) => finalizationRegistry.unregister(handle);
+		return attachFinalizer(handle);
+	};
+	var deletionQueue = [];
+	var flushPendingDeletes = () => {
+		while (deletionQueue.length) {
+			var obj = deletionQueue.pop();
+			obj.$$.deleteScheduled = false;
+			obj["delete"]();
+		}
+	};
+	var delayFunction;
+	var init_ClassHandle = () => {
+		let proto = ClassHandle.prototype;
+		Object.assign(proto, {
+			isAliasOf(other) {
+				if (!(this instanceof ClassHandle)) return false;
+				if (!(other instanceof ClassHandle)) return false;
+				var leftClass = this.$$.ptrType.registeredClass;
+				var left = this.$$.ptr;
+				other.$$ = other.$$;
+				var rightClass = other.$$.ptrType.registeredClass;
+				var right = other.$$.ptr;
+				while (leftClass.baseClass) {
+					left = leftClass.upcast(left);
+					leftClass = leftClass.baseClass;
+				}
+				while (rightClass.baseClass) {
+					right = rightClass.upcast(right);
+					rightClass = rightClass.baseClass;
+				}
+				return leftClass === rightClass && left === right;
+			},
+			clone() {
+				if (!this.$$.ptr) throwInstanceAlreadyDeleted(this);
+				if (this.$$.preservePointerOnDelete) {
+					this.$$.count.value += 1;
+					return this;
+				} else {
+					var clone = attachFinalizer(Object.create(Object.getPrototypeOf(this), { $$: { value: shallowCopyInternalPointer(this.$$) } }));
+					clone.$$.count.value += 1;
+					clone.$$.deleteScheduled = false;
+					return clone;
+				}
+			},
+			delete() {
+				if (!this.$$.ptr) throwInstanceAlreadyDeleted(this);
+				if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) throwBindingError("Object already scheduled for deletion");
+				detachFinalizer(this);
+				releaseClassHandle(this.$$);
+				if (!this.$$.preservePointerOnDelete) {
+					this.$$.smartPtr = void 0;
+					this.$$.ptr = void 0;
+				}
+			},
+			isDeleted() {
+				return !this.$$.ptr;
+			},
+			deleteLater() {
+				if (!this.$$.ptr) throwInstanceAlreadyDeleted(this);
+				if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) throwBindingError("Object already scheduled for deletion");
+				deletionQueue.push(this);
+				if (deletionQueue.length === 1 && delayFunction) delayFunction(flushPendingDeletes);
+				this.$$.deleteScheduled = true;
+				return this;
+			}
+		});
+		const symbolDispose = Symbol.dispose;
+		if (symbolDispose) proto[symbolDispose] = proto["delete"];
+	};
+	function ClassHandle() {}
+	var createNamedFunction = (name, func) => Object.defineProperty(func, "name", { value: name });
+	var registeredPointers = {};
+	var ensureOverloadTable = (proto, methodName, humanName) => {
+		if (void 0 === proto[methodName].overloadTable) {
+			var prevFunc = proto[methodName];
+			proto[methodName] = function(...args) {
+				if (!proto[methodName].overloadTable.hasOwnProperty(args.length)) throwBindingError(`Function '${humanName}' called with an invalid number of arguments (${args.length}) - expects one of (${proto[methodName].overloadTable})!`);
+				return proto[methodName].overloadTable[args.length].apply(this, args);
+			};
+			proto[methodName].overloadTable = [];
+			proto[methodName].overloadTable[prevFunc.argCount] = prevFunc;
+		}
+	};
+	var exposePublicSymbol = (name, value, numArguments) => {
+		if (Module.hasOwnProperty(name)) {
+			if (void 0 === numArguments || void 0 !== Module[name].overloadTable && void 0 !== Module[name].overloadTable[numArguments]) throwBindingError(`Cannot register public name '${name}' twice`);
+			ensureOverloadTable(Module, name, name);
+			if (Module[name].overloadTable.hasOwnProperty(numArguments)) throwBindingError(`Cannot register multiple overloads of a function with the same number of arguments (${numArguments})!`);
+			Module[name].overloadTable[numArguments] = value;
+		} else {
+			Module[name] = value;
+			Module[name].argCount = numArguments;
+		}
+	};
+	var char_0 = 48;
+	var char_9 = 57;
+	var makeLegalFunctionName = (name) => {
+		name = name.replace(/[^a-zA-Z0-9_]/g, "$");
+		var f = name.charCodeAt(0);
+		if (f >= char_0 && f <= char_9) return `_${name}`;
+		return name;
+	};
+	function RegisteredClass(name, constructor, instancePrototype, rawDestructor, baseClass, getActualType, upcast, downcast) {
+		this.name = name;
+		this.constructor = constructor;
+		this.instancePrototype = instancePrototype;
+		this.rawDestructor = rawDestructor;
+		this.baseClass = baseClass;
+		this.getActualType = getActualType;
+		this.upcast = upcast;
+		this.downcast = downcast;
+		this.pureVirtualFunctions = [];
+	}
+	var upcastPointer = (ptr, ptrClass, desiredClass) => {
+		while (ptrClass !== desiredClass) {
+			if (!ptrClass.upcast) throwBindingError(`Expected null or instance of ${desiredClass.name}, got an instance of ${ptrClass.name}`);
+			ptr = ptrClass.upcast(ptr);
+			ptrClass = ptrClass.baseClass;
+		}
+		return ptr;
+	};
+	function constNoSmartPtrRawPointerToWireType(destructors, handle) {
+		if (handle === null) {
+			if (this.isReference) throwBindingError(`null is not a valid ${this.name}`);
+			return 0;
+		}
+		if (!handle.$$) throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`);
+		if (!handle.$$.ptr) throwBindingError(`Cannot pass deleted object as a pointer of type ${this.name}`);
+		var handleClass = handle.$$.ptrType.registeredClass;
+		return upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);
+	}
+	function genericPointerToWireType(destructors, handle) {
+		var ptr;
+		if (handle === null) {
+			if (this.isReference) throwBindingError(`null is not a valid ${this.name}`);
+			if (this.isSmartPointer) {
+				ptr = this.rawConstructor();
+				if (destructors !== null) destructors.push(this.rawDestructor, ptr);
+				return ptr;
+			} else return 0;
+		}
+		if (!handle || !handle.$$) throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`);
+		if (!handle.$$.ptr) throwBindingError(`Cannot pass deleted object as a pointer of type ${this.name}`);
+		if (!this.isConst && handle.$$.ptrType.isConst) throwBindingError(`Cannot convert argument of type ${handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name} to parameter type ${this.name}`);
+		var handleClass = handle.$$.ptrType.registeredClass;
+		ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);
+		if (this.isSmartPointer) {
+			if (void 0 === handle.$$.smartPtr) throwBindingError("Passing raw pointer to smart pointer is illegal");
+			switch (this.sharingPolicy) {
+				case 0:
+					if (handle.$$.smartPtrType === this) ptr = handle.$$.smartPtr;
+					else throwBindingError(`Cannot convert argument of type ${handle.$$.smartPtrType ? handle.$$.smartPtrType.name : handle.$$.ptrType.name} to parameter type ${this.name}`);
+					break;
+				case 1:
+					ptr = handle.$$.smartPtr;
+					break;
+				case 2:
+					if (handle.$$.smartPtrType === this) ptr = handle.$$.smartPtr;
+					else {
+						var clonedHandle = handle["clone"]();
+						ptr = this.rawShare(ptr, Emval.toHandle(() => clonedHandle["delete"]()));
+						if (destructors !== null) destructors.push(this.rawDestructor, ptr);
+					}
+					break;
+				default: throwBindingError("Unsupporting sharing policy");
+			}
+		}
+		return ptr;
+	}
+	function nonConstNoSmartPtrRawPointerToWireType(destructors, handle) {
+		if (handle === null) {
+			if (this.isReference) throwBindingError(`null is not a valid ${this.name}`);
+			return 0;
+		}
+		if (!handle.$$) throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`);
+		if (!handle.$$.ptr) throwBindingError(`Cannot pass deleted object as a pointer of type ${this.name}`);
+		if (handle.$$.ptrType.isConst) throwBindingError(`Cannot convert argument of type ${handle.$$.ptrType.name} to parameter type ${this.name}`);
+		var handleClass = handle.$$.ptrType.registeredClass;
+		return upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);
+	}
+	function readPointer(pointer) {
+		return this["fromWireType"](HEAPU32[pointer >> 2]);
+	}
+	var downcastPointer = (ptr, ptrClass, desiredClass) => {
+		if (ptrClass === desiredClass) return ptr;
+		if (void 0 === desiredClass.baseClass) return null;
+		var rv = downcastPointer(ptr, ptrClass, desiredClass.baseClass);
+		if (rv === null) return null;
+		return desiredClass.downcast(rv);
+	};
+	var registeredInstances = {};
+	var getBasestPointer = (class_, ptr) => {
+		if (ptr === void 0) throwBindingError("ptr should not be undefined");
+		while (class_.baseClass) {
+			ptr = class_.upcast(ptr);
+			class_ = class_.baseClass;
+		}
+		return ptr;
+	};
+	var getInheritedInstance = (class_, ptr) => {
+		ptr = getBasestPointer(class_, ptr);
+		return registeredInstances[ptr];
+	};
+	var InternalError = Module["InternalError"] = class InternalError extends Error {
+		constructor(message) {
+			super(message);
+			this.name = "InternalError";
+		}
+	};
+	var throwInternalError = (message) => {
+		throw new InternalError(message);
+	};
+	var makeClassHandle = (prototype, record) => {
+		if (!record.ptrType || !record.ptr) throwInternalError("makeClassHandle requires ptr and ptrType");
+		if (!!record.smartPtrType !== !!record.smartPtr) throwInternalError("Both smartPtrType and smartPtr must be specified");
+		record.count = { value: 1 };
+		return attachFinalizer(Object.create(prototype, { $$: {
+			value: record,
+			writable: true
+		} }));
+	};
+	function RegisteredPointer_fromWireType(ptr) {
+		var rawPointer = this.getPointee(ptr);
+		if (!rawPointer) {
+			this.destructor(ptr);
+			return null;
+		}
+		var registeredInstance = getInheritedInstance(this.registeredClass, rawPointer);
+		if (void 0 !== registeredInstance) if (0 === registeredInstance.$$.count.value) {
+			registeredInstance.$$.ptr = rawPointer;
+			registeredInstance.$$.smartPtr = ptr;
+			return registeredInstance["clone"]();
+		} else {
+			var rv = registeredInstance["clone"]();
+			this.destructor(ptr);
+			return rv;
+		}
+		function makeDefaultHandle() {
+			if (this.isSmartPointer) return makeClassHandle(this.registeredClass.instancePrototype, {
+				ptrType: this.pointeeType,
+				ptr: rawPointer,
+				smartPtrType: this,
+				smartPtr: ptr
+			});
+			else return makeClassHandle(this.registeredClass.instancePrototype, {
+				ptrType: this,
+				ptr
+			});
+		}
+		var registeredPointerRecord = registeredPointers[this.registeredClass.getActualType(rawPointer)];
+		if (!registeredPointerRecord) return makeDefaultHandle.call(this);
+		var toType;
+		if (this.isConst) toType = registeredPointerRecord.constPointerType;
+		else toType = registeredPointerRecord.pointerType;
+		var dp = downcastPointer(rawPointer, this.registeredClass, toType.registeredClass);
+		if (dp === null) return makeDefaultHandle.call(this);
+		if (this.isSmartPointer) return makeClassHandle(toType.registeredClass.instancePrototype, {
+			ptrType: toType,
+			ptr: dp,
+			smartPtrType: this,
+			smartPtr: ptr
+		});
+		else return makeClassHandle(toType.registeredClass.instancePrototype, {
+			ptrType: toType,
+			ptr: dp
+		});
+	}
+	var init_RegisteredPointer = () => {
+		Object.assign(RegisteredPointer.prototype, {
+			getPointee(ptr) {
+				if (this.rawGetPointee) ptr = this.rawGetPointee(ptr);
+				return ptr;
+			},
+			destructor(ptr) {
+				this.rawDestructor?.(ptr);
+			},
+			argPackAdvance: GenericWireTypeSize,
+			readValueFromPointer: readPointer,
+			fromWireType: RegisteredPointer_fromWireType
+		});
+	};
+	function RegisteredPointer(name, registeredClass, isReference, isConst, isSmartPointer, pointeeType, sharingPolicy, rawGetPointee, rawConstructor, rawShare, rawDestructor) {
+		this.name = name;
+		this.registeredClass = registeredClass;
+		this.isReference = isReference;
+		this.isConst = isConst;
+		this.isSmartPointer = isSmartPointer;
+		this.pointeeType = pointeeType;
+		this.sharingPolicy = sharingPolicy;
+		this.rawGetPointee = rawGetPointee;
+		this.rawConstructor = rawConstructor;
+		this.rawShare = rawShare;
+		this.rawDestructor = rawDestructor;
+		if (!isSmartPointer && registeredClass.baseClass === void 0) if (isConst) {
+			this["toWireType"] = constNoSmartPtrRawPointerToWireType;
+			this.destructorFunction = null;
+		} else {
+			this["toWireType"] = nonConstNoSmartPtrRawPointerToWireType;
+			this.destructorFunction = null;
+		}
+		else this["toWireType"] = genericPointerToWireType;
+	}
+	var replacePublicSymbol = (name, value, numArguments) => {
+		if (!Module.hasOwnProperty(name)) throwInternalError("Replacing nonexistent public symbol");
+		if (void 0 !== Module[name].overloadTable && void 0 !== numArguments) Module[name].overloadTable[numArguments] = value;
+		else {
+			Module[name] = value;
+			Module[name].argCount = numArguments;
+		}
+	};
+	var wasmTableMirror = [];
+	var wasmTable;
+	var getWasmTableEntry = (funcPtr) => {
+		var func = wasmTableMirror[funcPtr];
+		if (!func) wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr);
+		return func;
+	};
+	var embind__requireFunction = (signature, rawFunction, isAsync = false) => {
+		signature = readLatin1String(signature);
+		function makeDynCaller() {
+			return getWasmTableEntry(rawFunction);
+		}
+		var fp = makeDynCaller();
+		if (typeof fp != "function") throwBindingError(`unknown function pointer with signature ${signature}: ${rawFunction}`);
+		return fp;
+	};
+	class UnboundTypeError extends Error {}
+	var getTypeName = (type) => {
+		var ptr = ___getTypeName(type);
+		var rv = readLatin1String(ptr);
+		_free(ptr);
+		return rv;
+	};
+	var throwUnboundTypeError = (message, types) => {
+		var unboundTypes = [];
+		var seen = {};
+		function visit(type) {
+			if (seen[type]) return;
+			if (registeredTypes[type]) return;
+			if (typeDependencies[type]) {
+				typeDependencies[type].forEach(visit);
+				return;
+			}
+			unboundTypes.push(type);
+			seen[type] = true;
+		}
+		types.forEach(visit);
+		throw new UnboundTypeError(`${message}: ` + unboundTypes.map(getTypeName).join([", "]));
+	};
+	var whenDependentTypesAreResolved = (myTypes, dependentTypes, getTypeConverters) => {
+		myTypes.forEach((type) => typeDependencies[type] = dependentTypes);
+		function onComplete(typeConverters) {
+			var myTypeConverters = getTypeConverters(typeConverters);
+			if (myTypeConverters.length !== myTypes.length) throwInternalError("Mismatched type converter count");
+			for (var i = 0; i < myTypes.length; ++i) registerType(myTypes[i], myTypeConverters[i]);
+		}
+		var typeConverters = new Array(dependentTypes.length);
+		var unregisteredTypes = [];
+		var registered = 0;
+		dependentTypes.forEach((dt, i) => {
+			if (registeredTypes.hasOwnProperty(dt)) typeConverters[i] = registeredTypes[dt];
+			else {
+				unregisteredTypes.push(dt);
+				if (!awaitingDependencies.hasOwnProperty(dt)) awaitingDependencies[dt] = [];
+				awaitingDependencies[dt].push(() => {
+					typeConverters[i] = registeredTypes[dt];
+					++registered;
+					if (registered === unregisteredTypes.length) onComplete(typeConverters);
+				});
+			}
+		});
+		if (0 === unregisteredTypes.length) onComplete(typeConverters);
+	};
+	var __embind_register_class = (rawType, rawPointerType, rawConstPointerType, baseClassRawType, getActualTypeSignature, getActualType, upcastSignature, upcast, downcastSignature, downcast, name, destructorSignature, rawDestructor) => {
+		name = readLatin1String(name);
+		getActualType = embind__requireFunction(getActualTypeSignature, getActualType);
+		upcast &&= embind__requireFunction(upcastSignature, upcast);
+		downcast &&= embind__requireFunction(downcastSignature, downcast);
+		rawDestructor = embind__requireFunction(destructorSignature, rawDestructor);
+		var legalFunctionName = makeLegalFunctionName(name);
+		exposePublicSymbol(legalFunctionName, function() {
+			throwUnboundTypeError(`Cannot construct ${name} due to unbound types`, [baseClassRawType]);
+		});
+		whenDependentTypesAreResolved([
+			rawType,
+			rawPointerType,
+			rawConstPointerType
+		], baseClassRawType ? [baseClassRawType] : [], (base) => {
+			base = base[0];
+			var baseClass;
+			var basePrototype;
+			if (baseClassRawType) {
+				baseClass = base.registeredClass;
+				basePrototype = baseClass.instancePrototype;
+			} else basePrototype = ClassHandle.prototype;
+			var constructor = createNamedFunction(name, function(...args) {
+				if (Object.getPrototypeOf(this) !== instancePrototype) throw new BindingError(`Use 'new' to construct ${name}`);
+				if (void 0 === registeredClass.constructor_body) throw new BindingError(`${name} has no accessible constructor`);
+				var body = registeredClass.constructor_body[args.length];
+				if (void 0 === body) throw new BindingError(`Tried to invoke ctor of ${name} with invalid number of parameters (${args.length}) - expected (${Object.keys(registeredClass.constructor_body).toString()}) parameters instead!`);
+				return body.apply(this, args);
+			});
+			var instancePrototype = Object.create(basePrototype, { constructor: { value: constructor } });
+			constructor.prototype = instancePrototype;
+			var registeredClass = new RegisteredClass(name, constructor, instancePrototype, rawDestructor, baseClass, getActualType, upcast, downcast);
+			if (registeredClass.baseClass) {
+				registeredClass.baseClass.__derivedClasses ??= [];
+				registeredClass.baseClass.__derivedClasses.push(registeredClass);
+			}
+			var referenceConverter = new RegisteredPointer(name, registeredClass, true, false, false);
+			var pointerConverter = new RegisteredPointer(name + "*", registeredClass, false, false, false);
+			var constPointerConverter = new RegisteredPointer(name + " const*", registeredClass, false, true, false);
+			registeredPointers[rawType] = {
+				pointerType: pointerConverter,
+				constPointerType: constPointerConverter
+			};
+			replacePublicSymbol(legalFunctionName, constructor);
+			return [
+				referenceConverter,
+				pointerConverter,
+				constPointerConverter
+			];
+		});
+	};
+	var heap32VectorToArray = (count, firstElement) => {
+		var array = [];
+		for (var i = 0; i < count; i++) array.push(HEAPU32[firstElement + i * 4 >> 2]);
+		return array;
+	};
+	var runDestructors = (destructors) => {
+		while (destructors.length) {
+			var ptr = destructors.pop();
+			destructors.pop()(ptr);
+		}
+	};
+	function usesDestructorStack(argTypes) {
+		for (var i = 1; i < argTypes.length; ++i) if (argTypes[i] !== null && argTypes[i].destructorFunction === void 0) return true;
+		return false;
+	}
+	function createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync) {
+		var needsDestructorStack = usesDestructorStack(argTypes);
+		var argCount = argTypes.length - 2;
+		var argsList = [];
+		var argsListWired = ["fn"];
+		if (isClassMethodFunc) argsListWired.push("thisWired");
+		for (var i = 0; i < argCount; ++i) {
+			argsList.push(`arg${i}`);
+			argsListWired.push(`arg${i}Wired`);
+		}
+		argsList = argsList.join(",");
+		argsListWired = argsListWired.join(",");
+		var invokerFnBody = `return function (${argsList}) {\n`;
+		if (needsDestructorStack) invokerFnBody += "var destructors = [];\n";
+		var dtorStack = needsDestructorStack ? "destructors" : "null";
+		var args1 = [
+			"humanName",
+			"throwBindingError",
+			"invoker",
+			"fn",
+			"runDestructors",
+			"retType",
+			"classParam"
+		];
+		if (isClassMethodFunc) invokerFnBody += `var thisWired = classParam['toWireType'](${dtorStack}, this);\n`;
+		for (var i = 0; i < argCount; ++i) {
+			invokerFnBody += `var arg${i}Wired = argType${i}['toWireType'](${dtorStack}, arg${i});\n`;
+			args1.push(`argType${i}`);
+		}
+		invokerFnBody += (returns || isAsync ? "var rv = " : "") + `invoker(${argsListWired});\n`;
+		if (needsDestructorStack) invokerFnBody += "runDestructors(destructors);\n";
+		else for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) {
+			var paramName = i === 1 ? "thisWired" : "arg" + (i - 2) + "Wired";
+			if (argTypes[i].destructorFunction !== null) {
+				invokerFnBody += `${paramName}_dtor(${paramName});\n`;
+				args1.push(`${paramName}_dtor`);
+			}
+		}
+		if (returns) invokerFnBody += "var ret = retType['fromWireType'](rv);\nreturn ret;\n";
+		invokerFnBody += "}\n";
+		return [args1, invokerFnBody];
+	}
+	function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc, isAsync) {
+		var argCount = argTypes.length;
+		if (argCount < 2) throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!");
+		var isClassMethodFunc = argTypes[1] !== null && classType !== null;
+		var needsDestructorStack = usesDestructorStack(argTypes);
+		var returns = argTypes[0].name !== "void";
+		var closureArgs = [
+			humanName,
+			throwBindingError,
+			cppInvokerFunc,
+			cppTargetFunc,
+			runDestructors,
+			argTypes[0],
+			argTypes[1]
+		];
+		for (var i = 0; i < argCount - 2; ++i) closureArgs.push(argTypes[i + 2]);
+		if (!needsDestructorStack) {
+			for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) if (argTypes[i].destructorFunction !== null) closureArgs.push(argTypes[i].destructorFunction);
+		}
+		let [args, invokerFnBody] = createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync);
+		return createNamedFunction(humanName, new Function(...args, invokerFnBody)(...closureArgs));
+	}
+	var __embind_register_class_constructor = (rawClassType, argCount, rawArgTypesAddr, invokerSignature, invoker, rawConstructor) => {
+		var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
+		invoker = embind__requireFunction(invokerSignature, invoker);
+		whenDependentTypesAreResolved([], [rawClassType], (classType) => {
+			classType = classType[0];
+			var humanName = `constructor ${classType.name}`;
+			if (void 0 === classType.registeredClass.constructor_body) classType.registeredClass.constructor_body = [];
+			if (void 0 !== classType.registeredClass.constructor_body[argCount - 1]) throw new BindingError(`Cannot register multiple constructors with identical number of parameters (${argCount - 1}) for class '${classType.name}'! Overload resolution is currently only performed using the parameter count, not actual type info!`);
+			classType.registeredClass.constructor_body[argCount - 1] = () => {
+				throwUnboundTypeError(`Cannot construct ${classType.name} due to unbound types`, rawArgTypes);
+			};
+			whenDependentTypesAreResolved([], rawArgTypes, (argTypes) => {
+				argTypes.splice(1, 0, null);
+				classType.registeredClass.constructor_body[argCount - 1] = craftInvokerFunction(humanName, argTypes, null, invoker, rawConstructor);
+				return [];
+			});
+			return [];
+		});
+	};
+	var getFunctionName = (signature) => {
+		signature = signature.trim();
+		const argsIndex = signature.indexOf("(");
+		if (argsIndex === -1) return signature;
+		return signature.slice(0, argsIndex);
+	};
+	var __embind_register_class_function = (rawClassType, methodName, argCount, rawArgTypesAddr, invokerSignature, rawInvoker, context, isPureVirtual, isAsync, isNonnullReturn) => {
+		var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
+		methodName = readLatin1String(methodName);
+		methodName = getFunctionName(methodName);
+		rawInvoker = embind__requireFunction(invokerSignature, rawInvoker, isAsync);
+		whenDependentTypesAreResolved([], [rawClassType], (classType) => {
+			classType = classType[0];
+			var humanName = `${classType.name}.${methodName}`;
+			if (methodName.startsWith("@@")) methodName = Symbol[methodName.substring(2)];
+			if (isPureVirtual) classType.registeredClass.pureVirtualFunctions.push(methodName);
+			function unboundTypesHandler() {
+				throwUnboundTypeError(`Cannot call ${humanName} due to unbound types`, rawArgTypes);
+			}
+			var proto = classType.registeredClass.instancePrototype;
+			var method = proto[methodName];
+			if (void 0 === method || void 0 === method.overloadTable && method.className !== classType.name && method.argCount === argCount - 2) {
+				unboundTypesHandler.argCount = argCount - 2;
+				unboundTypesHandler.className = classType.name;
+				proto[methodName] = unboundTypesHandler;
+			} else {
+				ensureOverloadTable(proto, methodName, humanName);
+				proto[methodName].overloadTable[argCount - 2] = unboundTypesHandler;
+			}
+			whenDependentTypesAreResolved([], rawArgTypes, (argTypes) => {
+				var memberFunction = craftInvokerFunction(humanName, argTypes, classType, rawInvoker, context, isAsync);
+				if (void 0 === proto[methodName].overloadTable) {
+					memberFunction.argCount = argCount - 2;
+					proto[methodName] = memberFunction;
+				} else proto[methodName].overloadTable[argCount - 2] = memberFunction;
+				return [];
+			});
+			return [];
+		});
+	};
+	var emval_freelist = [];
+	var emval_handles = [];
+	var __emval_decref = (handle) => {
+		if (handle > 9 && 0 === --emval_handles[handle + 1]) {
+			emval_handles[handle] = void 0;
+			emval_freelist.push(handle);
+		}
+	};
+	var count_emval_handles = () => emval_handles.length / 2 - 5 - emval_freelist.length;
+	var init_emval = () => {
+		emval_handles.push(0, 1, void 0, 1, null, 1, true, 1, false, 1);
+		Module["count_emval_handles"] = count_emval_handles;
+	};
+	var Emval = {
+		toValue: (handle) => {
+			if (!handle) throwBindingError(`Cannot use deleted val. handle = ${handle}`);
+			return emval_handles[handle];
+		},
+		toHandle: (value) => {
+			switch (value) {
+				case void 0: return 2;
+				case null: return 4;
+				case true: return 6;
+				case false: return 8;
+				default: {
+					const handle = emval_freelist.pop() || emval_handles.length;
+					emval_handles[handle] = value;
+					emval_handles[handle + 1] = 1;
+					return handle;
+				}
+			}
+		}
+	};
+	var EmValType = {
+		name: "emscripten::val",
+		fromWireType: (handle) => {
+			var rv = Emval.toValue(handle);
+			__emval_decref(handle);
+			return rv;
+		},
+		toWireType: (destructors, value) => Emval.toHandle(value),
+		argPackAdvance: GenericWireTypeSize,
+		readValueFromPointer: readPointer,
+		destructorFunction: null
+	};
+	var __embind_register_emval = (rawType) => registerType(rawType, EmValType);
+	var floatReadValueFromPointer = (name, width) => {
+		switch (width) {
+			case 4: return function(pointer) {
+				return this["fromWireType"](HEAPF32[pointer >> 2]);
+			};
+			case 8: return function(pointer) {
+				return this["fromWireType"](HEAPF64[pointer >> 3]);
+			};
+			default: throw new TypeError(`invalid float width (${width}): ${name}`);
+		}
+	};
+	var __embind_register_float = (rawType, name, size) => {
+		name = readLatin1String(name);
+		registerType(rawType, {
+			name,
+			fromWireType: (value) => value,
+			toWireType: (destructors, value) => value,
+			argPackAdvance: GenericWireTypeSize,
+			readValueFromPointer: floatReadValueFromPointer(name, size),
+			destructorFunction: null
+		});
+	};
+	var __embind_register_integer = (primitiveType, name, size, minRange, maxRange) => {
+		name = readLatin1String(name);
+		if (maxRange === -1) maxRange = 4294967295;
+		var fromWireType = (value) => value;
+		if (minRange === 0) {
+			var bitshift = 32 - 8 * size;
+			fromWireType = (value) => value << bitshift >>> bitshift;
+		}
+		var isUnsignedType = name.includes("unsigned");
+		var checkAssertions = (value, toTypeName) => {};
+		var toWireType;
+		if (isUnsignedType) toWireType = function(destructors, value) {
+			checkAssertions(value, this.name);
+			return value >>> 0;
+		};
+		else toWireType = function(destructors, value) {
+			checkAssertions(value, this.name);
+			return value;
+		};
+		registerType(primitiveType, {
+			name,
+			fromWireType,
+			toWireType,
+			argPackAdvance: GenericWireTypeSize,
+			readValueFromPointer: integerReadValueFromPointer(name, size, minRange !== 0),
+			destructorFunction: null
+		});
+	};
+	var __embind_register_memory_view = (rawType, dataTypeIndex, name) => {
+		var TA = [
+			Int8Array,
+			Uint8Array,
+			Int16Array,
+			Uint16Array,
+			Int32Array,
+			Uint32Array,
+			Float32Array,
+			Float64Array,
+			BigInt64Array,
+			BigUint64Array
+		][dataTypeIndex];
+		function decodeMemoryView(handle) {
+			var size = HEAPU32[handle >> 2];
+			var data = HEAPU32[handle + 4 >> 2];
+			return new TA(HEAP8.buffer, data, size);
+		}
+		name = readLatin1String(name);
+		registerType(rawType, {
+			name,
+			fromWireType: decodeMemoryView,
+			argPackAdvance: GenericWireTypeSize,
+			readValueFromPointer: decodeMemoryView
+		}, { ignoreDuplicateRegistrations: true });
+	};
+	var EmValOptionalType = Object.assign({ optional: true }, EmValType);
+	var __embind_register_optional = (rawOptionalType, rawType) => {
+		registerType(rawOptionalType, EmValOptionalType);
+	};
+	var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {
+		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;
+				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;
+	};
+	var stringToUTF8 = (str, outPtr, maxBytesToWrite) => stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
+	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 UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder() : void 0;
+	var UTF8ArrayToString = (heapOrArray, idx = 0, maxBytesToRead = NaN) => {
+		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 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) => ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
+	var __embind_register_std_string = (rawType, name) => {
+		name = readLatin1String(name);
+		var stdStringIsUTF8 = true;
+		registerType(rawType, {
+			name,
+			fromWireType(value) {
+				var length = HEAPU32[value >> 2];
+				var payload = value + 4;
+				var str;
+				if (stdStringIsUTF8) {
+					var decodeStartPtr = payload;
+					for (var i = 0; i <= length; ++i) {
+						var currentBytePtr = payload + i;
+						if (i == length || HEAPU8[currentBytePtr] == 0) {
+							var maxRead = currentBytePtr - decodeStartPtr;
+							var stringSegment = UTF8ToString(decodeStartPtr, maxRead);
+							if (str === void 0) str = stringSegment;
+							else {
+								str += String.fromCharCode(0);
+								str += stringSegment;
+							}
+							decodeStartPtr = currentBytePtr + 1;
+						}
+					}
+				} else {
+					var a = new Array(length);
+					for (var i = 0; i < length; ++i) a[i] = String.fromCharCode(HEAPU8[payload + i]);
+					str = a.join("");
+				}
+				_free(value);
+				return str;
+			},
+			toWireType(destructors, value) {
+				if (value instanceof ArrayBuffer) value = new Uint8Array(value);
+				var length;
+				var valueIsOfTypeString = typeof value == "string";
+				if (!(valueIsOfTypeString || ArrayBuffer.isView(value) && value.BYTES_PER_ELEMENT == 1)) throwBindingError("Cannot pass non-string to std::string");
+				if (stdStringIsUTF8 && valueIsOfTypeString) length = lengthBytesUTF8(value);
+				else length = value.length;
+				var base = _malloc(4 + length + 1);
+				var ptr = base + 4;
+				HEAPU32[base >> 2] = length;
+				if (valueIsOfTypeString) if (stdStringIsUTF8) stringToUTF8(value, ptr, length + 1);
+				else for (var i = 0; i < length; ++i) {
+					var charCode = value.charCodeAt(i);
+					if (charCode > 255) {
+						_free(base);
+						throwBindingError("String has UTF-16 code units that do not fit in 8 bits");
+					}
+					HEAPU8[ptr + i] = charCode;
+				}
+				else HEAPU8.set(value, ptr);
+				if (destructors !== null) destructors.push(_free, base);
+				return base;
+			},
+			argPackAdvance: GenericWireTypeSize,
+			readValueFromPointer: readPointer,
+			destructorFunction(ptr) {
+				_free(ptr);
+			}
+		});
+	};
+	var UTF16Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf-16le") : void 0;
+	var UTF16ToString = (ptr, maxBytesToRead) => {
+		var endPtr = ptr;
+		var idx = endPtr >> 1;
+		var maxIdx = idx + maxBytesToRead / 2;
+		while (!(idx >= maxIdx) && HEAPU16[idx]) ++idx;
+		endPtr = idx << 1;
+		if (endPtr - ptr > 32 && UTF16Decoder) return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr));
+		var str = "";
+		for (var i = 0; !(i >= maxBytesToRead / 2); ++i) {
+			var codeUnit = HEAP16[ptr + i * 2 >> 1];
+			if (codeUnit == 0) break;
+			str += String.fromCharCode(codeUnit);
+		}
+		return str;
+	};
+	var stringToUTF16 = (str, outPtr, maxBytesToWrite) => {
+		maxBytesToWrite ??= 2147483647;
+		if (maxBytesToWrite < 2) return 0;
+		maxBytesToWrite -= 2;
+		var startPtr = outPtr;
+		var numCharsToWrite = maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length;
+		for (var i = 0; i < numCharsToWrite; ++i) {
+			var codeUnit = str.charCodeAt(i);
+			HEAP16[outPtr >> 1] = codeUnit;
+			outPtr += 2;
+		}
+		HEAP16[outPtr >> 1] = 0;
+		return outPtr - startPtr;
+	};
+	var lengthBytesUTF16 = (str) => str.length * 2;
+	var UTF32ToString = (ptr, maxBytesToRead) => {
+		var i = 0;
+		var str = "";
+		while (!(i >= maxBytesToRead / 4)) {
+			var utf32 = HEAP32[ptr + i * 4 >> 2];
+			if (utf32 == 0) break;
+			++i;
+			if (utf32 >= 65536) {
+				var ch = utf32 - 65536;
+				str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
+			} else str += String.fromCharCode(utf32);
+		}
+		return str;
+	};
+	var stringToUTF32 = (str, outPtr, maxBytesToWrite) => {
+		maxBytesToWrite ??= 2147483647;
+		if (maxBytesToWrite < 4) return 0;
+		var startPtr = outPtr;
+		var endPtr = startPtr + maxBytesToWrite - 4;
+		for (var i = 0; i < str.length; ++i) {
+			var codeUnit = str.charCodeAt(i);
+			if (codeUnit >= 55296 && codeUnit <= 57343) {
+				var trailSurrogate = str.charCodeAt(++i);
+				codeUnit = 65536 + ((codeUnit & 1023) << 10) | trailSurrogate & 1023;
+			}
+			HEAP32[outPtr >> 2] = codeUnit;
+			outPtr += 4;
+			if (outPtr + 4 > endPtr) break;
+		}
+		HEAP32[outPtr >> 2] = 0;
+		return outPtr - startPtr;
+	};
+	var lengthBytesUTF32 = (str) => {
+		var len = 0;
+		for (var i = 0; i < str.length; ++i) {
+			var codeUnit = str.charCodeAt(i);
+			if (codeUnit >= 55296 && codeUnit <= 57343) ++i;
+			len += 4;
+		}
+		return len;
+	};
+	var __embind_register_std_wstring = (rawType, charSize, name) => {
+		name = readLatin1String(name);
+		var decodeString, encodeString, readCharAt, lengthBytesUTF;
+		if (charSize === 2) {
+			decodeString = UTF16ToString;
+			encodeString = stringToUTF16;
+			lengthBytesUTF = lengthBytesUTF16;
+			readCharAt = (pointer) => HEAPU16[pointer >> 1];
+		} else if (charSize === 4) {
+			decodeString = UTF32ToString;
+			encodeString = stringToUTF32;
+			lengthBytesUTF = lengthBytesUTF32;
+			readCharAt = (pointer) => HEAPU32[pointer >> 2];
+		}
+		registerType(rawType, {
+			name,
+			fromWireType: (value) => {
+				var length = HEAPU32[value >> 2];
+				var str;
+				var decodeStartPtr = value + 4;
+				for (var i = 0; i <= length; ++i) {
+					var currentBytePtr = value + 4 + i * charSize;
+					if (i == length || readCharAt(currentBytePtr) == 0) {
+						var maxReadBytes = currentBytePtr - decodeStartPtr;
+						var stringSegment = decodeString(decodeStartPtr, maxReadBytes);
+						if (str === void 0) str = stringSegment;
+						else {
+							str += String.fromCharCode(0);
+							str += stringSegment;
+						}
+						decodeStartPtr = currentBytePtr + charSize;
+					}
+				}
+				_free(value);
+				return str;
+			},
+			toWireType: (destructors, value) => {
+				if (!(typeof value == "string")) throwBindingError(`Cannot pass non-string to C++ string type ${name}`);
+				var length = lengthBytesUTF(value);
+				var ptr = _malloc(4 + length + charSize);
+				HEAPU32[ptr >> 2] = length / charSize;
+				encodeString(value, ptr + 4, length + charSize);
+				if (destructors !== null) destructors.push(_free, ptr);
+				return ptr;
+			},
+			argPackAdvance: GenericWireTypeSize,
+			readValueFromPointer: readPointer,
+			destructorFunction(ptr) {
+				_free(ptr);
+			}
+		});
+	};
+	var __embind_register_void = (rawType, name) => {
+		name = readLatin1String(name);
+		registerType(rawType, {
+			isVoid: true,
+			name,
+			argPackAdvance: 0,
+			fromWireType: () => void 0,
+			toWireType: (destructors, o) => void 0
+		});
+	};
+	var requireRegisteredType = (rawType, humanName) => {
+		var impl = registeredTypes[rawType];
+		if (void 0 === impl) throwBindingError(`${humanName} has unknown type ${getTypeName(rawType)}`);
+		return impl;
+	};
+	var __emval_take_value = (type, arg) => {
+		type = requireRegisteredType(type, "_emval_take_value");
+		var v = type["readValueFromPointer"](arg);
+		return Emval.toHandle(v);
+	};
+	var __tzset_js = (timezone, daylight, std_name, dst_name) => {
+		var currentYear = (/* @__PURE__ */ new Date()).getFullYear();
+		var winter = new Date(currentYear, 0, 1);
+		var summer = new Date(currentYear, 6, 1);
+		var winterOffset = winter.getTimezoneOffset();
+		var summerOffset = summer.getTimezoneOffset();
+		var stdTimezoneOffset = Math.max(winterOffset, summerOffset);
+		HEAPU32[timezone >> 2] = stdTimezoneOffset * 60;
+		HEAP32[daylight >> 2] = Number(winterOffset != summerOffset);
+		var extractZone = (timezoneOffset) => {
+			var sign = timezoneOffset >= 0 ? "-" : "+";
+			var absOffset = Math.abs(timezoneOffset);
+			return `UTC${sign}${String(Math.floor(absOffset / 60)).padStart(2, "0")}${String(absOffset % 60).padStart(2, "0")}`;
+		};
+		var winterName = extractZone(winterOffset);
+		var summerName = extractZone(summerOffset);
+		if (summerOffset < winterOffset) {
+			stringToUTF8(winterName, std_name, 17);
+			stringToUTF8(summerName, dst_name, 17);
+		} else {
+			stringToUTF8(winterName, dst_name, 17);
+			stringToUTF8(summerName, std_name, 17);
+		}
+	};
+	var readEmAsmArgsArray = [];
+	var readEmAsmArgs = (sigPtr, buf) => {
+		readEmAsmArgsArray.length = 0;
+		var ch;
+		while (ch = HEAPU8[sigPtr++]) {
+			var wide = ch != 105;
+			wide &= ch != 112;
+			buf += wide && buf % 8 ? 4 : 0;
+			readEmAsmArgsArray.push(ch == 112 ? HEAPU32[buf >> 2] : ch == 106 ? HEAP64[buf >> 3] : ch == 105 ? HEAP32[buf >> 2] : HEAPF64[buf >> 3]);
+			buf += wide ? 8 : 4;
+		}
+		return readEmAsmArgsArray;
+	};
+	var runEmAsmFunction = (code, sigPtr, argbuf) => {
+		var args = readEmAsmArgs(sigPtr, argbuf);
+		return ASM_CONSTS[code](...args);
+	};
+	var _emscripten_asm_const_int = (code, sigPtr, argbuf) => runEmAsmFunction(code, sigPtr, argbuf);
+	var abortOnCannotGrowMemory = (requestedSize) => {
+		abort("OOM");
+	};
+	var _emscripten_resize_heap = (requestedSize) => {
+		HEAPU8.length;
+		requestedSize >>>= 0;
+		abortOnCannotGrowMemory(requestedSize);
+	};
+	var ENV = {};
+	var getExecutableName = () => thisProgram || "./this.program";
+	var getEnvStrings = () => {
+		if (!getEnvStrings.strings) {
+			var env = {
+				USER: "web_user",
+				LOGNAME: "web_user",
+				PATH: "/",
+				PWD: "/",
+				HOME: "/home/web_user",
+				LANG: (typeof navigator == "object" && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8",
+				_: getExecutableName()
+			};
+			for (var x in ENV) if (ENV[x] === void 0) delete env[x];
+			else env[x] = ENV[x];
+			var strings = [];
+			for (var x in env) strings.push(`${x}=${env[x]}`);
+			getEnvStrings.strings = strings;
+		}
+		return getEnvStrings.strings;
+	};
+	var _environ_get = (__environ, environ_buf) => {
+		var bufSize = 0;
+		var envp = 0;
+		for (var string of getEnvStrings()) {
+			var ptr = environ_buf + bufSize;
+			HEAPU32[__environ + envp >> 2] = ptr;
+			bufSize += stringToUTF8(string, ptr, Infinity) + 1;
+			envp += 4;
+		}
+		return 0;
+	};
+	var _environ_sizes_get = (penviron_count, penviron_buf_size) => {
+		var strings = getEnvStrings();
+		HEAPU32[penviron_count >> 2] = strings.length;
+		var bufSize = 0;
+		for (var string of strings) bufSize += lengthBytesUTF8(string) + 1;
+		HEAPU32[penviron_buf_size >> 2] = bufSize;
+		return 0;
+	};
+	var runtimeKeepaliveCounter = 0;
+	var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0;
+	var _proc_exit = (code) => {
+		if (!keepRuntimeAlive()) {
+			Module["onExit"]?.(code);
+			ABORT = true;
+		}
+		quit_(code, new ExitStatus(code));
+	};
+	var exitJS = (status, implicit) => {
+		_proc_exit(status);
+	};
+	var _exit = exitJS;
+	var getCFunc = (ident) => {
+		return Module["_" + ident];
+	};
+	var writeArrayToMemory = (array, buffer) => {
+		HEAP8.set(array, buffer);
+	};
+	var stackAlloc = (sz) => __emscripten_stack_alloc(sz);
+	var stringToUTF8OnStack = (str) => {
+		var size = lengthBytesUTF8(str) + 1;
+		var ret = stackAlloc(size);
+		stringToUTF8(str, ret, size);
+		return ret;
+	};
+	var ccall = (ident, returnType, argTypes, args, opts) => {
+		var toC = {
+			string: (str) => {
+				var ret = 0;
+				if (str !== null && str !== void 0 && str !== 0) ret = stringToUTF8OnStack(str);
+				return ret;
+			},
+			array: (arr) => {
+				var ret = stackAlloc(arr.length);
+				writeArrayToMemory(arr, ret);
+				return ret;
+			}
+		};
+		function convertReturnValue(ret) {
+			if (returnType === "string") return UTF8ToString(ret);
+			if (returnType === "boolean") return Boolean(ret);
+			return ret;
+		}
+		var func = getCFunc(ident);
+		var cArgs = [];
+		var stack = 0;
+		if (args) for (var i = 0; i < args.length; i++) {
+			var converter = toC[argTypes[i]];
+			if (converter) {
+				if (stack === 0) stack = stackSave();
+				cArgs[i] = converter(args[i]);
+			} else cArgs[i] = args[i];
+		}
+		var ret = func(...cArgs);
+		function onDone(ret) {
+			if (stack !== 0) stackRestore(stack);
+			return convertReturnValue(ret);
+		}
+		ret = onDone(ret);
+		return ret;
+	};
+	var cwrap = (ident, returnType, argTypes, opts) => {
+		var numericArgs = !argTypes || argTypes.every((type) => type === "number" || type === "boolean");
+		if (returnType !== "string" && numericArgs && !opts) return getCFunc(ident);
+		return (...args) => ccall(ident, returnType, argTypes, args, opts);
+	};
+	embind_init_charCodes();
+	init_ClassHandle();
+	init_RegisteredPointer();
+	init_emval();
+	if (Module["noExitRuntime"]) noExitRuntime = Module["noExitRuntime"];
+	if (Module["print"]) Module["print"];
+	if (Module["printErr"]) err = Module["printErr"];
+	if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
+	if (Module["arguments"]) Module["arguments"];
+	if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
+	Module["ccall"] = ccall;
+	Module["cwrap"] = cwrap;
+	var ASM_CONSTS = {
+		22048: () => Module.getRandomValue(),
+		22084: () => {
+			if (Module.getRandomValue === void 0) try {
+				var window_ = "object" === typeof window ? window : self;
+				var crypto_ = typeof window_.crypto !== "undefined" ? window_.crypto : window_.msCrypto;
+				crypto_ = crypto_ === void 0 ? crypto : crypto_;
+				var randomValuesStandard = function() {
+					var buf = new Uint32Array(1);
+					crypto_.getRandomValues(buf);
+					return buf[0] >>> 0;
+				};
+				randomValuesStandard();
+				Module.getRandomValue = randomValuesStandard;
+			} catch (e) {
+				try {
+					var crypto = require("crypto");
+					var randomValueNodeJS = function() {
+						var buf = crypto["randomBytes"](4);
+						return (buf[0] << 24 | buf[1] << 16 | buf[2] << 8 | buf[3]) >>> 0;
+					};
+					randomValueNodeJS();
+					Module.getRandomValue = randomValueNodeJS;
+				} catch (e) {
+					throw "No secure random number generator found";
+				}
+			}
+		}
+	};
+	var wasmImports = {
+		j: ___cxa_throw,
+		s: __abort_js,
+		l: __embind_register_bigint,
+		n: __embind_register_bool,
+		e: __embind_register_class,
+		d: __embind_register_class_constructor,
+		a: __embind_register_class_function,
+		u: __embind_register_emval,
+		k: __embind_register_float,
+		c: __embind_register_integer,
+		b: __embind_register_memory_view,
+		g: __embind_register_optional,
+		v: __embind_register_std_string,
+		h: __embind_register_std_wstring,
+		o: __embind_register_void,
+		f: __emval_take_value,
+		p: __tzset_js,
+		m: _emscripten_asm_const_int,
+		t: _emscripten_resize_heap,
+		q: _environ_get,
+		r: _environ_sizes_get,
+		i: _exit
+	};
+	var wasmExports = await createWasm();
+	wasmExports["x"];
+	var _malloc = wasmExports["z"];
+	var _free = wasmExports["A"];
+	var ___getTypeName = wasmExports["B"];
+	var __emscripten_stack_restore = wasmExports["C"];
+	var __emscripten_stack_alloc = wasmExports["D"];
+	var _emscripten_stack_get_current = wasmExports["E"];
+	function run() {
+		if (runDependencies > 0) {
+			dependenciesFulfilled = run;
+			return;
+		}
+		preRun();
+		if (runDependencies > 0) {
+			dependenciesFulfilled = run;
+			return;
+		}
+		function doRun() {
+			Module["calledRun"] = true;
+			if (ABORT) return;
+			initRuntime();
+			readyPromiseResolve(Module);
+			Module["onRuntimeInitialized"]?.();
+			postRun();
+		}
+		if (Module["setStatus"]) {
+			Module["setStatus"]("Running...");
+			setTimeout(() => {
+				setTimeout(() => Module["setStatus"](""), 1);
+				doRun();
+			}, 1);
+		} else doRun();
+	}
+	function preInit() {
+		if (Module["preInit"]) {
+			if (typeof Module["preInit"] == "function") Module["preInit"] = [Module["preInit"]];
+			while (Module["preInit"].length > 0) Module["preInit"].shift()();
+		}
+	}
+	preInit();
+	run();
+	moduleRtn = readyPromise;
+	return moduleRtn;
+});
+//#endregion
+//#region src/index.ts
+const MLKEM_ALGORITHM = { name: "ML-KEM-768" };
+function bytesToHexWithSpaces(bytes) {
+	return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join(" ");
+}
+function hexStringToBytes(hex) {
+	const cleaned = hex.trim().replace(/^0x/i, "");
+	if (!cleaned) return new Uint8Array();
+	const parts = cleaned.includes(" ") ? cleaned.split(/\s+/) : null;
+	if (parts) return Uint8Array.from(parts.map((p) => parseInt(p, 16)));
+	if (cleaned.length % 2 !== 0) throw new TypeError("Hex string must have even length");
+	const out = new Uint8Array(cleaned.length / 2);
+	for (let i = 0; i < out.length; i++) out[i] = parseInt(cleaned.slice(i * 2, i * 2 + 2), 16);
+	return out;
+}
+function bufferSourceToBytes(value) {
+	if (value instanceof Uint8Array) {
+		if (typeof SharedArrayBuffer !== "undefined" && value.buffer instanceof SharedArrayBuffer) return new Uint8Array(value);
+		return value;
+	}
+	if (value instanceof ArrayBuffer) return new Uint8Array(value);
+	if (ArrayBuffer.isView(value)) {
+		const buffer = value.buffer;
+		if (typeof SharedArrayBuffer !== "undefined" && buffer instanceof SharedArrayBuffer) {
+			const view = value;
+			const u8 = new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+			return new Uint8Array(u8);
+		}
+		return new Uint8Array(buffer, value.byteOffset, value.byteLength);
+	}
+	throw new TypeError("Expected a BufferSource (ArrayBuffer or typed array)");
+}
+function bytesToArrayBuffer(bytes) {
+	if (typeof SharedArrayBuffer !== "undefined" && bytes.buffer instanceof SharedArrayBuffer) return Uint8Array.from(bytes).buffer;
+	return bytes.buffer;
+}
+async function secretToKeyBytes(secret) {
+	const resolved = await secret;
+	if (typeof resolved === "string") return hexStringToBytes(resolved);
+	const bytes = bufferSourceToBytes(resolved);
+	return new Uint8Array(bytes);
+}
+async function cryptoKeyToRawHex(key) {
+	const format = key.type === "public" ? "raw-public" : "raw-seed";
+	return bytesToHexWithSpaces(bufferSourceToBytes(await mlkem_default.exportKey(format, key)));
+}
+var MlKemWrapper = class {
+	keypair() {
+		const keyPairPromise = mlkem_default.generateKey(MLKEM_ALGORITHM, true, ["encapsulateBits", "decapsulateBits"]);
+		return { get: (key) => keyPairPromise.then((kp) => key === "public_key" ? kp.publicKey : kp.privateKey) };
+	}
+	encrypt(public_key) {
+		const encPromise = Promise.resolve(public_key).then((pk) => mlkem_default.encapsulateBits(MLKEM_ALGORITHM, pk));
+		return { get: (key) => {
+			if (key === "cyphertext") return encPromise.then((r) => r.ciphertext);
+			if (key === "secret") return encPromise.then((r) => r.sharedKey);
+			throw new Error(`Unknown encrypt result field: ${String(key)}`);
+		} };
+	}
+	decrypt(cyphertext, private_key) {
+		const ctPromise = Promise.resolve(cyphertext);
+		const skPromise = Promise.resolve(private_key);
+		return Promise.all([ctPromise, skPromise]).then(([ct, sk]) => mlkem_default.decapsulateBits(MLKEM_ALGORITHM, sk, ct));
+	}
+	buffer_to_string(buffer) {
+		if (buffer && typeof buffer.then === "function") return buffer.then((b) => this.buffer_to_string(b));
+		if (buffer instanceof CryptoKey) return cryptoKeyToRawHex(buffer);
+		return bytesToHexWithSpaces(bufferSourceToBytes(buffer));
+	}
+	async encryptMessage(message, secret) {
+		const secretKeyBuffer = bytesToArrayBuffer(await secretToKeyBytes(secret));
+		const key = await crypto.subtle.importKey("raw", secretKeyBuffer, { name: "AES-GCM" }, false, ["encrypt"]);
+		const iv = crypto.getRandomValues(new Uint8Array(12));
+		const messageBytes = new TextEncoder().encode(message);
+		const encryptedData = await crypto.subtle.encrypt({
+			name: "AES-GCM",
+			iv
+		}, key, messageBytes);
+		const encryptedMessage = new Uint8Array(iv.length + encryptedData.byteLength);
+		encryptedMessage.set(iv, 0);
+		encryptedMessage.set(new Uint8Array(encryptedData), iv.length);
+		return encryptedMessage;
+	}
+	async decryptMessage(encryptedMessage, secret) {
+		const secretKeyBuffer = bytesToArrayBuffer(await secretToKeyBytes(secret));
+		const iv = encryptedMessage.slice(0, 12);
+		const encryptedData = encryptedMessage.slice(12);
+		const key = await crypto.subtle.importKey("raw", secretKeyBuffer, { name: "AES-GCM" }, false, ["decrypt"]);
+		const decryptedData = await crypto.subtle.decrypt({
+			name: "AES-GCM",
+			iv
+		}, key, encryptedData);
+		return new TextDecoder().decode(decryptedData);
+	}
+	delete() {}
+};
+async function loadMlKem1024() {
+	return new KyberVariantWrapper(new (await (kyber_crystals_wasm_engine())).MlKem1024());
+}
+async function loadMlKem512() {
+	return new KyberVariantWrapper(new (await (kyber_crystals_wasm_engine())).MlKem512());
+}
+async function loadMlKem768() {
+	return new MlKemWrapper();
+}
+var KyberVariantWrapper = class {
+	constructor(instance) {
+		this.instance = instance;
+	}
+	keypair() {
+		return this.instance.keypair();
+	}
+	encrypt(public_key) {
+		return this.instance.encrypt(public_key);
+	}
+	async decrypt(cyphertext, private_key) {
+		return this.instance.decrypt(cyphertext, private_key);
+	}
+	buffer_to_string(buffer) {
+		return this.instance.buffer_to_string(buffer);
+	}
+	async toSecretBytes(secret) {
+		const resolved = await secret;
+		if (typeof resolved === "string") return hexStringToBytes(resolved);
+		try {
+			return await secretToKeyBytes(resolved);
+		} catch {
+			return hexStringToBytes(this.instance.buffer_to_string(resolved));
+		}
+	}
+	async encryptMessage(message, secret) {
+		const secretKeyBuffer = bytesToArrayBuffer(await this.toSecretBytes(secret));
+		const key = await crypto.subtle.importKey("raw", secretKeyBuffer, { name: "AES-GCM" }, false, ["encrypt"]);
+		const iv = crypto.getRandomValues(new Uint8Array(12));
+		const messageBytes = new TextEncoder().encode(message);
+		const encryptedData = await crypto.subtle.encrypt({
+			name: "AES-GCM",
+			iv
+		}, key, messageBytes);
+		const encryptedMessage = new Uint8Array(iv.length + encryptedData.byteLength);
+		encryptedMessage.set(iv, 0);
+		encryptedMessage.set(new Uint8Array(encryptedData), iv.length);
+		return encryptedMessage;
+	}
+	async decryptMessage(encryptedMessage, secret) {
+		const secretKeyBuffer = bytesToArrayBuffer(await this.toSecretBytes(secret));
+		const iv = encryptedMessage.slice(0, 12);
+		const encryptedData = encryptedMessage.slice(12);
+		const key = await crypto.subtle.importKey("raw", secretKeyBuffer, { name: "AES-GCM" }, false, ["decrypt"]);
+		const decryptedData = await crypto.subtle.decrypt({
+			name: "AES-GCM",
+			iv
+		}, key, encryptedData);
+		return new TextDecoder().decode(decryptedData);
+	}
+	delete() {
+		this.instance.delete();
+	}
+};
+//#endregion
+export { loadMlKem1024, loadMlKem512, loadMlKem768 };