@trust0/ridb-mongodb 0.0.7 → 0.0.10

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/build/index.mjs CHANGED
@@ -113,6 +113,13 @@ var require_ridb_core = __commonJS({
113
113
  dropObject(idx);
114
114
  return ret;
115
115
  }
116
+ function addHeapObject(obj) {
117
+ if (heap_next === heap.length) heap.push(heap.length + 1);
118
+ const idx = heap_next;
119
+ heap_next = heap[idx];
120
+ heap[idx] = obj;
121
+ return idx;
122
+ }
116
123
  var cachedTextDecoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-8", { ignoreBOM: true, fatal: true }) : { decode: () => {
117
124
  throw Error("TextDecoder not available");
118
125
  } };
@@ -130,13 +137,6 @@ var require_ridb_core = __commonJS({
130
137
  ptr = ptr >>> 0;
131
138
  return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
132
139
  }
133
- function addHeapObject(obj) {
134
- if (heap_next === heap.length) heap.push(heap.length + 1);
135
- const idx = heap_next;
136
- heap_next = heap[idx];
137
- heap[idx] = obj;
138
- return idx;
139
- }
140
140
  var WASM_VECTOR_LEN = 0;
141
141
  var cachedTextEncoder = typeof TextEncoder !== "undefined" ? new TextEncoder("utf-8") : { encode: () => {
142
142
  throw Error("TextEncoder not available");
@@ -288,7 +288,7 @@ ${val.stack}`;
288
288
  return real;
289
289
  }
290
290
  function __wbg_adapter_56(arg0, arg1, arg2) {
291
- wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hcf4fe6fd0b7ccc8d(arg0, arg1, addHeapObject(arg2));
291
+ wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__ha7bc4bff3dafa2ad(arg0, arg1, addHeapObject(arg2));
292
292
  }
293
293
  function makeClosure(arg0, arg1, dtor, f) {
294
294
  const state = { a: arg0, b: arg1, cnt: 1, dtor };
@@ -311,7 +311,7 @@ ${val.stack}`;
311
311
  function __wbg_adapter_59(arg0, arg1, arg2, arg3, arg4) {
312
312
  try {
313
313
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
314
- wasm._dyn_core__ops__function__Fn__A_B_C___Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__he6024291054ff5aa(retptr, arg0, arg1, addHeapObject(arg2), addHeapObject(arg3), addHeapObject(arg4));
314
+ wasm._dyn_core__ops__function__Fn__A_B_C___Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h804a1f09b692c771(retptr, arg0, arg1, addHeapObject(arg2), addHeapObject(arg3), addHeapObject(arg4));
315
315
  var r0 = getInt32Memory0()[retptr / 4 + 0];
316
316
  var r1 = getInt32Memory0()[retptr / 4 + 1];
317
317
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -324,7 +324,13 @@ ${val.stack}`;
324
324
  }
325
325
  }
326
326
  function __wbg_adapter_62(arg0, arg1, arg2) {
327
- wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hb6eb1f8e3b5e56e9(arg0, arg1, addHeapObject(arg2));
327
+ wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hd4647cb021495324(arg0, arg1, addHeapObject(arg2));
328
+ }
329
+ var stack_pointer = 128;
330
+ function addBorrowedObject(obj) {
331
+ if (stack_pointer == 1) throw new Error("out of js stack");
332
+ heap[--stack_pointer] = obj;
333
+ return stack_pointer;
328
334
  }
329
335
  var cachedUint32Memory0 = null;
330
336
  function getUint32Memory0() {
@@ -349,26 +355,6 @@ ${val.stack}`;
349
355
  }
350
356
  return instance.ptr;
351
357
  }
352
- var stack_pointer = 128;
353
- function addBorrowedObject(obj) {
354
- if (stack_pointer == 1) throw new Error("out of js stack");
355
- heap[--stack_pointer] = obj;
356
- return stack_pointer;
357
- }
358
- function main_js() {
359
- wasm.main_js();
360
- }
361
- function is_debug_mode() {
362
- const ret = wasm.is_debug_mode();
363
- return ret !== 0;
364
- }
365
- function handleError(f, args) {
366
- try {
367
- return f.apply(this, args);
368
- } catch (e) {
369
- wasm.__wbindgen_exn_store(addHeapObject(e));
370
- }
371
- }
372
358
  function passArrayJsValueToWasm0(array, malloc) {
373
359
  const ptr = malloc(array.length * 4, 4) >>> 0;
374
360
  const mem = getUint32Memory0();
@@ -378,30 +364,47 @@ ${val.stack}`;
378
364
  WASM_VECTOR_LEN = array.length;
379
365
  return ptr;
380
366
  }
381
- function __wbgtest_console_log(args) {
367
+ function handleError(f, args) {
382
368
  try {
383
- wasm.__wbgtest_console_log(addBorrowedObject(args));
369
+ return f.apply(this, args);
370
+ } catch (e) {
371
+ wasm.__wbindgen_exn_store(addHeapObject(e));
372
+ }
373
+ }
374
+ function is_debug_mode() {
375
+ const ret = wasm.is_debug_mode();
376
+ return ret !== 0;
377
+ }
378
+ function main_js() {
379
+ wasm.main_js();
380
+ }
381
+ function __wbgtest_console_info(args) {
382
+ try {
383
+ wasm.__wbgtest_console_info(addBorrowedObject(args));
384
384
  } finally {
385
385
  heap[stack_pointer++] = void 0;
386
386
  }
387
387
  }
388
- function __wbgtest_console_debug(args) {
388
+ function __wbgtest_console_warn(args) {
389
389
  try {
390
- wasm.__wbgtest_console_debug(addBorrowedObject(args));
390
+ wasm.__wbgtest_console_warn(addBorrowedObject(args));
391
391
  } finally {
392
392
  heap[stack_pointer++] = void 0;
393
393
  }
394
394
  }
395
- function __wbgtest_console_info(args) {
395
+ function __wbg_adapter_287(arg0, arg1) {
396
+ wasm.wasm_bindgen__convert__closures__invoke0_mut__hc6452fdbb8c4addc(arg0, arg1);
397
+ }
398
+ function __wbgtest_console_debug(args) {
396
399
  try {
397
- wasm.__wbgtest_console_info(addBorrowedObject(args));
400
+ wasm.__wbgtest_console_debug(addBorrowedObject(args));
398
401
  } finally {
399
402
  heap[stack_pointer++] = void 0;
400
403
  }
401
404
  }
402
- function __wbgtest_console_warn(args) {
405
+ function __wbgtest_console_log(args) {
403
406
  try {
404
- wasm.__wbgtest_console_warn(addBorrowedObject(args));
407
+ wasm.__wbgtest_console_log(addBorrowedObject(args));
405
408
  } finally {
406
409
  heap[stack_pointer++] = void 0;
407
410
  }
@@ -413,14 +416,11 @@ ${val.stack}`;
413
416
  heap[stack_pointer++] = void 0;
414
417
  }
415
418
  }
416
- function __wbg_adapter_304(arg0, arg1) {
417
- wasm.wasm_bindgen__convert__closures__invoke0_mut__hff00333f3d941090(arg0, arg1);
418
- }
419
- function __wbg_adapter_347(arg0, arg1, arg2, arg3, arg4) {
420
- wasm.wasm_bindgen__convert__closures__invoke3_mut__h703f9c33fd3008bf(arg0, arg1, addHeapObject(arg2), arg3, addHeapObject(arg4));
419
+ function __wbg_adapter_378(arg0, arg1, arg2, arg3, arg4) {
420
+ wasm.wasm_bindgen__convert__closures__invoke3_mut__h2f203dbfa61ca113(arg0, arg1, addHeapObject(arg2), arg3, addHeapObject(arg4));
421
421
  }
422
- function __wbg_adapter_404(arg0, arg1, arg2, arg3) {
423
- wasm.wasm_bindgen__convert__closures__invoke2_mut__h97988f5fa0547d24(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
422
+ function __wbg_adapter_395(arg0, arg1, arg2, arg3) {
423
+ wasm.wasm_bindgen__convert__closures__invoke2_mut__h42aa995f02b6fdcb(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
424
424
  }
425
425
  var OpType2 = Object.freeze({
426
426
  /**
@@ -465,6 +465,32 @@ ${val.stack}`;
465
465
  wasm.__wbg_baseplugin_free(ptr);
466
466
  }
467
467
  /**
468
+ * @returns {any}
469
+ */
470
+ get docCreateHook() {
471
+ const ret = wasm.baseplugin_get_doc_create_hook(this.__wbg_ptr);
472
+ return takeObject(ret);
473
+ }
474
+ /**
475
+ * @param {any} hook
476
+ */
477
+ set docCreateHook(hook) {
478
+ wasm.baseplugin_set_doc_create_hook(this.__wbg_ptr, addHeapObject(hook));
479
+ }
480
+ /**
481
+ * @returns {any}
482
+ */
483
+ get docRecoverHook() {
484
+ const ret = wasm.baseplugin_get_doc_recover_hook(this.__wbg_ptr);
485
+ return takeObject(ret);
486
+ }
487
+ /**
488
+ * @param {any} hook
489
+ */
490
+ set docRecoverHook(hook) {
491
+ wasm.baseplugin_set_doc_recover_hook(this.__wbg_ptr, addHeapObject(hook));
492
+ }
493
+ /**
468
494
  * @param {string} name
469
495
  */
470
496
  constructor(name) {
@@ -492,32 +518,6 @@ ${val.stack}`;
492
518
  const ret = wasm.baseplugin_name(this.__wbg_ptr);
493
519
  return takeObject(ret);
494
520
  }
495
- /**
496
- * @returns {any}
497
- */
498
- get docCreateHook() {
499
- const ret = wasm.baseplugin_get_doc_create_hook(this.__wbg_ptr);
500
- return takeObject(ret);
501
- }
502
- /**
503
- * @returns {any}
504
- */
505
- get docRecoverHook() {
506
- const ret = wasm.baseplugin_get_doc_recover_hook(this.__wbg_ptr);
507
- return takeObject(ret);
508
- }
509
- /**
510
- * @param {any} hook
511
- */
512
- set docCreateHook(hook) {
513
- wasm.baseplugin_set_doc_create_hook(this.__wbg_ptr, addHeapObject(hook));
514
- }
515
- /**
516
- * @param {any} hook
517
- */
518
- set docRecoverHook(hook) {
519
- wasm.baseplugin_set_doc_recover_hook(this.__wbg_ptr, addHeapObject(hook));
520
- }
521
521
  };
522
522
  var BaseStorageFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
523
523
  }, unregister: () => {
@@ -534,66 +534,54 @@ ${val.stack}`;
534
534
  wasm.__wbg_basestorage_free(ptr);
535
535
  }
536
536
  /**
537
- * Creates a new `BaseStorage` instance with the provided name and schema type.
538
- *
539
- * # Arguments
540
- *
541
- * * `name` - The name of the storage.
542
- * * `schema_type` - The schema type in `JsValue` format.
543
- *
544
- * # Returns
545
- *
546
- * * `Result<BaseStorage, JsValue>` - A result containing the new `BaseStorage` instance or an error.
547
537
  * @param {string} name
548
- * @param {object} schemas_js
549
- * @param {object | undefined} [options]
538
+ * @returns {any}
550
539
  */
551
- constructor(name, schemas_js, options) {
540
+ getOption(name) {
552
541
  try {
553
542
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
554
543
  const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
555
544
  const len0 = WASM_VECTOR_LEN;
556
- wasm.basestorage_new(retptr, ptr0, len0, addHeapObject(schemas_js), isLikeNone(options) ? 0 : addHeapObject(options));
545
+ wasm.basestorage_getOption(retptr, this.__wbg_ptr, ptr0, len0);
557
546
  var r0 = getInt32Memory0()[retptr / 4 + 0];
558
547
  var r1 = getInt32Memory0()[retptr / 4 + 1];
559
548
  var r2 = getInt32Memory0()[retptr / 4 + 2];
560
549
  if (r2) {
561
550
  throw takeObject(r1);
562
551
  }
563
- this.__wbg_ptr = r0 >>> 0;
564
- return this;
552
+ return takeObject(r0);
565
553
  } finally {
566
554
  wasm.__wbindgen_add_to_stack_pointer(16);
567
555
  }
568
556
  }
569
557
  /**
570
- * @returns {any}
558
+ * @param {string} name
559
+ * @returns {Schema}
571
560
  */
572
- addIndexSchemas() {
561
+ getSchema(name) {
573
562
  try {
574
563
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
575
- wasm.basestorage_addIndexSchemas(retptr, this.__wbg_ptr);
564
+ const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
565
+ const len0 = WASM_VECTOR_LEN;
566
+ wasm.basestorage_getSchema(retptr, this.__wbg_ptr, ptr0, len0);
576
567
  var r0 = getInt32Memory0()[retptr / 4 + 0];
577
568
  var r1 = getInt32Memory0()[retptr / 4 + 1];
578
569
  var r2 = getInt32Memory0()[retptr / 4 + 2];
579
570
  if (r2) {
580
571
  throw takeObject(r1);
581
572
  }
582
- return takeObject(r0);
573
+ return Schema.__wrap(r0);
583
574
  } finally {
584
575
  wasm.__wbindgen_add_to_stack_pointer(16);
585
576
  }
586
577
  }
587
578
  /**
588
- * @param {string} name
589
579
  * @returns {any}
590
580
  */
591
- getOption(name) {
581
+ addIndexSchemas() {
592
582
  try {
593
583
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
594
- const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
595
- const len0 = WASM_VECTOR_LEN;
596
- wasm.basestorage_getOption(retptr, this.__wbg_ptr, ptr0, len0);
584
+ wasm.basestorage_addIndexSchemas(retptr, this.__wbg_ptr);
597
585
  var r0 = getInt32Memory0()[retptr / 4 + 0];
598
586
  var r1 = getInt32Memory0()[retptr / 4 + 1];
599
587
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -606,22 +594,34 @@ ${val.stack}`;
606
594
  }
607
595
  }
608
596
  /**
597
+ * Creates a new `BaseStorage` instance with the provided name and schema type.
598
+ *
599
+ * # Arguments
600
+ *
601
+ * * `name` - The name of the storage.
602
+ * * `schema_type` - The schema type in `JsValue` format.
603
+ *
604
+ * # Returns
605
+ *
606
+ * * `Result<BaseStorage, JsValue>` - A result containing the new `BaseStorage` instance or an error.
609
607
  * @param {string} name
610
- * @returns {Schema}
608
+ * @param {object} schemas_js
609
+ * @param {object | undefined} [options]
611
610
  */
612
- getSchema(name) {
611
+ constructor(name, schemas_js, options) {
613
612
  try {
614
613
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
615
614
  const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
616
615
  const len0 = WASM_VECTOR_LEN;
617
- wasm.basestorage_getSchema(retptr, this.__wbg_ptr, ptr0, len0);
616
+ wasm.basestorage_new(retptr, ptr0, len0, addHeapObject(schemas_js), isLikeNone(options) ? 0 : addHeapObject(options));
618
617
  var r0 = getInt32Memory0()[retptr / 4 + 0];
619
618
  var r1 = getInt32Memory0()[retptr / 4 + 1];
620
619
  var r2 = getInt32Memory0()[retptr / 4 + 2];
621
620
  if (r2) {
622
621
  throw takeObject(r1);
623
622
  }
624
- return Schema.__wrap(r0);
623
+ this.__wbg_ptr = r0 >>> 0;
624
+ return this;
625
625
  } finally {
626
626
  wasm.__wbindgen_add_to_stack_pointer(16);
627
627
  }
@@ -667,38 +667,31 @@ ${val.stack}`;
667
667
  wasm.__wbg_collection_free(ptr);
668
668
  }
669
669
  /**
670
- * @returns {string}
670
+ * Finds and returns a single document in the collection by its ID.
671
+ *
672
+ * This function is asynchronous.
673
+ * @param {any} primary_key
674
+ * @returns {Promise<any>}
671
675
  */
672
- get name() {
673
- let deferred1_0;
674
- let deferred1_1;
675
- try {
676
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
677
- wasm.collection_name(retptr, this.__wbg_ptr);
678
- var r0 = getInt32Memory0()[retptr / 4 + 0];
679
- var r1 = getInt32Memory0()[retptr / 4 + 1];
680
- deferred1_0 = r0;
681
- deferred1_1 = r1;
682
- return getStringFromWasm0(r0, r1);
683
- } finally {
684
- wasm.__wbindgen_add_to_stack_pointer(16);
685
- wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
686
- }
676
+ findById(primary_key) {
677
+ const ret = wasm.collection_findById(this.__wbg_ptr, addHeapObject(primary_key));
678
+ return takeObject(ret);
687
679
  }
688
680
  /**
689
- * @returns {Schema}
681
+ * @param {any} options
682
+ * @returns {QueryOptions}
690
683
  */
691
- get schema() {
684
+ parse_query_options(options) {
692
685
  try {
693
686
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
694
- wasm.collection_schema(retptr, this.__wbg_ptr);
687
+ wasm.collection_parse_query_options(retptr, this.__wbg_ptr, addHeapObject(options));
695
688
  var r0 = getInt32Memory0()[retptr / 4 + 0];
696
689
  var r1 = getInt32Memory0()[retptr / 4 + 1];
697
690
  var r2 = getInt32Memory0()[retptr / 4 + 2];
698
691
  if (r2) {
699
692
  throw takeObject(r1);
700
693
  }
701
- return Schema.__wrap(r0);
694
+ return QueryOptions.__wrap(r0);
702
695
  } finally {
703
696
  wasm.__wbindgen_add_to_stack_pointer(16);
704
697
  }
@@ -717,22 +710,22 @@ ${val.stack}`;
717
710
  return takeObject(ret);
718
711
  }
719
712
  /**
720
- * @param {any} options
721
- * @returns {QueryOptions}
713
+ * @returns {string}
722
714
  */
723
- parse_query_options(options) {
715
+ get name() {
716
+ let deferred1_0;
717
+ let deferred1_1;
724
718
  try {
725
719
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
726
- wasm.collection_parse_query_options(retptr, this.__wbg_ptr, addHeapObject(options));
720
+ wasm.collection_name(retptr, this.__wbg_ptr);
727
721
  var r0 = getInt32Memory0()[retptr / 4 + 0];
728
722
  var r1 = getInt32Memory0()[retptr / 4 + 1];
729
- var r2 = getInt32Memory0()[retptr / 4 + 2];
730
- if (r2) {
731
- throw takeObject(r1);
732
- }
733
- return QueryOptions.__wrap(r0);
723
+ deferred1_0 = r0;
724
+ deferred1_1 = r1;
725
+ return getStringFromWasm0(r0, r1);
734
726
  } finally {
735
727
  wasm.__wbindgen_add_to_stack_pointer(16);
728
+ wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
736
729
  }
737
730
  }
738
731
  /**
@@ -749,55 +742,62 @@ ${val.stack}`;
749
742
  return takeObject(ret);
750
743
  }
751
744
  /**
752
- * Finds and returns a single document in the collection by its ID.
753
- *
754
- * This function is asynchronous.
755
- * @param {any} primary_key
756
- * @returns {Promise<any>}
757
- */
758
- findById(primary_key) {
759
- const ret = wasm.collection_findById(this.__wbg_ptr, addHeapObject(primary_key));
760
- return takeObject(ret);
761
- }
762
- /**
763
- * Updates a document in the collection with the given data.
745
+ * Creates a new document in the collection.
764
746
  *
765
747
  * This function is asynchronous and returns a `Result` indicating success or failure.
766
748
  *
767
749
  * # Arguments
768
750
  *
769
- * * `document` - A `JsValue` representing the partial document to update.
751
+ * * `document` - A `JsValue` representing the document to create.
770
752
  * @param {any} document
771
753
  * @returns {Promise<any>}
772
754
  */
773
- update(document2) {
774
- const ret = wasm.collection_update(this.__wbg_ptr, addHeapObject(document2));
755
+ create(document2) {
756
+ const ret = wasm.collection_create(this.__wbg_ptr, addHeapObject(document2));
775
757
  return takeObject(ret);
776
758
  }
777
759
  /**
778
- * Creates a new document in the collection.
779
- *
780
- * This function is asynchronous and returns a `Result` indicating success or failure.
760
+ * Deletes a document from the collection by its ID.
781
761
  *
782
- * # Arguments
783
- *
784
- * * `document` - A `JsValue` representing the document to create.
785
- * @param {any} document
762
+ * This function is asynchronous.
763
+ * @param {any} primary_key
786
764
  * @returns {Promise<any>}
787
765
  */
788
- create(document2) {
789
- const ret = wasm.collection_create(this.__wbg_ptr, addHeapObject(document2));
766
+ delete(primary_key) {
767
+ const ret = wasm.collection_delete(this.__wbg_ptr, addHeapObject(primary_key));
790
768
  return takeObject(ret);
791
769
  }
792
770
  /**
793
- * Deletes a document from the collection by its ID.
771
+ * @returns {Schema}
772
+ */
773
+ get schema() {
774
+ try {
775
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
776
+ wasm.collection_schema(retptr, this.__wbg_ptr);
777
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
778
+ var r1 = getInt32Memory0()[retptr / 4 + 1];
779
+ var r2 = getInt32Memory0()[retptr / 4 + 2];
780
+ if (r2) {
781
+ throw takeObject(r1);
782
+ }
783
+ return Schema.__wrap(r0);
784
+ } finally {
785
+ wasm.__wbindgen_add_to_stack_pointer(16);
786
+ }
787
+ }
788
+ /**
789
+ * Updates a document in the collection with the given data.
794
790
  *
795
- * This function is asynchronous.
796
- * @param {any} primary_key
791
+ * This function is asynchronous and returns a `Result` indicating success or failure.
792
+ *
793
+ * # Arguments
794
+ *
795
+ * * `document` - A `JsValue` representing the partial document to update.
796
+ * @param {any} document
797
797
  * @returns {Promise<any>}
798
798
  */
799
- delete(primary_key) {
800
- const ret = wasm.collection_delete(this.__wbg_ptr, addHeapObject(primary_key));
799
+ update(document2) {
800
+ const ret = wasm.collection_update(this.__wbg_ptr, addHeapObject(document2));
801
801
  return takeObject(ret);
802
802
  }
803
803
  };
@@ -823,11 +823,29 @@ ${val.stack}`;
823
823
  wasm.__wbg_corestorage_free(ptr);
824
824
  }
825
825
  /**
826
+ * @param {Schema} schema
827
+ * @param {Operation} op
828
+ * @returns {(string)[]}
826
829
  */
827
- constructor() {
828
- const ret = wasm.corestorage_new();
829
- this.__wbg_ptr = ret >>> 0;
830
- return this;
830
+ getIndexes(schema, op) {
831
+ try {
832
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
833
+ _assertClass(schema, Schema);
834
+ _assertClass(op, Operation);
835
+ wasm.corestorage_getIndexes(retptr, this.__wbg_ptr, schema.__wbg_ptr, op.__wbg_ptr);
836
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
837
+ var r1 = getInt32Memory0()[retptr / 4 + 1];
838
+ var r2 = getInt32Memory0()[retptr / 4 + 2];
839
+ var r3 = getInt32Memory0()[retptr / 4 + 3];
840
+ if (r3) {
841
+ throw takeObject(r2);
842
+ }
843
+ var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
844
+ wasm.__wbindgen_free(r0, r1 * 4, 4);
845
+ return v1;
846
+ } finally {
847
+ wasm.__wbindgen_add_to_stack_pointer(16);
848
+ }
831
849
  }
832
850
  /**
833
851
  * @param {any} value
@@ -859,31 +877,6 @@ ${val.stack}`;
859
877
  }
860
878
  }
861
879
  /**
862
- * @param {Schema} schema
863
- * @param {Operation} op
864
- * @returns {(string)[]}
865
- */
866
- getIndexes(schema, op) {
867
- try {
868
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
869
- _assertClass(schema, Schema);
870
- _assertClass(op, Operation);
871
- wasm.corestorage_getIndexes(retptr, this.__wbg_ptr, schema.__wbg_ptr, op.__wbg_ptr);
872
- var r0 = getInt32Memory0()[retptr / 4 + 0];
873
- var r1 = getInt32Memory0()[retptr / 4 + 1];
874
- var r2 = getInt32Memory0()[retptr / 4 + 2];
875
- var r3 = getInt32Memory0()[retptr / 4 + 3];
876
- if (r3) {
877
- throw takeObject(r2);
878
- }
879
- var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
880
- wasm.__wbindgen_free(r0, r1 * 4, 4);
881
- return v1;
882
- } finally {
883
- wasm.__wbindgen_add_to_stack_pointer(16);
884
- }
885
- }
886
- /**
887
880
  * @param {any} document
888
881
  * @param {Query} query
889
882
  * @returns {boolean}
@@ -905,6 +898,13 @@ ${val.stack}`;
905
898
  heap[stack_pointer++] = void 0;
906
899
  }
907
900
  }
901
+ /**
902
+ */
903
+ constructor() {
904
+ const ret = wasm.corestorage_new();
905
+ this.__wbg_ptr = ret >>> 0;
906
+ return this;
907
+ }
908
908
  };
909
909
  var DatabaseFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
910
910
  }, unregister: () => {
@@ -928,38 +928,6 @@ ${val.stack}`;
928
928
  wasm.__wbg_database_free(ptr);
929
929
  }
930
930
  /**
931
- * @returns {Promise<any>}
932
- */
933
- start() {
934
- const ret = wasm.database_start(this.__wbg_ptr);
935
- return takeObject(ret);
936
- }
937
- /**
938
- * @returns {Promise<any>}
939
- */
940
- close() {
941
- const ptr = this.__destroy_into_raw();
942
- const ret = wasm.database_close(ptr);
943
- return takeObject(ret);
944
- }
945
- /**
946
- * @returns {boolean}
947
- */
948
- get started() {
949
- const ret = wasm.database_started(this.__wbg_ptr);
950
- return ret !== 0;
951
- }
952
- /**
953
- * @param {string} password
954
- * @returns {Promise<boolean>}
955
- */
956
- authenticate(password) {
957
- const ptr0 = passStringToWasm0(password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
958
- const len0 = WASM_VECTOR_LEN;
959
- const ret = wasm.database_authenticate(this.__wbg_ptr, ptr0, len0);
960
- return takeObject(ret);
961
- }
962
- /**
963
931
  * Retrieves the collections in the database.
964
932
  *
965
933
  * This function returns an `Object` containing the collections.
@@ -985,6 +953,31 @@ ${val.stack}`;
985
953
  }
986
954
  }
987
955
  /**
956
+ * @param {string} password
957
+ * @returns {Promise<boolean>}
958
+ */
959
+ authenticate(password) {
960
+ const ptr0 = passStringToWasm0(password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
961
+ const len0 = WASM_VECTOR_LEN;
962
+ const ret = wasm.database_authenticate(this.__wbg_ptr, ptr0, len0);
963
+ return takeObject(ret);
964
+ }
965
+ /**
966
+ * @returns {Promise<any>}
967
+ */
968
+ close() {
969
+ const ptr = this.__destroy_into_raw();
970
+ const ret = wasm.database_close(ptr);
971
+ return takeObject(ret);
972
+ }
973
+ /**
974
+ * @returns {Promise<any>}
975
+ */
976
+ start() {
977
+ const ret = wasm.database_start(this.__wbg_ptr);
978
+ return takeObject(ret);
979
+ }
980
+ /**
988
981
  * @param {string} db_name
989
982
  * @param {object} schemas_js
990
983
  * @param {object} migrations_js
@@ -1002,6 +995,13 @@ ${val.stack}`;
1002
995
  const ret = wasm.database_create(ptr0, len0, addHeapObject(schemas_js), addHeapObject(migrations_js), addHeapObject(plugins), addHeapObject(module2), ptr1, len1, isLikeNone(storage) ? 0 : addHeapObject(storage));
1003
996
  return takeObject(ret);
1004
997
  }
998
+ /**
999
+ * @returns {boolean}
1000
+ */
1001
+ get started() {
1002
+ const ret = wasm.database_started(this.__wbg_ptr);
1003
+ return ret !== 0;
1004
+ }
1005
1005
  };
1006
1006
  var InMemoryFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
1007
1007
  }, unregister: () => {
@@ -1025,6 +1025,17 @@ ${val.stack}`;
1025
1025
  wasm.__wbg_inmemory_free(ptr);
1026
1026
  }
1027
1027
  /**
1028
+ * @param {string} collection_name
1029
+ * @param {any} primary_key
1030
+ * @returns {Promise<any>}
1031
+ */
1032
+ findDocumentById(collection_name, primary_key) {
1033
+ const ptr0 = passStringToWasm0(collection_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1034
+ const len0 = WASM_VECTOR_LEN;
1035
+ const ret = wasm.inmemory_findDocumentById(this.__wbg_ptr, ptr0, len0, addHeapObject(primary_key));
1036
+ return takeObject(ret);
1037
+ }
1038
+ /**
1028
1039
  * @param {string} name
1029
1040
  * @param {object} schemas_js
1030
1041
  * @returns {Promise<InMemory>}
@@ -1036,16 +1047,6 @@ ${val.stack}`;
1036
1047
  return takeObject(ret);
1037
1048
  }
1038
1049
  /**
1039
- * @param {Operation} op
1040
- * @returns {Promise<any>}
1041
- */
1042
- write(op) {
1043
- _assertClass(op, Operation);
1044
- var ptr0 = op.__destroy_into_raw();
1045
- const ret = wasm.inmemory_write(this.__wbg_ptr, ptr0);
1046
- return takeObject(ret);
1047
- }
1048
- /**
1049
1050
  * @param {string} collection_name
1050
1051
  * @param {any} query_js
1051
1052
  * @param {QueryOptions} options
@@ -1060,14 +1061,10 @@ ${val.stack}`;
1060
1061
  return takeObject(ret);
1061
1062
  }
1062
1063
  /**
1063
- * @param {string} collection_name
1064
- * @param {any} primary_key
1065
1064
  * @returns {Promise<any>}
1066
1065
  */
1067
- findDocumentById(collection_name, primary_key) {
1068
- const ptr0 = passStringToWasm0(collection_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1069
- const len0 = WASM_VECTOR_LEN;
1070
- const ret = wasm.inmemory_findDocumentById(this.__wbg_ptr, ptr0, len0, addHeapObject(primary_key));
1066
+ close() {
1067
+ const ret = wasm.inmemory_close(this.__wbg_ptr);
1071
1068
  return takeObject(ret);
1072
1069
  }
1073
1070
  /**
@@ -1087,15 +1084,18 @@ ${val.stack}`;
1087
1084
  /**
1088
1085
  * @returns {Promise<any>}
1089
1086
  */
1090
- close() {
1091
- const ret = wasm.inmemory_close(this.__wbg_ptr);
1087
+ start() {
1088
+ const ret = wasm.inmemory_start(this.__wbg_ptr);
1092
1089
  return takeObject(ret);
1093
1090
  }
1094
1091
  /**
1092
+ * @param {Operation} op
1095
1093
  * @returns {Promise<any>}
1096
1094
  */
1097
- start() {
1098
- const ret = wasm.inmemory_start(this.__wbg_ptr);
1095
+ write(op) {
1096
+ _assertClass(op, Operation);
1097
+ var ptr0 = op.__destroy_into_raw();
1098
+ const ret = wasm.inmemory_write(this.__wbg_ptr, ptr0);
1099
1099
  return takeObject(ret);
1100
1100
  }
1101
1101
  };
@@ -1142,12 +1142,12 @@ ${val.stack}`;
1142
1142
  * @param {string} store_name
1143
1143
  * @returns {IDBObjectStore}
1144
1144
  */
1145
- get_store(store_name) {
1145
+ get_store_readonly(store_name) {
1146
1146
  try {
1147
1147
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1148
1148
  const ptr0 = passStringToWasm0(store_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1149
1149
  const len0 = WASM_VECTOR_LEN;
1150
- wasm.indexdb_get_store(retptr, this.__wbg_ptr, ptr0, len0);
1150
+ wasm.indexdb_get_store_readonly(retptr, this.__wbg_ptr, ptr0, len0);
1151
1151
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1152
1152
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1153
1153
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1160,6 +1160,17 @@ ${val.stack}`;
1160
1160
  }
1161
1161
  }
1162
1162
  /**
1163
+ * @param {string} collection_name
1164
+ * @param {any} primary_key
1165
+ * @returns {Promise<any>}
1166
+ */
1167
+ findDocumentById(collection_name, primary_key) {
1168
+ const ptr0 = passStringToWasm0(collection_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1169
+ const len0 = WASM_VECTOR_LEN;
1170
+ const ret = wasm.indexdb_findDocumentById(this.__wbg_ptr, ptr0, len0, addHeapObject(primary_key));
1171
+ return takeObject(ret);
1172
+ }
1173
+ /**
1163
1174
  * @param {string} name
1164
1175
  * @param {object} schemas_js
1165
1176
  * @returns {Promise<IndexDB>}
@@ -1171,16 +1182,6 @@ ${val.stack}`;
1171
1182
  return takeObject(ret);
1172
1183
  }
1173
1184
  /**
1174
- * @param {Operation} op
1175
- * @returns {Promise<any>}
1176
- */
1177
- write(op) {
1178
- _assertClass(op, Operation);
1179
- var ptr0 = op.__destroy_into_raw();
1180
- const ret = wasm.indexdb_write(this.__wbg_ptr, ptr0);
1181
- return takeObject(ret);
1182
- }
1183
- /**
1184
1185
  * @param {string} collection_name
1185
1186
  * @param {any} query
1186
1187
  * @param {QueryOptions} options
@@ -1195,14 +1196,10 @@ ${val.stack}`;
1195
1196
  return takeObject(ret);
1196
1197
  }
1197
1198
  /**
1198
- * @param {string} collection_name
1199
- * @param {any} primary_key
1200
1199
  * @returns {Promise<any>}
1201
1200
  */
1202
- findDocumentById(collection_name, primary_key) {
1203
- const ptr0 = passStringToWasm0(collection_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1204
- const len0 = WASM_VECTOR_LEN;
1205
- const ret = wasm.indexdb_findDocumentById(this.__wbg_ptr, ptr0, len0, addHeapObject(primary_key));
1201
+ close() {
1202
+ const ret = wasm.indexdb_close(this.__wbg_ptr);
1206
1203
  return takeObject(ret);
1207
1204
  }
1208
1205
  /**
@@ -1222,27 +1219,51 @@ ${val.stack}`;
1222
1219
  /**
1223
1220
  * @returns {Promise<any>}
1224
1221
  */
1225
- close() {
1226
- const ret = wasm.indexdb_close(this.__wbg_ptr);
1222
+ start() {
1223
+ const ret = wasm.indexdb_start(this.__wbg_ptr);
1227
1224
  return takeObject(ret);
1228
1225
  }
1229
1226
  /**
1227
+ * @param {Operation} op
1230
1228
  * @returns {Promise<any>}
1231
1229
  */
1232
- start() {
1233
- const ret = wasm.indexdb_start(this.__wbg_ptr);
1230
+ write(op) {
1231
+ _assertClass(op, Operation);
1232
+ var ptr0 = op.__destroy_into_raw();
1233
+ const ret = wasm.indexdb_write(this.__wbg_ptr, ptr0);
1234
1234
  return takeObject(ret);
1235
1235
  }
1236
- };
1237
- var OperationFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
1238
- }, unregister: () => {
1239
- } } : new FinalizationRegistry((ptr) => wasm.__wbg_operation_free(ptr >>> 0));
1240
- var Operation = class _Operation {
1241
- static __wrap(ptr) {
1242
- ptr = ptr >>> 0;
1243
- const obj = Object.create(_Operation.prototype);
1244
- obj.__wbg_ptr = ptr;
1245
- OperationFinalization.register(obj, obj.__wbg_ptr, obj);
1236
+ /**
1237
+ * @param {string} store_name
1238
+ * @returns {IDBObjectStore}
1239
+ */
1240
+ get_store(store_name) {
1241
+ try {
1242
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1243
+ const ptr0 = passStringToWasm0(store_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1244
+ const len0 = WASM_VECTOR_LEN;
1245
+ wasm.indexdb_get_store(retptr, this.__wbg_ptr, ptr0, len0);
1246
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
1247
+ var r1 = getInt32Memory0()[retptr / 4 + 1];
1248
+ var r2 = getInt32Memory0()[retptr / 4 + 2];
1249
+ if (r2) {
1250
+ throw takeObject(r1);
1251
+ }
1252
+ return takeObject(r0);
1253
+ } finally {
1254
+ wasm.__wbindgen_add_to_stack_pointer(16);
1255
+ }
1256
+ }
1257
+ };
1258
+ var OperationFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
1259
+ }, unregister: () => {
1260
+ } } : new FinalizationRegistry((ptr) => wasm.__wbg_operation_free(ptr >>> 0));
1261
+ var Operation = class _Operation {
1262
+ static __wrap(ptr) {
1263
+ ptr = ptr >>> 0;
1264
+ const obj = Object.create(_Operation.prototype);
1265
+ obj.__wbg_ptr = ptr;
1266
+ OperationFinalization.register(obj, obj.__wbg_ptr, obj);
1246
1267
  return obj;
1247
1268
  }
1248
1269
  __destroy_into_raw() {
@@ -1280,27 +1301,15 @@ ${val.stack}`;
1280
1301
  }
1281
1302
  }
1282
1303
  /**
1283
- * Retrieves the type of operation.
1284
- *
1285
- * # Returns
1286
- *
1287
- * * `OpType` - The type of operation.
1288
- * @returns {OpType}
1289
- */
1290
- get opType() {
1291
- const ret = wasm.operation_opType(this.__wbg_ptr);
1292
- return ret;
1293
- }
1294
- /**
1295
- * Retrieves the data involved in the operation.
1304
+ * Retrieves the primary key value of the current data.
1296
1305
  *
1297
1306
  * # Returns
1298
1307
  *
1299
- * * `JsValue` - The data involved in the operation.
1308
+ * * `Option<JsValue>` - The primary key value of the current data.
1300
1309
  * @returns {any}
1301
1310
  */
1302
- get data() {
1303
- const ret = wasm.operation_data(this.__wbg_ptr);
1311
+ get primaryKey() {
1312
+ const ret = wasm.operation_primaryKey(this.__wbg_ptr);
1304
1313
  return takeObject(ret);
1305
1314
  }
1306
1315
  /**
@@ -1316,18 +1325,6 @@ ${val.stack}`;
1316
1325
  return takeObject(ret);
1317
1326
  }
1318
1327
  /**
1319
- * Retrieves the primary key value of the current data.
1320
- *
1321
- * # Returns
1322
- *
1323
- * * `Option<JsValue>` - The primary key value of the current data.
1324
- * @returns {any}
1325
- */
1326
- get primaryKey() {
1327
- const ret = wasm.operation_primaryKey(this.__wbg_ptr);
1328
- return takeObject(ret);
1329
- }
1330
- /**
1331
1328
  * @returns {string}
1332
1329
  */
1333
1330
  get primaryKeyIndex() {
@@ -1355,6 +1352,30 @@ ${val.stack}`;
1355
1352
  wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
1356
1353
  }
1357
1354
  }
1355
+ /**
1356
+ * Retrieves the data involved in the operation.
1357
+ *
1358
+ * # Returns
1359
+ *
1360
+ * * `JsValue` - The data involved in the operation.
1361
+ * @returns {any}
1362
+ */
1363
+ get data() {
1364
+ const ret = wasm.operation_data(this.__wbg_ptr);
1365
+ return takeObject(ret);
1366
+ }
1367
+ /**
1368
+ * Retrieves the type of operation.
1369
+ *
1370
+ * # Returns
1371
+ *
1372
+ * * `OpType` - The type of operation.
1373
+ * @returns {OpType}
1374
+ */
1375
+ get opType() {
1376
+ const ret = wasm.operation_opType(this.__wbg_ptr);
1377
+ return ret;
1378
+ }
1358
1379
  };
1359
1380
  var PropertyFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
1360
1381
  }, unregister: () => {
@@ -1371,52 +1392,40 @@ ${val.stack}`;
1371
1392
  wasm.__wbg_property_free(ptr);
1372
1393
  }
1373
1394
  /**
1374
- * Checks is the schema is valid.
1395
+ * Retrieves the maximum length of the property.
1375
1396
  *
1376
1397
  * # Returns
1377
1398
  *
1378
- * Throws exception if not valid
1379
- * @returns {boolean}
1399
+ * * `Result<JsValue, JsValue>` - A result containing the maximum length as a `JsValue` or an error.
1400
+ * @returns {any}
1380
1401
  */
1381
- is_valid() {
1402
+ get maxLength() {
1382
1403
  try {
1383
1404
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1384
- wasm.property_is_valid(retptr, this.__wbg_ptr);
1405
+ wasm.property_maxLength(retptr, this.__wbg_ptr);
1385
1406
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1386
1407
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1387
1408
  var r2 = getInt32Memory0()[retptr / 4 + 2];
1388
1409
  if (r2) {
1389
1410
  throw takeObject(r1);
1390
1411
  }
1391
- return r0 !== 0;
1412
+ return takeObject(r0);
1392
1413
  } finally {
1393
1414
  wasm.__wbindgen_add_to_stack_pointer(16);
1394
1415
  }
1395
1416
  }
1396
1417
  /**
1397
- * Retrieves the type of the property.
1398
- *
1399
- * # Returns
1400
- *
1401
- * * `PropertyType` - The type of the property.
1402
- * @returns {any}
1403
- */
1404
- get type() {
1405
- const ret = wasm.property_type(this.__wbg_ptr);
1406
- return takeObject(ret);
1407
- }
1408
- /**
1409
- * Retrieves the items of the property.
1418
+ * Retrieves the minimum length of the property.
1410
1419
  *
1411
1420
  * # Returns
1412
1421
  *
1413
- * * `Result<JsValue, JsValue>` - A result containing the items as a `JsValue` or an error.
1422
+ * * `Result<JsValue, JsValue>` - A result containing the minimum length as a `JsValue` or an error.
1414
1423
  * @returns {any}
1415
1424
  */
1416
- get items() {
1425
+ get minLength() {
1417
1426
  try {
1418
1427
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1419
- wasm.property_items(retptr, this.__wbg_ptr);
1428
+ wasm.property_minLength(retptr, this.__wbg_ptr);
1420
1429
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1421
1430
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1422
1431
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1429,17 +1438,17 @@ ${val.stack}`;
1429
1438
  }
1430
1439
  }
1431
1440
  /**
1432
- * Retrieves the maximum number of items of the property.
1441
+ * Retrieves the nested properties of the property.
1433
1442
  *
1434
1443
  * # Returns
1435
1444
  *
1436
- * * `Result<JsValue, JsValue>` - A result containing the maximum number of items as a `JsValue` or an error.
1445
+ * * `Result<JsValue, JsValue>` - A result containing the nested properties as a `JsValue` or an error.
1437
1446
  * @returns {any}
1438
1447
  */
1439
- get maxItems() {
1448
+ get properties() {
1440
1449
  try {
1441
1450
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1442
- wasm.property_maxItems(retptr, this.__wbg_ptr);
1451
+ wasm.property_properties(retptr, this.__wbg_ptr);
1443
1452
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1444
1453
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1445
1454
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1452,17 +1461,29 @@ ${val.stack}`;
1452
1461
  }
1453
1462
  }
1454
1463
  /**
1455
- * Retrieves the minimum number of items of the property.
1464
+ * Retrieves the type of the property.
1456
1465
  *
1457
1466
  * # Returns
1458
1467
  *
1459
- * * `Result<JsValue, JsValue>` - A result containing the minimum number of items as a `JsValue` or an error.
1468
+ * * `PropertyType` - The type of the property.
1460
1469
  * @returns {any}
1461
1470
  */
1462
- get minItems() {
1471
+ get type() {
1472
+ const ret = wasm.property_type(this.__wbg_ptr);
1473
+ return takeObject(ret);
1474
+ }
1475
+ /**
1476
+ * Retrieves the items of the property.
1477
+ *
1478
+ * # Returns
1479
+ *
1480
+ * * `Result<JsValue, JsValue>` - A result containing the items as a `JsValue` or an error.
1481
+ * @returns {any}
1482
+ */
1483
+ get items() {
1463
1484
  try {
1464
1485
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1465
- wasm.property_minItems(retptr, this.__wbg_ptr);
1486
+ wasm.property_items(retptr, this.__wbg_ptr);
1466
1487
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1467
1488
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1468
1489
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1475,40 +1496,40 @@ ${val.stack}`;
1475
1496
  }
1476
1497
  }
1477
1498
  /**
1478
- * Retrieves the maximum length of the property.
1499
+ * Checks is the schema is valid.
1479
1500
  *
1480
1501
  * # Returns
1481
1502
  *
1482
- * * `Result<JsValue, JsValue>` - A result containing the maximum length as a `JsValue` or an error.
1483
- * @returns {any}
1503
+ * Throws exception if not valid
1504
+ * @returns {boolean}
1484
1505
  */
1485
- get maxLength() {
1506
+ is_valid() {
1486
1507
  try {
1487
1508
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1488
- wasm.property_maxLength(retptr, this.__wbg_ptr);
1509
+ wasm.property_is_valid(retptr, this.__wbg_ptr);
1489
1510
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1490
1511
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1491
1512
  var r2 = getInt32Memory0()[retptr / 4 + 2];
1492
1513
  if (r2) {
1493
1514
  throw takeObject(r1);
1494
1515
  }
1495
- return takeObject(r0);
1516
+ return r0 !== 0;
1496
1517
  } finally {
1497
1518
  wasm.__wbindgen_add_to_stack_pointer(16);
1498
1519
  }
1499
1520
  }
1500
1521
  /**
1501
- * Retrieves the minimum length of the property.
1522
+ * Retrieves the maximum number of items of the property.
1502
1523
  *
1503
1524
  * # Returns
1504
1525
  *
1505
- * * `Result<JsValue, JsValue>` - A result containing the minimum length as a `JsValue` or an error.
1526
+ * * `Result<JsValue, JsValue>` - A result containing the maximum number of items as a `JsValue` or an error.
1506
1527
  * @returns {any}
1507
1528
  */
1508
- get minLength() {
1529
+ get maxItems() {
1509
1530
  try {
1510
1531
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1511
- wasm.property_minLength(retptr, this.__wbg_ptr);
1532
+ wasm.property_maxItems(retptr, this.__wbg_ptr);
1512
1533
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1513
1534
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1514
1535
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1521,17 +1542,17 @@ ${val.stack}`;
1521
1542
  }
1522
1543
  }
1523
1544
  /**
1524
- * Retrieves the nested properties of the property.
1545
+ * Retrieves the minimum number of items of the property.
1525
1546
  *
1526
1547
  * # Returns
1527
1548
  *
1528
- * * `Result<JsValue, JsValue>` - A result containing the nested properties as a `JsValue` or an error.
1549
+ * * `Result<JsValue, JsValue>` - A result containing the minimum number of items as a `JsValue` or an error.
1529
1550
  * @returns {any}
1530
1551
  */
1531
- get properties() {
1552
+ get minItems() {
1532
1553
  try {
1533
1554
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1534
- wasm.property_properties(retptr, this.__wbg_ptr);
1555
+ wasm.property_minItems(retptr, this.__wbg_ptr);
1535
1556
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1536
1557
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1537
1558
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1560,33 +1581,12 @@ ${val.stack}`;
1560
1581
  }
1561
1582
  /**
1562
1583
  * @param {any} query
1563
- * @param {Schema} schema
1564
- */
1565
- constructor(query, schema) {
1566
- try {
1567
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1568
- _assertClass(schema, Schema);
1569
- var ptr0 = schema.__destroy_into_raw();
1570
- wasm.query_new(retptr, addHeapObject(query), ptr0);
1571
- var r0 = getInt32Memory0()[retptr / 4 + 0];
1572
- var r1 = getInt32Memory0()[retptr / 4 + 1];
1573
- var r2 = getInt32Memory0()[retptr / 4 + 2];
1574
- if (r2) {
1575
- throw takeObject(r1);
1576
- }
1577
- this.__wbg_ptr = r0 >>> 0;
1578
- return this;
1579
- } finally {
1580
- wasm.__wbindgen_add_to_stack_pointer(16);
1581
- }
1582
- }
1583
- /**
1584
1584
  * @returns {any}
1585
1585
  */
1586
- get query() {
1586
+ process_query(query) {
1587
1587
  try {
1588
1588
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1589
- wasm.query_query(retptr, this.__wbg_ptr);
1589
+ wasm.query_process_query(retptr, this.__wbg_ptr, addBorrowedObject(query));
1590
1590
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1591
1591
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1592
1592
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1596,6 +1596,7 @@ ${val.stack}`;
1596
1596
  return takeObject(r0);
1597
1597
  } finally {
1598
1598
  wasm.__wbindgen_add_to_stack_pointer(16);
1599
+ heap[stack_pointer++] = void 0;
1599
1600
  }
1600
1601
  }
1601
1602
  /**
@@ -1622,12 +1623,31 @@ ${val.stack}`;
1622
1623
  }
1623
1624
  }
1624
1625
  /**
1626
+ * @returns {boolean}
1627
+ */
1628
+ has_or_operator() {
1629
+ const ret = wasm.query_has_or_operator(this.__wbg_ptr);
1630
+ return ret !== 0;
1631
+ }
1632
+ /**
1633
+ * Returns the value of a property from the (normalized) query by its name.
1634
+ * This will scan the normalized query structure (including arrays, $and/$or blocks, etc.)
1635
+ * to find the first occurrence of the given property name and return its corresponding value.
1636
+ *
1637
+ * If not found, an error is returned.
1638
+ *
1639
+ * Example:
1640
+ * let val = query.get("age")?;
1641
+ * // val is a JsValue that might be a number, string, boolean, array, or object (e.g., { "$gt": 30 })
1642
+ * @param {string} property_name
1625
1643
  * @returns {any}
1626
1644
  */
1627
- parse() {
1645
+ get(property_name) {
1628
1646
  try {
1629
1647
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1630
- wasm.query_parse(retptr, this.__wbg_ptr);
1648
+ const ptr0 = passStringToWasm0(property_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1649
+ const len0 = WASM_VECTOR_LEN;
1650
+ wasm.query_get(retptr, this.__wbg_ptr, ptr0, len0);
1631
1651
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1632
1652
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1633
1653
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1641,43 +1661,33 @@ ${val.stack}`;
1641
1661
  }
1642
1662
  /**
1643
1663
  * @param {any} query
1644
- * @returns {any}
1664
+ * @param {Schema} schema
1645
1665
  */
1646
- process_query(query) {
1666
+ constructor(query, schema) {
1647
1667
  try {
1648
1668
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1649
- wasm.query_process_query(retptr, this.__wbg_ptr, addBorrowedObject(query));
1669
+ _assertClass(schema, Schema);
1670
+ var ptr0 = schema.__destroy_into_raw();
1671
+ wasm.query_new(retptr, addHeapObject(query), ptr0);
1650
1672
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1651
1673
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1652
1674
  var r2 = getInt32Memory0()[retptr / 4 + 2];
1653
1675
  if (r2) {
1654
1676
  throw takeObject(r1);
1655
1677
  }
1656
- return takeObject(r0);
1678
+ this.__wbg_ptr = r0 >>> 0;
1679
+ return this;
1657
1680
  } finally {
1658
1681
  wasm.__wbindgen_add_to_stack_pointer(16);
1659
- heap[stack_pointer++] = void 0;
1660
1682
  }
1661
1683
  }
1662
1684
  /**
1663
- * Returns the value of a property from the (normalized) query by its name.
1664
- * This will scan the normalized query structure (including arrays, $and/$or blocks, etc.)
1665
- * to find the first occurrence of the given property name and return its corresponding value.
1666
- *
1667
- * If not found, an error is returned.
1668
- *
1669
- * Example:
1670
- * let val = query.get("age")?;
1671
- * // val is a JsValue that might be a number, string, boolean, array, or object (e.g., { "$gt": 30 })
1672
- * @param {string} property_name
1673
1685
  * @returns {any}
1674
1686
  */
1675
- get(property_name) {
1687
+ parse() {
1676
1688
  try {
1677
1689
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1678
- const ptr0 = passStringToWasm0(property_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1679
- const len0 = WASM_VECTOR_LEN;
1680
- wasm.query_get(retptr, this.__wbg_ptr, ptr0, len0);
1690
+ wasm.query_parse(retptr, this.__wbg_ptr);
1681
1691
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1682
1692
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1683
1693
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1690,11 +1700,22 @@ ${val.stack}`;
1690
1700
  }
1691
1701
  }
1692
1702
  /**
1693
- * @returns {boolean}
1703
+ * @returns {any}
1694
1704
  */
1695
- has_or_operator() {
1696
- const ret = wasm.query_has_or_operator(this.__wbg_ptr);
1697
- return ret !== 0;
1705
+ get query() {
1706
+ try {
1707
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1708
+ wasm.query_query(retptr, this.__wbg_ptr);
1709
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
1710
+ var r1 = getInt32Memory0()[retptr / 4 + 1];
1711
+ var r2 = getInt32Memory0()[retptr / 4 + 2];
1712
+ if (r2) {
1713
+ throw takeObject(r1);
1714
+ }
1715
+ return takeObject(r0);
1716
+ } finally {
1717
+ wasm.__wbindgen_add_to_stack_pointer(16);
1718
+ }
1698
1719
  }
1699
1720
  };
1700
1721
  var QueryOptionsFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
@@ -1721,10 +1742,10 @@ ${val.stack}`;
1721
1742
  /**
1722
1743
  * @returns {any}
1723
1744
  */
1724
- get limit() {
1745
+ get offset() {
1725
1746
  try {
1726
1747
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1727
- wasm.queryoptions_limit(retptr, this.__wbg_ptr);
1748
+ wasm.queryoptions_offset(retptr, this.__wbg_ptr);
1728
1749
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1729
1750
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1730
1751
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1739,10 +1760,10 @@ ${val.stack}`;
1739
1760
  /**
1740
1761
  * @returns {any}
1741
1762
  */
1742
- get offset() {
1763
+ get limit() {
1743
1764
  try {
1744
1765
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1745
- wasm.queryoptions_offset(retptr, this.__wbg_ptr);
1766
+ wasm.queryoptions_limit(retptr, this.__wbg_ptr);
1746
1767
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1747
1768
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1748
1769
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1768,9 +1789,9 @@ ${val.stack}`;
1768
1789
  }
1769
1790
  toJSON() {
1770
1791
  return {
1771
- type: this.type,
1792
+ message: this.message,
1772
1793
  code: this.code,
1773
- message: this.message
1794
+ type: this.type
1774
1795
  };
1775
1796
  }
1776
1797
  toString() {
@@ -1787,44 +1808,15 @@ ${val.stack}`;
1787
1808
  wasm.__wbg_ridberror_free(ptr);
1788
1809
  }
1789
1810
  /**
1790
- * @param {string} err_type
1791
- * @param {string} message
1811
+ * @param {string} err
1792
1812
  * @param {number} code
1813
+ * @returns {RIDBError}
1793
1814
  */
1794
- constructor(err_type, message, code) {
1795
- const ptr0 = passStringToWasm0(err_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1815
+ static validation(err, code) {
1816
+ const ptr0 = passStringToWasm0(err, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1796
1817
  const len0 = WASM_VECTOR_LEN;
1797
- const ptr1 = passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1798
- const len1 = WASM_VECTOR_LEN;
1799
- const ret = wasm.ridberror_new(ptr0, len0, ptr1, len1, code);
1800
- this.__wbg_ptr = ret >>> 0;
1801
- return this;
1802
- }
1803
- /**
1804
- * @returns {string}
1805
- */
1806
- get type() {
1807
- let deferred1_0;
1808
- let deferred1_1;
1809
- try {
1810
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1811
- wasm.ridberror_type(retptr, this.__wbg_ptr);
1812
- var r0 = getInt32Memory0()[retptr / 4 + 0];
1813
- var r1 = getInt32Memory0()[retptr / 4 + 1];
1814
- deferred1_0 = r0;
1815
- deferred1_1 = r1;
1816
- return getStringFromWasm0(r0, r1);
1817
- } finally {
1818
- wasm.__wbindgen_add_to_stack_pointer(16);
1819
- wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
1820
- }
1821
- }
1822
- /**
1823
- * @returns {any}
1824
- */
1825
- get code() {
1826
- const ret = wasm.ridberror_code(this.__wbg_ptr);
1827
- return takeObject(ret);
1818
+ const ret = wasm.ridberror_validation(ptr0, len0, code);
1819
+ return _RIDBError.__wrap(ret);
1828
1820
  }
1829
1821
  /**
1830
1822
  * @returns {string}
@@ -1846,11 +1838,14 @@ ${val.stack}`;
1846
1838
  }
1847
1839
  }
1848
1840
  /**
1849
- * @param {any} err
1841
+ * @param {string} err
1842
+ * @param {number} code
1850
1843
  * @returns {RIDBError}
1851
1844
  */
1852
- static from(err) {
1853
- const ret = wasm.ridberror_from(addHeapObject(err));
1845
+ static serialisation(err, code) {
1846
+ const ptr0 = passStringToWasm0(err, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1847
+ const len0 = WASM_VECTOR_LEN;
1848
+ const ret = wasm.ridberror_serialisation(ptr0, len0, code);
1854
1849
  return _RIDBError.__wrap(ret);
1855
1850
  }
1856
1851
  /**
@@ -1858,32 +1853,35 @@ ${val.stack}`;
1858
1853
  * @param {number} code
1859
1854
  * @returns {RIDBError}
1860
1855
  */
1861
- static error(err, code) {
1856
+ static authentication(err, code) {
1862
1857
  const ptr0 = passStringToWasm0(err, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1863
1858
  const len0 = WASM_VECTOR_LEN;
1864
- const ret = wasm.ridberror_error(ptr0, len0, code);
1859
+ const ret = wasm.ridberror_authentication(ptr0, len0, code);
1865
1860
  return _RIDBError.__wrap(ret);
1866
1861
  }
1867
1862
  /**
1868
- * @param {string} err
1863
+ * @param {string} err_type
1864
+ * @param {string} message
1869
1865
  * @param {number} code
1870
- * @returns {RIDBError}
1871
1866
  */
1872
- static query(err, code) {
1873
- const ptr0 = passStringToWasm0(err, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1867
+ constructor(err_type, message, code) {
1868
+ const ptr0 = passStringToWasm0(err_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1874
1869
  const len0 = WASM_VECTOR_LEN;
1875
- const ret = wasm.ridberror_query(ptr0, len0, code);
1876
- return _RIDBError.__wrap(ret);
1870
+ const ptr1 = passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1871
+ const len1 = WASM_VECTOR_LEN;
1872
+ const ret = wasm.ridberror_new(ptr0, len0, ptr1, len1, code);
1873
+ this.__wbg_ptr = ret >>> 0;
1874
+ return this;
1877
1875
  }
1878
1876
  /**
1879
1877
  * @param {string} err
1880
1878
  * @param {number} code
1881
1879
  * @returns {RIDBError}
1882
1880
  */
1883
- static authentication(err, code) {
1881
+ static hook(err, code) {
1884
1882
  const ptr0 = passStringToWasm0(err, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1885
1883
  const len0 = WASM_VECTOR_LEN;
1886
- const ret = wasm.ridberror_authentication(ptr0, len0, code);
1884
+ const ret = wasm.ridberror_hook(ptr0, len0, code);
1887
1885
  return _RIDBError.__wrap(ret);
1888
1886
  }
1889
1887
  /**
@@ -1891,10 +1889,10 @@ ${val.stack}`;
1891
1889
  * @param {number} code
1892
1890
  * @returns {RIDBError}
1893
1891
  */
1894
- static serialisation(err, code) {
1892
+ static error(err, code) {
1895
1893
  const ptr0 = passStringToWasm0(err, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1896
1894
  const len0 = WASM_VECTOR_LEN;
1897
- const ret = wasm.ridberror_serialisation(ptr0, len0, code);
1895
+ const ret = wasm.ridberror_error(ptr0, len0, code);
1898
1896
  return _RIDBError.__wrap(ret);
1899
1897
  }
1900
1898
  /**
@@ -1902,23 +1900,46 @@ ${val.stack}`;
1902
1900
  * @param {number} code
1903
1901
  * @returns {RIDBError}
1904
1902
  */
1905
- static validation(err, code) {
1903
+ static query(err, code) {
1906
1904
  const ptr0 = passStringToWasm0(err, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1907
1905
  const len0 = WASM_VECTOR_LEN;
1908
- const ret = wasm.ridberror_validation(ptr0, len0, code);
1906
+ const ret = wasm.ridberror_query(ptr0, len0, code);
1909
1907
  return _RIDBError.__wrap(ret);
1910
1908
  }
1911
1909
  /**
1912
- * @param {string} err
1913
- * @param {number} code
1910
+ * @returns {any}
1911
+ */
1912
+ get code() {
1913
+ const ret = wasm.ridberror_code(this.__wbg_ptr);
1914
+ return takeObject(ret);
1915
+ }
1916
+ /**
1917
+ * @param {any} err
1914
1918
  * @returns {RIDBError}
1915
1919
  */
1916
- static hook(err, code) {
1917
- const ptr0 = passStringToWasm0(err, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1918
- const len0 = WASM_VECTOR_LEN;
1919
- const ret = wasm.ridberror_hook(ptr0, len0, code);
1920
+ static from(err) {
1921
+ const ret = wasm.ridberror_from(addHeapObject(err));
1920
1922
  return _RIDBError.__wrap(ret);
1921
1923
  }
1924
+ /**
1925
+ * @returns {string}
1926
+ */
1927
+ get type() {
1928
+ let deferred1_0;
1929
+ let deferred1_1;
1930
+ try {
1931
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1932
+ wasm.ridberror_type(retptr, this.__wbg_ptr);
1933
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
1934
+ var r1 = getInt32Memory0()[retptr / 4 + 1];
1935
+ deferred1_0 = r0;
1936
+ deferred1_1 = r1;
1937
+ return getStringFromWasm0(r0, r1);
1938
+ } finally {
1939
+ wasm.__wbindgen_add_to_stack_pointer(16);
1940
+ wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
1941
+ }
1942
+ }
1922
1943
  };
1923
1944
  var SchemaFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
1924
1945
  }, unregister: () => {
@@ -1942,80 +1963,84 @@ ${val.stack}`;
1942
1963
  wasm.__wbg_schema_free(ptr);
1943
1964
  }
1944
1965
  /**
1945
- * @param {any} document
1966
+ * Retrieves the indexes of the schema, if any.
1967
+ *
1968
+ * # Returns
1969
+ *
1970
+ * * `Option<Vec<String>>` - The indexes of the schema, if any.
1971
+ * @returns {(string)[] | undefined}
1946
1972
  */
1947
- validate(document2) {
1973
+ get indexes() {
1948
1974
  try {
1949
1975
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1950
- wasm.schema_validate(retptr, this.__wbg_ptr, addHeapObject(document2));
1976
+ wasm.schema_indexes(retptr, this.__wbg_ptr);
1951
1977
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1952
1978
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1953
- if (r1) {
1954
- throw takeObject(r0);
1979
+ let v1;
1980
+ if (r0 !== 0) {
1981
+ v1 = getArrayJsValueFromWasm0(r0, r1).slice();
1982
+ wasm.__wbindgen_free(r0, r1 * 4, 4);
1955
1983
  }
1984
+ return v1;
1956
1985
  } finally {
1957
1986
  wasm.__wbindgen_add_to_stack_pointer(16);
1958
1987
  }
1959
1988
  }
1960
1989
  /**
1961
- * @returns {boolean}
1990
+ * Retrieves the version of the schema.
1991
+ *
1992
+ * # Returns
1993
+ *
1994
+ * * `i32` - The version of the schema.
1995
+ * @returns {number}
1962
1996
  */
1963
- is_valid() {
1997
+ get version() {
1998
+ const ret = wasm.schema_version(this.__wbg_ptr);
1999
+ return ret;
2000
+ }
2001
+ /**
2002
+ * @returns {(string)[] | undefined}
2003
+ */
2004
+ get encrypted() {
1964
2005
  try {
1965
2006
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1966
- wasm.schema_is_valid(retptr, this.__wbg_ptr);
2007
+ wasm.schema_encrypted(retptr, this.__wbg_ptr);
1967
2008
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1968
2009
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1969
- var r2 = getInt32Memory0()[retptr / 4 + 2];
1970
- if (r2) {
1971
- throw takeObject(r1);
2010
+ let v1;
2011
+ if (r0 !== 0) {
2012
+ v1 = getArrayJsValueFromWasm0(r0, r1).slice();
2013
+ wasm.__wbindgen_free(r0, r1 * 4, 4);
1972
2014
  }
1973
- return r0 !== 0;
2015
+ return v1;
1974
2016
  } finally {
1975
2017
  wasm.__wbindgen_add_to_stack_pointer(16);
1976
2018
  }
1977
2019
  }
1978
2020
  /**
1979
- * Creates a new `Schema` instance from a given `JsValue`.
1980
- *
1981
- * # Arguments
1982
- *
1983
- * * `schema` - A `JsValue` representing the schema.
2021
+ * Retrieves the properties of the schema.
1984
2022
  *
1985
2023
  * # Returns
1986
2024
  *
1987
- * * `Result<Schema, JsValue>` - A result containing the new `Schema` instance or an error.
1988
- * @param {any} schema
1989
- * @returns {Schema}
2025
+ * * `Result<JsValue, JsValue>` - A result containing the properties as a `JsValue` or an error.
2026
+ * @returns {any}
1990
2027
  */
1991
- static create(schema) {
2028
+ get properties() {
1992
2029
  try {
1993
2030
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1994
- wasm.schema_create(retptr, addHeapObject(schema));
2031
+ wasm.schema_properties(retptr, this.__wbg_ptr);
1995
2032
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1996
2033
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1997
2034
  var r2 = getInt32Memory0()[retptr / 4 + 2];
1998
2035
  if (r2) {
1999
2036
  throw takeObject(r1);
2000
2037
  }
2001
- return _Schema.__wrap(r0);
2038
+ return takeObject(r0);
2002
2039
  } finally {
2003
2040
  wasm.__wbindgen_add_to_stack_pointer(16);
2004
2041
  }
2005
2042
  }
2006
2043
  /**
2007
- * Retrieves the version of the schema.
2008
- *
2009
- * # Returns
2010
- *
2011
- * * `i32` - The version of the schema.
2012
- * @returns {number}
2013
- */
2014
- get version() {
2015
- const ret = wasm.schema_version(this.__wbg_ptr);
2016
- return ret;
2017
- }
2018
- /**
2019
2044
  * Retrieves the primary key of the schema.
2020
2045
  *
2021
2046
  * # Returns
@@ -2064,67 +2089,63 @@ ${val.stack}`;
2064
2089
  }
2065
2090
  }
2066
2091
  /**
2067
- * Retrieves the indexes of the schema, if any.
2068
- *
2069
- * # Returns
2070
- *
2071
- * * `Option<Vec<String>>` - The indexes of the schema, if any.
2072
- * @returns {(string)[] | undefined}
2092
+ * @param {any} document
2073
2093
  */
2074
- get indexes() {
2094
+ validate(document2) {
2075
2095
  try {
2076
2096
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2077
- wasm.schema_indexes(retptr, this.__wbg_ptr);
2097
+ wasm.schema_validate(retptr, this.__wbg_ptr, addHeapObject(document2));
2078
2098
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2079
2099
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2080
- let v1;
2081
- if (r0 !== 0) {
2082
- v1 = getArrayJsValueFromWasm0(r0, r1).slice();
2083
- wasm.__wbindgen_free(r0, r1 * 4, 4);
2100
+ if (r1) {
2101
+ throw takeObject(r0);
2084
2102
  }
2085
- return v1;
2086
2103
  } finally {
2087
2104
  wasm.__wbindgen_add_to_stack_pointer(16);
2088
2105
  }
2089
2106
  }
2090
2107
  /**
2091
- * @returns {(string)[] | undefined}
2108
+ * Creates a new `Schema` instance from a given `JsValue`.
2109
+ *
2110
+ * # Arguments
2111
+ *
2112
+ * * `schema` - A `JsValue` representing the schema.
2113
+ *
2114
+ * # Returns
2115
+ *
2116
+ * * `Result<Schema, JsValue>` - A result containing the new `Schema` instance or an error.
2117
+ * @param {any} schema
2118
+ * @returns {Schema}
2092
2119
  */
2093
- get encrypted() {
2120
+ static create(schema) {
2094
2121
  try {
2095
2122
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2096
- wasm.schema_encrypted(retptr, this.__wbg_ptr);
2123
+ wasm.schema_create(retptr, addHeapObject(schema));
2097
2124
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2098
2125
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2099
- let v1;
2100
- if (r0 !== 0) {
2101
- v1 = getArrayJsValueFromWasm0(r0, r1).slice();
2102
- wasm.__wbindgen_free(r0, r1 * 4, 4);
2126
+ var r2 = getInt32Memory0()[retptr / 4 + 2];
2127
+ if (r2) {
2128
+ throw takeObject(r1);
2103
2129
  }
2104
- return v1;
2130
+ return _Schema.__wrap(r0);
2105
2131
  } finally {
2106
2132
  wasm.__wbindgen_add_to_stack_pointer(16);
2107
2133
  }
2108
2134
  }
2109
2135
  /**
2110
- * Retrieves the properties of the schema.
2111
- *
2112
- * # Returns
2113
- *
2114
- * * `Result<JsValue, JsValue>` - A result containing the properties as a `JsValue` or an error.
2115
- * @returns {any}
2136
+ * @returns {boolean}
2116
2137
  */
2117
- get properties() {
2138
+ is_valid() {
2118
2139
  try {
2119
2140
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2120
- wasm.schema_properties(retptr, this.__wbg_ptr);
2141
+ wasm.schema_is_valid(retptr, this.__wbg_ptr);
2121
2142
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2122
2143
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2123
2144
  var r2 = getInt32Memory0()[retptr / 4 + 2];
2124
2145
  if (r2) {
2125
2146
  throw takeObject(r1);
2126
2147
  }
2127
- return takeObject(r0);
2148
+ return r0 !== 0;
2128
2149
  } finally {
2129
2150
  wasm.__wbindgen_add_to_stack_pointer(16);
2130
2151
  }
@@ -2157,16 +2178,6 @@ ${val.stack}`;
2157
2178
  return this;
2158
2179
  }
2159
2180
  /**
2160
- * Inform this context about runtime arguments passed to the test
2161
- * harness.
2162
- * @param {any[]} args
2163
- */
2164
- args(args) {
2165
- const ptr0 = passArrayJsValueToWasm0(args, wasm.__wbindgen_malloc);
2166
- const len0 = WASM_VECTOR_LEN;
2167
- wasm.wasmbindgentestcontext_args(this.__wbg_ptr, ptr0, len0);
2168
- }
2169
- /**
2170
2181
  * Executes a list of tests, returning a promise representing their
2171
2182
  * eventual completion.
2172
2183
  *
@@ -2185,6 +2196,16 @@ ${val.stack}`;
2185
2196
  const ret = wasm.wasmbindgentestcontext_run(this.__wbg_ptr, ptr0, len0);
2186
2197
  return takeObject(ret);
2187
2198
  }
2199
+ /**
2200
+ * Inform this context about runtime arguments passed to the test
2201
+ * harness.
2202
+ * @param {any[]} args
2203
+ */
2204
+ args(args) {
2205
+ const ptr0 = passArrayJsValueToWasm0(args, wasm.__wbindgen_malloc);
2206
+ const len0 = WASM_VECTOR_LEN;
2207
+ wasm.wasmbindgentestcontext_args(this.__wbg_ptr, ptr0, len0);
2208
+ }
2188
2209
  };
2189
2210
  async function __wbg_load(module2, imports) {
2190
2211
  if (typeof Response === "function" && module2 instanceof Response) {
@@ -2216,51 +2237,30 @@ ${val.stack}`;
2216
2237
  imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
2217
2238
  takeObject(arg0);
2218
2239
  };
2219
- imports.wbg.__wbg_count_19db4c3174d573d5 = function() {
2220
- return handleError(function(arg0, arg1, arg2, arg3, arg4) {
2221
- const ret = getObject(arg0).count(getStringFromWasm0(arg1, arg2), takeObject(arg3), QueryOptions.__wrap(arg4));
2222
- return addHeapObject(ret);
2223
- }, arguments);
2224
- };
2225
- imports.wbg.__wbg_ridberror_new = function(arg0) {
2226
- const ret = RIDBError.__wrap(arg0);
2240
+ imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
2241
+ const ret = getObject(arg0);
2227
2242
  return addHeapObject(ret);
2228
2243
  };
2229
2244
  imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
2230
2245
  const ret = getStringFromWasm0(arg0, arg1);
2231
2246
  return addHeapObject(ret);
2232
2247
  };
2233
- imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
2234
- const ret = getObject(arg0);
2248
+ imports.wbg.__wbindgen_number_new = function(arg0) {
2249
+ const ret = arg0;
2235
2250
  return addHeapObject(ret);
2236
2251
  };
2237
- imports.wbg.__wbindgen_is_undefined = function(arg0) {
2238
- const ret = getObject(arg0) === void 0;
2239
- return ret;
2252
+ imports.wbg.__wbg_ridberror_new = function(arg0) {
2253
+ const ret = RIDBError.__wrap(arg0);
2254
+ return addHeapObject(ret);
2240
2255
  };
2241
2256
  imports.wbg.__wbindgen_is_null = function(arg0) {
2242
2257
  const ret = getObject(arg0) === null;
2243
2258
  return ret;
2244
2259
  };
2245
- imports.wbg.__wbg_start_76c138c3b73ae6f8 = function() {
2246
- return handleError(function(arg0) {
2247
- const ret = getObject(arg0).start();
2248
- return addHeapObject(ret);
2249
- }, arguments);
2250
- };
2251
- imports.wbg.__wbindgen_cb_drop = function(arg0) {
2252
- const obj = takeObject(arg0).original;
2253
- if (obj.cnt-- == 1) {
2254
- obj.a = 0;
2255
- return true;
2256
- }
2257
- const ret = false;
2260
+ imports.wbg.__wbindgen_is_undefined = function(arg0) {
2261
+ const ret = getObject(arg0) === void 0;
2258
2262
  return ret;
2259
2263
  };
2260
- imports.wbg.__wbindgen_number_new = function(arg0) {
2261
- const ret = arg0;
2262
- return addHeapObject(ret);
2263
- };
2264
2264
  imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
2265
2265
  const obj = getObject(arg1);
2266
2266
  const ret = typeof obj === "string" ? obj : void 0;
@@ -2269,6 +2269,12 @@ ${val.stack}`;
2269
2269
  getInt32Memory0()[arg0 / 4 + 1] = len1;
2270
2270
  getInt32Memory0()[arg0 / 4 + 0] = ptr1;
2271
2271
  };
2272
+ imports.wbg.__wbg_count_19db4c3174d573d5 = function() {
2273
+ return handleError(function(arg0, arg1, arg2, arg3, arg4) {
2274
+ const ret = getObject(arg0).count(getStringFromWasm0(arg1, arg2), takeObject(arg3), QueryOptions.__wrap(arg4));
2275
+ return addHeapObject(ret);
2276
+ }, arguments);
2277
+ };
2272
2278
  imports.wbg.__wbg_apply_9f557eba1534d597 = function() {
2273
2279
  return handleError(function(arg0, arg1, arg2) {
2274
2280
  const ret = getObject(arg1).apply(takeObject(arg2));
@@ -2282,59 +2288,66 @@ ${val.stack}`;
2282
2288
  const ret = InMemory.__wrap(arg0);
2283
2289
  return addHeapObject(ret);
2284
2290
  };
2291
+ imports.wbg.__wbindgen_cb_drop = function(arg0) {
2292
+ const obj = takeObject(arg0).original;
2293
+ if (obj.cnt-- == 1) {
2294
+ obj.a = 0;
2295
+ return true;
2296
+ }
2297
+ const ret = false;
2298
+ return ret;
2299
+ };
2285
2300
  imports.wbg.__wbg_close_6384ed3c27ef25c1 = function() {
2286
2301
  return handleError(function(arg0) {
2287
2302
  const ret = getObject(arg0).close();
2288
2303
  return addHeapObject(ret);
2289
2304
  }, arguments);
2290
2305
  };
2306
+ imports.wbg.__wbg_start_76c138c3b73ae6f8 = function() {
2307
+ return handleError(function(arg0) {
2308
+ const ret = getObject(arg0).start();
2309
+ return addHeapObject(ret);
2310
+ }, arguments);
2311
+ };
2291
2312
  imports.wbg.__wbindgen_number_get = function(arg0, arg1) {
2292
2313
  const obj = getObject(arg1);
2293
2314
  const ret = typeof obj === "number" ? obj : void 0;
2294
2315
  getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret;
2295
2316
  getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
2296
2317
  };
2297
- imports.wbg.__wbg_find_567c5c9f064fe3d2 = function() {
2298
- return handleError(function(arg0, arg1, arg2, arg3, arg4) {
2299
- const ret = getObject(arg0).find(getStringFromWasm0(arg1, arg2), takeObject(arg3), QueryOptions.__wrap(arg4));
2300
- return addHeapObject(ret);
2301
- }, arguments);
2302
- };
2303
2318
  imports.wbg.__wbg_findDocumentById_2edf7350e5f12657 = function() {
2304
2319
  return handleError(function(arg0, arg1, arg2, arg3) {
2305
2320
  const ret = getObject(arg0).findDocumentById(getStringFromWasm0(arg1, arg2), takeObject(arg3));
2306
2321
  return addHeapObject(ret);
2307
2322
  }, arguments);
2308
2323
  };
2324
+ imports.wbg.__wbg_find_567c5c9f064fe3d2 = function() {
2325
+ return handleError(function(arg0, arg1, arg2, arg3, arg4) {
2326
+ const ret = getObject(arg0).find(getStringFromWasm0(arg1, arg2), takeObject(arg3), QueryOptions.__wrap(arg4));
2327
+ return addHeapObject(ret);
2328
+ }, arguments);
2329
+ };
2309
2330
  imports.wbg.__wbg_write_1159c67c07f62020 = function() {
2310
2331
  return handleError(function(arg0, arg1) {
2311
2332
  const ret = getObject(arg0).write(Operation.__wrap(arg1));
2312
2333
  return addHeapObject(ret);
2313
2334
  }, arguments);
2314
2335
  };
2315
- imports.wbg.__wbg_database_new = function(arg0) {
2316
- const ret = Database.__wrap(arg0);
2317
- return addHeapObject(ret);
2318
- };
2319
- imports.wbg.__wbg_collection_new = function(arg0) {
2320
- const ret = Collection.__wrap(arg0);
2321
- return addHeapObject(ret);
2336
+ imports.wbg.__wbindgen_is_object = function(arg0) {
2337
+ const val = getObject(arg0);
2338
+ const ret = typeof val === "object" && val !== null;
2339
+ return ret;
2322
2340
  };
2323
- imports.wbg.__wbg_indexdb_new = function(arg0) {
2324
- const ret = IndexDB.__wrap(arg0);
2325
- return addHeapObject(ret);
2341
+ imports.wbg.__wbindgen_is_string = function(arg0) {
2342
+ const ret = typeof getObject(arg0) === "string";
2343
+ return ret;
2326
2344
  };
2327
2345
  imports.wbg.__wbindgen_is_array = function(arg0) {
2328
2346
  const ret = Array.isArray(getObject(arg0));
2329
2347
  return ret;
2330
2348
  };
2331
- imports.wbg.__wbindgen_is_object = function(arg0) {
2332
- const val = getObject(arg0);
2333
- const ret = typeof val === "object" && val !== null;
2334
- return ret;
2335
- };
2336
- imports.wbg.__wbindgen_jsval_eq = function(arg0, arg1) {
2337
- const ret = getObject(arg0) === getObject(arg1);
2349
+ imports.wbg.__wbindgen_is_falsy = function(arg0) {
2350
+ const ret = !getObject(arg0);
2338
2351
  return ret;
2339
2352
  };
2340
2353
  imports.wbg.__wbindgen_boolean_get = function(arg0) {
@@ -2342,10 +2355,18 @@ ${val.stack}`;
2342
2355
  const ret = typeof v === "boolean" ? v ? 1 : 0 : 2;
2343
2356
  return ret;
2344
2357
  };
2358
+ imports.wbg.__wbindgen_is_function = function(arg0) {
2359
+ const ret = typeof getObject(arg0) === "function";
2360
+ return ret;
2361
+ };
2345
2362
  imports.wbg.__wbindgen_is_bigint = function(arg0) {
2346
2363
  const ret = typeof getObject(arg0) === "bigint";
2347
2364
  return ret;
2348
2365
  };
2366
+ imports.wbg.__wbg_collection_new = function(arg0) {
2367
+ const ret = Collection.__wrap(arg0);
2368
+ return addHeapObject(ret);
2369
+ };
2349
2370
  imports.wbg.__wbindgen_in = function(arg0, arg1) {
2350
2371
  const ret = getObject(arg0) in getObject(arg1);
2351
2372
  return ret;
@@ -2354,6 +2375,10 @@ ${val.stack}`;
2354
2375
  const ret = arg0;
2355
2376
  return addHeapObject(ret);
2356
2377
  };
2378
+ imports.wbg.__wbindgen_jsval_eq = function(arg0, arg1) {
2379
+ const ret = getObject(arg0) === getObject(arg1);
2380
+ return ret;
2381
+ };
2357
2382
  imports.wbg.__wbindgen_bigint_from_u64 = function(arg0) {
2358
2383
  const ret = BigInt.asUintN(64, arg0);
2359
2384
  return addHeapObject(ret);
@@ -2362,17 +2387,13 @@ ${val.stack}`;
2362
2387
  const ret = new Error(getStringFromWasm0(arg0, arg1));
2363
2388
  return addHeapObject(ret);
2364
2389
  };
2365
- imports.wbg.__wbindgen_is_string = function(arg0) {
2366
- const ret = typeof getObject(arg0) === "string";
2367
- return ret;
2368
- };
2369
- imports.wbg.__wbindgen_is_falsy = function(arg0) {
2370
- const ret = !getObject(arg0);
2371
- return ret;
2390
+ imports.wbg.__wbg_database_new = function(arg0) {
2391
+ const ret = Database.__wrap(arg0);
2392
+ return addHeapObject(ret);
2372
2393
  };
2373
- imports.wbg.__wbindgen_is_function = function(arg0) {
2374
- const ret = typeof getObject(arg0) === "function";
2375
- return ret;
2394
+ imports.wbg.__wbg_indexdb_new = function(arg0) {
2395
+ const ret = IndexDB.__wrap(arg0);
2396
+ return addHeapObject(ret);
2376
2397
  };
2377
2398
  imports.wbg.__wbg_crypto_1d1f22824a6a080c = function(arg0) {
2378
2399
  const ret = getObject(arg0).crypto;
@@ -2426,6 +2447,12 @@ ${val.stack}`;
2426
2447
  return isLikeNone(ret) ? 0 : addHeapObject(ret);
2427
2448
  }, arguments);
2428
2449
  };
2450
+ imports.wbg.__wbg_indexedDB_d312f95759a15fdc = function() {
2451
+ return handleError(function(arg0) {
2452
+ const ret = getObject(arg0).indexedDB;
2453
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
2454
+ }, arguments);
2455
+ };
2429
2456
  imports.wbg.__wbg_instanceof_WorkerGlobalScope_46b577f151fad960 = function(arg0) {
2430
2457
  let result;
2431
2458
  try {
@@ -2436,105 +2463,106 @@ ${val.stack}`;
2436
2463
  const ret = result;
2437
2464
  return ret;
2438
2465
  };
2439
- imports.wbg.__wbg_indexedDB_d312f95759a15fdc = function() {
2466
+ imports.wbg.__wbg_continue_f1c3e0815924de62 = function() {
2440
2467
  return handleError(function(arg0) {
2441
- const ret = getObject(arg0).indexedDB;
2442
- return isLikeNone(ret) ? 0 : addHeapObject(ret);
2468
+ getObject(arg0).continue();
2443
2469
  }, arguments);
2444
2470
  };
2445
- imports.wbg.__wbg_debug_5fb96680aecf5dc8 = function(arg0) {
2446
- console.debug(getObject(arg0));
2447
- };
2448
- imports.wbg.__wbg_openCursor_425aba9cbe1d4d39 = function() {
2449
- return handleError(function(arg0) {
2450
- const ret = getObject(arg0).openCursor();
2471
+ imports.wbg.__wbg_open_f0d7259fd7e689ce = function() {
2472
+ return handleError(function(arg0, arg1, arg2, arg3) {
2473
+ const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2), arg3 >>> 0);
2451
2474
  return addHeapObject(ret);
2452
2475
  }, arguments);
2453
2476
  };
2454
- imports.wbg.__wbg_openCursor_e3042770817a8d57 = function() {
2455
- return handleError(function(arg0, arg1) {
2456
- const ret = getObject(arg0).openCursor(getObject(arg1));
2477
+ imports.wbg.__wbg_lowerBound_cd1c8a3b3fdf1582 = function() {
2478
+ return handleError(function(arg0) {
2479
+ const ret = IDBKeyRange.lowerBound(getObject(arg0));
2457
2480
  return addHeapObject(ret);
2458
2481
  }, arguments);
2459
2482
  };
2460
- imports.wbg.__wbg_openKeyCursor_6a1881d8dd9f1c21 = function() {
2483
+ imports.wbg.__wbg_upperBound_1e3077b2c05bdd71 = function() {
2461
2484
  return handleError(function(arg0) {
2462
- const ret = getObject(arg0).openKeyCursor();
2485
+ const ret = IDBKeyRange.upperBound(getObject(arg0));
2463
2486
  return addHeapObject(ret);
2464
2487
  }, arguments);
2465
2488
  };
2466
- imports.wbg.__wbg_openKeyCursor_a50d16a4992519e2 = function() {
2489
+ imports.wbg.__wbg_lowerBound_e77f6e14cb69151e = function() {
2467
2490
  return handleError(function(arg0, arg1) {
2468
- const ret = getObject(arg0).openKeyCursor(getObject(arg1));
2491
+ const ret = IDBKeyRange.lowerBound(getObject(arg0), arg1 !== 0);
2469
2492
  return addHeapObject(ret);
2470
2493
  }, arguments);
2471
2494
  };
2472
- imports.wbg.__wbg_createIndex_b8da1f5571f644be = function() {
2473
- return handleError(function(arg0, arg1, arg2, arg3, arg4, arg5) {
2474
- const ret = getObject(arg0).createIndex(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4), getObject(arg5));
2495
+ imports.wbg.__wbg_upperBound_4c692da072d1a11e = function() {
2496
+ return handleError(function(arg0, arg1) {
2497
+ const ret = IDBKeyRange.upperBound(getObject(arg0), arg1 !== 0);
2475
2498
  return addHeapObject(ret);
2476
2499
  }, arguments);
2477
2500
  };
2478
- imports.wbg.__wbg_delete_f60bba7d0ae59a4f = function() {
2479
- return handleError(function(arg0, arg1) {
2480
- const ret = getObject(arg0).delete(getObject(arg1));
2501
+ imports.wbg.__wbg_bound_25385469508e98c7 = function() {
2502
+ return handleError(function(arg0, arg1, arg2, arg3) {
2503
+ const ret = IDBKeyRange.bound(getObject(arg0), getObject(arg1), arg2 !== 0, arg3 !== 0);
2481
2504
  return addHeapObject(ret);
2482
2505
  }, arguments);
2483
2506
  };
2484
- imports.wbg.__wbg_get_5361b64cac0d0826 = function() {
2485
- return handleError(function(arg0, arg1) {
2486
- const ret = getObject(arg0).get(getObject(arg1));
2507
+ imports.wbg.__wbg_only_cacf767244bdc280 = function() {
2508
+ return handleError(function(arg0) {
2509
+ const ret = IDBKeyRange.only(getObject(arg0));
2487
2510
  return addHeapObject(ret);
2488
2511
  }, arguments);
2489
2512
  };
2490
- imports.wbg.__wbg_index_383b6812c1508030 = function() {
2491
- return handleError(function(arg0, arg1, arg2) {
2492
- const ret = getObject(arg0).index(getStringFromWasm0(arg1, arg2));
2513
+ imports.wbg.__wbg_get_910bbb94abdcf488 = function(arg0, arg1, arg2) {
2514
+ const ret = getObject(arg1)[arg2 >>> 0];
2515
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2516
+ var len1 = WASM_VECTOR_LEN;
2517
+ getInt32Memory0()[arg0 / 4 + 1] = len1;
2518
+ getInt32Memory0()[arg0 / 4 + 0] = ptr1;
2519
+ };
2520
+ imports.wbg.__wbg_length_9ae5daf9a690cba9 = function(arg0) {
2521
+ const ret = getObject(arg0).length;
2522
+ return ret;
2523
+ };
2524
+ imports.wbg.__wbg_contains_c65b44400b549286 = function(arg0, arg1, arg2) {
2525
+ const ret = getObject(arg0).contains(getStringFromWasm0(arg1, arg2));
2526
+ return ret;
2527
+ };
2528
+ imports.wbg.__wbg_value_86d3334f5075b232 = function() {
2529
+ return handleError(function(arg0) {
2530
+ const ret = getObject(arg0).value;
2493
2531
  return addHeapObject(ret);
2494
2532
  }, arguments);
2495
2533
  };
2496
- imports.wbg.__wbg_openCursor_30d58ae27a327629 = function() {
2534
+ imports.wbg.__wbg_instanceof_IdbCursorWithValue_abeb44d13d947bc2 = function(arg0) {
2535
+ let result;
2536
+ try {
2537
+ result = getObject(arg0) instanceof IDBCursorWithValue;
2538
+ } catch (_) {
2539
+ result = false;
2540
+ }
2541
+ const ret = result;
2542
+ return ret;
2543
+ };
2544
+ imports.wbg.__wbg_debug_5fb96680aecf5dc8 = function(arg0) {
2545
+ console.debug(getObject(arg0));
2546
+ };
2547
+ imports.wbg.__wbg_openCursor_425aba9cbe1d4d39 = function() {
2497
2548
  return handleError(function(arg0) {
2498
2549
  const ret = getObject(arg0).openCursor();
2499
2550
  return addHeapObject(ret);
2500
2551
  }, arguments);
2501
2552
  };
2502
- imports.wbg.__wbg_openCursor_611b1e488c393dd8 = function() {
2553
+ imports.wbg.__wbg_openCursor_e3042770817a8d57 = function() {
2503
2554
  return handleError(function(arg0, arg1) {
2504
2555
  const ret = getObject(arg0).openCursor(getObject(arg1));
2505
2556
  return addHeapObject(ret);
2506
2557
  }, arguments);
2507
2558
  };
2508
- imports.wbg.__wbg_put_22792e17580ca18b = function() {
2559
+ imports.wbg.__wbg_objectStoreNames_588b5924274239fd = function(arg0) {
2560
+ const ret = getObject(arg0).objectStoreNames;
2561
+ return addHeapObject(ret);
2562
+ };
2563
+ imports.wbg.__wbg_createObjectStore_882f2f6b1b1ef040 = function() {
2509
2564
  return handleError(function(arg0, arg1, arg2) {
2510
- const ret = getObject(arg0).put(getObject(arg1), getObject(arg2));
2511
- return addHeapObject(ret);
2512
- }, arguments);
2513
- };
2514
- imports.wbg.__wbg_target_2fc177e386c8b7b0 = function(arg0) {
2515
- const ret = getObject(arg0).target;
2516
- return isLikeNone(ret) ? 0 : addHeapObject(ret);
2517
- };
2518
- imports.wbg.__wbg_instanceof_IdbDatabase_db671cf2454a9542 = function(arg0) {
2519
- let result;
2520
- try {
2521
- result = getObject(arg0) instanceof IDBDatabase;
2522
- } catch (_) {
2523
- result = false;
2524
- }
2525
- const ret = result;
2526
- return ret;
2527
- };
2528
- imports.wbg.__wbg_objectStoreNames_588b5924274239fd = function(arg0) {
2529
- const ret = getObject(arg0).objectStoreNames;
2530
- return addHeapObject(ret);
2531
- };
2532
- imports.wbg.__wbg_close_6bfe4ca2fe67cb67 = function(arg0) {
2533
- getObject(arg0).close();
2534
- };
2535
- imports.wbg.__wbg_createObjectStore_882f2f6b1b1ef040 = function() {
2536
- return handleError(function(arg0, arg1, arg2) {
2537
- const ret = getObject(arg0).createObjectStore(getStringFromWasm0(arg1, arg2));
2565
+ const ret = getObject(arg0).createObjectStore(getStringFromWasm0(arg1, arg2));
2538
2566
  return addHeapObject(ret);
2539
2567
  }, arguments);
2540
2568
  };
@@ -2550,147 +2578,112 @@ ${val.stack}`;
2550
2578
  return addHeapObject(ret);
2551
2579
  }, arguments);
2552
2580
  };
2553
- imports.wbg.__wbg_objectStore_da468793bd9df17b = function() {
2554
- return handleError(function(arg0, arg1, arg2) {
2555
- const ret = getObject(arg0).objectStore(getStringFromWasm0(arg1, arg2));
2556
- return addHeapObject(ret);
2557
- }, arguments);
2581
+ imports.wbg.__wbg_close_6bfe4ca2fe67cb67 = function(arg0) {
2582
+ getObject(arg0).close();
2558
2583
  };
2559
- imports.wbg.__wbg_instanceof_IdbCursor_e572a9900478e938 = function(arg0) {
2584
+ imports.wbg.__wbg_instanceof_IdbDatabase_db671cf2454a9542 = function(arg0) {
2560
2585
  let result;
2561
2586
  try {
2562
- result = getObject(arg0) instanceof IDBCursor;
2587
+ result = getObject(arg0) instanceof IDBDatabase;
2563
2588
  } catch (_) {
2564
2589
  result = false;
2565
2590
  }
2566
2591
  const ret = result;
2567
2592
  return ret;
2568
2593
  };
2569
- imports.wbg.__wbg_primaryKey_ac28363943d108c5 = function() {
2594
+ imports.wbg.__wbg_openCursor_30d58ae27a327629 = function() {
2570
2595
  return handleError(function(arg0) {
2571
- const ret = getObject(arg0).primaryKey;
2596
+ const ret = getObject(arg0).openCursor();
2572
2597
  return addHeapObject(ret);
2573
2598
  }, arguments);
2574
2599
  };
2575
- imports.wbg.__wbg_continue_f1c3e0815924de62 = function() {
2576
- return handleError(function(arg0) {
2577
- getObject(arg0).continue();
2600
+ imports.wbg.__wbg_put_22792e17580ca18b = function() {
2601
+ return handleError(function(arg0, arg1, arg2) {
2602
+ const ret = getObject(arg0).put(getObject(arg1), getObject(arg2));
2603
+ return addHeapObject(ret);
2578
2604
  }, arguments);
2579
2605
  };
2580
- imports.wbg.__wbg_length_9ae5daf9a690cba9 = function(arg0) {
2581
- const ret = getObject(arg0).length;
2582
- return ret;
2583
- };
2584
- imports.wbg.__wbg_contains_c65b44400b549286 = function(arg0, arg1, arg2) {
2585
- const ret = getObject(arg0).contains(getStringFromWasm0(arg1, arg2));
2586
- return ret;
2587
- };
2588
- imports.wbg.__wbg_get_910bbb94abdcf488 = function(arg0, arg1, arg2) {
2589
- const ret = getObject(arg1)[arg2 >>> 0];
2590
- var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2591
- var len1 = WASM_VECTOR_LEN;
2592
- getInt32Memory0()[arg0 / 4 + 1] = len1;
2593
- getInt32Memory0()[arg0 / 4 + 0] = ptr1;
2594
- };
2595
- imports.wbg.__wbg_instanceof_IdbCursorWithValue_abeb44d13d947bc2 = function(arg0) {
2596
- let result;
2597
- try {
2598
- result = getObject(arg0) instanceof IDBCursorWithValue;
2599
- } catch (_) {
2600
- result = false;
2601
- }
2602
- const ret = result;
2603
- return ret;
2604
- };
2605
- imports.wbg.__wbg_value_86d3334f5075b232 = function() {
2606
- return handleError(function(arg0) {
2607
- const ret = getObject(arg0).value;
2606
+ imports.wbg.__wbg_openCursor_611b1e488c393dd8 = function() {
2607
+ return handleError(function(arg0, arg1) {
2608
+ const ret = getObject(arg0).openCursor(getObject(arg1));
2608
2609
  return addHeapObject(ret);
2609
2610
  }, arguments);
2610
2611
  };
2611
- imports.wbg.__wbg_open_f0d7259fd7e689ce = function() {
2612
- return handleError(function(arg0, arg1, arg2, arg3) {
2613
- const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2), arg3 >>> 0);
2612
+ imports.wbg.__wbg_get_5361b64cac0d0826 = function() {
2613
+ return handleError(function(arg0, arg1) {
2614
+ const ret = getObject(arg0).get(getObject(arg1));
2614
2615
  return addHeapObject(ret);
2615
2616
  }, arguments);
2616
2617
  };
2617
- imports.wbg.__wbg_bound_25385469508e98c7 = function() {
2618
- return handleError(function(arg0, arg1, arg2, arg3) {
2619
- const ret = IDBKeyRange.bound(getObject(arg0), getObject(arg1), arg2 !== 0, arg3 !== 0);
2618
+ imports.wbg.__wbg_createIndex_b8da1f5571f644be = function() {
2619
+ return handleError(function(arg0, arg1, arg2, arg3, arg4, arg5) {
2620
+ const ret = getObject(arg0).createIndex(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4), getObject(arg5));
2620
2621
  return addHeapObject(ret);
2621
2622
  }, arguments);
2622
2623
  };
2623
- imports.wbg.__wbg_lowerBound_cd1c8a3b3fdf1582 = function() {
2624
- return handleError(function(arg0) {
2625
- const ret = IDBKeyRange.lowerBound(getObject(arg0));
2624
+ imports.wbg.__wbg_index_383b6812c1508030 = function() {
2625
+ return handleError(function(arg0, arg1, arg2) {
2626
+ const ret = getObject(arg0).index(getStringFromWasm0(arg1, arg2));
2626
2627
  return addHeapObject(ret);
2627
2628
  }, arguments);
2628
2629
  };
2629
- imports.wbg.__wbg_lowerBound_e77f6e14cb69151e = function() {
2630
+ imports.wbg.__wbg_delete_f60bba7d0ae59a4f = function() {
2630
2631
  return handleError(function(arg0, arg1) {
2631
- const ret = IDBKeyRange.lowerBound(getObject(arg0), arg1 !== 0);
2632
+ const ret = getObject(arg0).delete(getObject(arg1));
2632
2633
  return addHeapObject(ret);
2633
2634
  }, arguments);
2634
2635
  };
2635
- imports.wbg.__wbg_only_cacf767244bdc280 = function() {
2636
- return handleError(function(arg0) {
2637
- const ret = IDBKeyRange.only(getObject(arg0));
2638
- return addHeapObject(ret);
2639
- }, arguments);
2636
+ imports.wbg.__wbg_target_2fc177e386c8b7b0 = function(arg0) {
2637
+ const ret = getObject(arg0).target;
2638
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
2640
2639
  };
2641
- imports.wbg.__wbg_upperBound_1e3077b2c05bdd71 = function() {
2640
+ imports.wbg.__wbg_setonerror_8479b33e7568a904 = function(arg0, arg1) {
2641
+ getObject(arg0).onerror = getObject(arg1);
2642
+ };
2643
+ imports.wbg.__wbg_setonsuccess_632ce0a1460455c2 = function(arg0, arg1) {
2644
+ getObject(arg0).onsuccess = getObject(arg1);
2645
+ };
2646
+ imports.wbg.__wbg_error_685b20024dc2d6ca = function() {
2642
2647
  return handleError(function(arg0) {
2643
- const ret = IDBKeyRange.upperBound(getObject(arg0));
2644
- return addHeapObject(ret);
2648
+ const ret = getObject(arg0).error;
2649
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
2645
2650
  }, arguments);
2646
2651
  };
2647
- imports.wbg.__wbg_upperBound_4c692da072d1a11e = function() {
2648
- return handleError(function(arg0, arg1) {
2649
- const ret = IDBKeyRange.upperBound(getObject(arg0), arg1 !== 0);
2652
+ imports.wbg.__wbg_result_6cedf5f78600a79c = function() {
2653
+ return handleError(function(arg0) {
2654
+ const ret = getObject(arg0).result;
2650
2655
  return addHeapObject(ret);
2651
2656
  }, arguments);
2652
2657
  };
2653
- imports.wbg.__wbg_instanceof_IdbOpenDbRequest_3f4a166bc0340578 = function(arg0) {
2658
+ imports.wbg.__wbg_instanceof_IdbRequest_93249da04f5370b6 = function(arg0) {
2654
2659
  let result;
2655
2660
  try {
2656
- result = getObject(arg0) instanceof IDBOpenDBRequest;
2661
+ result = getObject(arg0) instanceof IDBRequest;
2657
2662
  } catch (_) {
2658
2663
  result = false;
2659
2664
  }
2660
2665
  const ret = result;
2661
2666
  return ret;
2662
2667
  };
2668
+ imports.wbg.__wbg_objectStore_da468793bd9df17b = function() {
2669
+ return handleError(function(arg0, arg1, arg2) {
2670
+ const ret = getObject(arg0).objectStore(getStringFromWasm0(arg1, arg2));
2671
+ return addHeapObject(ret);
2672
+ }, arguments);
2673
+ };
2663
2674
  imports.wbg.__wbg_setonupgradeneeded_ad7645373c7d5e1b = function(arg0, arg1) {
2664
2675
  getObject(arg0).onupgradeneeded = getObject(arg1);
2665
2676
  };
2666
- imports.wbg.__wbg_instanceof_IdbRequest_93249da04f5370b6 = function(arg0) {
2677
+ imports.wbg.__wbg_instanceof_IdbOpenDbRequest_3f4a166bc0340578 = function(arg0) {
2667
2678
  let result;
2668
2679
  try {
2669
- result = getObject(arg0) instanceof IDBRequest;
2680
+ result = getObject(arg0) instanceof IDBOpenDBRequest;
2670
2681
  } catch (_) {
2671
2682
  result = false;
2672
2683
  }
2673
2684
  const ret = result;
2674
2685
  return ret;
2675
2686
  };
2676
- imports.wbg.__wbg_result_6cedf5f78600a79c = function() {
2677
- return handleError(function(arg0) {
2678
- const ret = getObject(arg0).result;
2679
- return addHeapObject(ret);
2680
- }, arguments);
2681
- };
2682
- imports.wbg.__wbg_error_685b20024dc2d6ca = function() {
2683
- return handleError(function(arg0) {
2684
- const ret = getObject(arg0).error;
2685
- return isLikeNone(ret) ? 0 : addHeapObject(ret);
2686
- }, arguments);
2687
- };
2688
- imports.wbg.__wbg_setonsuccess_632ce0a1460455c2 = function(arg0, arg1) {
2689
- getObject(arg0).onsuccess = getObject(arg1);
2690
- };
2691
- imports.wbg.__wbg_setonerror_8479b33e7568a904 = function(arg0, arg1) {
2692
- getObject(arg0).onerror = getObject(arg1);
2693
- };
2694
2687
  imports.wbg.__wbindgen_jsval_loose_eq = function(arg0, arg1) {
2695
2688
  const ret = getObject(arg0) == getObject(arg1);
2696
2689
  return ret;
@@ -2699,13 +2692,6 @@ ${val.stack}`;
2699
2692
  const ret = +getObject(arg0);
2700
2693
  return ret;
2701
2694
  };
2702
- imports.wbg.__wbg_String_389b54bd9d25375f = function(arg0, arg1) {
2703
- const ret = String(getObject(arg1));
2704
- const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2705
- const len1 = WASM_VECTOR_LEN;
2706
- getInt32Memory0()[arg0 / 4 + 1] = len1;
2707
- getInt32Memory0()[arg0 / 4 + 0] = ptr1;
2708
- };
2709
2695
  imports.wbg.__wbg_getwithrefkey_4a92a5eca60879b9 = function(arg0, arg1) {
2710
2696
  const ret = getObject(arg0)[getObject(arg1)];
2711
2697
  return addHeapObject(ret);
@@ -2713,22 +2699,15 @@ ${val.stack}`;
2713
2699
  imports.wbg.__wbg_set_9182712abebf82ef = function(arg0, arg1, arg2) {
2714
2700
  getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
2715
2701
  };
2716
- imports.wbg.__wbg_log_28eee4e6432efd24 = function(arg0, arg1) {
2717
- console.log(getStringFromWasm0(arg0, arg1));
2718
- };
2719
- imports.wbg.__wbg_String_55b8bdc4bc243677 = function(arg0, arg1) {
2702
+ imports.wbg.__wbg_String_389b54bd9d25375f = function(arg0, arg1) {
2720
2703
  const ret = String(getObject(arg1));
2721
2704
  const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2722
2705
  const len1 = WASM_VECTOR_LEN;
2723
2706
  getInt32Memory0()[arg0 / 4 + 1] = len1;
2724
2707
  getInt32Memory0()[arg0 / 4 + 0] = ptr1;
2725
2708
  };
2726
- imports.wbg.__wbg_getElementById_8458f2a6c28467dc = function(arg0, arg1, arg2) {
2727
- const ret = getObject(arg0).getElementById(getStringFromWasm0(arg1, arg2));
2728
- return addHeapObject(ret);
2729
- };
2730
- imports.wbg.__wbg_settextcontent_fc3ff485b96fcb1d = function(arg0, arg1, arg2) {
2731
- getObject(arg0).textContent = getStringFromWasm0(arg1, arg2);
2709
+ imports.wbg.__wbg_log_28eee4e6432efd24 = function(arg0, arg1) {
2710
+ console.log(getStringFromWasm0(arg0, arg1));
2732
2711
  };
2733
2712
  imports.wbg.__wbg_wbgtestinvoke_8c20f4132af2bded = function() {
2734
2713
  return handleError(function(arg0, arg1) {
@@ -2738,7 +2717,7 @@ ${val.stack}`;
2738
2717
  const a = state0.a;
2739
2718
  state0.a = 0;
2740
2719
  try {
2741
- return __wbg_adapter_304(a, state0.b);
2720
+ return __wbg_adapter_287(a, state0.b);
2742
2721
  } finally {
2743
2722
  state0.a = a;
2744
2723
  }
@@ -2749,13 +2728,20 @@ ${val.stack}`;
2749
2728
  }
2750
2729
  }, arguments);
2751
2730
  };
2752
- imports.wbg.__wbg_wbgtestoutputwriteln_4db3bd64914ec955 = function(arg0) {
2753
- __wbg_test_output_writeln(takeObject(arg0));
2754
- };
2755
- imports.wbg.__wbg_stack_436273c21658169b = function(arg0) {
2756
- const ret = getObject(arg0).stack;
2731
+ imports.wbg.__wbg_getElementById_8458f2a6c28467dc = function(arg0, arg1, arg2) {
2732
+ const ret = getObject(arg0).getElementById(getStringFromWasm0(arg1, arg2));
2757
2733
  return addHeapObject(ret);
2758
2734
  };
2735
+ imports.wbg.__wbg_settextcontent_fc3ff485b96fcb1d = function(arg0, arg1, arg2) {
2736
+ getObject(arg0).textContent = getStringFromWasm0(arg1, arg2);
2737
+ };
2738
+ imports.wbg.__wbg_String_55b8bdc4bc243677 = function(arg0, arg1) {
2739
+ const ret = String(getObject(arg1));
2740
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2741
+ const len1 = WASM_VECTOR_LEN;
2742
+ getInt32Memory0()[arg0 / 4 + 1] = len1;
2743
+ getInt32Memory0()[arg0 / 4 + 0] = ptr1;
2744
+ };
2759
2745
  imports.wbg.__wbg_self_55106357ec10ecd4 = function(arg0) {
2760
2746
  const ret = getObject(arg0).self;
2761
2747
  return isLikeNone(ret) ? 0 : addHeapObject(ret);
@@ -2771,8 +2757,12 @@ ${val.stack}`;
2771
2757
  getInt32Memory0()[arg0 / 4 + 1] = len1;
2772
2758
  getInt32Memory0()[arg0 / 4 + 0] = ptr1;
2773
2759
  };
2774
- imports.wbg.__wbg_textcontent_67e4e811cbdf00fc = function(arg0, arg1) {
2775
- const ret = getObject(arg1).textContent;
2760
+ imports.wbg.__wbg_static_accessor_document_d4b6ae7f5578480f = function() {
2761
+ const ret = document;
2762
+ return addHeapObject(ret);
2763
+ };
2764
+ imports.wbg.__wbg_stack_17c77e9f5bfe6714 = function(arg0, arg1) {
2765
+ const ret = getObject(arg1).stack;
2776
2766
  const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2777
2767
  const len1 = WASM_VECTOR_LEN;
2778
2768
  getInt32Memory0()[arg0 / 4 + 1] = len1;
@@ -2782,17 +2772,20 @@ ${val.stack}`;
2782
2772
  const ret = getObject(arg0).stack;
2783
2773
  return addHeapObject(ret);
2784
2774
  };
2785
- imports.wbg.__wbg_static_accessor_document_d4b6ae7f5578480f = function() {
2786
- const ret = document;
2787
- return addHeapObject(ret);
2788
- };
2789
- imports.wbg.__wbg_stack_17c77e9f5bfe6714 = function(arg0, arg1) {
2790
- const ret = getObject(arg1).stack;
2775
+ imports.wbg.__wbg_textcontent_67e4e811cbdf00fc = function(arg0, arg1) {
2776
+ const ret = getObject(arg1).textContent;
2791
2777
  const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2792
2778
  const len1 = WASM_VECTOR_LEN;
2793
2779
  getInt32Memory0()[arg0 / 4 + 1] = len1;
2794
2780
  getInt32Memory0()[arg0 / 4 + 0] = ptr1;
2795
2781
  };
2782
+ imports.wbg.__wbg_stack_436273c21658169b = function(arg0) {
2783
+ const ret = getObject(arg0).stack;
2784
+ return addHeapObject(ret);
2785
+ };
2786
+ imports.wbg.__wbg_wbgtestoutputwriteln_4db3bd64914ec955 = function(arg0) {
2787
+ __wbg_test_output_writeln(takeObject(arg0));
2788
+ };
2796
2789
  imports.wbg.__wbg_new_abda76e883ba8a5f = function() {
2797
2790
  const ret = new Error();
2798
2791
  return addHeapObject(ret);
@@ -2815,94 +2808,113 @@ ${val.stack}`;
2815
2808
  wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
2816
2809
  }
2817
2810
  };
2818
- imports.wbg.__wbg_queueMicrotask_3cbae2ec6b6cd3d6 = function(arg0) {
2819
- const ret = getObject(arg0).queueMicrotask;
2820
- return addHeapObject(ret);
2821
- };
2822
2811
  imports.wbg.__wbg_queueMicrotask_481971b0d87f3dd4 = function(arg0) {
2823
2812
  queueMicrotask(getObject(arg0));
2824
2813
  };
2825
- imports.wbg.__wbg_get_bd8e338fbd5f5cc8 = function(arg0, arg1) {
2826
- const ret = getObject(arg0)[arg1 >>> 0];
2814
+ imports.wbg.__wbg_queueMicrotask_3cbae2ec6b6cd3d6 = function(arg0) {
2815
+ const ret = getObject(arg0).queueMicrotask;
2827
2816
  return addHeapObject(ret);
2828
2817
  };
2829
- imports.wbg.__wbg_length_cd7af8117672b8b8 = function(arg0) {
2830
- const ret = getObject(arg0).length;
2831
- return ret;
2818
+ imports.wbg.__wbg_new_d9bc3a0147634640 = function() {
2819
+ const ret = /* @__PURE__ */ new Map();
2820
+ return addHeapObject(ret);
2832
2821
  };
2833
2822
  imports.wbg.__wbg_new_16b304a2cfa7ff4a = function() {
2834
2823
  const ret = new Array();
2835
2824
  return addHeapObject(ret);
2836
2825
  };
2826
+ imports.wbg.__wbg_new_72fb9a18b5ae2624 = function() {
2827
+ const ret = new Object();
2828
+ return addHeapObject(ret);
2829
+ };
2837
2830
  imports.wbg.__wbg_newnoargs_e258087cd0daa0ea = function(arg0, arg1) {
2838
2831
  const ret = new Function(getStringFromWasm0(arg0, arg1));
2839
2832
  return addHeapObject(ret);
2840
2833
  };
2841
- imports.wbg.__wbg_new_d9bc3a0147634640 = function() {
2842
- const ret = /* @__PURE__ */ new Map();
2834
+ imports.wbg.__wbg_new_63b92bc8671ed464 = function(arg0) {
2835
+ const ret = new Uint8Array(getObject(arg0));
2843
2836
  return addHeapObject(ret);
2844
2837
  };
2845
- imports.wbg.__wbg_next_40fc327bfc8770e6 = function(arg0) {
2846
- const ret = getObject(arg0).next;
2838
+ imports.wbg.__wbg_buffer_12d079cc21e14bdb = function(arg0) {
2839
+ const ret = getObject(arg0).buffer;
2847
2840
  return addHeapObject(ret);
2848
2841
  };
2849
- imports.wbg.__wbg_next_196c84450b364254 = function() {
2850
- return handleError(function(arg0) {
2851
- const ret = getObject(arg0).next();
2852
- return addHeapObject(ret);
2853
- }, arguments);
2854
- };
2855
- imports.wbg.__wbg_done_298b57d23c0fc80c = function(arg0) {
2856
- const ret = getObject(arg0).done;
2857
- return ret;
2842
+ imports.wbg.__wbg_newwithbyteoffsetandlength_aa4a17c33a06e5cb = function(arg0, arg1, arg2) {
2843
+ const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
2844
+ return addHeapObject(ret);
2858
2845
  };
2859
- imports.wbg.__wbg_value_d93c65011f51a456 = function(arg0) {
2860
- const ret = getObject(arg0).value;
2846
+ imports.wbg.__wbg_newwithlength_e9b4878cebadb3d3 = function(arg0) {
2847
+ const ret = new Uint8Array(arg0 >>> 0);
2861
2848
  return addHeapObject(ret);
2862
2849
  };
2863
- imports.wbg.__wbg_iterator_2cee6dadfd956dfa = function() {
2864
- const ret = Symbol.iterator;
2850
+ imports.wbg.__wbg_set_a47bac70306a19a7 = function(arg0, arg1, arg2) {
2851
+ getObject(arg0).set(getObject(arg1), arg2 >>> 0);
2852
+ };
2853
+ imports.wbg.__wbg_length_c20a40f15020d68a = function(arg0) {
2854
+ const ret = getObject(arg0).length;
2855
+ return ret;
2856
+ };
2857
+ imports.wbg.__wbg_subarray_a1f73cd4b5b42fe1 = function(arg0, arg1, arg2) {
2858
+ const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
2865
2859
  return addHeapObject(ret);
2866
2860
  };
2867
- imports.wbg.__wbg_get_e3c254076557e348 = function() {
2868
- return handleError(function(arg0, arg1) {
2869
- const ret = Reflect.get(getObject(arg0), getObject(arg1));
2870
- return addHeapObject(ret);
2871
- }, arguments);
2861
+ imports.wbg.__wbg_done_298b57d23c0fc80c = function(arg0) {
2862
+ const ret = getObject(arg0).done;
2863
+ return ret;
2872
2864
  };
2873
- imports.wbg.__wbg_call_27c0f87801dedf93 = function() {
2874
- return handleError(function(arg0, arg1) {
2875
- const ret = getObject(arg0).call(getObject(arg1));
2876
- return addHeapObject(ret);
2877
- }, arguments);
2865
+ imports.wbg.__wbg_value_d93c65011f51a456 = function(arg0) {
2866
+ const ret = getObject(arg0).value;
2867
+ return addHeapObject(ret);
2878
2868
  };
2879
- imports.wbg.__wbg_new_72fb9a18b5ae2624 = function() {
2880
- const ret = new Object();
2869
+ imports.wbg.__wbg_instanceof_Object_71ca3c0a59266746 = function(arg0) {
2870
+ let result;
2871
+ try {
2872
+ result = getObject(arg0) instanceof Object;
2873
+ } catch (_) {
2874
+ result = false;
2875
+ }
2876
+ const ret = result;
2877
+ return ret;
2878
+ };
2879
+ imports.wbg.__wbg_instanceof_Uint8Array_2b3bbecd033d19f6 = function(arg0) {
2880
+ let result;
2881
+ try {
2882
+ result = getObject(arg0) instanceof Uint8Array;
2883
+ } catch (_) {
2884
+ result = false;
2885
+ }
2886
+ const ret = result;
2887
+ return ret;
2888
+ };
2889
+ imports.wbg.__wbg_instanceof_ArrayBuffer_836825be07d4c9d2 = function(arg0) {
2890
+ let result;
2891
+ try {
2892
+ result = getObject(arg0) instanceof ArrayBuffer;
2893
+ } catch (_) {
2894
+ result = false;
2895
+ }
2896
+ const ret = result;
2897
+ return ret;
2898
+ };
2899
+ imports.wbg.__wbg_set_8417257aaedc936b = function(arg0, arg1, arg2) {
2900
+ const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
2881
2901
  return addHeapObject(ret);
2882
2902
  };
2883
- imports.wbg.__wbg_self_ce0dbfc45cf2f5be = function() {
2884
- return handleError(function() {
2885
- const ret = self.self;
2886
- return addHeapObject(ret);
2887
- }, arguments);
2903
+ imports.wbg.__wbg_new0_7d84e5b2cd9fdc73 = function() {
2904
+ const ret = /* @__PURE__ */ new Date();
2905
+ return addHeapObject(ret);
2888
2906
  };
2889
- imports.wbg.__wbg_window_c6fb939a7f436783 = function() {
2890
- return handleError(function() {
2891
- const ret = window.window;
2892
- return addHeapObject(ret);
2893
- }, arguments);
2907
+ imports.wbg.__wbg_getTime_2bc4375165f02d15 = function(arg0) {
2908
+ const ret = getObject(arg0).getTime();
2909
+ return ret;
2894
2910
  };
2895
- imports.wbg.__wbg_globalThis_d1e6af4856ba331b = function() {
2896
- return handleError(function() {
2897
- const ret = globalThis.globalThis;
2898
- return addHeapObject(ret);
2899
- }, arguments);
2911
+ imports.wbg.__wbg_get_bd8e338fbd5f5cc8 = function(arg0, arg1) {
2912
+ const ret = getObject(arg0)[arg1 >>> 0];
2913
+ return addHeapObject(ret);
2900
2914
  };
2901
- imports.wbg.__wbg_global_207b558942527489 = function() {
2902
- return handleError(function() {
2903
- const ret = global.global;
2904
- return addHeapObject(ret);
2905
- }, arguments);
2915
+ imports.wbg.__wbg_of_4a2b313a453ec059 = function(arg0) {
2916
+ const ret = Array.of(getObject(arg0));
2917
+ return addHeapObject(ret);
2906
2918
  };
2907
2919
  imports.wbg.__wbg_set_d4638f722068f043 = function(arg0, arg1, arg2) {
2908
2920
  getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
@@ -2911,6 +2923,14 @@ ${val.stack}`;
2911
2923
  const ret = Array.from(getObject(arg0));
2912
2924
  return addHeapObject(ret);
2913
2925
  };
2926
+ imports.wbg.__wbg_length_cd7af8117672b8b8 = function(arg0) {
2927
+ const ret = getObject(arg0).length;
2928
+ return ret;
2929
+ };
2930
+ imports.wbg.__wbg_push_a5b05aedc7234f9f = function(arg0, arg1) {
2931
+ const ret = getObject(arg0).push(getObject(arg1));
2932
+ return ret;
2933
+ };
2914
2934
  imports.wbg.__wbg_forEach_2be8de7347d63332 = function(arg0, arg1, arg2) {
2915
2935
  try {
2916
2936
  var state0 = { a: arg1, b: arg2 };
@@ -2918,7 +2938,7 @@ ${val.stack}`;
2918
2938
  const a = state0.a;
2919
2939
  state0.a = 0;
2920
2940
  try {
2921
- return __wbg_adapter_347(a, state0.b, arg02, arg12, arg22);
2941
+ return __wbg_adapter_378(a, state0.b, arg02, arg12, arg22);
2922
2942
  } finally {
2923
2943
  state0.a = a;
2924
2944
  }
@@ -2932,70 +2952,26 @@ ${val.stack}`;
2932
2952
  const ret = Array.isArray(getObject(arg0));
2933
2953
  return ret;
2934
2954
  };
2935
- imports.wbg.__wbg_of_4a2b313a453ec059 = function(arg0) {
2936
- const ret = Array.of(getObject(arg0));
2937
- return addHeapObject(ret);
2938
- };
2939
- imports.wbg.__wbg_push_a5b05aedc7234f9f = function(arg0, arg1) {
2940
- const ret = getObject(arg0).push(getObject(arg1));
2941
- return ret;
2942
- };
2943
- imports.wbg.__wbg_instanceof_ArrayBuffer_836825be07d4c9d2 = function(arg0) {
2944
- let result;
2945
- try {
2946
- result = getObject(arg0) instanceof ArrayBuffer;
2947
- } catch (_) {
2948
- result = false;
2949
- }
2950
- const ret = result;
2951
- return ret;
2952
- };
2953
- imports.wbg.__wbg_message_5bf28016c2b49cfb = function(arg0) {
2954
- const ret = getObject(arg0).message;
2955
- return addHeapObject(ret);
2956
- };
2957
2955
  imports.wbg.__wbg_name_e7429f0dda6079e2 = function(arg0) {
2958
2956
  const ret = getObject(arg0).name;
2959
2957
  return addHeapObject(ret);
2960
2958
  };
2961
- imports.wbg.__wbg_call_b3ca7c6051f9bec1 = function() {
2962
- return handleError(function(arg0, arg1, arg2) {
2963
- const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
2964
- return addHeapObject(ret);
2965
- }, arguments);
2966
- };
2967
- imports.wbg.__wbg_call_938992c832f74314 = function() {
2968
- return handleError(function(arg0, arg1, arg2, arg3, arg4) {
2969
- const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3), getObject(arg4));
2970
- return addHeapObject(ret);
2971
- }, arguments);
2972
- };
2973
- imports.wbg.__wbg_set_8417257aaedc936b = function(arg0, arg1, arg2) {
2974
- const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
2959
+ imports.wbg.__wbg_message_5bf28016c2b49cfb = function(arg0) {
2960
+ const ret = getObject(arg0).message;
2975
2961
  return addHeapObject(ret);
2976
2962
  };
2977
2963
  imports.wbg.__wbg_isSafeInteger_f7b04ef02296c4d2 = function(arg0) {
2978
2964
  const ret = Number.isSafeInteger(getObject(arg0));
2979
2965
  return ret;
2980
2966
  };
2981
- imports.wbg.__wbg_getTime_2bc4375165f02d15 = function(arg0) {
2982
- const ret = getObject(arg0).getTime();
2967
+ imports.wbg.__wbg_is_010fdc0f4ab96916 = function(arg0, arg1) {
2968
+ const ret = Object.is(getObject(arg0), getObject(arg1));
2983
2969
  return ret;
2984
2970
  };
2985
- imports.wbg.__wbg_new0_7d84e5b2cd9fdc73 = function() {
2986
- const ret = /* @__PURE__ */ new Date();
2971
+ imports.wbg.__wbg_keys_91e412b4b222659f = function(arg0) {
2972
+ const ret = Object.keys(getObject(arg0));
2987
2973
  return addHeapObject(ret);
2988
2974
  };
2989
- imports.wbg.__wbg_instanceof_Object_71ca3c0a59266746 = function(arg0) {
2990
- let result;
2991
- try {
2992
- result = getObject(arg0) instanceof Object;
2993
- } catch (_) {
2994
- result = false;
2995
- }
2996
- const ret = result;
2997
- return ret;
2998
- };
2999
2975
  imports.wbg.__wbg_assign_496d2d14fecafbcf = function(arg0, arg1) {
3000
2976
  const ret = Object.assign(getObject(arg0), getObject(arg1));
3001
2977
  return addHeapObject(ret);
@@ -3004,14 +2980,40 @@ ${val.stack}`;
3004
2980
  const ret = Object.entries(getObject(arg0));
3005
2981
  return addHeapObject(ret);
3006
2982
  };
3007
- imports.wbg.__wbg_is_010fdc0f4ab96916 = function(arg0, arg1) {
3008
- const ret = Object.is(getObject(arg0), getObject(arg1));
3009
- return ret;
3010
- };
3011
- imports.wbg.__wbg_keys_91e412b4b222659f = function(arg0) {
3012
- const ret = Object.keys(getObject(arg0));
2983
+ imports.wbg.__wbg_iterator_2cee6dadfd956dfa = function() {
2984
+ const ret = Symbol.iterator;
3013
2985
  return addHeapObject(ret);
3014
2986
  };
2987
+ imports.wbg.__wbg_self_ce0dbfc45cf2f5be = function() {
2988
+ return handleError(function() {
2989
+ const ret = self.self;
2990
+ return addHeapObject(ret);
2991
+ }, arguments);
2992
+ };
2993
+ imports.wbg.__wbg_window_c6fb939a7f436783 = function() {
2994
+ return handleError(function() {
2995
+ const ret = window.window;
2996
+ return addHeapObject(ret);
2997
+ }, arguments);
2998
+ };
2999
+ imports.wbg.__wbg_globalThis_d1e6af4856ba331b = function() {
3000
+ return handleError(function() {
3001
+ const ret = globalThis.globalThis;
3002
+ return addHeapObject(ret);
3003
+ }, arguments);
3004
+ };
3005
+ imports.wbg.__wbg_global_207b558942527489 = function() {
3006
+ return handleError(function() {
3007
+ const ret = global.global;
3008
+ return addHeapObject(ret);
3009
+ }, arguments);
3010
+ };
3011
+ imports.wbg.__wbg_call_27c0f87801dedf93 = function() {
3012
+ return handleError(function(arg0, arg1) {
3013
+ const ret = getObject(arg0).call(getObject(arg1));
3014
+ return addHeapObject(ret);
3015
+ }, arguments);
3016
+ };
3015
3017
  imports.wbg.__wbg_new_81740750da40724f = function(arg0, arg1) {
3016
3018
  try {
3017
3019
  var state0 = { a: arg0, b: arg1 };
@@ -3019,7 +3021,7 @@ ${val.stack}`;
3019
3021
  const a = state0.a;
3020
3022
  state0.a = 0;
3021
3023
  try {
3022
- return __wbg_adapter_404(a, state0.b, arg02, arg12);
3024
+ return __wbg_adapter_395(a, state0.b, arg02, arg12);
3023
3025
  } finally {
3024
3026
  state0.a = a;
3025
3027
  }
@@ -3030,10 +3032,6 @@ ${val.stack}`;
3030
3032
  state0.a = state0.b = 0;
3031
3033
  }
3032
3034
  };
3033
- imports.wbg.__wbg_resolve_b0083a7967828ec8 = function(arg0) {
3034
- const ret = Promise.resolve(getObject(arg0));
3035
- return addHeapObject(ret);
3036
- };
3037
3035
  imports.wbg.__wbg_then_0c86a60e8fcfe9f6 = function(arg0, arg1) {
3038
3036
  const ret = getObject(arg0).then(getObject(arg1));
3039
3037
  return addHeapObject(ret);
@@ -3042,46 +3040,47 @@ ${val.stack}`;
3042
3040
  const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
3043
3041
  return addHeapObject(ret);
3044
3042
  };
3045
- imports.wbg.__wbg_buffer_12d079cc21e14bdb = function(arg0) {
3046
- const ret = getObject(arg0).buffer;
3047
- return addHeapObject(ret);
3048
- };
3049
- imports.wbg.__wbg_newwithbyteoffsetandlength_aa4a17c33a06e5cb = function(arg0, arg1, arg2) {
3050
- const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
3043
+ imports.wbg.__wbg_resolve_b0083a7967828ec8 = function(arg0) {
3044
+ const ret = Promise.resolve(getObject(arg0));
3051
3045
  return addHeapObject(ret);
3052
3046
  };
3053
- imports.wbg.__wbg_new_63b92bc8671ed464 = function(arg0) {
3054
- const ret = new Uint8Array(getObject(arg0));
3055
- return addHeapObject(ret);
3047
+ imports.wbg.__wbg_call_b3ca7c6051f9bec1 = function() {
3048
+ return handleError(function(arg0, arg1, arg2) {
3049
+ const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
3050
+ return addHeapObject(ret);
3051
+ }, arguments);
3056
3052
  };
3057
- imports.wbg.__wbg_set_a47bac70306a19a7 = function(arg0, arg1, arg2) {
3058
- getObject(arg0).set(getObject(arg1), arg2 >>> 0);
3053
+ imports.wbg.__wbg_call_938992c832f74314 = function() {
3054
+ return handleError(function(arg0, arg1, arg2, arg3, arg4) {
3055
+ const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3), getObject(arg4));
3056
+ return addHeapObject(ret);
3057
+ }, arguments);
3059
3058
  };
3060
- imports.wbg.__wbg_length_c20a40f15020d68a = function(arg0) {
3061
- const ret = getObject(arg0).length;
3062
- return ret;
3059
+ imports.wbg.__wbg_next_40fc327bfc8770e6 = function(arg0) {
3060
+ const ret = getObject(arg0).next;
3061
+ return addHeapObject(ret);
3063
3062
  };
3064
- imports.wbg.__wbg_instanceof_Uint8Array_2b3bbecd033d19f6 = function(arg0) {
3065
- let result;
3066
- try {
3067
- result = getObject(arg0) instanceof Uint8Array;
3068
- } catch (_) {
3069
- result = false;
3070
- }
3071
- const ret = result;
3072
- return ret;
3063
+ imports.wbg.__wbg_next_196c84450b364254 = function() {
3064
+ return handleError(function(arg0) {
3065
+ const ret = getObject(arg0).next();
3066
+ return addHeapObject(ret);
3067
+ }, arguments);
3073
3068
  };
3074
- imports.wbg.__wbg_newwithlength_e9b4878cebadb3d3 = function(arg0) {
3075
- const ret = new Uint8Array(arg0 >>> 0);
3076
- return addHeapObject(ret);
3069
+ imports.wbg.__wbg_get_e3c254076557e348 = function() {
3070
+ return handleError(function(arg0, arg1) {
3071
+ const ret = Reflect.get(getObject(arg0), getObject(arg1));
3072
+ return addHeapObject(ret);
3073
+ }, arguments);
3077
3074
  };
3078
- imports.wbg.__wbg_subarray_a1f73cd4b5b42fe1 = function(arg0, arg1, arg2) {
3079
- const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
3080
- return addHeapObject(ret);
3075
+ imports.wbg.__wbg_parse_66d1801634e099ac = function() {
3076
+ return handleError(function(arg0, arg1) {
3077
+ const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
3078
+ return addHeapObject(ret);
3079
+ }, arguments);
3081
3080
  };
3082
- imports.wbg.__wbg_apply_0a5aa603881e6d79 = function() {
3083
- return handleError(function(arg0, arg1, arg2) {
3084
- const ret = Reflect.apply(getObject(arg0), getObject(arg1), getObject(arg2));
3081
+ imports.wbg.__wbg_stringify_8887fe74e1c50d81 = function() {
3082
+ return handleError(function(arg0) {
3083
+ const ret = JSON.stringify(getObject(arg0));
3085
3084
  return addHeapObject(ret);
3086
3085
  }, arguments);
3087
3086
  };
@@ -3103,15 +3102,9 @@ ${val.stack}`;
3103
3102
  return ret;
3104
3103
  }, arguments);
3105
3104
  };
3106
- imports.wbg.__wbg_parse_66d1801634e099ac = function() {
3107
- return handleError(function(arg0, arg1) {
3108
- const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
3109
- return addHeapObject(ret);
3110
- }, arguments);
3111
- };
3112
- imports.wbg.__wbg_stringify_8887fe74e1c50d81 = function() {
3113
- return handleError(function(arg0) {
3114
- const ret = JSON.stringify(getObject(arg0));
3105
+ imports.wbg.__wbg_apply_0a5aa603881e6d79 = function() {
3106
+ return handleError(function(arg0, arg1, arg2) {
3107
+ const ret = Reflect.apply(getObject(arg0), getObject(arg1), getObject(arg2));
3115
3108
  return addHeapObject(ret);
3116
3109
  }, arguments);
3117
3110
  };
@@ -3121,6 +3114,13 @@ ${val.stack}`;
3121
3114
  getBigInt64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? BigInt(0) : ret;
3122
3115
  getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
3123
3116
  };
3117
+ imports.wbg.__wbindgen_memory = function() {
3118
+ const ret = wasm.memory;
3119
+ return addHeapObject(ret);
3120
+ };
3121
+ imports.wbg.__wbindgen_throw = function(arg0, arg1) {
3122
+ throw new Error(getStringFromWasm0(arg0, arg1));
3123
+ };
3124
3124
  imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
3125
3125
  const ret = debugString(getObject(arg1));
3126
3126
  const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -3128,23 +3128,16 @@ ${val.stack}`;
3128
3128
  getInt32Memory0()[arg0 / 4 + 1] = len1;
3129
3129
  getInt32Memory0()[arg0 / 4 + 0] = ptr1;
3130
3130
  };
3131
- imports.wbg.__wbindgen_throw = function(arg0, arg1) {
3132
- throw new Error(getStringFromWasm0(arg0, arg1));
3133
- };
3134
- imports.wbg.__wbindgen_memory = function() {
3135
- const ret = wasm.memory;
3136
- return addHeapObject(ret);
3137
- };
3138
- imports.wbg.__wbindgen_closure_wrapper504 = function(arg0, arg1, arg2) {
3139
- const ret = makeMutClosure(arg0, arg1, 226, __wbg_adapter_56);
3131
+ imports.wbg.__wbindgen_closure_wrapper515 = function(arg0, arg1, arg2) {
3132
+ const ret = makeMutClosure(arg0, arg1, 181, __wbg_adapter_56);
3140
3133
  return addHeapObject(ret);
3141
3134
  };
3142
- imports.wbg.__wbindgen_closure_wrapper506 = function(arg0, arg1, arg2) {
3143
- const ret = makeClosure(arg0, arg1, 226, __wbg_adapter_59);
3135
+ imports.wbg.__wbindgen_closure_wrapper517 = function(arg0, arg1, arg2) {
3136
+ const ret = makeClosure(arg0, arg1, 181, __wbg_adapter_59);
3144
3137
  return addHeapObject(ret);
3145
3138
  };
3146
- imports.wbg.__wbindgen_closure_wrapper1689 = function(arg0, arg1, arg2) {
3147
- const ret = makeMutClosure(arg0, arg1, 466, __wbg_adapter_62);
3139
+ imports.wbg.__wbindgen_closure_wrapper1702 = function(arg0, arg1, arg2) {
3140
+ const ret = makeMutClosure(arg0, arg1, 465, __wbg_adapter_62);
3148
3141
  return addHeapObject(ret);
3149
3142
  };
3150
3143
  return imports;