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