@trust0/ridb-core 1.7.35 → 1.7.38

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -43,6 +43,13 @@ function takeObject(idx) {
43
43
  dropObject(idx);
44
44
  return ret;
45
45
  }
46
+ function addHeapObject(obj) {
47
+ if (heap_next === heap.length) heap.push(heap.length + 1);
48
+ const idx = heap_next;
49
+ heap_next = heap[idx];
50
+ heap[idx] = obj;
51
+ return idx;
52
+ }
46
53
  var cachedTextDecoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-8", { ignoreBOM: true, fatal: true }) : { decode: () => {
47
54
  throw Error("TextDecoder not available");
48
55
  } };
@@ -60,13 +67,6 @@ function getStringFromWasm0(ptr, len) {
60
67
  ptr = ptr >>> 0;
61
68
  return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
62
69
  }
63
- function addHeapObject(obj) {
64
- if (heap_next === heap.length) heap.push(heap.length + 1);
65
- const idx = heap_next;
66
- heap_next = heap[idx];
67
- heap[idx] = obj;
68
- return idx;
69
- }
70
70
  var WASM_VECTOR_LEN = 0;
71
71
  var cachedTextEncoder = typeof TextEncoder !== "undefined" ? new TextEncoder("utf-8") : { encode: () => {
72
72
  throw Error("TextEncoder not available");
@@ -218,7 +218,7 @@ function makeMutClosure(arg0, arg1, dtor, f) {
218
218
  return real;
219
219
  }
220
220
  function __wbg_adapter_56(arg0, arg1, arg2) {
221
- wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hcf4fe6fd0b7ccc8d(arg0, arg1, addHeapObject(arg2));
221
+ wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__ha7bc4bff3dafa2ad(arg0, arg1, addHeapObject(arg2));
222
222
  }
223
223
  function makeClosure(arg0, arg1, dtor, f) {
224
224
  const state = { a: arg0, b: arg1, cnt: 1, dtor };
@@ -241,7 +241,7 @@ function makeClosure(arg0, arg1, dtor, f) {
241
241
  function __wbg_adapter_59(arg0, arg1, arg2, arg3, arg4) {
242
242
  try {
243
243
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
244
- 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));
244
+ 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));
245
245
  var r0 = getInt32Memory0()[retptr / 4 + 0];
246
246
  var r1 = getInt32Memory0()[retptr / 4 + 1];
247
247
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -254,7 +254,13 @@ function __wbg_adapter_59(arg0, arg1, arg2, arg3, arg4) {
254
254
  }
255
255
  }
256
256
  function __wbg_adapter_62(arg0, arg1, arg2) {
257
- wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hb6eb1f8e3b5e56e9(arg0, arg1, addHeapObject(arg2));
257
+ wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hd4647cb021495324(arg0, arg1, addHeapObject(arg2));
258
+ }
259
+ var stack_pointer = 128;
260
+ function addBorrowedObject(obj) {
261
+ if (stack_pointer == 1) throw new Error("out of js stack");
262
+ heap[--stack_pointer] = obj;
263
+ return stack_pointer;
258
264
  }
259
265
  var cachedUint32Memory0 = null;
260
266
  function getUint32Memory0() {
@@ -279,26 +285,6 @@ function _assertClass(instance, klass) {
279
285
  }
280
286
  return instance.ptr;
281
287
  }
282
- var stack_pointer = 128;
283
- function addBorrowedObject(obj) {
284
- if (stack_pointer == 1) throw new Error("out of js stack");
285
- heap[--stack_pointer] = obj;
286
- return stack_pointer;
287
- }
288
- function main_js() {
289
- wasm.main_js();
290
- }
291
- function is_debug_mode() {
292
- const ret = wasm.is_debug_mode();
293
- return ret !== 0;
294
- }
295
- function handleError(f, args) {
296
- try {
297
- return f.apply(this, args);
298
- } catch (e) {
299
- wasm.__wbindgen_exn_store(addHeapObject(e));
300
- }
301
- }
302
288
  function passArrayJsValueToWasm0(array, malloc) {
303
289
  const ptr = malloc(array.length * 4, 4) >>> 0;
304
290
  const mem = getUint32Memory0();
@@ -308,30 +294,47 @@ function passArrayJsValueToWasm0(array, malloc) {
308
294
  WASM_VECTOR_LEN = array.length;
309
295
  return ptr;
310
296
  }
311
- function __wbgtest_console_log(args) {
297
+ function handleError(f, args) {
312
298
  try {
313
- wasm.__wbgtest_console_log(addBorrowedObject(args));
299
+ return f.apply(this, args);
300
+ } catch (e) {
301
+ wasm.__wbindgen_exn_store(addHeapObject(e));
302
+ }
303
+ }
304
+ function is_debug_mode() {
305
+ const ret = wasm.is_debug_mode();
306
+ return ret !== 0;
307
+ }
308
+ function main_js() {
309
+ wasm.main_js();
310
+ }
311
+ function __wbgtest_console_info(args) {
312
+ try {
313
+ wasm.__wbgtest_console_info(addBorrowedObject(args));
314
314
  } finally {
315
315
  heap[stack_pointer++] = void 0;
316
316
  }
317
317
  }
318
- function __wbgtest_console_debug(args) {
318
+ function __wbgtest_console_warn(args) {
319
319
  try {
320
- wasm.__wbgtest_console_debug(addBorrowedObject(args));
320
+ wasm.__wbgtest_console_warn(addBorrowedObject(args));
321
321
  } finally {
322
322
  heap[stack_pointer++] = void 0;
323
323
  }
324
324
  }
325
- function __wbgtest_console_info(args) {
325
+ function __wbg_adapter_287(arg0, arg1) {
326
+ wasm.wasm_bindgen__convert__closures__invoke0_mut__hc6452fdbb8c4addc(arg0, arg1);
327
+ }
328
+ function __wbgtest_console_debug(args) {
326
329
  try {
327
- wasm.__wbgtest_console_info(addBorrowedObject(args));
330
+ wasm.__wbgtest_console_debug(addBorrowedObject(args));
328
331
  } finally {
329
332
  heap[stack_pointer++] = void 0;
330
333
  }
331
334
  }
332
- function __wbgtest_console_warn(args) {
335
+ function __wbgtest_console_log(args) {
333
336
  try {
334
- wasm.__wbgtest_console_warn(addBorrowedObject(args));
337
+ wasm.__wbgtest_console_log(addBorrowedObject(args));
335
338
  } finally {
336
339
  heap[stack_pointer++] = void 0;
337
340
  }
@@ -343,14 +346,11 @@ function __wbgtest_console_error(args) {
343
346
  heap[stack_pointer++] = void 0;
344
347
  }
345
348
  }
346
- function __wbg_adapter_304(arg0, arg1) {
347
- wasm.wasm_bindgen__convert__closures__invoke0_mut__hff00333f3d941090(arg0, arg1);
348
- }
349
- function __wbg_adapter_347(arg0, arg1, arg2, arg3, arg4) {
350
- wasm.wasm_bindgen__convert__closures__invoke3_mut__h703f9c33fd3008bf(arg0, arg1, addHeapObject(arg2), arg3, addHeapObject(arg4));
349
+ function __wbg_adapter_378(arg0, arg1, arg2, arg3, arg4) {
350
+ wasm.wasm_bindgen__convert__closures__invoke3_mut__h2f203dbfa61ca113(arg0, arg1, addHeapObject(arg2), arg3, addHeapObject(arg4));
351
351
  }
352
- function __wbg_adapter_404(arg0, arg1, arg2, arg3) {
353
- wasm.wasm_bindgen__convert__closures__invoke2_mut__h97988f5fa0547d24(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
352
+ function __wbg_adapter_395(arg0, arg1, arg2, arg3) {
353
+ wasm.wasm_bindgen__convert__closures__invoke2_mut__h42aa995f02b6fdcb(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
354
354
  }
355
355
  var OpType = Object.freeze({
356
356
  /**
@@ -395,6 +395,32 @@ var BasePlugin = class {
395
395
  wasm.__wbg_baseplugin_free(ptr);
396
396
  }
397
397
  /**
398
+ * @returns {any}
399
+ */
400
+ get docCreateHook() {
401
+ const ret = wasm.baseplugin_get_doc_create_hook(this.__wbg_ptr);
402
+ return takeObject(ret);
403
+ }
404
+ /**
405
+ * @param {any} hook
406
+ */
407
+ set docCreateHook(hook) {
408
+ wasm.baseplugin_set_doc_create_hook(this.__wbg_ptr, addHeapObject(hook));
409
+ }
410
+ /**
411
+ * @returns {any}
412
+ */
413
+ get docRecoverHook() {
414
+ const ret = wasm.baseplugin_get_doc_recover_hook(this.__wbg_ptr);
415
+ return takeObject(ret);
416
+ }
417
+ /**
418
+ * @param {any} hook
419
+ */
420
+ set docRecoverHook(hook) {
421
+ wasm.baseplugin_set_doc_recover_hook(this.__wbg_ptr, addHeapObject(hook));
422
+ }
423
+ /**
398
424
  * @param {string} name
399
425
  */
400
426
  constructor(name) {
@@ -422,32 +448,6 @@ var BasePlugin = class {
422
448
  const ret = wasm.baseplugin_name(this.__wbg_ptr);
423
449
  return takeObject(ret);
424
450
  }
425
- /**
426
- * @returns {any}
427
- */
428
- get docCreateHook() {
429
- const ret = wasm.baseplugin_get_doc_create_hook(this.__wbg_ptr);
430
- return takeObject(ret);
431
- }
432
- /**
433
- * @returns {any}
434
- */
435
- get docRecoverHook() {
436
- const ret = wasm.baseplugin_get_doc_recover_hook(this.__wbg_ptr);
437
- return takeObject(ret);
438
- }
439
- /**
440
- * @param {any} hook
441
- */
442
- set docCreateHook(hook) {
443
- wasm.baseplugin_set_doc_create_hook(this.__wbg_ptr, addHeapObject(hook));
444
- }
445
- /**
446
- * @param {any} hook
447
- */
448
- set docRecoverHook(hook) {
449
- wasm.baseplugin_set_doc_recover_hook(this.__wbg_ptr, addHeapObject(hook));
450
- }
451
451
  };
452
452
  var BaseStorageFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
453
453
  }, unregister: () => {
@@ -464,66 +464,54 @@ var BaseStorage = class {
464
464
  wasm.__wbg_basestorage_free(ptr);
465
465
  }
466
466
  /**
467
- * Creates a new `BaseStorage` instance with the provided name and schema type.
468
- *
469
- * # Arguments
470
- *
471
- * * `name` - The name of the storage.
472
- * * `schema_type` - The schema type in `JsValue` format.
473
- *
474
- * # Returns
475
- *
476
- * * `Result<BaseStorage, JsValue>` - A result containing the new `BaseStorage` instance or an error.
477
467
  * @param {string} name
478
- * @param {object} schemas_js
479
- * @param {object | undefined} [options]
468
+ * @returns {any}
480
469
  */
481
- constructor(name, schemas_js, options) {
470
+ getOption(name) {
482
471
  try {
483
472
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
484
473
  const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
485
474
  const len0 = WASM_VECTOR_LEN;
486
- wasm.basestorage_new(retptr, ptr0, len0, addHeapObject(schemas_js), isLikeNone(options) ? 0 : addHeapObject(options));
475
+ wasm.basestorage_getOption(retptr, this.__wbg_ptr, ptr0, len0);
487
476
  var r0 = getInt32Memory0()[retptr / 4 + 0];
488
477
  var r1 = getInt32Memory0()[retptr / 4 + 1];
489
478
  var r2 = getInt32Memory0()[retptr / 4 + 2];
490
479
  if (r2) {
491
480
  throw takeObject(r1);
492
481
  }
493
- this.__wbg_ptr = r0 >>> 0;
494
- return this;
482
+ return takeObject(r0);
495
483
  } finally {
496
484
  wasm.__wbindgen_add_to_stack_pointer(16);
497
485
  }
498
486
  }
499
487
  /**
500
- * @returns {any}
488
+ * @param {string} name
489
+ * @returns {Schema}
501
490
  */
502
- addIndexSchemas() {
491
+ getSchema(name) {
503
492
  try {
504
493
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
505
- wasm.basestorage_addIndexSchemas(retptr, this.__wbg_ptr);
494
+ const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
495
+ const len0 = WASM_VECTOR_LEN;
496
+ wasm.basestorage_getSchema(retptr, this.__wbg_ptr, ptr0, len0);
506
497
  var r0 = getInt32Memory0()[retptr / 4 + 0];
507
498
  var r1 = getInt32Memory0()[retptr / 4 + 1];
508
499
  var r2 = getInt32Memory0()[retptr / 4 + 2];
509
500
  if (r2) {
510
501
  throw takeObject(r1);
511
502
  }
512
- return takeObject(r0);
503
+ return Schema.__wrap(r0);
513
504
  } finally {
514
505
  wasm.__wbindgen_add_to_stack_pointer(16);
515
506
  }
516
507
  }
517
508
  /**
518
- * @param {string} name
519
509
  * @returns {any}
520
510
  */
521
- getOption(name) {
511
+ addIndexSchemas() {
522
512
  try {
523
513
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
524
- const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
525
- const len0 = WASM_VECTOR_LEN;
526
- wasm.basestorage_getOption(retptr, this.__wbg_ptr, ptr0, len0);
514
+ wasm.basestorage_addIndexSchemas(retptr, this.__wbg_ptr);
527
515
  var r0 = getInt32Memory0()[retptr / 4 + 0];
528
516
  var r1 = getInt32Memory0()[retptr / 4 + 1];
529
517
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -536,22 +524,34 @@ var BaseStorage = class {
536
524
  }
537
525
  }
538
526
  /**
527
+ * Creates a new `BaseStorage` instance with the provided name and schema type.
528
+ *
529
+ * # Arguments
530
+ *
531
+ * * `name` - The name of the storage.
532
+ * * `schema_type` - The schema type in `JsValue` format.
533
+ *
534
+ * # Returns
535
+ *
536
+ * * `Result<BaseStorage, JsValue>` - A result containing the new `BaseStorage` instance or an error.
539
537
  * @param {string} name
540
- * @returns {Schema}
538
+ * @param {object} schemas_js
539
+ * @param {object | undefined} [options]
541
540
  */
542
- getSchema(name) {
541
+ constructor(name, schemas_js, options) {
543
542
  try {
544
543
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
545
544
  const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
546
545
  const len0 = WASM_VECTOR_LEN;
547
- wasm.basestorage_getSchema(retptr, this.__wbg_ptr, ptr0, len0);
546
+ wasm.basestorage_new(retptr, ptr0, len0, addHeapObject(schemas_js), isLikeNone(options) ? 0 : addHeapObject(options));
548
547
  var r0 = getInt32Memory0()[retptr / 4 + 0];
549
548
  var r1 = getInt32Memory0()[retptr / 4 + 1];
550
549
  var r2 = getInt32Memory0()[retptr / 4 + 2];
551
550
  if (r2) {
552
551
  throw takeObject(r1);
553
552
  }
554
- return Schema.__wrap(r0);
553
+ this.__wbg_ptr = r0 >>> 0;
554
+ return this;
555
555
  } finally {
556
556
  wasm.__wbindgen_add_to_stack_pointer(16);
557
557
  }
@@ -597,38 +597,31 @@ var Collection = class _Collection {
597
597
  wasm.__wbg_collection_free(ptr);
598
598
  }
599
599
  /**
600
- * @returns {string}
600
+ * Finds and returns a single document in the collection by its ID.
601
+ *
602
+ * This function is asynchronous.
603
+ * @param {any} primary_key
604
+ * @returns {Promise<any>}
601
605
  */
602
- get name() {
603
- let deferred1_0;
604
- let deferred1_1;
605
- try {
606
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
607
- wasm.collection_name(retptr, this.__wbg_ptr);
608
- var r0 = getInt32Memory0()[retptr / 4 + 0];
609
- var r1 = getInt32Memory0()[retptr / 4 + 1];
610
- deferred1_0 = r0;
611
- deferred1_1 = r1;
612
- return getStringFromWasm0(r0, r1);
613
- } finally {
614
- wasm.__wbindgen_add_to_stack_pointer(16);
615
- wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
616
- }
606
+ findById(primary_key) {
607
+ const ret = wasm.collection_findById(this.__wbg_ptr, addHeapObject(primary_key));
608
+ return takeObject(ret);
617
609
  }
618
610
  /**
619
- * @returns {Schema}
611
+ * @param {any} options
612
+ * @returns {QueryOptions}
620
613
  */
621
- get schema() {
614
+ parse_query_options(options) {
622
615
  try {
623
616
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
624
- wasm.collection_schema(retptr, this.__wbg_ptr);
617
+ wasm.collection_parse_query_options(retptr, this.__wbg_ptr, addHeapObject(options));
625
618
  var r0 = getInt32Memory0()[retptr / 4 + 0];
626
619
  var r1 = getInt32Memory0()[retptr / 4 + 1];
627
620
  var r2 = getInt32Memory0()[retptr / 4 + 2];
628
621
  if (r2) {
629
622
  throw takeObject(r1);
630
623
  }
631
- return Schema.__wrap(r0);
624
+ return QueryOptions.__wrap(r0);
632
625
  } finally {
633
626
  wasm.__wbindgen_add_to_stack_pointer(16);
634
627
  }
@@ -647,22 +640,22 @@ var Collection = class _Collection {
647
640
  return takeObject(ret);
648
641
  }
649
642
  /**
650
- * @param {any} options
651
- * @returns {QueryOptions}
643
+ * @returns {string}
652
644
  */
653
- parse_query_options(options) {
645
+ get name() {
646
+ let deferred1_0;
647
+ let deferred1_1;
654
648
  try {
655
649
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
656
- wasm.collection_parse_query_options(retptr, this.__wbg_ptr, addHeapObject(options));
650
+ wasm.collection_name(retptr, this.__wbg_ptr);
657
651
  var r0 = getInt32Memory0()[retptr / 4 + 0];
658
652
  var r1 = getInt32Memory0()[retptr / 4 + 1];
659
- var r2 = getInt32Memory0()[retptr / 4 + 2];
660
- if (r2) {
661
- throw takeObject(r1);
662
- }
663
- return QueryOptions.__wrap(r0);
653
+ deferred1_0 = r0;
654
+ deferred1_1 = r1;
655
+ return getStringFromWasm0(r0, r1);
664
656
  } finally {
665
657
  wasm.__wbindgen_add_to_stack_pointer(16);
658
+ wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
666
659
  }
667
660
  }
668
661
  /**
@@ -679,55 +672,62 @@ var Collection = class _Collection {
679
672
  return takeObject(ret);
680
673
  }
681
674
  /**
682
- * Finds and returns a single document in the collection by its ID.
683
- *
684
- * This function is asynchronous.
685
- * @param {any} primary_key
686
- * @returns {Promise<any>}
687
- */
688
- findById(primary_key) {
689
- const ret = wasm.collection_findById(this.__wbg_ptr, addHeapObject(primary_key));
690
- return takeObject(ret);
691
- }
692
- /**
693
- * Updates a document in the collection with the given data.
675
+ * Creates a new document in the collection.
694
676
  *
695
677
  * This function is asynchronous and returns a `Result` indicating success or failure.
696
678
  *
697
679
  * # Arguments
698
680
  *
699
- * * `document` - A `JsValue` representing the partial document to update.
681
+ * * `document` - A `JsValue` representing the document to create.
700
682
  * @param {any} document
701
683
  * @returns {Promise<any>}
702
684
  */
703
- update(document2) {
704
- const ret = wasm.collection_update(this.__wbg_ptr, addHeapObject(document2));
685
+ create(document2) {
686
+ const ret = wasm.collection_create(this.__wbg_ptr, addHeapObject(document2));
705
687
  return takeObject(ret);
706
688
  }
707
689
  /**
708
- * Creates a new document in the collection.
709
- *
710
- * This function is asynchronous and returns a `Result` indicating success or failure.
690
+ * Deletes a document from the collection by its ID.
711
691
  *
712
- * # Arguments
713
- *
714
- * * `document` - A `JsValue` representing the document to create.
715
- * @param {any} document
692
+ * This function is asynchronous.
693
+ * @param {any} primary_key
716
694
  * @returns {Promise<any>}
717
695
  */
718
- create(document2) {
719
- const ret = wasm.collection_create(this.__wbg_ptr, addHeapObject(document2));
696
+ delete(primary_key) {
697
+ const ret = wasm.collection_delete(this.__wbg_ptr, addHeapObject(primary_key));
720
698
  return takeObject(ret);
721
699
  }
722
700
  /**
723
- * Deletes a document from the collection by its ID.
701
+ * @returns {Schema}
702
+ */
703
+ get schema() {
704
+ try {
705
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
706
+ wasm.collection_schema(retptr, this.__wbg_ptr);
707
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
708
+ var r1 = getInt32Memory0()[retptr / 4 + 1];
709
+ var r2 = getInt32Memory0()[retptr / 4 + 2];
710
+ if (r2) {
711
+ throw takeObject(r1);
712
+ }
713
+ return Schema.__wrap(r0);
714
+ } finally {
715
+ wasm.__wbindgen_add_to_stack_pointer(16);
716
+ }
717
+ }
718
+ /**
719
+ * Updates a document in the collection with the given data.
724
720
  *
725
- * This function is asynchronous.
726
- * @param {any} primary_key
721
+ * This function is asynchronous and returns a `Result` indicating success or failure.
722
+ *
723
+ * # Arguments
724
+ *
725
+ * * `document` - A `JsValue` representing the partial document to update.
726
+ * @param {any} document
727
727
  * @returns {Promise<any>}
728
728
  */
729
- delete(primary_key) {
730
- const ret = wasm.collection_delete(this.__wbg_ptr, addHeapObject(primary_key));
729
+ update(document2) {
730
+ const ret = wasm.collection_update(this.__wbg_ptr, addHeapObject(document2));
731
731
  return takeObject(ret);
732
732
  }
733
733
  };
@@ -753,11 +753,29 @@ var CoreStorage = class _CoreStorage {
753
753
  wasm.__wbg_corestorage_free(ptr);
754
754
  }
755
755
  /**
756
+ * @param {Schema} schema
757
+ * @param {Operation} op
758
+ * @returns {(string)[]}
756
759
  */
757
- constructor() {
758
- const ret = wasm.corestorage_new();
759
- this.__wbg_ptr = ret >>> 0;
760
- return this;
760
+ getIndexes(schema, op) {
761
+ try {
762
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
763
+ _assertClass(schema, Schema);
764
+ _assertClass(op, Operation);
765
+ wasm.corestorage_getIndexes(retptr, this.__wbg_ptr, schema.__wbg_ptr, op.__wbg_ptr);
766
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
767
+ var r1 = getInt32Memory0()[retptr / 4 + 1];
768
+ var r2 = getInt32Memory0()[retptr / 4 + 2];
769
+ var r3 = getInt32Memory0()[retptr / 4 + 3];
770
+ if (r3) {
771
+ throw takeObject(r2);
772
+ }
773
+ var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
774
+ wasm.__wbindgen_free(r0, r1 * 4, 4);
775
+ return v1;
776
+ } finally {
777
+ wasm.__wbindgen_add_to_stack_pointer(16);
778
+ }
761
779
  }
762
780
  /**
763
781
  * @param {any} value
@@ -789,31 +807,6 @@ var CoreStorage = class _CoreStorage {
789
807
  }
790
808
  }
791
809
  /**
792
- * @param {Schema} schema
793
- * @param {Operation} op
794
- * @returns {(string)[]}
795
- */
796
- getIndexes(schema, op) {
797
- try {
798
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
799
- _assertClass(schema, Schema);
800
- _assertClass(op, Operation);
801
- wasm.corestorage_getIndexes(retptr, this.__wbg_ptr, schema.__wbg_ptr, op.__wbg_ptr);
802
- var r0 = getInt32Memory0()[retptr / 4 + 0];
803
- var r1 = getInt32Memory0()[retptr / 4 + 1];
804
- var r2 = getInt32Memory0()[retptr / 4 + 2];
805
- var r3 = getInt32Memory0()[retptr / 4 + 3];
806
- if (r3) {
807
- throw takeObject(r2);
808
- }
809
- var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
810
- wasm.__wbindgen_free(r0, r1 * 4, 4);
811
- return v1;
812
- } finally {
813
- wasm.__wbindgen_add_to_stack_pointer(16);
814
- }
815
- }
816
- /**
817
810
  * @param {any} document
818
811
  * @param {Query} query
819
812
  * @returns {boolean}
@@ -835,6 +828,13 @@ var CoreStorage = class _CoreStorage {
835
828
  heap[stack_pointer++] = void 0;
836
829
  }
837
830
  }
831
+ /**
832
+ */
833
+ constructor() {
834
+ const ret = wasm.corestorage_new();
835
+ this.__wbg_ptr = ret >>> 0;
836
+ return this;
837
+ }
838
838
  };
839
839
  var DatabaseFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
840
840
  }, unregister: () => {
@@ -858,38 +858,6 @@ var Database = class _Database {
858
858
  wasm.__wbg_database_free(ptr);
859
859
  }
860
860
  /**
861
- * @returns {Promise<any>}
862
- */
863
- start() {
864
- const ret = wasm.database_start(this.__wbg_ptr);
865
- return takeObject(ret);
866
- }
867
- /**
868
- * @returns {Promise<any>}
869
- */
870
- close() {
871
- const ptr = this.__destroy_into_raw();
872
- const ret = wasm.database_close(ptr);
873
- return takeObject(ret);
874
- }
875
- /**
876
- * @returns {boolean}
877
- */
878
- get started() {
879
- const ret = wasm.database_started(this.__wbg_ptr);
880
- return ret !== 0;
881
- }
882
- /**
883
- * @param {string} password
884
- * @returns {Promise<boolean>}
885
- */
886
- authenticate(password) {
887
- const ptr0 = passStringToWasm0(password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
888
- const len0 = WASM_VECTOR_LEN;
889
- const ret = wasm.database_authenticate(this.__wbg_ptr, ptr0, len0);
890
- return takeObject(ret);
891
- }
892
- /**
893
861
  * Retrieves the collections in the database.
894
862
  *
895
863
  * This function returns an `Object` containing the collections.
@@ -915,6 +883,31 @@ var Database = class _Database {
915
883
  }
916
884
  }
917
885
  /**
886
+ * @param {string} password
887
+ * @returns {Promise<boolean>}
888
+ */
889
+ authenticate(password) {
890
+ const ptr0 = passStringToWasm0(password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
891
+ const len0 = WASM_VECTOR_LEN;
892
+ const ret = wasm.database_authenticate(this.__wbg_ptr, ptr0, len0);
893
+ return takeObject(ret);
894
+ }
895
+ /**
896
+ * @returns {Promise<any>}
897
+ */
898
+ close() {
899
+ const ptr = this.__destroy_into_raw();
900
+ const ret = wasm.database_close(ptr);
901
+ return takeObject(ret);
902
+ }
903
+ /**
904
+ * @returns {Promise<any>}
905
+ */
906
+ start() {
907
+ const ret = wasm.database_start(this.__wbg_ptr);
908
+ return takeObject(ret);
909
+ }
910
+ /**
918
911
  * @param {string} db_name
919
912
  * @param {object} schemas_js
920
913
  * @param {object} migrations_js
@@ -932,6 +925,13 @@ var Database = class _Database {
932
925
  const ret = wasm.database_create(ptr0, len0, addHeapObject(schemas_js), addHeapObject(migrations_js), addHeapObject(plugins), addHeapObject(module2), ptr1, len1, isLikeNone(storage) ? 0 : addHeapObject(storage));
933
926
  return takeObject(ret);
934
927
  }
928
+ /**
929
+ * @returns {boolean}
930
+ */
931
+ get started() {
932
+ const ret = wasm.database_started(this.__wbg_ptr);
933
+ return ret !== 0;
934
+ }
935
935
  };
936
936
  var InMemoryFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
937
937
  }, unregister: () => {
@@ -955,6 +955,17 @@ var InMemory = class _InMemory {
955
955
  wasm.__wbg_inmemory_free(ptr);
956
956
  }
957
957
  /**
958
+ * @param {string} collection_name
959
+ * @param {any} primary_key
960
+ * @returns {Promise<any>}
961
+ */
962
+ findDocumentById(collection_name, primary_key) {
963
+ const ptr0 = passStringToWasm0(collection_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
964
+ const len0 = WASM_VECTOR_LEN;
965
+ const ret = wasm.inmemory_findDocumentById(this.__wbg_ptr, ptr0, len0, addHeapObject(primary_key));
966
+ return takeObject(ret);
967
+ }
968
+ /**
958
969
  * @param {string} name
959
970
  * @param {object} schemas_js
960
971
  * @returns {Promise<InMemory>}
@@ -966,16 +977,6 @@ var InMemory = class _InMemory {
966
977
  return takeObject(ret);
967
978
  }
968
979
  /**
969
- * @param {Operation} op
970
- * @returns {Promise<any>}
971
- */
972
- write(op) {
973
- _assertClass(op, Operation);
974
- var ptr0 = op.__destroy_into_raw();
975
- const ret = wasm.inmemory_write(this.__wbg_ptr, ptr0);
976
- return takeObject(ret);
977
- }
978
- /**
979
980
  * @param {string} collection_name
980
981
  * @param {any} query_js
981
982
  * @param {QueryOptions} options
@@ -990,14 +991,10 @@ var InMemory = class _InMemory {
990
991
  return takeObject(ret);
991
992
  }
992
993
  /**
993
- * @param {string} collection_name
994
- * @param {any} primary_key
995
994
  * @returns {Promise<any>}
996
995
  */
997
- findDocumentById(collection_name, primary_key) {
998
- const ptr0 = passStringToWasm0(collection_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
999
- const len0 = WASM_VECTOR_LEN;
1000
- const ret = wasm.inmemory_findDocumentById(this.__wbg_ptr, ptr0, len0, addHeapObject(primary_key));
996
+ close() {
997
+ const ret = wasm.inmemory_close(this.__wbg_ptr);
1001
998
  return takeObject(ret);
1002
999
  }
1003
1000
  /**
@@ -1017,15 +1014,18 @@ var InMemory = class _InMemory {
1017
1014
  /**
1018
1015
  * @returns {Promise<any>}
1019
1016
  */
1020
- close() {
1021
- const ret = wasm.inmemory_close(this.__wbg_ptr);
1017
+ start() {
1018
+ const ret = wasm.inmemory_start(this.__wbg_ptr);
1022
1019
  return takeObject(ret);
1023
1020
  }
1024
1021
  /**
1022
+ * @param {Operation} op
1025
1023
  * @returns {Promise<any>}
1026
1024
  */
1027
- start() {
1028
- const ret = wasm.inmemory_start(this.__wbg_ptr);
1025
+ write(op) {
1026
+ _assertClass(op, Operation);
1027
+ var ptr0 = op.__destroy_into_raw();
1028
+ const ret = wasm.inmemory_write(this.__wbg_ptr, ptr0);
1029
1029
  return takeObject(ret);
1030
1030
  }
1031
1031
  };
@@ -1072,12 +1072,12 @@ var IndexDB = class _IndexDB {
1072
1072
  * @param {string} store_name
1073
1073
  * @returns {IDBObjectStore}
1074
1074
  */
1075
- get_store(store_name) {
1075
+ get_store_readonly(store_name) {
1076
1076
  try {
1077
1077
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1078
1078
  const ptr0 = passStringToWasm0(store_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1079
1079
  const len0 = WASM_VECTOR_LEN;
1080
- wasm.indexdb_get_store(retptr, this.__wbg_ptr, ptr0, len0);
1080
+ wasm.indexdb_get_store_readonly(retptr, this.__wbg_ptr, ptr0, len0);
1081
1081
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1082
1082
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1083
1083
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1090,6 +1090,17 @@ var IndexDB = class _IndexDB {
1090
1090
  }
1091
1091
  }
1092
1092
  /**
1093
+ * @param {string} collection_name
1094
+ * @param {any} primary_key
1095
+ * @returns {Promise<any>}
1096
+ */
1097
+ findDocumentById(collection_name, primary_key) {
1098
+ const ptr0 = passStringToWasm0(collection_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1099
+ const len0 = WASM_VECTOR_LEN;
1100
+ const ret = wasm.indexdb_findDocumentById(this.__wbg_ptr, ptr0, len0, addHeapObject(primary_key));
1101
+ return takeObject(ret);
1102
+ }
1103
+ /**
1093
1104
  * @param {string} name
1094
1105
  * @param {object} schemas_js
1095
1106
  * @returns {Promise<IndexDB>}
@@ -1101,16 +1112,6 @@ var IndexDB = class _IndexDB {
1101
1112
  return takeObject(ret);
1102
1113
  }
1103
1114
  /**
1104
- * @param {Operation} op
1105
- * @returns {Promise<any>}
1106
- */
1107
- write(op) {
1108
- _assertClass(op, Operation);
1109
- var ptr0 = op.__destroy_into_raw();
1110
- const ret = wasm.indexdb_write(this.__wbg_ptr, ptr0);
1111
- return takeObject(ret);
1112
- }
1113
- /**
1114
1115
  * @param {string} collection_name
1115
1116
  * @param {any} query
1116
1117
  * @param {QueryOptions} options
@@ -1125,14 +1126,10 @@ var IndexDB = class _IndexDB {
1125
1126
  return takeObject(ret);
1126
1127
  }
1127
1128
  /**
1128
- * @param {string} collection_name
1129
- * @param {any} primary_key
1130
1129
  * @returns {Promise<any>}
1131
1130
  */
1132
- findDocumentById(collection_name, primary_key) {
1133
- const ptr0 = passStringToWasm0(collection_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1134
- const len0 = WASM_VECTOR_LEN;
1135
- const ret = wasm.indexdb_findDocumentById(this.__wbg_ptr, ptr0, len0, addHeapObject(primary_key));
1131
+ close() {
1132
+ const ret = wasm.indexdb_close(this.__wbg_ptr);
1136
1133
  return takeObject(ret);
1137
1134
  }
1138
1135
  /**
@@ -1152,27 +1149,51 @@ var IndexDB = class _IndexDB {
1152
1149
  /**
1153
1150
  * @returns {Promise<any>}
1154
1151
  */
1155
- close() {
1156
- const ret = wasm.indexdb_close(this.__wbg_ptr);
1152
+ start() {
1153
+ const ret = wasm.indexdb_start(this.__wbg_ptr);
1157
1154
  return takeObject(ret);
1158
1155
  }
1159
1156
  /**
1157
+ * @param {Operation} op
1160
1158
  * @returns {Promise<any>}
1161
1159
  */
1162
- start() {
1163
- const ret = wasm.indexdb_start(this.__wbg_ptr);
1160
+ write(op) {
1161
+ _assertClass(op, Operation);
1162
+ var ptr0 = op.__destroy_into_raw();
1163
+ const ret = wasm.indexdb_write(this.__wbg_ptr, ptr0);
1164
1164
  return takeObject(ret);
1165
1165
  }
1166
- };
1167
- var OperationFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
1168
- }, unregister: () => {
1169
- } } : new FinalizationRegistry((ptr) => wasm.__wbg_operation_free(ptr >>> 0));
1170
- var Operation = class _Operation {
1171
- static __wrap(ptr) {
1172
- ptr = ptr >>> 0;
1173
- const obj = Object.create(_Operation.prototype);
1174
- obj.__wbg_ptr = ptr;
1175
- OperationFinalization.register(obj, obj.__wbg_ptr, obj);
1166
+ /**
1167
+ * @param {string} store_name
1168
+ * @returns {IDBObjectStore}
1169
+ */
1170
+ get_store(store_name) {
1171
+ try {
1172
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1173
+ const ptr0 = passStringToWasm0(store_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1174
+ const len0 = WASM_VECTOR_LEN;
1175
+ wasm.indexdb_get_store(retptr, this.__wbg_ptr, ptr0, len0);
1176
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
1177
+ var r1 = getInt32Memory0()[retptr / 4 + 1];
1178
+ var r2 = getInt32Memory0()[retptr / 4 + 2];
1179
+ if (r2) {
1180
+ throw takeObject(r1);
1181
+ }
1182
+ return takeObject(r0);
1183
+ } finally {
1184
+ wasm.__wbindgen_add_to_stack_pointer(16);
1185
+ }
1186
+ }
1187
+ };
1188
+ var OperationFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
1189
+ }, unregister: () => {
1190
+ } } : new FinalizationRegistry((ptr) => wasm.__wbg_operation_free(ptr >>> 0));
1191
+ var Operation = class _Operation {
1192
+ static __wrap(ptr) {
1193
+ ptr = ptr >>> 0;
1194
+ const obj = Object.create(_Operation.prototype);
1195
+ obj.__wbg_ptr = ptr;
1196
+ OperationFinalization.register(obj, obj.__wbg_ptr, obj);
1176
1197
  return obj;
1177
1198
  }
1178
1199
  __destroy_into_raw() {
@@ -1210,27 +1231,15 @@ var Operation = class _Operation {
1210
1231
  }
1211
1232
  }
1212
1233
  /**
1213
- * Retrieves the type of operation.
1214
- *
1215
- * # Returns
1216
- *
1217
- * * `OpType` - The type of operation.
1218
- * @returns {OpType}
1219
- */
1220
- get opType() {
1221
- const ret = wasm.operation_opType(this.__wbg_ptr);
1222
- return ret;
1223
- }
1224
- /**
1225
- * Retrieves the data involved in the operation.
1234
+ * Retrieves the primary key value of the current data.
1226
1235
  *
1227
1236
  * # Returns
1228
1237
  *
1229
- * * `JsValue` - The data involved in the operation.
1238
+ * * `Option<JsValue>` - The primary key value of the current data.
1230
1239
  * @returns {any}
1231
1240
  */
1232
- get data() {
1233
- const ret = wasm.operation_data(this.__wbg_ptr);
1241
+ get primaryKey() {
1242
+ const ret = wasm.operation_primaryKey(this.__wbg_ptr);
1234
1243
  return takeObject(ret);
1235
1244
  }
1236
1245
  /**
@@ -1246,18 +1255,6 @@ var Operation = class _Operation {
1246
1255
  return takeObject(ret);
1247
1256
  }
1248
1257
  /**
1249
- * Retrieves the primary key value of the current data.
1250
- *
1251
- * # Returns
1252
- *
1253
- * * `Option<JsValue>` - The primary key value of the current data.
1254
- * @returns {any}
1255
- */
1256
- get primaryKey() {
1257
- const ret = wasm.operation_primaryKey(this.__wbg_ptr);
1258
- return takeObject(ret);
1259
- }
1260
- /**
1261
1258
  * @returns {string}
1262
1259
  */
1263
1260
  get primaryKeyIndex() {
@@ -1285,6 +1282,30 @@ var Operation = class _Operation {
1285
1282
  wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
1286
1283
  }
1287
1284
  }
1285
+ /**
1286
+ * Retrieves the data involved in the operation.
1287
+ *
1288
+ * # Returns
1289
+ *
1290
+ * * `JsValue` - The data involved in the operation.
1291
+ * @returns {any}
1292
+ */
1293
+ get data() {
1294
+ const ret = wasm.operation_data(this.__wbg_ptr);
1295
+ return takeObject(ret);
1296
+ }
1297
+ /**
1298
+ * Retrieves the type of operation.
1299
+ *
1300
+ * # Returns
1301
+ *
1302
+ * * `OpType` - The type of operation.
1303
+ * @returns {OpType}
1304
+ */
1305
+ get opType() {
1306
+ const ret = wasm.operation_opType(this.__wbg_ptr);
1307
+ return ret;
1308
+ }
1288
1309
  };
1289
1310
  var PropertyFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
1290
1311
  }, unregister: () => {
@@ -1301,52 +1322,40 @@ var Property = class {
1301
1322
  wasm.__wbg_property_free(ptr);
1302
1323
  }
1303
1324
  /**
1304
- * Checks is the schema is valid.
1325
+ * Retrieves the maximum length of the property.
1305
1326
  *
1306
1327
  * # Returns
1307
1328
  *
1308
- * Throws exception if not valid
1309
- * @returns {boolean}
1329
+ * * `Result<JsValue, JsValue>` - A result containing the maximum length as a `JsValue` or an error.
1330
+ * @returns {any}
1310
1331
  */
1311
- is_valid() {
1332
+ get maxLength() {
1312
1333
  try {
1313
1334
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1314
- wasm.property_is_valid(retptr, this.__wbg_ptr);
1335
+ wasm.property_maxLength(retptr, this.__wbg_ptr);
1315
1336
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1316
1337
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1317
1338
  var r2 = getInt32Memory0()[retptr / 4 + 2];
1318
1339
  if (r2) {
1319
1340
  throw takeObject(r1);
1320
1341
  }
1321
- return r0 !== 0;
1342
+ return takeObject(r0);
1322
1343
  } finally {
1323
1344
  wasm.__wbindgen_add_to_stack_pointer(16);
1324
1345
  }
1325
1346
  }
1326
1347
  /**
1327
- * Retrieves the type of the property.
1328
- *
1329
- * # Returns
1330
- *
1331
- * * `PropertyType` - The type of the property.
1332
- * @returns {any}
1333
- */
1334
- get type() {
1335
- const ret = wasm.property_type(this.__wbg_ptr);
1336
- return takeObject(ret);
1337
- }
1338
- /**
1339
- * Retrieves the items of the property.
1348
+ * Retrieves the minimum length of the property.
1340
1349
  *
1341
1350
  * # Returns
1342
1351
  *
1343
- * * `Result<JsValue, JsValue>` - A result containing the items as a `JsValue` or an error.
1352
+ * * `Result<JsValue, JsValue>` - A result containing the minimum length as a `JsValue` or an error.
1344
1353
  * @returns {any}
1345
1354
  */
1346
- get items() {
1355
+ get minLength() {
1347
1356
  try {
1348
1357
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1349
- wasm.property_items(retptr, this.__wbg_ptr);
1358
+ wasm.property_minLength(retptr, this.__wbg_ptr);
1350
1359
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1351
1360
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1352
1361
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1359,17 +1368,17 @@ var Property = class {
1359
1368
  }
1360
1369
  }
1361
1370
  /**
1362
- * Retrieves the maximum number of items of the property.
1371
+ * Retrieves the nested properties of the property.
1363
1372
  *
1364
1373
  * # Returns
1365
1374
  *
1366
- * * `Result<JsValue, JsValue>` - A result containing the maximum number of items as a `JsValue` or an error.
1375
+ * * `Result<JsValue, JsValue>` - A result containing the nested properties as a `JsValue` or an error.
1367
1376
  * @returns {any}
1368
1377
  */
1369
- get maxItems() {
1378
+ get properties() {
1370
1379
  try {
1371
1380
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1372
- wasm.property_maxItems(retptr, this.__wbg_ptr);
1381
+ wasm.property_properties(retptr, this.__wbg_ptr);
1373
1382
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1374
1383
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1375
1384
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1382,17 +1391,29 @@ var Property = class {
1382
1391
  }
1383
1392
  }
1384
1393
  /**
1385
- * Retrieves the minimum number of items of the property.
1394
+ * Retrieves the type of the property.
1386
1395
  *
1387
1396
  * # Returns
1388
1397
  *
1389
- * * `Result<JsValue, JsValue>` - A result containing the minimum number of items as a `JsValue` or an error.
1398
+ * * `PropertyType` - The type of the property.
1390
1399
  * @returns {any}
1391
1400
  */
1392
- get minItems() {
1401
+ get type() {
1402
+ const ret = wasm.property_type(this.__wbg_ptr);
1403
+ return takeObject(ret);
1404
+ }
1405
+ /**
1406
+ * Retrieves the items of the property.
1407
+ *
1408
+ * # Returns
1409
+ *
1410
+ * * `Result<JsValue, JsValue>` - A result containing the items as a `JsValue` or an error.
1411
+ * @returns {any}
1412
+ */
1413
+ get items() {
1393
1414
  try {
1394
1415
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1395
- wasm.property_minItems(retptr, this.__wbg_ptr);
1416
+ wasm.property_items(retptr, this.__wbg_ptr);
1396
1417
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1397
1418
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1398
1419
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1405,40 +1426,40 @@ var Property = class {
1405
1426
  }
1406
1427
  }
1407
1428
  /**
1408
- * Retrieves the maximum length of the property.
1429
+ * Checks is the schema is valid.
1409
1430
  *
1410
1431
  * # Returns
1411
1432
  *
1412
- * * `Result<JsValue, JsValue>` - A result containing the maximum length as a `JsValue` or an error.
1413
- * @returns {any}
1433
+ * Throws exception if not valid
1434
+ * @returns {boolean}
1414
1435
  */
1415
- get maxLength() {
1436
+ is_valid() {
1416
1437
  try {
1417
1438
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1418
- wasm.property_maxLength(retptr, this.__wbg_ptr);
1439
+ wasm.property_is_valid(retptr, this.__wbg_ptr);
1419
1440
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1420
1441
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1421
1442
  var r2 = getInt32Memory0()[retptr / 4 + 2];
1422
1443
  if (r2) {
1423
1444
  throw takeObject(r1);
1424
1445
  }
1425
- return takeObject(r0);
1446
+ return r0 !== 0;
1426
1447
  } finally {
1427
1448
  wasm.__wbindgen_add_to_stack_pointer(16);
1428
1449
  }
1429
1450
  }
1430
1451
  /**
1431
- * Retrieves the minimum length of the property.
1452
+ * Retrieves the maximum number of items of the property.
1432
1453
  *
1433
1454
  * # Returns
1434
1455
  *
1435
- * * `Result<JsValue, JsValue>` - A result containing the minimum length as a `JsValue` or an error.
1456
+ * * `Result<JsValue, JsValue>` - A result containing the maximum number of items as a `JsValue` or an error.
1436
1457
  * @returns {any}
1437
1458
  */
1438
- get minLength() {
1459
+ get maxItems() {
1439
1460
  try {
1440
1461
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1441
- wasm.property_minLength(retptr, this.__wbg_ptr);
1462
+ wasm.property_maxItems(retptr, this.__wbg_ptr);
1442
1463
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1443
1464
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1444
1465
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1451,17 +1472,17 @@ var Property = class {
1451
1472
  }
1452
1473
  }
1453
1474
  /**
1454
- * Retrieves the nested properties of the property.
1475
+ * Retrieves the minimum number of items of the property.
1455
1476
  *
1456
1477
  * # Returns
1457
1478
  *
1458
- * * `Result<JsValue, JsValue>` - A result containing the nested properties as a `JsValue` or an error.
1479
+ * * `Result<JsValue, JsValue>` - A result containing the minimum number of items as a `JsValue` or an error.
1459
1480
  * @returns {any}
1460
1481
  */
1461
- get properties() {
1482
+ get minItems() {
1462
1483
  try {
1463
1484
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1464
- wasm.property_properties(retptr, this.__wbg_ptr);
1485
+ wasm.property_minItems(retptr, this.__wbg_ptr);
1465
1486
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1466
1487
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1467
1488
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1490,33 +1511,12 @@ var Query = class {
1490
1511
  }
1491
1512
  /**
1492
1513
  * @param {any} query
1493
- * @param {Schema} schema
1494
- */
1495
- constructor(query, schema) {
1496
- try {
1497
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1498
- _assertClass(schema, Schema);
1499
- var ptr0 = schema.__destroy_into_raw();
1500
- wasm.query_new(retptr, addHeapObject(query), ptr0);
1501
- var r0 = getInt32Memory0()[retptr / 4 + 0];
1502
- var r1 = getInt32Memory0()[retptr / 4 + 1];
1503
- var r2 = getInt32Memory0()[retptr / 4 + 2];
1504
- if (r2) {
1505
- throw takeObject(r1);
1506
- }
1507
- this.__wbg_ptr = r0 >>> 0;
1508
- return this;
1509
- } finally {
1510
- wasm.__wbindgen_add_to_stack_pointer(16);
1511
- }
1512
- }
1513
- /**
1514
1514
  * @returns {any}
1515
1515
  */
1516
- get query() {
1516
+ process_query(query) {
1517
1517
  try {
1518
1518
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1519
- wasm.query_query(retptr, this.__wbg_ptr);
1519
+ wasm.query_process_query(retptr, this.__wbg_ptr, addBorrowedObject(query));
1520
1520
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1521
1521
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1522
1522
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1526,6 +1526,7 @@ var Query = class {
1526
1526
  return takeObject(r0);
1527
1527
  } finally {
1528
1528
  wasm.__wbindgen_add_to_stack_pointer(16);
1529
+ heap[stack_pointer++] = void 0;
1529
1530
  }
1530
1531
  }
1531
1532
  /**
@@ -1552,12 +1553,31 @@ var Query = class {
1552
1553
  }
1553
1554
  }
1554
1555
  /**
1556
+ * @returns {boolean}
1557
+ */
1558
+ has_or_operator() {
1559
+ const ret = wasm.query_has_or_operator(this.__wbg_ptr);
1560
+ return ret !== 0;
1561
+ }
1562
+ /**
1563
+ * Returns the value of a property from the (normalized) query by its name.
1564
+ * This will scan the normalized query structure (including arrays, $and/$or blocks, etc.)
1565
+ * to find the first occurrence of the given property name and return its corresponding value.
1566
+ *
1567
+ * If not found, an error is returned.
1568
+ *
1569
+ * Example:
1570
+ * let val = query.get("age")?;
1571
+ * // val is a JsValue that might be a number, string, boolean, array, or object (e.g., { "$gt": 30 })
1572
+ * @param {string} property_name
1555
1573
  * @returns {any}
1556
1574
  */
1557
- parse() {
1575
+ get(property_name) {
1558
1576
  try {
1559
1577
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1560
- wasm.query_parse(retptr, this.__wbg_ptr);
1578
+ const ptr0 = passStringToWasm0(property_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1579
+ const len0 = WASM_VECTOR_LEN;
1580
+ wasm.query_get(retptr, this.__wbg_ptr, ptr0, len0);
1561
1581
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1562
1582
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1563
1583
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1571,43 +1591,33 @@ var Query = class {
1571
1591
  }
1572
1592
  /**
1573
1593
  * @param {any} query
1574
- * @returns {any}
1594
+ * @param {Schema} schema
1575
1595
  */
1576
- process_query(query) {
1596
+ constructor(query, schema) {
1577
1597
  try {
1578
1598
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1579
- wasm.query_process_query(retptr, this.__wbg_ptr, addBorrowedObject(query));
1599
+ _assertClass(schema, Schema);
1600
+ var ptr0 = schema.__destroy_into_raw();
1601
+ wasm.query_new(retptr, addHeapObject(query), ptr0);
1580
1602
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1581
1603
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1582
1604
  var r2 = getInt32Memory0()[retptr / 4 + 2];
1583
1605
  if (r2) {
1584
1606
  throw takeObject(r1);
1585
1607
  }
1586
- return takeObject(r0);
1608
+ this.__wbg_ptr = r0 >>> 0;
1609
+ return this;
1587
1610
  } finally {
1588
1611
  wasm.__wbindgen_add_to_stack_pointer(16);
1589
- heap[stack_pointer++] = void 0;
1590
1612
  }
1591
1613
  }
1592
1614
  /**
1593
- * Returns the value of a property from the (normalized) query by its name.
1594
- * This will scan the normalized query structure (including arrays, $and/$or blocks, etc.)
1595
- * to find the first occurrence of the given property name and return its corresponding value.
1596
- *
1597
- * If not found, an error is returned.
1598
- *
1599
- * Example:
1600
- * let val = query.get("age")?;
1601
- * // val is a JsValue that might be a number, string, boolean, array, or object (e.g., { "$gt": 30 })
1602
- * @param {string} property_name
1603
1615
  * @returns {any}
1604
1616
  */
1605
- get(property_name) {
1617
+ parse() {
1606
1618
  try {
1607
1619
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1608
- const ptr0 = passStringToWasm0(property_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1609
- const len0 = WASM_VECTOR_LEN;
1610
- wasm.query_get(retptr, this.__wbg_ptr, ptr0, len0);
1620
+ wasm.query_parse(retptr, this.__wbg_ptr);
1611
1621
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1612
1622
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1613
1623
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1620,11 +1630,22 @@ var Query = class {
1620
1630
  }
1621
1631
  }
1622
1632
  /**
1623
- * @returns {boolean}
1633
+ * @returns {any}
1624
1634
  */
1625
- has_or_operator() {
1626
- const ret = wasm.query_has_or_operator(this.__wbg_ptr);
1627
- return ret !== 0;
1635
+ get query() {
1636
+ try {
1637
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1638
+ wasm.query_query(retptr, this.__wbg_ptr);
1639
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
1640
+ var r1 = getInt32Memory0()[retptr / 4 + 1];
1641
+ var r2 = getInt32Memory0()[retptr / 4 + 2];
1642
+ if (r2) {
1643
+ throw takeObject(r1);
1644
+ }
1645
+ return takeObject(r0);
1646
+ } finally {
1647
+ wasm.__wbindgen_add_to_stack_pointer(16);
1648
+ }
1628
1649
  }
1629
1650
  };
1630
1651
  var QueryOptionsFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
@@ -1651,10 +1672,10 @@ var QueryOptions = class _QueryOptions {
1651
1672
  /**
1652
1673
  * @returns {any}
1653
1674
  */
1654
- get limit() {
1675
+ get offset() {
1655
1676
  try {
1656
1677
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1657
- wasm.queryoptions_limit(retptr, this.__wbg_ptr);
1678
+ wasm.queryoptions_offset(retptr, this.__wbg_ptr);
1658
1679
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1659
1680
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1660
1681
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1669,10 +1690,10 @@ var QueryOptions = class _QueryOptions {
1669
1690
  /**
1670
1691
  * @returns {any}
1671
1692
  */
1672
- get offset() {
1693
+ get limit() {
1673
1694
  try {
1674
1695
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1675
- wasm.queryoptions_offset(retptr, this.__wbg_ptr);
1696
+ wasm.queryoptions_limit(retptr, this.__wbg_ptr);
1676
1697
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1677
1698
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1678
1699
  var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1698,9 +1719,9 @@ var RIDBError = class _RIDBError {
1698
1719
  }
1699
1720
  toJSON() {
1700
1721
  return {
1701
- type: this.type,
1722
+ message: this.message,
1702
1723
  code: this.code,
1703
- message: this.message
1724
+ type: this.type
1704
1725
  };
1705
1726
  }
1706
1727
  toString() {
@@ -1717,44 +1738,15 @@ var RIDBError = class _RIDBError {
1717
1738
  wasm.__wbg_ridberror_free(ptr);
1718
1739
  }
1719
1740
  /**
1720
- * @param {string} err_type
1721
- * @param {string} message
1741
+ * @param {string} err
1722
1742
  * @param {number} code
1743
+ * @returns {RIDBError}
1723
1744
  */
1724
- constructor(err_type, message, code) {
1725
- const ptr0 = passStringToWasm0(err_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1745
+ static validation(err, code) {
1746
+ const ptr0 = passStringToWasm0(err, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1726
1747
  const len0 = WASM_VECTOR_LEN;
1727
- const ptr1 = passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1728
- const len1 = WASM_VECTOR_LEN;
1729
- const ret = wasm.ridberror_new(ptr0, len0, ptr1, len1, code);
1730
- this.__wbg_ptr = ret >>> 0;
1731
- return this;
1732
- }
1733
- /**
1734
- * @returns {string}
1735
- */
1736
- get type() {
1737
- let deferred1_0;
1738
- let deferred1_1;
1739
- try {
1740
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1741
- wasm.ridberror_type(retptr, this.__wbg_ptr);
1742
- var r0 = getInt32Memory0()[retptr / 4 + 0];
1743
- var r1 = getInt32Memory0()[retptr / 4 + 1];
1744
- deferred1_0 = r0;
1745
- deferred1_1 = r1;
1746
- return getStringFromWasm0(r0, r1);
1747
- } finally {
1748
- wasm.__wbindgen_add_to_stack_pointer(16);
1749
- wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
1750
- }
1751
- }
1752
- /**
1753
- * @returns {any}
1754
- */
1755
- get code() {
1756
- const ret = wasm.ridberror_code(this.__wbg_ptr);
1757
- return takeObject(ret);
1748
+ const ret = wasm.ridberror_validation(ptr0, len0, code);
1749
+ return _RIDBError.__wrap(ret);
1758
1750
  }
1759
1751
  /**
1760
1752
  * @returns {string}
@@ -1776,11 +1768,14 @@ var RIDBError = class _RIDBError {
1776
1768
  }
1777
1769
  }
1778
1770
  /**
1779
- * @param {any} err
1771
+ * @param {string} err
1772
+ * @param {number} code
1780
1773
  * @returns {RIDBError}
1781
1774
  */
1782
- static from(err) {
1783
- const ret = wasm.ridberror_from(addHeapObject(err));
1775
+ static serialisation(err, code) {
1776
+ const ptr0 = passStringToWasm0(err, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1777
+ const len0 = WASM_VECTOR_LEN;
1778
+ const ret = wasm.ridberror_serialisation(ptr0, len0, code);
1784
1779
  return _RIDBError.__wrap(ret);
1785
1780
  }
1786
1781
  /**
@@ -1788,32 +1783,35 @@ var RIDBError = class _RIDBError {
1788
1783
  * @param {number} code
1789
1784
  * @returns {RIDBError}
1790
1785
  */
1791
- static error(err, code) {
1786
+ static authentication(err, code) {
1792
1787
  const ptr0 = passStringToWasm0(err, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1793
1788
  const len0 = WASM_VECTOR_LEN;
1794
- const ret = wasm.ridberror_error(ptr0, len0, code);
1789
+ const ret = wasm.ridberror_authentication(ptr0, len0, code);
1795
1790
  return _RIDBError.__wrap(ret);
1796
1791
  }
1797
1792
  /**
1798
- * @param {string} err
1793
+ * @param {string} err_type
1794
+ * @param {string} message
1799
1795
  * @param {number} code
1800
- * @returns {RIDBError}
1801
1796
  */
1802
- static query(err, code) {
1803
- const ptr0 = passStringToWasm0(err, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1797
+ constructor(err_type, message, code) {
1798
+ const ptr0 = passStringToWasm0(err_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1804
1799
  const len0 = WASM_VECTOR_LEN;
1805
- const ret = wasm.ridberror_query(ptr0, len0, code);
1806
- return _RIDBError.__wrap(ret);
1800
+ const ptr1 = passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1801
+ const len1 = WASM_VECTOR_LEN;
1802
+ const ret = wasm.ridberror_new(ptr0, len0, ptr1, len1, code);
1803
+ this.__wbg_ptr = ret >>> 0;
1804
+ return this;
1807
1805
  }
1808
1806
  /**
1809
1807
  * @param {string} err
1810
1808
  * @param {number} code
1811
1809
  * @returns {RIDBError}
1812
1810
  */
1813
- static authentication(err, code) {
1811
+ static hook(err, code) {
1814
1812
  const ptr0 = passStringToWasm0(err, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1815
1813
  const len0 = WASM_VECTOR_LEN;
1816
- const ret = wasm.ridberror_authentication(ptr0, len0, code);
1814
+ const ret = wasm.ridberror_hook(ptr0, len0, code);
1817
1815
  return _RIDBError.__wrap(ret);
1818
1816
  }
1819
1817
  /**
@@ -1821,10 +1819,10 @@ var RIDBError = class _RIDBError {
1821
1819
  * @param {number} code
1822
1820
  * @returns {RIDBError}
1823
1821
  */
1824
- static serialisation(err, code) {
1822
+ static error(err, code) {
1825
1823
  const ptr0 = passStringToWasm0(err, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1826
1824
  const len0 = WASM_VECTOR_LEN;
1827
- const ret = wasm.ridberror_serialisation(ptr0, len0, code);
1825
+ const ret = wasm.ridberror_error(ptr0, len0, code);
1828
1826
  return _RIDBError.__wrap(ret);
1829
1827
  }
1830
1828
  /**
@@ -1832,23 +1830,46 @@ var RIDBError = class _RIDBError {
1832
1830
  * @param {number} code
1833
1831
  * @returns {RIDBError}
1834
1832
  */
1835
- static validation(err, code) {
1833
+ static query(err, code) {
1836
1834
  const ptr0 = passStringToWasm0(err, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1837
1835
  const len0 = WASM_VECTOR_LEN;
1838
- const ret = wasm.ridberror_validation(ptr0, len0, code);
1836
+ const ret = wasm.ridberror_query(ptr0, len0, code);
1839
1837
  return _RIDBError.__wrap(ret);
1840
1838
  }
1841
1839
  /**
1842
- * @param {string} err
1843
- * @param {number} code
1840
+ * @returns {any}
1841
+ */
1842
+ get code() {
1843
+ const ret = wasm.ridberror_code(this.__wbg_ptr);
1844
+ return takeObject(ret);
1845
+ }
1846
+ /**
1847
+ * @param {any} err
1844
1848
  * @returns {RIDBError}
1845
1849
  */
1846
- static hook(err, code) {
1847
- const ptr0 = passStringToWasm0(err, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1848
- const len0 = WASM_VECTOR_LEN;
1849
- const ret = wasm.ridberror_hook(ptr0, len0, code);
1850
+ static from(err) {
1851
+ const ret = wasm.ridberror_from(addHeapObject(err));
1850
1852
  return _RIDBError.__wrap(ret);
1851
1853
  }
1854
+ /**
1855
+ * @returns {string}
1856
+ */
1857
+ get type() {
1858
+ let deferred1_0;
1859
+ let deferred1_1;
1860
+ try {
1861
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1862
+ wasm.ridberror_type(retptr, this.__wbg_ptr);
1863
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
1864
+ var r1 = getInt32Memory0()[retptr / 4 + 1];
1865
+ deferred1_0 = r0;
1866
+ deferred1_1 = r1;
1867
+ return getStringFromWasm0(r0, r1);
1868
+ } finally {
1869
+ wasm.__wbindgen_add_to_stack_pointer(16);
1870
+ wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
1871
+ }
1872
+ }
1852
1873
  };
1853
1874
  var SchemaFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
1854
1875
  }, unregister: () => {
@@ -1872,80 +1893,84 @@ var Schema = class _Schema {
1872
1893
  wasm.__wbg_schema_free(ptr);
1873
1894
  }
1874
1895
  /**
1875
- * @param {any} document
1896
+ * Retrieves the indexes of the schema, if any.
1897
+ *
1898
+ * # Returns
1899
+ *
1900
+ * * `Option<Vec<String>>` - The indexes of the schema, if any.
1901
+ * @returns {(string)[] | undefined}
1876
1902
  */
1877
- validate(document2) {
1903
+ get indexes() {
1878
1904
  try {
1879
1905
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1880
- wasm.schema_validate(retptr, this.__wbg_ptr, addHeapObject(document2));
1906
+ wasm.schema_indexes(retptr, this.__wbg_ptr);
1881
1907
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1882
1908
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1883
- if (r1) {
1884
- throw takeObject(r0);
1909
+ let v1;
1910
+ if (r0 !== 0) {
1911
+ v1 = getArrayJsValueFromWasm0(r0, r1).slice();
1912
+ wasm.__wbindgen_free(r0, r1 * 4, 4);
1885
1913
  }
1914
+ return v1;
1886
1915
  } finally {
1887
1916
  wasm.__wbindgen_add_to_stack_pointer(16);
1888
1917
  }
1889
1918
  }
1890
1919
  /**
1891
- * @returns {boolean}
1920
+ * Retrieves the version of the schema.
1921
+ *
1922
+ * # Returns
1923
+ *
1924
+ * * `i32` - The version of the schema.
1925
+ * @returns {number}
1892
1926
  */
1893
- is_valid() {
1927
+ get version() {
1928
+ const ret = wasm.schema_version(this.__wbg_ptr);
1929
+ return ret;
1930
+ }
1931
+ /**
1932
+ * @returns {(string)[] | undefined}
1933
+ */
1934
+ get encrypted() {
1894
1935
  try {
1895
1936
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1896
- wasm.schema_is_valid(retptr, this.__wbg_ptr);
1937
+ wasm.schema_encrypted(retptr, this.__wbg_ptr);
1897
1938
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1898
1939
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1899
- var r2 = getInt32Memory0()[retptr / 4 + 2];
1900
- if (r2) {
1901
- throw takeObject(r1);
1940
+ let v1;
1941
+ if (r0 !== 0) {
1942
+ v1 = getArrayJsValueFromWasm0(r0, r1).slice();
1943
+ wasm.__wbindgen_free(r0, r1 * 4, 4);
1902
1944
  }
1903
- return r0 !== 0;
1945
+ return v1;
1904
1946
  } finally {
1905
1947
  wasm.__wbindgen_add_to_stack_pointer(16);
1906
1948
  }
1907
1949
  }
1908
1950
  /**
1909
- * Creates a new `Schema` instance from a given `JsValue`.
1910
- *
1911
- * # Arguments
1912
- *
1913
- * * `schema` - A `JsValue` representing the schema.
1951
+ * Retrieves the properties of the schema.
1914
1952
  *
1915
1953
  * # Returns
1916
1954
  *
1917
- * * `Result<Schema, JsValue>` - A result containing the new `Schema` instance or an error.
1918
- * @param {any} schema
1919
- * @returns {Schema}
1955
+ * * `Result<JsValue, JsValue>` - A result containing the properties as a `JsValue` or an error.
1956
+ * @returns {any}
1920
1957
  */
1921
- static create(schema) {
1958
+ get properties() {
1922
1959
  try {
1923
1960
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1924
- wasm.schema_create(retptr, addHeapObject(schema));
1961
+ wasm.schema_properties(retptr, this.__wbg_ptr);
1925
1962
  var r0 = getInt32Memory0()[retptr / 4 + 0];
1926
1963
  var r1 = getInt32Memory0()[retptr / 4 + 1];
1927
1964
  var r2 = getInt32Memory0()[retptr / 4 + 2];
1928
1965
  if (r2) {
1929
1966
  throw takeObject(r1);
1930
1967
  }
1931
- return _Schema.__wrap(r0);
1968
+ return takeObject(r0);
1932
1969
  } finally {
1933
1970
  wasm.__wbindgen_add_to_stack_pointer(16);
1934
1971
  }
1935
1972
  }
1936
1973
  /**
1937
- * Retrieves the version of the schema.
1938
- *
1939
- * # Returns
1940
- *
1941
- * * `i32` - The version of the schema.
1942
- * @returns {number}
1943
- */
1944
- get version() {
1945
- const ret = wasm.schema_version(this.__wbg_ptr);
1946
- return ret;
1947
- }
1948
- /**
1949
1974
  * Retrieves the primary key of the schema.
1950
1975
  *
1951
1976
  * # Returns
@@ -1994,67 +2019,63 @@ var Schema = class _Schema {
1994
2019
  }
1995
2020
  }
1996
2021
  /**
1997
- * Retrieves the indexes of the schema, if any.
1998
- *
1999
- * # Returns
2000
- *
2001
- * * `Option<Vec<String>>` - The indexes of the schema, if any.
2002
- * @returns {(string)[] | undefined}
2022
+ * @param {any} document
2003
2023
  */
2004
- get indexes() {
2024
+ validate(document2) {
2005
2025
  try {
2006
2026
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2007
- wasm.schema_indexes(retptr, this.__wbg_ptr);
2027
+ wasm.schema_validate(retptr, this.__wbg_ptr, addHeapObject(document2));
2008
2028
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2009
2029
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2010
- let v1;
2011
- if (r0 !== 0) {
2012
- v1 = getArrayJsValueFromWasm0(r0, r1).slice();
2013
- wasm.__wbindgen_free(r0, r1 * 4, 4);
2030
+ if (r1) {
2031
+ throw takeObject(r0);
2014
2032
  }
2015
- return v1;
2016
2033
  } finally {
2017
2034
  wasm.__wbindgen_add_to_stack_pointer(16);
2018
2035
  }
2019
2036
  }
2020
2037
  /**
2021
- * @returns {(string)[] | undefined}
2038
+ * Creates a new `Schema` instance from a given `JsValue`.
2039
+ *
2040
+ * # Arguments
2041
+ *
2042
+ * * `schema` - A `JsValue` representing the schema.
2043
+ *
2044
+ * # Returns
2045
+ *
2046
+ * * `Result<Schema, JsValue>` - A result containing the new `Schema` instance or an error.
2047
+ * @param {any} schema
2048
+ * @returns {Schema}
2022
2049
  */
2023
- get encrypted() {
2050
+ static create(schema) {
2024
2051
  try {
2025
2052
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2026
- wasm.schema_encrypted(retptr, this.__wbg_ptr);
2053
+ wasm.schema_create(retptr, addHeapObject(schema));
2027
2054
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2028
2055
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2029
- let v1;
2030
- if (r0 !== 0) {
2031
- v1 = getArrayJsValueFromWasm0(r0, r1).slice();
2032
- wasm.__wbindgen_free(r0, r1 * 4, 4);
2056
+ var r2 = getInt32Memory0()[retptr / 4 + 2];
2057
+ if (r2) {
2058
+ throw takeObject(r1);
2033
2059
  }
2034
- return v1;
2060
+ return _Schema.__wrap(r0);
2035
2061
  } finally {
2036
2062
  wasm.__wbindgen_add_to_stack_pointer(16);
2037
2063
  }
2038
2064
  }
2039
2065
  /**
2040
- * Retrieves the properties of the schema.
2041
- *
2042
- * # Returns
2043
- *
2044
- * * `Result<JsValue, JsValue>` - A result containing the properties as a `JsValue` or an error.
2045
- * @returns {any}
2066
+ * @returns {boolean}
2046
2067
  */
2047
- get properties() {
2068
+ is_valid() {
2048
2069
  try {
2049
2070
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2050
- wasm.schema_properties(retptr, this.__wbg_ptr);
2071
+ wasm.schema_is_valid(retptr, this.__wbg_ptr);
2051
2072
  var r0 = getInt32Memory0()[retptr / 4 + 0];
2052
2073
  var r1 = getInt32Memory0()[retptr / 4 + 1];
2053
2074
  var r2 = getInt32Memory0()[retptr / 4 + 2];
2054
2075
  if (r2) {
2055
2076
  throw takeObject(r1);
2056
2077
  }
2057
- return takeObject(r0);
2078
+ return r0 !== 0;
2058
2079
  } finally {
2059
2080
  wasm.__wbindgen_add_to_stack_pointer(16);
2060
2081
  }
@@ -2087,16 +2108,6 @@ var WasmBindgenTestContext = class {
2087
2108
  return this;
2088
2109
  }
2089
2110
  /**
2090
- * Inform this context about runtime arguments passed to the test
2091
- * harness.
2092
- * @param {any[]} args
2093
- */
2094
- args(args) {
2095
- const ptr0 = passArrayJsValueToWasm0(args, wasm.__wbindgen_malloc);
2096
- const len0 = WASM_VECTOR_LEN;
2097
- wasm.wasmbindgentestcontext_args(this.__wbg_ptr, ptr0, len0);
2098
- }
2099
- /**
2100
2111
  * Executes a list of tests, returning a promise representing their
2101
2112
  * eventual completion.
2102
2113
  *
@@ -2115,6 +2126,16 @@ var WasmBindgenTestContext = class {
2115
2126
  const ret = wasm.wasmbindgentestcontext_run(this.__wbg_ptr, ptr0, len0);
2116
2127
  return takeObject(ret);
2117
2128
  }
2129
+ /**
2130
+ * Inform this context about runtime arguments passed to the test
2131
+ * harness.
2132
+ * @param {any[]} args
2133
+ */
2134
+ args(args) {
2135
+ const ptr0 = passArrayJsValueToWasm0(args, wasm.__wbindgen_malloc);
2136
+ const len0 = WASM_VECTOR_LEN;
2137
+ wasm.wasmbindgentestcontext_args(this.__wbg_ptr, ptr0, len0);
2138
+ }
2118
2139
  };
2119
2140
  async function __wbg_load(module2, imports) {
2120
2141
  if (typeof Response === "function" && module2 instanceof Response) {
@@ -2146,51 +2167,30 @@ function __wbg_get_imports() {
2146
2167
  imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
2147
2168
  takeObject(arg0);
2148
2169
  };
2149
- imports.wbg.__wbg_count_19db4c3174d573d5 = function() {
2150
- return handleError(function(arg0, arg1, arg2, arg3, arg4) {
2151
- const ret = getObject(arg0).count(getStringFromWasm0(arg1, arg2), takeObject(arg3), QueryOptions.__wrap(arg4));
2152
- return addHeapObject(ret);
2153
- }, arguments);
2154
- };
2155
- imports.wbg.__wbg_ridberror_new = function(arg0) {
2156
- const ret = RIDBError.__wrap(arg0);
2170
+ imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
2171
+ const ret = getObject(arg0);
2157
2172
  return addHeapObject(ret);
2158
2173
  };
2159
2174
  imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
2160
2175
  const ret = getStringFromWasm0(arg0, arg1);
2161
2176
  return addHeapObject(ret);
2162
2177
  };
2163
- imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
2164
- const ret = getObject(arg0);
2178
+ imports.wbg.__wbindgen_number_new = function(arg0) {
2179
+ const ret = arg0;
2165
2180
  return addHeapObject(ret);
2166
2181
  };
2167
- imports.wbg.__wbindgen_is_undefined = function(arg0) {
2168
- const ret = getObject(arg0) === void 0;
2169
- return ret;
2182
+ imports.wbg.__wbg_ridberror_new = function(arg0) {
2183
+ const ret = RIDBError.__wrap(arg0);
2184
+ return addHeapObject(ret);
2170
2185
  };
2171
2186
  imports.wbg.__wbindgen_is_null = function(arg0) {
2172
2187
  const ret = getObject(arg0) === null;
2173
2188
  return ret;
2174
2189
  };
2175
- imports.wbg.__wbg_start_76c138c3b73ae6f8 = function() {
2176
- return handleError(function(arg0) {
2177
- const ret = getObject(arg0).start();
2178
- return addHeapObject(ret);
2179
- }, arguments);
2180
- };
2181
- imports.wbg.__wbindgen_cb_drop = function(arg0) {
2182
- const obj = takeObject(arg0).original;
2183
- if (obj.cnt-- == 1) {
2184
- obj.a = 0;
2185
- return true;
2186
- }
2187
- const ret = false;
2190
+ imports.wbg.__wbindgen_is_undefined = function(arg0) {
2191
+ const ret = getObject(arg0) === void 0;
2188
2192
  return ret;
2189
2193
  };
2190
- imports.wbg.__wbindgen_number_new = function(arg0) {
2191
- const ret = arg0;
2192
- return addHeapObject(ret);
2193
- };
2194
2194
  imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
2195
2195
  const obj = getObject(arg1);
2196
2196
  const ret = typeof obj === "string" ? obj : void 0;
@@ -2199,6 +2199,12 @@ function __wbg_get_imports() {
2199
2199
  getInt32Memory0()[arg0 / 4 + 1] = len1;
2200
2200
  getInt32Memory0()[arg0 / 4 + 0] = ptr1;
2201
2201
  };
2202
+ imports.wbg.__wbg_count_19db4c3174d573d5 = function() {
2203
+ return handleError(function(arg0, arg1, arg2, arg3, arg4) {
2204
+ const ret = getObject(arg0).count(getStringFromWasm0(arg1, arg2), takeObject(arg3), QueryOptions.__wrap(arg4));
2205
+ return addHeapObject(ret);
2206
+ }, arguments);
2207
+ };
2202
2208
  imports.wbg.__wbg_apply_9f557eba1534d597 = function() {
2203
2209
  return handleError(function(arg0, arg1, arg2) {
2204
2210
  const ret = getObject(arg1).apply(takeObject(arg2));
@@ -2212,59 +2218,66 @@ function __wbg_get_imports() {
2212
2218
  const ret = InMemory.__wrap(arg0);
2213
2219
  return addHeapObject(ret);
2214
2220
  };
2221
+ imports.wbg.__wbindgen_cb_drop = function(arg0) {
2222
+ const obj = takeObject(arg0).original;
2223
+ if (obj.cnt-- == 1) {
2224
+ obj.a = 0;
2225
+ return true;
2226
+ }
2227
+ const ret = false;
2228
+ return ret;
2229
+ };
2215
2230
  imports.wbg.__wbg_close_6384ed3c27ef25c1 = function() {
2216
2231
  return handleError(function(arg0) {
2217
2232
  const ret = getObject(arg0).close();
2218
2233
  return addHeapObject(ret);
2219
2234
  }, arguments);
2220
2235
  };
2236
+ imports.wbg.__wbg_start_76c138c3b73ae6f8 = function() {
2237
+ return handleError(function(arg0) {
2238
+ const ret = getObject(arg0).start();
2239
+ return addHeapObject(ret);
2240
+ }, arguments);
2241
+ };
2221
2242
  imports.wbg.__wbindgen_number_get = function(arg0, arg1) {
2222
2243
  const obj = getObject(arg1);
2223
2244
  const ret = typeof obj === "number" ? obj : void 0;
2224
2245
  getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret;
2225
2246
  getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
2226
2247
  };
2227
- imports.wbg.__wbg_find_567c5c9f064fe3d2 = function() {
2228
- return handleError(function(arg0, arg1, arg2, arg3, arg4) {
2229
- const ret = getObject(arg0).find(getStringFromWasm0(arg1, arg2), takeObject(arg3), QueryOptions.__wrap(arg4));
2230
- return addHeapObject(ret);
2231
- }, arguments);
2232
- };
2233
2248
  imports.wbg.__wbg_findDocumentById_2edf7350e5f12657 = function() {
2234
2249
  return handleError(function(arg0, arg1, arg2, arg3) {
2235
2250
  const ret = getObject(arg0).findDocumentById(getStringFromWasm0(arg1, arg2), takeObject(arg3));
2236
2251
  return addHeapObject(ret);
2237
2252
  }, arguments);
2238
2253
  };
2254
+ imports.wbg.__wbg_find_567c5c9f064fe3d2 = function() {
2255
+ return handleError(function(arg0, arg1, arg2, arg3, arg4) {
2256
+ const ret = getObject(arg0).find(getStringFromWasm0(arg1, arg2), takeObject(arg3), QueryOptions.__wrap(arg4));
2257
+ return addHeapObject(ret);
2258
+ }, arguments);
2259
+ };
2239
2260
  imports.wbg.__wbg_write_1159c67c07f62020 = function() {
2240
2261
  return handleError(function(arg0, arg1) {
2241
2262
  const ret = getObject(arg0).write(Operation.__wrap(arg1));
2242
2263
  return addHeapObject(ret);
2243
2264
  }, arguments);
2244
2265
  };
2245
- imports.wbg.__wbg_database_new = function(arg0) {
2246
- const ret = Database.__wrap(arg0);
2247
- return addHeapObject(ret);
2248
- };
2249
- imports.wbg.__wbg_collection_new = function(arg0) {
2250
- const ret = Collection.__wrap(arg0);
2251
- return addHeapObject(ret);
2266
+ imports.wbg.__wbindgen_is_object = function(arg0) {
2267
+ const val = getObject(arg0);
2268
+ const ret = typeof val === "object" && val !== null;
2269
+ return ret;
2252
2270
  };
2253
- imports.wbg.__wbg_indexdb_new = function(arg0) {
2254
- const ret = IndexDB.__wrap(arg0);
2255
- return addHeapObject(ret);
2271
+ imports.wbg.__wbindgen_is_string = function(arg0) {
2272
+ const ret = typeof getObject(arg0) === "string";
2273
+ return ret;
2256
2274
  };
2257
2275
  imports.wbg.__wbindgen_is_array = function(arg0) {
2258
2276
  const ret = Array.isArray(getObject(arg0));
2259
2277
  return ret;
2260
2278
  };
2261
- imports.wbg.__wbindgen_is_object = function(arg0) {
2262
- const val = getObject(arg0);
2263
- const ret = typeof val === "object" && val !== null;
2264
- return ret;
2265
- };
2266
- imports.wbg.__wbindgen_jsval_eq = function(arg0, arg1) {
2267
- const ret = getObject(arg0) === getObject(arg1);
2279
+ imports.wbg.__wbindgen_is_falsy = function(arg0) {
2280
+ const ret = !getObject(arg0);
2268
2281
  return ret;
2269
2282
  };
2270
2283
  imports.wbg.__wbindgen_boolean_get = function(arg0) {
@@ -2272,10 +2285,18 @@ function __wbg_get_imports() {
2272
2285
  const ret = typeof v === "boolean" ? v ? 1 : 0 : 2;
2273
2286
  return ret;
2274
2287
  };
2288
+ imports.wbg.__wbindgen_is_function = function(arg0) {
2289
+ const ret = typeof getObject(arg0) === "function";
2290
+ return ret;
2291
+ };
2275
2292
  imports.wbg.__wbindgen_is_bigint = function(arg0) {
2276
2293
  const ret = typeof getObject(arg0) === "bigint";
2277
2294
  return ret;
2278
2295
  };
2296
+ imports.wbg.__wbg_collection_new = function(arg0) {
2297
+ const ret = Collection.__wrap(arg0);
2298
+ return addHeapObject(ret);
2299
+ };
2279
2300
  imports.wbg.__wbindgen_in = function(arg0, arg1) {
2280
2301
  const ret = getObject(arg0) in getObject(arg1);
2281
2302
  return ret;
@@ -2284,6 +2305,10 @@ function __wbg_get_imports() {
2284
2305
  const ret = arg0;
2285
2306
  return addHeapObject(ret);
2286
2307
  };
2308
+ imports.wbg.__wbindgen_jsval_eq = function(arg0, arg1) {
2309
+ const ret = getObject(arg0) === getObject(arg1);
2310
+ return ret;
2311
+ };
2287
2312
  imports.wbg.__wbindgen_bigint_from_u64 = function(arg0) {
2288
2313
  const ret = BigInt.asUintN(64, arg0);
2289
2314
  return addHeapObject(ret);
@@ -2292,17 +2317,13 @@ function __wbg_get_imports() {
2292
2317
  const ret = new Error(getStringFromWasm0(arg0, arg1));
2293
2318
  return addHeapObject(ret);
2294
2319
  };
2295
- imports.wbg.__wbindgen_is_string = function(arg0) {
2296
- const ret = typeof getObject(arg0) === "string";
2297
- return ret;
2298
- };
2299
- imports.wbg.__wbindgen_is_falsy = function(arg0) {
2300
- const ret = !getObject(arg0);
2301
- return ret;
2320
+ imports.wbg.__wbg_database_new = function(arg0) {
2321
+ const ret = Database.__wrap(arg0);
2322
+ return addHeapObject(ret);
2302
2323
  };
2303
- imports.wbg.__wbindgen_is_function = function(arg0) {
2304
- const ret = typeof getObject(arg0) === "function";
2305
- return ret;
2324
+ imports.wbg.__wbg_indexdb_new = function(arg0) {
2325
+ const ret = IndexDB.__wrap(arg0);
2326
+ return addHeapObject(ret);
2306
2327
  };
2307
2328
  imports.wbg.__wbg_crypto_1d1f22824a6a080c = function(arg0) {
2308
2329
  const ret = getObject(arg0).crypto;
@@ -2356,6 +2377,12 @@ function __wbg_get_imports() {
2356
2377
  return isLikeNone(ret) ? 0 : addHeapObject(ret);
2357
2378
  }, arguments);
2358
2379
  };
2380
+ imports.wbg.__wbg_indexedDB_d312f95759a15fdc = function() {
2381
+ return handleError(function(arg0) {
2382
+ const ret = getObject(arg0).indexedDB;
2383
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
2384
+ }, arguments);
2385
+ };
2359
2386
  imports.wbg.__wbg_instanceof_WorkerGlobalScope_46b577f151fad960 = function(arg0) {
2360
2387
  let result;
2361
2388
  try {
@@ -2366,105 +2393,106 @@ function __wbg_get_imports() {
2366
2393
  const ret = result;
2367
2394
  return ret;
2368
2395
  };
2369
- imports.wbg.__wbg_indexedDB_d312f95759a15fdc = function() {
2396
+ imports.wbg.__wbg_continue_f1c3e0815924de62 = function() {
2370
2397
  return handleError(function(arg0) {
2371
- const ret = getObject(arg0).indexedDB;
2372
- return isLikeNone(ret) ? 0 : addHeapObject(ret);
2398
+ getObject(arg0).continue();
2373
2399
  }, arguments);
2374
2400
  };
2375
- imports.wbg.__wbg_debug_5fb96680aecf5dc8 = function(arg0) {
2376
- console.debug(getObject(arg0));
2377
- };
2378
- imports.wbg.__wbg_openCursor_425aba9cbe1d4d39 = function() {
2379
- return handleError(function(arg0) {
2380
- const ret = getObject(arg0).openCursor();
2401
+ imports.wbg.__wbg_open_f0d7259fd7e689ce = function() {
2402
+ return handleError(function(arg0, arg1, arg2, arg3) {
2403
+ const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2), arg3 >>> 0);
2381
2404
  return addHeapObject(ret);
2382
2405
  }, arguments);
2383
2406
  };
2384
- imports.wbg.__wbg_openCursor_e3042770817a8d57 = function() {
2385
- return handleError(function(arg0, arg1) {
2386
- const ret = getObject(arg0).openCursor(getObject(arg1));
2407
+ imports.wbg.__wbg_lowerBound_cd1c8a3b3fdf1582 = function() {
2408
+ return handleError(function(arg0) {
2409
+ const ret = IDBKeyRange.lowerBound(getObject(arg0));
2387
2410
  return addHeapObject(ret);
2388
2411
  }, arguments);
2389
2412
  };
2390
- imports.wbg.__wbg_openKeyCursor_6a1881d8dd9f1c21 = function() {
2413
+ imports.wbg.__wbg_upperBound_1e3077b2c05bdd71 = function() {
2391
2414
  return handleError(function(arg0) {
2392
- const ret = getObject(arg0).openKeyCursor();
2415
+ const ret = IDBKeyRange.upperBound(getObject(arg0));
2393
2416
  return addHeapObject(ret);
2394
2417
  }, arguments);
2395
2418
  };
2396
- imports.wbg.__wbg_openKeyCursor_a50d16a4992519e2 = function() {
2419
+ imports.wbg.__wbg_lowerBound_e77f6e14cb69151e = function() {
2397
2420
  return handleError(function(arg0, arg1) {
2398
- const ret = getObject(arg0).openKeyCursor(getObject(arg1));
2421
+ const ret = IDBKeyRange.lowerBound(getObject(arg0), arg1 !== 0);
2399
2422
  return addHeapObject(ret);
2400
2423
  }, arguments);
2401
2424
  };
2402
- imports.wbg.__wbg_createIndex_b8da1f5571f644be = function() {
2403
- return handleError(function(arg0, arg1, arg2, arg3, arg4, arg5) {
2404
- const ret = getObject(arg0).createIndex(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4), getObject(arg5));
2425
+ imports.wbg.__wbg_upperBound_4c692da072d1a11e = function() {
2426
+ return handleError(function(arg0, arg1) {
2427
+ const ret = IDBKeyRange.upperBound(getObject(arg0), arg1 !== 0);
2405
2428
  return addHeapObject(ret);
2406
2429
  }, arguments);
2407
2430
  };
2408
- imports.wbg.__wbg_delete_f60bba7d0ae59a4f = function() {
2409
- return handleError(function(arg0, arg1) {
2410
- const ret = getObject(arg0).delete(getObject(arg1));
2431
+ imports.wbg.__wbg_bound_25385469508e98c7 = function() {
2432
+ return handleError(function(arg0, arg1, arg2, arg3) {
2433
+ const ret = IDBKeyRange.bound(getObject(arg0), getObject(arg1), arg2 !== 0, arg3 !== 0);
2411
2434
  return addHeapObject(ret);
2412
2435
  }, arguments);
2413
2436
  };
2414
- imports.wbg.__wbg_get_5361b64cac0d0826 = function() {
2415
- return handleError(function(arg0, arg1) {
2416
- const ret = getObject(arg0).get(getObject(arg1));
2437
+ imports.wbg.__wbg_only_cacf767244bdc280 = function() {
2438
+ return handleError(function(arg0) {
2439
+ const ret = IDBKeyRange.only(getObject(arg0));
2417
2440
  return addHeapObject(ret);
2418
2441
  }, arguments);
2419
2442
  };
2420
- imports.wbg.__wbg_index_383b6812c1508030 = function() {
2421
- return handleError(function(arg0, arg1, arg2) {
2422
- const ret = getObject(arg0).index(getStringFromWasm0(arg1, arg2));
2443
+ imports.wbg.__wbg_get_910bbb94abdcf488 = function(arg0, arg1, arg2) {
2444
+ const ret = getObject(arg1)[arg2 >>> 0];
2445
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2446
+ var len1 = WASM_VECTOR_LEN;
2447
+ getInt32Memory0()[arg0 / 4 + 1] = len1;
2448
+ getInt32Memory0()[arg0 / 4 + 0] = ptr1;
2449
+ };
2450
+ imports.wbg.__wbg_length_9ae5daf9a690cba9 = function(arg0) {
2451
+ const ret = getObject(arg0).length;
2452
+ return ret;
2453
+ };
2454
+ imports.wbg.__wbg_contains_c65b44400b549286 = function(arg0, arg1, arg2) {
2455
+ const ret = getObject(arg0).contains(getStringFromWasm0(arg1, arg2));
2456
+ return ret;
2457
+ };
2458
+ imports.wbg.__wbg_value_86d3334f5075b232 = function() {
2459
+ return handleError(function(arg0) {
2460
+ const ret = getObject(arg0).value;
2423
2461
  return addHeapObject(ret);
2424
2462
  }, arguments);
2425
2463
  };
2426
- imports.wbg.__wbg_openCursor_30d58ae27a327629 = function() {
2464
+ imports.wbg.__wbg_instanceof_IdbCursorWithValue_abeb44d13d947bc2 = function(arg0) {
2465
+ let result;
2466
+ try {
2467
+ result = getObject(arg0) instanceof IDBCursorWithValue;
2468
+ } catch (_) {
2469
+ result = false;
2470
+ }
2471
+ const ret = result;
2472
+ return ret;
2473
+ };
2474
+ imports.wbg.__wbg_debug_5fb96680aecf5dc8 = function(arg0) {
2475
+ console.debug(getObject(arg0));
2476
+ };
2477
+ imports.wbg.__wbg_openCursor_425aba9cbe1d4d39 = function() {
2427
2478
  return handleError(function(arg0) {
2428
2479
  const ret = getObject(arg0).openCursor();
2429
2480
  return addHeapObject(ret);
2430
2481
  }, arguments);
2431
2482
  };
2432
- imports.wbg.__wbg_openCursor_611b1e488c393dd8 = function() {
2483
+ imports.wbg.__wbg_openCursor_e3042770817a8d57 = function() {
2433
2484
  return handleError(function(arg0, arg1) {
2434
2485
  const ret = getObject(arg0).openCursor(getObject(arg1));
2435
2486
  return addHeapObject(ret);
2436
2487
  }, arguments);
2437
2488
  };
2438
- imports.wbg.__wbg_put_22792e17580ca18b = function() {
2489
+ imports.wbg.__wbg_objectStoreNames_588b5924274239fd = function(arg0) {
2490
+ const ret = getObject(arg0).objectStoreNames;
2491
+ return addHeapObject(ret);
2492
+ };
2493
+ imports.wbg.__wbg_createObjectStore_882f2f6b1b1ef040 = function() {
2439
2494
  return handleError(function(arg0, arg1, arg2) {
2440
- const ret = getObject(arg0).put(getObject(arg1), getObject(arg2));
2441
- return addHeapObject(ret);
2442
- }, arguments);
2443
- };
2444
- imports.wbg.__wbg_target_2fc177e386c8b7b0 = function(arg0) {
2445
- const ret = getObject(arg0).target;
2446
- return isLikeNone(ret) ? 0 : addHeapObject(ret);
2447
- };
2448
- imports.wbg.__wbg_instanceof_IdbDatabase_db671cf2454a9542 = function(arg0) {
2449
- let result;
2450
- try {
2451
- result = getObject(arg0) instanceof IDBDatabase;
2452
- } catch (_) {
2453
- result = false;
2454
- }
2455
- const ret = result;
2456
- return ret;
2457
- };
2458
- imports.wbg.__wbg_objectStoreNames_588b5924274239fd = function(arg0) {
2459
- const ret = getObject(arg0).objectStoreNames;
2460
- return addHeapObject(ret);
2461
- };
2462
- imports.wbg.__wbg_close_6bfe4ca2fe67cb67 = function(arg0) {
2463
- getObject(arg0).close();
2464
- };
2465
- imports.wbg.__wbg_createObjectStore_882f2f6b1b1ef040 = function() {
2466
- return handleError(function(arg0, arg1, arg2) {
2467
- const ret = getObject(arg0).createObjectStore(getStringFromWasm0(arg1, arg2));
2495
+ const ret = getObject(arg0).createObjectStore(getStringFromWasm0(arg1, arg2));
2468
2496
  return addHeapObject(ret);
2469
2497
  }, arguments);
2470
2498
  };
@@ -2480,147 +2508,112 @@ function __wbg_get_imports() {
2480
2508
  return addHeapObject(ret);
2481
2509
  }, arguments);
2482
2510
  };
2483
- imports.wbg.__wbg_objectStore_da468793bd9df17b = function() {
2484
- return handleError(function(arg0, arg1, arg2) {
2485
- const ret = getObject(arg0).objectStore(getStringFromWasm0(arg1, arg2));
2486
- return addHeapObject(ret);
2487
- }, arguments);
2511
+ imports.wbg.__wbg_close_6bfe4ca2fe67cb67 = function(arg0) {
2512
+ getObject(arg0).close();
2488
2513
  };
2489
- imports.wbg.__wbg_instanceof_IdbCursor_e572a9900478e938 = function(arg0) {
2514
+ imports.wbg.__wbg_instanceof_IdbDatabase_db671cf2454a9542 = function(arg0) {
2490
2515
  let result;
2491
2516
  try {
2492
- result = getObject(arg0) instanceof IDBCursor;
2517
+ result = getObject(arg0) instanceof IDBDatabase;
2493
2518
  } catch (_) {
2494
2519
  result = false;
2495
2520
  }
2496
2521
  const ret = result;
2497
2522
  return ret;
2498
2523
  };
2499
- imports.wbg.__wbg_primaryKey_ac28363943d108c5 = function() {
2524
+ imports.wbg.__wbg_openCursor_30d58ae27a327629 = function() {
2500
2525
  return handleError(function(arg0) {
2501
- const ret = getObject(arg0).primaryKey;
2526
+ const ret = getObject(arg0).openCursor();
2502
2527
  return addHeapObject(ret);
2503
2528
  }, arguments);
2504
2529
  };
2505
- imports.wbg.__wbg_continue_f1c3e0815924de62 = function() {
2506
- return handleError(function(arg0) {
2507
- getObject(arg0).continue();
2530
+ imports.wbg.__wbg_put_22792e17580ca18b = function() {
2531
+ return handleError(function(arg0, arg1, arg2) {
2532
+ const ret = getObject(arg0).put(getObject(arg1), getObject(arg2));
2533
+ return addHeapObject(ret);
2508
2534
  }, arguments);
2509
2535
  };
2510
- imports.wbg.__wbg_length_9ae5daf9a690cba9 = function(arg0) {
2511
- const ret = getObject(arg0).length;
2512
- return ret;
2513
- };
2514
- imports.wbg.__wbg_contains_c65b44400b549286 = function(arg0, arg1, arg2) {
2515
- const ret = getObject(arg0).contains(getStringFromWasm0(arg1, arg2));
2516
- return ret;
2517
- };
2518
- imports.wbg.__wbg_get_910bbb94abdcf488 = function(arg0, arg1, arg2) {
2519
- const ret = getObject(arg1)[arg2 >>> 0];
2520
- var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2521
- var len1 = WASM_VECTOR_LEN;
2522
- getInt32Memory0()[arg0 / 4 + 1] = len1;
2523
- getInt32Memory0()[arg0 / 4 + 0] = ptr1;
2524
- };
2525
- imports.wbg.__wbg_instanceof_IdbCursorWithValue_abeb44d13d947bc2 = function(arg0) {
2526
- let result;
2527
- try {
2528
- result = getObject(arg0) instanceof IDBCursorWithValue;
2529
- } catch (_) {
2530
- result = false;
2531
- }
2532
- const ret = result;
2533
- return ret;
2534
- };
2535
- imports.wbg.__wbg_value_86d3334f5075b232 = function() {
2536
- return handleError(function(arg0) {
2537
- const ret = getObject(arg0).value;
2536
+ imports.wbg.__wbg_openCursor_611b1e488c393dd8 = function() {
2537
+ return handleError(function(arg0, arg1) {
2538
+ const ret = getObject(arg0).openCursor(getObject(arg1));
2538
2539
  return addHeapObject(ret);
2539
2540
  }, arguments);
2540
2541
  };
2541
- imports.wbg.__wbg_open_f0d7259fd7e689ce = function() {
2542
- return handleError(function(arg0, arg1, arg2, arg3) {
2543
- const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2), arg3 >>> 0);
2542
+ imports.wbg.__wbg_get_5361b64cac0d0826 = function() {
2543
+ return handleError(function(arg0, arg1) {
2544
+ const ret = getObject(arg0).get(getObject(arg1));
2544
2545
  return addHeapObject(ret);
2545
2546
  }, arguments);
2546
2547
  };
2547
- imports.wbg.__wbg_bound_25385469508e98c7 = function() {
2548
- return handleError(function(arg0, arg1, arg2, arg3) {
2549
- const ret = IDBKeyRange.bound(getObject(arg0), getObject(arg1), arg2 !== 0, arg3 !== 0);
2548
+ imports.wbg.__wbg_createIndex_b8da1f5571f644be = function() {
2549
+ return handleError(function(arg0, arg1, arg2, arg3, arg4, arg5) {
2550
+ const ret = getObject(arg0).createIndex(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4), getObject(arg5));
2550
2551
  return addHeapObject(ret);
2551
2552
  }, arguments);
2552
2553
  };
2553
- imports.wbg.__wbg_lowerBound_cd1c8a3b3fdf1582 = function() {
2554
- return handleError(function(arg0) {
2555
- const ret = IDBKeyRange.lowerBound(getObject(arg0));
2554
+ imports.wbg.__wbg_index_383b6812c1508030 = function() {
2555
+ return handleError(function(arg0, arg1, arg2) {
2556
+ const ret = getObject(arg0).index(getStringFromWasm0(arg1, arg2));
2556
2557
  return addHeapObject(ret);
2557
2558
  }, arguments);
2558
2559
  };
2559
- imports.wbg.__wbg_lowerBound_e77f6e14cb69151e = function() {
2560
+ imports.wbg.__wbg_delete_f60bba7d0ae59a4f = function() {
2560
2561
  return handleError(function(arg0, arg1) {
2561
- const ret = IDBKeyRange.lowerBound(getObject(arg0), arg1 !== 0);
2562
+ const ret = getObject(arg0).delete(getObject(arg1));
2562
2563
  return addHeapObject(ret);
2563
2564
  }, arguments);
2564
2565
  };
2565
- imports.wbg.__wbg_only_cacf767244bdc280 = function() {
2566
- return handleError(function(arg0) {
2567
- const ret = IDBKeyRange.only(getObject(arg0));
2568
- return addHeapObject(ret);
2569
- }, arguments);
2566
+ imports.wbg.__wbg_target_2fc177e386c8b7b0 = function(arg0) {
2567
+ const ret = getObject(arg0).target;
2568
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
2570
2569
  };
2571
- imports.wbg.__wbg_upperBound_1e3077b2c05bdd71 = function() {
2570
+ imports.wbg.__wbg_setonerror_8479b33e7568a904 = function(arg0, arg1) {
2571
+ getObject(arg0).onerror = getObject(arg1);
2572
+ };
2573
+ imports.wbg.__wbg_setonsuccess_632ce0a1460455c2 = function(arg0, arg1) {
2574
+ getObject(arg0).onsuccess = getObject(arg1);
2575
+ };
2576
+ imports.wbg.__wbg_error_685b20024dc2d6ca = function() {
2572
2577
  return handleError(function(arg0) {
2573
- const ret = IDBKeyRange.upperBound(getObject(arg0));
2574
- return addHeapObject(ret);
2578
+ const ret = getObject(arg0).error;
2579
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
2575
2580
  }, arguments);
2576
2581
  };
2577
- imports.wbg.__wbg_upperBound_4c692da072d1a11e = function() {
2578
- return handleError(function(arg0, arg1) {
2579
- const ret = IDBKeyRange.upperBound(getObject(arg0), arg1 !== 0);
2582
+ imports.wbg.__wbg_result_6cedf5f78600a79c = function() {
2583
+ return handleError(function(arg0) {
2584
+ const ret = getObject(arg0).result;
2580
2585
  return addHeapObject(ret);
2581
2586
  }, arguments);
2582
2587
  };
2583
- imports.wbg.__wbg_instanceof_IdbOpenDbRequest_3f4a166bc0340578 = function(arg0) {
2588
+ imports.wbg.__wbg_instanceof_IdbRequest_93249da04f5370b6 = function(arg0) {
2584
2589
  let result;
2585
2590
  try {
2586
- result = getObject(arg0) instanceof IDBOpenDBRequest;
2591
+ result = getObject(arg0) instanceof IDBRequest;
2587
2592
  } catch (_) {
2588
2593
  result = false;
2589
2594
  }
2590
2595
  const ret = result;
2591
2596
  return ret;
2592
2597
  };
2598
+ imports.wbg.__wbg_objectStore_da468793bd9df17b = function() {
2599
+ return handleError(function(arg0, arg1, arg2) {
2600
+ const ret = getObject(arg0).objectStore(getStringFromWasm0(arg1, arg2));
2601
+ return addHeapObject(ret);
2602
+ }, arguments);
2603
+ };
2593
2604
  imports.wbg.__wbg_setonupgradeneeded_ad7645373c7d5e1b = function(arg0, arg1) {
2594
2605
  getObject(arg0).onupgradeneeded = getObject(arg1);
2595
2606
  };
2596
- imports.wbg.__wbg_instanceof_IdbRequest_93249da04f5370b6 = function(arg0) {
2607
+ imports.wbg.__wbg_instanceof_IdbOpenDbRequest_3f4a166bc0340578 = function(arg0) {
2597
2608
  let result;
2598
2609
  try {
2599
- result = getObject(arg0) instanceof IDBRequest;
2610
+ result = getObject(arg0) instanceof IDBOpenDBRequest;
2600
2611
  } catch (_) {
2601
2612
  result = false;
2602
2613
  }
2603
2614
  const ret = result;
2604
2615
  return ret;
2605
2616
  };
2606
- imports.wbg.__wbg_result_6cedf5f78600a79c = function() {
2607
- return handleError(function(arg0) {
2608
- const ret = getObject(arg0).result;
2609
- return addHeapObject(ret);
2610
- }, arguments);
2611
- };
2612
- imports.wbg.__wbg_error_685b20024dc2d6ca = function() {
2613
- return handleError(function(arg0) {
2614
- const ret = getObject(arg0).error;
2615
- return isLikeNone(ret) ? 0 : addHeapObject(ret);
2616
- }, arguments);
2617
- };
2618
- imports.wbg.__wbg_setonsuccess_632ce0a1460455c2 = function(arg0, arg1) {
2619
- getObject(arg0).onsuccess = getObject(arg1);
2620
- };
2621
- imports.wbg.__wbg_setonerror_8479b33e7568a904 = function(arg0, arg1) {
2622
- getObject(arg0).onerror = getObject(arg1);
2623
- };
2624
2617
  imports.wbg.__wbindgen_jsval_loose_eq = function(arg0, arg1) {
2625
2618
  const ret = getObject(arg0) == getObject(arg1);
2626
2619
  return ret;
@@ -2629,13 +2622,6 @@ function __wbg_get_imports() {
2629
2622
  const ret = +getObject(arg0);
2630
2623
  return ret;
2631
2624
  };
2632
- imports.wbg.__wbg_String_389b54bd9d25375f = function(arg0, arg1) {
2633
- const ret = String(getObject(arg1));
2634
- const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2635
- const len1 = WASM_VECTOR_LEN;
2636
- getInt32Memory0()[arg0 / 4 + 1] = len1;
2637
- getInt32Memory0()[arg0 / 4 + 0] = ptr1;
2638
- };
2639
2625
  imports.wbg.__wbg_getwithrefkey_4a92a5eca60879b9 = function(arg0, arg1) {
2640
2626
  const ret = getObject(arg0)[getObject(arg1)];
2641
2627
  return addHeapObject(ret);
@@ -2643,22 +2629,15 @@ function __wbg_get_imports() {
2643
2629
  imports.wbg.__wbg_set_9182712abebf82ef = function(arg0, arg1, arg2) {
2644
2630
  getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
2645
2631
  };
2646
- imports.wbg.__wbg_log_28eee4e6432efd24 = function(arg0, arg1) {
2647
- console.log(getStringFromWasm0(arg0, arg1));
2648
- };
2649
- imports.wbg.__wbg_String_55b8bdc4bc243677 = function(arg0, arg1) {
2632
+ imports.wbg.__wbg_String_389b54bd9d25375f = function(arg0, arg1) {
2650
2633
  const ret = String(getObject(arg1));
2651
2634
  const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2652
2635
  const len1 = WASM_VECTOR_LEN;
2653
2636
  getInt32Memory0()[arg0 / 4 + 1] = len1;
2654
2637
  getInt32Memory0()[arg0 / 4 + 0] = ptr1;
2655
2638
  };
2656
- imports.wbg.__wbg_getElementById_8458f2a6c28467dc = function(arg0, arg1, arg2) {
2657
- const ret = getObject(arg0).getElementById(getStringFromWasm0(arg1, arg2));
2658
- return addHeapObject(ret);
2659
- };
2660
- imports.wbg.__wbg_settextcontent_fc3ff485b96fcb1d = function(arg0, arg1, arg2) {
2661
- getObject(arg0).textContent = getStringFromWasm0(arg1, arg2);
2639
+ imports.wbg.__wbg_log_28eee4e6432efd24 = function(arg0, arg1) {
2640
+ console.log(getStringFromWasm0(arg0, arg1));
2662
2641
  };
2663
2642
  imports.wbg.__wbg_wbgtestinvoke_8c20f4132af2bded = function() {
2664
2643
  return handleError(function(arg0, arg1) {
@@ -2668,7 +2647,7 @@ function __wbg_get_imports() {
2668
2647
  const a = state0.a;
2669
2648
  state0.a = 0;
2670
2649
  try {
2671
- return __wbg_adapter_304(a, state0.b);
2650
+ return __wbg_adapter_287(a, state0.b);
2672
2651
  } finally {
2673
2652
  state0.a = a;
2674
2653
  }
@@ -2679,13 +2658,20 @@ function __wbg_get_imports() {
2679
2658
  }
2680
2659
  }, arguments);
2681
2660
  };
2682
- imports.wbg.__wbg_wbgtestoutputwriteln_4db3bd64914ec955 = function(arg0) {
2683
- __wbg_test_output_writeln(takeObject(arg0));
2684
- };
2685
- imports.wbg.__wbg_stack_436273c21658169b = function(arg0) {
2686
- const ret = getObject(arg0).stack;
2661
+ imports.wbg.__wbg_getElementById_8458f2a6c28467dc = function(arg0, arg1, arg2) {
2662
+ const ret = getObject(arg0).getElementById(getStringFromWasm0(arg1, arg2));
2687
2663
  return addHeapObject(ret);
2688
2664
  };
2665
+ imports.wbg.__wbg_settextcontent_fc3ff485b96fcb1d = function(arg0, arg1, arg2) {
2666
+ getObject(arg0).textContent = getStringFromWasm0(arg1, arg2);
2667
+ };
2668
+ imports.wbg.__wbg_String_55b8bdc4bc243677 = function(arg0, arg1) {
2669
+ const ret = String(getObject(arg1));
2670
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2671
+ const len1 = WASM_VECTOR_LEN;
2672
+ getInt32Memory0()[arg0 / 4 + 1] = len1;
2673
+ getInt32Memory0()[arg0 / 4 + 0] = ptr1;
2674
+ };
2689
2675
  imports.wbg.__wbg_self_55106357ec10ecd4 = function(arg0) {
2690
2676
  const ret = getObject(arg0).self;
2691
2677
  return isLikeNone(ret) ? 0 : addHeapObject(ret);
@@ -2701,8 +2687,12 @@ function __wbg_get_imports() {
2701
2687
  getInt32Memory0()[arg0 / 4 + 1] = len1;
2702
2688
  getInt32Memory0()[arg0 / 4 + 0] = ptr1;
2703
2689
  };
2704
- imports.wbg.__wbg_textcontent_67e4e811cbdf00fc = function(arg0, arg1) {
2705
- const ret = getObject(arg1).textContent;
2690
+ imports.wbg.__wbg_static_accessor_document_d4b6ae7f5578480f = function() {
2691
+ const ret = document;
2692
+ return addHeapObject(ret);
2693
+ };
2694
+ imports.wbg.__wbg_stack_17c77e9f5bfe6714 = function(arg0, arg1) {
2695
+ const ret = getObject(arg1).stack;
2706
2696
  const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2707
2697
  const len1 = WASM_VECTOR_LEN;
2708
2698
  getInt32Memory0()[arg0 / 4 + 1] = len1;
@@ -2712,17 +2702,20 @@ function __wbg_get_imports() {
2712
2702
  const ret = getObject(arg0).stack;
2713
2703
  return addHeapObject(ret);
2714
2704
  };
2715
- imports.wbg.__wbg_static_accessor_document_d4b6ae7f5578480f = function() {
2716
- const ret = document;
2717
- return addHeapObject(ret);
2718
- };
2719
- imports.wbg.__wbg_stack_17c77e9f5bfe6714 = function(arg0, arg1) {
2720
- const ret = getObject(arg1).stack;
2705
+ imports.wbg.__wbg_textcontent_67e4e811cbdf00fc = function(arg0, arg1) {
2706
+ const ret = getObject(arg1).textContent;
2721
2707
  const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2722
2708
  const len1 = WASM_VECTOR_LEN;
2723
2709
  getInt32Memory0()[arg0 / 4 + 1] = len1;
2724
2710
  getInt32Memory0()[arg0 / 4 + 0] = ptr1;
2725
2711
  };
2712
+ imports.wbg.__wbg_stack_436273c21658169b = function(arg0) {
2713
+ const ret = getObject(arg0).stack;
2714
+ return addHeapObject(ret);
2715
+ };
2716
+ imports.wbg.__wbg_wbgtestoutputwriteln_4db3bd64914ec955 = function(arg0) {
2717
+ __wbg_test_output_writeln(takeObject(arg0));
2718
+ };
2726
2719
  imports.wbg.__wbg_new_abda76e883ba8a5f = function() {
2727
2720
  const ret = new Error();
2728
2721
  return addHeapObject(ret);
@@ -2745,94 +2738,113 @@ function __wbg_get_imports() {
2745
2738
  wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
2746
2739
  }
2747
2740
  };
2748
- imports.wbg.__wbg_queueMicrotask_3cbae2ec6b6cd3d6 = function(arg0) {
2749
- const ret = getObject(arg0).queueMicrotask;
2750
- return addHeapObject(ret);
2751
- };
2752
2741
  imports.wbg.__wbg_queueMicrotask_481971b0d87f3dd4 = function(arg0) {
2753
2742
  queueMicrotask(getObject(arg0));
2754
2743
  };
2755
- imports.wbg.__wbg_get_bd8e338fbd5f5cc8 = function(arg0, arg1) {
2756
- const ret = getObject(arg0)[arg1 >>> 0];
2744
+ imports.wbg.__wbg_queueMicrotask_3cbae2ec6b6cd3d6 = function(arg0) {
2745
+ const ret = getObject(arg0).queueMicrotask;
2757
2746
  return addHeapObject(ret);
2758
2747
  };
2759
- imports.wbg.__wbg_length_cd7af8117672b8b8 = function(arg0) {
2760
- const ret = getObject(arg0).length;
2761
- return ret;
2748
+ imports.wbg.__wbg_new_d9bc3a0147634640 = function() {
2749
+ const ret = /* @__PURE__ */ new Map();
2750
+ return addHeapObject(ret);
2762
2751
  };
2763
2752
  imports.wbg.__wbg_new_16b304a2cfa7ff4a = function() {
2764
2753
  const ret = new Array();
2765
2754
  return addHeapObject(ret);
2766
2755
  };
2756
+ imports.wbg.__wbg_new_72fb9a18b5ae2624 = function() {
2757
+ const ret = new Object();
2758
+ return addHeapObject(ret);
2759
+ };
2767
2760
  imports.wbg.__wbg_newnoargs_e258087cd0daa0ea = function(arg0, arg1) {
2768
2761
  const ret = new Function(getStringFromWasm0(arg0, arg1));
2769
2762
  return addHeapObject(ret);
2770
2763
  };
2771
- imports.wbg.__wbg_new_d9bc3a0147634640 = function() {
2772
- const ret = /* @__PURE__ */ new Map();
2764
+ imports.wbg.__wbg_new_63b92bc8671ed464 = function(arg0) {
2765
+ const ret = new Uint8Array(getObject(arg0));
2773
2766
  return addHeapObject(ret);
2774
2767
  };
2775
- imports.wbg.__wbg_next_40fc327bfc8770e6 = function(arg0) {
2776
- const ret = getObject(arg0).next;
2768
+ imports.wbg.__wbg_buffer_12d079cc21e14bdb = function(arg0) {
2769
+ const ret = getObject(arg0).buffer;
2777
2770
  return addHeapObject(ret);
2778
2771
  };
2779
- imports.wbg.__wbg_next_196c84450b364254 = function() {
2780
- return handleError(function(arg0) {
2781
- const ret = getObject(arg0).next();
2782
- return addHeapObject(ret);
2783
- }, arguments);
2784
- };
2785
- imports.wbg.__wbg_done_298b57d23c0fc80c = function(arg0) {
2786
- const ret = getObject(arg0).done;
2787
- return ret;
2772
+ imports.wbg.__wbg_newwithbyteoffsetandlength_aa4a17c33a06e5cb = function(arg0, arg1, arg2) {
2773
+ const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
2774
+ return addHeapObject(ret);
2788
2775
  };
2789
- imports.wbg.__wbg_value_d93c65011f51a456 = function(arg0) {
2790
- const ret = getObject(arg0).value;
2776
+ imports.wbg.__wbg_newwithlength_e9b4878cebadb3d3 = function(arg0) {
2777
+ const ret = new Uint8Array(arg0 >>> 0);
2791
2778
  return addHeapObject(ret);
2792
2779
  };
2793
- imports.wbg.__wbg_iterator_2cee6dadfd956dfa = function() {
2794
- const ret = Symbol.iterator;
2780
+ imports.wbg.__wbg_set_a47bac70306a19a7 = function(arg0, arg1, arg2) {
2781
+ getObject(arg0).set(getObject(arg1), arg2 >>> 0);
2782
+ };
2783
+ imports.wbg.__wbg_length_c20a40f15020d68a = function(arg0) {
2784
+ const ret = getObject(arg0).length;
2785
+ return ret;
2786
+ };
2787
+ imports.wbg.__wbg_subarray_a1f73cd4b5b42fe1 = function(arg0, arg1, arg2) {
2788
+ const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
2795
2789
  return addHeapObject(ret);
2796
2790
  };
2797
- imports.wbg.__wbg_get_e3c254076557e348 = function() {
2798
- return handleError(function(arg0, arg1) {
2799
- const ret = Reflect.get(getObject(arg0), getObject(arg1));
2800
- return addHeapObject(ret);
2801
- }, arguments);
2791
+ imports.wbg.__wbg_done_298b57d23c0fc80c = function(arg0) {
2792
+ const ret = getObject(arg0).done;
2793
+ return ret;
2802
2794
  };
2803
- imports.wbg.__wbg_call_27c0f87801dedf93 = function() {
2804
- return handleError(function(arg0, arg1) {
2805
- const ret = getObject(arg0).call(getObject(arg1));
2806
- return addHeapObject(ret);
2807
- }, arguments);
2795
+ imports.wbg.__wbg_value_d93c65011f51a456 = function(arg0) {
2796
+ const ret = getObject(arg0).value;
2797
+ return addHeapObject(ret);
2808
2798
  };
2809
- imports.wbg.__wbg_new_72fb9a18b5ae2624 = function() {
2810
- const ret = new Object();
2799
+ imports.wbg.__wbg_instanceof_Object_71ca3c0a59266746 = function(arg0) {
2800
+ let result;
2801
+ try {
2802
+ result = getObject(arg0) instanceof Object;
2803
+ } catch (_) {
2804
+ result = false;
2805
+ }
2806
+ const ret = result;
2807
+ return ret;
2808
+ };
2809
+ imports.wbg.__wbg_instanceof_Uint8Array_2b3bbecd033d19f6 = function(arg0) {
2810
+ let result;
2811
+ try {
2812
+ result = getObject(arg0) instanceof Uint8Array;
2813
+ } catch (_) {
2814
+ result = false;
2815
+ }
2816
+ const ret = result;
2817
+ return ret;
2818
+ };
2819
+ imports.wbg.__wbg_instanceof_ArrayBuffer_836825be07d4c9d2 = function(arg0) {
2820
+ let result;
2821
+ try {
2822
+ result = getObject(arg0) instanceof ArrayBuffer;
2823
+ } catch (_) {
2824
+ result = false;
2825
+ }
2826
+ const ret = result;
2827
+ return ret;
2828
+ };
2829
+ imports.wbg.__wbg_set_8417257aaedc936b = function(arg0, arg1, arg2) {
2830
+ const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
2811
2831
  return addHeapObject(ret);
2812
2832
  };
2813
- imports.wbg.__wbg_self_ce0dbfc45cf2f5be = function() {
2814
- return handleError(function() {
2815
- const ret = self.self;
2816
- return addHeapObject(ret);
2817
- }, arguments);
2833
+ imports.wbg.__wbg_new0_7d84e5b2cd9fdc73 = function() {
2834
+ const ret = /* @__PURE__ */ new Date();
2835
+ return addHeapObject(ret);
2818
2836
  };
2819
- imports.wbg.__wbg_window_c6fb939a7f436783 = function() {
2820
- return handleError(function() {
2821
- const ret = window.window;
2822
- return addHeapObject(ret);
2823
- }, arguments);
2837
+ imports.wbg.__wbg_getTime_2bc4375165f02d15 = function(arg0) {
2838
+ const ret = getObject(arg0).getTime();
2839
+ return ret;
2824
2840
  };
2825
- imports.wbg.__wbg_globalThis_d1e6af4856ba331b = function() {
2826
- return handleError(function() {
2827
- const ret = globalThis.globalThis;
2828
- return addHeapObject(ret);
2829
- }, arguments);
2841
+ imports.wbg.__wbg_get_bd8e338fbd5f5cc8 = function(arg0, arg1) {
2842
+ const ret = getObject(arg0)[arg1 >>> 0];
2843
+ return addHeapObject(ret);
2830
2844
  };
2831
- imports.wbg.__wbg_global_207b558942527489 = function() {
2832
- return handleError(function() {
2833
- const ret = global.global;
2834
- return addHeapObject(ret);
2835
- }, arguments);
2845
+ imports.wbg.__wbg_of_4a2b313a453ec059 = function(arg0) {
2846
+ const ret = Array.of(getObject(arg0));
2847
+ return addHeapObject(ret);
2836
2848
  };
2837
2849
  imports.wbg.__wbg_set_d4638f722068f043 = function(arg0, arg1, arg2) {
2838
2850
  getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
@@ -2841,6 +2853,14 @@ function __wbg_get_imports() {
2841
2853
  const ret = Array.from(getObject(arg0));
2842
2854
  return addHeapObject(ret);
2843
2855
  };
2856
+ imports.wbg.__wbg_length_cd7af8117672b8b8 = function(arg0) {
2857
+ const ret = getObject(arg0).length;
2858
+ return ret;
2859
+ };
2860
+ imports.wbg.__wbg_push_a5b05aedc7234f9f = function(arg0, arg1) {
2861
+ const ret = getObject(arg0).push(getObject(arg1));
2862
+ return ret;
2863
+ };
2844
2864
  imports.wbg.__wbg_forEach_2be8de7347d63332 = function(arg0, arg1, arg2) {
2845
2865
  try {
2846
2866
  var state0 = { a: arg1, b: arg2 };
@@ -2848,7 +2868,7 @@ function __wbg_get_imports() {
2848
2868
  const a = state0.a;
2849
2869
  state0.a = 0;
2850
2870
  try {
2851
- return __wbg_adapter_347(a, state0.b, arg02, arg12, arg22);
2871
+ return __wbg_adapter_378(a, state0.b, arg02, arg12, arg22);
2852
2872
  } finally {
2853
2873
  state0.a = a;
2854
2874
  }
@@ -2862,70 +2882,26 @@ function __wbg_get_imports() {
2862
2882
  const ret = Array.isArray(getObject(arg0));
2863
2883
  return ret;
2864
2884
  };
2865
- imports.wbg.__wbg_of_4a2b313a453ec059 = function(arg0) {
2866
- const ret = Array.of(getObject(arg0));
2867
- return addHeapObject(ret);
2868
- };
2869
- imports.wbg.__wbg_push_a5b05aedc7234f9f = function(arg0, arg1) {
2870
- const ret = getObject(arg0).push(getObject(arg1));
2871
- return ret;
2872
- };
2873
- imports.wbg.__wbg_instanceof_ArrayBuffer_836825be07d4c9d2 = function(arg0) {
2874
- let result;
2875
- try {
2876
- result = getObject(arg0) instanceof ArrayBuffer;
2877
- } catch (_) {
2878
- result = false;
2879
- }
2880
- const ret = result;
2881
- return ret;
2882
- };
2883
- imports.wbg.__wbg_message_5bf28016c2b49cfb = function(arg0) {
2884
- const ret = getObject(arg0).message;
2885
- return addHeapObject(ret);
2886
- };
2887
2885
  imports.wbg.__wbg_name_e7429f0dda6079e2 = function(arg0) {
2888
2886
  const ret = getObject(arg0).name;
2889
2887
  return addHeapObject(ret);
2890
2888
  };
2891
- imports.wbg.__wbg_call_b3ca7c6051f9bec1 = function() {
2892
- return handleError(function(arg0, arg1, arg2) {
2893
- const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
2894
- return addHeapObject(ret);
2895
- }, arguments);
2896
- };
2897
- imports.wbg.__wbg_call_938992c832f74314 = function() {
2898
- return handleError(function(arg0, arg1, arg2, arg3, arg4) {
2899
- const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3), getObject(arg4));
2900
- return addHeapObject(ret);
2901
- }, arguments);
2902
- };
2903
- imports.wbg.__wbg_set_8417257aaedc936b = function(arg0, arg1, arg2) {
2904
- const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
2889
+ imports.wbg.__wbg_message_5bf28016c2b49cfb = function(arg0) {
2890
+ const ret = getObject(arg0).message;
2905
2891
  return addHeapObject(ret);
2906
2892
  };
2907
2893
  imports.wbg.__wbg_isSafeInteger_f7b04ef02296c4d2 = function(arg0) {
2908
2894
  const ret = Number.isSafeInteger(getObject(arg0));
2909
2895
  return ret;
2910
2896
  };
2911
- imports.wbg.__wbg_getTime_2bc4375165f02d15 = function(arg0) {
2912
- const ret = getObject(arg0).getTime();
2897
+ imports.wbg.__wbg_is_010fdc0f4ab96916 = function(arg0, arg1) {
2898
+ const ret = Object.is(getObject(arg0), getObject(arg1));
2913
2899
  return ret;
2914
2900
  };
2915
- imports.wbg.__wbg_new0_7d84e5b2cd9fdc73 = function() {
2916
- const ret = /* @__PURE__ */ new Date();
2901
+ imports.wbg.__wbg_keys_91e412b4b222659f = function(arg0) {
2902
+ const ret = Object.keys(getObject(arg0));
2917
2903
  return addHeapObject(ret);
2918
2904
  };
2919
- imports.wbg.__wbg_instanceof_Object_71ca3c0a59266746 = function(arg0) {
2920
- let result;
2921
- try {
2922
- result = getObject(arg0) instanceof Object;
2923
- } catch (_) {
2924
- result = false;
2925
- }
2926
- const ret = result;
2927
- return ret;
2928
- };
2929
2905
  imports.wbg.__wbg_assign_496d2d14fecafbcf = function(arg0, arg1) {
2930
2906
  const ret = Object.assign(getObject(arg0), getObject(arg1));
2931
2907
  return addHeapObject(ret);
@@ -2934,14 +2910,40 @@ function __wbg_get_imports() {
2934
2910
  const ret = Object.entries(getObject(arg0));
2935
2911
  return addHeapObject(ret);
2936
2912
  };
2937
- imports.wbg.__wbg_is_010fdc0f4ab96916 = function(arg0, arg1) {
2938
- const ret = Object.is(getObject(arg0), getObject(arg1));
2939
- return ret;
2940
- };
2941
- imports.wbg.__wbg_keys_91e412b4b222659f = function(arg0) {
2942
- const ret = Object.keys(getObject(arg0));
2913
+ imports.wbg.__wbg_iterator_2cee6dadfd956dfa = function() {
2914
+ const ret = Symbol.iterator;
2943
2915
  return addHeapObject(ret);
2944
2916
  };
2917
+ imports.wbg.__wbg_self_ce0dbfc45cf2f5be = function() {
2918
+ return handleError(function() {
2919
+ const ret = self.self;
2920
+ return addHeapObject(ret);
2921
+ }, arguments);
2922
+ };
2923
+ imports.wbg.__wbg_window_c6fb939a7f436783 = function() {
2924
+ return handleError(function() {
2925
+ const ret = window.window;
2926
+ return addHeapObject(ret);
2927
+ }, arguments);
2928
+ };
2929
+ imports.wbg.__wbg_globalThis_d1e6af4856ba331b = function() {
2930
+ return handleError(function() {
2931
+ const ret = globalThis.globalThis;
2932
+ return addHeapObject(ret);
2933
+ }, arguments);
2934
+ };
2935
+ imports.wbg.__wbg_global_207b558942527489 = function() {
2936
+ return handleError(function() {
2937
+ const ret = global.global;
2938
+ return addHeapObject(ret);
2939
+ }, arguments);
2940
+ };
2941
+ imports.wbg.__wbg_call_27c0f87801dedf93 = function() {
2942
+ return handleError(function(arg0, arg1) {
2943
+ const ret = getObject(arg0).call(getObject(arg1));
2944
+ return addHeapObject(ret);
2945
+ }, arguments);
2946
+ };
2945
2947
  imports.wbg.__wbg_new_81740750da40724f = function(arg0, arg1) {
2946
2948
  try {
2947
2949
  var state0 = { a: arg0, b: arg1 };
@@ -2949,7 +2951,7 @@ function __wbg_get_imports() {
2949
2951
  const a = state0.a;
2950
2952
  state0.a = 0;
2951
2953
  try {
2952
- return __wbg_adapter_404(a, state0.b, arg02, arg12);
2954
+ return __wbg_adapter_395(a, state0.b, arg02, arg12);
2953
2955
  } finally {
2954
2956
  state0.a = a;
2955
2957
  }
@@ -2960,10 +2962,6 @@ function __wbg_get_imports() {
2960
2962
  state0.a = state0.b = 0;
2961
2963
  }
2962
2964
  };
2963
- imports.wbg.__wbg_resolve_b0083a7967828ec8 = function(arg0) {
2964
- const ret = Promise.resolve(getObject(arg0));
2965
- return addHeapObject(ret);
2966
- };
2967
2965
  imports.wbg.__wbg_then_0c86a60e8fcfe9f6 = function(arg0, arg1) {
2968
2966
  const ret = getObject(arg0).then(getObject(arg1));
2969
2967
  return addHeapObject(ret);
@@ -2972,46 +2970,47 @@ function __wbg_get_imports() {
2972
2970
  const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
2973
2971
  return addHeapObject(ret);
2974
2972
  };
2975
- imports.wbg.__wbg_buffer_12d079cc21e14bdb = function(arg0) {
2976
- const ret = getObject(arg0).buffer;
2977
- return addHeapObject(ret);
2978
- };
2979
- imports.wbg.__wbg_newwithbyteoffsetandlength_aa4a17c33a06e5cb = function(arg0, arg1, arg2) {
2980
- const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
2973
+ imports.wbg.__wbg_resolve_b0083a7967828ec8 = function(arg0) {
2974
+ const ret = Promise.resolve(getObject(arg0));
2981
2975
  return addHeapObject(ret);
2982
2976
  };
2983
- imports.wbg.__wbg_new_63b92bc8671ed464 = function(arg0) {
2984
- const ret = new Uint8Array(getObject(arg0));
2985
- return addHeapObject(ret);
2977
+ imports.wbg.__wbg_call_b3ca7c6051f9bec1 = function() {
2978
+ return handleError(function(arg0, arg1, arg2) {
2979
+ const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
2980
+ return addHeapObject(ret);
2981
+ }, arguments);
2986
2982
  };
2987
- imports.wbg.__wbg_set_a47bac70306a19a7 = function(arg0, arg1, arg2) {
2988
- getObject(arg0).set(getObject(arg1), arg2 >>> 0);
2983
+ imports.wbg.__wbg_call_938992c832f74314 = function() {
2984
+ return handleError(function(arg0, arg1, arg2, arg3, arg4) {
2985
+ const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3), getObject(arg4));
2986
+ return addHeapObject(ret);
2987
+ }, arguments);
2989
2988
  };
2990
- imports.wbg.__wbg_length_c20a40f15020d68a = function(arg0) {
2991
- const ret = getObject(arg0).length;
2992
- return ret;
2989
+ imports.wbg.__wbg_next_40fc327bfc8770e6 = function(arg0) {
2990
+ const ret = getObject(arg0).next;
2991
+ return addHeapObject(ret);
2993
2992
  };
2994
- imports.wbg.__wbg_instanceof_Uint8Array_2b3bbecd033d19f6 = function(arg0) {
2995
- let result;
2996
- try {
2997
- result = getObject(arg0) instanceof Uint8Array;
2998
- } catch (_) {
2999
- result = false;
3000
- }
3001
- const ret = result;
3002
- return ret;
2993
+ imports.wbg.__wbg_next_196c84450b364254 = function() {
2994
+ return handleError(function(arg0) {
2995
+ const ret = getObject(arg0).next();
2996
+ return addHeapObject(ret);
2997
+ }, arguments);
3003
2998
  };
3004
- imports.wbg.__wbg_newwithlength_e9b4878cebadb3d3 = function(arg0) {
3005
- const ret = new Uint8Array(arg0 >>> 0);
3006
- return addHeapObject(ret);
2999
+ imports.wbg.__wbg_get_e3c254076557e348 = function() {
3000
+ return handleError(function(arg0, arg1) {
3001
+ const ret = Reflect.get(getObject(arg0), getObject(arg1));
3002
+ return addHeapObject(ret);
3003
+ }, arguments);
3007
3004
  };
3008
- imports.wbg.__wbg_subarray_a1f73cd4b5b42fe1 = function(arg0, arg1, arg2) {
3009
- const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
3010
- return addHeapObject(ret);
3005
+ imports.wbg.__wbg_parse_66d1801634e099ac = function() {
3006
+ return handleError(function(arg0, arg1) {
3007
+ const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
3008
+ return addHeapObject(ret);
3009
+ }, arguments);
3011
3010
  };
3012
- imports.wbg.__wbg_apply_0a5aa603881e6d79 = function() {
3013
- return handleError(function(arg0, arg1, arg2) {
3014
- const ret = Reflect.apply(getObject(arg0), getObject(arg1), getObject(arg2));
3011
+ imports.wbg.__wbg_stringify_8887fe74e1c50d81 = function() {
3012
+ return handleError(function(arg0) {
3013
+ const ret = JSON.stringify(getObject(arg0));
3015
3014
  return addHeapObject(ret);
3016
3015
  }, arguments);
3017
3016
  };
@@ -3033,15 +3032,9 @@ function __wbg_get_imports() {
3033
3032
  return ret;
3034
3033
  }, arguments);
3035
3034
  };
3036
- imports.wbg.__wbg_parse_66d1801634e099ac = function() {
3037
- return handleError(function(arg0, arg1) {
3038
- const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
3039
- return addHeapObject(ret);
3040
- }, arguments);
3041
- };
3042
- imports.wbg.__wbg_stringify_8887fe74e1c50d81 = function() {
3043
- return handleError(function(arg0) {
3044
- const ret = JSON.stringify(getObject(arg0));
3035
+ imports.wbg.__wbg_apply_0a5aa603881e6d79 = function() {
3036
+ return handleError(function(arg0, arg1, arg2) {
3037
+ const ret = Reflect.apply(getObject(arg0), getObject(arg1), getObject(arg2));
3045
3038
  return addHeapObject(ret);
3046
3039
  }, arguments);
3047
3040
  };
@@ -3051,6 +3044,13 @@ function __wbg_get_imports() {
3051
3044
  getBigInt64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? BigInt(0) : ret;
3052
3045
  getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
3053
3046
  };
3047
+ imports.wbg.__wbindgen_memory = function() {
3048
+ const ret = wasm.memory;
3049
+ return addHeapObject(ret);
3050
+ };
3051
+ imports.wbg.__wbindgen_throw = function(arg0, arg1) {
3052
+ throw new Error(getStringFromWasm0(arg0, arg1));
3053
+ };
3054
3054
  imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
3055
3055
  const ret = debugString(getObject(arg1));
3056
3056
  const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -3058,23 +3058,16 @@ function __wbg_get_imports() {
3058
3058
  getInt32Memory0()[arg0 / 4 + 1] = len1;
3059
3059
  getInt32Memory0()[arg0 / 4 + 0] = ptr1;
3060
3060
  };
3061
- imports.wbg.__wbindgen_throw = function(arg0, arg1) {
3062
- throw new Error(getStringFromWasm0(arg0, arg1));
3063
- };
3064
- imports.wbg.__wbindgen_memory = function() {
3065
- const ret = wasm.memory;
3066
- return addHeapObject(ret);
3067
- };
3068
- imports.wbg.__wbindgen_closure_wrapper504 = function(arg0, arg1, arg2) {
3069
- const ret = makeMutClosure(arg0, arg1, 226, __wbg_adapter_56);
3061
+ imports.wbg.__wbindgen_closure_wrapper515 = function(arg0, arg1, arg2) {
3062
+ const ret = makeMutClosure(arg0, arg1, 181, __wbg_adapter_56);
3070
3063
  return addHeapObject(ret);
3071
3064
  };
3072
- imports.wbg.__wbindgen_closure_wrapper506 = function(arg0, arg1, arg2) {
3073
- const ret = makeClosure(arg0, arg1, 226, __wbg_adapter_59);
3065
+ imports.wbg.__wbindgen_closure_wrapper517 = function(arg0, arg1, arg2) {
3066
+ const ret = makeClosure(arg0, arg1, 181, __wbg_adapter_59);
3074
3067
  return addHeapObject(ret);
3075
3068
  };
3076
- imports.wbg.__wbindgen_closure_wrapper1689 = function(arg0, arg1, arg2) {
3077
- const ret = makeMutClosure(arg0, arg1, 466, __wbg_adapter_62);
3069
+ imports.wbg.__wbindgen_closure_wrapper1702 = function(arg0, arg1, arg2) {
3070
+ const ret = makeMutClosure(arg0, arg1, 465, __wbg_adapter_62);
3078
3071
  return addHeapObject(ret);
3079
3072
  };
3080
3073
  return imports;