@trust0/ridb-mongodb 0.0.8 → 0.0.10

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