@aztec/bb.js 0.85.0-nightly.20250417 → 0.85.0-nightly.20250418

package/dest/browser/index.js

@@ -3384,21 +3384,6 @@ var __webpack_exports__ = {};
         }
     }
     Buffer128.SIZE_IN_BYTES = 128;
-    function parseBigEndianU32Array(buffer, hasSizePrefix = false) {
-        const dv = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-        let offset = 0;
-        let count = buffer.byteLength >>> 2;
-        if (hasSizePrefix) {
-            count = dv.getUint32(0, false);
-            offset = 4;
-        }
-        const out = new Array(count);
-        for (let i = 0; i < count; i++) {
-            out[i] = dv.getUint32(offset, false);
-            offset += 4;
-        }
-        return out;
-    }
     class BarretenbergApi {
         constructor(wasm) {
             this.wasm = wasm;
@@ -3438,13 +3423,6 @@ var __webpack_exports__ = {};
             const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
             return out[0];
         }
-        async poseidon2HashAccumulate(inputsBuffer) {
-            const inArgs = [ inputsBuffer ].map(serializeBufferable);
-            const outTypes = [ Fr ];
-            const result = await this.wasm.callWasmExport("poseidon2_hash_accumulate", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
-            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
-            return out[0];
-        }
         async poseidon2Hashes(inputsBuffer) {
             const inArgs = [ inputsBuffer ].map(serializeBufferable);
             const outTypes = [ Fr ];
@@ -3459,6 +3437,13 @@ var __webpack_exports__ = {};
             const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
             return out[0];
         }
+        async poseidon2HashAccumulate(inputsBuffer) {
+            const inArgs = [ inputsBuffer ].map(serializeBufferable);
+            const outTypes = [ Fr ];
+            const result = await this.wasm.callWasmExport("poseidon2_hash_accumulate", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
+            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
+            return out[0];
+        }
         async blake2s(data) {
             const inArgs = [ data ].map(serializeBufferable);
             const outTypes = [ Buffer32 ];
@@ -3473,69 +3458,6 @@ var __webpack_exports__ = {};
             const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
             return out[0];
         }
-        async schnorrComputePublicKey(privateKey) {
-            const inArgs = [ privateKey ].map(serializeBufferable);
-            const outTypes = [ Point ];
-            const result = await this.wasm.callWasmExport("schnorr_compute_public_key", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
-            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
-            return out[0];
-        }
-        async schnorrNegatePublicKey(publicKeyBuffer) {
-            const inArgs = [ publicKeyBuffer ].map(serializeBufferable);
-            const outTypes = [ Point ];
-            const result = await this.wasm.callWasmExport("schnorr_negate_public_key", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
-            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
-            return out[0];
-        }
-        async schnorrConstructSignature(message, privateKey) {
-            const inArgs = [ message, privateKey ].map(serializeBufferable);
-            const outTypes = [ Buffer32, Buffer32 ];
-            const result = await this.wasm.callWasmExport("schnorr_construct_signature", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
-            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
-            return out;
-        }
-        async schnorrVerifySignature(message, pubKey, sigS, sigE) {
-            const inArgs = [ message, pubKey, sigS, sigE ].map(serializeBufferable);
-            const outTypes = [ BoolDeserializer() ];
-            const result = await this.wasm.callWasmExport("schnorr_verify_signature", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
-            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
-            return out[0];
-        }
-        async schnorrMultisigCreateMultisigPublicKey(privateKey) {
-            const inArgs = [ privateKey ].map(serializeBufferable);
-            const outTypes = [ Buffer128 ];
-            const result = await this.wasm.callWasmExport("schnorr_multisig_create_multisig_public_key", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
-            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
-            return out[0];
-        }
-        async schnorrMultisigValidateAndCombineSignerPubkeys(signerPubkeyBuf) {
-            const inArgs = [ signerPubkeyBuf ].map(serializeBufferable);
-            const outTypes = [ Point, BoolDeserializer() ];
-            const result = await this.wasm.callWasmExport("schnorr_multisig_validate_and_combine_signer_pubkeys", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
-            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
-            return out;
-        }
-        async schnorrMultisigConstructSignatureRound1() {
-            const inArgs = [].map(serializeBufferable);
-            const outTypes = [ Buffer128, Buffer128 ];
-            const result = await this.wasm.callWasmExport("schnorr_multisig_construct_signature_round_1", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
-            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
-            return out;
-        }
-        async schnorrMultisigConstructSignatureRound2(message, privateKey, signerRoundOnePrivateBuf, signerPubkeysBuf, roundOnePublicBuf) {
-            const inArgs = [ message, privateKey, signerRoundOnePrivateBuf, signerPubkeysBuf, roundOnePublicBuf ].map(serializeBufferable);
-            const outTypes = [ Fq, BoolDeserializer() ];
-            const result = await this.wasm.callWasmExport("schnorr_multisig_construct_signature_round_2", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
-            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
-            return out;
-        }
-        async schnorrMultisigCombineSignatures(message, signerPubkeysBuf, roundOneBuf, roundTwoBuf) {
-            const inArgs = [ message, signerPubkeysBuf, roundOneBuf, roundTwoBuf ].map(serializeBufferable);
-            const outTypes = [ Buffer32, Buffer32, BoolDeserializer() ];
-            const result = await this.wasm.callWasmExport("schnorr_multisig_combine_signatures", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
-            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
-            return out;
-        }
         async aesEncryptBufferCbc(input, iv, key, length) {
             const inArgs = [ input, iv, key, length ].map(serializeBufferable);
             const outTypes = [ BufferDeserializer() ];
@@ -3592,12 +3514,6 @@ var __webpack_exports__ = {};
             const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
             return out;
         }
-        async acirGatesAztecClient(acirVec) {
-            const inArgs = [ acirVec ].map(serializeBufferable);
-            const outTypes = [ BufferDeserializer() ];
-            const resultBuffer = await this.wasm.callWasmExport("acir_gates_aztec_client", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
-            return parseBigEndianU32Array(resultBuffer[0], true);
-        }
         async acirNewAcirComposer(sizeHint) {
             const inArgs = [ sizeHint ].map(serializeBufferable);
             const outTypes = [ Ptr ];
@@ -3640,6 +3556,20 @@ var __webpack_exports__ = {};
             const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
             return out[0];
         }
+        async acirProveAztecClient(ivcInputsBuf) {
+            const inArgs = [ ivcInputsBuf ].map(serializeBufferable);
+            const outTypes = [ BufferDeserializer(), BufferDeserializer() ];
+            const result = await this.wasm.callWasmExport("acir_prove_aztec_client", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
+            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
+            return out;
+        }
+        async acirVerifyAztecClient(proofBuf, vkBuf) {
+            const inArgs = [ proofBuf, vkBuf ].map(serializeBufferable);
+            const outTypes = [ BoolDeserializer() ];
+            const result = await this.wasm.callWasmExport("acir_verify_aztec_client", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
+            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
+            return out[0];
+        }
         async acirLoadVerificationKey(acirComposerPtr, vkBuf) {
             const inArgs = [ acirComposerPtr, vkBuf ].map(serializeBufferable);
             const outTypes = [];
@@ -3682,6 +3612,13 @@ var __webpack_exports__ = {};
             const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
             return out[0];
         }
+        async acirHonkSolidityVerifier(proofBuf, vkBuf) {
+            const inArgs = [ proofBuf, vkBuf ].map(serializeBufferable);
+            const outTypes = [ StringDeserializer() ];
+            const result = await this.wasm.callWasmExport("acir_honk_solidity_verifier", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
+            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
+            return out[0];
+        }
         async acirSerializeProofIntoFields(acirComposerPtr, proofBuf, numInnerPublicInputs) {
             const inArgs = [ acirComposerPtr, proofBuf, numInnerPublicInputs ].map(serializeBufferable);
             const outTypes = [ VectorDeserializer(Fr) ];
@@ -3696,27 +3633,6 @@ var __webpack_exports__ = {};
             const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
             return out;
         }
-        async acirProveAndVerifyAztecClient(acirVec, witnessVec) {
-            const inArgs = [ acirVec, witnessVec ].map(serializeBufferable);
-            const outTypes = [ BoolDeserializer() ];
-            const result = await this.wasm.callWasmExport("acir_prove_and_verify_aztec_client", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
-            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
-            return out[0];
-        }
-        async acirProveAztecClient(acirVec, witnessVec) {
-            const inArgs = [ acirVec, witnessVec ].map(serializeBufferable);
-            const outTypes = [ BufferDeserializer(), BufferDeserializer() ];
-            const result = await this.wasm.callWasmExport("acir_prove_aztec_client", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
-            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
-            return [ out[0], out[1] ];
-        }
-        async acirVerifyAztecClient(proofBuf, vkBuf) {
-            const inArgs = [ proofBuf, vkBuf ].map(serializeBufferable);
-            const outTypes = [ BoolDeserializer() ];
-            const result = await this.wasm.callWasmExport("acir_verify_aztec_client", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
-            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
-            return out[0];
-        }
         async acirProveUltraHonk(acirVec, witnessVec) {
             const inArgs = [ acirVec, witnessVec ].map(serializeBufferable);
             const outTypes = [ BufferDeserializer() ];
@@ -3759,13 +3675,6 @@ var __webpack_exports__ = {};
             const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
             return out[0];
         }
-        async acirHonkSolidityVerifier(acirVec, vkBuf) {
-            const inArgs = [ acirVec, vkBuf ].map(serializeBufferable);
-            const outTypes = [ BufferDeserializer() ];
-            const result = await this.wasm.callWasmExport("acir_honk_solidity_verifier", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
-            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
-            return out[0];
-        }
         async acirProofAsFieldsUltraHonk(proofBuf) {
             const inArgs = [ proofBuf ].map(serializeBufferable);
             const outTypes = [ VectorDeserializer(Fr) ];
@@ -3787,6 +3696,13 @@ var __webpack_exports__ = {};
             const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
             return out[0];
         }
+        async acirGatesAztecClient(ivcInputsBuf) {
+            const inArgs = [ ivcInputsBuf ].map(serializeBufferable);
+            const outTypes = [ BufferDeserializer() ];
+            const result = await this.wasm.callWasmExport("acir_gates_aztec_client", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
+            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
+            return out[0];
+        }
     }
     class BarretenbergApiSync {
         constructor(wasm) {
@@ -3827,13 +3743,6 @@ var __webpack_exports__ = {};
             const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
             return out[0];
         }
-        poseidon2HashAccumulate(inputsBuffer) {
-            const inArgs = [ inputsBuffer ].map(serializeBufferable);
-            const outTypes = [ Fr ];
-            const result = this.wasm.callWasmExport("poseidon2_hash_accumulate", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
-            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
-            return out[0];
-        }
         poseidon2Hashes(inputsBuffer) {
             const inArgs = [ inputsBuffer ].map(serializeBufferable);
             const outTypes = [ Fr ];
@@ -3848,6 +3757,13 @@ var __webpack_exports__ = {};
             const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
             return out[0];
         }
+        poseidon2HashAccumulate(inputsBuffer) {
+            const inArgs = [ inputsBuffer ].map(serializeBufferable);
+            const outTypes = [ Fr ];
+            const result = this.wasm.callWasmExport("poseidon2_hash_accumulate", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
+            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
+            return out[0];
+        }
         blake2s(data) {
             const inArgs = [ data ].map(serializeBufferable);
             const outTypes = [ Buffer32 ];
@@ -3862,69 +3778,6 @@ var __webpack_exports__ = {};
             const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
             return out[0];
         }
-        schnorrComputePublicKey(privateKey) {
-            const inArgs = [ privateKey ].map(serializeBufferable);
-            const outTypes = [ Point ];
-            const result = this.wasm.callWasmExport("schnorr_compute_public_key", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
-            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
-            return out[0];
-        }
-        schnorrNegatePublicKey(publicKeyBuffer) {
-            const inArgs = [ publicKeyBuffer ].map(serializeBufferable);
-            const outTypes = [ Point ];
-            const result = this.wasm.callWasmExport("schnorr_negate_public_key", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
-            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
-            return out[0];
-        }
-        schnorrConstructSignature(message, privateKey) {
-            const inArgs = [ message, privateKey ].map(serializeBufferable);
-            const outTypes = [ Buffer32, Buffer32 ];
-            const result = this.wasm.callWasmExport("schnorr_construct_signature", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
-            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
-            return out;
-        }
-        schnorrVerifySignature(message, pubKey, sigS, sigE) {
-            const inArgs = [ message, pubKey, sigS, sigE ].map(serializeBufferable);
-            const outTypes = [ BoolDeserializer() ];
-            const result = this.wasm.callWasmExport("schnorr_verify_signature", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
-            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
-            return out[0];
-        }
-        schnorrMultisigCreateMultisigPublicKey(privateKey) {
-            const inArgs = [ privateKey ].map(serializeBufferable);
-            const outTypes = [ Buffer128 ];
-            const result = this.wasm.callWasmExport("schnorr_multisig_create_multisig_public_key", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
-            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
-            return out[0];
-        }
-        schnorrMultisigValidateAndCombineSignerPubkeys(signerPubkeyBuf) {
-            const inArgs = [ signerPubkeyBuf ].map(serializeBufferable);
-            const outTypes = [ Point, BoolDeserializer() ];
-            const result = this.wasm.callWasmExport("schnorr_multisig_validate_and_combine_signer_pubkeys", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
-            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
-            return out;
-        }
-        schnorrMultisigConstructSignatureRound1() {
-            const inArgs = [].map(serializeBufferable);
-            const outTypes = [ Buffer128, Buffer128 ];
-            const result = this.wasm.callWasmExport("schnorr_multisig_construct_signature_round_1", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
-            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
-            return out;
-        }
-        schnorrMultisigConstructSignatureRound2(message, privateKey, signerRoundOnePrivateBuf, signerPubkeysBuf, roundOnePublicBuf) {
-            const inArgs = [ message, privateKey, signerRoundOnePrivateBuf, signerPubkeysBuf, roundOnePublicBuf ].map(serializeBufferable);
-            const outTypes = [ Fq, BoolDeserializer() ];
-            const result = this.wasm.callWasmExport("schnorr_multisig_construct_signature_round_2", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
-            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
-            return out;
-        }
-        schnorrMultisigCombineSignatures(message, signerPubkeysBuf, roundOneBuf, roundTwoBuf) {
-            const inArgs = [ message, signerPubkeysBuf, roundOneBuf, roundTwoBuf ].map(serializeBufferable);
-            const outTypes = [ Buffer32, Buffer32, BoolDeserializer() ];
-            const result = this.wasm.callWasmExport("schnorr_multisig_combine_signatures", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
-            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
-            return out;
-        }
         aesEncryptBufferCbc(input, iv, key, length) {
             const inArgs = [ input, iv, key, length ].map(serializeBufferable);
             const outTypes = [ BufferDeserializer() ];
@@ -4023,6 +3876,20 @@ var __webpack_exports__ = {};
             const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
             return out[0];
         }
+        acirProveAztecClient(ivcInputsBuf) {
+            const inArgs = [ ivcInputsBuf ].map(serializeBufferable);
+            const outTypes = [ BufferDeserializer(), BufferDeserializer() ];
+            const result = this.wasm.callWasmExport("acir_prove_aztec_client", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
+            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
+            return out;
+        }
+        acirVerifyAztecClient(proofBuf, vkBuf) {
+            const inArgs = [ proofBuf, vkBuf ].map(serializeBufferable);
+            const outTypes = [ BoolDeserializer() ];
+            const result = this.wasm.callWasmExport("acir_verify_aztec_client", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
+            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
+            return out[0];
+        }
         acirLoadVerificationKey(acirComposerPtr, vkBuf) {
             const inArgs = [ acirComposerPtr, vkBuf ].map(serializeBufferable);
             const outTypes = [];
@@ -4065,6 +3932,13 @@ var __webpack_exports__ = {};
             const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
             return out[0];
         }
+        acirHonkSolidityVerifier(proofBuf, vkBuf) {
+            const inArgs = [ proofBuf, vkBuf ].map(serializeBufferable);
+            const outTypes = [ StringDeserializer() ];
+            const result = this.wasm.callWasmExport("acir_honk_solidity_verifier", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
+            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
+            return out[0];
+        }
         acirSerializeProofIntoFields(acirComposerPtr, proofBuf, numInnerPublicInputs) {
             const inArgs = [ acirComposerPtr, proofBuf, numInnerPublicInputs ].map(serializeBufferable);
             const outTypes = [ VectorDeserializer(Fr) ];
@@ -4086,6 +3960,13 @@ var __webpack_exports__ = {};
             const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
             return out[0];
         }
+        acirProveUltraKeccakHonk(acirVec, witnessVec) {
+            const inArgs = [ acirVec, witnessVec ].map(serializeBufferable);
+            const outTypes = [ BufferDeserializer() ];
+            const result = this.wasm.callWasmExport("acir_prove_ultra_keccak_honk", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
+            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
+            return out[0];
+        }
         acirVerifyUltraHonk(proofBuf, vkBuf) {
             const inArgs = [ proofBuf, vkBuf ].map(serializeBufferable);
             const outTypes = [ BoolDeserializer() ];
@@ -4093,6 +3974,13 @@ var __webpack_exports__ = {};
             const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
             return out[0];
         }
+        acirVerifyUltraKeccakHonk(proofBuf, vkBuf) {
+            const inArgs = [ proofBuf, vkBuf ].map(serializeBufferable);
+            const outTypes = [ BoolDeserializer() ];
+            const result = this.wasm.callWasmExport("acir_verify_ultra_keccak_honk", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
+            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
+            return out[0];
+        }
         acirWriteVkUltraHonk(acirVec) {
             const inArgs = [ acirVec ].map(serializeBufferable);
             const outTypes = [ BufferDeserializer() ];
@@ -4100,6 +3988,13 @@ var __webpack_exports__ = {};
             const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
             return out[0];
         }
+        acirWriteVkUltraKeccakHonk(acirVec) {
+            const inArgs = [ acirVec ].map(serializeBufferable);
+            const outTypes = [ BufferDeserializer() ];
+            const result = this.wasm.callWasmExport("acir_write_vk_ultra_keccak_honk", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
+            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
+            return out[0];
+        }
         acirProofAsFieldsUltraHonk(proofBuf) {
             const inArgs = [ proofBuf ].map(serializeBufferable);
             const outTypes = [ VectorDeserializer(Fr) ];
@@ -4121,6 +4016,13 @@ var __webpack_exports__ = {};
             const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
             return out[0];
         }
+        acirGatesAztecClient(ivcInputsBuf) {
+            const inArgs = [ ivcInputsBuf ].map(serializeBufferable);
+            const outTypes = [ BufferDeserializer() ];
+            const result = this.wasm.callWasmExport("acir_gates_aztec_client", inArgs, outTypes.map((t => t.SIZE_IN_BYTES)));
+            const out = result.map(((r, i) => outTypes[i].fromBuffer(r)));
+            return out[0];
+        }
     }
     var browser = __webpack_require__(227);
     var browser_default = __webpack_require__.n(browser);
@@ -10381,12 +10283,2038 @@ var __webpack_exports__ = {};
         }
         return files;
     }
+    var unpack_Buffer = __webpack_require__(764)["lW"];
+    var decoder;
+    try {
+        decoder = new TextDecoder;
+    } catch (error) {}
+    var src;
+    var srcEnd;
+    var position = 0;
+    var alreadySet;
+    const EMPTY_ARRAY = [];
+    var unpack_strings = EMPTY_ARRAY;
+    var stringPosition = 0;
+    var currentUnpackr = {};
+    var currentStructures;
+    var srcString;
+    var srcStringStart = 0;
+    var srcStringEnd = 0;
+    var bundledStrings;
+    var referenceMap;
+    var currentExtensions = [];
+    var dataView;
+    var defaultOptions = {
+        useRecords: false,
+        mapsAsObjects: true
+    };
+    class C1Type {}
+    const C1 = new C1Type;
+    C1.name = "MessagePack 0xC1";
+    var sequentialMode = false;
+    var inlineObjectReadThreshold = 2;
+    var readStruct, onLoadedStructures, onSaveState;
+    var BlockedFunction;
+    try {
+        new Function("");
+    } catch (error) {
+        inlineObjectReadThreshold = Infinity;
+    }
+    class Unpackr {
+        constructor(options) {
+            if (options) {
+                if (options.useRecords === false && options.mapsAsObjects === undefined) options.mapsAsObjects = true;
+                if (options.sequential && options.trusted !== false) {
+                    options.trusted = true;
+                    if (!options.structures && options.useRecords != false) {
+                        options.structures = [];
+                        if (!options.maxSharedStructures) options.maxSharedStructures = 0;
+                    }
+                }
+                if (options.structures) options.structures.sharedLength = options.structures.length; else if (options.getStructures) {
+                    (options.structures = []).uninitialized = true;
+                    options.structures.sharedLength = 0;
+                }
+                if (options.int64AsNumber) {
+                    options.int64AsType = "number";
+                }
+            }
+            Object.assign(this, options);
+        }
+        unpack(source, options) {
+            if (src) {
+                return saveState((() => {
+                    clearSource();
+                    return this ? this.unpack(source, options) : Unpackr.prototype.unpack.call(defaultOptions, source, options);
+                }));
+            }
+            if (!source.buffer && source.constructor === ArrayBuffer) source = typeof unpack_Buffer !== "undefined" ? unpack_Buffer.from(source) : new Uint8Array(source);
+            if (typeof options === "object") {
+                srcEnd = options.end || source.length;
+                position = options.start || 0;
+            } else {
+                position = 0;
+                srcEnd = options > -1 ? options : source.length;
+            }
+            stringPosition = 0;
+            srcStringEnd = 0;
+            srcString = null;
+            unpack_strings = EMPTY_ARRAY;
+            bundledStrings = null;
+            src = source;
+            try {
+                dataView = source.dataView || (source.dataView = new DataView(source.buffer, source.byteOffset, source.byteLength));
+            } catch (error) {
+                src = null;
+                if (source instanceof Uint8Array) throw error;
+                throw new Error("Source must be a Uint8Array or Buffer but was a " + (source && typeof source == "object" ? source.constructor.name : typeof source));
+            }
+            if (this instanceof Unpackr) {
+                currentUnpackr = this;
+                if (this.structures) {
+                    currentStructures = this.structures;
+                    return checkedRead(options);
+                } else if (!currentStructures || currentStructures.length > 0) {
+                    currentStructures = [];
+                }
+            } else {
+                currentUnpackr = defaultOptions;
+                if (!currentStructures || currentStructures.length > 0) currentStructures = [];
+            }
+            return checkedRead(options);
+        }
+        unpackMultiple(source, forEach) {
+            let values, lastPosition = 0;
+            try {
+                sequentialMode = true;
+                let size = source.length;
+                let value = this ? this.unpack(source, size) : defaultUnpackr.unpack(source, size);
+                if (forEach) {
+                    if (forEach(value, lastPosition, position) === false) return;
+                    while (position < size) {
+                        lastPosition = position;
+                        if (forEach(checkedRead(), lastPosition, position) === false) {
+                            return;
+                        }
+                    }
+                } else {
+                    values = [ value ];
+                    while (position < size) {
+                        lastPosition = position;
+                        values.push(checkedRead());
+                    }
+                    return values;
+                }
+            } catch (error) {
+                error.lastPosition = lastPosition;
+                error.values = values;
+                throw error;
+            } finally {
+                sequentialMode = false;
+                clearSource();
+            }
+        }
+        _mergeStructures(loadedStructures, existingStructures) {
+            if (onLoadedStructures) loadedStructures = onLoadedStructures.call(this, loadedStructures);
+            loadedStructures = loadedStructures || [];
+            if (Object.isFrozen(loadedStructures)) loadedStructures = loadedStructures.map((structure => structure.slice(0)));
+            for (let i = 0, l = loadedStructures.length; i < l; i++) {
+                let structure = loadedStructures[i];
+                if (structure) {
+                    structure.isShared = true;
+                    if (i >= 32) structure.highByte = i - 32 >> 5;
+                }
+            }
+            loadedStructures.sharedLength = loadedStructures.length;
+            for (let id in existingStructures || []) {
+                if (id >= 0) {
+                    let structure = loadedStructures[id];
+                    let existing = existingStructures[id];
+                    if (existing) {
+                        if (structure) (loadedStructures.restoreStructures || (loadedStructures.restoreStructures = []))[id] = structure;
+                        loadedStructures[id] = existing;
+                    }
+                }
+            }
+            return this.structures = loadedStructures;
+        }
+        decode(source, options) {
+            return this.unpack(source, options);
+        }
+    }
+    function getPosition() {
+        return position;
+    }
+    function checkedRead(options) {
+        try {
+            if (!currentUnpackr.trusted && !sequentialMode) {
+                let sharedLength = currentStructures.sharedLength || 0;
+                if (sharedLength < currentStructures.length) currentStructures.length = sharedLength;
+            }
+            let result;
+            if (currentUnpackr.randomAccessStructure && src[position] < 64 && src[position] >= 32 && readStruct) {
+                result = readStruct(src, position, srcEnd, currentUnpackr);
+                src = null;
+                if (!(options && options.lazy) && result) result = result.toJSON();
+                position = srcEnd;
+            } else result = read();
+            if (bundledStrings) {
+                position = bundledStrings.postBundlePosition;
+                bundledStrings = null;
+            }
+            if (sequentialMode) currentStructures.restoreStructures = null;
+            if (position == srcEnd) {
+                if (currentStructures && currentStructures.restoreStructures) restoreStructures();
+                currentStructures = null;
+                src = null;
+                if (referenceMap) referenceMap = null;
+            } else if (position > srcEnd) {
+                throw new Error("Unexpected end of MessagePack data");
+            } else if (!sequentialMode) {
+                let jsonView;
+                try {
+                    jsonView = JSON.stringify(result, ((_, value) => typeof value === "bigint" ? `${value}n` : value)).slice(0, 100);
+                } catch (error) {
+                    jsonView = "(JSON view not available " + error + ")";
+                }
+                throw new Error("Data read, but end of buffer not reached " + jsonView);
+            }
+            return result;
+        } catch (error) {
+            if (currentStructures && currentStructures.restoreStructures) restoreStructures();
+            clearSource();
+            if (error instanceof RangeError || error.message.startsWith("Unexpected end of buffer") || position > srcEnd) {
+                error.incomplete = true;
+            }
+            throw error;
+        }
+    }
+    function restoreStructures() {
+        for (let id in currentStructures.restoreStructures) {
+            currentStructures[id] = currentStructures.restoreStructures[id];
+        }
+        currentStructures.restoreStructures = null;
+    }
+    function read() {
+        let token = src[position++];
+        if (token < 160) {
+            if (token < 128) {
+                if (token < 64) return token; else {
+                    let structure = currentStructures[token & 63] || currentUnpackr.getStructures && loadStructures()[token & 63];
+                    if (structure) {
+                        if (!structure.read) {
+                            structure.read = createStructureReader(structure, token & 63);
+                        }
+                        return structure.read();
+                    } else return token;
+                }
+            } else if (token < 144) {
+                token -= 128;
+                if (currentUnpackr.mapsAsObjects) {
+                    let object = {};
+                    for (let i = 0; i < token; i++) {
+                        let key = readKey();
+                        if (key === "__proto__") key = "__proto_";
+                        object[key] = read();
+                    }
+                    return object;
+                } else {
+                    let map = new Map;
+                    for (let i = 0; i < token; i++) {
+                        map.set(read(), read());
+                    }
+                    return map;
+                }
+            } else {
+                token -= 144;
+                let array = new Array(token);
+                for (let i = 0; i < token; i++) {
+                    array[i] = read();
+                }
+                if (currentUnpackr.freezeData) return Object.freeze(array);
+                return array;
+            }
+        } else if (token < 192) {
+            let length = token - 160;
+            if (srcStringEnd >= position) {
+                return srcString.slice(position - srcStringStart, (position += length) - srcStringStart);
+            }
+            if (srcStringEnd == 0 && srcEnd < 140) {
+                let string = length < 16 ? shortStringInJS(length) : longStringInJS(length);
+                if (string != null) return string;
+            }
+            return readFixedString(length);
+        } else {
+            let value;
+            switch (token) {
+              case 192:
+                return null;
+
+              case 193:
+                if (bundledStrings) {
+                    value = read();
+                    if (value > 0) return bundledStrings[1].slice(bundledStrings.position1, bundledStrings.position1 += value); else return bundledStrings[0].slice(bundledStrings.position0, bundledStrings.position0 -= value);
+                }
+                return C1;
+
+              case 194:
+                return false;
+
+              case 195:
+                return true;
+
+              case 196:
+                value = src[position++];
+                if (value === undefined) throw new Error("Unexpected end of buffer");
+                return readBin(value);
+
+              case 197:
+                value = dataView.getUint16(position);
+                position += 2;
+                return readBin(value);
+
+              case 198:
+                value = dataView.getUint32(position);
+                position += 4;
+                return readBin(value);
+
+              case 199:
+                return readExt(src[position++]);
+
+              case 200:
+                value = dataView.getUint16(position);
+                position += 2;
+                return readExt(value);
+
+              case 201:
+                value = dataView.getUint32(position);
+                position += 4;
+                return readExt(value);
+
+              case 202:
+                value = dataView.getFloat32(position);
+                if (currentUnpackr.useFloat32 > 2) {
+                    let multiplier = mult10[(src[position] & 127) << 1 | src[position + 1] >> 7];
+                    position += 4;
+                    return (multiplier * value + (value > 0 ? .5 : -.5) >> 0) / multiplier;
+                }
+                position += 4;
+                return value;
+
+              case 203:
+                value = dataView.getFloat64(position);
+                position += 8;
+                return value;
+
+              case 204:
+                return src[position++];
+
+              case 205:
+                value = dataView.getUint16(position);
+                position += 2;
+                return value;
+
+              case 206:
+                value = dataView.getUint32(position);
+                position += 4;
+                return value;
+
+              case 207:
+                if (currentUnpackr.int64AsType === "number") {
+                    value = dataView.getUint32(position) * 4294967296;
+                    value += dataView.getUint32(position + 4);
+                } else if (currentUnpackr.int64AsType === "string") {
+                    value = dataView.getBigUint64(position).toString();
+                } else if (currentUnpackr.int64AsType === "auto") {
+                    value = dataView.getBigUint64(position);
+                    if (value <= BigInt(2) << BigInt(52)) value = Number(value);
+                } else value = dataView.getBigUint64(position);
+                position += 8;
+                return value;
+
+              case 208:
+                return dataView.getInt8(position++);
+
+              case 209:
+                value = dataView.getInt16(position);
+                position += 2;
+                return value;
+
+              case 210:
+                value = dataView.getInt32(position);
+                position += 4;
+                return value;
+
+              case 211:
+                if (currentUnpackr.int64AsType === "number") {
+                    value = dataView.getInt32(position) * 4294967296;
+                    value += dataView.getUint32(position + 4);
+                } else if (currentUnpackr.int64AsType === "string") {
+                    value = dataView.getBigInt64(position).toString();
+                } else if (currentUnpackr.int64AsType === "auto") {
+                    value = dataView.getBigInt64(position);
+                    if (value >= BigInt(-2) << BigInt(52) && value <= BigInt(2) << BigInt(52)) value = Number(value);
+                } else value = dataView.getBigInt64(position);
+                position += 8;
+                return value;
+
+              case 212:
+                value = src[position++];
+                if (value == 114) {
+                    return recordDefinition(src[position++] & 63);
+                } else {
+                    let extension = currentExtensions[value];
+                    if (extension) {
+                        if (extension.read) {
+                            position++;
+                            return extension.read(read());
+                        } else if (extension.noBuffer) {
+                            position++;
+                            return extension();
+                        } else return extension(src.subarray(position, ++position));
+                    } else throw new Error("Unknown extension " + value);
+                }
+
+              case 213:
+                value = src[position];
+                if (value == 114) {
+                    position++;
+                    return recordDefinition(src[position++] & 63, src[position++]);
+                } else return readExt(2);
+
+              case 214:
+                return readExt(4);
+
+              case 215:
+                return readExt(8);
+
+              case 216:
+                return readExt(16);
+
+              case 217:
+                value = src[position++];
+                if (srcStringEnd >= position) {
+                    return srcString.slice(position - srcStringStart, (position += value) - srcStringStart);
+                }
+                return readString8(value);
+
+              case 218:
+                value = dataView.getUint16(position);
+                position += 2;
+                if (srcStringEnd >= position) {
+                    return srcString.slice(position - srcStringStart, (position += value) - srcStringStart);
+                }
+                return readString16(value);
+
+              case 219:
+                value = dataView.getUint32(position);
+                position += 4;
+                if (srcStringEnd >= position) {
+                    return srcString.slice(position - srcStringStart, (position += value) - srcStringStart);
+                }
+                return readString32(value);
+
+              case 220:
+                value = dataView.getUint16(position);
+                position += 2;
+                return readArray(value);
+
+              case 221:
+                value = dataView.getUint32(position);
+                position += 4;
+                return readArray(value);
+
+              case 222:
+                value = dataView.getUint16(position);
+                position += 2;
+                return readMap(value);
+
+              case 223:
+                value = dataView.getUint32(position);
+                position += 4;
+                return readMap(value);
+
+              default:
+                if (token >= 224) return token - 256;
+                if (token === undefined) {
+                    let error = new Error("Unexpected end of MessagePack data");
+                    error.incomplete = true;
+                    throw error;
+                }
+                throw new Error("Unknown MessagePack token " + token);
+            }
+        }
+    }
+    const validName = /^[a-zA-Z_$][a-zA-Z\d_$]*$/;
+    function createStructureReader(structure, firstId) {
+        function readObject() {
+            if (readObject.count++ > inlineObjectReadThreshold) {
+                let readObject = structure.read = new Function("r", "return function(){return " + (currentUnpackr.freezeData ? "Object.freeze" : "") + "({" + structure.map((key => key === "__proto__" ? "__proto_:r()" : validName.test(key) ? key + ":r()" : "[" + JSON.stringify(key) + "]:r()")).join(",") + "})}")(read);
+                if (structure.highByte === 0) structure.read = createSecondByteReader(firstId, structure.read);
+                return readObject();
+            }
+            let object = {};
+            for (let i = 0, l = structure.length; i < l; i++) {
+                let key = structure[i];
+                if (key === "__proto__") key = "__proto_";
+                object[key] = read();
+            }
+            if (currentUnpackr.freezeData) return Object.freeze(object);
+            return object;
+        }
+        readObject.count = 0;
+        if (structure.highByte === 0) {
+            return createSecondByteReader(firstId, readObject);
+        }
+        return readObject;
+    }
+    const createSecondByteReader = (firstId, read0) => function() {
+        let highByte = src[position++];
+        if (highByte === 0) return read0();
+        let id = firstId < 32 ? -(firstId + (highByte << 5)) : firstId + (highByte << 5);
+        let structure = currentStructures[id] || loadStructures()[id];
+        if (!structure) {
+            throw new Error("Record id is not defined for " + id);
+        }
+        if (!structure.read) structure.read = createStructureReader(structure, firstId);
+        return structure.read();
+    };
+    function loadStructures() {
+        let loadedStructures = saveState((() => {
+            src = null;
+            return currentUnpackr.getStructures();
+        }));
+        return currentStructures = currentUnpackr._mergeStructures(loadedStructures, currentStructures);
+    }
+    var readFixedString = readStringJS;
+    var readString8 = readStringJS;
+    var readString16 = readStringJS;
+    var readString32 = readStringJS;
+    let isNativeAccelerationEnabled = false;
+    function setExtractor(extractStrings) {
+        isNativeAccelerationEnabled = true;
+        readFixedString = readString(1);
+        readString8 = readString(2);
+        readString16 = readString(3);
+        readString32 = readString(5);
+        function readString(headerLength) {
+            return function readString(length) {
+                let string = unpack_strings[stringPosition++];
+                if (string == null) {
+                    if (bundledStrings) return readStringJS(length);
+                    let byteOffset = src.byteOffset;
+                    let extraction = extractStrings(position - headerLength + byteOffset, srcEnd + byteOffset, src.buffer);
+                    if (typeof extraction == "string") {
+                        string = extraction;
+                        unpack_strings = EMPTY_ARRAY;
+                    } else {
+                        unpack_strings = extraction;
+                        stringPosition = 1;
+                        srcStringEnd = 1;
+                        string = unpack_strings[0];
+                        if (string === undefined) throw new Error("Unexpected end of buffer");
+                    }
+                }
+                let srcStringLength = string.length;
+                if (srcStringLength <= length) {
+                    position += length;
+                    return string;
+                }
+                srcString = string;
+                srcStringStart = position;
+                srcStringEnd = position + srcStringLength;
+                position += length;
+                return string.slice(0, length);
+            };
+        }
+    }
+    function readStringJS(length) {
+        let result;
+        if (length < 16) {
+            if (result = shortStringInJS(length)) return result;
+        }
+        if (length > 64 && decoder) return decoder.decode(src.subarray(position, position += length));
+        const end = position + length;
+        const units = [];
+        result = "";
+        while (position < end) {
+            const byte1 = src[position++];
+            if ((byte1 & 128) === 0) {
+                units.push(byte1);
+            } else if ((byte1 & 224) === 192) {
+                const byte2 = src[position++] & 63;
+                units.push((byte1 & 31) << 6 | byte2);
+            } else if ((byte1 & 240) === 224) {
+                const byte2 = src[position++] & 63;
+                const byte3 = src[position++] & 63;
+                units.push((byte1 & 31) << 12 | byte2 << 6 | byte3);
+            } else if ((byte1 & 248) === 240) {
+                const byte2 = src[position++] & 63;
+                const byte3 = src[position++] & 63;
+                const byte4 = src[position++] & 63;
+                let unit = (byte1 & 7) << 18 | byte2 << 12 | byte3 << 6 | byte4;
+                if (unit > 65535) {
+                    unit -= 65536;
+                    units.push(unit >>> 10 & 1023 | 55296);
+                    unit = 56320 | unit & 1023;
+                }
+                units.push(unit);
+            } else {
+                units.push(byte1);
+            }
+            if (units.length >= 4096) {
+                result += fromCharCode.apply(String, units);
+                units.length = 0;
+            }
+        }
+        if (units.length > 0) {
+            result += fromCharCode.apply(String, units);
+        }
+        return result;
+    }
+    function readString(source, start, length) {
+        let existingSrc = src;
+        src = source;
+        position = start;
+        try {
+            return readStringJS(length);
+        } finally {
+            src = existingSrc;
+        }
+    }
+    function readArray(length) {
+        let array = new Array(length);
+        for (let i = 0; i < length; i++) {
+            array[i] = read();
+        }
+        if (currentUnpackr.freezeData) return Object.freeze(array);
+        return array;
+    }
+    function readMap(length) {
+        if (currentUnpackr.mapsAsObjects) {
+            let object = {};
+            for (let i = 0; i < length; i++) {
+                let key = readKey();
+                if (key === "__proto__") key = "__proto_";
+                object[key] = read();
+            }
+            return object;
+        } else {
+            let map = new Map;
+            for (let i = 0; i < length; i++) {
+                map.set(read(), read());
+            }
+            return map;
+        }
+    }
+    var fromCharCode = String.fromCharCode;
+    function longStringInJS(length) {
+        let start = position;
+        let bytes = new Array(length);
+        for (let i = 0; i < length; i++) {
+            const byte = src[position++];
+            if ((byte & 128) > 0) {
+                position = start;
+                return;
+            }
+            bytes[i] = byte;
+        }
+        return fromCharCode.apply(String, bytes);
+    }
+    function shortStringInJS(length) {
+        if (length < 4) {
+            if (length < 2) {
+                if (length === 0) return ""; else {
+                    let a = src[position++];
+                    if ((a & 128) > 1) {
+                        position -= 1;
+                        return;
+                    }
+                    return fromCharCode(a);
+                }
+            } else {
+                let a = src[position++];
+                let b = src[position++];
+                if ((a & 128) > 0 || (b & 128) > 0) {
+                    position -= 2;
+                    return;
+                }
+                if (length < 3) return fromCharCode(a, b);
+                let c = src[position++];
+                if ((c & 128) > 0) {
+                    position -= 3;
+                    return;
+                }
+                return fromCharCode(a, b, c);
+            }
+        } else {
+            let a = src[position++];
+            let b = src[position++];
+            let c = src[position++];
+            let d = src[position++];
+            if ((a & 128) > 0 || (b & 128) > 0 || (c & 128) > 0 || (d & 128) > 0) {
+                position -= 4;
+                return;
+            }
+            if (length < 6) {
+                if (length === 4) return fromCharCode(a, b, c, d); else {
+                    let e = src[position++];
+                    if ((e & 128) > 0) {
+                        position -= 5;
+                        return;
+                    }
+                    return fromCharCode(a, b, c, d, e);
+                }
+            } else if (length < 8) {
+                let e = src[position++];
+                let f = src[position++];
+                if ((e & 128) > 0 || (f & 128) > 0) {
+                    position -= 6;
+                    return;
+                }
+                if (length < 7) return fromCharCode(a, b, c, d, e, f);
+                let g = src[position++];
+                if ((g & 128) > 0) {
+                    position -= 7;
+                    return;
+                }
+                return fromCharCode(a, b, c, d, e, f, g);
+            } else {
+                let e = src[position++];
+                let f = src[position++];
+                let g = src[position++];
+                let h = src[position++];
+                if ((e & 128) > 0 || (f & 128) > 0 || (g & 128) > 0 || (h & 128) > 0) {
+                    position -= 8;
+                    return;
+                }
+                if (length < 10) {
+                    if (length === 8) return fromCharCode(a, b, c, d, e, f, g, h); else {
+                        let i = src[position++];
+                        if ((i & 128) > 0) {
+                            position -= 9;
+                            return;
+                        }
+                        return fromCharCode(a, b, c, d, e, f, g, h, i);
+                    }
+                } else if (length < 12) {
+                    let i = src[position++];
+                    let j = src[position++];
+                    if ((i & 128) > 0 || (j & 128) > 0) {
+                        position -= 10;
+                        return;
+                    }
+                    if (length < 11) return fromCharCode(a, b, c, d, e, f, g, h, i, j);
+                    let k = src[position++];
+                    if ((k & 128) > 0) {
+                        position -= 11;
+                        return;
+                    }
+                    return fromCharCode(a, b, c, d, e, f, g, h, i, j, k);
+                } else {
+                    let i = src[position++];
+                    let j = src[position++];
+                    let k = src[position++];
+                    let l = src[position++];
+                    if ((i & 128) > 0 || (j & 128) > 0 || (k & 128) > 0 || (l & 128) > 0) {
+                        position -= 12;
+                        return;
+                    }
+                    if (length < 14) {
+                        if (length === 12) return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l); else {
+                            let m = src[position++];
+                            if ((m & 128) > 0) {
+                                position -= 13;
+                                return;
+                            }
+                            return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m);
+                        }
+                    } else {
+                        let m = src[position++];
+                        let n = src[position++];
+                        if ((m & 128) > 0 || (n & 128) > 0) {
+                            position -= 14;
+                            return;
+                        }
+                        if (length < 15) return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n);
+                        let o = src[position++];
+                        if ((o & 128) > 0) {
+                            position -= 15;
+                            return;
+                        }
+                        return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o);
+                    }
+                }
+            }
+        }
+    }
+    function readOnlyJSString() {
+        let token = src[position++];
+        let length;
+        if (token < 192) {
+            length = token - 160;
+        } else {
+            switch (token) {
+              case 217:
+                length = src[position++];
+                break;
+
+              case 218:
+                length = dataView.getUint16(position);
+                position += 2;
+                break;
+
+              case 219:
+                length = dataView.getUint32(position);
+                position += 4;
+                break;
+
+              default:
+                throw new Error("Expected string");
+            }
+        }
+        return readStringJS(length);
+    }
+    function readBin(length) {
+        return currentUnpackr.copyBuffers ? Uint8Array.prototype.slice.call(src, position, position += length) : src.subarray(position, position += length);
+    }
+    function readExt(length) {
+        let type = src[position++];
+        if (currentExtensions[type]) {
+            let end;
+            return currentExtensions[type](src.subarray(position, end = position += length), (readPosition => {
+                position = readPosition;
+                try {
+                    return read();
+                } finally {
+                    position = end;
+                }
+            }));
+        } else throw new Error("Unknown extension type " + type);
+    }
+    var keyCache = new Array(4096);
+    function readKey() {
+        let length = src[position++];
+        if (length >= 160 && length < 192) {
+            length = length - 160;
+            if (srcStringEnd >= position) return srcString.slice(position - srcStringStart, (position += length) - srcStringStart); else if (!(srcStringEnd == 0 && srcEnd < 180)) return readFixedString(length);
+        } else {
+            position--;
+            return asSafeString(read());
+        }
+        let key = (length << 5 ^ (length > 1 ? dataView.getUint16(position) : length > 0 ? src[position] : 0)) & 4095;
+        let entry = keyCache[key];
+        let checkPosition = position;
+        let end = position + length - 3;
+        let chunk;
+        let i = 0;
+        if (entry && entry.bytes == length) {
+            while (checkPosition < end) {
+                chunk = dataView.getUint32(checkPosition);
+                if (chunk != entry[i++]) {
+                    checkPosition = 1879048192;
+                    break;
+                }
+                checkPosition += 4;
+            }
+            end += 3;
+            while (checkPosition < end) {
+                chunk = src[checkPosition++];
+                if (chunk != entry[i++]) {
+                    checkPosition = 1879048192;
+                    break;
+                }
+            }
+            if (checkPosition === end) {
+                position = checkPosition;
+                return entry.string;
+            }
+            end -= 3;
+            checkPosition = position;
+        }
+        entry = [];
+        keyCache[key] = entry;
+        entry.bytes = length;
+        while (checkPosition < end) {
+            chunk = dataView.getUint32(checkPosition);
+            entry.push(chunk);
+            checkPosition += 4;
+        }
+        end += 3;
+        while (checkPosition < end) {
+            chunk = src[checkPosition++];
+            entry.push(chunk);
+        }
+        let string = length < 16 ? shortStringInJS(length) : longStringInJS(length);
+        if (string != null) return entry.string = string;
+        return entry.string = readFixedString(length);
+    }
+    function asSafeString(property) {
+        if (typeof property === "string") return property;
+        if (typeof property === "number" || typeof property === "boolean" || typeof property === "bigint") return property.toString();
+        if (property == null) return property + "";
+        throw new Error("Invalid property type for record", typeof property);
+    }
+    const recordDefinition = (id, highByte) => {
+        let structure = read().map(asSafeString);
+        let firstByte = id;
+        if (highByte !== undefined) {
+            id = id < 32 ? -((highByte << 5) + id) : (highByte << 5) + id;
+            structure.highByte = highByte;
+        }
+        let existingStructure = currentStructures[id];
+        if (existingStructure && (existingStructure.isShared || sequentialMode)) {
+            (currentStructures.restoreStructures || (currentStructures.restoreStructures = []))[id] = existingStructure;
+        }
+        currentStructures[id] = structure;
+        structure.read = createStructureReader(structure, firstByte);
+        return structure.read();
+    };
+    currentExtensions[0] = () => {};
+    currentExtensions[0].noBuffer = true;
+    currentExtensions[66] = data => {
+        let length = data.length;
+        let value = BigInt(data[0] & 128 ? data[0] - 256 : data[0]);
+        for (let i = 1; i < length; i++) {
+            value <<= BigInt(8);
+            value += BigInt(data[i]);
+        }
+        return value;
+    };
+    let errors = {
+        Error,
+        TypeError,
+        ReferenceError
+    };
+    currentExtensions[101] = () => {
+        let data = read();
+        return (errors[data[0]] || Error)(data[1], {
+            cause: data[2]
+        });
+    };
+    currentExtensions[105] = data => {
+        if (currentUnpackr.structuredClone === false) throw new Error("Structured clone extension is disabled");
+        let id = dataView.getUint32(position - 4);
+        if (!referenceMap) referenceMap = new Map;
+        let token = src[position];
+        let target;
+        if (token >= 144 && token < 160 || token == 220 || token == 221) target = []; else target = {};
+        let refEntry = {
+            target
+        };
+        referenceMap.set(id, refEntry);
+        let targetProperties = read();
+        if (refEntry.used) return Object.assign(target, targetProperties);
+        refEntry.target = targetProperties;
+        return targetProperties;
+    };
+    currentExtensions[112] = data => {
+        if (currentUnpackr.structuredClone === false) throw new Error("Structured clone extension is disabled");
+        let id = dataView.getUint32(position - 4);
+        let refEntry = referenceMap.get(id);
+        refEntry.used = true;
+        return refEntry.target;
+    };
+    currentExtensions[115] = () => new Set(read());
+    const typedArrays = [ "Int8", "Uint8", "Uint8Clamped", "Int16", "Uint16", "Int32", "Uint32", "Float32", "Float64", "BigInt64", "BigUint64" ].map((type => type + "Array"));
+    let glbl = typeof globalThis === "object" ? globalThis : window;
+    currentExtensions[116] = data => {
+        let typeCode = data[0];
+        let typedArrayName = typedArrays[typeCode];
+        if (!typedArrayName) {
+            if (typeCode === 16) {
+                let ab = new ArrayBuffer(data.length - 1);
+                let u8 = new Uint8Array(ab);
+                u8.set(data.subarray(1));
+                return ab;
+            }
+            throw new Error("Could not find typed array for code " + typeCode);
+        }
+        return new glbl[typedArrayName](Uint8Array.prototype.slice.call(data, 1).buffer);
+    };
+    currentExtensions[120] = () => {
+        let data = read();
+        return new RegExp(data[0], data[1]);
+    };
+    const TEMP_BUNDLE = [];
+    currentExtensions[98] = data => {
+        let dataSize = (data[0] << 24) + (data[1] << 16) + (data[2] << 8) + data[3];
+        let dataPosition = position;
+        position += dataSize - data.length;
+        bundledStrings = TEMP_BUNDLE;
+        bundledStrings = [ readOnlyJSString(), readOnlyJSString() ];
+        bundledStrings.position0 = 0;
+        bundledStrings.position1 = 0;
+        bundledStrings.postBundlePosition = position;
+        position = dataPosition;
+        return read();
+    };
+    currentExtensions[255] = data => {
+        if (data.length == 4) return new Date((data[0] * 16777216 + (data[1] << 16) + (data[2] << 8) + data[3]) * 1e3); else if (data.length == 8) return new Date(((data[0] << 22) + (data[1] << 14) + (data[2] << 6) + (data[3] >> 2)) / 1e6 + ((data[3] & 3) * 4294967296 + data[4] * 16777216 + (data[5] << 16) + (data[6] << 8) + data[7]) * 1e3); else if (data.length == 12) return new Date(((data[0] << 24) + (data[1] << 16) + (data[2] << 8) + data[3]) / 1e6 + ((data[4] & 128 ? -281474976710656 : 0) + data[6] * 1099511627776 + data[7] * 4294967296 + data[8] * 16777216 + (data[9] << 16) + (data[10] << 8) + data[11]) * 1e3); else return new Date("invalid");
+    };
+    function saveState(callback) {
+        if (onSaveState) onSaveState();
+        let savedSrcEnd = srcEnd;
+        let savedPosition = position;
+        let savedStringPosition = stringPosition;
+        let savedSrcStringStart = srcStringStart;
+        let savedSrcStringEnd = srcStringEnd;
+        let savedSrcString = srcString;
+        let savedStrings = unpack_strings;
+        let savedReferenceMap = referenceMap;
+        let savedBundledStrings = bundledStrings;
+        let savedSrc = new Uint8Array(src.slice(0, srcEnd));
+        let savedStructures = currentStructures;
+        let savedStructuresContents = currentStructures.slice(0, currentStructures.length);
+        let savedPackr = currentUnpackr;
+        let savedSequentialMode = sequentialMode;
+        let value = callback();
+        srcEnd = savedSrcEnd;
+        position = savedPosition;
+        stringPosition = savedStringPosition;
+        srcStringStart = savedSrcStringStart;
+        srcStringEnd = savedSrcStringEnd;
+        srcString = savedSrcString;
+        unpack_strings = savedStrings;
+        referenceMap = savedReferenceMap;
+        bundledStrings = savedBundledStrings;
+        src = savedSrc;
+        sequentialMode = savedSequentialMode;
+        currentStructures = savedStructures;
+        currentStructures.splice(0, currentStructures.length, ...savedStructuresContents);
+        currentUnpackr = savedPackr;
+        dataView = new DataView(src.buffer, src.byteOffset, src.byteLength);
+        return value;
+    }
+    function clearSource() {
+        src = null;
+        referenceMap = null;
+        currentStructures = null;
+    }
+    function addExtension(extension) {
+        if (extension.unpack) currentExtensions[extension.type] = extension.unpack; else currentExtensions[extension.type] = extension;
+    }
+    const mult10 = new Array(147);
+    for (let i = 0; i < 256; i++) {
+        mult10[i] = +("1e" + Math.floor(45.15 - i * .30103));
+    }
+    const Decoder = null && Unpackr;
+    var defaultUnpackr = new Unpackr({
+        useRecords: false
+    });
+    const unpack = defaultUnpackr.unpack;
+    const unpackMultiple = defaultUnpackr.unpackMultiple;
+    const decode = defaultUnpackr.unpack;
+    const FLOAT32_OPTIONS = {
+        NEVER: 0,
+        ALWAYS: 1,
+        DECIMAL_ROUND: 3,
+        DECIMAL_FIT: 4
+    };
+    let f32Array = new Float32Array(1);
+    let u8Array = new Uint8Array(f32Array.buffer, 0, 4);
+    function roundFloat32(float32Number) {
+        f32Array[0] = float32Number;
+        let multiplier = mult10[(u8Array[3] & 127) << 1 | u8Array[2] >> 7];
+        return (multiplier * float32Number + (float32Number > 0 ? .5 : -.5) >> 0) / multiplier;
+    }
+    function setReadStruct(updatedReadStruct, loadedStructs, saveState) {
+        readStruct = updatedReadStruct;
+        onLoadedStructures = loadedStructs;
+        onSaveState = saveState;
+    }
+    var pack_Buffer = __webpack_require__(764)["lW"];
+    let textEncoder;
+    try {
+        textEncoder = new TextEncoder;
+    } catch (error) {}
+    let extensions, extensionClasses;
+    const hasNodeBuffer = typeof pack_Buffer !== "undefined";
+    const ByteArrayAllocate = hasNodeBuffer ? function(length) {
+        return pack_Buffer.allocUnsafeSlow(length);
+    } : Uint8Array;
+    const ByteArray = hasNodeBuffer ? pack_Buffer : Uint8Array;
+    const MAX_BUFFER_SIZE = hasNodeBuffer ? 4294967296 : 2144337920;
+    let target, keysTarget;
+    let targetView;
+    let pack_position = 0;
+    let safeEnd;
+    let pack_bundledStrings = null;
+    let writeStructSlots;
+    const MAX_BUNDLE_SIZE = 21760;
+    const hasNonLatin = /[\u0080-\uFFFF]/;
+    const RECORD_SYMBOL = Symbol("record-id");
+    class Packr extends Unpackr {
+        constructor(options) {
+            super(options);
+            this.offset = 0;
+            let typeBuffer;
+            let start;
+            let hasSharedUpdate;
+            let structures;
+            let referenceMap;
+            let encodeUtf8 = ByteArray.prototype.utf8Write ? function(string, position) {
+                return target.utf8Write(string, position, target.byteLength - position);
+            } : textEncoder && textEncoder.encodeInto ? function(string, position) {
+                return textEncoder.encodeInto(string, target.subarray(position)).written;
+            } : false;
+            let packr = this;
+            if (!options) options = {};
+            let isSequential = options && options.sequential;
+            let hasSharedStructures = options.structures || options.saveStructures;
+            let maxSharedStructures = options.maxSharedStructures;
+            if (maxSharedStructures == null) maxSharedStructures = hasSharedStructures ? 32 : 0;
+            if (maxSharedStructures > 8160) throw new Error("Maximum maxSharedStructure is 8160");
+            if (options.structuredClone && options.moreTypes == undefined) {
+                this.moreTypes = true;
+            }
+            let maxOwnStructures = options.maxOwnStructures;
+            if (maxOwnStructures == null) maxOwnStructures = hasSharedStructures ? 32 : 64;
+            if (!this.structures && options.useRecords != false) this.structures = [];
+            let useTwoByteRecords = maxSharedStructures > 32 || maxOwnStructures + maxSharedStructures > 64;
+            let sharedLimitId = maxSharedStructures + 64;
+            let maxStructureId = maxSharedStructures + maxOwnStructures + 64;
+            if (maxStructureId > 8256) {
+                throw new Error("Maximum maxSharedStructure + maxOwnStructure is 8192");
+            }
+            let recordIdsToRemove = [];
+            let transitionsCount = 0;
+            let serializationsSinceTransitionRebuild = 0;
+            this.pack = this.encode = function(value, encodeOptions) {
+                if (!target) {
+                    target = new ByteArrayAllocate(8192);
+                    targetView = target.dataView || (target.dataView = new DataView(target.buffer, 0, 8192));
+                    pack_position = 0;
+                }
+                safeEnd = target.length - 10;
+                if (safeEnd - pack_position < 2048) {
+                    target = new ByteArrayAllocate(target.length);
+                    targetView = target.dataView || (target.dataView = new DataView(target.buffer, 0, target.length));
+                    safeEnd = target.length - 10;
+                    pack_position = 0;
+                } else pack_position = pack_position + 7 & 2147483640;
+                start = pack_position;
+                if (encodeOptions & RESERVE_START_SPACE) pack_position += encodeOptions & 255;
+                referenceMap = packr.structuredClone ? new Map : null;
+                if (packr.bundleStrings && typeof value !== "string") {
+                    pack_bundledStrings = [];
+                    pack_bundledStrings.size = Infinity;
+                } else pack_bundledStrings = null;
+                structures = packr.structures;
+                if (structures) {
+                    if (structures.uninitialized) structures = packr._mergeStructures(packr.getStructures());
+                    let sharedLength = structures.sharedLength || 0;
+                    if (sharedLength > maxSharedStructures) {
+                        throw new Error("Shared structures is larger than maximum shared structures, try increasing maxSharedStructures to " + structures.sharedLength);
+                    }
+                    if (!structures.transitions) {
+                        structures.transitions = Object.create(null);
+                        for (let i = 0; i < sharedLength; i++) {
+                            let keys = structures[i];
+                            if (!keys) continue;
+                            let nextTransition, transition = structures.transitions;
+                            for (let j = 0, l = keys.length; j < l; j++) {
+                                let key = keys[j];
+                                nextTransition = transition[key];
+                                if (!nextTransition) {
+                                    nextTransition = transition[key] = Object.create(null);
+                                }
+                                transition = nextTransition;
+                            }
+                            transition[RECORD_SYMBOL] = i + 64;
+                        }
+                        this.lastNamedStructuresLength = sharedLength;
+                    }
+                    if (!isSequential) {
+                        structures.nextId = sharedLength + 64;
+                    }
+                }
+                if (hasSharedUpdate) hasSharedUpdate = false;
+                let encodingError;
+                try {
+                    if (packr.randomAccessStructure && value && value.constructor && value.constructor === Object) writeStruct(value); else pack(value);
+                    let lastBundle = pack_bundledStrings;
+                    if (pack_bundledStrings) writeBundles(start, pack, 0);
+                    if (referenceMap && referenceMap.idsToInsert) {
+                        let idsToInsert = referenceMap.idsToInsert.sort(((a, b) => a.offset > b.offset ? 1 : -1));
+                        let i = idsToInsert.length;
+                        let incrementPosition = -1;
+                        while (lastBundle && i > 0) {
+                            let insertionPoint = idsToInsert[--i].offset + start;
+                            if (insertionPoint < lastBundle.stringsPosition + start && incrementPosition === -1) incrementPosition = 0;
+                            if (insertionPoint > lastBundle.position + start) {
+                                if (incrementPosition >= 0) incrementPosition += 6;
+                            } else {
+                                if (incrementPosition >= 0) {
+                                    targetView.setUint32(lastBundle.position + start, targetView.getUint32(lastBundle.position + start) + incrementPosition);
+                                    incrementPosition = -1;
+                                }
+                                lastBundle = lastBundle.previous;
+                                i++;
+                            }
+                        }
+                        if (incrementPosition >= 0 && lastBundle) {
+                            targetView.setUint32(lastBundle.position + start, targetView.getUint32(lastBundle.position + start) + incrementPosition);
+                        }
+                        pack_position += idsToInsert.length * 6;
+                        if (pack_position > safeEnd) makeRoom(pack_position);
+                        packr.offset = pack_position;
+                        let serialized = insertIds(target.subarray(start, pack_position), idsToInsert);
+                        referenceMap = null;
+                        return serialized;
+                    }
+                    packr.offset = pack_position;
+                    if (encodeOptions & REUSE_BUFFER_MODE) {
+                        target.start = start;
+                        target.end = pack_position;
+                        return target;
+                    }
+                    return target.subarray(start, pack_position);
+                } catch (error) {
+                    encodingError = error;
+                    throw error;
+                } finally {
+                    if (structures) {
+                        resetStructures();
+                        if (hasSharedUpdate && packr.saveStructures) {
+                            let sharedLength = structures.sharedLength || 0;
+                            let returnBuffer = target.subarray(start, pack_position);
+                            let newSharedData = prepareStructures(structures, packr);
+                            if (!encodingError) {
+                                if (packr.saveStructures(newSharedData, newSharedData.isCompatible) === false) {
+                                    return packr.pack(value, encodeOptions);
+                                }
+                                packr.lastNamedStructuresLength = sharedLength;
+                                if (target.length > 1073741824) target = null;
+                                return returnBuffer;
+                            }
+                        }
+                    }
+                    if (target.length > 1073741824) target = null;
+                    if (encodeOptions & RESET_BUFFER_MODE) pack_position = start;
+                }
+            };
+            const resetStructures = () => {
+                if (serializationsSinceTransitionRebuild < 10) serializationsSinceTransitionRebuild++;
+                let sharedLength = structures.sharedLength || 0;
+                if (structures.length > sharedLength && !isSequential) structures.length = sharedLength;
+                if (transitionsCount > 1e4) {
+                    structures.transitions = null;
+                    serializationsSinceTransitionRebuild = 0;
+                    transitionsCount = 0;
+                    if (recordIdsToRemove.length > 0) recordIdsToRemove = [];
+                } else if (recordIdsToRemove.length > 0 && !isSequential) {
+                    for (let i = 0, l = recordIdsToRemove.length; i < l; i++) {
+                        recordIdsToRemove[i][RECORD_SYMBOL] = 0;
+                    }
+                    recordIdsToRemove = [];
+                }
+            };
+            const packArray = value => {
+                var length = value.length;
+                if (length < 16) {
+                    target[pack_position++] = 144 | length;
+                } else if (length < 65536) {
+                    target[pack_position++] = 220;
+                    target[pack_position++] = length >> 8;
+                    target[pack_position++] = length & 255;
+                } else {
+                    target[pack_position++] = 221;
+                    targetView.setUint32(pack_position, length);
+                    pack_position += 4;
+                }
+                for (let i = 0; i < length; i++) {
+                    pack(value[i]);
+                }
+            };
+            const pack = value => {
+                if (pack_position > safeEnd) target = makeRoom(pack_position);
+                var type = typeof value;
+                var length;
+                if (type === "string") {
+                    let strLength = value.length;
+                    if (pack_bundledStrings && strLength >= 4 && strLength < 4096) {
+                        if ((pack_bundledStrings.size += strLength) > MAX_BUNDLE_SIZE) {
+                            let extStart;
+                            let maxBytes = (pack_bundledStrings[0] ? pack_bundledStrings[0].length * 3 + pack_bundledStrings[1].length : 0) + 10;
+                            if (pack_position + maxBytes > safeEnd) target = makeRoom(pack_position + maxBytes);
+                            let lastBundle;
+                            if (pack_bundledStrings.position) {
+                                lastBundle = pack_bundledStrings;
+                                target[pack_position] = 200;
+                                pack_position += 3;
+                                target[pack_position++] = 98;
+                                extStart = pack_position - start;
+                                pack_position += 4;
+                                writeBundles(start, pack, 0);
+                                targetView.setUint16(extStart + start - 3, pack_position - start - extStart);
+                            } else {
+                                target[pack_position++] = 214;
+                                target[pack_position++] = 98;
+                                extStart = pack_position - start;
+                                pack_position += 4;
+                            }
+                            pack_bundledStrings = [ "", "" ];
+                            pack_bundledStrings.previous = lastBundle;
+                            pack_bundledStrings.size = 0;
+                            pack_bundledStrings.position = extStart;
+                        }
+                        let twoByte = hasNonLatin.test(value);
+                        pack_bundledStrings[twoByte ? 0 : 1] += value;
+                        target[pack_position++] = 193;
+                        pack(twoByte ? -strLength : strLength);
+                        return;
+                    }
+                    let headerSize;
+                    if (strLength < 32) {
+                        headerSize = 1;
+                    } else if (strLength < 256) {
+                        headerSize = 2;
+                    } else if (strLength < 65536) {
+                        headerSize = 3;
+                    } else {
+                        headerSize = 5;
+                    }
+                    let maxBytes = strLength * 3;
+                    if (pack_position + maxBytes > safeEnd) target = makeRoom(pack_position + maxBytes);
+                    if (strLength < 64 || !encodeUtf8) {
+                        let i, c1, c2, strPosition = pack_position + headerSize;
+                        for (i = 0; i < strLength; i++) {
+                            c1 = value.charCodeAt(i);
+                            if (c1 < 128) {
+                                target[strPosition++] = c1;
+                            } else if (c1 < 2048) {
+                                target[strPosition++] = c1 >> 6 | 192;
+                                target[strPosition++] = c1 & 63 | 128;
+                            } else if ((c1 & 64512) === 55296 && ((c2 = value.charCodeAt(i + 1)) & 64512) === 56320) {
+                                c1 = 65536 + ((c1 & 1023) << 10) + (c2 & 1023);
+                                i++;
+                                target[strPosition++] = c1 >> 18 | 240;
+                                target[strPosition++] = c1 >> 12 & 63 | 128;
+                                target[strPosition++] = c1 >> 6 & 63 | 128;
+                                target[strPosition++] = c1 & 63 | 128;
+                            } else {
+                                target[strPosition++] = c1 >> 12 | 224;
+                                target[strPosition++] = c1 >> 6 & 63 | 128;
+                                target[strPosition++] = c1 & 63 | 128;
+                            }
+                        }
+                        length = strPosition - pack_position - headerSize;
+                    } else {
+                        length = encodeUtf8(value, pack_position + headerSize);
+                    }
+                    if (length < 32) {
+                        target[pack_position++] = 160 | length;
+                    } else if (length < 256) {
+                        if (headerSize < 2) {
+                            target.copyWithin(pack_position + 2, pack_position + 1, pack_position + 1 + length);
+                        }
+                        target[pack_position++] = 217;
+                        target[pack_position++] = length;
+                    } else if (length < 65536) {
+                        if (headerSize < 3) {
+                            target.copyWithin(pack_position + 3, pack_position + 2, pack_position + 2 + length);
+                        }
+                        target[pack_position++] = 218;
+                        target[pack_position++] = length >> 8;
+                        target[pack_position++] = length & 255;
+                    } else {
+                        if (headerSize < 5) {
+                            target.copyWithin(pack_position + 5, pack_position + 3, pack_position + 3 + length);
+                        }
+                        target[pack_position++] = 219;
+                        targetView.setUint32(pack_position, length);
+                        pack_position += 4;
+                    }
+                    pack_position += length;
+                } else if (type === "number") {
+                    if (value >>> 0 === value) {
+                        if (value < 32 || value < 128 && this.useRecords === false || value < 64 && !this.randomAccessStructure) {
+                            target[pack_position++] = value;
+                        } else if (value < 256) {
+                            target[pack_position++] = 204;
+                            target[pack_position++] = value;
+                        } else if (value < 65536) {
+                            target[pack_position++] = 205;
+                            target[pack_position++] = value >> 8;
+                            target[pack_position++] = value & 255;
+                        } else {
+                            target[pack_position++] = 206;
+                            targetView.setUint32(pack_position, value);
+                            pack_position += 4;
+                        }
+                    } else if (value >> 0 === value) {
+                        if (value >= -32) {
+                            target[pack_position++] = 256 + value;
+                        } else if (value >= -128) {
+                            target[pack_position++] = 208;
+                            target[pack_position++] = value + 256;
+                        } else if (value >= -32768) {
+                            target[pack_position++] = 209;
+                            targetView.setInt16(pack_position, value);
+                            pack_position += 2;
+                        } else {
+                            target[pack_position++] = 210;
+                            targetView.setInt32(pack_position, value);
+                            pack_position += 4;
+                        }
+                    } else {
+                        let useFloat32;
+                        if ((useFloat32 = this.useFloat32) > 0 && value < 4294967296 && value >= -2147483648) {
+                            target[pack_position++] = 202;
+                            targetView.setFloat32(pack_position, value);
+                            let xShifted;
+                            if (useFloat32 < 4 || (xShifted = value * mult10[(target[pack_position] & 127) << 1 | target[pack_position + 1] >> 7]) >> 0 === xShifted) {
+                                pack_position += 4;
+                                return;
+                            } else pack_position--;
+                        }
+                        target[pack_position++] = 203;
+                        targetView.setFloat64(pack_position, value);
+                        pack_position += 8;
+                    }
+                } else if (type === "object" || type === "function") {
+                    if (!value) target[pack_position++] = 192; else {
+                        if (referenceMap) {
+                            let referee = referenceMap.get(value);
+                            if (referee) {
+                                if (!referee.id) {
+                                    let idsToInsert = referenceMap.idsToInsert || (referenceMap.idsToInsert = []);
+                                    referee.id = idsToInsert.push(referee);
+                                }
+                                target[pack_position++] = 214;
+                                target[pack_position++] = 112;
+                                targetView.setUint32(pack_position, referee.id);
+                                pack_position += 4;
+                                return;
+                            } else referenceMap.set(value, {
+                                offset: pack_position - start
+                            });
+                        }
+                        let constructor = value.constructor;
+                        if (constructor === Object) {
+                            writeObject(value);
+                        } else if (constructor === Array) {
+                            packArray(value);
+                        } else if (constructor === Map) {
+                            if (this.mapAsEmptyObject) target[pack_position++] = 128; else {
+                                length = value.size;
+                                if (length < 16) {
+                                    target[pack_position++] = 128 | length;
+                                } else if (length < 65536) {
+                                    target[pack_position++] = 222;
+                                    target[pack_position++] = length >> 8;
+                                    target[pack_position++] = length & 255;
+                                } else {
+                                    target[pack_position++] = 223;
+                                    targetView.setUint32(pack_position, length);
+                                    pack_position += 4;
+                                }
+                                for (let [key, entryValue] of value) {
+                                    pack(key);
+                                    pack(entryValue);
+                                }
+                            }
+                        } else {
+                            for (let i = 0, l = extensions.length; i < l; i++) {
+                                let extensionClass = extensionClasses[i];
+                                if (value instanceof extensionClass) {
+                                    let extension = extensions[i];
+                                    if (extension.write) {
+                                        if (extension.type) {
+                                            target[pack_position++] = 212;
+                                            target[pack_position++] = extension.type;
+                                            target[pack_position++] = 0;
+                                        }
+                                        let writeResult = extension.write.call(this, value);
+                                        if (writeResult === value) {
+                                            if (Array.isArray(value)) {
+                                                packArray(value);
+                                            } else {
+                                                writeObject(value);
+                                            }
+                                        } else {
+                                            pack(writeResult);
+                                        }
+                                        return;
+                                    }
+                                    let currentTarget = target;
+                                    let currentTargetView = targetView;
+                                    let currentPosition = pack_position;
+                                    target = null;
+                                    let result;
+                                    try {
+                                        result = extension.pack.call(this, value, (size => {
+                                            target = currentTarget;
+                                            currentTarget = null;
+                                            pack_position += size;
+                                            if (pack_position > safeEnd) makeRoom(pack_position);
+                                            return {
+                                                target,
+                                                targetView,
+                                                position: pack_position - size
+                                            };
+                                        }), pack);
+                                    } finally {
+                                        if (currentTarget) {
+                                            target = currentTarget;
+                                            targetView = currentTargetView;
+                                            pack_position = currentPosition;
+                                            safeEnd = target.length - 10;
+                                        }
+                                    }
+                                    if (result) {
+                                        if (result.length + pack_position > safeEnd) makeRoom(result.length + pack_position);
+                                        pack_position = writeExtensionData(result, target, pack_position, extension.type);
+                                    }
+                                    return;
+                                }
+                            }
+                            if (Array.isArray(value)) {
+                                packArray(value);
+                            } else {
+                                if (value.toJSON) {
+                                    const json = value.toJSON();
+                                    if (json !== value) return pack(json);
+                                }
+                                if (type === "function") return pack(this.writeFunction && this.writeFunction(value));
+                                writeObject(value);
+                            }
+                        }
+                    }
+                } else if (type === "boolean") {
+                    target[pack_position++] = value ? 195 : 194;
+                } else if (type === "bigint") {
+                    if (value < BigInt(1) << BigInt(63) && value >= -(BigInt(1) << BigInt(63))) {
+                        target[pack_position++] = 211;
+                        targetView.setBigInt64(pack_position, value);
+                    } else if (value < BigInt(1) << BigInt(64) && value > 0) {
+                        target[pack_position++] = 207;
+                        targetView.setBigUint64(pack_position, value);
+                    } else {
+                        if (this.largeBigIntToFloat) {
+                            target[pack_position++] = 203;
+                            targetView.setFloat64(pack_position, Number(value));
+                        } else if (this.largeBigIntToString) {
+                            return pack(value.toString());
+                        } else if (this.useBigIntExtension && value < BigInt(2) ** BigInt(1023) && value > -(BigInt(2) ** BigInt(1023))) {
+                            target[pack_position++] = 199;
+                            pack_position++;
+                            target[pack_position++] = 66;
+                            let bytes = [];
+                            let alignedSign;
+                            do {
+                                let byte = value & BigInt(255);
+                                alignedSign = (byte & BigInt(128)) === (value < BigInt(0) ? BigInt(128) : BigInt(0));
+                                bytes.push(byte);
+                                value >>= BigInt(8);
+                            } while (!((value === BigInt(0) || value === BigInt(-1)) && alignedSign));
+                            target[pack_position - 2] = bytes.length;
+                            for (let i = bytes.length; i > 0; ) {
+                                target[pack_position++] = Number(bytes[--i]);
+                            }
+                            return;
+                        } else {
+                            throw new RangeError(value + " was too large to fit in MessagePack 64-bit integer format, use" + " useBigIntExtension, or set largeBigIntToFloat to convert to float-64, or set" + " largeBigIntToString to convert to string");
+                        }
+                    }
+                    pack_position += 8;
+                } else if (type === "undefined") {
+                    if (this.encodeUndefinedAsNil) target[pack_position++] = 192; else {
+                        target[pack_position++] = 212;
+                        target[pack_position++] = 0;
+                        target[pack_position++] = 0;
+                    }
+                } else {
+                    throw new Error("Unknown type: " + type);
+                }
+            };
+            const writePlainObject = this.variableMapSize || this.coercibleKeyAsNumber || this.skipValues ? object => {
+                let keys;
+                if (this.skipValues) {
+                    keys = [];
+                    for (let key in object) {
+                        if ((typeof object.hasOwnProperty !== "function" || object.hasOwnProperty(key)) && !this.skipValues.includes(object[key])) keys.push(key);
+                    }
+                } else {
+                    keys = Object.keys(object);
+                }
+                let length = keys.length;
+                if (length < 16) {
+                    target[pack_position++] = 128 | length;
+                } else if (length < 65536) {
+                    target[pack_position++] = 222;
+                    target[pack_position++] = length >> 8;
+                    target[pack_position++] = length & 255;
+                } else {
+                    target[pack_position++] = 223;
+                    targetView.setUint32(pack_position, length);
+                    pack_position += 4;
+                }
+                let key;
+                if (this.coercibleKeyAsNumber) {
+                    for (let i = 0; i < length; i++) {
+                        key = keys[i];
+                        let num = Number(key);
+                        pack(isNaN(num) ? key : num);
+                        pack(object[key]);
+                    }
+                } else {
+                    for (let i = 0; i < length; i++) {
+                        pack(key = keys[i]);
+                        pack(object[key]);
+                    }
+                }
+            } : object => {
+                target[pack_position++] = 222;
+                let objectOffset = pack_position - start;
+                pack_position += 2;
+                let size = 0;
+                for (let key in object) {
+                    if (typeof object.hasOwnProperty !== "function" || object.hasOwnProperty(key)) {
+                        pack(key);
+                        pack(object[key]);
+                        size++;
+                    }
+                }
+                if (size > 65535) {
+                    throw new Error("Object is too large to serialize with fast 16-bit map size," + ' use the "variableMapSize" option to serialize this object');
+                }
+                target[objectOffset++ + start] = size >> 8;
+                target[objectOffset + start] = size & 255;
+            };
+            const writeRecord = this.useRecords === false ? writePlainObject : options.progressiveRecords && !useTwoByteRecords ? object => {
+                let nextTransition, transition = structures.transitions || (structures.transitions = Object.create(null));
+                let objectOffset = pack_position++ - start;
+                let wroteKeys;
+                for (let key in object) {
+                    if (typeof object.hasOwnProperty !== "function" || object.hasOwnProperty(key)) {
+                        nextTransition = transition[key];
+                        if (nextTransition) transition = nextTransition; else {
+                            let keys = Object.keys(object);
+                            let lastTransition = transition;
+                            transition = structures.transitions;
+                            let newTransitions = 0;
+                            for (let i = 0, l = keys.length; i < l; i++) {
+                                let key = keys[i];
+                                nextTransition = transition[key];
+                                if (!nextTransition) {
+                                    nextTransition = transition[key] = Object.create(null);
+                                    newTransitions++;
+                                }
+                                transition = nextTransition;
+                            }
+                            if (objectOffset + start + 1 == pack_position) {
+                                pack_position--;
+                                newRecord(transition, keys, newTransitions);
+                            } else insertNewRecord(transition, keys, objectOffset, newTransitions);
+                            wroteKeys = true;
+                            transition = lastTransition[key];
+                        }
+                        pack(object[key]);
+                    }
+                }
+                if (!wroteKeys) {
+                    let recordId = transition[RECORD_SYMBOL];
+                    if (recordId) target[objectOffset + start] = recordId; else insertNewRecord(transition, Object.keys(object), objectOffset, 0);
+                }
+            } : object => {
+                let nextTransition, transition = structures.transitions || (structures.transitions = Object.create(null));
+                let newTransitions = 0;
+                for (let key in object) if (typeof object.hasOwnProperty !== "function" || object.hasOwnProperty(key)) {
+                    nextTransition = transition[key];
+                    if (!nextTransition) {
+                        nextTransition = transition[key] = Object.create(null);
+                        newTransitions++;
+                    }
+                    transition = nextTransition;
+                }
+                let recordId = transition[RECORD_SYMBOL];
+                if (recordId) {
+                    if (recordId >= 96 && useTwoByteRecords) {
+                        target[pack_position++] = ((recordId -= 96) & 31) + 96;
+                        target[pack_position++] = recordId >> 5;
+                    } else target[pack_position++] = recordId;
+                } else {
+                    newRecord(transition, transition.__keys__ || Object.keys(object), newTransitions);
+                }
+                for (let key in object) if (typeof object.hasOwnProperty !== "function" || object.hasOwnProperty(key)) {
+                    pack(object[key]);
+                }
+            };
+            const checkUseRecords = typeof this.useRecords == "function" && this.useRecords;
+            const writeObject = checkUseRecords ? object => {
+                checkUseRecords(object) ? writeRecord(object) : writePlainObject(object);
+            } : writeRecord;
+            const makeRoom = end => {
+                let newSize;
+                if (end > 16777216) {
+                    if (end - start > MAX_BUFFER_SIZE) throw new Error("Packed buffer would be larger than maximum buffer size");
+                    newSize = Math.min(MAX_BUFFER_SIZE, Math.round(Math.max((end - start) * (end > 67108864 ? 1.25 : 2), 4194304) / 4096) * 4096);
+                } else newSize = (Math.max(end - start << 2, target.length - 1) >> 12) + 1 << 12;
+                let newBuffer = new ByteArrayAllocate(newSize);
+                targetView = newBuffer.dataView || (newBuffer.dataView = new DataView(newBuffer.buffer, 0, newSize));
+                end = Math.min(end, target.length);
+                if (target.copy) target.copy(newBuffer, 0, start, end); else newBuffer.set(target.slice(start, end));
+                pack_position -= start;
+                start = 0;
+                safeEnd = newBuffer.length - 10;
+                return target = newBuffer;
+            };
+            const newRecord = (transition, keys, newTransitions) => {
+                let recordId = structures.nextId;
+                if (!recordId) recordId = 64;
+                if (recordId < sharedLimitId && this.shouldShareStructure && !this.shouldShareStructure(keys)) {
+                    recordId = structures.nextOwnId;
+                    if (!(recordId < maxStructureId)) recordId = sharedLimitId;
+                    structures.nextOwnId = recordId + 1;
+                } else {
+                    if (recordId >= maxStructureId) recordId = sharedLimitId;
+                    structures.nextId = recordId + 1;
+                }
+                let highByte = keys.highByte = recordId >= 96 && useTwoByteRecords ? recordId - 96 >> 5 : -1;
+                transition[RECORD_SYMBOL] = recordId;
+                transition.__keys__ = keys;
+                structures[recordId - 64] = keys;
+                if (recordId < sharedLimitId) {
+                    keys.isShared = true;
+                    structures.sharedLength = recordId - 63;
+                    hasSharedUpdate = true;
+                    if (highByte >= 0) {
+                        target[pack_position++] = (recordId & 31) + 96;
+                        target[pack_position++] = highByte;
+                    } else {
+                        target[pack_position++] = recordId;
+                    }
+                } else {
+                    if (highByte >= 0) {
+                        target[pack_position++] = 213;
+                        target[pack_position++] = 114;
+                        target[pack_position++] = (recordId & 31) + 96;
+                        target[pack_position++] = highByte;
+                    } else {
+                        target[pack_position++] = 212;
+                        target[pack_position++] = 114;
+                        target[pack_position++] = recordId;
+                    }
+                    if (newTransitions) transitionsCount += serializationsSinceTransitionRebuild * newTransitions;
+                    if (recordIdsToRemove.length >= maxOwnStructures) recordIdsToRemove.shift()[RECORD_SYMBOL] = 0;
+                    recordIdsToRemove.push(transition);
+                    pack(keys);
+                }
+            };
+            const insertNewRecord = (transition, keys, insertionOffset, newTransitions) => {
+                let mainTarget = target;
+                let mainPosition = pack_position;
+                let mainSafeEnd = safeEnd;
+                let mainStart = start;
+                target = keysTarget;
+                pack_position = 0;
+                start = 0;
+                if (!target) keysTarget = target = new ByteArrayAllocate(8192);
+                safeEnd = target.length - 10;
+                newRecord(transition, keys, newTransitions);
+                keysTarget = target;
+                let keysPosition = pack_position;
+                target = mainTarget;
+                pack_position = mainPosition;
+                safeEnd = mainSafeEnd;
+                start = mainStart;
+                if (keysPosition > 1) {
+                    let newEnd = pack_position + keysPosition - 1;
+                    if (newEnd > safeEnd) makeRoom(newEnd);
+                    let insertionPosition = insertionOffset + start;
+                    target.copyWithin(insertionPosition + keysPosition, insertionPosition + 1, pack_position);
+                    target.set(keysTarget.slice(0, keysPosition), insertionPosition);
+                    pack_position = newEnd;
+                } else {
+                    target[insertionOffset + start] = keysTarget[0];
+                }
+            };
+            const writeStruct = object => {
+                let newPosition = writeStructSlots(object, target, start, pack_position, structures, makeRoom, ((value, newPosition, notifySharedUpdate) => {
+                    if (notifySharedUpdate) return hasSharedUpdate = true;
+                    pack_position = newPosition;
+                    let startTarget = target;
+                    pack(value);
+                    resetStructures();
+                    if (startTarget !== target) {
+                        return {
+                            position: pack_position,
+                            targetView,
+                            target
+                        };
+                    }
+                    return pack_position;
+                }), this);
+                if (newPosition === 0) return writeObject(object);
+                pack_position = newPosition;
+            };
+        }
+        useBuffer(buffer) {
+            target = buffer;
+            target.dataView || (target.dataView = new DataView(target.buffer, target.byteOffset, target.byteLength));
+            pack_position = 0;
+        }
+        set position(value) {
+            pack_position = value;
+        }
+        get position() {
+            return pack_position;
+        }
+        clearSharedData() {
+            if (this.structures) this.structures = [];
+            if (this.typedStructs) this.typedStructs = [];
+        }
+    }
+    extensionClasses = [ Date, Set, Error, RegExp, ArrayBuffer, Object.getPrototypeOf(Uint8Array.prototype).constructor, C1Type ];
+    extensions = [ {
+        pack(date, allocateForWrite, pack) {
+            let seconds = date.getTime() / 1e3;
+            if ((this.useTimestamp32 || date.getMilliseconds() === 0) && seconds >= 0 && seconds < 4294967296) {
+                let {target, targetView, position} = allocateForWrite(6);
+                target[position++] = 214;
+                target[position++] = 255;
+                targetView.setUint32(position, seconds);
+            } else if (seconds > 0 && seconds < 4294967296) {
+                let {target, targetView, position} = allocateForWrite(10);
+                target[position++] = 215;
+                target[position++] = 255;
+                targetView.setUint32(position, date.getMilliseconds() * 4e6 + (seconds / 1e3 / 4294967296 >> 0));
+                targetView.setUint32(position + 4, seconds);
+            } else if (isNaN(seconds)) {
+                if (this.onInvalidDate) {
+                    allocateForWrite(0);
+                    return pack(this.onInvalidDate());
+                }
+                let {target, targetView, position} = allocateForWrite(3);
+                target[position++] = 212;
+                target[position++] = 255;
+                target[position++] = 255;
+            } else {
+                let {target, targetView, position} = allocateForWrite(15);
+                target[position++] = 199;
+                target[position++] = 12;
+                target[position++] = 255;
+                targetView.setUint32(position, date.getMilliseconds() * 1e6);
+                targetView.setBigInt64(position + 4, BigInt(Math.floor(seconds)));
+            }
+        }
+    }, {
+        pack(set, allocateForWrite, pack) {
+            if (this.setAsEmptyObject) {
+                allocateForWrite(0);
+                return pack({});
+            }
+            let array = Array.from(set);
+            let {target, position} = allocateForWrite(this.moreTypes ? 3 : 0);
+            if (this.moreTypes) {
+                target[position++] = 212;
+                target[position++] = 115;
+                target[position++] = 0;
+            }
+            pack(array);
+        }
+    }, {
+        pack(error, allocateForWrite, pack) {
+            let {target, position} = allocateForWrite(this.moreTypes ? 3 : 0);
+            if (this.moreTypes) {
+                target[position++] = 212;
+                target[position++] = 101;
+                target[position++] = 0;
+            }
+            pack([ error.name, error.message, error.cause ]);
+        }
+    }, {
+        pack(regex, allocateForWrite, pack) {
+            let {target, position} = allocateForWrite(this.moreTypes ? 3 : 0);
+            if (this.moreTypes) {
+                target[position++] = 212;
+                target[position++] = 120;
+                target[position++] = 0;
+            }
+            pack([ regex.source, regex.flags ]);
+        }
+    }, {
+        pack(arrayBuffer, allocateForWrite) {
+            if (this.moreTypes) writeExtBuffer(arrayBuffer, 16, allocateForWrite); else writeBuffer(hasNodeBuffer ? pack_Buffer.from(arrayBuffer) : new Uint8Array(arrayBuffer), allocateForWrite);
+        }
+    }, {
+        pack(typedArray, allocateForWrite) {
+            let constructor = typedArray.constructor;
+            if (constructor !== ByteArray && this.moreTypes) writeExtBuffer(typedArray, typedArrays.indexOf(constructor.name), allocateForWrite); else writeBuffer(typedArray, allocateForWrite);
+        }
+    }, {
+        pack(c1, allocateForWrite) {
+            let {target, position} = allocateForWrite(1);
+            target[position] = 193;
+        }
+    } ];
+    function writeExtBuffer(typedArray, type, allocateForWrite, encode) {
+        let length = typedArray.byteLength;
+        if (length + 1 < 256) {
+            var {target, position} = allocateForWrite(4 + length);
+            target[position++] = 199;
+            target[position++] = length + 1;
+        } else if (length + 1 < 65536) {
+            var {target, position} = allocateForWrite(5 + length);
+            target[position++] = 200;
+            target[position++] = length + 1 >> 8;
+            target[position++] = length + 1 & 255;
+        } else {
+            var {target, position, targetView} = allocateForWrite(7 + length);
+            target[position++] = 201;
+            targetView.setUint32(position, length + 1);
+            position += 4;
+        }
+        target[position++] = 116;
+        target[position++] = type;
+        if (!typedArray.buffer) typedArray = new Uint8Array(typedArray);
+        target.set(new Uint8Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength), position);
+    }
+    function writeBuffer(buffer, allocateForWrite) {
+        let length = buffer.byteLength;
+        var target, position;
+        if (length < 256) {
+            var {target, position} = allocateForWrite(length + 2);
+            target[position++] = 196;
+            target[position++] = length;
+        } else if (length < 65536) {
+            var {target, position} = allocateForWrite(length + 3);
+            target[position++] = 197;
+            target[position++] = length >> 8;
+            target[position++] = length & 255;
+        } else {
+            var {target, position, targetView} = allocateForWrite(length + 5);
+            target[position++] = 198;
+            targetView.setUint32(position, length);
+            position += 4;
+        }
+        target.set(buffer, position);
+    }
+    function writeExtensionData(result, target, position, type) {
+        let length = result.length;
+        switch (length) {
+          case 1:
+            target[position++] = 212;
+            break;
+
+          case 2:
+            target[position++] = 213;
+            break;
+
+          case 4:
+            target[position++] = 214;
+            break;
+
+          case 8:
+            target[position++] = 215;
+            break;
+
+          case 16:
+            target[position++] = 216;
+            break;
+
+          default:
+            if (length < 256) {
+                target[position++] = 199;
+                target[position++] = length;
+            } else if (length < 65536) {
+                target[position++] = 200;
+                target[position++] = length >> 8;
+                target[position++] = length & 255;
+            } else {
+                target[position++] = 201;
+                target[position++] = length >> 24;
+                target[position++] = length >> 16 & 255;
+                target[position++] = length >> 8 & 255;
+                target[position++] = length & 255;
+            }
+        }
+        target[position++] = type;
+        target.set(result, position);
+        position += length;
+        return position;
+    }
+    function insertIds(serialized, idsToInsert) {
+        let nextId;
+        let distanceToMove = idsToInsert.length * 6;
+        let lastEnd = serialized.length - distanceToMove;
+        while (nextId = idsToInsert.pop()) {
+            let offset = nextId.offset;
+            let id = nextId.id;
+            serialized.copyWithin(offset + distanceToMove, offset, lastEnd);
+            distanceToMove -= 6;
+            let position = offset + distanceToMove;
+            serialized[position++] = 214;
+            serialized[position++] = 105;
+            serialized[position++] = id >> 24;
+            serialized[position++] = id >> 16 & 255;
+            serialized[position++] = id >> 8 & 255;
+            serialized[position++] = id & 255;
+            lastEnd = offset;
+        }
+        return serialized;
+    }
+    function writeBundles(start, pack, incrementPosition) {
+        if (pack_bundledStrings.length > 0) {
+            targetView.setUint32(pack_bundledStrings.position + start, pack_position + incrementPosition - pack_bundledStrings.position - start);
+            pack_bundledStrings.stringsPosition = pack_position - start;
+            let writeStrings = pack_bundledStrings;
+            pack_bundledStrings = null;
+            pack(writeStrings[0]);
+            pack(writeStrings[1]);
+        }
+    }
+    function pack_addExtension(extension) {
+        if (extension.Class) {
+            if (!extension.pack && !extension.write) throw new Error("Extension has no pack or write function");
+            if (extension.pack && !extension.type) throw new Error("Extension has no type (numeric code to identify the extension)");
+            extensionClasses.unshift(extension.Class);
+            extensions.unshift(extension);
+        }
+        unpackAddExtension(extension);
+    }
+    function prepareStructures(structures, packr) {
+        structures.isCompatible = existingStructures => {
+            let compatible = !existingStructures || (packr.lastNamedStructuresLength || 0) === existingStructures.length;
+            if (!compatible) packr._mergeStructures(existingStructures);
+            return compatible;
+        };
+        return structures;
+    }
+    function setWriteStructSlots(writeSlots, makeStructures) {
+        writeStructSlots = writeSlots;
+        prepareStructures = makeStructures;
+    }
+    let defaultPackr = new Packr({
+        useRecords: false
+    });
+    const pack = defaultPackr.pack;
+    const encode = defaultPackr.pack;
+    const Encoder = Packr;
+    const {NEVER, ALWAYS, DECIMAL_ROUND, DECIMAL_FIT} = FLOAT32_OPTIONS;
+    const REUSE_BUFFER_MODE = 512;
+    const RESET_BUFFER_MODE = 1024;
+    const RESERVE_START_SPACE = 2048;
     var backend_Buffer = __webpack_require__(764)["lW"];
     class AztecClientBackendError extends Error {
         constructor(message) {
             super(message);
         }
     }
+    function parseBigEndianU32Array(buffer) {
+        const dv = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+        let offset = 0;
+        const count = buffer.byteLength >>> 2;
+        console.log(buffer);
+        const out = new Array(count);
+        for (let i = 0; i < count; i++) {
+            out[i] = dv.getUint32(offset, false);
+            offset += 4;
+        }
+        return out;
+    }
     class UltraPlonkBackend {
         constructor(acirBytecode, backendOptions = {
             threads: 1
@@ -10524,11 +12452,29 @@ var __webpack_exports__ = {};
             await this.api.destroy();
         }
     }
+    function serializeAztecClientExecutionSteps(acirBuf, witnessBuf, vksBuf) {
+        const steps = [];
+        for (let i = 0; i < acirBuf.length; i++) {
+            const bytecode = acirBuf[i];
+            const witness = witnessBuf[i] || backend_Buffer.from([]);
+            const vk = vksBuf[i] || backend_Buffer.from([]);
+            const functionName = `unknown_wasm_${i}`;
+            steps.push({
+                bytecode,
+                witness,
+                vk,
+                functionName
+            });
+        }
+        return new Encoder({
+            useRecords: false
+        }).pack(steps);
+    }
     class AztecClientBackend {
-        constructor(acirMsgpack, options = {
+        constructor(acirBuf, options = {
             threads: 1
         }) {
-            this.acirMsgpack = acirMsgpack;
+            this.acirBuf = acirBuf;
             this.options = options;
         }
         async instantiate() {
@@ -10538,9 +12484,16 @@ var __webpack_exports__ = {};
                 this.api = api;
             }
         }
-        async prove(witnessMsgpack) {
+        async prove(witnessBuf, vksBuf = []) {
+            if (vksBuf.length !== 0 && this.acirBuf.length !== witnessBuf.length) {
+                throw new AztecClientBackendError("Witness and bytecodes must have the same stack depth!");
+            }
+            if (vksBuf.length !== 0 && vksBuf.length !== witnessBuf.length) {
+                throw new AztecClientBackendError("Witness and VKs must have the same stack depth!");
+            }
             await this.instantiate();
-            const proofAndVk = await this.api.acirProveAztecClient(this.acirMsgpack, witnessMsgpack);
+            const ivcInputsBuf = serializeAztecClientExecutionSteps(this.acirBuf, witnessBuf, vksBuf);
+            const proofAndVk = await this.api.acirProveAztecClient(ivcInputsBuf);
             const [proof, vk] = proofAndVk;
             if (!await this.verify(proof, vk)) {
                 throw new AztecClientBackendError("Failed to verify the private (ClientIVC) transaction proof!");
@@ -10551,13 +12504,11 @@ var __webpack_exports__ = {};
             await this.instantiate();
             return this.api.acirVerifyAztecClient(proof, vk);
         }
-        async proveAndVerify(witnessMsgpack) {
-            await this.instantiate();
-            return this.api.acirProveAndVerifyAztecClient(this.acirMsgpack, witnessMsgpack);
-        }
         async gates() {
             await this.instantiate();
-            return this.api.acirGatesAztecClient(this.acirMsgpack);
+            const ivcInputsBuf = serializeAztecClientExecutionSteps(this.acirBuf, [], []);
+            const resultBuffer = await this.api.acirGatesAztecClient(ivcInputsBuf);
+            return parseBigEndianU32Array(resultBuffer);
         }
         async destroy() {
             if (!this.api) {