@trust0/ridb-mongodb 0.0.8 → 0.0.11-rc.0

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