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