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 +821 -782
- package/dist/index.mjs +821 -782
- package/dist/wasm/package.json +1 -1
- package/dist/wasm/rvlite.d.ts +259 -250
- package/dist/wasm/rvlite.js +1115 -1085
- package/dist/wasm/rvlite_bg.wasm +0 -0
- package/dist/wasm/rvlite_bg.wasm.d.ts +5 -5
- package/package.json +1 -1
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: () =>
|
|
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 <
|
|
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
|
|
213
|
-
wasm
|
|
214
|
-
|
|
215
|
-
|
|
216
|
-
|
|
217
|
-
|
|
218
|
-
|
|
219
|
-
wasm
|
|
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 &&
|
|
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
|
-
|
|
250
|
-
|
|
251
|
-
|
|
252
|
-
|
|
253
|
-
|
|
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
|
-
|
|
442
|
-
|
|
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 (
|
|
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 (
|
|
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 (
|
|
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
|
|
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
|
-
*
|
|
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
|
-
*
|
|
805
|
+
* Execute a Cypher query and return JSON results
|
|
806
|
+
* @param {string} query
|
|
809
807
|
* @returns {any}
|
|
810
808
|
*/
|
|
811
|
-
|
|
809
|
+
execute(query) {
|
|
812
810
|
try {
|
|
813
811
|
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
814
|
-
wasm.
|
|
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
|
-
*
|
|
828
|
-
|
|
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
|
-
|
|
839
|
+
stats() {
|
|
832
840
|
try {
|
|
833
841
|
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
834
|
-
|
|
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
|
-
*
|
|
900
|
-
* @returns {any}
|
|
905
|
+
* Clear saved state from IndexedDB
|
|
906
|
+
* @returns {Promise<any>}
|
|
901
907
|
*/
|
|
902
|
-
|
|
903
|
-
|
|
904
|
-
|
|
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
|
-
*
|
|
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
|
-
|
|
929
|
+
cypher(query) {
|
|
922
930
|
try {
|
|
923
931
|
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
924
|
-
wasm.
|
|
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
|
-
*
|
|
1000
|
-
* @returns {
|
|
972
|
+
* Create with default configuration (384 dimensions, cosine similarity)
|
|
973
|
+
* @returns {RvLite}
|
|
1001
974
|
*/
|
|
1002
|
-
|
|
975
|
+
static default() {
|
|
1003
976
|
try {
|
|
1004
977
|
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
1005
|
-
wasm.
|
|
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
|
|
985
|
+
return _RvLite.__wrap(r0);
|
|
1013
986
|
} finally {
|
|
1014
987
|
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
1015
988
|
}
|
|
1016
989
|
}
|
|
1017
990
|
/**
|
|
1018
|
-
*
|
|
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
|
-
* @
|
|
1052
|
-
* @param {any} metadata
|
|
993
|
+
* @returns {boolean}
|
|
1053
994
|
*/
|
|
1054
|
-
|
|
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
|
-
|
|
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
|
-
|
|
1065
|
-
|
|
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
|
-
*
|
|
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
|
-
|
|
1016
|
+
export_json() {
|
|
1087
1017
|
try {
|
|
1088
1018
|
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
1089
|
-
|
|
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
|
|
1135
|
-
* @returns {
|
|
1054
|
+
* Get configuration
|
|
1055
|
+
* @returns {any}
|
|
1136
1056
|
*/
|
|
1137
|
-
|
|
1057
|
+
get_config() {
|
|
1138
1058
|
try {
|
|
1139
1059
|
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
1140
|
-
wasm.
|
|
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
|
|
1067
|
+
return takeObject(r0);
|
|
1148
1068
|
} finally {
|
|
1149
1069
|
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
1150
1070
|
}
|
|
1151
1071
|
}
|
|
1152
1072
|
/**
|
|
1153
|
-
*
|
|
1154
|
-
* @
|
|
1073
|
+
* Get enabled features
|
|
1074
|
+
* @returns {any}
|
|
1155
1075
|
*/
|
|
1156
|
-
|
|
1076
|
+
get_features() {
|
|
1157
1077
|
try {
|
|
1158
1078
|
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
1159
|
-
|
|
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
|
-
|
|
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
|
-
*
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
1196
|
-
|
|
1197
|
-
|
|
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
|
-
*
|
|
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
|
|
1211
|
-
|
|
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
|
-
*
|
|
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
|
-
|
|
1123
|
+
import_json(json) {
|
|
1237
1124
|
try {
|
|
1238
1125
|
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
1239
|
-
|
|
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
|
-
|
|
1245
|
-
|
|
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
|
-
*
|
|
1255
|
-
*
|
|
1256
|
-
* @returns {
|
|
1137
|
+
* Initialize IndexedDB storage for persistence
|
|
1138
|
+
* Must be called before save() or load()
|
|
1139
|
+
* @returns {Promise<any>}
|
|
1257
1140
|
*/
|
|
1258
|
-
|
|
1259
|
-
|
|
1260
|
-
|
|
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
|
-
*
|
|
1334
|
-
*
|
|
1335
|
-
*
|
|
1336
|
-
*
|
|
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
|
-
|
|
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 =
|
|
1333
|
+
const ptr0 = passArrayF32ToWasm0(query_vector, wasm.__wbindgen_export);
|
|
1346
1334
|
const len0 = WASM_VECTOR_LEN;
|
|
1347
|
-
wasm.
|
|
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
|
-
*
|
|
1361
|
-
*
|
|
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
|
-
|
|
1357
|
+
sparql(query) {
|
|
1364
1358
|
try {
|
|
1365
1359
|
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
1366
|
-
wasm.
|
|
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
|
|
1369
|
+
return takeObject(r0);
|
|
1374
1370
|
} finally {
|
|
1375
1371
|
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
1376
1372
|
}
|
|
1377
1373
|
}
|
|
1378
1374
|
/**
|
|
1379
|
-
*
|
|
1380
|
-
*
|
|
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
|
-
|
|
1386
|
+
sql(query) {
|
|
1383
1387
|
try {
|
|
1384
1388
|
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
|
1385
|
-
wasm.
|
|
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
|
|
1398
|
+
return takeObject(r0);
|
|
1393
1399
|
} finally {
|
|
1394
1400
|
wasm.__wbindgen_add_to_stack_pointer(16);
|
|
1395
1401
|
}
|
|
1396
1402
|
}
|
|
1397
1403
|
/**
|
|
1398
|
-
*
|
|
1399
|
-
* @returns {
|
|
1404
|
+
* Get the number of triples in the store
|
|
1405
|
+
* @returns {number}
|
|
1400
1406
|
*/
|
|
1401
|
-
|
|
1402
|
-
const ret = wasm.
|
|
1403
|
-
return ret
|
|
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
|
-
|
|
1477
|
-
|
|
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
|
|
1515
|
-
await
|
|
1516
|
-
this.wasm = new
|
|
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
|
|
1655
|
-
instance.wasm = await
|
|
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
|
|
1663
|
-
return
|
|
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
|
/**
|