@trust0/ridb-core 1.7.35 → 1.7.38

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.
@@ -90,6 +90,13 @@ function takeObject(idx) {
90
90
  dropObject(idx);
91
91
  return ret;
92
92
  }
93
+ function addHeapObject(obj) {
94
+ if (heap_next === heap.length) heap.push(heap.length + 1);
95
+ const idx = heap_next;
96
+ heap_next = heap[idx];
97
+ heap[idx] = obj;
98
+ return idx;
99
+ }
93
100
  var cachedTextDecoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-8", { ignoreBOM: true, fatal: true }) : { decode: () => {
94
101
  throw Error("TextDecoder not available");
95
102
  } };
@@ -107,13 +114,6 @@ function getStringFromWasm0(ptr, len) {
107
114
  ptr = ptr >>> 0;
108
115
  return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
109
116
  }
110
- function addHeapObject(obj) {
111
- if (heap_next === heap.length) heap.push(heap.length + 1);
112
- const idx = heap_next;
113
- heap_next = heap[idx];
114
- heap[idx] = obj;
115
- return idx;
116
- }
117
117
  var WASM_VECTOR_LEN = 0;
118
118
  var cachedTextEncoder = typeof TextEncoder !== "undefined" ? new TextEncoder("utf-8") : { encode: () => {
119
119
  throw Error("TextEncoder not available");
@@ -265,7 +265,7 @@ function makeMutClosure(arg0, arg1, dtor, f) {
265
265
  return real;
266
266
  }
267
267
  function __wbg_adapter_56(arg0, arg1, arg2) {
268
- wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hcf4fe6fd0b7ccc8d(arg0, arg1, addHeapObject(arg2));
268
+ wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__ha7bc4bff3dafa2ad(arg0, arg1, addHeapObject(arg2));
269
269
  }
270
270
  function makeClosure(arg0, arg1, dtor, f) {
271
271
  const state = { a: arg0, b: arg1, cnt: 1, dtor };
@@ -288,7 +288,7 @@ function makeClosure(arg0, arg1, dtor, f) {
288
288
  function __wbg_adapter_59(arg0, arg1, arg2, arg3, arg4) {
289
289
  try {
290
290
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
291
- 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));
291
+ 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));
292
292
  var r0 = getInt32Memory0()[retptr / 4 + 0];
293
293
  var r1 = getInt32Memory0()[retptr / 4 + 1];
294
294
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -301,7 +301,13 @@ function __wbg_adapter_59(arg0, arg1, arg2, arg3, arg4) {
301
301
  }
302
302
  }
303
303
  function __wbg_adapter_62(arg0, arg1, arg2) {
304
- wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hb6eb1f8e3b5e56e9(arg0, arg1, addHeapObject(arg2));
304
+ wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hd4647cb021495324(arg0, arg1, addHeapObject(arg2));
305
+ }
306
+ var stack_pointer = 128;
307
+ function addBorrowedObject(obj) {
308
+ if (stack_pointer == 1) throw new Error("out of js stack");
309
+ heap[--stack_pointer] = obj;
310
+ return stack_pointer;
305
311
  }
306
312
  var cachedUint32Memory0 = null;
307
313
  function getUint32Memory0() {
@@ -326,26 +332,6 @@ function _assertClass(instance, klass) {
326
332
  }
327
333
  return instance.ptr;
328
334
  }
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;
334
- }
335
- function main_js() {
336
- wasm.main_js();
337
- }
338
- function is_debug_mode() {
339
- const ret = wasm.is_debug_mode();
340
- return ret !== 0;
341
- }
342
- function handleError(f, args) {
343
- try {
344
- return f.apply(this, args);
345
- } catch (e) {
346
- wasm.__wbindgen_exn_store(addHeapObject(e));
347
- }
348
- }
349
335
  function passArrayJsValueToWasm0(array, malloc) {
350
336
  const ptr = malloc(array.length * 4, 4) >>> 0;
351
337
  const mem = getUint32Memory0();
@@ -355,30 +341,47 @@ function passArrayJsValueToWasm0(array, malloc) {
355
341
  WASM_VECTOR_LEN = array.length;
356
342
  return ptr;
357
343
  }
358
- function __wbgtest_console_log(args) {
344
+ function handleError(f, args) {
359
345
  try {
360
- wasm.__wbgtest_console_log(addBorrowedObject(args));
346
+ return f.apply(this, args);
347
+ } catch (e) {
348
+ wasm.__wbindgen_exn_store(addHeapObject(e));
349
+ }
350
+ }
351
+ function is_debug_mode() {
352
+ const ret = wasm.is_debug_mode();
353
+ return ret !== 0;
354
+ }
355
+ function main_js() {
356
+ wasm.main_js();
357
+ }
358
+ function __wbgtest_console_info(args) {
359
+ try {
360
+ wasm.__wbgtest_console_info(addBorrowedObject(args));
361
361
  } finally {
362
362
  heap[stack_pointer++] = void 0;
363
363
  }
364
364
  }
365
- function __wbgtest_console_debug(args) {
365
+ function __wbgtest_console_warn(args) {
366
366
  try {
367
- wasm.__wbgtest_console_debug(addBorrowedObject(args));
367
+ wasm.__wbgtest_console_warn(addBorrowedObject(args));
368
368
  } finally {
369
369
  heap[stack_pointer++] = void 0;
370
370
  }
371
371
  }
372
- function __wbgtest_console_info(args) {
372
+ function __wbg_adapter_287(arg0, arg1) {
373
+ wasm.wasm_bindgen__convert__closures__invoke0_mut__hc6452fdbb8c4addc(arg0, arg1);
374
+ }
375
+ function __wbgtest_console_debug(args) {
373
376
  try {
374
- wasm.__wbgtest_console_info(addBorrowedObject(args));
377
+ wasm.__wbgtest_console_debug(addBorrowedObject(args));
375
378
  } finally {
376
379
  heap[stack_pointer++] = void 0;
377
380
  }
378
381
  }
379
- function __wbgtest_console_warn(args) {
382
+ function __wbgtest_console_log(args) {
380
383
  try {
381
- wasm.__wbgtest_console_warn(addBorrowedObject(args));
384
+ wasm.__wbgtest_console_log(addBorrowedObject(args));
382
385
  } finally {
383
386
  heap[stack_pointer++] = void 0;
384
387
  }
@@ -390,14 +393,11 @@ function __wbgtest_console_error(args) {
390
393
  heap[stack_pointer++] = void 0;
391
394
  }
392
395
  }
393
- function __wbg_adapter_304(arg0, arg1) {
394
- wasm.wasm_bindgen__convert__closures__invoke0_mut__hff00333f3d941090(arg0, arg1);
395
- }
396
- function __wbg_adapter_347(arg0, arg1, arg2, arg3, arg4) {
397
- wasm.wasm_bindgen__convert__closures__invoke3_mut__h703f9c33fd3008bf(arg0, arg1, addHeapObject(arg2), arg3, addHeapObject(arg4));
396
+ function __wbg_adapter_378(arg0, arg1, arg2, arg3, arg4) {
397
+ wasm.wasm_bindgen__convert__closures__invoke3_mut__h2f203dbfa61ca113(arg0, arg1, addHeapObject(arg2), arg3, addHeapObject(arg4));
398
398
  }
399
- function __wbg_adapter_404(arg0, arg1, arg2, arg3) {
400
- wasm.wasm_bindgen__convert__closures__invoke2_mut__h97988f5fa0547d24(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
399
+ function __wbg_adapter_395(arg0, arg1, arg2, arg3) {
400
+ wasm.wasm_bindgen__convert__closures__invoke2_mut__h42aa995f02b6fdcb(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
401
401
  }
402
402
  var OpType = Object.freeze({
403
403
  /**
@@ -442,6 +442,32 @@ var BasePlugin = class {
442
442
  wasm.__wbg_baseplugin_free(ptr);
443
443
  }
444
444
  /**
445
+ * @returns {any}
446
+ */
447
+ get docCreateHook() {
448
+ const ret = wasm.baseplugin_get_doc_create_hook(this.__wbg_ptr);
449
+ return takeObject(ret);
450
+ }
451
+ /**
452
+ * @param {any} hook
453
+ */
454
+ set docCreateHook(hook) {
455
+ wasm.baseplugin_set_doc_create_hook(this.__wbg_ptr, addHeapObject(hook));
456
+ }
457
+ /**
458
+ * @returns {any}
459
+ */
460
+ get docRecoverHook() {
461
+ const ret = wasm.baseplugin_get_doc_recover_hook(this.__wbg_ptr);
462
+ return takeObject(ret);
463
+ }
464
+ /**
465
+ * @param {any} hook
466
+ */
467
+ set docRecoverHook(hook) {
468
+ wasm.baseplugin_set_doc_recover_hook(this.__wbg_ptr, addHeapObject(hook));
469
+ }
470
+ /**
445
471
  * @param {string} name
446
472
  */
447
473
  constructor(name) {
@@ -469,32 +495,6 @@ var BasePlugin = class {
469
495
  const ret = wasm.baseplugin_name(this.__wbg_ptr);
470
496
  return takeObject(ret);
471
497
  }
472
- /**
473
- * @returns {any}
474
- */
475
- get docCreateHook() {
476
- const ret = wasm.baseplugin_get_doc_create_hook(this.__wbg_ptr);
477
- return takeObject(ret);
478
- }
479
- /**
480
- * @returns {any}
481
- */
482
- get docRecoverHook() {
483
- const ret = wasm.baseplugin_get_doc_recover_hook(this.__wbg_ptr);
484
- return takeObject(ret);
485
- }
486
- /**
487
- * @param {any} hook
488
- */
489
- set docCreateHook(hook) {
490
- wasm.baseplugin_set_doc_create_hook(this.__wbg_ptr, addHeapObject(hook));
491
- }
492
- /**
493
- * @param {any} hook
494
- */
495
- set docRecoverHook(hook) {
496
- wasm.baseplugin_set_doc_recover_hook(this.__wbg_ptr, addHeapObject(hook));
497
- }
498
498
  };
499
499
  var BaseStorageFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
500
500
  }, unregister: () => {
@@ -511,66 +511,54 @@ var BaseStorage = class {
511
511
  wasm.__wbg_basestorage_free(ptr);
512
512
  }
513
513
  /**
514
- * Creates a new `BaseStorage` instance with the provided name and schema type.
515
- *
516
- * # Arguments
517
- *
518
- * * `name` - The name of the storage.
519
- * * `schema_type` - The schema type in `JsValue` format.
520
- *
521
- * # Returns
522
- *
523
- * * `Result<BaseStorage, JsValue>` - A result containing the new `BaseStorage` instance or an error.
524
514
  * @param {string} name
525
- * @param {object} schemas_js
526
- * @param {object | undefined} [options]
515
+ * @returns {any}
527
516
  */
528
- constructor(name, schemas_js, options) {
517
+ getOption(name) {
529
518
  try {
530
519
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
531
520
  const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
532
521
  const len0 = WASM_VECTOR_LEN;
533
- wasm.basestorage_new(retptr, ptr0, len0, addHeapObject(schemas_js), isLikeNone(options) ? 0 : addHeapObject(options));
522
+ wasm.basestorage_getOption(retptr, this.__wbg_ptr, ptr0, len0);
534
523
  var r0 = getInt32Memory0()[retptr / 4 + 0];
535
524
  var r1 = getInt32Memory0()[retptr / 4 + 1];
536
525
  var r2 = getInt32Memory0()[retptr / 4 + 2];
537
526
  if (r2) {
538
527
  throw takeObject(r1);
539
528
  }
540
- this.__wbg_ptr = r0 >>> 0;
541
- return this;
529
+ return takeObject(r0);
542
530
  } finally {
543
531
  wasm.__wbindgen_add_to_stack_pointer(16);
544
532
  }
545
533
  }
546
534
  /**
547
- * @returns {any}
535
+ * @param {string} name
536
+ * @returns {Schema}
548
537
  */
549
- addIndexSchemas() {
538
+ getSchema(name) {
550
539
  try {
551
540
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
552
- wasm.basestorage_addIndexSchemas(retptr, this.__wbg_ptr);
541
+ const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
542
+ const len0 = WASM_VECTOR_LEN;
543
+ wasm.basestorage_getSchema(retptr, this.__wbg_ptr, ptr0, len0);
553
544
  var r0 = getInt32Memory0()[retptr / 4 + 0];
554
545
  var r1 = getInt32Memory0()[retptr / 4 + 1];
555
546
  var r2 = getInt32Memory0()[retptr / 4 + 2];
556
547
  if (r2) {
557
548
  throw takeObject(r1);
558
549
  }
559
- return takeObject(r0);
550
+ return Schema.__wrap(r0);
560
551
  } finally {
561
552
  wasm.__wbindgen_add_to_stack_pointer(16);
562
553
  }
563
554
  }
564
555
  /**
565
- * @param {string} name
566
556
  * @returns {any}
567
557
  */
568
- getOption(name) {
558
+ addIndexSchemas() {
569
559
  try {
570
560
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
571
- const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
572
- const len0 = WASM_VECTOR_LEN;
573
- wasm.basestorage_getOption(retptr, this.__wbg_ptr, ptr0, len0);
561
+ wasm.basestorage_addIndexSchemas(retptr, this.__wbg_ptr);
574
562
  var r0 = getInt32Memory0()[retptr / 4 + 0];
575
563
  var r1 = getInt32Memory0()[retptr / 4 + 1];
576
564
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -583,22 +571,34 @@ var BaseStorage = class {
583
571
  }
584
572
  }
585
573
  /**
574
+ * Creates a new `BaseStorage` instance with the provided name and schema type.
575
+ *
576
+ * # Arguments
577
+ *
578
+ * * `name` - The name of the storage.
579
+ * * `schema_type` - The schema type in `JsValue` format.
580
+ *
581
+ * # Returns
582
+ *
583
+ * * `Result<BaseStorage, JsValue>` - A result containing the new `BaseStorage` instance or an error.
586
584
  * @param {string} name
587
- * @returns {Schema}
585
+ * @param {object} schemas_js
586
+ * @param {object | undefined} [options]
588
587
  */
589
- getSchema(name) {
588
+ constructor(name, schemas_js, options) {
590
589
  try {
591
590
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
592
591
  const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
593
592
  const len0 = WASM_VECTOR_LEN;
594
- wasm.basestorage_getSchema(retptr, this.__wbg_ptr, ptr0, len0);
593
+ wasm.basestorage_new(retptr, ptr0, len0, addHeapObject(schemas_js), isLikeNone(options) ? 0 : addHeapObject(options));
595
594
  var r0 = getInt32Memory0()[retptr / 4 + 0];
596
595
  var r1 = getInt32Memory0()[retptr / 4 + 1];
597
596
  var r2 = getInt32Memory0()[retptr / 4 + 2];
598
597
  if (r2) {
599
598
  throw takeObject(r1);
600
599
  }
601
- return Schema.__wrap(r0);
600
+ this.__wbg_ptr = r0 >>> 0;
601
+ return this;
602
602
  } finally {
603
603
  wasm.__wbindgen_add_to_stack_pointer(16);
604
604
  }
@@ -644,38 +644,31 @@ var Collection = class _Collection {
644
644
  wasm.__wbg_collection_free(ptr);
645
645
  }
646
646
  /**
647
- * @returns {string}
647
+ * Finds and returns a single document in the collection by its ID.
648
+ *
649
+ * This function is asynchronous.
650
+ * @param {any} primary_key
651
+ * @returns {Promise<any>}
648
652
  */
649
- get name() {
650
- let deferred1_0;
651
- let deferred1_1;
652
- try {
653
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
654
- wasm.collection_name(retptr, this.__wbg_ptr);
655
- var r0 = getInt32Memory0()[retptr / 4 + 0];
656
- var r1 = getInt32Memory0()[retptr / 4 + 1];
657
- deferred1_0 = r0;
658
- deferred1_1 = r1;
659
- return getStringFromWasm0(r0, r1);
660
- } finally {
661
- wasm.__wbindgen_add_to_stack_pointer(16);
662
- wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
663
- }
653
+ findById(primary_key) {
654
+ const ret = wasm.collection_findById(this.__wbg_ptr, addHeapObject(primary_key));
655
+ return takeObject(ret);
664
656
  }
665
657
  /**
666
- * @returns {Schema}
658
+ * @param {any} options
659
+ * @returns {QueryOptions}
667
660
  */
668
- get schema() {
661
+ parse_query_options(options) {
669
662
  try {
670
663
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
671
- wasm.collection_schema(retptr, this.__wbg_ptr);
664
+ wasm.collection_parse_query_options(retptr, this.__wbg_ptr, addHeapObject(options));
672
665
  var r0 = getInt32Memory0()[retptr / 4 + 0];
673
666
  var r1 = getInt32Memory0()[retptr / 4 + 1];
674
667
  var r2 = getInt32Memory0()[retptr / 4 + 2];
675
668
  if (r2) {
676
669
  throw takeObject(r1);
677
670
  }
678
- return Schema.__wrap(r0);
671
+ return QueryOptions.__wrap(r0);
679
672
  } finally {
680
673
  wasm.__wbindgen_add_to_stack_pointer(16);
681
674
  }
@@ -694,22 +687,22 @@ var Collection = class _Collection {
694
687
  return takeObject(ret);
695
688
  }
696
689
  /**
697
- * @param {any} options
698
- * @returns {QueryOptions}
690
+ * @returns {string}
699
691
  */
700
- parse_query_options(options) {
692
+ get name() {
693
+ let deferred1_0;
694
+ let deferred1_1;
701
695
  try {
702
696
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
703
- wasm.collection_parse_query_options(retptr, this.__wbg_ptr, addHeapObject(options));
697
+ wasm.collection_name(retptr, this.__wbg_ptr);
704
698
  var r0 = getInt32Memory0()[retptr / 4 + 0];
705
699
  var r1 = getInt32Memory0()[retptr / 4 + 1];
706
- var r2 = getInt32Memory0()[retptr / 4 + 2];
707
- if (r2) {
708
- throw takeObject(r1);
709
- }
710
- return QueryOptions.__wrap(r0);
700
+ deferred1_0 = r0;
701
+ deferred1_1 = r1;
702
+ return getStringFromWasm0(r0, r1);
711
703
  } finally {
712
704
  wasm.__wbindgen_add_to_stack_pointer(16);
705
+ wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
713
706
  }
714
707
  }
715
708
  /**
@@ -726,55 +719,62 @@ var Collection = class _Collection {
726
719
  return takeObject(ret);
727
720
  }
728
721
  /**
729
- * Finds and returns a single document in the collection by its ID.
730
- *
731
- * This function is asynchronous.
732
- * @param {any} primary_key
733
- * @returns {Promise<any>}
734
- */
735
- findById(primary_key) {
736
- const ret = wasm.collection_findById(this.__wbg_ptr, addHeapObject(primary_key));
737
- return takeObject(ret);
738
- }
739
- /**
740
- * Updates a document in the collection with the given data.
722
+ * Creates a new document in the collection.
741
723
  *
742
724
  * This function is asynchronous and returns a `Result` indicating success or failure.
743
725
  *
744
726
  * # Arguments
745
727
  *
746
- * * `document` - A `JsValue` representing the partial document to update.
728
+ * * `document` - A `JsValue` representing the document to create.
747
729
  * @param {any} document
748
730
  * @returns {Promise<any>}
749
731
  */
750
- update(document2) {
751
- const ret = wasm.collection_update(this.__wbg_ptr, addHeapObject(document2));
732
+ create(document2) {
733
+ const ret = wasm.collection_create(this.__wbg_ptr, addHeapObject(document2));
752
734
  return takeObject(ret);
753
735
  }
754
736
  /**
755
- * Creates a new document in the collection.
756
- *
757
- * This function is asynchronous and returns a `Result` indicating success or failure.
737
+ * Deletes a document from the collection by its ID.
758
738
  *
759
- * # Arguments
760
- *
761
- * * `document` - A `JsValue` representing the document to create.
762
- * @param {any} document
739
+ * This function is asynchronous.
740
+ * @param {any} primary_key
763
741
  * @returns {Promise<any>}
764
742
  */
765
- create(document2) {
766
- const ret = wasm.collection_create(this.__wbg_ptr, addHeapObject(document2));
743
+ delete(primary_key) {
744
+ const ret = wasm.collection_delete(this.__wbg_ptr, addHeapObject(primary_key));
767
745
  return takeObject(ret);
768
746
  }
769
747
  /**
770
- * Deletes a document from the collection by its ID.
748
+ * @returns {Schema}
749
+ */
750
+ get schema() {
751
+ try {
752
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
753
+ wasm.collection_schema(retptr, this.__wbg_ptr);
754
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
755
+ var r1 = getInt32Memory0()[retptr / 4 + 1];
756
+ var r2 = getInt32Memory0()[retptr / 4 + 2];
757
+ if (r2) {
758
+ throw takeObject(r1);
759
+ }
760
+ return Schema.__wrap(r0);
761
+ } finally {
762
+ wasm.__wbindgen_add_to_stack_pointer(16);
763
+ }
764
+ }
765
+ /**
766
+ * Updates a document in the collection with the given data.
771
767
  *
772
- * This function is asynchronous.
773
- * @param {any} primary_key
768
+ * This function is asynchronous and returns a `Result` indicating success or failure.
769
+ *
770
+ * # Arguments
771
+ *
772
+ * * `document` - A `JsValue` representing the partial document to update.
773
+ * @param {any} document
774
774
  * @returns {Promise<any>}
775
775
  */
776
- delete(primary_key) {
777
- const ret = wasm.collection_delete(this.__wbg_ptr, addHeapObject(primary_key));
776
+ update(document2) {
777
+ const ret = wasm.collection_update(this.__wbg_ptr, addHeapObject(document2));
778
778
  return takeObject(ret);
779
779
  }
780
780
  };
@@ -800,11 +800,29 @@ var CoreStorage = class _CoreStorage {
800
800
  wasm.__wbg_corestorage_free(ptr);
801
801
  }
802
802
  /**
803
+ * @param {Schema} schema
804
+ * @param {Operation} op
805
+ * @returns {(string)[]}
803
806
  */
804
- constructor() {
805
- const ret = wasm.corestorage_new();
806
- this.__wbg_ptr = ret >>> 0;
807
- return this;
807
+ getIndexes(schema, op) {
808
+ try {
809
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
810
+ _assertClass(schema, Schema);
811
+ _assertClass(op, Operation);
812
+ wasm.corestorage_getIndexes(retptr, this.__wbg_ptr, schema.__wbg_ptr, op.__wbg_ptr);
813
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
814
+ var r1 = getInt32Memory0()[retptr / 4 + 1];
815
+ var r2 = getInt32Memory0()[retptr / 4 + 2];
816
+ var r3 = getInt32Memory0()[retptr / 4 + 3];
817
+ if (r3) {
818
+ throw takeObject(r2);
819
+ }
820
+ var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
821
+ wasm.__wbindgen_free(r0, r1 * 4, 4);
822
+ return v1;
823
+ } finally {
824
+ wasm.__wbindgen_add_to_stack_pointer(16);
825
+ }
808
826
  }
809
827
  /**
810
828
  * @param {any} value
@@ -836,31 +854,6 @@ var CoreStorage = class _CoreStorage {
836
854
  }
837
855
  }
838
856
  /**
839
- * @param {Schema} schema
840
- * @param {Operation} op
841
- * @returns {(string)[]}
842
- */
843
- getIndexes(schema, op) {
844
- try {
845
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
846
- _assertClass(schema, Schema);
847
- _assertClass(op, Operation);
848
- wasm.corestorage_getIndexes(retptr, this.__wbg_ptr, schema.__wbg_ptr, op.__wbg_ptr);
849
- var r0 = getInt32Memory0()[retptr / 4 + 0];
850
- var r1 = getInt32Memory0()[retptr / 4 + 1];
851
- var r2 = getInt32Memory0()[retptr / 4 + 2];
852
- var r3 = getInt32Memory0()[retptr / 4 + 3];
853
- if (r3) {
854
- throw takeObject(r2);
855
- }
856
- var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
857
- wasm.__wbindgen_free(r0, r1 * 4, 4);
858
- return v1;
859
- } finally {
860
- wasm.__wbindgen_add_to_stack_pointer(16);
861
- }
862
- }
863
- /**
864
857
  * @param {any} document
865
858
  * @param {Query} query
866
859
  * @returns {boolean}
@@ -882,6 +875,13 @@ var CoreStorage = class _CoreStorage {
882
875
  heap[stack_pointer++] = void 0;
883
876
  }
884
877
  }
878
+ /**
879
+ */
880
+ constructor() {
881
+ const ret = wasm.corestorage_new();
882
+ this.__wbg_ptr = ret >>> 0;
883
+ return this;
884
+ }
885
885
  };
886
886
  var DatabaseFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
887
887
  }, unregister: () => {
@@ -905,38 +905,6 @@ var Database = class _Database {
905
905
  wasm.__wbg_database_free(ptr);
906
906
  }
907
907
  /**
908
- * @returns {Promise<any>}
909
- */
910
- start() {
911
- const ret = wasm.database_start(this.__wbg_ptr);
912
- return takeObject(ret);
913
- }
914
- /**
915
- * @returns {Promise<any>}
916
- */
917
- close() {
918
- const ptr = this.__destroy_into_raw();
919
- const ret = wasm.database_close(ptr);
920
- return takeObject(ret);
921
- }
922
- /**
923
- * @returns {boolean}
924
- */
925
- get started() {
926
- const ret = wasm.database_started(this.__wbg_ptr);
927
- return ret !== 0;
928
- }
929
- /**
930
- * @param {string} password
931
- * @returns {Promise<boolean>}
932
- */
933
- authenticate(password) {
934
- const ptr0 = passStringToWasm0(password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
935
- const len0 = WASM_VECTOR_LEN;
936
- const ret = wasm.database_authenticate(this.__wbg_ptr, ptr0, len0);
937
- return takeObject(ret);
938
- }
939
- /**
940
908
  * Retrieves the collections in the database.
941
909
  *
942
910
  * This function returns an `Object` containing the collections.
@@ -962,6 +930,31 @@ var Database = class _Database {
962
930
  }
963
931
  }
964
932
  /**
933
+ * @param {string} password
934
+ * @returns {Promise<boolean>}
935
+ */
936
+ authenticate(password) {
937
+ const ptr0 = passStringToWasm0(password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
938
+ const len0 = WASM_VECTOR_LEN;
939
+ const ret = wasm.database_authenticate(this.__wbg_ptr, ptr0, len0);
940
+ return takeObject(ret);
941
+ }
942
+ /**
943
+ * @returns {Promise<any>}
944
+ */
945
+ close() {
946
+ const ptr = this.__destroy_into_raw();
947
+ const ret = wasm.database_close(ptr);
948
+ return takeObject(ret);
949
+ }
950
+ /**
951
+ * @returns {Promise<any>}
952
+ */
953
+ start() {
954
+ const ret = wasm.database_start(this.__wbg_ptr);
955
+ return takeObject(ret);
956
+ }
957
+ /**
965
958
  * @param {string} db_name
966
959
  * @param {object} schemas_js
967
960
  * @param {object} migrations_js
@@ -979,6 +972,13 @@ var Database = class _Database {
979
972
  const ret = wasm.database_create(ptr0, len0, addHeapObject(schemas_js), addHeapObject(migrations_js), addHeapObject(plugins), addHeapObject(module2), ptr1, len1, isLikeNone(storage) ? 0 : addHeapObject(storage));
980
973
  return takeObject(ret);
981
974
  }
975
+ /**
976
+ * @returns {boolean}
977
+ */
978
+ get started() {
979
+ const ret = wasm.database_started(this.__wbg_ptr);
980
+ return ret !== 0;
981
+ }
982
982
  };
983
983
  var InMemoryFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
984
984
  }, unregister: () => {
@@ -1002,6 +1002,17 @@ var InMemory = class _InMemory {
1002
1002
  wasm.__wbg_inmemory_free(ptr);
1003
1003
  }
1004
1004
  /**
1005
+ * @param {string} collection_name
1006
+ * @param {any} primary_key
1007
+ * @returns {Promise<any>}
1008
+ */
1009
+ findDocumentById(collection_name, primary_key) {
1010
+ const ptr0 = passStringToWasm0(collection_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1011
+ const len0 = WASM_VECTOR_LEN;
1012
+ const ret = wasm.inmemory_findDocumentById(this.__wbg_ptr, ptr0, len0, addHeapObject(primary_key));
1013
+ return takeObject(ret);
1014
+ }
1015
+ /**
1005
1016
  * @param {string} name
1006
1017
  * @param {object} schemas_js
1007
1018
  * @returns {Promise<InMemory>}
@@ -1013,16 +1024,6 @@ var InMemory = class _InMemory {
1013
1024
  return takeObject(ret);
1014
1025
  }
1015
1026
  /**
1016
- * @param {Operation} op
1017
- * @returns {Promise<any>}
1018
- */
1019
- write(op) {
1020
- _assertClass(op, Operation);
1021
- var ptr0 = op.__destroy_into_raw();
1022
- const ret = wasm.inmemory_write(this.__wbg_ptr, ptr0);
1023
- return takeObject(ret);
1024
- }
1025
- /**
1026
1027
  * @param {string} collection_name
1027
1028
  * @param {any} query_js
1028
1029
  * @param {QueryOptions} options
@@ -1037,14 +1038,10 @@ var InMemory = class _InMemory {
1037
1038
  return takeObject(ret);
1038
1039
  }
1039
1040
  /**
1040
- * @param {string} collection_name
1041
- * @param {any} primary_key
1042
1041
  * @returns {Promise<any>}
1043
1042
  */
1044
- findDocumentById(collection_name, primary_key) {
1045
- const ptr0 = passStringToWasm0(collection_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1046
- const len0 = WASM_VECTOR_LEN;
1047
- const ret = wasm.inmemory_findDocumentById(this.__wbg_ptr, ptr0, len0, addHeapObject(primary_key));
1043
+ close() {
1044
+ const ret = wasm.inmemory_close(this.__wbg_ptr);
1048
1045
  return takeObject(ret);
1049
1046
  }
1050
1047
  /**
@@ -1064,15 +1061,18 @@ var InMemory = class _InMemory {
1064
1061
  /**
1065
1062
  * @returns {Promise<any>}
1066
1063
  */
1067
- close() {
1068
- const ret = wasm.inmemory_close(this.__wbg_ptr);
1064
+ start() {
1065
+ const ret = wasm.inmemory_start(this.__wbg_ptr);
1069
1066
  return takeObject(ret);
1070
1067
  }
1071
1068
  /**
1069
+ * @param {Operation} op
1072
1070
  * @returns {Promise<any>}
1073
1071
  */
1074
- start() {
1075
- const ret = wasm.inmemory_start(this.__wbg_ptr);
1072
+ write(op) {
1073
+ _assertClass(op, Operation);
1074
+ var ptr0 = op.__destroy_into_raw();
1075
+ const ret = wasm.inmemory_write(this.__wbg_ptr, ptr0);
1076
1076
  return takeObject(ret);
1077
1077
  }
1078
1078
  };
@@ -1119,12 +1119,12 @@ var IndexDB = class _IndexDB {
1119
1119
  * @param {string} store_name
1120
1120
  * @returns {IDBObjectStore}
1121
1121
  */
1122
- get_store(store_name) {
1122
+ get_store_readonly(store_name) {
1123
1123
  try {
1124
1124
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1125
1125
  const ptr0 = passStringToWasm0(store_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1126
1126
  const len0 = WASM_VECTOR_LEN;
1127
- wasm.indexdb_get_store(retptr, this.__wbg_ptr, ptr0, len0);
1127
+ wasm.indexdb_get_store_readonly(retptr, this.__wbg_ptr, ptr0, len0);
1128
1128
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1129
1129
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1130
1130
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1137,6 +1137,17 @@ var IndexDB = class _IndexDB {
1137
1137
  }
1138
1138
  }
1139
1139
  /**
1140
+ * @param {string} collection_name
1141
+ * @param {any} primary_key
1142
+ * @returns {Promise<any>}
1143
+ */
1144
+ findDocumentById(collection_name, primary_key) {
1145
+ const ptr0 = passStringToWasm0(collection_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1146
+ const len0 = WASM_VECTOR_LEN;
1147
+ const ret = wasm.indexdb_findDocumentById(this.__wbg_ptr, ptr0, len0, addHeapObject(primary_key));
1148
+ return takeObject(ret);
1149
+ }
1150
+ /**
1140
1151
  * @param {string} name
1141
1152
  * @param {object} schemas_js
1142
1153
  * @returns {Promise<IndexDB>}
@@ -1148,16 +1159,6 @@ var IndexDB = class _IndexDB {
1148
1159
  return takeObject(ret);
1149
1160
  }
1150
1161
  /**
1151
- * @param {Operation} op
1152
- * @returns {Promise<any>}
1153
- */
1154
- write(op) {
1155
- _assertClass(op, Operation);
1156
- var ptr0 = op.__destroy_into_raw();
1157
- const ret = wasm.indexdb_write(this.__wbg_ptr, ptr0);
1158
- return takeObject(ret);
1159
- }
1160
- /**
1161
1162
  * @param {string} collection_name
1162
1163
  * @param {any} query
1163
1164
  * @param {QueryOptions} options
@@ -1172,14 +1173,10 @@ var IndexDB = class _IndexDB {
1172
1173
  return takeObject(ret);
1173
1174
  }
1174
1175
  /**
1175
- * @param {string} collection_name
1176
- * @param {any} primary_key
1177
1176
  * @returns {Promise<any>}
1178
1177
  */
1179
- findDocumentById(collection_name, primary_key) {
1180
- const ptr0 = passStringToWasm0(collection_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1181
- const len0 = WASM_VECTOR_LEN;
1182
- const ret = wasm.indexdb_findDocumentById(this.__wbg_ptr, ptr0, len0, addHeapObject(primary_key));
1178
+ close() {
1179
+ const ret = wasm.indexdb_close(this.__wbg_ptr);
1183
1180
  return takeObject(ret);
1184
1181
  }
1185
1182
  /**
@@ -1199,27 +1196,51 @@ var IndexDB = class _IndexDB {
1199
1196
  /**
1200
1197
  * @returns {Promise<any>}
1201
1198
  */
1202
- close() {
1203
- const ret = wasm.indexdb_close(this.__wbg_ptr);
1199
+ start() {
1200
+ const ret = wasm.indexdb_start(this.__wbg_ptr);
1204
1201
  return takeObject(ret);
1205
1202
  }
1206
1203
  /**
1204
+ * @param {Operation} op
1207
1205
  * @returns {Promise<any>}
1208
1206
  */
1209
- start() {
1210
- const ret = wasm.indexdb_start(this.__wbg_ptr);
1207
+ write(op) {
1208
+ _assertClass(op, Operation);
1209
+ var ptr0 = op.__destroy_into_raw();
1210
+ const ret = wasm.indexdb_write(this.__wbg_ptr, ptr0);
1211
1211
  return takeObject(ret);
1212
1212
  }
1213
- };
1214
- var OperationFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
1215
- }, unregister: () => {
1216
- } } : new FinalizationRegistry((ptr) => wasm.__wbg_operation_free(ptr >>> 0));
1217
- var Operation = class _Operation {
1218
- static __wrap(ptr) {
1219
- ptr = ptr >>> 0;
1220
- const obj = Object.create(_Operation.prototype);
1221
- obj.__wbg_ptr = ptr;
1222
- OperationFinalization.register(obj, obj.__wbg_ptr, obj);
1213
+ /**
1214
+ * @param {string} store_name
1215
+ * @returns {IDBObjectStore}
1216
+ */
1217
+ get_store(store_name) {
1218
+ try {
1219
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1220
+ const ptr0 = passStringToWasm0(store_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1221
+ const len0 = WASM_VECTOR_LEN;
1222
+ wasm.indexdb_get_store(retptr, this.__wbg_ptr, ptr0, len0);
1223
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
1224
+ var r1 = getInt32Memory0()[retptr / 4 + 1];
1225
+ var r2 = getInt32Memory0()[retptr / 4 + 2];
1226
+ if (r2) {
1227
+ throw takeObject(r1);
1228
+ }
1229
+ return takeObject(r0);
1230
+ } finally {
1231
+ wasm.__wbindgen_add_to_stack_pointer(16);
1232
+ }
1233
+ }
1234
+ };
1235
+ var OperationFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
1236
+ }, unregister: () => {
1237
+ } } : new FinalizationRegistry((ptr) => wasm.__wbg_operation_free(ptr >>> 0));
1238
+ var Operation = class _Operation {
1239
+ static __wrap(ptr) {
1240
+ ptr = ptr >>> 0;
1241
+ const obj = Object.create(_Operation.prototype);
1242
+ obj.__wbg_ptr = ptr;
1243
+ OperationFinalization.register(obj, obj.__wbg_ptr, obj);
1223
1244
  return obj;
1224
1245
  }
1225
1246
  __destroy_into_raw() {
@@ -1257,27 +1278,15 @@ var Operation = class _Operation {
1257
1278
  }
1258
1279
  }
1259
1280
  /**
1260
- * Retrieves the type of operation.
1261
- *
1262
- * # Returns
1263
- *
1264
- * * `OpType` - The type of operation.
1265
- * @returns {OpType}
1266
- */
1267
- get opType() {
1268
- const ret = wasm.operation_opType(this.__wbg_ptr);
1269
- return ret;
1270
- }
1271
- /**
1272
- * Retrieves the data involved in the operation.
1281
+ * Retrieves the primary key value of the current data.
1273
1282
  *
1274
1283
  * # Returns
1275
1284
  *
1276
- * * `JsValue` - The data involved in the operation.
1285
+ * * `Option<JsValue>` - The primary key value of the current data.
1277
1286
  * @returns {any}
1278
1287
  */
1279
- get data() {
1280
- const ret = wasm.operation_data(this.__wbg_ptr);
1288
+ get primaryKey() {
1289
+ const ret = wasm.operation_primaryKey(this.__wbg_ptr);
1281
1290
  return takeObject(ret);
1282
1291
  }
1283
1292
  /**
@@ -1293,18 +1302,6 @@ var Operation = class _Operation {
1293
1302
  return takeObject(ret);
1294
1303
  }
1295
1304
  /**
1296
- * Retrieves the primary key value of the current data.
1297
- *
1298
- * # Returns
1299
- *
1300
- * * `Option<JsValue>` - The primary key value of the current data.
1301
- * @returns {any}
1302
- */
1303
- get primaryKey() {
1304
- const ret = wasm.operation_primaryKey(this.__wbg_ptr);
1305
- return takeObject(ret);
1306
- }
1307
- /**
1308
1305
  * @returns {string}
1309
1306
  */
1310
1307
  get primaryKeyIndex() {
@@ -1332,6 +1329,30 @@ var Operation = class _Operation {
1332
1329
  wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
1333
1330
  }
1334
1331
  }
1332
+ /**
1333
+ * Retrieves the data involved in the operation.
1334
+ *
1335
+ * # Returns
1336
+ *
1337
+ * * `JsValue` - The data involved in the operation.
1338
+ * @returns {any}
1339
+ */
1340
+ get data() {
1341
+ const ret = wasm.operation_data(this.__wbg_ptr);
1342
+ return takeObject(ret);
1343
+ }
1344
+ /**
1345
+ * Retrieves the type of operation.
1346
+ *
1347
+ * # Returns
1348
+ *
1349
+ * * `OpType` - The type of operation.
1350
+ * @returns {OpType}
1351
+ */
1352
+ get opType() {
1353
+ const ret = wasm.operation_opType(this.__wbg_ptr);
1354
+ return ret;
1355
+ }
1335
1356
  };
1336
1357
  var PropertyFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
1337
1358
  }, unregister: () => {
@@ -1348,52 +1369,40 @@ var Property = class {
1348
1369
  wasm.__wbg_property_free(ptr);
1349
1370
  }
1350
1371
  /**
1351
- * Checks is the schema is valid.
1372
+ * Retrieves the maximum length of the property.
1352
1373
  *
1353
1374
  * # Returns
1354
1375
  *
1355
- * Throws exception if not valid
1356
- * @returns {boolean}
1376
+ * * `Result<JsValue, JsValue>` - A result containing the maximum length as a `JsValue` or an error.
1377
+ * @returns {any}
1357
1378
  */
1358
- is_valid() {
1379
+ get maxLength() {
1359
1380
  try {
1360
1381
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1361
- wasm.property_is_valid(retptr, this.__wbg_ptr);
1382
+ wasm.property_maxLength(retptr, this.__wbg_ptr);
1362
1383
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1363
1384
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1364
1385
  var r2 = getInt32Memory0()[retptr / 4 + 2];
1365
1386
  if (r2) {
1366
1387
  throw takeObject(r1);
1367
1388
  }
1368
- return r0 !== 0;
1389
+ return takeObject(r0);
1369
1390
  } finally {
1370
1391
  wasm.__wbindgen_add_to_stack_pointer(16);
1371
1392
  }
1372
1393
  }
1373
1394
  /**
1374
- * Retrieves the type of the property.
1375
- *
1376
- * # Returns
1377
- *
1378
- * * `PropertyType` - The type of the property.
1379
- * @returns {any}
1380
- */
1381
- get type() {
1382
- const ret = wasm.property_type(this.__wbg_ptr);
1383
- return takeObject(ret);
1384
- }
1385
- /**
1386
- * Retrieves the items of the property.
1395
+ * Retrieves the minimum length of the property.
1387
1396
  *
1388
1397
  * # Returns
1389
1398
  *
1390
- * * `Result<JsValue, JsValue>` - A result containing the items as a `JsValue` or an error.
1399
+ * * `Result<JsValue, JsValue>` - A result containing the minimum length as a `JsValue` or an error.
1391
1400
  * @returns {any}
1392
1401
  */
1393
- get items() {
1402
+ get minLength() {
1394
1403
  try {
1395
1404
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1396
- wasm.property_items(retptr, this.__wbg_ptr);
1405
+ wasm.property_minLength(retptr, this.__wbg_ptr);
1397
1406
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1398
1407
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1399
1408
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1406,17 +1415,17 @@ var Property = class {
1406
1415
  }
1407
1416
  }
1408
1417
  /**
1409
- * Retrieves the maximum number of items of the property.
1418
+ * Retrieves the nested properties of the property.
1410
1419
  *
1411
1420
  * # Returns
1412
1421
  *
1413
- * * `Result<JsValue, JsValue>` - A result containing the maximum number of items as a `JsValue` or an error.
1422
+ * * `Result<JsValue, JsValue>` - A result containing the nested properties as a `JsValue` or an error.
1414
1423
  * @returns {any}
1415
1424
  */
1416
- get maxItems() {
1425
+ get properties() {
1417
1426
  try {
1418
1427
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1419
- wasm.property_maxItems(retptr, this.__wbg_ptr);
1428
+ wasm.property_properties(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,29 @@ var Property = class {
1429
1438
  }
1430
1439
  }
1431
1440
  /**
1432
- * Retrieves the minimum number of items of the property.
1441
+ * Retrieves the type of the property.
1433
1442
  *
1434
1443
  * # Returns
1435
1444
  *
1436
- * * `Result<JsValue, JsValue>` - A result containing the minimum number of items as a `JsValue` or an error.
1445
+ * * `PropertyType` - The type of the property.
1437
1446
  * @returns {any}
1438
1447
  */
1439
- get minItems() {
1448
+ get type() {
1449
+ const ret = wasm.property_type(this.__wbg_ptr);
1450
+ return takeObject(ret);
1451
+ }
1452
+ /**
1453
+ * Retrieves the items of the property.
1454
+ *
1455
+ * # Returns
1456
+ *
1457
+ * * `Result<JsValue, JsValue>` - A result containing the items as a `JsValue` or an error.
1458
+ * @returns {any}
1459
+ */
1460
+ get items() {
1440
1461
  try {
1441
1462
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1442
- wasm.property_minItems(retptr, this.__wbg_ptr);
1463
+ wasm.property_items(retptr, this.__wbg_ptr);
1443
1464
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1444
1465
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1445
1466
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1452,40 +1473,40 @@ var Property = class {
1452
1473
  }
1453
1474
  }
1454
1475
  /**
1455
- * Retrieves the maximum length of the property.
1476
+ * Checks is the schema is valid.
1456
1477
  *
1457
1478
  * # Returns
1458
1479
  *
1459
- * * `Result<JsValue, JsValue>` - A result containing the maximum length as a `JsValue` or an error.
1460
- * @returns {any}
1480
+ * Throws exception if not valid
1481
+ * @returns {boolean}
1461
1482
  */
1462
- get maxLength() {
1483
+ is_valid() {
1463
1484
  try {
1464
1485
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1465
- wasm.property_maxLength(retptr, this.__wbg_ptr);
1486
+ wasm.property_is_valid(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];
1469
1490
  if (r2) {
1470
1491
  throw takeObject(r1);
1471
1492
  }
1472
- return takeObject(r0);
1493
+ return r0 !== 0;
1473
1494
  } finally {
1474
1495
  wasm.__wbindgen_add_to_stack_pointer(16);
1475
1496
  }
1476
1497
  }
1477
1498
  /**
1478
- * Retrieves the minimum length of the property.
1499
+ * Retrieves the maximum number of items of the property.
1479
1500
  *
1480
1501
  * # Returns
1481
1502
  *
1482
- * * `Result<JsValue, JsValue>` - A result containing the minimum length as a `JsValue` or an error.
1503
+ * * `Result<JsValue, JsValue>` - A result containing the maximum number of items as a `JsValue` or an error.
1483
1504
  * @returns {any}
1484
1505
  */
1485
- get minLength() {
1506
+ get maxItems() {
1486
1507
  try {
1487
1508
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1488
- wasm.property_minLength(retptr, this.__wbg_ptr);
1509
+ wasm.property_maxItems(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];
@@ -1498,17 +1519,17 @@ var Property = class {
1498
1519
  }
1499
1520
  }
1500
1521
  /**
1501
- * Retrieves the nested properties of the property.
1522
+ * Retrieves the minimum number of items of the property.
1502
1523
  *
1503
1524
  * # Returns
1504
1525
  *
1505
- * * `Result<JsValue, JsValue>` - A result containing the nested properties as a `JsValue` or an error.
1526
+ * * `Result<JsValue, JsValue>` - A result containing the minimum number of items as a `JsValue` or an error.
1506
1527
  * @returns {any}
1507
1528
  */
1508
- get properties() {
1529
+ get minItems() {
1509
1530
  try {
1510
1531
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1511
- wasm.property_properties(retptr, this.__wbg_ptr);
1532
+ wasm.property_minItems(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];
@@ -1537,33 +1558,12 @@ var Query = class {
1537
1558
  }
1538
1559
  /**
1539
1560
  * @param {any} query
1540
- * @param {Schema} schema
1541
- */
1542
- constructor(query, schema) {
1543
- try {
1544
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1545
- _assertClass(schema, Schema);
1546
- var ptr0 = schema.__destroy_into_raw();
1547
- wasm.query_new(retptr, addHeapObject(query), ptr0);
1548
- var r0 = getInt32Memory0()[retptr / 4 + 0];
1549
- var r1 = getInt32Memory0()[retptr / 4 + 1];
1550
- var r2 = getInt32Memory0()[retptr / 4 + 2];
1551
- if (r2) {
1552
- throw takeObject(r1);
1553
- }
1554
- this.__wbg_ptr = r0 >>> 0;
1555
- return this;
1556
- } finally {
1557
- wasm.__wbindgen_add_to_stack_pointer(16);
1558
- }
1559
- }
1560
- /**
1561
1561
  * @returns {any}
1562
1562
  */
1563
- get query() {
1563
+ process_query(query) {
1564
1564
  try {
1565
1565
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1566
- wasm.query_query(retptr, this.__wbg_ptr);
1566
+ wasm.query_process_query(retptr, this.__wbg_ptr, addBorrowedObject(query));
1567
1567
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1568
1568
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1569
1569
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1573,6 +1573,7 @@ var Query = class {
1573
1573
  return takeObject(r0);
1574
1574
  } finally {
1575
1575
  wasm.__wbindgen_add_to_stack_pointer(16);
1576
+ heap[stack_pointer++] = void 0;
1576
1577
  }
1577
1578
  }
1578
1579
  /**
@@ -1599,12 +1600,31 @@ var Query = class {
1599
1600
  }
1600
1601
  }
1601
1602
  /**
1603
+ * @returns {boolean}
1604
+ */
1605
+ has_or_operator() {
1606
+ const ret = wasm.query_has_or_operator(this.__wbg_ptr);
1607
+ return ret !== 0;
1608
+ }
1609
+ /**
1610
+ * Returns the value of a property from the (normalized) query by its name.
1611
+ * This will scan the normalized query structure (including arrays, $and/$or blocks, etc.)
1612
+ * to find the first occurrence of the given property name and return its corresponding value.
1613
+ *
1614
+ * If not found, an error is returned.
1615
+ *
1616
+ * Example:
1617
+ * let val = query.get("age")?;
1618
+ * // val is a JsValue that might be a number, string, boolean, array, or object (e.g., { "$gt": 30 })
1619
+ * @param {string} property_name
1602
1620
  * @returns {any}
1603
1621
  */
1604
- parse() {
1622
+ get(property_name) {
1605
1623
  try {
1606
1624
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1607
- wasm.query_parse(retptr, this.__wbg_ptr);
1625
+ const ptr0 = passStringToWasm0(property_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1626
+ const len0 = WASM_VECTOR_LEN;
1627
+ wasm.query_get(retptr, this.__wbg_ptr, ptr0, len0);
1608
1628
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1609
1629
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1610
1630
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1618,43 +1638,33 @@ var Query = class {
1618
1638
  }
1619
1639
  /**
1620
1640
  * @param {any} query
1621
- * @returns {any}
1641
+ * @param {Schema} schema
1622
1642
  */
1623
- process_query(query) {
1643
+ constructor(query, schema) {
1624
1644
  try {
1625
1645
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1626
- wasm.query_process_query(retptr, this.__wbg_ptr, addBorrowedObject(query));
1646
+ _assertClass(schema, Schema);
1647
+ var ptr0 = schema.__destroy_into_raw();
1648
+ wasm.query_new(retptr, addHeapObject(query), ptr0);
1627
1649
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1628
1650
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1629
1651
  var r2 = getInt32Memory0()[retptr / 4 + 2];
1630
1652
  if (r2) {
1631
1653
  throw takeObject(r1);
1632
1654
  }
1633
- return takeObject(r0);
1655
+ this.__wbg_ptr = r0 >>> 0;
1656
+ return this;
1634
1657
  } finally {
1635
1658
  wasm.__wbindgen_add_to_stack_pointer(16);
1636
- heap[stack_pointer++] = void 0;
1637
1659
  }
1638
1660
  }
1639
1661
  /**
1640
- * Returns the value of a property from the (normalized) query by its name.
1641
- * This will scan the normalized query structure (including arrays, $and/$or blocks, etc.)
1642
- * to find the first occurrence of the given property name and return its corresponding value.
1643
- *
1644
- * If not found, an error is returned.
1645
- *
1646
- * Example:
1647
- * let val = query.get("age")?;
1648
- * // val is a JsValue that might be a number, string, boolean, array, or object (e.g., { "$gt": 30 })
1649
- * @param {string} property_name
1650
1662
  * @returns {any}
1651
1663
  */
1652
- get(property_name) {
1664
+ parse() {
1653
1665
  try {
1654
1666
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1655
- const ptr0 = passStringToWasm0(property_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1656
- const len0 = WASM_VECTOR_LEN;
1657
- wasm.query_get(retptr, this.__wbg_ptr, ptr0, len0);
1667
+ wasm.query_parse(retptr, this.__wbg_ptr);
1658
1668
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1659
1669
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1660
1670
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1667,11 +1677,22 @@ var Query = class {
1667
1677
  }
1668
1678
  }
1669
1679
  /**
1670
- * @returns {boolean}
1680
+ * @returns {any}
1671
1681
  */
1672
- has_or_operator() {
1673
- const ret = wasm.query_has_or_operator(this.__wbg_ptr);
1674
- return ret !== 0;
1682
+ get query() {
1683
+ try {
1684
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1685
+ wasm.query_query(retptr, this.__wbg_ptr);
1686
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
1687
+ var r1 = getInt32Memory0()[retptr / 4 + 1];
1688
+ var r2 = getInt32Memory0()[retptr / 4 + 2];
1689
+ if (r2) {
1690
+ throw takeObject(r1);
1691
+ }
1692
+ return takeObject(r0);
1693
+ } finally {
1694
+ wasm.__wbindgen_add_to_stack_pointer(16);
1695
+ }
1675
1696
  }
1676
1697
  };
1677
1698
  var QueryOptionsFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
@@ -1698,10 +1719,10 @@ var QueryOptions = class _QueryOptions {
1698
1719
  /**
1699
1720
  * @returns {any}
1700
1721
  */
1701
- get limit() {
1722
+ get offset() {
1702
1723
  try {
1703
1724
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1704
- wasm.queryoptions_limit(retptr, this.__wbg_ptr);
1725
+ wasm.queryoptions_offset(retptr, this.__wbg_ptr);
1705
1726
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1706
1727
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1707
1728
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1716,10 +1737,10 @@ var QueryOptions = class _QueryOptions {
1716
1737
  /**
1717
1738
  * @returns {any}
1718
1739
  */
1719
- get offset() {
1740
+ get limit() {
1720
1741
  try {
1721
1742
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1722
- wasm.queryoptions_offset(retptr, this.__wbg_ptr);
1743
+ wasm.queryoptions_limit(retptr, this.__wbg_ptr);
1723
1744
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1724
1745
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1725
1746
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1745,9 +1766,9 @@ var RIDBError = class _RIDBError {
1745
1766
  }
1746
1767
  toJSON() {
1747
1768
  return {
1748
- type: this.type,
1769
+ message: this.message,
1749
1770
  code: this.code,
1750
- message: this.message
1771
+ type: this.type
1751
1772
  };
1752
1773
  }
1753
1774
  toString() {
@@ -1764,44 +1785,15 @@ var RIDBError = class _RIDBError {
1764
1785
  wasm.__wbg_ridberror_free(ptr);
1765
1786
  }
1766
1787
  /**
1767
- * @param {string} err_type
1768
- * @param {string} message
1788
+ * @param {string} err
1769
1789
  * @param {number} code
1790
+ * @returns {RIDBError}
1770
1791
  */
1771
- constructor(err_type, message, code) {
1772
- const ptr0 = passStringToWasm0(err_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1792
+ static validation(err, code) {
1793
+ const ptr0 = passStringToWasm0(err, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1773
1794
  const len0 = WASM_VECTOR_LEN;
1774
- const ptr1 = passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1775
- const len1 = WASM_VECTOR_LEN;
1776
- const ret = wasm.ridberror_new(ptr0, len0, ptr1, len1, code);
1777
- this.__wbg_ptr = ret >>> 0;
1778
- return this;
1779
- }
1780
- /**
1781
- * @returns {string}
1782
- */
1783
- get type() {
1784
- let deferred1_0;
1785
- let deferred1_1;
1786
- try {
1787
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1788
- wasm.ridberror_type(retptr, this.__wbg_ptr);
1789
- var r0 = getInt32Memory0()[retptr / 4 + 0];
1790
- var r1 = getInt32Memory0()[retptr / 4 + 1];
1791
- deferred1_0 = r0;
1792
- deferred1_1 = r1;
1793
- return getStringFromWasm0(r0, r1);
1794
- } finally {
1795
- wasm.__wbindgen_add_to_stack_pointer(16);
1796
- wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
1797
- }
1798
- }
1799
- /**
1800
- * @returns {any}
1801
- */
1802
- get code() {
1803
- const ret = wasm.ridberror_code(this.__wbg_ptr);
1804
- return takeObject(ret);
1795
+ const ret = wasm.ridberror_validation(ptr0, len0, code);
1796
+ return _RIDBError.__wrap(ret);
1805
1797
  }
1806
1798
  /**
1807
1799
  * @returns {string}
@@ -1823,11 +1815,14 @@ var RIDBError = class _RIDBError {
1823
1815
  }
1824
1816
  }
1825
1817
  /**
1826
- * @param {any} err
1818
+ * @param {string} err
1819
+ * @param {number} code
1827
1820
  * @returns {RIDBError}
1828
1821
  */
1829
- static from(err) {
1830
- const ret = wasm.ridberror_from(addHeapObject(err));
1822
+ static serialisation(err, code) {
1823
+ const ptr0 = passStringToWasm0(err, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1824
+ const len0 = WASM_VECTOR_LEN;
1825
+ const ret = wasm.ridberror_serialisation(ptr0, len0, code);
1831
1826
  return _RIDBError.__wrap(ret);
1832
1827
  }
1833
1828
  /**
@@ -1835,32 +1830,35 @@ var RIDBError = class _RIDBError {
1835
1830
  * @param {number} code
1836
1831
  * @returns {RIDBError}
1837
1832
  */
1838
- static error(err, code) {
1833
+ static authentication(err, code) {
1839
1834
  const ptr0 = passStringToWasm0(err, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1840
1835
  const len0 = WASM_VECTOR_LEN;
1841
- const ret = wasm.ridberror_error(ptr0, len0, code);
1836
+ const ret = wasm.ridberror_authentication(ptr0, len0, code);
1842
1837
  return _RIDBError.__wrap(ret);
1843
1838
  }
1844
1839
  /**
1845
- * @param {string} err
1840
+ * @param {string} err_type
1841
+ * @param {string} message
1846
1842
  * @param {number} code
1847
- * @returns {RIDBError}
1848
1843
  */
1849
- static query(err, code) {
1850
- const ptr0 = passStringToWasm0(err, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1844
+ constructor(err_type, message, code) {
1845
+ const ptr0 = passStringToWasm0(err_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1851
1846
  const len0 = WASM_VECTOR_LEN;
1852
- const ret = wasm.ridberror_query(ptr0, len0, code);
1853
- return _RIDBError.__wrap(ret);
1847
+ const ptr1 = passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1848
+ const len1 = WASM_VECTOR_LEN;
1849
+ const ret = wasm.ridberror_new(ptr0, len0, ptr1, len1, code);
1850
+ this.__wbg_ptr = ret >>> 0;
1851
+ return this;
1854
1852
  }
1855
1853
  /**
1856
1854
  * @param {string} err
1857
1855
  * @param {number} code
1858
1856
  * @returns {RIDBError}
1859
1857
  */
1860
- static authentication(err, code) {
1858
+ static hook(err, code) {
1861
1859
  const ptr0 = passStringToWasm0(err, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1862
1860
  const len0 = WASM_VECTOR_LEN;
1863
- const ret = wasm.ridberror_authentication(ptr0, len0, code);
1861
+ const ret = wasm.ridberror_hook(ptr0, len0, code);
1864
1862
  return _RIDBError.__wrap(ret);
1865
1863
  }
1866
1864
  /**
@@ -1868,10 +1866,10 @@ var RIDBError = class _RIDBError {
1868
1866
  * @param {number} code
1869
1867
  * @returns {RIDBError}
1870
1868
  */
1871
- static serialisation(err, code) {
1869
+ static error(err, code) {
1872
1870
  const ptr0 = passStringToWasm0(err, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1873
1871
  const len0 = WASM_VECTOR_LEN;
1874
- const ret = wasm.ridberror_serialisation(ptr0, len0, code);
1872
+ const ret = wasm.ridberror_error(ptr0, len0, code);
1875
1873
  return _RIDBError.__wrap(ret);
1876
1874
  }
1877
1875
  /**
@@ -1879,23 +1877,46 @@ var RIDBError = class _RIDBError {
1879
1877
  * @param {number} code
1880
1878
  * @returns {RIDBError}
1881
1879
  */
1882
- static validation(err, code) {
1880
+ static query(err, code) {
1883
1881
  const ptr0 = passStringToWasm0(err, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1884
1882
  const len0 = WASM_VECTOR_LEN;
1885
- const ret = wasm.ridberror_validation(ptr0, len0, code);
1883
+ const ret = wasm.ridberror_query(ptr0, len0, code);
1886
1884
  return _RIDBError.__wrap(ret);
1887
1885
  }
1888
1886
  /**
1889
- * @param {string} err
1890
- * @param {number} code
1887
+ * @returns {any}
1888
+ */
1889
+ get code() {
1890
+ const ret = wasm.ridberror_code(this.__wbg_ptr);
1891
+ return takeObject(ret);
1892
+ }
1893
+ /**
1894
+ * @param {any} err
1891
1895
  * @returns {RIDBError}
1892
1896
  */
1893
- static hook(err, code) {
1894
- const ptr0 = passStringToWasm0(err, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1895
- const len0 = WASM_VECTOR_LEN;
1896
- const ret = wasm.ridberror_hook(ptr0, len0, code);
1897
+ static from(err) {
1898
+ const ret = wasm.ridberror_from(addHeapObject(err));
1897
1899
  return _RIDBError.__wrap(ret);
1898
1900
  }
1901
+ /**
1902
+ * @returns {string}
1903
+ */
1904
+ get type() {
1905
+ let deferred1_0;
1906
+ let deferred1_1;
1907
+ try {
1908
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1909
+ wasm.ridberror_type(retptr, this.__wbg_ptr);
1910
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
1911
+ var r1 = getInt32Memory0()[retptr / 4 + 1];
1912
+ deferred1_0 = r0;
1913
+ deferred1_1 = r1;
1914
+ return getStringFromWasm0(r0, r1);
1915
+ } finally {
1916
+ wasm.__wbindgen_add_to_stack_pointer(16);
1917
+ wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
1918
+ }
1919
+ }
1899
1920
  };
1900
1921
  var SchemaFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
1901
1922
  }, unregister: () => {
@@ -1919,80 +1940,84 @@ var Schema = class _Schema {
1919
1940
  wasm.__wbg_schema_free(ptr);
1920
1941
  }
1921
1942
  /**
1922
- * @param {any} document
1943
+ * Retrieves the indexes of the schema, if any.
1944
+ *
1945
+ * # Returns
1946
+ *
1947
+ * * `Option<Vec<String>>` - The indexes of the schema, if any.
1948
+ * @returns {(string)[] | undefined}
1923
1949
  */
1924
- validate(document2) {
1950
+ get indexes() {
1925
1951
  try {
1926
1952
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1927
- wasm.schema_validate(retptr, this.__wbg_ptr, addHeapObject(document2));
1953
+ wasm.schema_indexes(retptr, this.__wbg_ptr);
1928
1954
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1929
1955
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1930
- if (r1) {
1931
- throw takeObject(r0);
1956
+ let v1;
1957
+ if (r0 !== 0) {
1958
+ v1 = getArrayJsValueFromWasm0(r0, r1).slice();
1959
+ wasm.__wbindgen_free(r0, r1 * 4, 4);
1932
1960
  }
1961
+ return v1;
1933
1962
  } finally {
1934
1963
  wasm.__wbindgen_add_to_stack_pointer(16);
1935
1964
  }
1936
1965
  }
1937
1966
  /**
1938
- * @returns {boolean}
1967
+ * Retrieves the version of the schema.
1968
+ *
1969
+ * # Returns
1970
+ *
1971
+ * * `i32` - The version of the schema.
1972
+ * @returns {number}
1939
1973
  */
1940
- is_valid() {
1974
+ get version() {
1975
+ const ret = wasm.schema_version(this.__wbg_ptr);
1976
+ return ret;
1977
+ }
1978
+ /**
1979
+ * @returns {(string)[] | undefined}
1980
+ */
1981
+ get encrypted() {
1941
1982
  try {
1942
1983
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1943
- wasm.schema_is_valid(retptr, this.__wbg_ptr);
1984
+ wasm.schema_encrypted(retptr, this.__wbg_ptr);
1944
1985
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1945
1986
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1946
- var r2 = getInt32Memory0()[retptr / 4 + 2];
1947
- if (r2) {
1948
- throw takeObject(r1);
1987
+ let v1;
1988
+ if (r0 !== 0) {
1989
+ v1 = getArrayJsValueFromWasm0(r0, r1).slice();
1990
+ wasm.__wbindgen_free(r0, r1 * 4, 4);
1949
1991
  }
1950
- return r0 !== 0;
1992
+ return v1;
1951
1993
  } finally {
1952
1994
  wasm.__wbindgen_add_to_stack_pointer(16);
1953
1995
  }
1954
1996
  }
1955
1997
  /**
1956
- * Creates a new `Schema` instance from a given `JsValue`.
1957
- *
1958
- * # Arguments
1959
- *
1960
- * * `schema` - A `JsValue` representing the schema.
1998
+ * Retrieves the properties of the schema.
1961
1999
  *
1962
2000
  * # Returns
1963
2001
  *
1964
- * * `Result<Schema, JsValue>` - A result containing the new `Schema` instance or an error.
1965
- * @param {any} schema
1966
- * @returns {Schema}
2002
+ * * `Result<JsValue, JsValue>` - A result containing the properties as a `JsValue` or an error.
2003
+ * @returns {any}
1967
2004
  */
1968
- static create(schema) {
2005
+ get properties() {
1969
2006
  try {
1970
2007
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1971
- wasm.schema_create(retptr, addHeapObject(schema));
2008
+ wasm.schema_properties(retptr, this.__wbg_ptr);
1972
2009
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1973
2010
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1974
2011
  var r2 = getInt32Memory0()[retptr / 4 + 2];
1975
2012
  if (r2) {
1976
2013
  throw takeObject(r1);
1977
2014
  }
1978
- return _Schema.__wrap(r0);
2015
+ return takeObject(r0);
1979
2016
  } finally {
1980
2017
  wasm.__wbindgen_add_to_stack_pointer(16);
1981
2018
  }
1982
2019
  }
1983
2020
  /**
1984
- * Retrieves the version of the schema.
1985
- *
1986
- * # Returns
1987
- *
1988
- * * `i32` - The version of the schema.
1989
- * @returns {number}
1990
- */
1991
- get version() {
1992
- const ret = wasm.schema_version(this.__wbg_ptr);
1993
- return ret;
1994
- }
1995
- /**
1996
2021
  * Retrieves the primary key of the schema.
1997
2022
  *
1998
2023
  * # Returns
@@ -2041,67 +2066,63 @@ var Schema = class _Schema {
2041
2066
  }
2042
2067
  }
2043
2068
  /**
2044
- * Retrieves the indexes of the schema, if any.
2045
- *
2046
- * # Returns
2047
- *
2048
- * * `Option<Vec<String>>` - The indexes of the schema, if any.
2049
- * @returns {(string)[] | undefined}
2069
+ * @param {any} document
2050
2070
  */
2051
- get indexes() {
2071
+ validate(document2) {
2052
2072
  try {
2053
2073
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2054
- wasm.schema_indexes(retptr, this.__wbg_ptr);
2074
+ wasm.schema_validate(retptr, this.__wbg_ptr, addHeapObject(document2));
2055
2075
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2056
2076
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2057
- let v1;
2058
- if (r0 !== 0) {
2059
- v1 = getArrayJsValueFromWasm0(r0, r1).slice();
2060
- wasm.__wbindgen_free(r0, r1 * 4, 4);
2077
+ if (r1) {
2078
+ throw takeObject(r0);
2061
2079
  }
2062
- return v1;
2063
2080
  } finally {
2064
2081
  wasm.__wbindgen_add_to_stack_pointer(16);
2065
2082
  }
2066
2083
  }
2067
2084
  /**
2068
- * @returns {(string)[] | undefined}
2085
+ * Creates a new `Schema` instance from a given `JsValue`.
2086
+ *
2087
+ * # Arguments
2088
+ *
2089
+ * * `schema` - A `JsValue` representing the schema.
2090
+ *
2091
+ * # Returns
2092
+ *
2093
+ * * `Result<Schema, JsValue>` - A result containing the new `Schema` instance or an error.
2094
+ * @param {any} schema
2095
+ * @returns {Schema}
2069
2096
  */
2070
- get encrypted() {
2097
+ static create(schema) {
2071
2098
  try {
2072
2099
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2073
- wasm.schema_encrypted(retptr, this.__wbg_ptr);
2100
+ wasm.schema_create(retptr, addHeapObject(schema));
2074
2101
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2075
2102
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2076
- let v1;
2077
- if (r0 !== 0) {
2078
- v1 = getArrayJsValueFromWasm0(r0, r1).slice();
2079
- wasm.__wbindgen_free(r0, r1 * 4, 4);
2103
+ var r2 = getInt32Memory0()[retptr / 4 + 2];
2104
+ if (r2) {
2105
+ throw takeObject(r1);
2080
2106
  }
2081
- return v1;
2107
+ return _Schema.__wrap(r0);
2082
2108
  } finally {
2083
2109
  wasm.__wbindgen_add_to_stack_pointer(16);
2084
2110
  }
2085
2111
  }
2086
2112
  /**
2087
- * Retrieves the properties of the schema.
2088
- *
2089
- * # Returns
2090
- *
2091
- * * `Result<JsValue, JsValue>` - A result containing the properties as a `JsValue` or an error.
2092
- * @returns {any}
2113
+ * @returns {boolean}
2093
2114
  */
2094
- get properties() {
2115
+ is_valid() {
2095
2116
  try {
2096
2117
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2097
- wasm.schema_properties(retptr, this.__wbg_ptr);
2118
+ wasm.schema_is_valid(retptr, this.__wbg_ptr);
2098
2119
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2099
2120
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2100
2121
  var r2 = getInt32Memory0()[retptr / 4 + 2];
2101
2122
  if (r2) {
2102
2123
  throw takeObject(r1);
2103
2124
  }
2104
- return takeObject(r0);
2125
+ return r0 !== 0;
2105
2126
  } finally {
2106
2127
  wasm.__wbindgen_add_to_stack_pointer(16);
2107
2128
  }
@@ -2134,16 +2155,6 @@ var WasmBindgenTestContext = class {
2134
2155
  return this;
2135
2156
  }
2136
2157
  /**
2137
- * Inform this context about runtime arguments passed to the test
2138
- * harness.
2139
- * @param {any[]} args
2140
- */
2141
- args(args) {
2142
- const ptr0 = passArrayJsValueToWasm0(args, wasm.__wbindgen_malloc);
2143
- const len0 = WASM_VECTOR_LEN;
2144
- wasm.wasmbindgentestcontext_args(this.__wbg_ptr, ptr0, len0);
2145
- }
2146
- /**
2147
2158
  * Executes a list of tests, returning a promise representing their
2148
2159
  * eventual completion.
2149
2160
  *
@@ -2162,6 +2173,16 @@ var WasmBindgenTestContext = class {
2162
2173
  const ret = wasm.wasmbindgentestcontext_run(this.__wbg_ptr, ptr0, len0);
2163
2174
  return takeObject(ret);
2164
2175
  }
2176
+ /**
2177
+ * Inform this context about runtime arguments passed to the test
2178
+ * harness.
2179
+ * @param {any[]} args
2180
+ */
2181
+ args(args) {
2182
+ const ptr0 = passArrayJsValueToWasm0(args, wasm.__wbindgen_malloc);
2183
+ const len0 = WASM_VECTOR_LEN;
2184
+ wasm.wasmbindgentestcontext_args(this.__wbg_ptr, ptr0, len0);
2185
+ }
2165
2186
  };
2166
2187
  async function __wbg_load(module2, imports) {
2167
2188
  if (typeof Response === "function" && module2 instanceof Response) {
@@ -2193,51 +2214,30 @@ function __wbg_get_imports() {
2193
2214
  imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
2194
2215
  takeObject(arg0);
2195
2216
  };
2196
- imports.wbg.__wbg_count_19db4c3174d573d5 = function() {
2197
- return handleError(function(arg0, arg1, arg2, arg3, arg4) {
2198
- const ret = getObject(arg0).count(getStringFromWasm0(arg1, arg2), takeObject(arg3), QueryOptions.__wrap(arg4));
2199
- return addHeapObject(ret);
2200
- }, arguments);
2201
- };
2202
- imports.wbg.__wbg_ridberror_new = function(arg0) {
2203
- const ret = RIDBError.__wrap(arg0);
2217
+ imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
2218
+ const ret = getObject(arg0);
2204
2219
  return addHeapObject(ret);
2205
2220
  };
2206
2221
  imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
2207
2222
  const ret = getStringFromWasm0(arg0, arg1);
2208
2223
  return addHeapObject(ret);
2209
2224
  };
2210
- imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
2211
- const ret = getObject(arg0);
2225
+ imports.wbg.__wbindgen_number_new = function(arg0) {
2226
+ const ret = arg0;
2212
2227
  return addHeapObject(ret);
2213
2228
  };
2214
- imports.wbg.__wbindgen_is_undefined = function(arg0) {
2215
- const ret = getObject(arg0) === void 0;
2216
- return ret;
2229
+ imports.wbg.__wbg_ridberror_new = function(arg0) {
2230
+ const ret = RIDBError.__wrap(arg0);
2231
+ return addHeapObject(ret);
2217
2232
  };
2218
2233
  imports.wbg.__wbindgen_is_null = function(arg0) {
2219
2234
  const ret = getObject(arg0) === null;
2220
2235
  return ret;
2221
2236
  };
2222
- imports.wbg.__wbg_start_76c138c3b73ae6f8 = function() {
2223
- return handleError(function(arg0) {
2224
- const ret = getObject(arg0).start();
2225
- return addHeapObject(ret);
2226
- }, arguments);
2227
- };
2228
- imports.wbg.__wbindgen_cb_drop = function(arg0) {
2229
- const obj = takeObject(arg0).original;
2230
- if (obj.cnt-- == 1) {
2231
- obj.a = 0;
2232
- return true;
2233
- }
2234
- const ret = false;
2237
+ imports.wbg.__wbindgen_is_undefined = function(arg0) {
2238
+ const ret = getObject(arg0) === void 0;
2235
2239
  return ret;
2236
2240
  };
2237
- imports.wbg.__wbindgen_number_new = function(arg0) {
2238
- const ret = arg0;
2239
- return addHeapObject(ret);
2240
- };
2241
2241
  imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
2242
2242
  const obj = getObject(arg1);
2243
2243
  const ret = typeof obj === "string" ? obj : void 0;
@@ -2246,6 +2246,12 @@ function __wbg_get_imports() {
2246
2246
  getInt32Memory0()[arg0 / 4 + 1] = len1;
2247
2247
  getInt32Memory0()[arg0 / 4 + 0] = ptr1;
2248
2248
  };
2249
+ imports.wbg.__wbg_count_19db4c3174d573d5 = function() {
2250
+ return handleError(function(arg0, arg1, arg2, arg3, arg4) {
2251
+ const ret = getObject(arg0).count(getStringFromWasm0(arg1, arg2), takeObject(arg3), QueryOptions.__wrap(arg4));
2252
+ return addHeapObject(ret);
2253
+ }, arguments);
2254
+ };
2249
2255
  imports.wbg.__wbg_apply_9f557eba1534d597 = function() {
2250
2256
  return handleError(function(arg0, arg1, arg2) {
2251
2257
  const ret = getObject(arg1).apply(takeObject(arg2));
@@ -2259,59 +2265,66 @@ function __wbg_get_imports() {
2259
2265
  const ret = InMemory.__wrap(arg0);
2260
2266
  return addHeapObject(ret);
2261
2267
  };
2268
+ imports.wbg.__wbindgen_cb_drop = function(arg0) {
2269
+ const obj = takeObject(arg0).original;
2270
+ if (obj.cnt-- == 1) {
2271
+ obj.a = 0;
2272
+ return true;
2273
+ }
2274
+ const ret = false;
2275
+ return ret;
2276
+ };
2262
2277
  imports.wbg.__wbg_close_6384ed3c27ef25c1 = function() {
2263
2278
  return handleError(function(arg0) {
2264
2279
  const ret = getObject(arg0).close();
2265
2280
  return addHeapObject(ret);
2266
2281
  }, arguments);
2267
2282
  };
2283
+ imports.wbg.__wbg_start_76c138c3b73ae6f8 = function() {
2284
+ return handleError(function(arg0) {
2285
+ const ret = getObject(arg0).start();
2286
+ return addHeapObject(ret);
2287
+ }, arguments);
2288
+ };
2268
2289
  imports.wbg.__wbindgen_number_get = function(arg0, arg1) {
2269
2290
  const obj = getObject(arg1);
2270
2291
  const ret = typeof obj === "number" ? obj : void 0;
2271
2292
  getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret;
2272
2293
  getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
2273
2294
  };
2274
- imports.wbg.__wbg_find_567c5c9f064fe3d2 = function() {
2275
- return handleError(function(arg0, arg1, arg2, arg3, arg4) {
2276
- const ret = getObject(arg0).find(getStringFromWasm0(arg1, arg2), takeObject(arg3), QueryOptions.__wrap(arg4));
2277
- return addHeapObject(ret);
2278
- }, arguments);
2279
- };
2280
2295
  imports.wbg.__wbg_findDocumentById_2edf7350e5f12657 = function() {
2281
2296
  return handleError(function(arg0, arg1, arg2, arg3) {
2282
2297
  const ret = getObject(arg0).findDocumentById(getStringFromWasm0(arg1, arg2), takeObject(arg3));
2283
2298
  return addHeapObject(ret);
2284
2299
  }, arguments);
2285
2300
  };
2301
+ imports.wbg.__wbg_find_567c5c9f064fe3d2 = function() {
2302
+ return handleError(function(arg0, arg1, arg2, arg3, arg4) {
2303
+ const ret = getObject(arg0).find(getStringFromWasm0(arg1, arg2), takeObject(arg3), QueryOptions.__wrap(arg4));
2304
+ return addHeapObject(ret);
2305
+ }, arguments);
2306
+ };
2286
2307
  imports.wbg.__wbg_write_1159c67c07f62020 = function() {
2287
2308
  return handleError(function(arg0, arg1) {
2288
2309
  const ret = getObject(arg0).write(Operation.__wrap(arg1));
2289
2310
  return addHeapObject(ret);
2290
2311
  }, arguments);
2291
2312
  };
2292
- imports.wbg.__wbg_database_new = function(arg0) {
2293
- const ret = Database.__wrap(arg0);
2294
- return addHeapObject(ret);
2295
- };
2296
- imports.wbg.__wbg_collection_new = function(arg0) {
2297
- const ret = Collection.__wrap(arg0);
2298
- return addHeapObject(ret);
2313
+ imports.wbg.__wbindgen_is_object = function(arg0) {
2314
+ const val = getObject(arg0);
2315
+ const ret = typeof val === "object" && val !== null;
2316
+ return ret;
2299
2317
  };
2300
- imports.wbg.__wbg_indexdb_new = function(arg0) {
2301
- const ret = IndexDB.__wrap(arg0);
2302
- return addHeapObject(ret);
2318
+ imports.wbg.__wbindgen_is_string = function(arg0) {
2319
+ const ret = typeof getObject(arg0) === "string";
2320
+ return ret;
2303
2321
  };
2304
2322
  imports.wbg.__wbindgen_is_array = function(arg0) {
2305
2323
  const ret = Array.isArray(getObject(arg0));
2306
2324
  return ret;
2307
2325
  };
2308
- imports.wbg.__wbindgen_is_object = function(arg0) {
2309
- const val = getObject(arg0);
2310
- const ret = typeof val === "object" && val !== null;
2311
- return ret;
2312
- };
2313
- imports.wbg.__wbindgen_jsval_eq = function(arg0, arg1) {
2314
- const ret = getObject(arg0) === getObject(arg1);
2326
+ imports.wbg.__wbindgen_is_falsy = function(arg0) {
2327
+ const ret = !getObject(arg0);
2315
2328
  return ret;
2316
2329
  };
2317
2330
  imports.wbg.__wbindgen_boolean_get = function(arg0) {
@@ -2319,10 +2332,18 @@ function __wbg_get_imports() {
2319
2332
  const ret = typeof v === "boolean" ? v ? 1 : 0 : 2;
2320
2333
  return ret;
2321
2334
  };
2335
+ imports.wbg.__wbindgen_is_function = function(arg0) {
2336
+ const ret = typeof getObject(arg0) === "function";
2337
+ return ret;
2338
+ };
2322
2339
  imports.wbg.__wbindgen_is_bigint = function(arg0) {
2323
2340
  const ret = typeof getObject(arg0) === "bigint";
2324
2341
  return ret;
2325
2342
  };
2343
+ imports.wbg.__wbg_collection_new = function(arg0) {
2344
+ const ret = Collection.__wrap(arg0);
2345
+ return addHeapObject(ret);
2346
+ };
2326
2347
  imports.wbg.__wbindgen_in = function(arg0, arg1) {
2327
2348
  const ret = getObject(arg0) in getObject(arg1);
2328
2349
  return ret;
@@ -2331,6 +2352,10 @@ function __wbg_get_imports() {
2331
2352
  const ret = arg0;
2332
2353
  return addHeapObject(ret);
2333
2354
  };
2355
+ imports.wbg.__wbindgen_jsval_eq = function(arg0, arg1) {
2356
+ const ret = getObject(arg0) === getObject(arg1);
2357
+ return ret;
2358
+ };
2334
2359
  imports.wbg.__wbindgen_bigint_from_u64 = function(arg0) {
2335
2360
  const ret = BigInt.asUintN(64, arg0);
2336
2361
  return addHeapObject(ret);
@@ -2339,17 +2364,13 @@ function __wbg_get_imports() {
2339
2364
  const ret = new Error(getStringFromWasm0(arg0, arg1));
2340
2365
  return addHeapObject(ret);
2341
2366
  };
2342
- imports.wbg.__wbindgen_is_string = function(arg0) {
2343
- const ret = typeof getObject(arg0) === "string";
2344
- return ret;
2345
- };
2346
- imports.wbg.__wbindgen_is_falsy = function(arg0) {
2347
- const ret = !getObject(arg0);
2348
- return ret;
2367
+ imports.wbg.__wbg_database_new = function(arg0) {
2368
+ const ret = Database.__wrap(arg0);
2369
+ return addHeapObject(ret);
2349
2370
  };
2350
- imports.wbg.__wbindgen_is_function = function(arg0) {
2351
- const ret = typeof getObject(arg0) === "function";
2352
- return ret;
2371
+ imports.wbg.__wbg_indexdb_new = function(arg0) {
2372
+ const ret = IndexDB.__wrap(arg0);
2373
+ return addHeapObject(ret);
2353
2374
  };
2354
2375
  imports.wbg.__wbg_crypto_1d1f22824a6a080c = function(arg0) {
2355
2376
  const ret = getObject(arg0).crypto;
@@ -2403,6 +2424,12 @@ function __wbg_get_imports() {
2403
2424
  return isLikeNone(ret) ? 0 : addHeapObject(ret);
2404
2425
  }, arguments);
2405
2426
  };
2427
+ imports.wbg.__wbg_indexedDB_d312f95759a15fdc = function() {
2428
+ return handleError(function(arg0) {
2429
+ const ret = getObject(arg0).indexedDB;
2430
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
2431
+ }, arguments);
2432
+ };
2406
2433
  imports.wbg.__wbg_instanceof_WorkerGlobalScope_46b577f151fad960 = function(arg0) {
2407
2434
  let result;
2408
2435
  try {
@@ -2413,105 +2440,106 @@ function __wbg_get_imports() {
2413
2440
  const ret = result;
2414
2441
  return ret;
2415
2442
  };
2416
- imports.wbg.__wbg_indexedDB_d312f95759a15fdc = function() {
2443
+ imports.wbg.__wbg_continue_f1c3e0815924de62 = function() {
2417
2444
  return handleError(function(arg0) {
2418
- const ret = getObject(arg0).indexedDB;
2419
- return isLikeNone(ret) ? 0 : addHeapObject(ret);
2445
+ getObject(arg0).continue();
2420
2446
  }, arguments);
2421
2447
  };
2422
- imports.wbg.__wbg_debug_5fb96680aecf5dc8 = function(arg0) {
2423
- console.debug(getObject(arg0));
2424
- };
2425
- imports.wbg.__wbg_openCursor_425aba9cbe1d4d39 = function() {
2426
- return handleError(function(arg0) {
2427
- const ret = getObject(arg0).openCursor();
2448
+ imports.wbg.__wbg_open_f0d7259fd7e689ce = function() {
2449
+ return handleError(function(arg0, arg1, arg2, arg3) {
2450
+ const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2), arg3 >>> 0);
2428
2451
  return addHeapObject(ret);
2429
2452
  }, arguments);
2430
2453
  };
2431
- imports.wbg.__wbg_openCursor_e3042770817a8d57 = function() {
2432
- return handleError(function(arg0, arg1) {
2433
- const ret = getObject(arg0).openCursor(getObject(arg1));
2454
+ imports.wbg.__wbg_lowerBound_cd1c8a3b3fdf1582 = function() {
2455
+ return handleError(function(arg0) {
2456
+ const ret = IDBKeyRange.lowerBound(getObject(arg0));
2434
2457
  return addHeapObject(ret);
2435
2458
  }, arguments);
2436
2459
  };
2437
- imports.wbg.__wbg_openKeyCursor_6a1881d8dd9f1c21 = function() {
2460
+ imports.wbg.__wbg_upperBound_1e3077b2c05bdd71 = function() {
2438
2461
  return handleError(function(arg0) {
2439
- const ret = getObject(arg0).openKeyCursor();
2462
+ const ret = IDBKeyRange.upperBound(getObject(arg0));
2440
2463
  return addHeapObject(ret);
2441
2464
  }, arguments);
2442
2465
  };
2443
- imports.wbg.__wbg_openKeyCursor_a50d16a4992519e2 = function() {
2466
+ imports.wbg.__wbg_lowerBound_e77f6e14cb69151e = function() {
2444
2467
  return handleError(function(arg0, arg1) {
2445
- const ret = getObject(arg0).openKeyCursor(getObject(arg1));
2468
+ const ret = IDBKeyRange.lowerBound(getObject(arg0), arg1 !== 0);
2446
2469
  return addHeapObject(ret);
2447
2470
  }, arguments);
2448
2471
  };
2449
- imports.wbg.__wbg_createIndex_b8da1f5571f644be = function() {
2450
- return handleError(function(arg0, arg1, arg2, arg3, arg4, arg5) {
2451
- const ret = getObject(arg0).createIndex(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4), getObject(arg5));
2472
+ imports.wbg.__wbg_upperBound_4c692da072d1a11e = function() {
2473
+ return handleError(function(arg0, arg1) {
2474
+ const ret = IDBKeyRange.upperBound(getObject(arg0), arg1 !== 0);
2452
2475
  return addHeapObject(ret);
2453
2476
  }, arguments);
2454
2477
  };
2455
- imports.wbg.__wbg_delete_f60bba7d0ae59a4f = function() {
2456
- return handleError(function(arg0, arg1) {
2457
- const ret = getObject(arg0).delete(getObject(arg1));
2478
+ imports.wbg.__wbg_bound_25385469508e98c7 = function() {
2479
+ return handleError(function(arg0, arg1, arg2, arg3) {
2480
+ const ret = IDBKeyRange.bound(getObject(arg0), getObject(arg1), arg2 !== 0, arg3 !== 0);
2458
2481
  return addHeapObject(ret);
2459
2482
  }, arguments);
2460
2483
  };
2461
- imports.wbg.__wbg_get_5361b64cac0d0826 = function() {
2462
- return handleError(function(arg0, arg1) {
2463
- const ret = getObject(arg0).get(getObject(arg1));
2484
+ imports.wbg.__wbg_only_cacf767244bdc280 = function() {
2485
+ return handleError(function(arg0) {
2486
+ const ret = IDBKeyRange.only(getObject(arg0));
2464
2487
  return addHeapObject(ret);
2465
2488
  }, arguments);
2466
2489
  };
2467
- imports.wbg.__wbg_index_383b6812c1508030 = function() {
2468
- return handleError(function(arg0, arg1, arg2) {
2469
- const ret = getObject(arg0).index(getStringFromWasm0(arg1, arg2));
2490
+ imports.wbg.__wbg_get_910bbb94abdcf488 = function(arg0, arg1, arg2) {
2491
+ const ret = getObject(arg1)[arg2 >>> 0];
2492
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2493
+ var len1 = WASM_VECTOR_LEN;
2494
+ getInt32Memory0()[arg0 / 4 + 1] = len1;
2495
+ getInt32Memory0()[arg0 / 4 + 0] = ptr1;
2496
+ };
2497
+ imports.wbg.__wbg_length_9ae5daf9a690cba9 = function(arg0) {
2498
+ const ret = getObject(arg0).length;
2499
+ return ret;
2500
+ };
2501
+ imports.wbg.__wbg_contains_c65b44400b549286 = function(arg0, arg1, arg2) {
2502
+ const ret = getObject(arg0).contains(getStringFromWasm0(arg1, arg2));
2503
+ return ret;
2504
+ };
2505
+ imports.wbg.__wbg_value_86d3334f5075b232 = function() {
2506
+ return handleError(function(arg0) {
2507
+ const ret = getObject(arg0).value;
2470
2508
  return addHeapObject(ret);
2471
2509
  }, arguments);
2472
2510
  };
2473
- imports.wbg.__wbg_openCursor_30d58ae27a327629 = function() {
2511
+ imports.wbg.__wbg_instanceof_IdbCursorWithValue_abeb44d13d947bc2 = function(arg0) {
2512
+ let result;
2513
+ try {
2514
+ result = getObject(arg0) instanceof IDBCursorWithValue;
2515
+ } catch (_) {
2516
+ result = false;
2517
+ }
2518
+ const ret = result;
2519
+ return ret;
2520
+ };
2521
+ imports.wbg.__wbg_debug_5fb96680aecf5dc8 = function(arg0) {
2522
+ console.debug(getObject(arg0));
2523
+ };
2524
+ imports.wbg.__wbg_openCursor_425aba9cbe1d4d39 = function() {
2474
2525
  return handleError(function(arg0) {
2475
2526
  const ret = getObject(arg0).openCursor();
2476
2527
  return addHeapObject(ret);
2477
2528
  }, arguments);
2478
2529
  };
2479
- imports.wbg.__wbg_openCursor_611b1e488c393dd8 = function() {
2530
+ imports.wbg.__wbg_openCursor_e3042770817a8d57 = function() {
2480
2531
  return handleError(function(arg0, arg1) {
2481
2532
  const ret = getObject(arg0).openCursor(getObject(arg1));
2482
2533
  return addHeapObject(ret);
2483
2534
  }, arguments);
2484
2535
  };
2485
- imports.wbg.__wbg_put_22792e17580ca18b = function() {
2536
+ imports.wbg.__wbg_objectStoreNames_588b5924274239fd = function(arg0) {
2537
+ const ret = getObject(arg0).objectStoreNames;
2538
+ return addHeapObject(ret);
2539
+ };
2540
+ imports.wbg.__wbg_createObjectStore_882f2f6b1b1ef040 = function() {
2486
2541
  return handleError(function(arg0, arg1, arg2) {
2487
- const ret = getObject(arg0).put(getObject(arg1), getObject(arg2));
2488
- return addHeapObject(ret);
2489
- }, arguments);
2490
- };
2491
- imports.wbg.__wbg_target_2fc177e386c8b7b0 = function(arg0) {
2492
- const ret = getObject(arg0).target;
2493
- return isLikeNone(ret) ? 0 : addHeapObject(ret);
2494
- };
2495
- imports.wbg.__wbg_instanceof_IdbDatabase_db671cf2454a9542 = function(arg0) {
2496
- let result;
2497
- try {
2498
- result = getObject(arg0) instanceof IDBDatabase;
2499
- } catch (_) {
2500
- result = false;
2501
- }
2502
- const ret = result;
2503
- return ret;
2504
- };
2505
- imports.wbg.__wbg_objectStoreNames_588b5924274239fd = function(arg0) {
2506
- const ret = getObject(arg0).objectStoreNames;
2507
- return addHeapObject(ret);
2508
- };
2509
- imports.wbg.__wbg_close_6bfe4ca2fe67cb67 = function(arg0) {
2510
- getObject(arg0).close();
2511
- };
2512
- imports.wbg.__wbg_createObjectStore_882f2f6b1b1ef040 = function() {
2513
- return handleError(function(arg0, arg1, arg2) {
2514
- const ret = getObject(arg0).createObjectStore(getStringFromWasm0(arg1, arg2));
2542
+ const ret = getObject(arg0).createObjectStore(getStringFromWasm0(arg1, arg2));
2515
2543
  return addHeapObject(ret);
2516
2544
  }, arguments);
2517
2545
  };
@@ -2527,147 +2555,112 @@ function __wbg_get_imports() {
2527
2555
  return addHeapObject(ret);
2528
2556
  }, arguments);
2529
2557
  };
2530
- imports.wbg.__wbg_objectStore_da468793bd9df17b = function() {
2531
- return handleError(function(arg0, arg1, arg2) {
2532
- const ret = getObject(arg0).objectStore(getStringFromWasm0(arg1, arg2));
2533
- return addHeapObject(ret);
2534
- }, arguments);
2558
+ imports.wbg.__wbg_close_6bfe4ca2fe67cb67 = function(arg0) {
2559
+ getObject(arg0).close();
2535
2560
  };
2536
- imports.wbg.__wbg_instanceof_IdbCursor_e572a9900478e938 = function(arg0) {
2561
+ imports.wbg.__wbg_instanceof_IdbDatabase_db671cf2454a9542 = function(arg0) {
2537
2562
  let result;
2538
2563
  try {
2539
- result = getObject(arg0) instanceof IDBCursor;
2564
+ result = getObject(arg0) instanceof IDBDatabase;
2540
2565
  } catch (_) {
2541
2566
  result = false;
2542
2567
  }
2543
2568
  const ret = result;
2544
2569
  return ret;
2545
2570
  };
2546
- imports.wbg.__wbg_primaryKey_ac28363943d108c5 = function() {
2571
+ imports.wbg.__wbg_openCursor_30d58ae27a327629 = function() {
2547
2572
  return handleError(function(arg0) {
2548
- const ret = getObject(arg0).primaryKey;
2573
+ const ret = getObject(arg0).openCursor();
2549
2574
  return addHeapObject(ret);
2550
2575
  }, arguments);
2551
2576
  };
2552
- imports.wbg.__wbg_continue_f1c3e0815924de62 = function() {
2553
- return handleError(function(arg0) {
2554
- getObject(arg0).continue();
2577
+ imports.wbg.__wbg_put_22792e17580ca18b = function() {
2578
+ return handleError(function(arg0, arg1, arg2) {
2579
+ const ret = getObject(arg0).put(getObject(arg1), getObject(arg2));
2580
+ return addHeapObject(ret);
2555
2581
  }, arguments);
2556
2582
  };
2557
- imports.wbg.__wbg_length_9ae5daf9a690cba9 = function(arg0) {
2558
- const ret = getObject(arg0).length;
2559
- return ret;
2560
- };
2561
- imports.wbg.__wbg_contains_c65b44400b549286 = function(arg0, arg1, arg2) {
2562
- const ret = getObject(arg0).contains(getStringFromWasm0(arg1, arg2));
2563
- return ret;
2564
- };
2565
- imports.wbg.__wbg_get_910bbb94abdcf488 = function(arg0, arg1, arg2) {
2566
- const ret = getObject(arg1)[arg2 >>> 0];
2567
- var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2568
- var len1 = WASM_VECTOR_LEN;
2569
- getInt32Memory0()[arg0 / 4 + 1] = len1;
2570
- getInt32Memory0()[arg0 / 4 + 0] = ptr1;
2571
- };
2572
- imports.wbg.__wbg_instanceof_IdbCursorWithValue_abeb44d13d947bc2 = function(arg0) {
2573
- let result;
2574
- try {
2575
- result = getObject(arg0) instanceof IDBCursorWithValue;
2576
- } catch (_) {
2577
- result = false;
2578
- }
2579
- const ret = result;
2580
- return ret;
2581
- };
2582
- imports.wbg.__wbg_value_86d3334f5075b232 = function() {
2583
- return handleError(function(arg0) {
2584
- const ret = getObject(arg0).value;
2583
+ imports.wbg.__wbg_openCursor_611b1e488c393dd8 = function() {
2584
+ return handleError(function(arg0, arg1) {
2585
+ const ret = getObject(arg0).openCursor(getObject(arg1));
2585
2586
  return addHeapObject(ret);
2586
2587
  }, arguments);
2587
2588
  };
2588
- imports.wbg.__wbg_open_f0d7259fd7e689ce = function() {
2589
- return handleError(function(arg0, arg1, arg2, arg3) {
2590
- const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2), arg3 >>> 0);
2589
+ imports.wbg.__wbg_get_5361b64cac0d0826 = function() {
2590
+ return handleError(function(arg0, arg1) {
2591
+ const ret = getObject(arg0).get(getObject(arg1));
2591
2592
  return addHeapObject(ret);
2592
2593
  }, arguments);
2593
2594
  };
2594
- imports.wbg.__wbg_bound_25385469508e98c7 = function() {
2595
- return handleError(function(arg0, arg1, arg2, arg3) {
2596
- const ret = IDBKeyRange.bound(getObject(arg0), getObject(arg1), arg2 !== 0, arg3 !== 0);
2595
+ imports.wbg.__wbg_createIndex_b8da1f5571f644be = function() {
2596
+ return handleError(function(arg0, arg1, arg2, arg3, arg4, arg5) {
2597
+ const ret = getObject(arg0).createIndex(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4), getObject(arg5));
2597
2598
  return addHeapObject(ret);
2598
2599
  }, arguments);
2599
2600
  };
2600
- imports.wbg.__wbg_lowerBound_cd1c8a3b3fdf1582 = function() {
2601
- return handleError(function(arg0) {
2602
- const ret = IDBKeyRange.lowerBound(getObject(arg0));
2601
+ imports.wbg.__wbg_index_383b6812c1508030 = function() {
2602
+ return handleError(function(arg0, arg1, arg2) {
2603
+ const ret = getObject(arg0).index(getStringFromWasm0(arg1, arg2));
2603
2604
  return addHeapObject(ret);
2604
2605
  }, arguments);
2605
2606
  };
2606
- imports.wbg.__wbg_lowerBound_e77f6e14cb69151e = function() {
2607
+ imports.wbg.__wbg_delete_f60bba7d0ae59a4f = function() {
2607
2608
  return handleError(function(arg0, arg1) {
2608
- const ret = IDBKeyRange.lowerBound(getObject(arg0), arg1 !== 0);
2609
+ const ret = getObject(arg0).delete(getObject(arg1));
2609
2610
  return addHeapObject(ret);
2610
2611
  }, arguments);
2611
2612
  };
2612
- imports.wbg.__wbg_only_cacf767244bdc280 = function() {
2613
- return handleError(function(arg0) {
2614
- const ret = IDBKeyRange.only(getObject(arg0));
2615
- return addHeapObject(ret);
2616
- }, arguments);
2613
+ imports.wbg.__wbg_target_2fc177e386c8b7b0 = function(arg0) {
2614
+ const ret = getObject(arg0).target;
2615
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
2617
2616
  };
2618
- imports.wbg.__wbg_upperBound_1e3077b2c05bdd71 = function() {
2617
+ imports.wbg.__wbg_setonerror_8479b33e7568a904 = function(arg0, arg1) {
2618
+ getObject(arg0).onerror = getObject(arg1);
2619
+ };
2620
+ imports.wbg.__wbg_setonsuccess_632ce0a1460455c2 = function(arg0, arg1) {
2621
+ getObject(arg0).onsuccess = getObject(arg1);
2622
+ };
2623
+ imports.wbg.__wbg_error_685b20024dc2d6ca = function() {
2619
2624
  return handleError(function(arg0) {
2620
- const ret = IDBKeyRange.upperBound(getObject(arg0));
2621
- return addHeapObject(ret);
2625
+ const ret = getObject(arg0).error;
2626
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
2622
2627
  }, arguments);
2623
2628
  };
2624
- imports.wbg.__wbg_upperBound_4c692da072d1a11e = function() {
2625
- return handleError(function(arg0, arg1) {
2626
- const ret = IDBKeyRange.upperBound(getObject(arg0), arg1 !== 0);
2629
+ imports.wbg.__wbg_result_6cedf5f78600a79c = function() {
2630
+ return handleError(function(arg0) {
2631
+ const ret = getObject(arg0).result;
2627
2632
  return addHeapObject(ret);
2628
2633
  }, arguments);
2629
2634
  };
2630
- imports.wbg.__wbg_instanceof_IdbOpenDbRequest_3f4a166bc0340578 = function(arg0) {
2635
+ imports.wbg.__wbg_instanceof_IdbRequest_93249da04f5370b6 = function(arg0) {
2631
2636
  let result;
2632
2637
  try {
2633
- result = getObject(arg0) instanceof IDBOpenDBRequest;
2638
+ result = getObject(arg0) instanceof IDBRequest;
2634
2639
  } catch (_) {
2635
2640
  result = false;
2636
2641
  }
2637
2642
  const ret = result;
2638
2643
  return ret;
2639
2644
  };
2645
+ imports.wbg.__wbg_objectStore_da468793bd9df17b = function() {
2646
+ return handleError(function(arg0, arg1, arg2) {
2647
+ const ret = getObject(arg0).objectStore(getStringFromWasm0(arg1, arg2));
2648
+ return addHeapObject(ret);
2649
+ }, arguments);
2650
+ };
2640
2651
  imports.wbg.__wbg_setonupgradeneeded_ad7645373c7d5e1b = function(arg0, arg1) {
2641
2652
  getObject(arg0).onupgradeneeded = getObject(arg1);
2642
2653
  };
2643
- imports.wbg.__wbg_instanceof_IdbRequest_93249da04f5370b6 = function(arg0) {
2654
+ imports.wbg.__wbg_instanceof_IdbOpenDbRequest_3f4a166bc0340578 = function(arg0) {
2644
2655
  let result;
2645
2656
  try {
2646
- result = getObject(arg0) instanceof IDBRequest;
2657
+ result = getObject(arg0) instanceof IDBOpenDBRequest;
2647
2658
  } catch (_) {
2648
2659
  result = false;
2649
2660
  }
2650
2661
  const ret = result;
2651
2662
  return ret;
2652
2663
  };
2653
- imports.wbg.__wbg_result_6cedf5f78600a79c = function() {
2654
- return handleError(function(arg0) {
2655
- const ret = getObject(arg0).result;
2656
- return addHeapObject(ret);
2657
- }, arguments);
2658
- };
2659
- imports.wbg.__wbg_error_685b20024dc2d6ca = function() {
2660
- return handleError(function(arg0) {
2661
- const ret = getObject(arg0).error;
2662
- return isLikeNone(ret) ? 0 : addHeapObject(ret);
2663
- }, arguments);
2664
- };
2665
- imports.wbg.__wbg_setonsuccess_632ce0a1460455c2 = function(arg0, arg1) {
2666
- getObject(arg0).onsuccess = getObject(arg1);
2667
- };
2668
- imports.wbg.__wbg_setonerror_8479b33e7568a904 = function(arg0, arg1) {
2669
- getObject(arg0).onerror = getObject(arg1);
2670
- };
2671
2664
  imports.wbg.__wbindgen_jsval_loose_eq = function(arg0, arg1) {
2672
2665
  const ret = getObject(arg0) == getObject(arg1);
2673
2666
  return ret;
@@ -2676,13 +2669,6 @@ function __wbg_get_imports() {
2676
2669
  const ret = +getObject(arg0);
2677
2670
  return ret;
2678
2671
  };
2679
- imports.wbg.__wbg_String_389b54bd9d25375f = function(arg0, arg1) {
2680
- const ret = String(getObject(arg1));
2681
- const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2682
- const len1 = WASM_VECTOR_LEN;
2683
- getInt32Memory0()[arg0 / 4 + 1] = len1;
2684
- getInt32Memory0()[arg0 / 4 + 0] = ptr1;
2685
- };
2686
2672
  imports.wbg.__wbg_getwithrefkey_4a92a5eca60879b9 = function(arg0, arg1) {
2687
2673
  const ret = getObject(arg0)[getObject(arg1)];
2688
2674
  return addHeapObject(ret);
@@ -2690,22 +2676,15 @@ function __wbg_get_imports() {
2690
2676
  imports.wbg.__wbg_set_9182712abebf82ef = function(arg0, arg1, arg2) {
2691
2677
  getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
2692
2678
  };
2693
- imports.wbg.__wbg_log_28eee4e6432efd24 = function(arg0, arg1) {
2694
- console.log(getStringFromWasm0(arg0, arg1));
2695
- };
2696
- imports.wbg.__wbg_String_55b8bdc4bc243677 = function(arg0, arg1) {
2679
+ imports.wbg.__wbg_String_389b54bd9d25375f = function(arg0, arg1) {
2697
2680
  const ret = String(getObject(arg1));
2698
2681
  const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2699
2682
  const len1 = WASM_VECTOR_LEN;
2700
2683
  getInt32Memory0()[arg0 / 4 + 1] = len1;
2701
2684
  getInt32Memory0()[arg0 / 4 + 0] = ptr1;
2702
2685
  };
2703
- imports.wbg.__wbg_getElementById_8458f2a6c28467dc = function(arg0, arg1, arg2) {
2704
- const ret = getObject(arg0).getElementById(getStringFromWasm0(arg1, arg2));
2705
- return addHeapObject(ret);
2706
- };
2707
- imports.wbg.__wbg_settextcontent_fc3ff485b96fcb1d = function(arg0, arg1, arg2) {
2708
- getObject(arg0).textContent = getStringFromWasm0(arg1, arg2);
2686
+ imports.wbg.__wbg_log_28eee4e6432efd24 = function(arg0, arg1) {
2687
+ console.log(getStringFromWasm0(arg0, arg1));
2709
2688
  };
2710
2689
  imports.wbg.__wbg_wbgtestinvoke_8c20f4132af2bded = function() {
2711
2690
  return handleError(function(arg0, arg1) {
@@ -2715,7 +2694,7 @@ function __wbg_get_imports() {
2715
2694
  const a = state0.a;
2716
2695
  state0.a = 0;
2717
2696
  try {
2718
- return __wbg_adapter_304(a, state0.b);
2697
+ return __wbg_adapter_287(a, state0.b);
2719
2698
  } finally {
2720
2699
  state0.a = a;
2721
2700
  }
@@ -2726,13 +2705,20 @@ function __wbg_get_imports() {
2726
2705
  }
2727
2706
  }, arguments);
2728
2707
  };
2729
- imports.wbg.__wbg_wbgtestoutputwriteln_4db3bd64914ec955 = function(arg0) {
2730
- __wbg_test_output_writeln(takeObject(arg0));
2731
- };
2732
- imports.wbg.__wbg_stack_436273c21658169b = function(arg0) {
2733
- const ret = getObject(arg0).stack;
2708
+ imports.wbg.__wbg_getElementById_8458f2a6c28467dc = function(arg0, arg1, arg2) {
2709
+ const ret = getObject(arg0).getElementById(getStringFromWasm0(arg1, arg2));
2734
2710
  return addHeapObject(ret);
2735
2711
  };
2712
+ imports.wbg.__wbg_settextcontent_fc3ff485b96fcb1d = function(arg0, arg1, arg2) {
2713
+ getObject(arg0).textContent = getStringFromWasm0(arg1, arg2);
2714
+ };
2715
+ imports.wbg.__wbg_String_55b8bdc4bc243677 = function(arg0, arg1) {
2716
+ const ret = String(getObject(arg1));
2717
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2718
+ const len1 = WASM_VECTOR_LEN;
2719
+ getInt32Memory0()[arg0 / 4 + 1] = len1;
2720
+ getInt32Memory0()[arg0 / 4 + 0] = ptr1;
2721
+ };
2736
2722
  imports.wbg.__wbg_self_55106357ec10ecd4 = function(arg0) {
2737
2723
  const ret = getObject(arg0).self;
2738
2724
  return isLikeNone(ret) ? 0 : addHeapObject(ret);
@@ -2748,8 +2734,12 @@ function __wbg_get_imports() {
2748
2734
  getInt32Memory0()[arg0 / 4 + 1] = len1;
2749
2735
  getInt32Memory0()[arg0 / 4 + 0] = ptr1;
2750
2736
  };
2751
- imports.wbg.__wbg_textcontent_67e4e811cbdf00fc = function(arg0, arg1) {
2752
- const ret = getObject(arg1).textContent;
2737
+ imports.wbg.__wbg_static_accessor_document_d4b6ae7f5578480f = function() {
2738
+ const ret = document;
2739
+ return addHeapObject(ret);
2740
+ };
2741
+ imports.wbg.__wbg_stack_17c77e9f5bfe6714 = function(arg0, arg1) {
2742
+ const ret = getObject(arg1).stack;
2753
2743
  const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2754
2744
  const len1 = WASM_VECTOR_LEN;
2755
2745
  getInt32Memory0()[arg0 / 4 + 1] = len1;
@@ -2759,17 +2749,20 @@ function __wbg_get_imports() {
2759
2749
  const ret = getObject(arg0).stack;
2760
2750
  return addHeapObject(ret);
2761
2751
  };
2762
- imports.wbg.__wbg_static_accessor_document_d4b6ae7f5578480f = function() {
2763
- const ret = document;
2764
- return addHeapObject(ret);
2765
- };
2766
- imports.wbg.__wbg_stack_17c77e9f5bfe6714 = function(arg0, arg1) {
2767
- const ret = getObject(arg1).stack;
2752
+ imports.wbg.__wbg_textcontent_67e4e811cbdf00fc = function(arg0, arg1) {
2753
+ const ret = getObject(arg1).textContent;
2768
2754
  const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2769
2755
  const len1 = WASM_VECTOR_LEN;
2770
2756
  getInt32Memory0()[arg0 / 4 + 1] = len1;
2771
2757
  getInt32Memory0()[arg0 / 4 + 0] = ptr1;
2772
2758
  };
2759
+ imports.wbg.__wbg_stack_436273c21658169b = function(arg0) {
2760
+ const ret = getObject(arg0).stack;
2761
+ return addHeapObject(ret);
2762
+ };
2763
+ imports.wbg.__wbg_wbgtestoutputwriteln_4db3bd64914ec955 = function(arg0) {
2764
+ __wbg_test_output_writeln(takeObject(arg0));
2765
+ };
2773
2766
  imports.wbg.__wbg_new_abda76e883ba8a5f = function() {
2774
2767
  const ret = new Error();
2775
2768
  return addHeapObject(ret);
@@ -2792,94 +2785,113 @@ function __wbg_get_imports() {
2792
2785
  wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
2793
2786
  }
2794
2787
  };
2795
- imports.wbg.__wbg_queueMicrotask_3cbae2ec6b6cd3d6 = function(arg0) {
2796
- const ret = getObject(arg0).queueMicrotask;
2797
- return addHeapObject(ret);
2798
- };
2799
2788
  imports.wbg.__wbg_queueMicrotask_481971b0d87f3dd4 = function(arg0) {
2800
2789
  queueMicrotask(getObject(arg0));
2801
2790
  };
2802
- imports.wbg.__wbg_get_bd8e338fbd5f5cc8 = function(arg0, arg1) {
2803
- const ret = getObject(arg0)[arg1 >>> 0];
2791
+ imports.wbg.__wbg_queueMicrotask_3cbae2ec6b6cd3d6 = function(arg0) {
2792
+ const ret = getObject(arg0).queueMicrotask;
2804
2793
  return addHeapObject(ret);
2805
2794
  };
2806
- imports.wbg.__wbg_length_cd7af8117672b8b8 = function(arg0) {
2807
- const ret = getObject(arg0).length;
2808
- return ret;
2795
+ imports.wbg.__wbg_new_d9bc3a0147634640 = function() {
2796
+ const ret = /* @__PURE__ */ new Map();
2797
+ return addHeapObject(ret);
2809
2798
  };
2810
2799
  imports.wbg.__wbg_new_16b304a2cfa7ff4a = function() {
2811
2800
  const ret = new Array();
2812
2801
  return addHeapObject(ret);
2813
2802
  };
2803
+ imports.wbg.__wbg_new_72fb9a18b5ae2624 = function() {
2804
+ const ret = new Object();
2805
+ return addHeapObject(ret);
2806
+ };
2814
2807
  imports.wbg.__wbg_newnoargs_e258087cd0daa0ea = function(arg0, arg1) {
2815
2808
  const ret = new Function(getStringFromWasm0(arg0, arg1));
2816
2809
  return addHeapObject(ret);
2817
2810
  };
2818
- imports.wbg.__wbg_new_d9bc3a0147634640 = function() {
2819
- const ret = /* @__PURE__ */ new Map();
2811
+ imports.wbg.__wbg_new_63b92bc8671ed464 = function(arg0) {
2812
+ const ret = new Uint8Array(getObject(arg0));
2820
2813
  return addHeapObject(ret);
2821
2814
  };
2822
- imports.wbg.__wbg_next_40fc327bfc8770e6 = function(arg0) {
2823
- const ret = getObject(arg0).next;
2815
+ imports.wbg.__wbg_buffer_12d079cc21e14bdb = function(arg0) {
2816
+ const ret = getObject(arg0).buffer;
2824
2817
  return addHeapObject(ret);
2825
2818
  };
2826
- imports.wbg.__wbg_next_196c84450b364254 = function() {
2827
- return handleError(function(arg0) {
2828
- const ret = getObject(arg0).next();
2829
- return addHeapObject(ret);
2830
- }, arguments);
2831
- };
2832
- imports.wbg.__wbg_done_298b57d23c0fc80c = function(arg0) {
2833
- const ret = getObject(arg0).done;
2834
- return ret;
2819
+ imports.wbg.__wbg_newwithbyteoffsetandlength_aa4a17c33a06e5cb = function(arg0, arg1, arg2) {
2820
+ const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
2821
+ return addHeapObject(ret);
2835
2822
  };
2836
- imports.wbg.__wbg_value_d93c65011f51a456 = function(arg0) {
2837
- const ret = getObject(arg0).value;
2823
+ imports.wbg.__wbg_newwithlength_e9b4878cebadb3d3 = function(arg0) {
2824
+ const ret = new Uint8Array(arg0 >>> 0);
2838
2825
  return addHeapObject(ret);
2839
2826
  };
2840
- imports.wbg.__wbg_iterator_2cee6dadfd956dfa = function() {
2841
- const ret = Symbol.iterator;
2827
+ imports.wbg.__wbg_set_a47bac70306a19a7 = function(arg0, arg1, arg2) {
2828
+ getObject(arg0).set(getObject(arg1), arg2 >>> 0);
2829
+ };
2830
+ imports.wbg.__wbg_length_c20a40f15020d68a = function(arg0) {
2831
+ const ret = getObject(arg0).length;
2832
+ return ret;
2833
+ };
2834
+ imports.wbg.__wbg_subarray_a1f73cd4b5b42fe1 = function(arg0, arg1, arg2) {
2835
+ const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
2842
2836
  return addHeapObject(ret);
2843
2837
  };
2844
- imports.wbg.__wbg_get_e3c254076557e348 = function() {
2845
- return handleError(function(arg0, arg1) {
2846
- const ret = Reflect.get(getObject(arg0), getObject(arg1));
2847
- return addHeapObject(ret);
2848
- }, arguments);
2838
+ imports.wbg.__wbg_done_298b57d23c0fc80c = function(arg0) {
2839
+ const ret = getObject(arg0).done;
2840
+ return ret;
2849
2841
  };
2850
- imports.wbg.__wbg_call_27c0f87801dedf93 = function() {
2851
- return handleError(function(arg0, arg1) {
2852
- const ret = getObject(arg0).call(getObject(arg1));
2853
- return addHeapObject(ret);
2854
- }, arguments);
2842
+ imports.wbg.__wbg_value_d93c65011f51a456 = function(arg0) {
2843
+ const ret = getObject(arg0).value;
2844
+ return addHeapObject(ret);
2855
2845
  };
2856
- imports.wbg.__wbg_new_72fb9a18b5ae2624 = function() {
2857
- const ret = new Object();
2846
+ imports.wbg.__wbg_instanceof_Object_71ca3c0a59266746 = function(arg0) {
2847
+ let result;
2848
+ try {
2849
+ result = getObject(arg0) instanceof Object;
2850
+ } catch (_) {
2851
+ result = false;
2852
+ }
2853
+ const ret = result;
2854
+ return ret;
2855
+ };
2856
+ imports.wbg.__wbg_instanceof_Uint8Array_2b3bbecd033d19f6 = function(arg0) {
2857
+ let result;
2858
+ try {
2859
+ result = getObject(arg0) instanceof Uint8Array;
2860
+ } catch (_) {
2861
+ result = false;
2862
+ }
2863
+ const ret = result;
2864
+ return ret;
2865
+ };
2866
+ imports.wbg.__wbg_instanceof_ArrayBuffer_836825be07d4c9d2 = function(arg0) {
2867
+ let result;
2868
+ try {
2869
+ result = getObject(arg0) instanceof ArrayBuffer;
2870
+ } catch (_) {
2871
+ result = false;
2872
+ }
2873
+ const ret = result;
2874
+ return ret;
2875
+ };
2876
+ imports.wbg.__wbg_set_8417257aaedc936b = function(arg0, arg1, arg2) {
2877
+ const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
2858
2878
  return addHeapObject(ret);
2859
2879
  };
2860
- imports.wbg.__wbg_self_ce0dbfc45cf2f5be = function() {
2861
- return handleError(function() {
2862
- const ret = self.self;
2863
- return addHeapObject(ret);
2864
- }, arguments);
2880
+ imports.wbg.__wbg_new0_7d84e5b2cd9fdc73 = function() {
2881
+ const ret = /* @__PURE__ */ new Date();
2882
+ return addHeapObject(ret);
2865
2883
  };
2866
- imports.wbg.__wbg_window_c6fb939a7f436783 = function() {
2867
- return handleError(function() {
2868
- const ret = window.window;
2869
- return addHeapObject(ret);
2870
- }, arguments);
2884
+ imports.wbg.__wbg_getTime_2bc4375165f02d15 = function(arg0) {
2885
+ const ret = getObject(arg0).getTime();
2886
+ return ret;
2871
2887
  };
2872
- imports.wbg.__wbg_globalThis_d1e6af4856ba331b = function() {
2873
- return handleError(function() {
2874
- const ret = globalThis.globalThis;
2875
- return addHeapObject(ret);
2876
- }, arguments);
2888
+ imports.wbg.__wbg_get_bd8e338fbd5f5cc8 = function(arg0, arg1) {
2889
+ const ret = getObject(arg0)[arg1 >>> 0];
2890
+ return addHeapObject(ret);
2877
2891
  };
2878
- imports.wbg.__wbg_global_207b558942527489 = function() {
2879
- return handleError(function() {
2880
- const ret = global.global;
2881
- return addHeapObject(ret);
2882
- }, arguments);
2892
+ imports.wbg.__wbg_of_4a2b313a453ec059 = function(arg0) {
2893
+ const ret = Array.of(getObject(arg0));
2894
+ return addHeapObject(ret);
2883
2895
  };
2884
2896
  imports.wbg.__wbg_set_d4638f722068f043 = function(arg0, arg1, arg2) {
2885
2897
  getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
@@ -2888,6 +2900,14 @@ function __wbg_get_imports() {
2888
2900
  const ret = Array.from(getObject(arg0));
2889
2901
  return addHeapObject(ret);
2890
2902
  };
2903
+ imports.wbg.__wbg_length_cd7af8117672b8b8 = function(arg0) {
2904
+ const ret = getObject(arg0).length;
2905
+ return ret;
2906
+ };
2907
+ imports.wbg.__wbg_push_a5b05aedc7234f9f = function(arg0, arg1) {
2908
+ const ret = getObject(arg0).push(getObject(arg1));
2909
+ return ret;
2910
+ };
2891
2911
  imports.wbg.__wbg_forEach_2be8de7347d63332 = function(arg0, arg1, arg2) {
2892
2912
  try {
2893
2913
  var state0 = { a: arg1, b: arg2 };
@@ -2895,7 +2915,7 @@ function __wbg_get_imports() {
2895
2915
  const a = state0.a;
2896
2916
  state0.a = 0;
2897
2917
  try {
2898
- return __wbg_adapter_347(a, state0.b, arg02, arg12, arg22);
2918
+ return __wbg_adapter_378(a, state0.b, arg02, arg12, arg22);
2899
2919
  } finally {
2900
2920
  state0.a = a;
2901
2921
  }
@@ -2909,70 +2929,26 @@ function __wbg_get_imports() {
2909
2929
  const ret = Array.isArray(getObject(arg0));
2910
2930
  return ret;
2911
2931
  };
2912
- imports.wbg.__wbg_of_4a2b313a453ec059 = function(arg0) {
2913
- const ret = Array.of(getObject(arg0));
2914
- return addHeapObject(ret);
2915
- };
2916
- imports.wbg.__wbg_push_a5b05aedc7234f9f = function(arg0, arg1) {
2917
- const ret = getObject(arg0).push(getObject(arg1));
2918
- return ret;
2919
- };
2920
- imports.wbg.__wbg_instanceof_ArrayBuffer_836825be07d4c9d2 = function(arg0) {
2921
- let result;
2922
- try {
2923
- result = getObject(arg0) instanceof ArrayBuffer;
2924
- } catch (_) {
2925
- result = false;
2926
- }
2927
- const ret = result;
2928
- return ret;
2929
- };
2930
- imports.wbg.__wbg_message_5bf28016c2b49cfb = function(arg0) {
2931
- const ret = getObject(arg0).message;
2932
- return addHeapObject(ret);
2933
- };
2934
2932
  imports.wbg.__wbg_name_e7429f0dda6079e2 = function(arg0) {
2935
2933
  const ret = getObject(arg0).name;
2936
2934
  return addHeapObject(ret);
2937
2935
  };
2938
- imports.wbg.__wbg_call_b3ca7c6051f9bec1 = function() {
2939
- return handleError(function(arg0, arg1, arg2) {
2940
- const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
2941
- return addHeapObject(ret);
2942
- }, arguments);
2943
- };
2944
- imports.wbg.__wbg_call_938992c832f74314 = function() {
2945
- return handleError(function(arg0, arg1, arg2, arg3, arg4) {
2946
- const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3), getObject(arg4));
2947
- return addHeapObject(ret);
2948
- }, arguments);
2949
- };
2950
- imports.wbg.__wbg_set_8417257aaedc936b = function(arg0, arg1, arg2) {
2951
- const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
2936
+ imports.wbg.__wbg_message_5bf28016c2b49cfb = function(arg0) {
2937
+ const ret = getObject(arg0).message;
2952
2938
  return addHeapObject(ret);
2953
2939
  };
2954
2940
  imports.wbg.__wbg_isSafeInteger_f7b04ef02296c4d2 = function(arg0) {
2955
2941
  const ret = Number.isSafeInteger(getObject(arg0));
2956
2942
  return ret;
2957
2943
  };
2958
- imports.wbg.__wbg_getTime_2bc4375165f02d15 = function(arg0) {
2959
- const ret = getObject(arg0).getTime();
2944
+ imports.wbg.__wbg_is_010fdc0f4ab96916 = function(arg0, arg1) {
2945
+ const ret = Object.is(getObject(arg0), getObject(arg1));
2960
2946
  return ret;
2961
2947
  };
2962
- imports.wbg.__wbg_new0_7d84e5b2cd9fdc73 = function() {
2963
- const ret = /* @__PURE__ */ new Date();
2948
+ imports.wbg.__wbg_keys_91e412b4b222659f = function(arg0) {
2949
+ const ret = Object.keys(getObject(arg0));
2964
2950
  return addHeapObject(ret);
2965
2951
  };
2966
- imports.wbg.__wbg_instanceof_Object_71ca3c0a59266746 = function(arg0) {
2967
- let result;
2968
- try {
2969
- result = getObject(arg0) instanceof Object;
2970
- } catch (_) {
2971
- result = false;
2972
- }
2973
- const ret = result;
2974
- return ret;
2975
- };
2976
2952
  imports.wbg.__wbg_assign_496d2d14fecafbcf = function(arg0, arg1) {
2977
2953
  const ret = Object.assign(getObject(arg0), getObject(arg1));
2978
2954
  return addHeapObject(ret);
@@ -2981,14 +2957,40 @@ function __wbg_get_imports() {
2981
2957
  const ret = Object.entries(getObject(arg0));
2982
2958
  return addHeapObject(ret);
2983
2959
  };
2984
- imports.wbg.__wbg_is_010fdc0f4ab96916 = function(arg0, arg1) {
2985
- const ret = Object.is(getObject(arg0), getObject(arg1));
2986
- return ret;
2987
- };
2988
- imports.wbg.__wbg_keys_91e412b4b222659f = function(arg0) {
2989
- const ret = Object.keys(getObject(arg0));
2960
+ imports.wbg.__wbg_iterator_2cee6dadfd956dfa = function() {
2961
+ const ret = Symbol.iterator;
2990
2962
  return addHeapObject(ret);
2991
2963
  };
2964
+ imports.wbg.__wbg_self_ce0dbfc45cf2f5be = function() {
2965
+ return handleError(function() {
2966
+ const ret = self.self;
2967
+ return addHeapObject(ret);
2968
+ }, arguments);
2969
+ };
2970
+ imports.wbg.__wbg_window_c6fb939a7f436783 = function() {
2971
+ return handleError(function() {
2972
+ const ret = window.window;
2973
+ return addHeapObject(ret);
2974
+ }, arguments);
2975
+ };
2976
+ imports.wbg.__wbg_globalThis_d1e6af4856ba331b = function() {
2977
+ return handleError(function() {
2978
+ const ret = globalThis.globalThis;
2979
+ return addHeapObject(ret);
2980
+ }, arguments);
2981
+ };
2982
+ imports.wbg.__wbg_global_207b558942527489 = function() {
2983
+ return handleError(function() {
2984
+ const ret = global.global;
2985
+ return addHeapObject(ret);
2986
+ }, arguments);
2987
+ };
2988
+ imports.wbg.__wbg_call_27c0f87801dedf93 = function() {
2989
+ return handleError(function(arg0, arg1) {
2990
+ const ret = getObject(arg0).call(getObject(arg1));
2991
+ return addHeapObject(ret);
2992
+ }, arguments);
2993
+ };
2992
2994
  imports.wbg.__wbg_new_81740750da40724f = function(arg0, arg1) {
2993
2995
  try {
2994
2996
  var state0 = { a: arg0, b: arg1 };
@@ -2996,7 +2998,7 @@ function __wbg_get_imports() {
2996
2998
  const a = state0.a;
2997
2999
  state0.a = 0;
2998
3000
  try {
2999
- return __wbg_adapter_404(a, state0.b, arg02, arg12);
3001
+ return __wbg_adapter_395(a, state0.b, arg02, arg12);
3000
3002
  } finally {
3001
3003
  state0.a = a;
3002
3004
  }
@@ -3007,10 +3009,6 @@ function __wbg_get_imports() {
3007
3009
  state0.a = state0.b = 0;
3008
3010
  }
3009
3011
  };
3010
- imports.wbg.__wbg_resolve_b0083a7967828ec8 = function(arg0) {
3011
- const ret = Promise.resolve(getObject(arg0));
3012
- return addHeapObject(ret);
3013
- };
3014
3012
  imports.wbg.__wbg_then_0c86a60e8fcfe9f6 = function(arg0, arg1) {
3015
3013
  const ret = getObject(arg0).then(getObject(arg1));
3016
3014
  return addHeapObject(ret);
@@ -3019,46 +3017,47 @@ function __wbg_get_imports() {
3019
3017
  const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
3020
3018
  return addHeapObject(ret);
3021
3019
  };
3022
- imports.wbg.__wbg_buffer_12d079cc21e14bdb = function(arg0) {
3023
- const ret = getObject(arg0).buffer;
3024
- return addHeapObject(ret);
3025
- };
3026
- imports.wbg.__wbg_newwithbyteoffsetandlength_aa4a17c33a06e5cb = function(arg0, arg1, arg2) {
3027
- const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
3020
+ imports.wbg.__wbg_resolve_b0083a7967828ec8 = function(arg0) {
3021
+ const ret = Promise.resolve(getObject(arg0));
3028
3022
  return addHeapObject(ret);
3029
3023
  };
3030
- imports.wbg.__wbg_new_63b92bc8671ed464 = function(arg0) {
3031
- const ret = new Uint8Array(getObject(arg0));
3032
- return addHeapObject(ret);
3024
+ imports.wbg.__wbg_call_b3ca7c6051f9bec1 = function() {
3025
+ return handleError(function(arg0, arg1, arg2) {
3026
+ const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
3027
+ return addHeapObject(ret);
3028
+ }, arguments);
3033
3029
  };
3034
- imports.wbg.__wbg_set_a47bac70306a19a7 = function(arg0, arg1, arg2) {
3035
- getObject(arg0).set(getObject(arg1), arg2 >>> 0);
3030
+ imports.wbg.__wbg_call_938992c832f74314 = function() {
3031
+ return handleError(function(arg0, arg1, arg2, arg3, arg4) {
3032
+ const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3), getObject(arg4));
3033
+ return addHeapObject(ret);
3034
+ }, arguments);
3036
3035
  };
3037
- imports.wbg.__wbg_length_c20a40f15020d68a = function(arg0) {
3038
- const ret = getObject(arg0).length;
3039
- return ret;
3036
+ imports.wbg.__wbg_next_40fc327bfc8770e6 = function(arg0) {
3037
+ const ret = getObject(arg0).next;
3038
+ return addHeapObject(ret);
3040
3039
  };
3041
- imports.wbg.__wbg_instanceof_Uint8Array_2b3bbecd033d19f6 = function(arg0) {
3042
- let result;
3043
- try {
3044
- result = getObject(arg0) instanceof Uint8Array;
3045
- } catch (_) {
3046
- result = false;
3047
- }
3048
- const ret = result;
3049
- return ret;
3040
+ imports.wbg.__wbg_next_196c84450b364254 = function() {
3041
+ return handleError(function(arg0) {
3042
+ const ret = getObject(arg0).next();
3043
+ return addHeapObject(ret);
3044
+ }, arguments);
3050
3045
  };
3051
- imports.wbg.__wbg_newwithlength_e9b4878cebadb3d3 = function(arg0) {
3052
- const ret = new Uint8Array(arg0 >>> 0);
3053
- return addHeapObject(ret);
3046
+ imports.wbg.__wbg_get_e3c254076557e348 = function() {
3047
+ return handleError(function(arg0, arg1) {
3048
+ const ret = Reflect.get(getObject(arg0), getObject(arg1));
3049
+ return addHeapObject(ret);
3050
+ }, arguments);
3054
3051
  };
3055
- imports.wbg.__wbg_subarray_a1f73cd4b5b42fe1 = function(arg0, arg1, arg2) {
3056
- const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
3057
- return addHeapObject(ret);
3052
+ imports.wbg.__wbg_parse_66d1801634e099ac = function() {
3053
+ return handleError(function(arg0, arg1) {
3054
+ const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
3055
+ return addHeapObject(ret);
3056
+ }, arguments);
3058
3057
  };
3059
- imports.wbg.__wbg_apply_0a5aa603881e6d79 = function() {
3060
- return handleError(function(arg0, arg1, arg2) {
3061
- const ret = Reflect.apply(getObject(arg0), getObject(arg1), getObject(arg2));
3058
+ imports.wbg.__wbg_stringify_8887fe74e1c50d81 = function() {
3059
+ return handleError(function(arg0) {
3060
+ const ret = JSON.stringify(getObject(arg0));
3062
3061
  return addHeapObject(ret);
3063
3062
  }, arguments);
3064
3063
  };
@@ -3080,15 +3079,9 @@ function __wbg_get_imports() {
3080
3079
  return ret;
3081
3080
  }, arguments);
3082
3081
  };
3083
- imports.wbg.__wbg_parse_66d1801634e099ac = function() {
3084
- return handleError(function(arg0, arg1) {
3085
- const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
3086
- return addHeapObject(ret);
3087
- }, arguments);
3088
- };
3089
- imports.wbg.__wbg_stringify_8887fe74e1c50d81 = function() {
3090
- return handleError(function(arg0) {
3091
- const ret = JSON.stringify(getObject(arg0));
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));
3092
3085
  return addHeapObject(ret);
3093
3086
  }, arguments);
3094
3087
  };
@@ -3098,6 +3091,13 @@ function __wbg_get_imports() {
3098
3091
  getBigInt64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? BigInt(0) : ret;
3099
3092
  getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
3100
3093
  };
3094
+ imports.wbg.__wbindgen_memory = function() {
3095
+ const ret = wasm.memory;
3096
+ return addHeapObject(ret);
3097
+ };
3098
+ imports.wbg.__wbindgen_throw = function(arg0, arg1) {
3099
+ throw new Error(getStringFromWasm0(arg0, arg1));
3100
+ };
3101
3101
  imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
3102
3102
  const ret = debugString(getObject(arg1));
3103
3103
  const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -3105,23 +3105,16 @@ function __wbg_get_imports() {
3105
3105
  getInt32Memory0()[arg0 / 4 + 1] = len1;
3106
3106
  getInt32Memory0()[arg0 / 4 + 0] = ptr1;
3107
3107
  };
3108
- imports.wbg.__wbindgen_throw = function(arg0, arg1) {
3109
- throw new Error(getStringFromWasm0(arg0, arg1));
3110
- };
3111
- imports.wbg.__wbindgen_memory = function() {
3112
- const ret = wasm.memory;
3113
- return addHeapObject(ret);
3114
- };
3115
- imports.wbg.__wbindgen_closure_wrapper504 = function(arg0, arg1, arg2) {
3116
- const ret = makeMutClosure(arg0, arg1, 226, __wbg_adapter_56);
3108
+ imports.wbg.__wbindgen_closure_wrapper515 = function(arg0, arg1, arg2) {
3109
+ const ret = makeMutClosure(arg0, arg1, 181, __wbg_adapter_56);
3117
3110
  return addHeapObject(ret);
3118
3111
  };
3119
- imports.wbg.__wbindgen_closure_wrapper506 = function(arg0, arg1, arg2) {
3120
- const ret = makeClosure(arg0, arg1, 226, __wbg_adapter_59);
3112
+ imports.wbg.__wbindgen_closure_wrapper517 = function(arg0, arg1, arg2) {
3113
+ const ret = makeClosure(arg0, arg1, 181, __wbg_adapter_59);
3121
3114
  return addHeapObject(ret);
3122
3115
  };
3123
- imports.wbg.__wbindgen_closure_wrapper1689 = function(arg0, arg1, arg2) {
3124
- const ret = makeMutClosure(arg0, arg1, 466, __wbg_adapter_62);
3116
+ imports.wbg.__wbindgen_closure_wrapper1702 = function(arg0, arg1, arg2) {
3117
+ const ret = makeMutClosure(arg0, arg1, 465, __wbg_adapter_62);
3125
3118
  return addHeapObject(ret);
3126
3119
  };
3127
3120
  return imports;