incroxigraph-js 0.0.0-stage → 0.0.1

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.
@@ -0,0 +1,1161 @@
1
+ import { factory } from './snippets/incroxigraph-js-a4ed36773eeebefc/src/data_model.js';
2
+
3
+
4
+ class AsyncParserIterator {
5
+ static __wrap(ptr) {
6
+ const obj = Object.create(AsyncParserIterator.prototype);
7
+ obj.__wbg_ptr = ptr;
8
+ AsyncParserIteratorFinalization.register(obj, obj.__wbg_ptr, obj);
9
+ return obj;
10
+ }
11
+ __destroy_into_raw() {
12
+ const ptr = this.__wbg_ptr;
13
+ this.__wbg_ptr = 0;
14
+ AsyncParserIteratorFinalization.unregister(this);
15
+ return ptr;
16
+ }
17
+ free() {
18
+ const ptr = this.__destroy_into_raw();
19
+ wasm.__wbg_asyncparseriterator_free(ptr, 0);
20
+ }
21
+ /**
22
+ * @returns {AsyncParserIterator}
23
+ */
24
+ [Symbol.asyncIterator]() {
25
+ const ptr = this.__destroy_into_raw();
26
+ const ret = wasm.asyncparseriterator_Symbol_asyncIterator(ptr);
27
+ return AsyncParserIterator.__wrap(ret);
28
+ }
29
+ /**
30
+ * @returns {Promise<ParserIteratorResult>}
31
+ */
32
+ next() {
33
+ const ret = wasm.asyncparseriterator_next(this.__wbg_ptr);
34
+ return ret;
35
+ }
36
+ }
37
+ if (Symbol.dispose) AsyncParserIterator.prototype[Symbol.dispose] = AsyncParserIterator.prototype.free;
38
+
39
+ /**
40
+ * One occurrence added to or removed from a query result.
41
+ * @enum {0 | 1}
42
+ */
43
+ export const DeltaKind = Object.freeze({
44
+ Addition: 0, "0": "Addition",
45
+ Deletion: 1, "1": "Deletion",
46
+ });
47
+
48
+ /**
49
+ * A synchronous live query returning consumed, owned batches of changes.
50
+ */
51
+ export class IncrementalQueryDeltas {
52
+ static __wrap(ptr) {
53
+ const obj = Object.create(IncrementalQueryDeltas.prototype);
54
+ obj.__wbg_ptr = ptr;
55
+ IncrementalQueryDeltasFinalization.register(obj, obj.__wbg_ptr, obj);
56
+ return obj;
57
+ }
58
+ __destroy_into_raw() {
59
+ const ptr = this.__wbg_ptr;
60
+ this.__wbg_ptr = 0;
61
+ IncrementalQueryDeltasFinalization.unregister(this);
62
+ return ptr;
63
+ }
64
+ free() {
65
+ const ptr = this.__destroy_into_raw();
66
+ wasm.__wbg_incrementalquerydeltas_free(ptr, 0);
67
+ }
68
+ close() {
69
+ wasm.incrementalquerydeltas_close(this.__wbg_ptr);
70
+ }
71
+ /**
72
+ * @returns {boolean}
73
+ */
74
+ get closed() {
75
+ const ret = wasm.incrementalquerydeltas_closed(this.__wbg_ptr);
76
+ return ret !== 0;
77
+ }
78
+ /**
79
+ * SELECT/CONSTRUCT return Delta records; ASK returns zero or one booleans.
80
+ * @returns {any}
81
+ */
82
+ deltas() {
83
+ const ret = wasm.incrementalquerydeltas_deltas(this.__wbg_ptr);
84
+ if (ret[2]) {
85
+ throw takeFromExternrefTable0(ret[1]);
86
+ }
87
+ return takeFromExternrefTable0(ret[0]);
88
+ }
89
+ /**
90
+ * @returns {any}
91
+ */
92
+ get variables() {
93
+ const ret = wasm.incrementalquerydeltas_variables(this.__wbg_ptr);
94
+ return ret;
95
+ }
96
+ }
97
+ if (Symbol.dispose) IncrementalQueryDeltas.prototype[Symbol.dispose] = IncrementalQueryDeltas.prototype.free;
98
+
99
+ /**
100
+ * A synchronous live query returning complete, owned JavaScript snapshots.
101
+ */
102
+ export class IncrementalQueryResults {
103
+ static __wrap(ptr) {
104
+ const obj = Object.create(IncrementalQueryResults.prototype);
105
+ obj.__wbg_ptr = ptr;
106
+ IncrementalQueryResultsFinalization.register(obj, obj.__wbg_ptr, obj);
107
+ return obj;
108
+ }
109
+ __destroy_into_raw() {
110
+ const ptr = this.__wbg_ptr;
111
+ this.__wbg_ptr = 0;
112
+ IncrementalQueryResultsFinalization.unregister(this);
113
+ return ptr;
114
+ }
115
+ free() {
116
+ const ptr = this.__destroy_into_raw();
117
+ wasm.__wbg_incrementalqueryresults_free(ptr, 0);
118
+ }
119
+ /**
120
+ * Releases subscriptions. Repeated calls are safe.
121
+ */
122
+ close() {
123
+ wasm.incrementalqueryresults_close(this.__wbg_ptr);
124
+ }
125
+ /**
126
+ * @returns {boolean}
127
+ */
128
+ get closed() {
129
+ const ret = wasm.incrementalqueryresults_closed(this.__wbg_ptr);
130
+ return ret !== 0;
131
+ }
132
+ /**
133
+ * Processes pending committed changes. The returned value owns its data.
134
+ * @returns {any}
135
+ */
136
+ results() {
137
+ const ret = wasm.incrementalqueryresults_results(this.__wbg_ptr);
138
+ if (ret[2]) {
139
+ throw takeFromExternrefTable0(ret[1]);
140
+ }
141
+ return takeFromExternrefTable0(ret[0]);
142
+ }
143
+ /**
144
+ * @returns {any}
145
+ */
146
+ get variables() {
147
+ const ret = wasm.incrementalqueryresults_variables(this.__wbg_ptr);
148
+ return ret;
149
+ }
150
+ }
151
+ if (Symbol.dispose) IncrementalQueryResults.prototype[Symbol.dispose] = IncrementalQueryResults.prototype.free;
152
+
153
+ class ParserIterator {
154
+ static __wrap(ptr) {
155
+ const obj = Object.create(ParserIterator.prototype);
156
+ obj.__wbg_ptr = ptr;
157
+ ParserIteratorFinalization.register(obj, obj.__wbg_ptr, obj);
158
+ return obj;
159
+ }
160
+ __destroy_into_raw() {
161
+ const ptr = this.__wbg_ptr;
162
+ this.__wbg_ptr = 0;
163
+ ParserIteratorFinalization.unregister(this);
164
+ return ptr;
165
+ }
166
+ free() {
167
+ const ptr = this.__destroy_into_raw();
168
+ wasm.__wbg_parseriterator_free(ptr, 0);
169
+ }
170
+ /**
171
+ * @returns {ParserIterator}
172
+ */
173
+ [Symbol.iterator]() {
174
+ const ptr = this.__destroy_into_raw();
175
+ const ret = wasm.parseriterator_Symbol_iterator(ptr);
176
+ return ParserIterator.__wrap(ret);
177
+ }
178
+ /**
179
+ * @returns {ParserIteratorResult}
180
+ */
181
+ next() {
182
+ const ret = wasm.parseriterator_next(this.__wbg_ptr);
183
+ if (ret[2]) {
184
+ throw takeFromExternrefTable0(ret[1]);
185
+ }
186
+ return ParserIteratorResult.__wrap(ret[0]);
187
+ }
188
+ }
189
+ if (Symbol.dispose) ParserIterator.prototype[Symbol.dispose] = ParserIterator.prototype.free;
190
+
191
+ class ParserIteratorResult {
192
+ static __wrap(ptr) {
193
+ const obj = Object.create(ParserIteratorResult.prototype);
194
+ obj.__wbg_ptr = ptr;
195
+ ParserIteratorResultFinalization.register(obj, obj.__wbg_ptr, obj);
196
+ return obj;
197
+ }
198
+ __destroy_into_raw() {
199
+ const ptr = this.__wbg_ptr;
200
+ this.__wbg_ptr = 0;
201
+ ParserIteratorResultFinalization.unregister(this);
202
+ return ptr;
203
+ }
204
+ free() {
205
+ const ptr = this.__destroy_into_raw();
206
+ wasm.__wbg_parseriteratorresult_free(ptr, 0);
207
+ }
208
+ /**
209
+ * @returns {boolean}
210
+ */
211
+ get done() {
212
+ const ret = wasm.parseriteratorresult_done(this.__wbg_ptr);
213
+ return ret !== 0;
214
+ }
215
+ /**
216
+ * @returns {any | undefined}
217
+ */
218
+ get value() {
219
+ const ret = wasm.parseriteratorresult_value(this.__wbg_ptr);
220
+ return ret;
221
+ }
222
+ }
223
+ if (Symbol.dispose) ParserIteratorResult.prototype[Symbol.dispose] = ParserIteratorResult.prototype.free;
224
+
225
+ export class Store {
226
+ __destroy_into_raw() {
227
+ const ptr = this.__wbg_ptr;
228
+ this.__wbg_ptr = 0;
229
+ StoreFinalization.unregister(this);
230
+ return ptr;
231
+ }
232
+ free() {
233
+ const ptr = this.__destroy_into_raw();
234
+ wasm.__wbg_store_free(ptr, 0);
235
+ }
236
+ /**
237
+ * @param {any} quad
238
+ */
239
+ add(quad) {
240
+ const ret = wasm.store_add(this.__wbg_ptr, quad);
241
+ if (ret[1]) {
242
+ throw takeFromExternrefTable0(ret[0]);
243
+ }
244
+ }
245
+ /**
246
+ * @param {any} quad
247
+ */
248
+ delete(quad) {
249
+ const ret = wasm.store_delete(this.__wbg_ptr, quad);
250
+ if (ret[1]) {
251
+ throw takeFromExternrefTable0(ret[0]);
252
+ }
253
+ }
254
+ /**
255
+ * @param {any} options
256
+ * @returns {string}
257
+ */
258
+ dump(options) {
259
+ let deferred2_0;
260
+ let deferred2_1;
261
+ try {
262
+ const ret = wasm.store_dump(this.__wbg_ptr, options);
263
+ var ptr1 = ret[0];
264
+ var len1 = ret[1];
265
+ if (ret[3]) {
266
+ ptr1 = 0; len1 = 0;
267
+ throw takeFromExternrefTable0(ret[2]);
268
+ }
269
+ deferred2_0 = ptr1;
270
+ deferred2_1 = len1;
271
+ return getStringFromWasm0(ptr1, len1);
272
+ } finally {
273
+ wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
274
+ }
275
+ }
276
+ /**
277
+ * Validates all quads, then inserts them in one atomic batch.
278
+ * @param {any} quads
279
+ */
280
+ extend(quads) {
281
+ const ret = wasm.store_extend(this.__wbg_ptr, quads);
282
+ if (ret[1]) {
283
+ throw takeFromExternrefTable0(ret[0]);
284
+ }
285
+ }
286
+ /**
287
+ * @param {any} quad
288
+ * @returns {boolean}
289
+ */
290
+ has(quad) {
291
+ const ret = wasm.store_has(this.__wbg_ptr, quad);
292
+ if (ret[2]) {
293
+ throw takeFromExternrefTable0(ret[1]);
294
+ }
295
+ return ret[0] !== 0;
296
+ }
297
+ /**
298
+ * @param {any} data
299
+ * @param {any} options
300
+ */
301
+ load(data, options) {
302
+ const ret = wasm.store_load(this.__wbg_ptr, data, options);
303
+ if (ret[1]) {
304
+ throw takeFromExternrefTable0(ret[0]);
305
+ }
306
+ }
307
+ /**
308
+ * @param {any} subject
309
+ * @param {any} predicate
310
+ * @param {any} object
311
+ * @param {any} graph_name
312
+ * @returns {any[]}
313
+ */
314
+ match(subject, predicate, object, graph_name) {
315
+ const ret = wasm.store_match(this.__wbg_ptr, subject, predicate, object, graph_name);
316
+ if (ret[3]) {
317
+ throw takeFromExternrefTable0(ret[2]);
318
+ }
319
+ var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]);
320
+ wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
321
+ return v1;
322
+ }
323
+ /**
324
+ * @param {any} quads
325
+ */
326
+ constructor(quads) {
327
+ const ret = wasm.store_new(quads);
328
+ if (ret[2]) {
329
+ throw takeFromExternrefTable0(ret[1]);
330
+ }
331
+ this.__wbg_ptr = ret[0];
332
+ StoreFinalization.register(this, this.__wbg_ptr, this);
333
+ return this;
334
+ }
335
+ /**
336
+ * Creates a live query whose deltas() method consumes pending result changes.
337
+ * @param {string} query
338
+ * @param {any} options
339
+ * @returns {IncrementalQueryDeltas}
340
+ */
341
+ queryIncrementalDeltas(query, options) {
342
+ const ptr0 = passStringToWasm0(query, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
343
+ const len0 = WASM_VECTOR_LEN;
344
+ const ret = wasm.store_queryIncrementalDeltas(this.__wbg_ptr, ptr0, len0, options);
345
+ if (ret[2]) {
346
+ throw takeFromExternrefTable0(ret[1]);
347
+ }
348
+ return IncrementalQueryDeltas.__wrap(ret[0]);
349
+ }
350
+ /**
351
+ * Creates a live query whose results() method returns complete snapshots.
352
+ * @param {string} query
353
+ * @param {any} options
354
+ * @returns {IncrementalQueryResults}
355
+ */
356
+ queryIncrementalResults(query, options) {
357
+ const ptr0 = passStringToWasm0(query, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
358
+ const len0 = WASM_VECTOR_LEN;
359
+ const ret = wasm.store_queryIncrementalResults(this.__wbg_ptr, ptr0, len0, options);
360
+ if (ret[2]) {
361
+ throw takeFromExternrefTable0(ret[1]);
362
+ }
363
+ return IncrementalQueryResults.__wrap(ret[0]);
364
+ }
365
+ /**
366
+ * @param {string} query
367
+ * @param {any} options
368
+ * @returns {any}
369
+ */
370
+ query(query, options) {
371
+ const ptr0 = passStringToWasm0(query, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
372
+ const len0 = WASM_VECTOR_LEN;
373
+ const ret = wasm.store_query(this.__wbg_ptr, ptr0, len0, options);
374
+ if (ret[2]) {
375
+ throw takeFromExternrefTable0(ret[1]);
376
+ }
377
+ return takeFromExternrefTable0(ret[0]);
378
+ }
379
+ /**
380
+ * @returns {number}
381
+ */
382
+ get size() {
383
+ const ret = wasm.store_size(this.__wbg_ptr);
384
+ if (ret[2]) {
385
+ throw takeFromExternrefTable0(ret[1]);
386
+ }
387
+ return ret[0] >>> 0;
388
+ }
389
+ /**
390
+ * Creates a buffered, write-only transaction. Call commit() to apply it.
391
+ * @returns {Transaction}
392
+ */
393
+ transaction() {
394
+ const ret = wasm.store_transaction(this.__wbg_ptr);
395
+ return Transaction.__wrap(ret);
396
+ }
397
+ /**
398
+ * @param {string} update
399
+ * @param {any} options
400
+ */
401
+ update(update, options) {
402
+ const ptr0 = passStringToWasm0(update, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
403
+ const len0 = WASM_VECTOR_LEN;
404
+ const ret = wasm.store_update(this.__wbg_ptr, ptr0, len0, options);
405
+ if (ret[1]) {
406
+ throw takeFromExternrefTable0(ret[0]);
407
+ }
408
+ }
409
+ }
410
+ if (Symbol.dispose) Store.prototype[Symbol.dispose] = Store.prototype.free;
411
+
412
+ /**
413
+ * A buffered, atomic, write-only batch. Dropping it discards uncommitted writes.
414
+ */
415
+ export class Transaction {
416
+ static __wrap(ptr) {
417
+ const obj = Object.create(Transaction.prototype);
418
+ obj.__wbg_ptr = ptr;
419
+ TransactionFinalization.register(obj, obj.__wbg_ptr, obj);
420
+ return obj;
421
+ }
422
+ __destroy_into_raw() {
423
+ const ptr = this.__wbg_ptr;
424
+ this.__wbg_ptr = 0;
425
+ TransactionFinalization.unregister(this);
426
+ return ptr;
427
+ }
428
+ free() {
429
+ const ptr = this.__destroy_into_raw();
430
+ wasm.__wbg_transaction_free(ptr, 0);
431
+ }
432
+ /**
433
+ * @param {any} quad
434
+ */
435
+ add(quad) {
436
+ const ret = wasm.transaction_add(this.__wbg_ptr, quad);
437
+ if (ret[1]) {
438
+ throw takeFromExternrefTable0(ret[0]);
439
+ }
440
+ }
441
+ /**
442
+ * @returns {boolean}
443
+ */
444
+ get closed() {
445
+ const ret = wasm.transaction_closed(this.__wbg_ptr);
446
+ return ret !== 0;
447
+ }
448
+ /**
449
+ * Applies all operations atomically and closes the transaction, including on failure.
450
+ */
451
+ commit() {
452
+ const ret = wasm.transaction_commit(this.__wbg_ptr);
453
+ if (ret[1]) {
454
+ throw takeFromExternrefTable0(ret[0]);
455
+ }
456
+ }
457
+ /**
458
+ * @param {any} quad
459
+ */
460
+ delete(quad) {
461
+ const ret = wasm.transaction_delete(this.__wbg_ptr, quad);
462
+ if (ret[1]) {
463
+ throw takeFromExternrefTable0(ret[0]);
464
+ }
465
+ }
466
+ /**
467
+ * @param {any} quads
468
+ */
469
+ extend(quads) {
470
+ const ret = wasm.transaction_extend(this.__wbg_ptr, quads);
471
+ if (ret[1]) {
472
+ throw takeFromExternrefTable0(ret[0]);
473
+ }
474
+ }
475
+ rollback() {
476
+ wasm.transaction_rollback(this.__wbg_ptr);
477
+ }
478
+ }
479
+ if (Symbol.dispose) Transaction.prototype[Symbol.dispose] = Transaction.prototype.free;
480
+
481
+ export function main() {
482
+ wasm.main();
483
+ }
484
+
485
+ /**
486
+ * @param {any} input
487
+ * @param {any} options
488
+ * @returns {any}
489
+ */
490
+ export function parse(input, options) {
491
+ const ret = wasm.parse(input, options);
492
+ if (ret[2]) {
493
+ throw takeFromExternrefTable0(ret[1]);
494
+ }
495
+ return takeFromExternrefTable0(ret[0]);
496
+ }
497
+ export function __wbg_Error_67e7344beaa85059(arg0, arg1) {
498
+ const ret = Error(getStringFromWasm0(arg0, arg1));
499
+ return ret;
500
+ }
501
+ export function __wbg___wbindgen_debug_string_0e68cf47c9cbd9b0(arg0, arg1) {
502
+ const ret = debugString(arg1);
503
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
504
+ const len1 = WASM_VECTOR_LEN;
505
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
506
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
507
+ }
508
+ export function __wbg___wbindgen_is_falsy_4502df4d571fca70(arg0) {
509
+ const ret = !arg0;
510
+ return ret;
511
+ }
512
+ export function __wbg___wbindgen_is_function_fcda5e3902d732fe(arg0) {
513
+ const ret = typeof(arg0) === 'function';
514
+ return ret;
515
+ }
516
+ export function __wbg___wbindgen_is_null_5160b3e381865372(arg0) {
517
+ const ret = arg0 === null;
518
+ return ret;
519
+ }
520
+ export function __wbg___wbindgen_is_object_edb6b15aa3afe12e(arg0) {
521
+ const val = arg0;
522
+ const ret = typeof(val) === 'object' && val !== null;
523
+ return ret;
524
+ }
525
+ export function __wbg___wbindgen_is_undefined_8c687d0b90d5b524(arg0) {
526
+ const ret = arg0 === undefined;
527
+ return ret;
528
+ }
529
+ export function __wbg___wbindgen_string_get_92ab86bb19cbc12f(arg0, arg1) {
530
+ const obj = arg1;
531
+ const ret = typeof(obj) === 'string' ? obj : undefined;
532
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
533
+ var len1 = WASM_VECTOR_LEN;
534
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
535
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
536
+ }
537
+ export function __wbg___wbindgen_throw_5d9e815e6fdf150f(arg0, arg1) {
538
+ throw new Error(getStringFromWasm0(arg0, arg1));
539
+ }
540
+ export function __wbg__wbg_cb_unref_997e73d32238e655(arg0) {
541
+ arg0._wbg_cb_unref();
542
+ }
543
+ export function __wbg_asyncIterator_67ecc0f983521575() {
544
+ const ret = Symbol.asyncIterator;
545
+ return ret;
546
+ }
547
+ export function __wbg_asyncparseriterator_new(arg0) {
548
+ const ret = AsyncParserIterator.__wrap(arg0);
549
+ return ret;
550
+ }
551
+ export function __wbg_blankNode_1b6cb1159955666e(arg0, arg1, arg2) {
552
+ const ret = arg0.blankNode(getStringFromWasm0(arg1, arg2));
553
+ return ret;
554
+ }
555
+ export function __wbg_call_269c5566fbede3eb() { return handleError(function (arg0, arg1) {
556
+ const ret = arg0.call(arg1);
557
+ return ret;
558
+ }, arguments); }
559
+ export function __wbg_call_6bcf8d3e20937e46() { return handleError(function (arg0, arg1, arg2) {
560
+ const ret = arg0.call(arg1, arg2);
561
+ return ret;
562
+ }, arguments); }
563
+ export function __wbg_defaultGraph_aa8c731b18c41235(arg0) {
564
+ const ret = arg0.defaultGraph();
565
+ return ret;
566
+ }
567
+ export function __wbg_done_cffed884d87aa22e(arg0) {
568
+ const ret = arg0.done;
569
+ return ret;
570
+ }
571
+ export function __wbg_error_757e9472f8410341(arg0, arg1) {
572
+ let deferred0_0;
573
+ let deferred0_1;
574
+ try {
575
+ deferred0_0 = arg0;
576
+ deferred0_1 = arg1;
577
+ console.error(getStringFromWasm0(arg0, arg1));
578
+ } finally {
579
+ wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
580
+ }
581
+ }
582
+ export function __wbg_freeze_d7506c617f5587f2(arg0) {
583
+ const ret = Object.freeze(arg0);
584
+ return ret;
585
+ }
586
+ export function __wbg_getRandomValues_436a51d0629d84e1() { return handleError(function (arg0, arg1) {
587
+ globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
588
+ }, arguments); }
589
+ export function __wbg_get_6cf5a4d4d8ad3c5a() { return handleError(function (arg0, arg1) {
590
+ const ret = Reflect.get(arg0, arg1);
591
+ return ret;
592
+ }, arguments); }
593
+ export function __wbg_get_989d0a1309644f2b() { return handleError(function (arg0, arg1) {
594
+ const ret = Reflect.get(arg0, arg1);
595
+ return ret;
596
+ }, arguments); }
597
+ export function __wbg_instanceof_Uint8Array_598adc0fef426aa8(arg0) {
598
+ let result;
599
+ try {
600
+ result = arg0 instanceof Uint8Array;
601
+ } catch (_) {
602
+ result = false;
603
+ }
604
+ const ret = result;
605
+ return ret;
606
+ }
607
+ export function __wbg_iterator_22ddeb808cf55a6f() {
608
+ const ret = Symbol.iterator;
609
+ return ret;
610
+ }
611
+ export function __wbg_length_31bdaf014f5fbde2(arg0) {
612
+ const ret = arg0.length;
613
+ return ret;
614
+ }
615
+ export function __wbg_literal_05d9495c15531df1(arg0, arg1, arg2, arg3, arg4) {
616
+ const ret = arg0.literal(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
617
+ return ret;
618
+ }
619
+ export function __wbg_literal_113173bd439a42d7(arg0, arg1, arg2) {
620
+ const ret = arg0.literal(getStringFromWasm0(arg1, arg2));
621
+ return ret;
622
+ }
623
+ export function __wbg_literal_6fa2089ef2d13431(arg0, arg1, arg2, arg3) {
624
+ const ret = arg0.literal(getStringFromWasm0(arg1, arg2), arg3);
625
+ return ret;
626
+ }
627
+ export function __wbg_namedNode_f6584da63304d0e4(arg0, arg1, arg2) {
628
+ const ret = arg0.namedNode(getStringFromWasm0(arg1, arg2));
629
+ return ret;
630
+ }
631
+ export function __wbg_new_227d7c05414eb861() {
632
+ const ret = new Error();
633
+ return ret;
634
+ }
635
+ export function __wbg_new_4a8d8768bb66c2d7(arg0, arg1) {
636
+ const ret = new URIError(getStringFromWasm0(arg0, arg1));
637
+ return ret;
638
+ }
639
+ export function __wbg_new_8d36e20aa758e411() {
640
+ const ret = new Map();
641
+ return ret;
642
+ }
643
+ export function __wbg_new_9ca27d4bce9deee9(arg0, arg1) {
644
+ const ret = new TypeError(getStringFromWasm0(arg0, arg1));
645
+ return ret;
646
+ }
647
+ export function __wbg_new_a32a1ab6c6655abe(arg0, arg1) {
648
+ const ret = new Error(getStringFromWasm0(arg0, arg1));
649
+ return ret;
650
+ }
651
+ export function __wbg_new_bebc3f4757acf305() {
652
+ const ret = new Object();
653
+ return ret;
654
+ }
655
+ export function __wbg_new_ffa92086ea89f79c() {
656
+ const ret = new Array();
657
+ return ret;
658
+ }
659
+ export function __wbg_new_typed_6f8b0d724fe26c07(arg0, arg1) {
660
+ try {
661
+ var state0 = {a: arg0, b: arg1};
662
+ var cb0 = (arg0, arg1) => {
663
+ const a = state0.a;
664
+ state0.a = 0;
665
+ try {
666
+ return wasm_bindgen_6d2a4a221079adc4___convert__closures_____invoke___js_sys_215bc708a0e1cc2a___Function_fn_wasm_bindgen_6d2a4a221079adc4___JsValue_____wasm_bindgen_6d2a4a221079adc4___sys__Undefined___js_sys_215bc708a0e1cc2a___Function_fn_wasm_bindgen_6d2a4a221079adc4___JsValue_____wasm_bindgen_6d2a4a221079adc4___sys__Undefined_______true_(a, state0.b, arg0, arg1);
667
+ } finally {
668
+ state0.a = a;
669
+ }
670
+ };
671
+ const ret = new Promise(cb0);
672
+ return ret;
673
+ } finally {
674
+ state0.a = 0;
675
+ }
676
+ }
677
+ export function __wbg_next_95053e306b1c3aed(arg0) {
678
+ const ret = arg0.next;
679
+ return ret;
680
+ }
681
+ export function __wbg_next_a128c458fd40a0a5() { return handleError(function (arg0) {
682
+ const ret = arg0.next();
683
+ return ret;
684
+ }, arguments); }
685
+ export function __wbg_next_f31ecb8646d2c605() { return handleError(function (arg0) {
686
+ const ret = arg0.next();
687
+ return ret;
688
+ }, arguments); }
689
+ export function __wbg_now_d1fb6650485d7f3e() {
690
+ const ret = Date.now();
691
+ return ret;
692
+ }
693
+ export function __wbg_parseriterator_new(arg0) {
694
+ const ret = ParserIterator.__wrap(arg0);
695
+ return ret;
696
+ }
697
+ export function __wbg_parseriteratorresult_new(arg0) {
698
+ const ret = ParserIteratorResult.__wrap(arg0);
699
+ return ret;
700
+ }
701
+ export function __wbg_prototypesetcall_ae9f5e7459250748(arg0, arg1, arg2) {
702
+ Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
703
+ }
704
+ export function __wbg_push_bfdf956ba476f65b(arg0, arg1) {
705
+ const ret = arg0.push(arg1);
706
+ return ret;
707
+ }
708
+ export function __wbg_quad_573c4ecd8dd77b34(arg0, arg1, arg2, arg3) {
709
+ const ret = arg0.quad(arg1, arg2, arg3);
710
+ return ret;
711
+ }
712
+ export function __wbg_quad_6484557cc371e9f5(arg0, arg1, arg2, arg3, arg4) {
713
+ const ret = arg0.quad(arg1, arg2, arg3, arg4);
714
+ return ret;
715
+ }
716
+ export function __wbg_queueMicrotask_85c90f6987555d65(arg0) {
717
+ const ret = arg0.queueMicrotask;
718
+ return ret;
719
+ }
720
+ export function __wbg_queueMicrotask_f6a1fa10b81d1fc0(arg0) {
721
+ queueMicrotask(arg0);
722
+ }
723
+ export function __wbg_resolve_35ec7e0c6af4c82c(arg0) {
724
+ const ret = Promise.resolve(arg0);
725
+ return ret;
726
+ }
727
+ export function __wbg_set_a377297433dfea63() { return handleError(function (arg0, arg1, arg2) {
728
+ const ret = Reflect.set(arg0, arg1, arg2);
729
+ return ret;
730
+ }, arguments); }
731
+ export function __wbg_set_bf6dde4923b9b059(arg0, arg1, arg2) {
732
+ const ret = arg0.set(arg1, arg2);
733
+ return ret;
734
+ }
735
+ export function __wbg_set_name_6e2a5da46a9ae1e7(arg0, arg1, arg2) {
736
+ arg0.name = getStringFromWasm0(arg1, arg2);
737
+ }
738
+ export function __wbg_stack_3b0d974bbf31e44f(arg0, arg1) {
739
+ const ret = arg1.stack;
740
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
741
+ const len1 = WASM_VECTOR_LEN;
742
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
743
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
744
+ }
745
+ export function __wbg_static_accessor_FACTORY_422cd57295f86526() {
746
+ const ret = factory;
747
+ return ret;
748
+ }
749
+ export function __wbg_static_accessor_GLOBAL_8eb4cd83130a11a0() {
750
+ const ret = typeof global === 'undefined' ? null : global;
751
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
752
+ }
753
+ export function __wbg_static_accessor_GLOBAL_THIS_1e7044f654e934db() {
754
+ const ret = typeof globalThis === 'undefined' ? null : globalThis;
755
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
756
+ }
757
+ export function __wbg_static_accessor_SELF_d8b50611246a6d92() {
758
+ const ret = typeof self === 'undefined' ? null : self;
759
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
760
+ }
761
+ export function __wbg_static_accessor_WINDOW_fd0bc376bf0f8b42() {
762
+ const ret = typeof window === 'undefined' ? null : window;
763
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
764
+ }
765
+ export function __wbg_string_BASE_IRI_c0ea4f49d1c324d8() {
766
+ const ret = `base_iri`;
767
+ return ret;
768
+ }
769
+ export function __wbg_string_DATATYPE_b3761a09af4c3501() {
770
+ const ret = `datatype`;
771
+ return ret;
772
+ }
773
+ export function __wbg_string_DATA_FACTORY_2863d1619ef84134() {
774
+ const ret = `data_factory`;
775
+ return ret;
776
+ }
777
+ export function __wbg_string_DEFAULT_GRAPH_3164a60b247922d3() {
778
+ const ret = `default_graph`;
779
+ return ret;
780
+ }
781
+ export function __wbg_string_DIRECTION_6bfcd3f7bc48f8f6() {
782
+ const ret = `direction`;
783
+ return ret;
784
+ }
785
+ export function __wbg_string_FORMAT_e9b7e723eb3df2a7() {
786
+ const ret = `format`;
787
+ return ret;
788
+ }
789
+ export function __wbg_string_FROM_GRAPH_NAME_a8e66d1bfa9df97a() {
790
+ const ret = `from_graph_name`;
791
+ return ret;
792
+ }
793
+ export function __wbg_string_GRAPH_095a1ed67690381a() {
794
+ const ret = `graph`;
795
+ return ret;
796
+ }
797
+ export function __wbg_string_LANGUAGE_bf1eb7f2727b876c() {
798
+ const ret = `language`;
799
+ return ret;
800
+ }
801
+ export function __wbg_string_LENIENT_b5b3475b9b25622e() {
802
+ const ret = `lenient`;
803
+ return ret;
804
+ }
805
+ export function __wbg_string_LTR_72659057b0a71f4b() {
806
+ const ret = `ltr`;
807
+ return ret;
808
+ }
809
+ export function __wbg_string_NAMED_GRAPHS_eca0abd14735994f() {
810
+ const ret = `named_graphs`;
811
+ return ret;
812
+ }
813
+ export function __wbg_string_NO_TRANSACTION_653d90503dfbf74a() {
814
+ const ret = `no_transaction`;
815
+ return ret;
816
+ }
817
+ export function __wbg_string_OBJECT_486935ff697ebae6() {
818
+ const ret = `object`;
819
+ return ret;
820
+ }
821
+ export function __wbg_string_PREDICATE_b6dcd6d03cd29967() {
822
+ const ret = `predicate`;
823
+ return ret;
824
+ }
825
+ export function __wbg_string_RESULTS_FORMAT_14a44bb3a6b6f00f() {
826
+ const ret = `results_format`;
827
+ return ret;
828
+ }
829
+ export function __wbg_string_RTL_8049271807e5eb9f() {
830
+ const ret = `rtl`;
831
+ return ret;
832
+ }
833
+ export function __wbg_string_SUBJECT_9b288d8456d03954() {
834
+ const ret = `subject`;
835
+ return ret;
836
+ }
837
+ export function __wbg_string_TERM_TYPE_e52e8648ef62f29b() {
838
+ const ret = `termType`;
839
+ return ret;
840
+ }
841
+ export function __wbg_string_TO_GRAPH_NAME_06814539fd327729() {
842
+ const ret = `to_graph_name`;
843
+ return ret;
844
+ }
845
+ export function __wbg_string_UNCHECKED_8b5d46fc1a0f4672() {
846
+ const ret = `unchecked`;
847
+ return ret;
848
+ }
849
+ export function __wbg_string_USED_DEFAULT_GRAPH_AS_UNION_f8dbfdeca6804a15() {
850
+ const ret = `use_default_graph_as_union`;
851
+ return ret;
852
+ }
853
+ export function __wbg_string_VALUE_3b9233c32182f4e6() {
854
+ const ret = `value`;
855
+ return ret;
856
+ }
857
+ export function __wbg_then_7a850dae4493f353(arg0, arg1, arg2) {
858
+ const ret = arg0.then(arg1, arg2);
859
+ return ret;
860
+ }
861
+ export function __wbg_then_b830475380919203(arg0, arg1) {
862
+ const ret = arg0.then(arg1);
863
+ return ret;
864
+ }
865
+ export function __wbg_value_c227f843d21da141(arg0) {
866
+ const ret = arg0.value;
867
+ return ret;
868
+ }
869
+ export function __wbindgen_generic_0000000000000001(arg0, arg1) {
870
+ // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 93, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
871
+ const ret = makeMutClosure(arg0, arg1, wasm_bindgen_6d2a4a221079adc4___convert__closures_____invoke___wasm_bindgen_6d2a4a221079adc4___JsValue__core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_6d2a4a221079adc4___JsError___true_);
872
+ return ret;
873
+ }
874
+ export function __wbindgen_generic_0000000000000002(arg0) {
875
+ // Cast intrinsic for `F64 -> Externref`.
876
+ const ret = arg0;
877
+ return ret;
878
+ }
879
+ export function __wbindgen_generic_0000000000000003(arg0, arg1) {
880
+ // Cast intrinsic for `Ref(String) -> Externref`.
881
+ const ret = getStringFromWasm0(arg0, arg1);
882
+ return ret;
883
+ }
884
+ export function __wbindgen_generic_0000000000000004(arg0, arg1) {
885
+ var v0 = getArrayJsValueFromWasm0(arg0, arg1);
886
+ wasm.__wbindgen_free(arg0, arg1 * 4, 4);
887
+ // Cast intrinsic for `Vector(Externref) -> Externref`.
888
+ const ret = v0;
889
+ return ret;
890
+ }
891
+ export function __wbindgen_init_externref_table() {
892
+ const table = wasm.__wbindgen_externrefs;
893
+ const offset = table.grow(4);
894
+ table.set(0, undefined);
895
+ table.set(offset + 0, undefined);
896
+ table.set(offset + 1, null);
897
+ table.set(offset + 2, true);
898
+ table.set(offset + 3, false);
899
+ }
900
+ function wasm_bindgen_6d2a4a221079adc4___convert__closures_____invoke___wasm_bindgen_6d2a4a221079adc4___JsValue__core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_6d2a4a221079adc4___JsError___true_(arg0, arg1, arg2) {
901
+ const ret = wasm.wasm_bindgen_6d2a4a221079adc4___convert__closures_____invoke___wasm_bindgen_6d2a4a221079adc4___JsValue__core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_6d2a4a221079adc4___JsError___true_(arg0, arg1, arg2);
902
+ if (ret[1]) {
903
+ throw takeFromExternrefTable0(ret[0]);
904
+ }
905
+ }
906
+
907
+ function wasm_bindgen_6d2a4a221079adc4___convert__closures_____invoke___js_sys_215bc708a0e1cc2a___Function_fn_wasm_bindgen_6d2a4a221079adc4___JsValue_____wasm_bindgen_6d2a4a221079adc4___sys__Undefined___js_sys_215bc708a0e1cc2a___Function_fn_wasm_bindgen_6d2a4a221079adc4___JsValue_____wasm_bindgen_6d2a4a221079adc4___sys__Undefined_______true_(arg0, arg1, arg2, arg3) {
908
+ wasm.wasm_bindgen_6d2a4a221079adc4___convert__closures_____invoke___js_sys_215bc708a0e1cc2a___Function_fn_wasm_bindgen_6d2a4a221079adc4___JsValue_____wasm_bindgen_6d2a4a221079adc4___sys__Undefined___js_sys_215bc708a0e1cc2a___Function_fn_wasm_bindgen_6d2a4a221079adc4___JsValue_____wasm_bindgen_6d2a4a221079adc4___sys__Undefined_______true_(arg0, arg1, arg2, arg3);
909
+ }
910
+
911
+ const AsyncParserIteratorFinalization = (typeof FinalizationRegistry === 'undefined')
912
+ ? { register: () => {}, unregister: () => {} }
913
+ : new FinalizationRegistry(ptr => wasm.__wbg_asyncparseriterator_free(ptr, 1));
914
+ const IncrementalQueryDeltasFinalization = (typeof FinalizationRegistry === 'undefined')
915
+ ? { register: () => {}, unregister: () => {} }
916
+ : new FinalizationRegistry(ptr => wasm.__wbg_incrementalquerydeltas_free(ptr, 1));
917
+ const IncrementalQueryResultsFinalization = (typeof FinalizationRegistry === 'undefined')
918
+ ? { register: () => {}, unregister: () => {} }
919
+ : new FinalizationRegistry(ptr => wasm.__wbg_incrementalqueryresults_free(ptr, 1));
920
+ const ParserIteratorFinalization = (typeof FinalizationRegistry === 'undefined')
921
+ ? { register: () => {}, unregister: () => {} }
922
+ : new FinalizationRegistry(ptr => wasm.__wbg_parseriterator_free(ptr, 1));
923
+ const ParserIteratorResultFinalization = (typeof FinalizationRegistry === 'undefined')
924
+ ? { register: () => {}, unregister: () => {} }
925
+ : new FinalizationRegistry(ptr => wasm.__wbg_parseriteratorresult_free(ptr, 1));
926
+ const StoreFinalization = (typeof FinalizationRegistry === 'undefined')
927
+ ? { register: () => {}, unregister: () => {} }
928
+ : new FinalizationRegistry(ptr => wasm.__wbg_store_free(ptr, 1));
929
+ const TransactionFinalization = (typeof FinalizationRegistry === 'undefined')
930
+ ? { register: () => {}, unregister: () => {} }
931
+ : new FinalizationRegistry(ptr => wasm.__wbg_transaction_free(ptr, 1));
932
+
933
+ function addToExternrefTable0(obj) {
934
+ const idx = wasm.__externref_table_alloc();
935
+ wasm.__wbindgen_externrefs.set(idx, obj);
936
+ return idx;
937
+ }
938
+
939
+ const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
940
+ ? { register: () => {}, unregister: () => {} }
941
+ : new FinalizationRegistry(state => wasm.__wbindgen_destroy_closure(state.a, state.b));
942
+
943
+ function debugString(val) {
944
+ // primitive types
945
+ const type = typeof val;
946
+ if (type == 'number' || type == 'boolean' || val == null) {
947
+ return `${val}`;
948
+ }
949
+ if (type == 'string') {
950
+ return `"${val}"`;
951
+ }
952
+ if (type == 'symbol') {
953
+ const description = val.description;
954
+ if (description == null) {
955
+ return 'Symbol';
956
+ } else {
957
+ return `Symbol(${description})`;
958
+ }
959
+ }
960
+ if (type == 'function') {
961
+ const name = val.name;
962
+ if (typeof name == 'string' && name.length > 0) {
963
+ return `Function(${name})`;
964
+ } else {
965
+ return 'Function';
966
+ }
967
+ }
968
+ // objects
969
+ if (Array.isArray(val)) {
970
+ const length = val.length;
971
+ let debug = '[';
972
+ if (length > 0) {
973
+ debug += debugString(val[0]);
974
+ }
975
+ for(let i = 1; i < length; i++) {
976
+ debug += ', ' + debugString(val[i]);
977
+ }
978
+ debug += ']';
979
+ return debug;
980
+ }
981
+ // Test for built-in
982
+ const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
983
+ let className;
984
+ if (builtInMatches && builtInMatches.length > 1) {
985
+ className = builtInMatches[1];
986
+ } else {
987
+ // Failed to match the standard '[object ClassName]'
988
+ return toString.call(val);
989
+ }
990
+ if (className == 'Object') {
991
+ // we're a user defined class or Object
992
+ // JSON.stringify avoids problems with cycles, and is generally much
993
+ // easier than looping through ownProperties of `val`.
994
+ try {
995
+ return 'Object(' + JSON.stringify(val) + ')';
996
+ } catch (_) {
997
+ return 'Object';
998
+ }
999
+ }
1000
+ // errors
1001
+ if (val instanceof Error) {
1002
+ return `${val.name}: ${val.message}\n${val.stack}`;
1003
+ }
1004
+ // TODO we could test for more things here, like `Set`s and `Map`s.
1005
+ return className;
1006
+ }
1007
+
1008
+ function getArrayJsValueFromWasm0(ptr, len) {
1009
+ ptr = ptr >>> 0;
1010
+ const mem = getDataViewMemory0();
1011
+ const result = [];
1012
+ for (let i = ptr; i < ptr + 4 * len; i += 4) {
1013
+ result.push(wasm.__wbindgen_externrefs.get(mem.getUint32(i, true)));
1014
+ }
1015
+ wasm.__externref_drop_slice(ptr, len);
1016
+ return result;
1017
+ }
1018
+
1019
+ function getArrayU8FromWasm0(ptr, len) {
1020
+ ptr = ptr >>> 0;
1021
+ return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
1022
+ }
1023
+
1024
+ let cachedDataViewMemory0 = null;
1025
+ function getDataViewMemory0() {
1026
+ if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
1027
+ cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
1028
+ }
1029
+ return cachedDataViewMemory0;
1030
+ }
1031
+
1032
+ function getStringFromWasm0(ptr, len) {
1033
+ return decodeText(ptr >>> 0, len);
1034
+ }
1035
+
1036
+ let cachedUint8ArrayMemory0 = null;
1037
+ function getUint8ArrayMemory0() {
1038
+ if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
1039
+ cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
1040
+ }
1041
+ return cachedUint8ArrayMemory0;
1042
+ }
1043
+
1044
+ function handleError(f, args) {
1045
+ try {
1046
+ return f.apply(this, args);
1047
+ } catch (e) {
1048
+ const idx = addToExternrefTable0(e);
1049
+ wasm.__wbindgen_exn_store(idx);
1050
+ }
1051
+ }
1052
+
1053
+ function isLikeNone(x) {
1054
+ return x === undefined || x === null;
1055
+ }
1056
+
1057
+ function makeMutClosure(arg0, arg1, f) {
1058
+ const state = { a: arg0, b: arg1, cnt: 1 };
1059
+ const real = (...args) => {
1060
+
1061
+ // First up with a closure we increment the internal reference
1062
+ // count. This ensures that the Rust closure environment won't
1063
+ // be deallocated while we're invoking it.
1064
+ state.cnt++;
1065
+ const a = state.a;
1066
+ state.a = 0;
1067
+ try {
1068
+ return f(a, state.b, ...args);
1069
+ } finally {
1070
+ state.a = a;
1071
+ real._wbg_cb_unref();
1072
+ }
1073
+ };
1074
+ real._wbg_cb_unref = () => {
1075
+ if (--state.cnt === 0) {
1076
+ wasm.__wbindgen_destroy_closure(state.a, state.b);
1077
+ state.a = 0;
1078
+ CLOSURE_DTORS.unregister(state);
1079
+ }
1080
+ };
1081
+ CLOSURE_DTORS.register(real, state, state);
1082
+ return real;
1083
+ }
1084
+
1085
+ function passStringToWasm0(arg, malloc, realloc) {
1086
+ if (realloc === undefined) {
1087
+ const buf = cachedTextEncoder.encode(arg);
1088
+ const ptr = malloc(buf.length, 1) >>> 0;
1089
+ getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
1090
+ WASM_VECTOR_LEN = buf.length;
1091
+ return ptr;
1092
+ }
1093
+
1094
+ let len = arg.length;
1095
+ let ptr = malloc(len, 1) >>> 0;
1096
+
1097
+ const mem = getUint8ArrayMemory0();
1098
+
1099
+ let offset = 0;
1100
+
1101
+ for (; offset < len; offset++) {
1102
+ const code = arg.charCodeAt(offset);
1103
+ if (code > 0x7F) break;
1104
+ mem[ptr + offset] = code;
1105
+ }
1106
+ if (offset !== len) {
1107
+ if (offset !== 0) {
1108
+ arg = arg.slice(offset);
1109
+ }
1110
+ ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
1111
+ const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
1112
+ const ret = cachedTextEncoder.encodeInto(arg, view);
1113
+
1114
+ offset += ret.written;
1115
+ ptr = realloc(ptr, len, offset, 1) >>> 0;
1116
+ }
1117
+
1118
+ WASM_VECTOR_LEN = offset;
1119
+ return ptr;
1120
+ }
1121
+
1122
+ function takeFromExternrefTable0(idx) {
1123
+ const value = wasm.__wbindgen_externrefs.get(idx);
1124
+ wasm.__externref_table_dealloc(idx);
1125
+ return value;
1126
+ }
1127
+
1128
+ let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
1129
+ cachedTextDecoder.decode();
1130
+ const MAX_SAFARI_DECODE_BYTES = 2146435072;
1131
+ let numBytesDecoded = 0;
1132
+ function decodeText(ptr, len) {
1133
+ numBytesDecoded += len;
1134
+ if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
1135
+ cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
1136
+ cachedTextDecoder.decode();
1137
+ numBytesDecoded = len;
1138
+ }
1139
+ return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
1140
+ }
1141
+
1142
+ const cachedTextEncoder = new TextEncoder();
1143
+
1144
+ if (!('encodeInto' in cachedTextEncoder)) {
1145
+ cachedTextEncoder.encodeInto = function (arg, view) {
1146
+ const buf = cachedTextEncoder.encode(arg);
1147
+ view.set(buf);
1148
+ return {
1149
+ read: arg.length,
1150
+ written: buf.length
1151
+ };
1152
+ };
1153
+ }
1154
+
1155
+ let WASM_VECTOR_LEN = 0;
1156
+
1157
+
1158
+ let wasm;
1159
+ export function __wbg_set_wasm(val) {
1160
+ wasm = val;
1161
+ }