@loradb/lora-wasm 0.9.0 → 0.10.0

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.
@@ -1,835 +0,0 @@
1
- let wasm;
2
- export function __wbg_set_wasm(val) {
3
- wasm = val;
4
- }
5
-
6
-
7
- let WASM_VECTOR_LEN = 0;
8
-
9
- let cachedUint8ArrayMemory0 = null;
10
-
11
- function getUint8ArrayMemory0() {
12
- if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
13
- cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
14
- }
15
- return cachedUint8ArrayMemory0;
16
- }
17
-
18
- const lTextEncoder = typeof TextEncoder === 'undefined' ? (0, module.require)('util').TextEncoder : TextEncoder;
19
-
20
- let cachedTextEncoder = new lTextEncoder('utf-8');
21
-
22
- const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
23
- ? function (arg, view) {
24
- return cachedTextEncoder.encodeInto(arg, view);
25
- }
26
- : function (arg, view) {
27
- const buf = cachedTextEncoder.encode(arg);
28
- view.set(buf);
29
- return {
30
- read: arg.length,
31
- written: buf.length
32
- };
33
- });
34
-
35
- function passStringToWasm0(arg, malloc, realloc) {
36
-
37
- if (realloc === undefined) {
38
- const buf = cachedTextEncoder.encode(arg);
39
- const ptr = malloc(buf.length, 1) >>> 0;
40
- getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
41
- WASM_VECTOR_LEN = buf.length;
42
- return ptr;
43
- }
44
-
45
- let len = arg.length;
46
- let ptr = malloc(len, 1) >>> 0;
47
-
48
- const mem = getUint8ArrayMemory0();
49
-
50
- let offset = 0;
51
-
52
- for (; offset < len; offset++) {
53
- const code = arg.charCodeAt(offset);
54
- if (code > 0x7F) break;
55
- mem[ptr + offset] = code;
56
- }
57
-
58
- if (offset !== len) {
59
- if (offset !== 0) {
60
- arg = arg.slice(offset);
61
- }
62
- ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
63
- const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
64
- const ret = encodeString(arg, view);
65
-
66
- offset += ret.written;
67
- ptr = realloc(ptr, len, offset, 1) >>> 0;
68
- }
69
-
70
- WASM_VECTOR_LEN = offset;
71
- return ptr;
72
- }
73
-
74
- let cachedDataViewMemory0 = null;
75
-
76
- function getDataViewMemory0() {
77
- if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
78
- cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
79
- }
80
- return cachedDataViewMemory0;
81
- }
82
-
83
- function addToExternrefTable0(obj) {
84
- const idx = wasm.__externref_table_alloc();
85
- wasm.__wbindgen_export_4.set(idx, obj);
86
- return idx;
87
- }
88
-
89
- function handleError(f, args) {
90
- try {
91
- return f.apply(this, args);
92
- } catch (e) {
93
- const idx = addToExternrefTable0(e);
94
- wasm.__wbindgen_exn_store(idx);
95
- }
96
- }
97
-
98
- const lTextDecoder = typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder;
99
-
100
- let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true });
101
-
102
- cachedTextDecoder.decode();
103
-
104
- function getStringFromWasm0(ptr, len) {
105
- ptr = ptr >>> 0;
106
- return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
107
- }
108
-
109
- function isLikeNone(x) {
110
- return x === undefined || x === null;
111
- }
112
-
113
- function debugString(val) {
114
- // primitive types
115
- const type = typeof val;
116
- if (type == 'number' || type == 'boolean' || val == null) {
117
- return `${val}`;
118
- }
119
- if (type == 'string') {
120
- return `"${val}"`;
121
- }
122
- if (type == 'symbol') {
123
- const description = val.description;
124
- if (description == null) {
125
- return 'Symbol';
126
- } else {
127
- return `Symbol(${description})`;
128
- }
129
- }
130
- if (type == 'function') {
131
- const name = val.name;
132
- if (typeof name == 'string' && name.length > 0) {
133
- return `Function(${name})`;
134
- } else {
135
- return 'Function';
136
- }
137
- }
138
- // objects
139
- if (Array.isArray(val)) {
140
- const length = val.length;
141
- let debug = '[';
142
- if (length > 0) {
143
- debug += debugString(val[0]);
144
- }
145
- for(let i = 1; i < length; i++) {
146
- debug += ', ' + debugString(val[i]);
147
- }
148
- debug += ']';
149
- return debug;
150
- }
151
- // Test for built-in
152
- const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
153
- let className;
154
- if (builtInMatches && builtInMatches.length > 1) {
155
- className = builtInMatches[1];
156
- } else {
157
- // Failed to match the standard '[object ClassName]'
158
- return toString.call(val);
159
- }
160
- if (className == 'Object') {
161
- // we're a user defined class or Object
162
- // JSON.stringify avoids problems with cycles, and is generally much
163
- // easier than looping through ownProperties of `val`.
164
- try {
165
- return 'Object(' + JSON.stringify(val) + ')';
166
- } catch (_) {
167
- return 'Object';
168
- }
169
- }
170
- // errors
171
- if (val instanceof Error) {
172
- return `${val.name}: ${val.message}\n${val.stack}`;
173
- }
174
- // TODO we could test for more things here, like `Set`s and `Map`s.
175
- return className;
176
- }
177
-
178
- function takeFromExternrefTable0(idx) {
179
- const value = wasm.__wbindgen_export_4.get(idx);
180
- wasm.__externref_table_dealloc(idx);
181
- return value;
182
- }
183
-
184
- function passArray8ToWasm0(arg, malloc) {
185
- const ptr = malloc(arg.length * 1, 1) >>> 0;
186
- getUint8ArrayMemory0().set(arg, ptr / 1);
187
- WASM_VECTOR_LEN = arg.length;
188
- return ptr;
189
- }
190
-
191
- function getArrayU8FromWasm0(ptr, len) {
192
- ptr = ptr >>> 0;
193
- return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
194
- }
195
- /**
196
- * Call once at module start to install a panic hook that routes Rust
197
- * panics to `console.error`. No-op if compiled without the default feature.
198
- */
199
- export function init() {
200
- wasm.init();
201
- }
202
-
203
- const WasmDatabaseFinalization = (typeof FinalizationRegistry === 'undefined')
204
- ? { register: () => {}, unregister: () => {} }
205
- : new FinalizationRegistry(ptr => wasm.__wbg_wasmdatabase_free(ptr >>> 0, 1));
206
- /**
207
- * In-memory Lora graph database handle.
208
- */
209
- export class WasmDatabase {
210
-
211
- __destroy_into_raw() {
212
- const ptr = this.__wbg_ptr;
213
- this.__wbg_ptr = 0;
214
- WasmDatabaseFinalization.unregister(this);
215
- return ptr;
216
- }
217
-
218
- free() {
219
- const ptr = this.__destroy_into_raw();
220
- wasm.__wbg_wasmdatabase_free(ptr, 0);
221
- }
222
- /**
223
- * @returns {number}
224
- */
225
- nodeCount() {
226
- const ret = wasm.wasmdatabase_nodeCount(this.__wbg_ptr);
227
- return ret >>> 0;
228
- }
229
- /**
230
- * Open a true native row stream. Rows are pulled from the Rust executor
231
- * one `next()` call at a time.
232
- * @param {string} query
233
- * @param {any} params
234
- * @returns {WasmQueryStream}
235
- */
236
- openStream(query, params) {
237
- const ptr0 = passStringToWasm0(query, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
238
- const len0 = WASM_VECTOR_LEN;
239
- const ret = wasm.wasmdatabase_openStream(this.__wbg_ptr, ptr0, len0, params);
240
- if (ret[2]) {
241
- throw takeFromExternrefTable0(ret[1]);
242
- }
243
- return WasmQueryStream.__wrap(ret[0]);
244
- }
245
- /**
246
- * Execute an array of `{ query, params? }` statements inside one native
247
- * transaction. Returns an array of query results in statement order.
248
- * @param {any} statements
249
- * @param {string | null} [mode]
250
- * @returns {any}
251
- */
252
- transaction(statements, mode) {
253
- var ptr0 = isLikeNone(mode) ? 0 : passStringToWasm0(mode, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
254
- var len0 = WASM_VECTOR_LEN;
255
- const ret = wasm.wasmdatabase_transaction(this.__wbg_ptr, statements, ptr0, len0);
256
- if (ret[2]) {
257
- throw takeFromExternrefTable0(ret[1]);
258
- }
259
- return takeFromExternrefTable0(ret[0]);
260
- }
261
- /**
262
- * Replace the graph state with a database snapshot decoded from `bytes`.
263
- * Legacy store snapshot bytes are accepted for compatibility.
264
- *
265
- * Returns a plain object matching the shape of `SnapshotMeta`:
266
- * `{ formatVersion, nodeCount, relationshipCount, walLsn }`.
267
- * @param {Uint8Array} bytes
268
- * @param {any} options
269
- * @returns {any}
270
- */
271
- loadSnapshot(bytes, options) {
272
- const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
273
- const len0 = WASM_VECTOR_LEN;
274
- const ret = wasm.wasmdatabase_loadSnapshot(this.__wbg_ptr, ptr0, len0, options);
275
- if (ret[2]) {
276
- throw takeFromExternrefTable0(ret[1]);
277
- }
278
- return takeFromExternrefTable0(ret[0]);
279
- }
280
- /**
281
- * Serialize the graph into database snapshot bytes. The caller is
282
- * responsible for writing them to IndexedDB, localStorage, a server, or
283
- * another host-provided store — WASM has no direct filesystem access.
284
- * The returned bytes can later be passed to `loadSnapshot` on any
285
- * `WasmDatabase` instance.
286
- *
287
- * Returns the serialized bytes as a `Uint8Array`.
288
- * @param {any} options
289
- * @returns {Uint8Array}
290
- */
291
- saveSnapshot(options) {
292
- const ret = wasm.wasmdatabase_saveSnapshot(this.__wbg_ptr, options);
293
- if (ret[3]) {
294
- throw takeFromExternrefTable0(ret[2]);
295
- }
296
- var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
297
- wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
298
- return v1;
299
- }
300
- /**
301
- * Execute a Lora query and return the result as a binary buffer.
302
- *
303
- * Wire format is the shared `lora_binding_buffer` layout. The TS
304
- * wrapper decodes it once into the same `{ columns, rows }` shape
305
- * `execute()` returns, but in a tight V8 loop instead of going
306
- * through `serde_wasm_bindgen` value-by-value. Materially faster
307
- * on bulk reads.
308
- * @param {string} query
309
- * @param {any} params
310
- * @returns {Uint8Array}
311
- */
312
- executeBuffer(query, params) {
313
- const ptr0 = passStringToWasm0(query, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
314
- const len0 = WASM_VECTOR_LEN;
315
- const ret = wasm.wasmdatabase_executeBuffer(this.__wbg_ptr, ptr0, len0, params);
316
- if (ret[3]) {
317
- throw takeFromExternrefTable0(ret[2]);
318
- }
319
- var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
320
- wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
321
- return v2;
322
- }
323
- /**
324
- * @returns {number}
325
- */
326
- relationshipCount() {
327
- const ret = wasm.wasmdatabase_relationshipCount(this.__wbg_ptr);
328
- return ret >>> 0;
329
- }
330
- constructor() {
331
- const ret = wasm.wasmdatabase_new();
332
- this.__wbg_ptr = ret >>> 0;
333
- WasmDatabaseFinalization.register(this, this.__wbg_ptr, this);
334
- return this;
335
- }
336
- clear() {
337
- wasm.wasmdatabase_clear(this.__wbg_ptr);
338
- }
339
- /**
340
- * Execute a Lora query. `params` may be `undefined`, `null`, or a
341
- * plain object keyed by parameter name.
342
- *
343
- * Returns `{ columns: string[], rows: Array<Record<string, LoraValue>> }`
344
- * as a plain JS object (structured-clonable).
345
- * @param {string} query
346
- * @param {any} params
347
- * @returns {any}
348
- */
349
- execute(query, params) {
350
- const ptr0 = passStringToWasm0(query, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
351
- const len0 = WASM_VECTOR_LEN;
352
- const ret = wasm.wasmdatabase_execute(this.__wbg_ptr, ptr0, len0, params);
353
- if (ret[2]) {
354
- throw takeFromExternrefTable0(ret[1]);
355
- }
356
- return takeFromExternrefTable0(ret[0]);
357
- }
358
- /**
359
- * Compile a query and return its plan without executing it.
360
- *
361
- * Mutating queries (CREATE / MERGE / SET / DELETE / REMOVE) leave
362
- * the graph untouched — this method never runs the executor.
363
- * @param {string} query
364
- * @param {any} params
365
- * @returns {any}
366
- */
367
- explain(query, params) {
368
- const ptr0 = passStringToWasm0(query, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
369
- const len0 = WASM_VECTOR_LEN;
370
- const ret = wasm.wasmdatabase_explain(this.__wbg_ptr, ptr0, len0, params);
371
- if (ret[2]) {
372
- throw takeFromExternrefTable0(ret[1]);
373
- }
374
- return takeFromExternrefTable0(ret[0]);
375
- }
376
- /**
377
- * Execute a query and return the plan plus runtime metrics.
378
- *
379
- * **PROFILE executes the query for real.** Mutating queries are
380
- * persisted exactly as in `execute()`. Use `explain()` to inspect
381
- * a mutating plan without running it.
382
- * @param {string} query
383
- * @param {any} params
384
- * @returns {any}
385
- */
386
- profile(query, params) {
387
- const ptr0 = passStringToWasm0(query, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
388
- const len0 = WASM_VECTOR_LEN;
389
- const ret = wasm.wasmdatabase_profile(this.__wbg_ptr, ptr0, len0, params);
390
- if (ret[2]) {
391
- throw takeFromExternrefTable0(ret[1]);
392
- }
393
- return takeFromExternrefTable0(ret[0]);
394
- }
395
- }
396
-
397
- const WasmQueryStreamFinalization = (typeof FinalizationRegistry === 'undefined')
398
- ? { register: () => {}, unregister: () => {} }
399
- : new FinalizationRegistry(ptr => wasm.__wbg_wasmquerystream_free(ptr >>> 0, 1));
400
-
401
- export class WasmQueryStream {
402
-
403
- static __wrap(ptr) {
404
- ptr = ptr >>> 0;
405
- const obj = Object.create(WasmQueryStream.prototype);
406
- obj.__wbg_ptr = ptr;
407
- WasmQueryStreamFinalization.register(obj, obj.__wbg_ptr, obj);
408
- return obj;
409
- }
410
-
411
- __destroy_into_raw() {
412
- const ptr = this.__wbg_ptr;
413
- this.__wbg_ptr = 0;
414
- WasmQueryStreamFinalization.unregister(this);
415
- return ptr;
416
- }
417
-
418
- free() {
419
- const ptr = this.__destroy_into_raw();
420
- wasm.__wbg_wasmquerystream_free(ptr, 0);
421
- }
422
- /**
423
- * @returns {any}
424
- */
425
- next() {
426
- const ret = wasm.wasmquerystream_next(this.__wbg_ptr);
427
- if (ret[2]) {
428
- throw takeFromExternrefTable0(ret[1]);
429
- }
430
- return takeFromExternrefTable0(ret[0]);
431
- }
432
- close() {
433
- wasm.wasmquerystream_close(this.__wbg_ptr);
434
- }
435
- /**
436
- * @returns {any}
437
- */
438
- columns() {
439
- const ret = wasm.wasmquerystream_columns(this.__wbg_ptr);
440
- if (ret[2]) {
441
- throw takeFromExternrefTable0(ret[1]);
442
- }
443
- return takeFromExternrefTable0(ret[0]);
444
- }
445
- }
446
-
447
- export function __wbg_String_8f0eb39a4a4c2f66(arg0, arg1) {
448
- const ret = String(arg1);
449
- const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
450
- const len1 = WASM_VECTOR_LEN;
451
- getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
452
- getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
453
- };
454
-
455
- export function __wbg_buffer_609cc3eee51ed158(arg0) {
456
- const ret = arg0.buffer;
457
- return ret;
458
- };
459
-
460
- export function __wbg_call_672a4d21634d4a24() { return handleError(function (arg0, arg1) {
461
- const ret = arg0.call(arg1);
462
- return ret;
463
- }, arguments) };
464
-
465
- export function __wbg_call_7cccdd69e0791ae2() { return handleError(function (arg0, arg1, arg2) {
466
- const ret = arg0.call(arg1, arg2);
467
- return ret;
468
- }, arguments) };
469
-
470
- export function __wbg_crypto_86f2631e91b51511(arg0) {
471
- const ret = arg0.crypto;
472
- return ret;
473
- };
474
-
475
- export function __wbg_done_769e5ede4b31c67b(arg0) {
476
- const ret = arg0.done;
477
- return ret;
478
- };
479
-
480
- export function __wbg_entries_3265d4158b33e5dc(arg0) {
481
- const ret = Object.entries(arg0);
482
- return ret;
483
- };
484
-
485
- export function __wbg_error_7534b8e9a36f1ab4(arg0, arg1) {
486
- let deferred0_0;
487
- let deferred0_1;
488
- try {
489
- deferred0_0 = arg0;
490
- deferred0_1 = arg1;
491
- console.error(getStringFromWasm0(arg0, arg1));
492
- } finally {
493
- wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
494
- }
495
- };
496
-
497
- export function __wbg_getRandomValues_b3f15fcbfabb0f8b() { return handleError(function (arg0, arg1) {
498
- arg0.getRandomValues(arg1);
499
- }, arguments) };
500
-
501
- export function __wbg_get_67b2ba62fc30de12() { return handleError(function (arg0, arg1) {
502
- const ret = Reflect.get(arg0, arg1);
503
- return ret;
504
- }, arguments) };
505
-
506
- export function __wbg_get_b9b93047fe3cf45b(arg0, arg1) {
507
- const ret = arg0[arg1 >>> 0];
508
- return ret;
509
- };
510
-
511
- export function __wbg_instanceof_ArrayBuffer_e14585432e3737fc(arg0) {
512
- let result;
513
- try {
514
- result = arg0 instanceof ArrayBuffer;
515
- } catch (_) {
516
- result = false;
517
- }
518
- const ret = result;
519
- return ret;
520
- };
521
-
522
- export function __wbg_instanceof_Map_f3469ce2244d2430(arg0) {
523
- let result;
524
- try {
525
- result = arg0 instanceof Map;
526
- } catch (_) {
527
- result = false;
528
- }
529
- const ret = result;
530
- return ret;
531
- };
532
-
533
- export function __wbg_instanceof_Uint8Array_17156bcf118086a9(arg0) {
534
- let result;
535
- try {
536
- result = arg0 instanceof Uint8Array;
537
- } catch (_) {
538
- result = false;
539
- }
540
- const ret = result;
541
- return ret;
542
- };
543
-
544
- export function __wbg_isArray_a1eab7e0d067391b(arg0) {
545
- const ret = Array.isArray(arg0);
546
- return ret;
547
- };
548
-
549
- export function __wbg_isSafeInteger_343e2beeeece1bb0(arg0) {
550
- const ret = Number.isSafeInteger(arg0);
551
- return ret;
552
- };
553
-
554
- export function __wbg_iterator_9a24c88df860dc65() {
555
- const ret = Symbol.iterator;
556
- return ret;
557
- };
558
-
559
- export function __wbg_length_a446193dc22c12f8(arg0) {
560
- const ret = arg0.length;
561
- return ret;
562
- };
563
-
564
- export function __wbg_length_e2d2a49132c1b256(arg0) {
565
- const ret = arg0.length;
566
- return ret;
567
- };
568
-
569
- export function __wbg_msCrypto_d562bbe83e0d4b91(arg0) {
570
- const ret = arg0.msCrypto;
571
- return ret;
572
- };
573
-
574
- export function __wbg_new_405e22f390576ce2() {
575
- const ret = new Object();
576
- return ret;
577
- };
578
-
579
- export function __wbg_new_5e0be73521bc8c17() {
580
- const ret = new Map();
581
- return ret;
582
- };
583
-
584
- export function __wbg_new_78feb108b6472713() {
585
- const ret = new Array();
586
- return ret;
587
- };
588
-
589
- export function __wbg_new_8a6f238a6ece86ea() {
590
- const ret = new Error();
591
- return ret;
592
- };
593
-
594
- export function __wbg_new_a12002a7f91c75be(arg0) {
595
- const ret = new Uint8Array(arg0);
596
- return ret;
597
- };
598
-
599
- export function __wbg_newnoargs_105ed471475aaf50(arg0, arg1) {
600
- const ret = new Function(getStringFromWasm0(arg0, arg1));
601
- return ret;
602
- };
603
-
604
- export function __wbg_newwithbyteoffsetandlength_d97e637ebe145a9a(arg0, arg1, arg2) {
605
- const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
606
- return ret;
607
- };
608
-
609
- export function __wbg_newwithlength_a381634e90c276d4(arg0) {
610
- const ret = new Uint8Array(arg0 >>> 0);
611
- return ret;
612
- };
613
-
614
- export function __wbg_next_25feadfc0913fea9(arg0) {
615
- const ret = arg0.next;
616
- return ret;
617
- };
618
-
619
- export function __wbg_next_6574e1a8a62d1055() { return handleError(function (arg0) {
620
- const ret = arg0.next();
621
- return ret;
622
- }, arguments) };
623
-
624
- export function __wbg_node_e1f24f89a7336c2e(arg0) {
625
- const ret = arg0.node;
626
- return ret;
627
- };
628
-
629
- export function __wbg_now_807e54c39636c349() {
630
- const ret = Date.now();
631
- return ret;
632
- };
633
-
634
- export function __wbg_process_3975fd6c72f520aa(arg0) {
635
- const ret = arg0.process;
636
- return ret;
637
- };
638
-
639
- export function __wbg_randomFillSync_f8c153b79f285817() { return handleError(function (arg0, arg1) {
640
- arg0.randomFillSync(arg1);
641
- }, arguments) };
642
-
643
- export function __wbg_require_b74f47fc2d022fd6() { return handleError(function () {
644
- const ret = module.require;
645
- return ret;
646
- }, arguments) };
647
-
648
- export function __wbg_set_37837023f3d740e8(arg0, arg1, arg2) {
649
- arg0[arg1 >>> 0] = arg2;
650
- };
651
-
652
- export function __wbg_set_3f1d0b984ed272ed(arg0, arg1, arg2) {
653
- arg0[arg1] = arg2;
654
- };
655
-
656
- export function __wbg_set_65595bdd868b3009(arg0, arg1, arg2) {
657
- arg0.set(arg1, arg2 >>> 0);
658
- };
659
-
660
- export function __wbg_set_8fc6bf8a5b1071d1(arg0, arg1, arg2) {
661
- const ret = arg0.set(arg1, arg2);
662
- return ret;
663
- };
664
-
665
- export function __wbg_stack_0ed75d68575b0f3c(arg0, arg1) {
666
- const ret = arg1.stack;
667
- const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
668
- const len1 = WASM_VECTOR_LEN;
669
- getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
670
- getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
671
- };
672
-
673
- export function __wbg_static_accessor_GLOBAL_88a902d13a557d07() {
674
- const ret = typeof global === 'undefined' ? null : global;
675
- return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
676
- };
677
-
678
- export function __wbg_static_accessor_GLOBAL_THIS_56578be7e9f832b0() {
679
- const ret = typeof globalThis === 'undefined' ? null : globalThis;
680
- return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
681
- };
682
-
683
- export function __wbg_static_accessor_SELF_37c5d418e4bf5819() {
684
- const ret = typeof self === 'undefined' ? null : self;
685
- return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
686
- };
687
-
688
- export function __wbg_static_accessor_WINDOW_5de37043a91a9c40() {
689
- const ret = typeof window === 'undefined' ? null : window;
690
- return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
691
- };
692
-
693
- export function __wbg_subarray_aa9065fa9dc5df96(arg0, arg1, arg2) {
694
- const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
695
- return ret;
696
- };
697
-
698
- export function __wbg_value_cd1ffa7b1ab794f1(arg0) {
699
- const ret = arg0.value;
700
- return ret;
701
- };
702
-
703
- export function __wbg_versions_4e31226f5e8dc909(arg0) {
704
- const ret = arg0.versions;
705
- return ret;
706
- };
707
-
708
- export function __wbindgen_bigint_from_i64(arg0) {
709
- const ret = arg0;
710
- return ret;
711
- };
712
-
713
- export function __wbindgen_bigint_from_u64(arg0) {
714
- const ret = BigInt.asUintN(64, arg0);
715
- return ret;
716
- };
717
-
718
- export function __wbindgen_bigint_get_as_i64(arg0, arg1) {
719
- const v = arg1;
720
- const ret = typeof(v) === 'bigint' ? v : undefined;
721
- getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
722
- getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
723
- };
724
-
725
- export function __wbindgen_boolean_get(arg0) {
726
- const v = arg0;
727
- const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
728
- return ret;
729
- };
730
-
731
- export function __wbindgen_debug_string(arg0, arg1) {
732
- const ret = debugString(arg1);
733
- const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
734
- const len1 = WASM_VECTOR_LEN;
735
- getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
736
- getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
737
- };
738
-
739
- export function __wbindgen_error_new(arg0, arg1) {
740
- const ret = new Error(getStringFromWasm0(arg0, arg1));
741
- return ret;
742
- };
743
-
744
- export function __wbindgen_in(arg0, arg1) {
745
- const ret = arg0 in arg1;
746
- return ret;
747
- };
748
-
749
- export function __wbindgen_init_externref_table() {
750
- const table = wasm.__wbindgen_export_4;
751
- const offset = table.grow(4);
752
- table.set(0, undefined);
753
- table.set(offset + 0, undefined);
754
- table.set(offset + 1, null);
755
- table.set(offset + 2, true);
756
- table.set(offset + 3, false);
757
- ;
758
- };
759
-
760
- export function __wbindgen_is_bigint(arg0) {
761
- const ret = typeof(arg0) === 'bigint';
762
- return ret;
763
- };
764
-
765
- export function __wbindgen_is_function(arg0) {
766
- const ret = typeof(arg0) === 'function';
767
- return ret;
768
- };
769
-
770
- export function __wbindgen_is_null(arg0) {
771
- const ret = arg0 === null;
772
- return ret;
773
- };
774
-
775
- export function __wbindgen_is_object(arg0) {
776
- const val = arg0;
777
- const ret = typeof(val) === 'object' && val !== null;
778
- return ret;
779
- };
780
-
781
- export function __wbindgen_is_string(arg0) {
782
- const ret = typeof(arg0) === 'string';
783
- return ret;
784
- };
785
-
786
- export function __wbindgen_is_undefined(arg0) {
787
- const ret = arg0 === undefined;
788
- return ret;
789
- };
790
-
791
- export function __wbindgen_jsval_eq(arg0, arg1) {
792
- const ret = arg0 === arg1;
793
- return ret;
794
- };
795
-
796
- export function __wbindgen_jsval_loose_eq(arg0, arg1) {
797
- const ret = arg0 == arg1;
798
- return ret;
799
- };
800
-
801
- export function __wbindgen_memory() {
802
- const ret = wasm.memory;
803
- return ret;
804
- };
805
-
806
- export function __wbindgen_number_get(arg0, arg1) {
807
- const obj = arg1;
808
- const ret = typeof(obj) === 'number' ? obj : undefined;
809
- getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
810
- getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
811
- };
812
-
813
- export function __wbindgen_number_new(arg0) {
814
- const ret = arg0;
815
- return ret;
816
- };
817
-
818
- export function __wbindgen_string_get(arg0, arg1) {
819
- const obj = arg1;
820
- const ret = typeof(obj) === 'string' ? obj : undefined;
821
- var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
822
- var len1 = WASM_VECTOR_LEN;
823
- getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
824
- getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
825
- };
826
-
827
- export function __wbindgen_string_new(arg0, arg1) {
828
- const ret = getStringFromWasm0(arg0, arg1);
829
- return ret;
830
- };
831
-
832
- export function __wbindgen_throw(arg0, arg1) {
833
- throw new Error(getStringFromWasm0(arg0, arg1));
834
- };
835
-