rvlite 0.2.3 → 0.2.5

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/dist/index.js CHANGED
@@ -36,10 +36,503 @@ __export(rvlite_exports, {
36
36
  CypherEngine: () => CypherEngine,
37
37
  RvLite: () => RvLite,
38
38
  RvLiteConfig: () => RvLiteConfig,
39
- default: () => rvlite_default,
39
+ default: () => __wbg_init,
40
40
  init: () => init,
41
41
  initSync: () => initSync
42
42
  });
43
+ function init() {
44
+ wasm.init();
45
+ }
46
+ function __wbg_get_imports() {
47
+ const import0 = {
48
+ __proto__: null,
49
+ __wbg_Error_4577686b3a6d9b3a: function(arg0, arg1) {
50
+ const ret = Error(getStringFromWasm0(arg0, arg1));
51
+ return addHeapObject(ret);
52
+ },
53
+ __wbg_Number_e89e48a2fe1a6355: function(arg0) {
54
+ const ret = Number(getObject(arg0));
55
+ return ret;
56
+ },
57
+ __wbg_String_8564e559799eccda: function(arg0, arg1) {
58
+ const ret = String(getObject(arg1));
59
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
60
+ const len1 = WASM_VECTOR_LEN;
61
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
62
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
63
+ },
64
+ __wbg___wbindgen_bigint_get_as_i64_578010f8442e0319: function(arg0, arg1) {
65
+ const v = getObject(arg1);
66
+ const ret = typeof v === "bigint" ? v : void 0;
67
+ getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
68
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
69
+ },
70
+ __wbg___wbindgen_boolean_get_18c4ed9422296fff: function(arg0) {
71
+ const v = getObject(arg0);
72
+ const ret = typeof v === "boolean" ? v : void 0;
73
+ return isLikeNone(ret) ? 16777215 : ret ? 1 : 0;
74
+ },
75
+ __wbg___wbindgen_debug_string_ddde1867f49c2442: function(arg0, arg1) {
76
+ const ret = debugString(getObject(arg1));
77
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
78
+ const len1 = WASM_VECTOR_LEN;
79
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
80
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
81
+ },
82
+ __wbg___wbindgen_in_1064a108f4d18b9e: function(arg0, arg1) {
83
+ const ret = getObject(arg0) in getObject(arg1);
84
+ return ret;
85
+ },
86
+ __wbg___wbindgen_is_bigint_a157f0734ca85901: function(arg0) {
87
+ const ret = typeof getObject(arg0) === "bigint";
88
+ return ret;
89
+ },
90
+ __wbg___wbindgen_is_function_d633e708baf0d146: function(arg0) {
91
+ const ret = typeof getObject(arg0) === "function";
92
+ return ret;
93
+ },
94
+ __wbg___wbindgen_is_null_a2a19127c13e7126: function(arg0) {
95
+ const ret = getObject(arg0) === null;
96
+ return ret;
97
+ },
98
+ __wbg___wbindgen_is_object_4b3de556756ee8a8: function(arg0) {
99
+ const val = getObject(arg0);
100
+ const ret = typeof val === "object" && val !== null;
101
+ return ret;
102
+ },
103
+ __wbg___wbindgen_is_string_7debe47dc1e045c2: function(arg0) {
104
+ const ret = typeof getObject(arg0) === "string";
105
+ return ret;
106
+ },
107
+ __wbg___wbindgen_is_undefined_c18285b9fc34cb7d: function(arg0) {
108
+ const ret = getObject(arg0) === void 0;
109
+ return ret;
110
+ },
111
+ __wbg___wbindgen_jsval_eq_a6afb59d8c5e78d6: function(arg0, arg1) {
112
+ const ret = getObject(arg0) === getObject(arg1);
113
+ return ret;
114
+ },
115
+ __wbg___wbindgen_jsval_loose_eq_1562ceb9af84e990: function(arg0, arg1) {
116
+ const ret = getObject(arg0) == getObject(arg1);
117
+ return ret;
118
+ },
119
+ __wbg___wbindgen_number_get_5854912275df1894: function(arg0, arg1) {
120
+ const obj = getObject(arg1);
121
+ const ret = typeof obj === "number" ? obj : void 0;
122
+ getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
123
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
124
+ },
125
+ __wbg___wbindgen_string_get_3e5751597f39a112: function(arg0, arg1) {
126
+ const obj = getObject(arg1);
127
+ const ret = typeof obj === "string" ? obj : void 0;
128
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
129
+ var len1 = WASM_VECTOR_LEN;
130
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
131
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
132
+ },
133
+ __wbg___wbindgen_throw_39bc967c0e5a9b58: function(arg0, arg1) {
134
+ throw new Error(getStringFromWasm0(arg0, arg1));
135
+ },
136
+ __wbg__wbg_cb_unref_b6d832240a919168: function(arg0) {
137
+ getObject(arg0)._wbg_cb_unref();
138
+ },
139
+ __wbg_call_08ad0d89caa7cb79: function() {
140
+ return handleError(function(arg0, arg1, arg2) {
141
+ const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
142
+ return addHeapObject(ret);
143
+ }, arguments);
144
+ },
145
+ __wbg_call_73af281463ec8b58: function() {
146
+ return handleError(function(arg0, arg1) {
147
+ const ret = getObject(arg0).call(getObject(arg1));
148
+ return addHeapObject(ret);
149
+ }, arguments);
150
+ },
151
+ __wbg_clear_9b50f7831893d6ec: function() {
152
+ return handleError(function(arg0) {
153
+ const ret = getObject(arg0).clear();
154
+ return addHeapObject(ret);
155
+ }, arguments);
156
+ },
157
+ __wbg_close_88d72cf512fed8bc: function(arg0) {
158
+ getObject(arg0).close();
159
+ },
160
+ __wbg_contains_412524090060514f: function(arg0, arg1, arg2) {
161
+ const ret = getObject(arg0).contains(getStringFromWasm0(arg1, arg2));
162
+ return ret;
163
+ },
164
+ __wbg_count_c0709a30cd0cf55f: function() {
165
+ return handleError(function(arg0, arg1) {
166
+ const ret = getObject(arg0).count(getObject(arg1));
167
+ return addHeapObject(ret);
168
+ }, arguments);
169
+ },
170
+ __wbg_createObjectStore_bfd875621f13f126: function() {
171
+ return handleError(function(arg0, arg1, arg2) {
172
+ const ret = getObject(arg0).createObjectStore(getStringFromWasm0(arg1, arg2));
173
+ return addHeapObject(ret);
174
+ }, arguments);
175
+ },
176
+ __wbg_done_5aad55ec6b1954b1: function(arg0) {
177
+ const ret = getObject(arg0).done;
178
+ return ret;
179
+ },
180
+ __wbg_entries_28d32ba4cd93f5fc: function(arg0) {
181
+ const ret = Object.entries(getObject(arg0));
182
+ return addHeapObject(ret);
183
+ },
184
+ __wbg_error_a6fa202b58aa1cd3: function(arg0, arg1) {
185
+ let deferred0_0;
186
+ let deferred0_1;
187
+ try {
188
+ deferred0_0 = arg0;
189
+ deferred0_1 = arg1;
190
+ console.error(getStringFromWasm0(arg0, arg1));
191
+ } finally {
192
+ wasm.__wbindgen_export4(deferred0_0, deferred0_1, 1);
193
+ }
194
+ },
195
+ __wbg_get_4920fefd3451364b: function() {
196
+ return handleError(function(arg0, arg1) {
197
+ const ret = Reflect.get(getObject(arg0), getObject(arg1));
198
+ return addHeapObject(ret);
199
+ }, arguments);
200
+ },
201
+ __wbg_get_791b26b41a7de3d5: function() {
202
+ return handleError(function(arg0, arg1) {
203
+ const ret = getObject(arg0).get(getObject(arg1));
204
+ return addHeapObject(ret);
205
+ }, arguments);
206
+ },
207
+ __wbg_get_f09c3a16f8848381: function(arg0, arg1) {
208
+ const ret = getObject(arg0)[arg1 >>> 0];
209
+ return addHeapObject(ret);
210
+ },
211
+ __wbg_get_unchecked_3d0f4b91c8eca4f0: function(arg0, arg1) {
212
+ const ret = getObject(arg0)[arg1 >>> 0];
213
+ return addHeapObject(ret);
214
+ },
215
+ __wbg_get_with_ref_key_6412cf3094599694: function(arg0, arg1) {
216
+ const ret = getObject(arg0)[getObject(arg1)];
217
+ return addHeapObject(ret);
218
+ },
219
+ __wbg_indexedDB_f950945d950fbd5e: function() {
220
+ return handleError(function(arg0) {
221
+ const ret = getObject(arg0).indexedDB;
222
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
223
+ }, arguments);
224
+ },
225
+ __wbg_instanceof_ArrayBuffer_15859862b80b732d: function(arg0) {
226
+ let result;
227
+ try {
228
+ result = getObject(arg0) instanceof ArrayBuffer;
229
+ } catch (_) {
230
+ result = false;
231
+ }
232
+ const ret = result;
233
+ return ret;
234
+ },
235
+ __wbg_instanceof_Map_9df16bf25ceb4ecb: function(arg0) {
236
+ let result;
237
+ try {
238
+ result = getObject(arg0) instanceof Map;
239
+ } catch (_) {
240
+ result = false;
241
+ }
242
+ const ret = result;
243
+ return ret;
244
+ },
245
+ __wbg_instanceof_Uint8Array_2240b7046ac16f05: function(arg0) {
246
+ let result;
247
+ try {
248
+ result = getObject(arg0) instanceof Uint8Array;
249
+ } catch (_) {
250
+ result = false;
251
+ }
252
+ const ret = result;
253
+ return ret;
254
+ },
255
+ __wbg_instanceof_Window_4aba49e4d1a12365: function(arg0) {
256
+ let result;
257
+ try {
258
+ result = getObject(arg0) instanceof Window;
259
+ } catch (_) {
260
+ result = false;
261
+ }
262
+ const ret = result;
263
+ return ret;
264
+ },
265
+ __wbg_isArray_fad08a0d12828686: function(arg0) {
266
+ const ret = Array.isArray(getObject(arg0));
267
+ return ret;
268
+ },
269
+ __wbg_isSafeInteger_10e4151eb694e42a: function(arg0) {
270
+ const ret = Number.isSafeInteger(getObject(arg0));
271
+ return ret;
272
+ },
273
+ __wbg_iterator_fc7ad8d33bab9e26: function() {
274
+ const ret = Symbol.iterator;
275
+ return addHeapObject(ret);
276
+ },
277
+ __wbg_length_5855c1f289dfffc1: function(arg0) {
278
+ const ret = getObject(arg0).length;
279
+ return ret;
280
+ },
281
+ __wbg_length_a31e05262e09b7f8: function(arg0) {
282
+ const ret = getObject(arg0).length;
283
+ return ret;
284
+ },
285
+ __wbg_log_3c5e4b64af29e724: function(arg0) {
286
+ console.log(getObject(arg0));
287
+ },
288
+ __wbg_new_09959f7b4c92c246: function(arg0) {
289
+ const ret = new Uint8Array(getObject(arg0));
290
+ return addHeapObject(ret);
291
+ },
292
+ __wbg_new_227d7c05414eb861: function() {
293
+ const ret = new Error();
294
+ return addHeapObject(ret);
295
+ },
296
+ __wbg_new_79ce7968119cfd96: function(arg0, arg1) {
297
+ try {
298
+ var state0 = { a: arg0, b: arg1 };
299
+ var cb0 = (arg02, arg12) => {
300
+ const a = state0.a;
301
+ state0.a = 0;
302
+ try {
303
+ return __wasm_bindgen_func_elem_1407(a, state0.b, arg02, arg12);
304
+ } finally {
305
+ state0.a = a;
306
+ }
307
+ };
308
+ const ret = new Promise(cb0);
309
+ return addHeapObject(ret);
310
+ } finally {
311
+ state0.a = state0.b = 0;
312
+ }
313
+ },
314
+ __wbg_new_92df58a8ec3bfb6b: function() {
315
+ const ret = /* @__PURE__ */ new Map();
316
+ return addHeapObject(ret);
317
+ },
318
+ __wbg_new_cbee8c0d5c479eac: function() {
319
+ const ret = new Array();
320
+ return addHeapObject(ret);
321
+ },
322
+ __wbg_new_ed69e637b553a997: function() {
323
+ const ret = new Object();
324
+ return addHeapObject(ret);
325
+ },
326
+ __wbg_new_typed_8258a0d8488ef2a2: function(arg0, arg1) {
327
+ try {
328
+ var state0 = { a: arg0, b: arg1 };
329
+ var cb0 = (arg02, arg12) => {
330
+ const a = state0.a;
331
+ state0.a = 0;
332
+ try {
333
+ return __wasm_bindgen_func_elem_1407(a, state0.b, arg02, arg12);
334
+ } finally {
335
+ state0.a = a;
336
+ }
337
+ };
338
+ const ret = new Promise(cb0);
339
+ return addHeapObject(ret);
340
+ } finally {
341
+ state0.a = state0.b = 0;
342
+ }
343
+ },
344
+ __wbg_next_a5fe6f328f7affc2: function(arg0) {
345
+ const ret = getObject(arg0).next;
346
+ return addHeapObject(ret);
347
+ },
348
+ __wbg_next_e592122bb4ed4c67: function() {
349
+ return handleError(function(arg0) {
350
+ const ret = getObject(arg0).next();
351
+ return addHeapObject(ret);
352
+ }, arguments);
353
+ },
354
+ __wbg_now_edd718b3004d8631: function() {
355
+ const ret = Date.now();
356
+ return ret;
357
+ },
358
+ __wbg_objectStoreNames_3645b6da2d1f3852: function(arg0) {
359
+ const ret = getObject(arg0).objectStoreNames;
360
+ return addHeapObject(ret);
361
+ },
362
+ __wbg_objectStore_3a6b969b917c6262: function() {
363
+ return handleError(function(arg0, arg1, arg2) {
364
+ const ret = getObject(arg0).objectStore(getStringFromWasm0(arg1, arg2));
365
+ return addHeapObject(ret);
366
+ }, arguments);
367
+ },
368
+ __wbg_open_9badd3c8846fbf11: function() {
369
+ return handleError(function(arg0, arg1, arg2, arg3) {
370
+ const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2), arg3 >>> 0);
371
+ return addHeapObject(ret);
372
+ }, arguments);
373
+ },
374
+ __wbg_parse_6dfe891b5bafb5cd: function() {
375
+ return handleError(function(arg0, arg1) {
376
+ const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
377
+ return addHeapObject(ret);
378
+ }, arguments);
379
+ },
380
+ __wbg_prototypesetcall_f034d444741426c3: function(arg0, arg1, arg2) {
381
+ Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
382
+ },
383
+ __wbg_push_a6f9488ffd3fae3b: function(arg0, arg1) {
384
+ const ret = getObject(arg0).push(getObject(arg1));
385
+ return ret;
386
+ },
387
+ __wbg_put_d86a6833e14a4c3b: function() {
388
+ return handleError(function(arg0, arg1, arg2) {
389
+ const ret = getObject(arg0).put(getObject(arg1), getObject(arg2));
390
+ return addHeapObject(ret);
391
+ }, arguments);
392
+ },
393
+ __wbg_queueMicrotask_2c8dfd1056f24fdc: function(arg0) {
394
+ const ret = getObject(arg0).queueMicrotask;
395
+ return addHeapObject(ret);
396
+ },
397
+ __wbg_queueMicrotask_8985ad63815852e7: function(arg0) {
398
+ queueMicrotask(getObject(arg0));
399
+ },
400
+ __wbg_resolve_5d61e0d10c14730a: function(arg0) {
401
+ const ret = Promise.resolve(getObject(arg0));
402
+ return addHeapObject(ret);
403
+ },
404
+ __wbg_result_aaba1e6bbc5d42c8: function() {
405
+ return handleError(function(arg0) {
406
+ const ret = getObject(arg0).result;
407
+ return addHeapObject(ret);
408
+ }, arguments);
409
+ },
410
+ __wbg_set_4c81cfb5dc3a333c: function(arg0, arg1, arg2) {
411
+ getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
412
+ },
413
+ __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
414
+ getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
415
+ },
416
+ __wbg_set_cfc6de03f990decf: function(arg0, arg1, arg2) {
417
+ const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
418
+ return addHeapObject(ret);
419
+ },
420
+ __wbg_set_onerror_8b43a0b08de76f6d: function(arg0, arg1) {
421
+ getObject(arg0).onerror = getObject(arg1);
422
+ },
423
+ __wbg_set_onsuccess_76214f5146684855: function(arg0, arg1) {
424
+ getObject(arg0).onsuccess = getObject(arg1);
425
+ },
426
+ __wbg_set_onupgradeneeded_74f1c8e9dbd2b70c: function(arg0, arg1) {
427
+ getObject(arg0).onupgradeneeded = getObject(arg1);
428
+ },
429
+ __wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) {
430
+ const ret = getObject(arg1).stack;
431
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
432
+ const len1 = WASM_VECTOR_LEN;
433
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
434
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
435
+ },
436
+ __wbg_static_accessor_GLOBAL_THIS_14325d8cca34bb77: function() {
437
+ const ret = typeof globalThis === "undefined" ? null : globalThis;
438
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
439
+ },
440
+ __wbg_static_accessor_GLOBAL_f3a1e69f9c5a7e8e: function() {
441
+ const ret = typeof global === "undefined" ? null : global;
442
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
443
+ },
444
+ __wbg_static_accessor_SELF_50cdb5b517789aca: function() {
445
+ const ret = typeof self === "undefined" ? null : self;
446
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
447
+ },
448
+ __wbg_static_accessor_WINDOW_d6c4126e4c244380: function() {
449
+ const ret = typeof window === "undefined" ? null : window;
450
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
451
+ },
452
+ __wbg_target_adcfd1353c3de078: function(arg0) {
453
+ const ret = getObject(arg0).target;
454
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
455
+ },
456
+ __wbg_then_d4163530723f56f4: function(arg0, arg1, arg2) {
457
+ const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
458
+ return addHeapObject(ret);
459
+ },
460
+ __wbg_then_f1c954fe00733701: function(arg0, arg1) {
461
+ const ret = getObject(arg0).then(getObject(arg1));
462
+ return addHeapObject(ret);
463
+ },
464
+ __wbg_transaction_30dda0e59a945fe4: function() {
465
+ return handleError(function(arg0, arg1, arg2) {
466
+ const ret = getObject(arg0).transaction(getObject(arg1), __wbindgen_enum_IdbTransactionMode[arg2]);
467
+ return addHeapObject(ret);
468
+ }, arguments);
469
+ },
470
+ __wbg_transaction_f90e157c0cdb0001: function() {
471
+ return handleError(function(arg0, arg1, arg2) {
472
+ const ret = getObject(arg0).transaction(getStringFromWasm0(arg1, arg2));
473
+ return addHeapObject(ret);
474
+ }, arguments);
475
+ },
476
+ __wbg_value_667dcb90597486a6: function(arg0) {
477
+ const ret = getObject(arg0).value;
478
+ return addHeapObject(ret);
479
+ },
480
+ __wbindgen_cast_0000000000000001: function(arg0, arg1) {
481
+ const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_1364, __wasm_bindgen_func_elem_1365);
482
+ return addHeapObject(ret);
483
+ },
484
+ __wbindgen_cast_0000000000000002: function(arg0, arg1) {
485
+ const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_191, __wasm_bindgen_func_elem_192);
486
+ return addHeapObject(ret);
487
+ },
488
+ __wbindgen_cast_0000000000000003: function(arg0) {
489
+ const ret = arg0;
490
+ return addHeapObject(ret);
491
+ },
492
+ __wbindgen_cast_0000000000000004: function(arg0) {
493
+ const ret = arg0;
494
+ return addHeapObject(ret);
495
+ },
496
+ __wbindgen_cast_0000000000000005: function(arg0, arg1) {
497
+ const ret = getStringFromWasm0(arg0, arg1);
498
+ return addHeapObject(ret);
499
+ },
500
+ __wbindgen_cast_0000000000000006: function(arg0) {
501
+ const ret = BigInt.asUintN(64, arg0);
502
+ return addHeapObject(ret);
503
+ },
504
+ __wbindgen_object_clone_ref: function(arg0) {
505
+ const ret = getObject(arg0);
506
+ return addHeapObject(ret);
507
+ },
508
+ __wbindgen_object_drop_ref: function(arg0) {
509
+ takeObject(arg0);
510
+ }
511
+ };
512
+ return {
513
+ __proto__: null,
514
+ "./rvlite_bg.js": import0
515
+ };
516
+ }
517
+ function __wasm_bindgen_func_elem_192(arg0, arg1, arg2) {
518
+ wasm.__wasm_bindgen_func_elem_192(arg0, arg1, addHeapObject(arg2));
519
+ }
520
+ function __wasm_bindgen_func_elem_1365(arg0, arg1, arg2) {
521
+ try {
522
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
523
+ wasm.__wasm_bindgen_func_elem_1365(retptr, arg0, arg1, addHeapObject(arg2));
524
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
525
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
526
+ if (r1) {
527
+ throw takeObject(r0);
528
+ }
529
+ } finally {
530
+ wasm.__wbindgen_add_to_stack_pointer(16);
531
+ }
532
+ }
533
+ function __wasm_bindgen_func_elem_1407(arg0, arg1, arg2, arg3) {
534
+ wasm.__wasm_bindgen_func_elem_1407(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
535
+ }
43
536
  function addHeapObject(obj) {
44
537
  if (heap_next === heap.length) heap.push(heap.length + 1);
45
538
  const idx = heap_next;
@@ -109,7 +602,7 @@ ${val.stack}`;
109
602
  return className;
110
603
  }
111
604
  function dropObject(idx) {
112
- if (idx < 132) return;
605
+ if (idx < 1028) return;
113
606
  heap[idx] = heap_next;
114
607
  heap_next = idx;
115
608
  }
@@ -225,17 +718,14 @@ function decodeText(ptr, len) {
225
718
  }
226
719
  return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
227
720
  }
228
- function __wasm_bindgen_func_elem_1339(arg0, arg1, arg2) {
229
- wasm.__wasm_bindgen_func_elem_1339(arg0, arg1, addHeapObject(arg2));
230
- }
231
- function __wasm_bindgen_func_elem_180(arg0, arg1, arg2) {
232
- wasm.__wasm_bindgen_func_elem_180(arg0, arg1, addHeapObject(arg2));
233
- }
234
- function __wasm_bindgen_func_elem_1385(arg0, arg1, arg2, arg3) {
235
- wasm.__wasm_bindgen_func_elem_1385(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
236
- }
237
- function init() {
238
- wasm.init();
721
+ function __wbg_finalize_init(instance, module2) {
722
+ wasm = instance.exports;
723
+ wasmModule = module2;
724
+ cachedDataViewMemory0 = null;
725
+ cachedFloat32ArrayMemory0 = null;
726
+ cachedUint8ArrayMemory0 = null;
727
+ wasm.__wbindgen_start();
728
+ return wasm;
239
729
  }
240
730
  async function __wbg_load(module2, imports) {
241
731
  if (typeof Response === "function" && module2 instanceof Response) {
@@ -243,7 +733,7 @@ async function __wbg_load(module2, imports) {
243
733
  try {
244
734
  return await WebAssembly.instantiateStreaming(module2, imports);
245
735
  } catch (e) {
246
- const validResponse = module2.ok && EXPECTED_RESPONSE_TYPES.has(module2.type);
736
+ const validResponse = module2.ok && expectedResponseType(module2.type);
247
737
  if (validResponse && module2.headers.get("Content-Type") !== "application/wasm") {
248
738
  console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
249
739
  } else {
@@ -261,468 +751,19 @@ async function __wbg_load(module2, imports) {
261
751
  return instance;
262
752
  }
263
753
  }
264
- }
265
- function __wbg_get_imports() {
266
- const imports = {};
267
- imports.wbg = {};
268
- imports.wbg.__wbg_Error_52673b7de5a0ca89 = function(arg0, arg1) {
269
- const ret = Error(getStringFromWasm0(arg0, arg1));
270
- return addHeapObject(ret);
271
- };
272
- imports.wbg.__wbg_Number_2d1dcfcf4ec51736 = function(arg0) {
273
- const ret = Number(getObject(arg0));
274
- return ret;
275
- };
276
- imports.wbg.__wbg_String_8f0eb39a4a4c2f66 = function(arg0, arg1) {
277
- const ret = String(getObject(arg1));
278
- const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
279
- const len1 = WASM_VECTOR_LEN;
280
- getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
281
- getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
282
- };
283
- imports.wbg.__wbg___wbindgen_bigint_get_as_i64_6e32f5e6aff02e1d = function(arg0, arg1) {
284
- const v = getObject(arg1);
285
- const ret = typeof v === "bigint" ? v : void 0;
286
- getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
287
- getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
288
- };
289
- imports.wbg.__wbg___wbindgen_boolean_get_dea25b33882b895b = function(arg0) {
290
- const v = getObject(arg0);
291
- const ret = typeof v === "boolean" ? v : void 0;
292
- return isLikeNone(ret) ? 16777215 : ret ? 1 : 0;
293
- };
294
- imports.wbg.__wbg___wbindgen_debug_string_adfb662ae34724b6 = function(arg0, arg1) {
295
- const ret = debugString(getObject(arg1));
296
- const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
297
- const len1 = WASM_VECTOR_LEN;
298
- getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
299
- getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
300
- };
301
- imports.wbg.__wbg___wbindgen_in_0d3e1e8f0c669317 = function(arg0, arg1) {
302
- const ret = getObject(arg0) in getObject(arg1);
303
- return ret;
304
- };
305
- imports.wbg.__wbg___wbindgen_is_bigint_0e1a2e3f55cfae27 = function(arg0) {
306
- const ret = typeof getObject(arg0) === "bigint";
307
- return ret;
308
- };
309
- imports.wbg.__wbg___wbindgen_is_function_8d400b8b1af978cd = function(arg0) {
310
- const ret = typeof getObject(arg0) === "function";
311
- return ret;
312
- };
313
- imports.wbg.__wbg___wbindgen_is_null_dfda7d66506c95b5 = function(arg0) {
314
- const ret = getObject(arg0) === null;
315
- return ret;
316
- };
317
- imports.wbg.__wbg___wbindgen_is_object_ce774f3490692386 = function(arg0) {
318
- const val = getObject(arg0);
319
- const ret = typeof val === "object" && val !== null;
320
- return ret;
321
- };
322
- imports.wbg.__wbg___wbindgen_is_string_704ef9c8fc131030 = function(arg0) {
323
- const ret = typeof getObject(arg0) === "string";
324
- return ret;
325
- };
326
- imports.wbg.__wbg___wbindgen_is_undefined_f6b95eab589e0269 = function(arg0) {
327
- const ret = getObject(arg0) === void 0;
328
- return ret;
329
- };
330
- imports.wbg.__wbg___wbindgen_jsval_eq_b6101cc9cef1fe36 = function(arg0, arg1) {
331
- const ret = getObject(arg0) === getObject(arg1);
332
- return ret;
333
- };
334
- imports.wbg.__wbg___wbindgen_jsval_loose_eq_766057600fdd1b0d = function(arg0, arg1) {
335
- const ret = getObject(arg0) == getObject(arg1);
336
- return ret;
337
- };
338
- imports.wbg.__wbg___wbindgen_number_get_9619185a74197f95 = function(arg0, arg1) {
339
- const obj = getObject(arg1);
340
- const ret = typeof obj === "number" ? obj : void 0;
341
- getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
342
- getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
343
- };
344
- imports.wbg.__wbg___wbindgen_string_get_a2a31e16edf96e42 = function(arg0, arg1) {
345
- const obj = getObject(arg1);
346
- const ret = typeof obj === "string" ? obj : void 0;
347
- var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
348
- var len1 = WASM_VECTOR_LEN;
349
- getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
350
- getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
351
- };
352
- imports.wbg.__wbg___wbindgen_throw_dd24417ed36fc46e = function(arg0, arg1) {
353
- throw new Error(getStringFromWasm0(arg0, arg1));
354
- };
355
- imports.wbg.__wbg__wbg_cb_unref_87dfb5aaa0cbcea7 = function(arg0) {
356
- getObject(arg0)._wbg_cb_unref();
357
- };
358
- imports.wbg.__wbg_call_3020136f7a2d6e44 = function() {
359
- return handleError(function(arg0, arg1, arg2) {
360
- const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
361
- return addHeapObject(ret);
362
- }, arguments);
363
- };
364
- imports.wbg.__wbg_call_abb4ff46ce38be40 = function() {
365
- return handleError(function(arg0, arg1) {
366
- const ret = getObject(arg0).call(getObject(arg1));
367
- return addHeapObject(ret);
368
- }, arguments);
369
- };
370
- imports.wbg.__wbg_clear_0e6ff4790cdabf11 = function() {
371
- return handleError(function(arg0) {
372
- const ret = getObject(arg0).clear();
373
- return addHeapObject(ret);
374
- }, arguments);
375
- };
376
- imports.wbg.__wbg_close_cf7ef4e294ac3858 = function(arg0) {
377
- getObject(arg0).close();
378
- };
379
- imports.wbg.__wbg_contains_de2a27de1ed31877 = function(arg0, arg1, arg2) {
380
- const ret = getObject(arg0).contains(getStringFromWasm0(arg1, arg2));
381
- return ret;
382
- };
383
- imports.wbg.__wbg_count_5aeeb43c8c540e73 = function() {
384
- return handleError(function(arg0, arg1) {
385
- const ret = getObject(arg0).count(getObject(arg1));
386
- return addHeapObject(ret);
387
- }, arguments);
388
- };
389
- imports.wbg.__wbg_createObjectStore_dba64acfe84d4191 = function() {
390
- return handleError(function(arg0, arg1, arg2) {
391
- const ret = getObject(arg0).createObjectStore(getStringFromWasm0(arg1, arg2));
392
- return addHeapObject(ret);
393
- }, arguments);
394
- };
395
- imports.wbg.__wbg_done_62ea16af4ce34b24 = function(arg0) {
396
- const ret = getObject(arg0).done;
397
- return ret;
398
- };
399
- imports.wbg.__wbg_entries_83c79938054e065f = function(arg0) {
400
- const ret = Object.entries(getObject(arg0));
401
- return addHeapObject(ret);
402
- };
403
- imports.wbg.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
404
- let deferred0_0;
405
- let deferred0_1;
406
- try {
407
- deferred0_0 = arg0;
408
- deferred0_1 = arg1;
409
- console.error(getStringFromWasm0(arg0, arg1));
410
- } finally {
411
- wasm.__wbindgen_export4(deferred0_0, deferred0_1, 1);
412
- }
413
- };
414
- imports.wbg.__wbg_get_6b7bd52aca3f9671 = function(arg0, arg1) {
415
- const ret = getObject(arg0)[arg1 >>> 0];
416
- return addHeapObject(ret);
417
- };
418
- imports.wbg.__wbg_get_7d8b665fa88606d5 = function() {
419
- return handleError(function(arg0, arg1) {
420
- const ret = getObject(arg0).get(getObject(arg1));
421
- return addHeapObject(ret);
422
- }, arguments);
423
- };
424
- imports.wbg.__wbg_get_af9dab7e9603ea93 = function() {
425
- return handleError(function(arg0, arg1) {
426
- const ret = Reflect.get(getObject(arg0), getObject(arg1));
427
- return addHeapObject(ret);
428
- }, arguments);
429
- };
430
- imports.wbg.__wbg_get_with_ref_key_1dc361bd10053bfe = function(arg0, arg1) {
431
- const ret = getObject(arg0)[getObject(arg1)];
432
- return addHeapObject(ret);
433
- };
434
- imports.wbg.__wbg_indexedDB_23c232e00a1e28ad = function() {
435
- return handleError(function(arg0) {
436
- const ret = getObject(arg0).indexedDB;
437
- return isLikeNone(ret) ? 0 : addHeapObject(ret);
438
- }, arguments);
439
- };
440
- imports.wbg.__wbg_instanceof_ArrayBuffer_f3320d2419cd0355 = function(arg0) {
441
- let result;
442
- try {
443
- result = getObject(arg0) instanceof ArrayBuffer;
444
- } catch (_) {
445
- result = false;
446
- }
447
- const ret = result;
448
- return ret;
449
- };
450
- imports.wbg.__wbg_instanceof_Map_084be8da74364158 = function(arg0) {
451
- let result;
452
- try {
453
- result = getObject(arg0) instanceof Map;
454
- } catch (_) {
455
- result = false;
754
+ function expectedResponseType(type) {
755
+ switch (type) {
756
+ case "basic":
757
+ case "cors":
758
+ case "default":
759
+ return true;
456
760
  }
457
- const ret = result;
458
- return ret;
459
- };
460
- imports.wbg.__wbg_instanceof_Uint8Array_da54ccc9d3e09434 = function(arg0) {
461
- let result;
462
- try {
463
- result = getObject(arg0) instanceof Uint8Array;
464
- } catch (_) {
465
- result = false;
466
- }
467
- const ret = result;
468
- return ret;
469
- };
470
- imports.wbg.__wbg_instanceof_Window_b5cf7783caa68180 = function(arg0) {
471
- let result;
472
- try {
473
- result = getObject(arg0) instanceof Window;
474
- } catch (_) {
475
- result = false;
476
- }
477
- const ret = result;
478
- return ret;
479
- };
480
- imports.wbg.__wbg_isArray_51fd9e6422c0a395 = function(arg0) {
481
- const ret = Array.isArray(getObject(arg0));
482
- return ret;
483
- };
484
- imports.wbg.__wbg_isSafeInteger_ae7d3f054d55fa16 = function(arg0) {
485
- const ret = Number.isSafeInteger(getObject(arg0));
486
- return ret;
487
- };
488
- imports.wbg.__wbg_iterator_27b7c8b35ab3e86b = function() {
489
- const ret = Symbol.iterator;
490
- return addHeapObject(ret);
491
- };
492
- imports.wbg.__wbg_length_22ac23eaec9d8053 = function(arg0) {
493
- const ret = getObject(arg0).length;
494
- return ret;
495
- };
496
- imports.wbg.__wbg_length_d45040a40c570362 = function(arg0) {
497
- const ret = getObject(arg0).length;
498
- return ret;
499
- };
500
- imports.wbg.__wbg_log_1d990106d99dacb7 = function(arg0) {
501
- console.log(getObject(arg0));
502
- };
503
- imports.wbg.__wbg_new_1ba21ce319a06297 = function() {
504
- const ret = new Object();
505
- return addHeapObject(ret);
506
- };
507
- imports.wbg.__wbg_new_25f239778d6112b9 = function() {
508
- const ret = new Array();
509
- return addHeapObject(ret);
510
- };
511
- imports.wbg.__wbg_new_6421f6084cc5bc5a = function(arg0) {
512
- const ret = new Uint8Array(getObject(arg0));
513
- return addHeapObject(ret);
514
- };
515
- imports.wbg.__wbg_new_8a6f238a6ece86ea = function() {
516
- const ret = new Error();
517
- return addHeapObject(ret);
518
- };
519
- imports.wbg.__wbg_new_b546ae120718850e = function() {
520
- const ret = /* @__PURE__ */ new Map();
521
- return addHeapObject(ret);
522
- };
523
- imports.wbg.__wbg_new_ff12d2b041fb48f1 = function(arg0, arg1) {
524
- try {
525
- var state0 = { a: arg0, b: arg1 };
526
- var cb0 = (arg02, arg12) => {
527
- const a = state0.a;
528
- state0.a = 0;
529
- try {
530
- return __wasm_bindgen_func_elem_1385(a, state0.b, arg02, arg12);
531
- } finally {
532
- state0.a = a;
533
- }
534
- };
535
- const ret = new Promise(cb0);
536
- return addHeapObject(ret);
537
- } finally {
538
- state0.a = state0.b = 0;
539
- }
540
- };
541
- imports.wbg.__wbg_new_no_args_cb138f77cf6151ee = function(arg0, arg1) {
542
- const ret = new Function(getStringFromWasm0(arg0, arg1));
543
- return addHeapObject(ret);
544
- };
545
- imports.wbg.__wbg_next_138a17bbf04e926c = function(arg0) {
546
- const ret = getObject(arg0).next;
547
- return addHeapObject(ret);
548
- };
549
- imports.wbg.__wbg_next_3cfe5c0fe2a4cc53 = function() {
550
- return handleError(function(arg0) {
551
- const ret = getObject(arg0).next();
552
- return addHeapObject(ret);
553
- }, arguments);
554
- };
555
- imports.wbg.__wbg_now_69d776cd24f5215b = function() {
556
- const ret = Date.now();
557
- return ret;
558
- };
559
- imports.wbg.__wbg_objectStoreNames_90900f9a531513ac = function(arg0) {
560
- const ret = getObject(arg0).objectStoreNames;
561
- return addHeapObject(ret);
562
- };
563
- imports.wbg.__wbg_objectStore_da9a077b8849dbe9 = function() {
564
- return handleError(function(arg0, arg1, arg2) {
565
- const ret = getObject(arg0).objectStore(getStringFromWasm0(arg1, arg2));
566
- return addHeapObject(ret);
567
- }, arguments);
568
- };
569
- imports.wbg.__wbg_open_0d7b85f4c0a38ffe = function() {
570
- return handleError(function(arg0, arg1, arg2, arg3) {
571
- const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2), arg3 >>> 0);
572
- return addHeapObject(ret);
573
- }, arguments);
574
- };
575
- imports.wbg.__wbg_parse_a09a54cf72639456 = function() {
576
- return handleError(function(arg0, arg1) {
577
- const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
578
- return addHeapObject(ret);
579
- }, arguments);
580
- };
581
- imports.wbg.__wbg_prototypesetcall_dfe9b766cdc1f1fd = function(arg0, arg1, arg2) {
582
- Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
583
- };
584
- imports.wbg.__wbg_push_7d9be8f38fc13975 = function(arg0, arg1) {
585
- const ret = getObject(arg0).push(getObject(arg1));
586
- return ret;
587
- };
588
- imports.wbg.__wbg_put_d40a68e5a8902a46 = function() {
589
- return handleError(function(arg0, arg1, arg2) {
590
- const ret = getObject(arg0).put(getObject(arg1), getObject(arg2));
591
- return addHeapObject(ret);
592
- }, arguments);
593
- };
594
- imports.wbg.__wbg_queueMicrotask_9b549dfce8865860 = function(arg0) {
595
- const ret = getObject(arg0).queueMicrotask;
596
- return addHeapObject(ret);
597
- };
598
- imports.wbg.__wbg_queueMicrotask_fca69f5bfad613a5 = function(arg0) {
599
- queueMicrotask(getObject(arg0));
600
- };
601
- imports.wbg.__wbg_resolve_fd5bfbaa4ce36e1e = function(arg0) {
602
- const ret = Promise.resolve(getObject(arg0));
603
- return addHeapObject(ret);
604
- };
605
- imports.wbg.__wbg_result_084f962aedb54250 = function() {
606
- return handleError(function(arg0) {
607
- const ret = getObject(arg0).result;
608
- return addHeapObject(ret);
609
- }, arguments);
610
- };
611
- imports.wbg.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
612
- getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
613
- };
614
- imports.wbg.__wbg_set_7df433eea03a5c14 = function(arg0, arg1, arg2) {
615
- getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
616
- };
617
- imports.wbg.__wbg_set_efaaf145b9377369 = function(arg0, arg1, arg2) {
618
- const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
619
- return addHeapObject(ret);
620
- };
621
- imports.wbg.__wbg_set_onerror_08fecec3bdc9d24d = function(arg0, arg1) {
622
- getObject(arg0).onerror = getObject(arg1);
623
- };
624
- imports.wbg.__wbg_set_onsuccess_94332a00452de699 = function(arg0, arg1) {
625
- getObject(arg0).onsuccess = getObject(arg1);
626
- };
627
- imports.wbg.__wbg_set_onupgradeneeded_3dc6e233a6d13fe2 = function(arg0, arg1) {
628
- getObject(arg0).onupgradeneeded = getObject(arg1);
629
- };
630
- imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
631
- const ret = getObject(arg1).stack;
632
- const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
633
- const len1 = WASM_VECTOR_LEN;
634
- getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
635
- getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
636
- };
637
- imports.wbg.__wbg_static_accessor_GLOBAL_769e6b65d6557335 = function() {
638
- const ret = typeof global === "undefined" ? null : global;
639
- return isLikeNone(ret) ? 0 : addHeapObject(ret);
640
- };
641
- imports.wbg.__wbg_static_accessor_GLOBAL_THIS_60cf02db4de8e1c1 = function() {
642
- const ret = typeof globalThis === "undefined" ? null : globalThis;
643
- return isLikeNone(ret) ? 0 : addHeapObject(ret);
644
- };
645
- imports.wbg.__wbg_static_accessor_SELF_08f5a74c69739274 = function() {
646
- const ret = typeof self === "undefined" ? null : self;
647
- return isLikeNone(ret) ? 0 : addHeapObject(ret);
648
- };
649
- imports.wbg.__wbg_static_accessor_WINDOW_a8924b26aa92d024 = function() {
650
- const ret = typeof window === "undefined" ? null : window;
651
- return isLikeNone(ret) ? 0 : addHeapObject(ret);
652
- };
653
- imports.wbg.__wbg_target_0e3e05a6263c37a0 = function(arg0) {
654
- const ret = getObject(arg0).target;
655
- return isLikeNone(ret) ? 0 : addHeapObject(ret);
656
- };
657
- imports.wbg.__wbg_then_429f7caf1026411d = function(arg0, arg1, arg2) {
658
- const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
659
- return addHeapObject(ret);
660
- };
661
- imports.wbg.__wbg_then_4f95312d68691235 = function(arg0, arg1) {
662
- const ret = getObject(arg0).then(getObject(arg1));
663
- return addHeapObject(ret);
664
- };
665
- imports.wbg.__wbg_transaction_257422def49a0094 = function() {
666
- return handleError(function(arg0, arg1, arg2) {
667
- const ret = getObject(arg0).transaction(getObject(arg1), __wbindgen_enum_IdbTransactionMode[arg2]);
668
- return addHeapObject(ret);
669
- }, arguments);
670
- };
671
- imports.wbg.__wbg_transaction_754344c3ae25fdcf = function() {
672
- return handleError(function(arg0, arg1, arg2) {
673
- const ret = getObject(arg0).transaction(getStringFromWasm0(arg1, arg2));
674
- return addHeapObject(ret);
675
- }, arguments);
676
- };
677
- imports.wbg.__wbg_value_57b7b035e117f7ee = function(arg0) {
678
- const ret = getObject(arg0).value;
679
- return addHeapObject(ret);
680
- };
681
- imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
682
- const ret = getStringFromWasm0(arg0, arg1);
683
- return addHeapObject(ret);
684
- };
685
- imports.wbg.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
686
- const ret = BigInt.asUintN(64, arg0);
687
- return addHeapObject(ret);
688
- };
689
- imports.wbg.__wbindgen_cast_59e89726c7c5a9af = function(arg0, arg1) {
690
- const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_179, __wasm_bindgen_func_elem_180);
691
- return addHeapObject(ret);
692
- };
693
- imports.wbg.__wbindgen_cast_8ff99cee1f2c383b = function(arg0, arg1) {
694
- const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_1338, __wasm_bindgen_func_elem_1339);
695
- return addHeapObject(ret);
696
- };
697
- imports.wbg.__wbindgen_cast_9ae0607507abb057 = function(arg0) {
698
- const ret = arg0;
699
- return addHeapObject(ret);
700
- };
701
- imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
702
- const ret = arg0;
703
- return addHeapObject(ret);
704
- };
705
- imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
706
- const ret = getObject(arg0);
707
- return addHeapObject(ret);
708
- };
709
- imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
710
- takeObject(arg0);
711
- };
712
- return imports;
713
- }
714
- function __wbg_finalize_init(instance, module2) {
715
- wasm = instance.exports;
716
- __wbg_init.__wbindgen_wasm_module = module2;
717
- cachedDataViewMemory0 = null;
718
- cachedFloat32ArrayMemory0 = null;
719
- cachedUint8ArrayMemory0 = null;
720
- wasm.__wbindgen_start();
721
- return wasm;
761
+ return false;
762
+ }
722
763
  }
723
764
  function initSync(module2) {
724
765
  if (wasm !== void 0) return wasm;
725
- if (typeof module2 !== "undefined") {
766
+ if (module2 !== void 0) {
726
767
  if (Object.getPrototypeOf(module2) === Object.prototype) {
727
768
  ({ module: module2 } = module2);
728
769
  } else {
@@ -738,14 +779,14 @@ function initSync(module2) {
738
779
  }
739
780
  async function __wbg_init(module_or_path) {
740
781
  if (wasm !== void 0) return wasm;
741
- if (typeof module_or_path !== "undefined") {
782
+ if (module_or_path !== void 0) {
742
783
  if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
743
784
  ({ module_or_path } = module_or_path);
744
785
  } else {
745
786
  console.warn("using deprecated parameters for the initialization function; pass a single object instead");
746
787
  }
747
788
  }
748
- if (typeof module_or_path === "undefined") {
789
+ if (module_or_path === void 0) {
749
790
  module_or_path = new URL("rvlite_bg.wasm", import_meta.url);
750
791
  }
751
792
  const imports = __wbg_get_imports();
@@ -755,46 +796,11 @@ async function __wbg_init(module_or_path) {
755
796
  const { instance, module: module2 } = await __wbg_load(await module_or_path, imports);
756
797
  return __wbg_finalize_init(instance, module2);
757
798
  }
758
- var import_meta, wasm, CLOSURE_DTORS, cachedDataViewMemory0, cachedFloat32ArrayMemory0, cachedUint8ArrayMemory0, heap, heap_next, cachedTextDecoder, MAX_SAFARI_DECODE_BYTES, numBytesDecoded, cachedTextEncoder, WASM_VECTOR_LEN, __wbindgen_enum_IdbTransactionMode, CypherEngineFinalization, RvLiteFinalization, RvLiteConfigFinalization, CypherEngine, RvLite, RvLiteConfig, EXPECTED_RESPONSE_TYPES, rvlite_default;
799
+ var import_meta, CypherEngine, RvLite, RvLiteConfig, __wbindgen_enum_IdbTransactionMode, CypherEngineFinalization, RvLiteFinalization, RvLiteConfigFinalization, CLOSURE_DTORS, cachedDataViewMemory0, cachedFloat32ArrayMemory0, cachedUint8ArrayMemory0, heap, heap_next, cachedTextDecoder, MAX_SAFARI_DECODE_BYTES, numBytesDecoded, cachedTextEncoder, WASM_VECTOR_LEN, wasmModule, wasm;
759
800
  var init_rvlite = __esm({
760
801
  "dist/wasm/rvlite.js"() {
761
802
  "use strict";
762
803
  import_meta = {};
763
- CLOSURE_DTORS = typeof FinalizationRegistry === "undefined" ? { register: () => {
764
- }, unregister: () => {
765
- } } : new FinalizationRegistry((state) => state.dtor(state.a, state.b));
766
- cachedDataViewMemory0 = null;
767
- cachedFloat32ArrayMemory0 = null;
768
- cachedUint8ArrayMemory0 = null;
769
- heap = new Array(128).fill(void 0);
770
- heap.push(void 0, null, true, false);
771
- heap_next = heap.length;
772
- cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
773
- cachedTextDecoder.decode();
774
- MAX_SAFARI_DECODE_BYTES = 2146435072;
775
- numBytesDecoded = 0;
776
- cachedTextEncoder = new TextEncoder();
777
- if (!("encodeInto" in cachedTextEncoder)) {
778
- cachedTextEncoder.encodeInto = function(arg, view) {
779
- const buf = cachedTextEncoder.encode(arg);
780
- view.set(buf);
781
- return {
782
- read: arg.length,
783
- written: buf.length
784
- };
785
- };
786
- }
787
- WASM_VECTOR_LEN = 0;
788
- __wbindgen_enum_IdbTransactionMode = ["readonly", "readwrite", "versionchange", "readwriteflush", "cleanup"];
789
- CypherEngineFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
790
- }, unregister: () => {
791
- } } : new FinalizationRegistry((ptr) => wasm.__wbg_cypherengine_free(ptr >>> 0, 1));
792
- RvLiteFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
793
- }, unregister: () => {
794
- } } : new FinalizationRegistry((ptr) => wasm.__wbg_rvlite_free(ptr >>> 0, 1));
795
- RvLiteConfigFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
796
- }, unregister: () => {
797
- } } : new FinalizationRegistry((ptr) => wasm.__wbg_rvliteconfig_free(ptr >>> 0, 1));
798
804
  CypherEngine = class {
799
805
  __destroy_into_raw() {
800
806
  const ptr = this.__wbg_ptr;
@@ -807,28 +813,22 @@ var init_rvlite = __esm({
807
813
  wasm.__wbg_cypherengine_free(ptr, 0);
808
814
  }
809
815
  /**
810
- * Create a new Cypher engine with empty graph
811
- */
812
- constructor() {
813
- const ret = wasm.cypherengine_new();
814
- this.__wbg_ptr = ret >>> 0;
815
- CypherEngineFinalization.register(this, this.__wbg_ptr, this);
816
- return this;
817
- }
818
- /**
819
- * Clear the graph
816
+ * Clear the graph
820
817
  */
821
818
  clear() {
822
819
  wasm.cypherengine_clear(this.__wbg_ptr);
823
820
  }
824
821
  /**
825
- * Get graph statistics
822
+ * Execute a Cypher query and return JSON results
823
+ * @param {string} query
826
824
  * @returns {any}
827
825
  */
828
- stats() {
826
+ execute(query) {
829
827
  try {
830
828
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
831
- wasm.cypherengine_stats(retptr, this.__wbg_ptr);
829
+ const ptr0 = passStringToWasm0(query, wasm.__wbindgen_export, wasm.__wbindgen_export2);
830
+ const len0 = WASM_VECTOR_LEN;
831
+ wasm.cypherengine_execute(retptr, this.__wbg_ptr, ptr0, len0);
832
832
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
833
833
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
834
834
  var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -841,16 +841,22 @@ var init_rvlite = __esm({
841
841
  }
842
842
  }
843
843
  /**
844
- * Execute a Cypher query and return JSON results
845
- * @param {string} query
844
+ * Create a new Cypher engine with empty graph
845
+ */
846
+ constructor() {
847
+ const ret = wasm.cypherengine_new();
848
+ this.__wbg_ptr = ret >>> 0;
849
+ CypherEngineFinalization.register(this, this.__wbg_ptr, this);
850
+ return this;
851
+ }
852
+ /**
853
+ * Get graph statistics
846
854
  * @returns {any}
847
855
  */
848
- execute(query) {
856
+ stats() {
849
857
  try {
850
858
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
851
- const ptr0 = passStringToWasm0(query, wasm.__wbindgen_export, wasm.__wbindgen_export2);
852
- const len0 = WASM_VECTOR_LEN;
853
- wasm.cypherengine_execute(retptr, this.__wbg_ptr, ptr0, len0);
859
+ wasm.cypherengine_stats(retptr, this.__wbg_ptr);
854
860
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
855
861
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
856
862
  var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -913,32 +919,36 @@ var init_rvlite = __esm({
913
919
  }
914
920
  }
915
921
  /**
916
- * Get configuration
917
- * @returns {any}
922
+ * Clear saved state from IndexedDB
923
+ * @returns {Promise<any>}
918
924
  */
919
- get_config() {
920
- try {
921
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
922
- wasm.rvlite_get_config(retptr, this.__wbg_ptr);
923
- var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
924
- var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
925
- var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
926
- if (r2) {
927
- throw takeObject(r1);
928
- }
929
- return takeObject(r0);
930
- } finally {
931
- wasm.__wbindgen_add_to_stack_pointer(16);
932
- }
925
+ static clear_storage() {
926
+ const ret = wasm.rvlite_clear_storage();
927
+ return takeObject(ret);
933
928
  }
934
929
  /**
935
- * Export database state as JSON (for manual backup)
930
+ * Clear all triples
931
+ */
932
+ clear_triples() {
933
+ wasm.rvlite_clear_triples(this.__wbg_ptr);
934
+ }
935
+ /**
936
+ * Execute Cypher query
937
+ *
938
+ * Supported operations:
939
+ * - CREATE (n:Label {prop: value})
940
+ * - MATCH (n:Label) WHERE n.prop = value RETURN n
941
+ * - CREATE (a)-[r:REL]->(b)
942
+ * - DELETE n
943
+ * @param {string} query
936
944
  * @returns {any}
937
945
  */
938
- export_json() {
946
+ cypher(query) {
939
947
  try {
940
948
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
941
- wasm.rvlite_export_json(retptr, this.__wbg_ptr);
949
+ const ptr0 = passStringToWasm0(query, wasm.__wbindgen_export, wasm.__wbindgen_export2);
950
+ const len0 = WASM_VECTOR_LEN;
951
+ wasm.rvlite_cypher(retptr, this.__wbg_ptr, ptr0, len0);
942
952
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
943
953
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
944
954
  var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -950,43 +960,6 @@ var init_rvlite = __esm({
950
960
  wasm.__wbindgen_add_to_stack_pointer(16);
951
961
  }
952
962
  }
953
- /**
954
- * Get version string
955
- * @returns {string}
956
- */
957
- get_version() {
958
- let deferred1_0;
959
- let deferred1_1;
960
- try {
961
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
962
- wasm.rvlite_get_version(retptr, this.__wbg_ptr);
963
- var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
964
- var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
965
- deferred1_0 = r0;
966
- deferred1_1 = r1;
967
- return getStringFromWasm0(r0, r1);
968
- } finally {
969
- wasm.__wbindgen_add_to_stack_pointer(16);
970
- wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
971
- }
972
- }
973
- /**
974
- * Import database state from JSON
975
- * @param {any} json
976
- */
977
- import_json(json) {
978
- try {
979
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
980
- wasm.rvlite_import_json(retptr, this.__wbg_ptr, addHeapObject(json));
981
- var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
982
- var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
983
- if (r1) {
984
- throw takeObject(r0);
985
- }
986
- } finally {
987
- wasm.__wbindgen_add_to_stack_pointer(16);
988
- }
989
- }
990
963
  /**
991
964
  * Clear the Cypher graph
992
965
  */
@@ -1013,99 +986,54 @@ var init_rvlite = __esm({
1013
986
  }
1014
987
  }
1015
988
  /**
1016
- * Get enabled features
1017
- * @returns {any}
989
+ * Create with default configuration (384 dimensions, cosine similarity)
990
+ * @returns {RvLite}
1018
991
  */
1019
- get_features() {
992
+ static default() {
1020
993
  try {
1021
994
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1022
- wasm.rvlite_get_features(retptr, this.__wbg_ptr);
995
+ wasm.rvlite_default(retptr);
1023
996
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1024
997
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1025
998
  var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1026
999
  if (r2) {
1027
1000
  throw takeObject(r1);
1028
1001
  }
1029
- return takeObject(r0);
1002
+ return _RvLite.__wrap(r0);
1030
1003
  } finally {
1031
1004
  wasm.__wbindgen_add_to_stack_pointer(16);
1032
1005
  }
1033
1006
  }
1034
1007
  /**
1035
- * Initialize IndexedDB storage for persistence
1036
- * Must be called before save() or load()
1037
- * @returns {Promise<any>}
1038
- */
1039
- init_storage() {
1040
- const ret = wasm.rvlite_init_storage(this.__wbg_ptr);
1041
- return takeObject(ret);
1042
- }
1043
- /**
1044
- * Get the number of triples in the store
1045
- * @returns {number}
1046
- */
1047
- triple_count() {
1048
- const ret = wasm.rvlite_triple_count(this.__wbg_ptr);
1049
- return ret >>> 0;
1050
- }
1051
- /**
1052
- * Clear saved state from IndexedDB
1053
- * @returns {Promise<any>}
1054
- */
1055
- static clear_storage() {
1056
- const ret = wasm.rvlite_clear_storage();
1057
- return takeObject(ret);
1058
- }
1059
- /**
1060
- * Clear all triples
1061
- */
1062
- clear_triples() {
1063
- wasm.rvlite_clear_triples(this.__wbg_ptr);
1064
- }
1065
- /**
1066
- * Insert a vector with a specific ID
1008
+ * Delete a vector by ID
1067
1009
  * @param {string} id
1068
- * @param {Float32Array} vector
1069
- * @param {any} metadata
1010
+ * @returns {boolean}
1070
1011
  */
1071
- insert_with_id(id, vector, metadata) {
1012
+ delete(id) {
1072
1013
  try {
1073
1014
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1074
1015
  const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1075
1016
  const len0 = WASM_VECTOR_LEN;
1076
- const ptr1 = passArrayF32ToWasm0(vector, wasm.__wbindgen_export);
1077
- const len1 = WASM_VECTOR_LEN;
1078
- wasm.rvlite_insert_with_id(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(metadata));
1017
+ wasm.rvlite_delete(retptr, this.__wbg_ptr, ptr0, len0);
1079
1018
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1080
1019
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1081
- if (r1) {
1082
- throw takeObject(r0);
1020
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1021
+ if (r2) {
1022
+ throw takeObject(r1);
1083
1023
  }
1024
+ return r0 !== 0;
1084
1025
  } finally {
1085
1026
  wasm.__wbindgen_add_to_stack_pointer(16);
1086
1027
  }
1087
1028
  }
1088
1029
  /**
1089
- * Check if saved state exists in IndexedDB
1090
- * @returns {Promise<any>}
1091
- */
1092
- static has_saved_state() {
1093
- const ret = wasm.rvlite_has_saved_state();
1094
- return takeObject(ret);
1095
- }
1096
- /**
1097
- * Search with metadata filter
1098
- * @param {Float32Array} query_vector
1099
- * @param {number} k
1100
- * @param {any} filter
1030
+ * Export database state as JSON (for manual backup)
1101
1031
  * @returns {any}
1102
1032
  */
1103
- search_with_filter(query_vector, k, filter) {
1033
+ export_json() {
1104
1034
  try {
1105
1035
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1106
- const ptr0 = passArrayF32ToWasm0(query_vector, wasm.__wbindgen_export);
1107
- const len0 = WASM_VECTOR_LEN;
1108
- wasm.rvlite_search_with_filter(retptr, this.__wbg_ptr, ptr0, len0, k, addHeapObject(filter));
1036
+ wasm.rvlite_export_json(retptr, this.__wbg_ptr);
1109
1037
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1110
1038
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1111
1039
  var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -1117,14 +1045,6 @@ var init_rvlite = __esm({
1117
1045
  wasm.__wbindgen_add_to_stack_pointer(16);
1118
1046
  }
1119
1047
  }
1120
- /**
1121
- * Check if IndexedDB is available in the browser
1122
- * @returns {boolean}
1123
- */
1124
- static is_storage_available() {
1125
- const ret = wasm.rvlite_is_storage_available();
1126
- return ret !== 0;
1127
- }
1128
1048
  /**
1129
1049
  * Get a vector by ID
1130
1050
  * @param {string} id
@@ -1148,146 +1068,96 @@ var init_rvlite = __esm({
1148
1068
  }
1149
1069
  }
1150
1070
  /**
1151
- * Get the number of vectors in the database
1152
- * @returns {number}
1071
+ * Get configuration
1072
+ * @returns {any}
1153
1073
  */
1154
- len() {
1074
+ get_config() {
1155
1075
  try {
1156
1076
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1157
- wasm.rvlite_len(retptr, this.__wbg_ptr);
1077
+ wasm.rvlite_get_config(retptr, this.__wbg_ptr);
1158
1078
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1159
1079
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1160
1080
  var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1161
1081
  if (r2) {
1162
1082
  throw takeObject(r1);
1163
1083
  }
1164
- return r0 >>> 0;
1084
+ return takeObject(r0);
1165
1085
  } finally {
1166
1086
  wasm.__wbindgen_add_to_stack_pointer(16);
1167
1087
  }
1168
1088
  }
1169
1089
  /**
1170
- * Create a new RvLite database
1171
- * @param {RvLiteConfig} config
1090
+ * Get enabled features
1091
+ * @returns {any}
1172
1092
  */
1173
- constructor(config) {
1093
+ get_features() {
1174
1094
  try {
1175
1095
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1176
- _assertClass(config, RvLiteConfig);
1177
- var ptr0 = config.__destroy_into_raw();
1178
- wasm.rvlite_new(retptr, ptr0);
1096
+ wasm.rvlite_get_features(retptr, this.__wbg_ptr);
1179
1097
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1180
1098
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1181
1099
  var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1182
1100
  if (r2) {
1183
1101
  throw takeObject(r1);
1184
1102
  }
1185
- this.__wbg_ptr = r0 >>> 0;
1186
- RvLiteFinalization.register(this, this.__wbg_ptr, this);
1187
- return this;
1103
+ return takeObject(r0);
1188
1104
  } finally {
1189
1105
  wasm.__wbindgen_add_to_stack_pointer(16);
1190
1106
  }
1191
1107
  }
1192
1108
  /**
1193
- * Execute SQL query
1194
- *
1195
- * Supported syntax:
1196
- * - CREATE TABLE vectors (id TEXT PRIMARY KEY, vector VECTOR(384))
1197
- * - SELECT * FROM vectors WHERE id = 'x'
1198
- * - SELECT id, vector <-> '[...]' AS distance FROM vectors ORDER BY distance LIMIT 10
1199
- * - INSERT INTO vectors (id, vector) VALUES ('x', '[...]')
1200
- * - DELETE FROM vectors WHERE id = 'x'
1201
- * @param {string} query
1202
- * @returns {any}
1109
+ * Get version string
1110
+ * @returns {string}
1203
1111
  */
1204
- sql(query) {
1112
+ get_version() {
1113
+ let deferred1_0;
1114
+ let deferred1_1;
1205
1115
  try {
1206
1116
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1207
- const ptr0 = passStringToWasm0(query, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1208
- const len0 = WASM_VECTOR_LEN;
1209
- wasm.rvlite_sql(retptr, this.__wbg_ptr, ptr0, len0);
1117
+ wasm.rvlite_get_version(retptr, this.__wbg_ptr);
1210
1118
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1211
1119
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1212
- var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1213
- if (r2) {
1214
- throw takeObject(r1);
1215
- }
1216
- return takeObject(r0);
1120
+ deferred1_0 = r0;
1121
+ deferred1_1 = r1;
1122
+ return getStringFromWasm0(r0, r1);
1217
1123
  } finally {
1218
1124
  wasm.__wbindgen_add_to_stack_pointer(16);
1125
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1219
1126
  }
1220
1127
  }
1221
1128
  /**
1222
- * Load database from IndexedDB
1223
- * Returns a Promise<RvLite> with the restored database
1224
- * @param {RvLiteConfig} config
1129
+ * Check if saved state exists in IndexedDB
1225
1130
  * @returns {Promise<any>}
1226
1131
  */
1227
- static load(config) {
1228
- _assertClass(config, RvLiteConfig);
1229
- var ptr0 = config.__destroy_into_raw();
1230
- const ret = wasm.rvlite_load(ptr0);
1231
- return takeObject(ret);
1232
- }
1233
- /**
1234
- * Save database state to IndexedDB
1235
- * Returns a Promise that resolves when save is complete
1236
- * @returns {Promise<any>}
1237
- */
1238
- save() {
1239
- const ret = wasm.rvlite_save(this.__wbg_ptr);
1132
+ static has_saved_state() {
1133
+ const ret = wasm.rvlite_has_saved_state();
1240
1134
  return takeObject(ret);
1241
1135
  }
1242
1136
  /**
1243
- * Execute Cypher query
1244
- *
1245
- * Supported operations:
1246
- * - CREATE (n:Label {prop: value})
1247
- * - MATCH (n:Label) WHERE n.prop = value RETURN n
1248
- * - CREATE (a)-[r:REL]->(b)
1249
- * - DELETE n
1250
- * @param {string} query
1251
- * @returns {any}
1137
+ * Import database state from JSON
1138
+ * @param {any} json
1252
1139
  */
1253
- cypher(query) {
1140
+ import_json(json) {
1254
1141
  try {
1255
1142
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1256
- const ptr0 = passStringToWasm0(query, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1257
- const len0 = WASM_VECTOR_LEN;
1258
- wasm.rvlite_cypher(retptr, this.__wbg_ptr, ptr0, len0);
1143
+ wasm.rvlite_import_json(retptr, this.__wbg_ptr, addHeapObject(json));
1259
1144
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1260
1145
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1261
- var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1262
- if (r2) {
1263
- throw takeObject(r1);
1146
+ if (r1) {
1147
+ throw takeObject(r0);
1264
1148
  }
1265
- return takeObject(r0);
1266
1149
  } finally {
1267
1150
  wasm.__wbindgen_add_to_stack_pointer(16);
1268
1151
  }
1269
1152
  }
1270
1153
  /**
1271
- * Delete a vector by ID
1272
- * @param {string} id
1273
- * @returns {boolean}
1154
+ * Initialize IndexedDB storage for persistence
1155
+ * Must be called before save() or load()
1156
+ * @returns {Promise<any>}
1274
1157
  */
1275
- delete(id) {
1276
- try {
1277
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1278
- const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1279
- const len0 = WASM_VECTOR_LEN;
1280
- wasm.rvlite_delete(retptr, this.__wbg_ptr, ptr0, len0);
1281
- var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1282
- var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1283
- var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1284
- if (r2) {
1285
- throw takeObject(r1);
1286
- }
1287
- return r0 !== 0;
1288
- } finally {
1289
- wasm.__wbindgen_add_to_stack_pointer(16);
1290
- }
1158
+ init_storage() {
1159
+ const ret = wasm.rvlite_init_storage(this.__wbg_ptr);
1160
+ return takeObject(ret);
1291
1161
  }
1292
1162
  /**
1293
1163
  * Insert a vector with optional metadata
@@ -1323,6 +1193,127 @@ var init_rvlite = __esm({
1323
1193
  wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
1324
1194
  }
1325
1195
  }
1196
+ /**
1197
+ * Insert a vector with a specific ID
1198
+ * @param {string} id
1199
+ * @param {Float32Array} vector
1200
+ * @param {any} metadata
1201
+ */
1202
+ insert_with_id(id, vector, metadata) {
1203
+ try {
1204
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1205
+ const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1206
+ const len0 = WASM_VECTOR_LEN;
1207
+ const ptr1 = passArrayF32ToWasm0(vector, wasm.__wbindgen_export);
1208
+ const len1 = WASM_VECTOR_LEN;
1209
+ wasm.rvlite_insert_with_id(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(metadata));
1210
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1211
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1212
+ if (r1) {
1213
+ throw takeObject(r0);
1214
+ }
1215
+ } finally {
1216
+ wasm.__wbindgen_add_to_stack_pointer(16);
1217
+ }
1218
+ }
1219
+ /**
1220
+ * Check if database is empty
1221
+ * @returns {boolean}
1222
+ */
1223
+ is_empty() {
1224
+ try {
1225
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1226
+ wasm.rvlite_is_empty(retptr, this.__wbg_ptr);
1227
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1228
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1229
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1230
+ if (r2) {
1231
+ throw takeObject(r1);
1232
+ }
1233
+ return r0 !== 0;
1234
+ } finally {
1235
+ wasm.__wbindgen_add_to_stack_pointer(16);
1236
+ }
1237
+ }
1238
+ /**
1239
+ * Check if database is ready
1240
+ * @returns {boolean}
1241
+ */
1242
+ is_ready() {
1243
+ const ret = wasm.rvlite_is_ready(this.__wbg_ptr);
1244
+ return ret !== 0;
1245
+ }
1246
+ /**
1247
+ * Check if IndexedDB is available in the browser
1248
+ * @returns {boolean}
1249
+ */
1250
+ static is_storage_available() {
1251
+ const ret = wasm.rvlite_is_storage_available();
1252
+ return ret !== 0;
1253
+ }
1254
+ /**
1255
+ * Get the number of vectors in the database
1256
+ * @returns {number}
1257
+ */
1258
+ len() {
1259
+ try {
1260
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1261
+ wasm.rvlite_len(retptr, this.__wbg_ptr);
1262
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1263
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1264
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1265
+ if (r2) {
1266
+ throw takeObject(r1);
1267
+ }
1268
+ return r0 >>> 0;
1269
+ } finally {
1270
+ wasm.__wbindgen_add_to_stack_pointer(16);
1271
+ }
1272
+ }
1273
+ /**
1274
+ * Load database from IndexedDB
1275
+ * Returns a Promise<RvLite> with the restored database
1276
+ * @param {RvLiteConfig} config
1277
+ * @returns {Promise<any>}
1278
+ */
1279
+ static load(config) {
1280
+ _assertClass(config, RvLiteConfig);
1281
+ var ptr0 = config.__destroy_into_raw();
1282
+ const ret = wasm.rvlite_load(ptr0);
1283
+ return takeObject(ret);
1284
+ }
1285
+ /**
1286
+ * Create a new RvLite database
1287
+ * @param {RvLiteConfig} config
1288
+ */
1289
+ constructor(config) {
1290
+ try {
1291
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1292
+ _assertClass(config, RvLiteConfig);
1293
+ var ptr0 = config.__destroy_into_raw();
1294
+ wasm.rvlite_new(retptr, ptr0);
1295
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1296
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1297
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1298
+ if (r2) {
1299
+ throw takeObject(r1);
1300
+ }
1301
+ this.__wbg_ptr = r0 >>> 0;
1302
+ RvLiteFinalization.register(this, this.__wbg_ptr, this);
1303
+ return this;
1304
+ } finally {
1305
+ wasm.__wbindgen_add_to_stack_pointer(16);
1306
+ }
1307
+ }
1308
+ /**
1309
+ * Save database state to IndexedDB
1310
+ * Returns a Promise that resolves when save is complete
1311
+ * @returns {Promise<any>}
1312
+ */
1313
+ save() {
1314
+ const ret = wasm.rvlite_save(this.__wbg_ptr);
1315
+ return takeObject(ret);
1316
+ }
1326
1317
  /**
1327
1318
  * Search for similar vectors
1328
1319
  * @param {Float32Array} query_vector
@@ -1347,21 +1338,18 @@ var init_rvlite = __esm({
1347
1338
  }
1348
1339
  }
1349
1340
  /**
1350
- * Execute SPARQL query
1351
- *
1352
- * Supported operations:
1353
- * - SELECT ?s ?p ?o WHERE { ?s ?p ?o }
1354
- * - SELECT ?s WHERE { ?s <predicate> ?o }
1355
- * - ASK { ?s ?p ?o }
1356
- * @param {string} query
1341
+ * Search with metadata filter
1342
+ * @param {Float32Array} query_vector
1343
+ * @param {number} k
1344
+ * @param {any} filter
1357
1345
  * @returns {any}
1358
1346
  */
1359
- sparql(query) {
1347
+ search_with_filter(query_vector, k, filter) {
1360
1348
  try {
1361
1349
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1362
- const ptr0 = passStringToWasm0(query, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1350
+ const ptr0 = passArrayF32ToWasm0(query_vector, wasm.__wbindgen_export);
1363
1351
  const len0 = WASM_VECTOR_LEN;
1364
- wasm.rvlite_sparql(retptr, this.__wbg_ptr, ptr0, len0);
1352
+ wasm.rvlite_search_with_filter(retptr, this.__wbg_ptr, ptr0, len0, k, addHeapObject(filter));
1365
1353
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1366
1354
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1367
1355
  var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -1374,50 +1362,68 @@ var init_rvlite = __esm({
1374
1362
  }
1375
1363
  }
1376
1364
  /**
1377
- * Create with default configuration (384 dimensions, cosine similarity)
1378
- * @returns {RvLite}
1365
+ * Execute SPARQL query
1366
+ *
1367
+ * Supported operations:
1368
+ * - SELECT ?s ?p ?o WHERE { ?s ?p ?o }
1369
+ * - SELECT ?s WHERE { ?s <predicate> ?o }
1370
+ * - ASK { ?s ?p ?o }
1371
+ * @param {string} query
1372
+ * @returns {any}
1379
1373
  */
1380
- static default() {
1374
+ sparql(query) {
1381
1375
  try {
1382
1376
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1383
- wasm.rvlite_default(retptr);
1377
+ const ptr0 = passStringToWasm0(query, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1378
+ const len0 = WASM_VECTOR_LEN;
1379
+ wasm.rvlite_sparql(retptr, this.__wbg_ptr, ptr0, len0);
1384
1380
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1385
1381
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1386
1382
  var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1387
1383
  if (r2) {
1388
1384
  throw takeObject(r1);
1389
1385
  }
1390
- return _RvLite.__wrap(r0);
1386
+ return takeObject(r0);
1391
1387
  } finally {
1392
1388
  wasm.__wbindgen_add_to_stack_pointer(16);
1393
1389
  }
1394
1390
  }
1395
1391
  /**
1396
- * Check if database is empty
1397
- * @returns {boolean}
1392
+ * Execute SQL query
1393
+ *
1394
+ * Supported syntax:
1395
+ * - CREATE TABLE vectors (id TEXT PRIMARY KEY, vector VECTOR(384))
1396
+ * - SELECT * FROM vectors WHERE id = 'x'
1397
+ * - SELECT id, vector <-> '[...]' AS distance FROM vectors ORDER BY distance LIMIT 10
1398
+ * - INSERT INTO vectors (id, vector) VALUES ('x', '[...]')
1399
+ * - DELETE FROM vectors WHERE id = 'x'
1400
+ * @param {string} query
1401
+ * @returns {any}
1398
1402
  */
1399
- is_empty() {
1403
+ sql(query) {
1400
1404
  try {
1401
1405
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1402
- wasm.rvlite_is_empty(retptr, this.__wbg_ptr);
1406
+ const ptr0 = passStringToWasm0(query, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1407
+ const len0 = WASM_VECTOR_LEN;
1408
+ wasm.rvlite_sql(retptr, this.__wbg_ptr, ptr0, len0);
1403
1409
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1404
1410
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1405
1411
  var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1406
1412
  if (r2) {
1407
1413
  throw takeObject(r1);
1408
1414
  }
1409
- return r0 !== 0;
1415
+ return takeObject(r0);
1410
1416
  } finally {
1411
1417
  wasm.__wbindgen_add_to_stack_pointer(16);
1412
1418
  }
1413
1419
  }
1414
1420
  /**
1415
- * Check if database is ready
1416
- * @returns {boolean}
1421
+ * Get the number of triples in the store
1422
+ * @returns {number}
1417
1423
  */
1418
- is_ready() {
1419
- const ret = wasm.rvlite_is_ready(this.__wbg_ptr);
1420
- return ret !== 0;
1424
+ triple_count() {
1425
+ const ret = wasm.rvlite_triple_count(this.__wbg_ptr);
1426
+ return ret >>> 0;
1421
1427
  }
1422
1428
  };
1423
1429
  if (Symbol.dispose) RvLite.prototype[Symbol.dispose] = RvLite.prototype.free;
@@ -1467,6 +1473,15 @@ var init_rvlite = __esm({
1467
1473
  wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1468
1474
  }
1469
1475
  }
1476
+ /**
1477
+ * @param {number} dimensions
1478
+ */
1479
+ constructor(dimensions) {
1480
+ const ret = wasm.rvliteconfig_new(dimensions);
1481
+ this.__wbg_ptr = ret >>> 0;
1482
+ RvLiteConfigFinalization.register(this, this.__wbg_ptr, this);
1483
+ return this;
1484
+ }
1470
1485
  /**
1471
1486
  * Set distance metric (euclidean, cosine, dotproduct, manhattan)
1472
1487
  * @param {string} metric
@@ -1479,19 +1494,43 @@ var init_rvlite = __esm({
1479
1494
  const ret = wasm.rvliteconfig_with_distance_metric(ptr, ptr0, len0);
1480
1495
  return _RvLiteConfig.__wrap(ret);
1481
1496
  }
1482
- /**
1483
- * @param {number} dimensions
1484
- */
1485
- constructor(dimensions) {
1486
- const ret = wasm.rvliteconfig_new(dimensions);
1487
- this.__wbg_ptr = ret >>> 0;
1488
- RvLiteConfigFinalization.register(this, this.__wbg_ptr, this);
1489
- return this;
1490
- }
1491
1497
  };
1492
1498
  if (Symbol.dispose) RvLiteConfig.prototype[Symbol.dispose] = RvLiteConfig.prototype.free;
1493
- EXPECTED_RESPONSE_TYPES = /* @__PURE__ */ new Set(["basic", "cors", "default"]);
1494
- rvlite_default = __wbg_init;
1499
+ __wbindgen_enum_IdbTransactionMode = ["readonly", "readwrite", "versionchange", "readwriteflush", "cleanup"];
1500
+ CypherEngineFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
1501
+ }, unregister: () => {
1502
+ } } : new FinalizationRegistry((ptr) => wasm.__wbg_cypherengine_free(ptr >>> 0, 1));
1503
+ RvLiteFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
1504
+ }, unregister: () => {
1505
+ } } : new FinalizationRegistry((ptr) => wasm.__wbg_rvlite_free(ptr >>> 0, 1));
1506
+ RvLiteConfigFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
1507
+ }, unregister: () => {
1508
+ } } : new FinalizationRegistry((ptr) => wasm.__wbg_rvliteconfig_free(ptr >>> 0, 1));
1509
+ CLOSURE_DTORS = typeof FinalizationRegistry === "undefined" ? { register: () => {
1510
+ }, unregister: () => {
1511
+ } } : new FinalizationRegistry((state) => state.dtor(state.a, state.b));
1512
+ cachedDataViewMemory0 = null;
1513
+ cachedFloat32ArrayMemory0 = null;
1514
+ cachedUint8ArrayMemory0 = null;
1515
+ heap = new Array(1024).fill(void 0);
1516
+ heap.push(void 0, null, true, false);
1517
+ heap_next = heap.length;
1518
+ cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
1519
+ cachedTextDecoder.decode();
1520
+ MAX_SAFARI_DECODE_BYTES = 2146435072;
1521
+ numBytesDecoded = 0;
1522
+ cachedTextEncoder = new TextEncoder();
1523
+ if (!("encodeInto" in cachedTextEncoder)) {
1524
+ cachedTextEncoder.encodeInto = function(arg, view) {
1525
+ const buf = cachedTextEncoder.encode(arg);
1526
+ view.set(buf);
1527
+ return {
1528
+ read: arg.length,
1529
+ written: buf.length
1530
+ };
1531
+ };
1532
+ }
1533
+ WASM_VECTOR_LEN = 0;
1495
1534
  }
1496
1535
  });
1497
1536
 
@@ -1548,9 +1587,9 @@ var RvLite2 = class _RvLite {
1548
1587
  */
1549
1588
  async init() {
1550
1589
  if (this.initialized) return;
1551
- const wasmModule = await Promise.resolve().then(() => (init_rvlite(), rvlite_exports));
1552
- await wasmModule.default();
1553
- this.wasm = new wasmModule.RvLite({
1590
+ const wasmModule2 = await Promise.resolve().then(() => (init_rvlite(), rvlite_exports));
1591
+ await wasmModule2.default();
1592
+ this.wasm = new wasmModule2.RvLite({
1554
1593
  dimensions: this.config.dimensions,
1555
1594
  distance_metric: this.config.distanceMetric
1556
1595
  });
@@ -1688,16 +1727,16 @@ var RvLite2 = class _RvLite {
1688
1727
  static async load(config = {}) {
1689
1728
  const instance = new _RvLite(config);
1690
1729
  await instance.init();
1691
- const wasmModule = await Promise.resolve().then(() => (init_rvlite(), rvlite_exports));
1692
- instance.wasm = await wasmModule.RvLite.load(config);
1730
+ const wasmModule2 = await Promise.resolve().then(() => (init_rvlite(), rvlite_exports));
1731
+ instance.wasm = await wasmModule2.RvLite.load(config);
1693
1732
  return instance;
1694
1733
  }
1695
1734
  /**
1696
1735
  * Clear IndexedDB storage (browser only)
1697
1736
  */
1698
1737
  static async clearStorage() {
1699
- const wasmModule = await Promise.resolve().then(() => (init_rvlite(), rvlite_exports));
1700
- return wasmModule.RvLite.clear_storage();
1738
+ const wasmModule2 = await Promise.resolve().then(() => (init_rvlite(), rvlite_exports));
1739
+ return wasmModule2.RvLite.clear_storage();
1701
1740
  }
1702
1741
  // ============ RVF Persistence ============
1703
1742
  /**