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