@noir-lang/acvm_js 0.46.0 → 0.47.0-30c50f5.nightly

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/web/acvm_js.js CHANGED
@@ -124,15 +124,6 @@ function getFloat64Memory0() {
124
124
  return cachedFloat64Memory0;
125
125
  }
126
126
 
127
- let cachedBigInt64Memory0 = null;
128
-
129
- function getBigInt64Memory0() {
130
- if (cachedBigInt64Memory0 === null || cachedBigInt64Memory0.byteLength === 0) {
131
- cachedBigInt64Memory0 = new BigInt64Array(wasm.memory.buffer);
132
- }
133
- return cachedBigInt64Memory0;
134
- }
135
-
136
127
  function debugString(val) {
137
128
  // primitive types
138
129
  const type = typeof val;
@@ -222,29 +213,8 @@ function makeMutClosure(arg0, arg1, dtor, f) {
222
213
 
223
214
  return real;
224
215
  }
225
- function __wbg_adapter_52(arg0, arg1, arg2) {
226
- wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hc5258430255de068(arg0, arg1, addHeapObject(arg2));
227
- }
228
-
229
- /**
230
- * Sets the package's logging level.
231
- *
232
- * @param {LogLevel} level - The maximum level of logging to be emitted.
233
- */
234
- export function initLogLevel(filter) {
235
- try {
236
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
237
- const ptr0 = passStringToWasm0(filter, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
238
- const len0 = WASM_VECTOR_LEN;
239
- wasm.initLogLevel(retptr, ptr0, len0);
240
- var r0 = getInt32Memory0()[retptr / 4 + 0];
241
- var r1 = getInt32Memory0()[retptr / 4 + 1];
242
- if (r1) {
243
- throw takeObject(r0);
244
- }
245
- } finally {
246
- wasm.__wbindgen_add_to_stack_pointer(16);
247
- }
216
+ function __wbg_adapter_22(arg0, arg1, arg2) {
217
+ wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h36bac5ff3ea3c380(arg0, arg1, addHeapObject(arg2));
248
218
  }
249
219
 
250
220
  /**
@@ -256,144 +226,10 @@ export function buildInfo() {
256
226
  return takeObject(ret);
257
227
  }
258
228
 
259
- /**
260
- * Performs a bitwise AND operation between `lhs` and `rhs`
261
- * @param {string} lhs
262
- * @param {string} rhs
263
- * @returns {string}
264
- */
265
- export function and(lhs, rhs) {
266
- const ret = wasm.and(addHeapObject(lhs), addHeapObject(rhs));
267
- return takeObject(ret);
268
- }
269
-
270
- /**
271
- * Performs a bitwise XOR operation between `lhs` and `rhs`
272
- * @param {string} lhs
273
- * @param {string} rhs
274
- * @returns {string}
275
- */
276
- export function xor(lhs, rhs) {
277
- const ret = wasm.xor(addHeapObject(lhs), addHeapObject(rhs));
278
- return takeObject(ret);
279
- }
280
-
281
- function passArray8ToWasm0(arg, malloc) {
282
- const ptr = malloc(arg.length * 1) >>> 0;
283
- getUint8Memory0().set(arg, ptr / 1);
284
- WASM_VECTOR_LEN = arg.length;
285
- return ptr;
286
- }
287
-
288
229
  function getArrayU8FromWasm0(ptr, len) {
289
230
  ptr = ptr >>> 0;
290
231
  return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
291
232
  }
292
- /**
293
- * Calculates the SHA256 hash of the input bytes
294
- * @param {Uint8Array} inputs
295
- * @returns {Uint8Array}
296
- */
297
- export function sha256(inputs) {
298
- try {
299
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
300
- const ptr0 = passArray8ToWasm0(inputs, wasm.__wbindgen_malloc);
301
- const len0 = WASM_VECTOR_LEN;
302
- wasm.sha256(retptr, ptr0, len0);
303
- var r0 = getInt32Memory0()[retptr / 4 + 0];
304
- var r1 = getInt32Memory0()[retptr / 4 + 1];
305
- var v2 = getArrayU8FromWasm0(r0, r1).slice();
306
- wasm.__wbindgen_free(r0, r1 * 1);
307
- return v2;
308
- } finally {
309
- wasm.__wbindgen_add_to_stack_pointer(16);
310
- }
311
- }
312
-
313
- /**
314
- * Calculates the Blake2s256 hash of the input bytes
315
- * @param {Uint8Array} inputs
316
- * @returns {Uint8Array}
317
- */
318
- export function blake2s256(inputs) {
319
- try {
320
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
321
- const ptr0 = passArray8ToWasm0(inputs, wasm.__wbindgen_malloc);
322
- const len0 = WASM_VECTOR_LEN;
323
- wasm.blake2s256(retptr, ptr0, len0);
324
- var r0 = getInt32Memory0()[retptr / 4 + 0];
325
- var r1 = getInt32Memory0()[retptr / 4 + 1];
326
- var v2 = getArrayU8FromWasm0(r0, r1).slice();
327
- wasm.__wbindgen_free(r0, r1 * 1);
328
- return v2;
329
- } finally {
330
- wasm.__wbindgen_add_to_stack_pointer(16);
331
- }
332
- }
333
-
334
- /**
335
- * Calculates the Keccak256 hash of the input bytes
336
- * @param {Uint8Array} inputs
337
- * @returns {Uint8Array}
338
- */
339
- export function keccak256(inputs) {
340
- try {
341
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
342
- const ptr0 = passArray8ToWasm0(inputs, wasm.__wbindgen_malloc);
343
- const len0 = WASM_VECTOR_LEN;
344
- wasm.keccak256(retptr, ptr0, len0);
345
- var r0 = getInt32Memory0()[retptr / 4 + 0];
346
- var r1 = getInt32Memory0()[retptr / 4 + 1];
347
- var v2 = getArrayU8FromWasm0(r0, r1).slice();
348
- wasm.__wbindgen_free(r0, r1 * 1);
349
- return v2;
350
- } finally {
351
- wasm.__wbindgen_add_to_stack_pointer(16);
352
- }
353
- }
354
-
355
- /**
356
- * Verifies a ECDSA signature over the secp256k1 curve.
357
- * @param {Uint8Array} hashed_msg
358
- * @param {Uint8Array} public_key_x_bytes
359
- * @param {Uint8Array} public_key_y_bytes
360
- * @param {Uint8Array} signature
361
- * @returns {boolean}
362
- */
363
- export function ecdsa_secp256k1_verify(hashed_msg, public_key_x_bytes, public_key_y_bytes, signature) {
364
- const ptr0 = passArray8ToWasm0(hashed_msg, wasm.__wbindgen_malloc);
365
- const len0 = WASM_VECTOR_LEN;
366
- const ptr1 = passArray8ToWasm0(public_key_x_bytes, wasm.__wbindgen_malloc);
367
- const len1 = WASM_VECTOR_LEN;
368
- const ptr2 = passArray8ToWasm0(public_key_y_bytes, wasm.__wbindgen_malloc);
369
- const len2 = WASM_VECTOR_LEN;
370
- const ptr3 = passArray8ToWasm0(signature, wasm.__wbindgen_malloc);
371
- const len3 = WASM_VECTOR_LEN;
372
- const ret = wasm.ecdsa_secp256k1_verify(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
373
- return ret !== 0;
374
- }
375
-
376
- /**
377
- * Verifies a ECDSA signature over the secp256r1 curve.
378
- * @param {Uint8Array} hashed_msg
379
- * @param {Uint8Array} public_key_x_bytes
380
- * @param {Uint8Array} public_key_y_bytes
381
- * @param {Uint8Array} signature
382
- * @returns {boolean}
383
- */
384
- export function ecdsa_secp256r1_verify(hashed_msg, public_key_x_bytes, public_key_y_bytes, signature) {
385
- const ptr0 = passArray8ToWasm0(hashed_msg, wasm.__wbindgen_malloc);
386
- const len0 = WASM_VECTOR_LEN;
387
- const ptr1 = passArray8ToWasm0(public_key_x_bytes, wasm.__wbindgen_malloc);
388
- const len1 = WASM_VECTOR_LEN;
389
- const ptr2 = passArray8ToWasm0(public_key_y_bytes, wasm.__wbindgen_malloc);
390
- const len2 = WASM_VECTOR_LEN;
391
- const ptr3 = passArray8ToWasm0(signature, wasm.__wbindgen_malloc);
392
- const len3 = WASM_VECTOR_LEN;
393
- const ret = wasm.ecdsa_secp256r1_verify(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
394
- return ret !== 0;
395
- }
396
-
397
233
  /**
398
234
  * Compresses a `WitnessMap` into the binary format outputted by Nargo.
399
235
  *
@@ -419,6 +255,12 @@ export function compressWitness(witness_map) {
419
255
  }
420
256
  }
421
257
 
258
+ function passArray8ToWasm0(arg, malloc) {
259
+ const ptr = malloc(arg.length * 1) >>> 0;
260
+ getUint8Memory0().set(arg, ptr / 1);
261
+ WASM_VECTOR_LEN = arg.length;
262
+ return ptr;
263
+ }
422
264
  /**
423
265
  * Decompresses a compressed witness as outputted by Nargo into a `WitnessMap`.
424
266
  * This should be used to only fetch the witness map for the main function.
@@ -493,14 +335,6 @@ export function decompressWitnessStack(compressed_witness) {
493
335
  }
494
336
  }
495
337
 
496
- /**
497
- * @returns {Promise<WasmBlackBoxFunctionSolver>}
498
- */
499
- export function createBlackBoxSolver() {
500
- const ret = wasm.createBlackBoxSolver();
501
- return takeObject(ret);
502
- }
503
-
504
338
  /**
505
339
  * Executes an ACIR circuit to generate the solved witness from the initial witness.
506
340
  *
@@ -516,48 +350,29 @@ export function executeCircuit(program, initial_witness, foreign_call_handler) {
516
350
  return takeObject(ret);
517
351
  }
518
352
 
519
- function _assertClass(instance, klass) {
520
- if (!(instance instanceof klass)) {
521
- throw new Error(`expected instance of ${klass.name}`);
522
- }
523
- return instance.ptr;
524
- }
525
353
  /**
526
354
  * Executes an ACIR circuit to generate the solved witness from the initial witness.
527
355
  * This method also extracts the public return values from the solved witness into its own return witness.
528
356
  *
529
- * @param {&WasmBlackBoxFunctionSolver} solver - A black box solver.
530
357
  * @param {Uint8Array} circuit - A serialized representation of an ACIR circuit
531
358
  * @param {WitnessMap} initial_witness - The initial witness map defining all of the inputs to `circuit`..
532
359
  * @param {ForeignCallHandler} foreign_call_handler - A callback to process any foreign calls from the circuit.
533
360
  * @returns {SolvedAndReturnWitness} The solved witness calculated by executing the circuit on the provided inputs, as well as the return witness indices as specified by the circuit.
534
361
  */
535
- export function executeCircuitWithReturnWitness(solver, program, initial_witness, foreign_call_handler) {
536
- _assertClass(solver, WasmBlackBoxFunctionSolver);
362
+ export function executeCircuitWithReturnWitness(program, initial_witness, foreign_call_handler) {
537
363
  const ptr0 = passArray8ToWasm0(program, wasm.__wbindgen_malloc);
538
364
  const len0 = WASM_VECTOR_LEN;
539
- const ret = wasm.executeCircuitWithReturnWitness(solver.__wbg_ptr, ptr0, len0, addHeapObject(initial_witness), addHeapObject(foreign_call_handler));
365
+ const ret = wasm.executeCircuitWithReturnWitness(ptr0, len0, addHeapObject(initial_witness), addHeapObject(foreign_call_handler));
540
366
  return takeObject(ret);
541
367
  }
542
368
 
543
369
  /**
544
370
  * Executes an ACIR circuit to generate the solved witness from the initial witness.
545
371
  *
546
- * @param {&WasmBlackBoxFunctionSolver} solver - A black box solver.
547
- * @param {Uint8Array} circuit - A serialized representation of an ACIR circuit
548
- * @param {WitnessMap} initial_witness - The initial witness map defining all of the inputs to `circuit`..
549
- * @param {ForeignCallHandler} foreign_call_handler - A callback to process any foreign calls from the circuit.
550
- * @returns {WitnessMap} The solved witness calculated by executing the circuit on the provided inputs.
551
- */
552
- export function executeCircuitWithBlackBoxSolver(solver, program, initial_witness, foreign_call_handler) {
553
- _assertClass(solver, WasmBlackBoxFunctionSolver);
554
- const ptr0 = passArray8ToWasm0(program, wasm.__wbindgen_malloc);
555
- const len0 = WASM_VECTOR_LEN;
556
- const ret = wasm.executeCircuitWithBlackBoxSolver(solver.__wbg_ptr, ptr0, len0, addHeapObject(initial_witness), addHeapObject(foreign_call_handler));
557
- return takeObject(ret);
558
- }
559
-
560
- /**
372
+ * @param {Uint8Array} program - A serialized representation of an ACIR program
373
+ * @param {WitnessMap} initial_witness - The initial witness map defining all of the inputs to `program`.
374
+ * @param {ForeignCallHandler} foreign_call_handler - A callback to process any foreign calls from the program.
375
+ * @returns {WitnessStack} The solved witness calculated by executing the program on the provided inputs.
561
376
  */
562
377
  export function executeProgram(program, initial_witness, foreign_call_handler) {
563
378
  const ptr0 = passArray8ToWasm0(program, wasm.__wbindgen_malloc);
@@ -566,16 +381,6 @@ export function executeProgram(program, initial_witness, foreign_call_handler) {
566
381
  return takeObject(ret);
567
382
  }
568
383
 
569
- /**
570
- */
571
- export function executeProgramWithBlackBoxSolver(solver, program, initial_witness, foreign_call_executor) {
572
- _assertClass(solver, WasmBlackBoxFunctionSolver);
573
- const ptr0 = passArray8ToWasm0(program, wasm.__wbindgen_malloc);
574
- const len0 = WASM_VECTOR_LEN;
575
- const ret = wasm.executeProgramWithBlackBoxSolver(solver.__wbg_ptr, ptr0, len0, addHeapObject(initial_witness), addHeapObject(foreign_call_executor));
576
- return takeObject(ret);
577
- }
578
-
579
384
  /**
580
385
  * Extracts a `WitnessMap` containing the witness indices corresponding to the circuit's return values.
581
386
  *
@@ -660,69 +465,168 @@ export function getPublicWitness(program, solved_witness) {
660
465
  }
661
466
  }
662
467
 
663
- function handleError(f, args) {
664
- try {
665
- return f.apply(this, args);
666
- } catch (e) {
667
- wasm.__wbindgen_exn_store(addHeapObject(e));
668
- }
669
- }
670
- function __wbg_adapter_134(arg0, arg1, arg2, arg3, arg4) {
671
- wasm.wasm_bindgen__convert__closures__invoke3_mut__h1e7d8ac96c74bd35(arg0, arg1, addHeapObject(arg2), arg3, addHeapObject(arg4));
468
+ /**
469
+ * Performs a bitwise AND operation between `lhs` and `rhs`
470
+ * @param {string} lhs
471
+ * @param {string} rhs
472
+ * @returns {string}
473
+ */
474
+ export function and(lhs, rhs) {
475
+ const ret = wasm.and(addHeapObject(lhs), addHeapObject(rhs));
476
+ return takeObject(ret);
672
477
  }
673
478
 
674
- function __wbg_adapter_171(arg0, arg1, arg2, arg3) {
675
- wasm.wasm_bindgen__convert__closures__invoke2_mut__h188e918906ff9a40(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
479
+ /**
480
+ * Performs a bitwise XOR operation between `lhs` and `rhs`
481
+ * @param {string} lhs
482
+ * @param {string} rhs
483
+ * @returns {string}
484
+ */
485
+ export function xor(lhs, rhs) {
486
+ const ret = wasm.xor(addHeapObject(lhs), addHeapObject(rhs));
487
+ return takeObject(ret);
676
488
  }
677
489
 
678
490
  /**
679
- * A struct representing a Trap
491
+ * Calculates the SHA256 hash of the input bytes
492
+ * @param {Uint8Array} inputs
493
+ * @returns {Uint8Array}
680
494
  */
681
- export class Trap {
682
-
683
- __destroy_into_raw() {
684
- const ptr = this.__wbg_ptr;
685
- this.__wbg_ptr = 0;
686
-
687
- return ptr;
495
+ export function sha256(inputs) {
496
+ try {
497
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
498
+ const ptr0 = passArray8ToWasm0(inputs, wasm.__wbindgen_malloc);
499
+ const len0 = WASM_VECTOR_LEN;
500
+ wasm.sha256(retptr, ptr0, len0);
501
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
502
+ var r1 = getInt32Memory0()[retptr / 4 + 1];
503
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
504
+ wasm.__wbindgen_free(r0, r1 * 1);
505
+ return v2;
506
+ } finally {
507
+ wasm.__wbindgen_add_to_stack_pointer(16);
688
508
  }
509
+ }
689
510
 
690
- free() {
691
- const ptr = this.__destroy_into_raw();
692
- wasm.__wbg_trap_free(ptr);
511
+ /**
512
+ * Calculates the Blake2s256 hash of the input bytes
513
+ * @param {Uint8Array} inputs
514
+ * @returns {Uint8Array}
515
+ */
516
+ export function blake2s256(inputs) {
517
+ try {
518
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
519
+ const ptr0 = passArray8ToWasm0(inputs, wasm.__wbindgen_malloc);
520
+ const len0 = WASM_VECTOR_LEN;
521
+ wasm.blake2s256(retptr, ptr0, len0);
522
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
523
+ var r1 = getInt32Memory0()[retptr / 4 + 1];
524
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
525
+ wasm.__wbindgen_free(r0, r1 * 1);
526
+ return v2;
527
+ } finally {
528
+ wasm.__wbindgen_add_to_stack_pointer(16);
693
529
  }
694
- /**
695
- * A marker method to indicate that an object is an instance of the `Trap`
696
- * class.
697
- */
698
- static __wbg_wasmer_trap() {
699
- wasm.trap___wbg_wasmer_trap();
530
+ }
531
+
532
+ /**
533
+ * Calculates the Keccak256 hash of the input bytes
534
+ * @param {Uint8Array} inputs
535
+ * @returns {Uint8Array}
536
+ */
537
+ export function keccak256(inputs) {
538
+ try {
539
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
540
+ const ptr0 = passArray8ToWasm0(inputs, wasm.__wbindgen_malloc);
541
+ const len0 = WASM_VECTOR_LEN;
542
+ wasm.keccak256(retptr, ptr0, len0);
543
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
544
+ var r1 = getInt32Memory0()[retptr / 4 + 1];
545
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
546
+ wasm.__wbindgen_free(r0, r1 * 1);
547
+ return v2;
548
+ } finally {
549
+ wasm.__wbindgen_add_to_stack_pointer(16);
700
550
  }
701
551
  }
552
+
702
553
  /**
554
+ * Verifies a ECDSA signature over the secp256k1 curve.
555
+ * @param {Uint8Array} hashed_msg
556
+ * @param {Uint8Array} public_key_x_bytes
557
+ * @param {Uint8Array} public_key_y_bytes
558
+ * @param {Uint8Array} signature
559
+ * @returns {boolean}
703
560
  */
704
- export class WasmBlackBoxFunctionSolver {
561
+ export function ecdsa_secp256k1_verify(hashed_msg, public_key_x_bytes, public_key_y_bytes, signature) {
562
+ const ptr0 = passArray8ToWasm0(hashed_msg, wasm.__wbindgen_malloc);
563
+ const len0 = WASM_VECTOR_LEN;
564
+ const ptr1 = passArray8ToWasm0(public_key_x_bytes, wasm.__wbindgen_malloc);
565
+ const len1 = WASM_VECTOR_LEN;
566
+ const ptr2 = passArray8ToWasm0(public_key_y_bytes, wasm.__wbindgen_malloc);
567
+ const len2 = WASM_VECTOR_LEN;
568
+ const ptr3 = passArray8ToWasm0(signature, wasm.__wbindgen_malloc);
569
+ const len3 = WASM_VECTOR_LEN;
570
+ const ret = wasm.ecdsa_secp256k1_verify(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
571
+ return ret !== 0;
572
+ }
705
573
 
706
- static __wrap(ptr) {
707
- ptr = ptr >>> 0;
708
- const obj = Object.create(WasmBlackBoxFunctionSolver.prototype);
709
- obj.__wbg_ptr = ptr;
574
+ /**
575
+ * Verifies a ECDSA signature over the secp256r1 curve.
576
+ * @param {Uint8Array} hashed_msg
577
+ * @param {Uint8Array} public_key_x_bytes
578
+ * @param {Uint8Array} public_key_y_bytes
579
+ * @param {Uint8Array} signature
580
+ * @returns {boolean}
581
+ */
582
+ export function ecdsa_secp256r1_verify(hashed_msg, public_key_x_bytes, public_key_y_bytes, signature) {
583
+ const ptr0 = passArray8ToWasm0(hashed_msg, wasm.__wbindgen_malloc);
584
+ const len0 = WASM_VECTOR_LEN;
585
+ const ptr1 = passArray8ToWasm0(public_key_x_bytes, wasm.__wbindgen_malloc);
586
+ const len1 = WASM_VECTOR_LEN;
587
+ const ptr2 = passArray8ToWasm0(public_key_y_bytes, wasm.__wbindgen_malloc);
588
+ const len2 = WASM_VECTOR_LEN;
589
+ const ptr3 = passArray8ToWasm0(signature, wasm.__wbindgen_malloc);
590
+ const len3 = WASM_VECTOR_LEN;
591
+ const ret = wasm.ecdsa_secp256r1_verify(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
592
+ return ret !== 0;
593
+ }
710
594
 
711
- return obj;
595
+ /**
596
+ * Sets the package's logging level.
597
+ *
598
+ * @param {LogLevel} level - The maximum level of logging to be emitted.
599
+ */
600
+ export function initLogLevel(filter) {
601
+ try {
602
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
603
+ const ptr0 = passStringToWasm0(filter, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
604
+ const len0 = WASM_VECTOR_LEN;
605
+ wasm.initLogLevel(retptr, ptr0, len0);
606
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
607
+ var r1 = getInt32Memory0()[retptr / 4 + 1];
608
+ if (r1) {
609
+ throw takeObject(r0);
610
+ }
611
+ } finally {
612
+ wasm.__wbindgen_add_to_stack_pointer(16);
712
613
  }
614
+ }
713
615
 
714
- __destroy_into_raw() {
715
- const ptr = this.__wbg_ptr;
716
- this.__wbg_ptr = 0;
717
-
718
- return ptr;
719
- }
616
+ function __wbg_adapter_76(arg0, arg1, arg2, arg3, arg4) {
617
+ wasm.wasm_bindgen__convert__closures__invoke3_mut__h629417323d5efbaa(arg0, arg1, addHeapObject(arg2), arg3, addHeapObject(arg4));
618
+ }
720
619
 
721
- free() {
722
- const ptr = this.__destroy_into_raw();
723
- wasm.__wbg_wasmblackboxfunctionsolver_free(ptr);
620
+ function handleError(f, args) {
621
+ try {
622
+ return f.apply(this, args);
623
+ } catch (e) {
624
+ wasm.__wbindgen_exn_store(addHeapObject(e));
724
625
  }
725
626
  }
627
+ function __wbg_adapter_93(arg0, arg1, arg2, arg3) {
628
+ wasm.wasm_bindgen__convert__closures__invoke2_mut__h4efdd1050cfb3ea7(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
629
+ }
726
630
 
727
631
  async function __wbg_load(module, imports) {
728
632
  if (typeof Response === 'function' && module instanceof Response) {
@@ -761,15 +665,19 @@ function __wbg_get_imports() {
761
665
  imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
762
666
  takeObject(arg0);
763
667
  };
764
- imports.wbg.__wbindgen_error_new = function(arg0, arg1) {
765
- const ret = new Error(getStringFromWasm0(arg0, arg1));
668
+ imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
669
+ const ret = getStringFromWasm0(arg0, arg1);
766
670
  return addHeapObject(ret);
767
671
  };
768
- imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
769
- const ret = getObject(arg0);
672
+ imports.wbg.__wbindgen_is_array = function(arg0) {
673
+ const ret = Array.isArray(getObject(arg0));
674
+ return ret;
675
+ };
676
+ imports.wbg.__wbg_constructor_971e67e66cc5bd6a = function(arg0) {
677
+ const ret = new Error(takeObject(arg0));
770
678
  return addHeapObject(ret);
771
679
  };
772
- imports.wbg.__wbg_new_6f6c75f9324b78e8 = function() {
680
+ imports.wbg.__wbg_new_193bac1dd2be232d = function() {
773
681
  const ret = new Map();
774
682
  return addHeapObject(ret);
775
683
  };
@@ -777,10 +685,6 @@ function __wbg_get_imports() {
777
685
  const ret = arg0;
778
686
  return addHeapObject(ret);
779
687
  };
780
- imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
781
- const ret = getStringFromWasm0(arg0, arg1);
782
- return addHeapObject(ret);
783
- };
784
688
  imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
785
689
  const obj = getObject(arg1);
786
690
  const ret = typeof(obj) === 'string' ? obj : undefined;
@@ -789,13 +693,11 @@ function __wbg_get_imports() {
789
693
  getInt32Memory0()[arg0 / 4 + 1] = len1;
790
694
  getInt32Memory0()[arg0 / 4 + 0] = ptr1;
791
695
  };
792
- imports.wbg.__wbg_wasmblackboxfunctionsolver_new = function(arg0) {
793
- const ret = WasmBlackBoxFunctionSolver.__wrap(arg0);
794
- return addHeapObject(ret);
795
- };
796
- imports.wbg.__wbg_constructor_81b34c49dcbdd2af = function(arg0) {
797
- const ret = new Error(takeObject(arg0));
798
- return addHeapObject(ret);
696
+ imports.wbg.__wbindgen_number_get = function(arg0, arg1) {
697
+ const obj = getObject(arg1);
698
+ const ret = typeof(obj) === 'number' ? obj : undefined;
699
+ getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret;
700
+ getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
799
701
  };
800
702
  imports.wbg.__wbindgen_cb_drop = function(arg0) {
801
703
  const obj = takeObject(arg0).original;
@@ -806,28 +708,14 @@ function __wbg_get_imports() {
806
708
  const ret = false;
807
709
  return ret;
808
710
  };
809
- imports.wbg.__wbindgen_is_undefined = function(arg0) {
810
- const ret = getObject(arg0) === undefined;
811
- return ret;
812
- };
813
- imports.wbg.__wbindgen_number_get = function(arg0, arg1) {
814
- const obj = getObject(arg1);
815
- const ret = typeof(obj) === 'number' ? obj : undefined;
816
- getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret;
817
- getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
818
- };
819
- imports.wbg.__wbindgen_is_array = function(arg0) {
820
- const ret = Array.isArray(getObject(arg0));
821
- return ret;
711
+ imports.wbg.__wbg_new_f139361aad331bd0 = function() {
712
+ const ret = new Array();
713
+ return addHeapObject(ret);
822
714
  };
823
715
  imports.wbg.__wbindgen_is_string = function(arg0) {
824
716
  const ret = typeof(getObject(arg0)) === 'string';
825
717
  return ret;
826
718
  };
827
- imports.wbg.__wbg_new_ee5ac63ff3b0fa4d = function() {
828
- const ret = new Array();
829
- return addHeapObject(ret);
830
- };
831
719
  imports.wbg.__wbg_new_abda76e883ba8a5f = function() {
832
720
  const ret = new Error();
833
721
  return addHeapObject(ret);
@@ -850,53 +738,6 @@ function __wbg_get_imports() {
850
738
  wasm.__wbindgen_free(deferred0_0, deferred0_1);
851
739
  }
852
740
  };
853
- imports.wbg.__wbindgen_ge = function(arg0, arg1) {
854
- const ret = getObject(arg0) >= getObject(arg1);
855
- return ret;
856
- };
857
- imports.wbg.__wbindgen_bigint_from_u64 = function(arg0) {
858
- const ret = BigInt.asUintN(64, arg0);
859
- return addHeapObject(ret);
860
- };
861
- imports.wbg.__wbindgen_shr = function(arg0, arg1) {
862
- const ret = getObject(arg0) >> getObject(arg1);
863
- return addHeapObject(ret);
864
- };
865
- imports.wbg.__wbindgen_jsval_eq = function(arg0, arg1) {
866
- const ret = getObject(arg0) === getObject(arg1);
867
- return ret;
868
- };
869
- imports.wbg.__wbindgen_is_bigint = function(arg0) {
870
- const ret = typeof(getObject(arg0)) === 'bigint';
871
- return ret;
872
- };
873
- imports.wbg.__wbindgen_bigint_from_i64 = function(arg0) {
874
- const ret = arg0;
875
- return addHeapObject(ret);
876
- };
877
- imports.wbg.__wbindgen_bigint_from_u128 = function(arg0, arg1) {
878
- const ret = BigInt.asUintN(64, arg0) << BigInt(64) | BigInt.asUintN(64, arg1);
879
- return addHeapObject(ret);
880
- };
881
- imports.wbg.__wbindgen_is_object = function(arg0) {
882
- const val = getObject(arg0);
883
- const ret = typeof(val) === 'object' && val !== null;
884
- return ret;
885
- };
886
- imports.wbg.__wbindgen_is_function = function(arg0) {
887
- const ret = typeof(getObject(arg0)) === 'function';
888
- return ret;
889
- };
890
- imports.wbg.__wbg_instanceof_Global_f4b019d2b45e18ab = function(arg0) {
891
- let result;
892
- try {
893
- result = getObject(arg0) instanceof WebAssembly.Global;
894
- } catch {
895
- result = false;
896
- }
897
- const ret = result;
898
- return ret;
899
- };
900
741
  imports.wbg.__wbg_debug_e3f6a1578e6d45ca = function(arg0) {
901
742
  console.debug(getObject(arg0));
902
743
  };
@@ -921,36 +762,6 @@ function __wbg_get_imports() {
921
762
  imports.wbg.__wbg_warn_8342bfbc6028193a = function(arg0, arg1, arg2, arg3) {
922
763
  console.warn(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
923
764
  };
924
- imports.wbg.__wbg_crypto_c48a774b022d20ac = function(arg0) {
925
- const ret = getObject(arg0).crypto;
926
- return addHeapObject(ret);
927
- };
928
- imports.wbg.__wbg_process_298734cf255a885d = function(arg0) {
929
- const ret = getObject(arg0).process;
930
- return addHeapObject(ret);
931
- };
932
- imports.wbg.__wbg_versions_e2e78e134e3e5d01 = function(arg0) {
933
- const ret = getObject(arg0).versions;
934
- return addHeapObject(ret);
935
- };
936
- imports.wbg.__wbg_node_1cd7a5d853dbea79 = function(arg0) {
937
- const ret = getObject(arg0).node;
938
- return addHeapObject(ret);
939
- };
940
- imports.wbg.__wbg_msCrypto_bcb970640f50a1e8 = function(arg0) {
941
- const ret = getObject(arg0).msCrypto;
942
- return addHeapObject(ret);
943
- };
944
- imports.wbg.__wbg_require_8f08ceecec0f4fee = function() { return handleError(function () {
945
- const ret = module.require;
946
- return addHeapObject(ret);
947
- }, arguments) };
948
- imports.wbg.__wbg_randomFillSync_dc1e9a60c158336d = function() { return handleError(function (arg0, arg1) {
949
- getObject(arg0).randomFillSync(takeObject(arg1));
950
- }, arguments) };
951
- imports.wbg.__wbg_getRandomValues_37fa2ca9e4e07fab = function() { return handleError(function (arg0, arg1) {
952
- getObject(arg0).getRandomValues(getObject(arg1));
953
- }, arguments) };
954
765
  imports.wbg.__wbg_get_7303ed2ef026b2f5 = function(arg0, arg1) {
955
766
  const ret = getObject(arg0)[arg1 >>> 0];
956
767
  return addHeapObject(ret);
@@ -963,53 +774,10 @@ function __wbg_get_imports() {
963
774
  const ret = new Array();
964
775
  return addHeapObject(ret);
965
776
  };
966
- imports.wbg.__wbg_BigInt_9523742cb675bb6f = function(arg0) {
967
- const ret = BigInt(getObject(arg0));
968
- return addHeapObject(ret);
969
- };
970
- imports.wbg.__wbg_newnoargs_c9e6043b8ad84109 = function(arg0, arg1) {
971
- const ret = new Function(getStringFromWasm0(arg0, arg1));
972
- return addHeapObject(ret);
973
- };
974
777
  imports.wbg.__wbg_new_0f2b71ca2f2a6029 = function() {
975
778
  const ret = new Map();
976
779
  return addHeapObject(ret);
977
780
  };
978
- imports.wbg.__wbg_get_f53c921291c381bd = function() { return handleError(function (arg0, arg1) {
979
- const ret = Reflect.get(getObject(arg0), getObject(arg1));
980
- return addHeapObject(ret);
981
- }, arguments) };
982
- imports.wbg.__wbg_call_557a2f2deacc4912 = function() { return handleError(function (arg0, arg1) {
983
- const ret = getObject(arg0).call(getObject(arg1));
984
- return addHeapObject(ret);
985
- }, arguments) };
986
- imports.wbg.__wbg_new_2b6fea4ea03b1b95 = function() {
987
- const ret = new Object();
988
- return addHeapObject(ret);
989
- };
990
- imports.wbg.__wbg_self_742dd6eab3e9211e = function() { return handleError(function () {
991
- const ret = self.self;
992
- return addHeapObject(ret);
993
- }, arguments) };
994
- imports.wbg.__wbg_window_c409e731db53a0e2 = function() { return handleError(function () {
995
- const ret = window.window;
996
- return addHeapObject(ret);
997
- }, arguments) };
998
- imports.wbg.__wbg_globalThis_b70c095388441f2d = function() { return handleError(function () {
999
- const ret = globalThis.globalThis;
1000
- return addHeapObject(ret);
1001
- }, arguments) };
1002
- imports.wbg.__wbg_global_1c72617491ed7194 = function() { return handleError(function () {
1003
- const ret = global.global;
1004
- return addHeapObject(ret);
1005
- }, arguments) };
1006
- imports.wbg.__wbg_newwithlength_cd1db47a173e3944 = function(arg0) {
1007
- const ret = new Array(arg0 >>> 0);
1008
- return addHeapObject(ret);
1009
- };
1010
- imports.wbg.__wbg_set_b4da98d504ac6091 = function(arg0, arg1, arg2) {
1011
- getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
1012
- };
1013
781
  imports.wbg.__wbg_from_6bc98a09a0b58bb1 = function(arg0) {
1014
782
  const ret = Array.from(getObject(arg0));
1015
783
  return addHeapObject(ret);
@@ -1021,7 +789,7 @@ function __wbg_get_imports() {
1021
789
  const a = state0.a;
1022
790
  state0.a = 0;
1023
791
  try {
1024
- return __wbg_adapter_134(a, state0.b, arg0, arg1, arg2);
792
+ return __wbg_adapter_76(a, state0.b, arg0, arg1, arg2);
1025
793
  } finally {
1026
794
  state0.a = a;
1027
795
  }
@@ -1039,27 +807,6 @@ function __wbg_get_imports() {
1039
807
  const ret = getObject(arg0).reverse();
1040
808
  return addHeapObject(ret);
1041
809
  };
1042
- imports.wbg.__wbg_byteLength_1a59a59856fc656a = function(arg0) {
1043
- const ret = getObject(arg0).byteLength;
1044
- return ret;
1045
- };
1046
- imports.wbg.__wbg_toString_68dcf9fa017bbb08 = function(arg0, arg1, arg2) {
1047
- const ret = getObject(arg1).toString(arg2);
1048
- const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1049
- const len1 = WASM_VECTOR_LEN;
1050
- getInt32Memory0()[arg0 / 4 + 1] = len1;
1051
- getInt32Memory0()[arg0 / 4 + 0] = ptr1;
1052
- };
1053
- imports.wbg.__wbg_instanceof_Error_fac23a8832b241da = function(arg0) {
1054
- let result;
1055
- try {
1056
- result = getObject(arg0) instanceof Error;
1057
- } catch {
1058
- result = false;
1059
- }
1060
- const ret = result;
1061
- return ret;
1062
- };
1063
810
  imports.wbg.__wbg_new_87297f22973157c8 = function(arg0, arg1) {
1064
811
  const ret = new Error(getStringFromWasm0(arg0, arg1));
1065
812
  return addHeapObject(ret);
@@ -1067,20 +814,6 @@ function __wbg_get_imports() {
1067
814
  imports.wbg.__wbg_setcause_394738aae0ce9341 = function(arg0, arg1) {
1068
815
  getObject(arg0).cause = getObject(arg1);
1069
816
  };
1070
- imports.wbg.__wbg_message_eab7d45ec69a2135 = function(arg0) {
1071
- const ret = getObject(arg0).message;
1072
- return addHeapObject(ret);
1073
- };
1074
- imports.wbg.__wbg_instanceof_Function_8e1bcaacb89c4438 = function(arg0) {
1075
- let result;
1076
- try {
1077
- result = getObject(arg0) instanceof Function;
1078
- } catch {
1079
- result = false;
1080
- }
1081
- const ret = result;
1082
- return ret;
1083
- };
1084
817
  imports.wbg.__wbg_call_587b30eea3e09332 = function() { return handleError(function (arg0, arg1, arg2) {
1085
818
  const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
1086
819
  return addHeapObject(ret);
@@ -1089,14 +822,6 @@ function __wbg_get_imports() {
1089
822
  const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3));
1090
823
  return addHeapObject(ret);
1091
824
  }, arguments) };
1092
- imports.wbg.__wbg_bind_7d5ce7224bedd5b8 = function(arg0, arg1, arg2) {
1093
- const ret = getObject(arg0).bind(getObject(arg1), getObject(arg2));
1094
- return addHeapObject(ret);
1095
- };
1096
- imports.wbg.__wbg_bind_f5218b29220675c3 = function(arg0, arg1, arg2, arg3) {
1097
- const ret = getObject(arg0).bind(getObject(arg1), getObject(arg2), getObject(arg3));
1098
- return addHeapObject(ret);
1099
- };
1100
825
  imports.wbg.__wbg_forEach_942772130a8d06a6 = function(arg0, arg1, arg2) {
1101
826
  try {
1102
827
  var state0 = {a: arg1, b: arg2};
@@ -1104,7 +829,7 @@ function __wbg_get_imports() {
1104
829
  const a = state0.a;
1105
830
  state0.a = 0;
1106
831
  try {
1107
- return __wbg_adapter_171(a, state0.b, arg0, arg1);
832
+ return __wbg_adapter_93(a, state0.b, arg0, arg1);
1108
833
  } finally {
1109
834
  state0.a = a;
1110
835
  }
@@ -1118,28 +843,10 @@ function __wbg_get_imports() {
1118
843
  const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
1119
844
  return addHeapObject(ret);
1120
845
  };
1121
- imports.wbg.__wbg_instanceof_Object_a9e9e5766628e8b5 = function(arg0) {
1122
- let result;
1123
- try {
1124
- result = getObject(arg0) instanceof Object;
1125
- } catch {
1126
- result = false;
1127
- }
1128
- const ret = result;
1129
- return ret;
1130
- };
1131
- imports.wbg.__wbg_constructor_f2623999a1f453eb = function(arg0) {
1132
- const ret = getObject(arg0).constructor;
1133
- return addHeapObject(ret);
1134
- };
1135
846
  imports.wbg.__wbg_fromEntries_d1b310956d20d858 = function() { return handleError(function (arg0) {
1136
847
  const ret = Object.fromEntries(getObject(arg0));
1137
848
  return addHeapObject(ret);
1138
849
  }, arguments) };
1139
- imports.wbg.__wbg_toString_e2b23ac99490a381 = function(arg0) {
1140
- const ret = getObject(arg0).toString();
1141
- return addHeapObject(ret);
1142
- };
1143
850
  imports.wbg.__wbg_values_099fd000c271c313 = function(arg0) {
1144
851
  const ret = Object.values(getObject(arg0));
1145
852
  return addHeapObject(ret);
@@ -1151,7 +858,7 @@ function __wbg_get_imports() {
1151
858
  const a = state0.a;
1152
859
  state0.a = 0;
1153
860
  try {
1154
- return __wbg_adapter_171(a, state0.b, arg0, arg1);
861
+ return __wbg_adapter_93(a, state0.b, arg0, arg1);
1155
862
  } finally {
1156
863
  state0.a = a;
1157
864
  }
@@ -1174,99 +881,14 @@ function __wbg_get_imports() {
1174
881
  const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
1175
882
  return addHeapObject(ret);
1176
883
  };
1177
- imports.wbg.__wbg_buffer_55ba7a6b1b92e2ac = function(arg0) {
1178
- const ret = getObject(arg0).buffer;
1179
- return addHeapObject(ret);
1180
- };
1181
- imports.wbg.__wbg_newwithbyteoffsetandlength_88d1d8be5df94b9b = function(arg0, arg1, arg2) {
1182
- const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
1183
- return addHeapObject(ret);
1184
- };
1185
- imports.wbg.__wbg_new_09938a7d020f049b = function(arg0) {
1186
- const ret = new Uint8Array(getObject(arg0));
1187
- return addHeapObject(ret);
1188
- };
1189
- imports.wbg.__wbg_set_3698e3ca519b3c3c = function(arg0, arg1, arg2) {
1190
- getObject(arg0).set(getObject(arg1), arg2 >>> 0);
1191
- };
1192
- imports.wbg.__wbg_length_0aab7ffd65ad19ed = function(arg0) {
1193
- const ret = getObject(arg0).length;
1194
- return ret;
1195
- };
1196
- imports.wbg.__wbg_newwithlength_89eeca401d8918c2 = function(arg0) {
1197
- const ret = new Uint8Array(arg0 >>> 0);
1198
- return addHeapObject(ret);
1199
- };
1200
- imports.wbg.__wbg_subarray_d82be056deb4ad27 = function(arg0, arg1, arg2) {
1201
- const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
1202
- return addHeapObject(ret);
1203
- };
1204
884
  imports.wbg.__wbg_parse_76a8a18ca3f8730b = function() { return handleError(function (arg0, arg1) {
1205
885
  const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
1206
886
  return addHeapObject(ret);
1207
887
  }, arguments) };
1208
- imports.wbg.__wbg_compile_eefe73dfb19bff3d = function(arg0) {
1209
- const ret = WebAssembly.compile(getObject(arg0));
1210
- return addHeapObject(ret);
1211
- };
1212
- imports.wbg.__wbg_instantiate_e61ee50cd947cd36 = function(arg0, arg1) {
1213
- const ret = WebAssembly.instantiate(getObject(arg0), getObject(arg1));
1214
- return addHeapObject(ret);
1215
- };
1216
- imports.wbg.__wbg_exports_311291a1333429a3 = function(arg0) {
1217
- const ret = getObject(arg0).exports;
1218
- return addHeapObject(ret);
1219
- };
1220
- imports.wbg.__wbg_exports_12505982ae149cb0 = function(arg0) {
1221
- const ret = WebAssembly.Module.exports(getObject(arg0));
1222
- return addHeapObject(ret);
1223
- };
1224
- imports.wbg.__wbg_instanceof_Table_b0af5234a12a19f9 = function(arg0) {
1225
- let result;
1226
- try {
1227
- result = getObject(arg0) instanceof WebAssembly.Table;
1228
- } catch {
1229
- result = false;
1230
- }
1231
- const ret = result;
1232
- return ret;
1233
- };
1234
- imports.wbg.__wbg_get_b5def15f90c3e295 = function() { return handleError(function (arg0, arg1) {
1235
- const ret = getObject(arg0).get(arg1 >>> 0);
1236
- return addHeapObject(ret);
1237
- }, arguments) };
1238
- imports.wbg.__wbg_instanceof_Memory_331618ccd3fa615d = function(arg0) {
1239
- let result;
1240
- try {
1241
- result = getObject(arg0) instanceof WebAssembly.Memory;
1242
- } catch {
1243
- result = false;
1244
- }
1245
- const ret = result;
1246
- return ret;
1247
- };
1248
- imports.wbg.__wbg_new_e40873b83efb2dcd = function() { return handleError(function (arg0) {
1249
- const ret = new WebAssembly.Memory(getObject(arg0));
1250
- return addHeapObject(ret);
1251
- }, arguments) };
1252
- imports.wbg.__wbg_apply_46ea2bb0ad750196 = function() { return handleError(function (arg0, arg1, arg2) {
1253
- const ret = Reflect.apply(getObject(arg0), getObject(arg1), getObject(arg2));
1254
- return addHeapObject(ret);
1255
- }, arguments) };
1256
- imports.wbg.__wbg_getPrototypeOf_7dc7a2328db2bc0e = function() { return handleError(function (arg0) {
1257
- const ret = Reflect.getPrototypeOf(getObject(arg0));
1258
- return addHeapObject(ret);
1259
- }, arguments) };
1260
888
  imports.wbg.__wbg_set_07da13cc24b69217 = function() { return handleError(function (arg0, arg1, arg2) {
1261
889
  const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
1262
890
  return ret;
1263
891
  }, arguments) };
1264
- imports.wbg.__wbindgen_bigint_get_as_i64 = function(arg0, arg1) {
1265
- const v = getObject(arg1);
1266
- const ret = typeof(v) === 'bigint' ? v : undefined;
1267
- getBigInt64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? BigInt(0) : ret;
1268
- getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
1269
- };
1270
892
  imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
1271
893
  const ret = debugString(getObject(arg1));
1272
894
  const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -1277,16 +899,8 @@ function __wbg_get_imports() {
1277
899
  imports.wbg.__wbindgen_throw = function(arg0, arg1) {
1278
900
  throw new Error(getStringFromWasm0(arg0, arg1));
1279
901
  };
1280
- imports.wbg.__wbindgen_memory = function() {
1281
- const ret = wasm.memory;
1282
- return addHeapObject(ret);
1283
- };
1284
- imports.wbg.__wbindgen_function_table = function() {
1285
- const ret = wasm.__wbindgen_export_2;
1286
- return addHeapObject(ret);
1287
- };
1288
- imports.wbg.__wbindgen_closure_wrapper2147 = function(arg0, arg1, arg2) {
1289
- const ret = makeMutClosure(arg0, arg1, 720, __wbg_adapter_52);
902
+ imports.wbg.__wbindgen_closure_wrapper748 = function(arg0, arg1, arg2) {
903
+ const ret = makeMutClosure(arg0, arg1, 246, __wbg_adapter_22);
1290
904
  return addHeapObject(ret);
1291
905
  };
1292
906
 
@@ -1300,7 +914,6 @@ function __wbg_init_memory(imports, maybe_memory) {
1300
914
  function __wbg_finalize_init(instance, module) {
1301
915
  wasm = instance.exports;
1302
916
  __wbg_init.__wbindgen_wasm_module = module;
1303
- cachedBigInt64Memory0 = null;
1304
917
  cachedFloat64Memory0 = null;
1305
918
  cachedInt32Memory0 = null;
1306
919
  cachedUint8Memory0 = null;