@learncard/didkit-plugin 1.10.5 → 1.10.6

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.
@@ -30,6 +30,23 @@ function getStringFromWasm0(ptr, len) {
30
30
  return decodeText(ptr, len);
31
31
  }
32
32
 
33
+ let heap = new Array(128).fill(undefined);
34
+
35
+ heap.push(undefined, null, true, false);
36
+
37
+ let heap_next = heap.length;
38
+
39
+ function addHeapObject(obj) {
40
+ if (heap_next === heap.length) heap.push(heap.length + 1);
41
+ const idx = heap_next;
42
+ heap_next = heap[idx];
43
+
44
+ heap[idx] = obj;
45
+ return idx;
46
+ }
47
+
48
+ function getObject(idx) { return heap[idx]; }
49
+
33
50
  let WASM_VECTOR_LEN = 0;
34
51
 
35
52
  const cachedTextEncoder = new TextEncoder();
@@ -93,21 +110,26 @@ function getDataViewMemory0() {
93
110
  return cachedDataViewMemory0;
94
111
  }
95
112
 
96
- function addToExternrefTable0(obj) {
97
- const idx = wasm.__externref_table_alloc();
98
- wasm.__wbindgen_export_4.set(idx, obj);
99
- return idx;
100
- }
101
-
102
113
  function handleError(f, args) {
103
114
  try {
104
115
  return f.apply(this, args);
105
116
  } catch (e) {
106
- const idx = addToExternrefTable0(e);
107
- wasm.__wbindgen_exn_store(idx);
117
+ wasm.__wbindgen_export_2(addHeapObject(e));
108
118
  }
109
119
  }
110
120
 
121
+ function dropObject(idx) {
122
+ if (idx < 132) return;
123
+ heap[idx] = heap_next;
124
+ heap_next = idx;
125
+ }
126
+
127
+ function takeObject(idx) {
128
+ const ret = getObject(idx);
129
+ dropObject(idx);
130
+ return ret;
131
+ }
132
+
111
133
  function getArrayU8FromWasm0(ptr, len) {
112
134
  ptr = ptr >>> 0;
113
135
  return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
@@ -186,7 +208,7 @@ const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
186
208
  ? { register: () => {}, unregister: () => {} }
187
209
  : new FinalizationRegistry(
188
210
  state => {
189
- wasm.__wbindgen_export_5.get(state.dtor)(state.a, state.b);
211
+ wasm.__wbindgen_export_3.get(state.dtor)(state.a, state.b);
190
212
  }
191
213
  );
192
214
 
@@ -204,7 +226,7 @@ function makeMutClosure(arg0, arg1, dtor, f) {
204
226
  return f(a, state.b, ...args);
205
227
  } finally {
206
228
  if (--state.cnt === 0) {
207
- wasm.__wbindgen_export_5.get(state.dtor)(a, state.b);
229
+ wasm.__wbindgen_export_3.get(state.dtor)(a, state.b);
208
230
  CLOSURE_DTORS.unregister(state);
209
231
  } else {
210
232
  state.a = a;
@@ -222,12 +244,16 @@ export function getVersion() {
222
244
  let deferred1_0;
223
245
  let deferred1_1;
224
246
  try {
225
- const ret = wasm.getVersion();
226
- deferred1_0 = ret[0];
227
- deferred1_1 = ret[1];
228
- return getStringFromWasm0(ret[0], ret[1]);
247
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
248
+ wasm.getVersion(retptr);
249
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
250
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
251
+ deferred1_0 = r0;
252
+ deferred1_1 = r1;
253
+ return getStringFromWasm0(r0, r1);
229
254
  } finally {
230
- wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
255
+ wasm.__wbindgen_add_to_stack_pointer(16);
256
+ wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
231
257
  }
232
258
  }
233
259
 
@@ -238,14 +264,14 @@ export function getVersion() {
238
264
  * @returns {Promise<any>}
239
265
  */
240
266
  export function completeIssuePresentation(presentation, preparation, signature) {
241
- const ptr0 = passStringToWasm0(presentation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
267
+ const ptr0 = passStringToWasm0(presentation, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
242
268
  const len0 = WASM_VECTOR_LEN;
243
- const ptr1 = passStringToWasm0(preparation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
269
+ const ptr1 = passStringToWasm0(preparation, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
244
270
  const len1 = WASM_VECTOR_LEN;
245
- const ptr2 = passStringToWasm0(signature, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
271
+ const ptr2 = passStringToWasm0(signature, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
246
272
  const len2 = WASM_VECTOR_LEN;
247
273
  const ret = wasm.completeIssuePresentation(ptr0, len0, ptr1, len1, ptr2, len2);
248
- return ret;
274
+ return takeObject(ret);
249
275
  }
250
276
 
251
277
  /**
@@ -255,14 +281,14 @@ export function completeIssuePresentation(presentation, preparation, signature)
255
281
  * @returns {Promise<any>}
256
282
  */
257
283
  export function verifyPresentation(vp, proof_options, context_map) {
258
- const ptr0 = passStringToWasm0(vp, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
284
+ const ptr0 = passStringToWasm0(vp, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
259
285
  const len0 = WASM_VECTOR_LEN;
260
- const ptr1 = passStringToWasm0(proof_options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
286
+ const ptr1 = passStringToWasm0(proof_options, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
261
287
  const len1 = WASM_VECTOR_LEN;
262
- const ptr2 = passStringToWasm0(context_map, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
288
+ const ptr2 = passStringToWasm0(context_map, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
263
289
  const len2 = WASM_VECTOR_LEN;
264
290
  const ret = wasm.verifyPresentation(ptr0, len0, ptr1, len1, ptr2, len2);
265
- return ret;
291
+ return takeObject(ret);
266
292
  }
267
293
 
268
294
  /**
@@ -273,16 +299,16 @@ export function verifyPresentation(vp, proof_options, context_map) {
273
299
  * @returns {Promise<any>}
274
300
  */
275
301
  export function DIDAuth(holder, linked_data_proof_options, key, context_map) {
276
- const ptr0 = passStringToWasm0(holder, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
302
+ const ptr0 = passStringToWasm0(holder, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
277
303
  const len0 = WASM_VECTOR_LEN;
278
- const ptr1 = passStringToWasm0(linked_data_proof_options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
304
+ const ptr1 = passStringToWasm0(linked_data_proof_options, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
279
305
  const len1 = WASM_VECTOR_LEN;
280
- const ptr2 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
306
+ const ptr2 = passStringToWasm0(key, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
281
307
  const len2 = WASM_VECTOR_LEN;
282
- const ptr3 = passStringToWasm0(context_map, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
308
+ const ptr3 = passStringToWasm0(context_map, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
283
309
  const len3 = WASM_VECTOR_LEN;
284
310
  const ret = wasm.DIDAuth(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
285
- return ret;
311
+ return takeObject(ret);
286
312
  }
287
313
 
288
314
  /**
@@ -291,12 +317,12 @@ export function DIDAuth(holder, linked_data_proof_options, key, context_map) {
291
317
  * @returns {Promise<any>}
292
318
  */
293
319
  export function verifyInvocation(invocation, delegation) {
294
- const ptr0 = passStringToWasm0(invocation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
320
+ const ptr0 = passStringToWasm0(invocation, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
295
321
  const len0 = WASM_VECTOR_LEN;
296
- const ptr1 = passStringToWasm0(delegation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
322
+ const ptr1 = passStringToWasm0(delegation, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
297
323
  const len1 = WASM_VECTOR_LEN;
298
324
  const ret = wasm.verifyInvocation(ptr0, len0, ptr1, len1);
299
- return ret;
325
+ return takeObject(ret);
300
326
  }
301
327
 
302
328
  /**
@@ -304,10 +330,10 @@ export function verifyInvocation(invocation, delegation) {
304
330
  * @returns {Promise<any>}
305
331
  */
306
332
  export function contextLoader(url) {
307
- const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
333
+ const ptr0 = passStringToWasm0(url, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
308
334
  const len0 = WASM_VECTOR_LEN;
309
335
  const ret = wasm.contextLoader(ptr0, len0);
310
- return ret;
336
+ return takeObject(ret);
311
337
  }
312
338
 
313
339
  /**
@@ -315,10 +341,10 @@ export function contextLoader(url) {
315
341
  * @returns {Promise<any>}
316
342
  */
317
343
  export function JWKFromTezos(tz) {
318
- const ptr0 = passStringToWasm0(tz, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
344
+ const ptr0 = passStringToWasm0(tz, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
319
345
  const len0 = WASM_VECTOR_LEN;
320
346
  const ret = wasm.JWKFromTezos(ptr0, len0);
321
- return ret;
347
+ return takeObject(ret);
322
348
  }
323
349
 
324
350
  /**
@@ -329,16 +355,16 @@ export function JWKFromTezos(tz) {
329
355
  * @returns {Promise<any>}
330
356
  */
331
357
  export function delegateCapability(capability, linked_data_proof_options, parents, key) {
332
- const ptr0 = passStringToWasm0(capability, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
358
+ const ptr0 = passStringToWasm0(capability, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
333
359
  const len0 = WASM_VECTOR_LEN;
334
- const ptr1 = passStringToWasm0(linked_data_proof_options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
360
+ const ptr1 = passStringToWasm0(linked_data_proof_options, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
335
361
  const len1 = WASM_VECTOR_LEN;
336
- const ptr2 = passStringToWasm0(parents, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
362
+ const ptr2 = passStringToWasm0(parents, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
337
363
  const len2 = WASM_VECTOR_LEN;
338
- const ptr3 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
364
+ const ptr3 = passStringToWasm0(key, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
339
365
  const len3 = WASM_VECTOR_LEN;
340
366
  const ret = wasm.delegateCapability(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
341
- return ret;
367
+ return takeObject(ret);
342
368
  }
343
369
 
344
370
  /**
@@ -349,16 +375,16 @@ export function delegateCapability(capability, linked_data_proof_options, parent
349
375
  * @returns {Promise<any>}
350
376
  */
351
377
  export function prepareDelegateCapability(capability, linked_data_proof_options, parents, public_key) {
352
- const ptr0 = passStringToWasm0(capability, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
378
+ const ptr0 = passStringToWasm0(capability, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
353
379
  const len0 = WASM_VECTOR_LEN;
354
- const ptr1 = passStringToWasm0(linked_data_proof_options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
380
+ const ptr1 = passStringToWasm0(linked_data_proof_options, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
355
381
  const len1 = WASM_VECTOR_LEN;
356
- const ptr2 = passStringToWasm0(parents, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
382
+ const ptr2 = passStringToWasm0(parents, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
357
383
  const len2 = WASM_VECTOR_LEN;
358
- const ptr3 = passStringToWasm0(public_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
384
+ const ptr3 = passStringToWasm0(public_key, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
359
385
  const len3 = WASM_VECTOR_LEN;
360
386
  const ret = wasm.prepareDelegateCapability(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
361
- return ret;
387
+ return takeObject(ret);
362
388
  }
363
389
 
364
390
  /**
@@ -368,14 +394,14 @@ export function prepareDelegateCapability(capability, linked_data_proof_options,
368
394
  * @returns {Promise<any>}
369
395
  */
370
396
  export function completeDelegateCapability(capability, preparation, signature) {
371
- const ptr0 = passStringToWasm0(capability, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
397
+ const ptr0 = passStringToWasm0(capability, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
372
398
  const len0 = WASM_VECTOR_LEN;
373
- const ptr1 = passStringToWasm0(preparation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
399
+ const ptr1 = passStringToWasm0(preparation, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
374
400
  const len1 = WASM_VECTOR_LEN;
375
- const ptr2 = passStringToWasm0(signature, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
401
+ const ptr2 = passStringToWasm0(signature, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
376
402
  const len2 = WASM_VECTOR_LEN;
377
403
  const ret = wasm.completeDelegateCapability(ptr0, len0, ptr1, len1, ptr2, len2);
378
- return ret;
404
+ return takeObject(ret);
379
405
  }
380
406
 
381
407
  /**
@@ -383,10 +409,10 @@ export function completeDelegateCapability(capability, preparation, signature) {
383
409
  * @returns {Promise<any>}
384
410
  */
385
411
  export function verifyDelegation(delegation) {
386
- const ptr0 = passStringToWasm0(delegation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
412
+ const ptr0 = passStringToWasm0(delegation, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
387
413
  const len0 = WASM_VECTOR_LEN;
388
414
  const ret = wasm.verifyDelegation(ptr0, len0);
389
- return ret;
415
+ return takeObject(ret);
390
416
  }
391
417
 
392
418
  /**
@@ -397,16 +423,16 @@ export function verifyDelegation(delegation) {
397
423
  * @returns {Promise<any>}
398
424
  */
399
425
  export function invokeCapability(invocation, target_id, linked_data_proof_options, key) {
400
- const ptr0 = passStringToWasm0(invocation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
426
+ const ptr0 = passStringToWasm0(invocation, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
401
427
  const len0 = WASM_VECTOR_LEN;
402
- const ptr1 = passStringToWasm0(target_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
428
+ const ptr1 = passStringToWasm0(target_id, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
403
429
  const len1 = WASM_VECTOR_LEN;
404
- const ptr2 = passStringToWasm0(linked_data_proof_options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
430
+ const ptr2 = passStringToWasm0(linked_data_proof_options, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
405
431
  const len2 = WASM_VECTOR_LEN;
406
- const ptr3 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
432
+ const ptr3 = passStringToWasm0(key, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
407
433
  const len3 = WASM_VECTOR_LEN;
408
434
  const ret = wasm.invokeCapability(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
409
- return ret;
435
+ return takeObject(ret);
410
436
  }
411
437
 
412
438
  /**
@@ -417,16 +443,16 @@ export function invokeCapability(invocation, target_id, linked_data_proof_option
417
443
  * @returns {Promise<any>}
418
444
  */
419
445
  export function prepareInvokeCapability(invocation, target_id, linked_data_proof_options, public_key) {
420
- const ptr0 = passStringToWasm0(invocation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
446
+ const ptr0 = passStringToWasm0(invocation, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
421
447
  const len0 = WASM_VECTOR_LEN;
422
- const ptr1 = passStringToWasm0(target_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
448
+ const ptr1 = passStringToWasm0(target_id, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
423
449
  const len1 = WASM_VECTOR_LEN;
424
- const ptr2 = passStringToWasm0(linked_data_proof_options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
450
+ const ptr2 = passStringToWasm0(linked_data_proof_options, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
425
451
  const len2 = WASM_VECTOR_LEN;
426
- const ptr3 = passStringToWasm0(public_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
452
+ const ptr3 = passStringToWasm0(public_key, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
427
453
  const len3 = WASM_VECTOR_LEN;
428
454
  const ret = wasm.prepareInvokeCapability(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
429
- return ret;
455
+ return takeObject(ret);
430
456
  }
431
457
 
432
458
  /**
@@ -436,14 +462,14 @@ export function prepareInvokeCapability(invocation, target_id, linked_data_proof
436
462
  * @returns {Promise<any>}
437
463
  */
438
464
  export function completeInvokeCapability(invocation, preparation, signature) {
439
- const ptr0 = passStringToWasm0(invocation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
465
+ const ptr0 = passStringToWasm0(invocation, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
440
466
  const len0 = WASM_VECTOR_LEN;
441
- const ptr1 = passStringToWasm0(preparation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
467
+ const ptr1 = passStringToWasm0(preparation, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
442
468
  const len1 = WASM_VECTOR_LEN;
443
- const ptr2 = passStringToWasm0(signature, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
469
+ const ptr2 = passStringToWasm0(signature, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
444
470
  const len2 = WASM_VECTOR_LEN;
445
471
  const ret = wasm.completeInvokeCapability(ptr0, len0, ptr1, len1, ptr2, len2);
446
- return ret;
472
+ return takeObject(ret);
447
473
  }
448
474
 
449
475
  /**
@@ -451,10 +477,10 @@ export function completeInvokeCapability(invocation, preparation, signature) {
451
477
  * @returns {Promise<any>}
452
478
  */
453
479
  export function verifyInvocationSignature(invocation) {
454
- const ptr0 = passStringToWasm0(invocation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
480
+ const ptr0 = passStringToWasm0(invocation, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
455
481
  const len0 = WASM_VECTOR_LEN;
456
482
  const ret = wasm.verifyInvocationSignature(ptr0, len0);
457
- return ret;
483
+ return takeObject(ret);
458
484
  }
459
485
 
460
486
  /**
@@ -462,7 +488,7 @@ export function verifyInvocationSignature(invocation) {
462
488
  */
463
489
  export function clearCache() {
464
490
  const ret = wasm.clearCache();
465
- return ret;
491
+ return takeObject(ret);
466
492
  }
467
493
 
468
494
  /**
@@ -471,12 +497,12 @@ export function clearCache() {
471
497
  * @returns {Promise<any>}
472
498
  */
473
499
  export function didResolver(did, input_metadata) {
474
- const ptr0 = passStringToWasm0(did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
500
+ const ptr0 = passStringToWasm0(did, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
475
501
  const len0 = WASM_VECTOR_LEN;
476
- const ptr1 = passStringToWasm0(input_metadata, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
502
+ const ptr1 = passStringToWasm0(input_metadata, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
477
503
  const len1 = WASM_VECTOR_LEN;
478
504
  const ret = wasm.didResolver(ptr0, len0, ptr1, len1);
479
- return ret;
505
+ return takeObject(ret);
480
506
  }
481
507
 
482
508
  /**
@@ -485,19 +511,14 @@ export function didResolver(did, input_metadata) {
485
511
  * @returns {Promise<any>}
486
512
  */
487
513
  export function resolveDID(did, input_metadata) {
488
- const ptr0 = passStringToWasm0(did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
514
+ const ptr0 = passStringToWasm0(did, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
489
515
  const len0 = WASM_VECTOR_LEN;
490
- const ptr1 = passStringToWasm0(input_metadata, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
516
+ const ptr1 = passStringToWasm0(input_metadata, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
491
517
  const len1 = WASM_VECTOR_LEN;
492
518
  const ret = wasm.resolveDID(ptr0, len0, ptr1, len1);
493
- return ret;
519
+ return takeObject(ret);
494
520
  }
495
521
 
496
- function takeFromExternrefTable0(idx) {
497
- const value = wasm.__wbindgen_export_4.get(idx);
498
- wasm.__externref_table_dealloc(idx);
499
- return value;
500
- }
501
522
  /**
502
523
  * @param {string} method_pattern
503
524
  * @param {string} jwk
@@ -507,22 +528,28 @@ export function keyToDID(method_pattern, jwk) {
507
528
  let deferred4_0;
508
529
  let deferred4_1;
509
530
  try {
510
- const ptr0 = passStringToWasm0(method_pattern, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
531
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
532
+ const ptr0 = passStringToWasm0(method_pattern, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
511
533
  const len0 = WASM_VECTOR_LEN;
512
- const ptr1 = passStringToWasm0(jwk, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
534
+ const ptr1 = passStringToWasm0(jwk, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
513
535
  const len1 = WASM_VECTOR_LEN;
514
- const ret = wasm.keyToDID(ptr0, len0, ptr1, len1);
515
- var ptr3 = ret[0];
516
- var len3 = ret[1];
517
- if (ret[3]) {
536
+ wasm.keyToDID(retptr, ptr0, len0, ptr1, len1);
537
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
538
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
539
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
540
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
541
+ var ptr3 = r0;
542
+ var len3 = r1;
543
+ if (r3) {
518
544
  ptr3 = 0; len3 = 0;
519
- throw takeFromExternrefTable0(ret[2]);
545
+ throw takeObject(r2);
520
546
  }
521
547
  deferred4_0 = ptr3;
522
548
  deferred4_1 = len3;
523
549
  return getStringFromWasm0(ptr3, len3);
524
550
  } finally {
525
- wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
551
+ wasm.__wbindgen_add_to_stack_pointer(16);
552
+ wasm.__wbindgen_export_4(deferred4_0, deferred4_1, 1);
526
553
  }
527
554
  }
528
555
 
@@ -532,12 +559,12 @@ export function keyToDID(method_pattern, jwk) {
532
559
  * @returns {Promise<any>}
533
560
  */
534
561
  export function keyToVerificationMethod(method_pattern, jwk) {
535
- const ptr0 = passStringToWasm0(method_pattern, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
562
+ const ptr0 = passStringToWasm0(method_pattern, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
536
563
  const len0 = WASM_VECTOR_LEN;
537
- const ptr1 = passStringToWasm0(jwk, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
564
+ const ptr1 = passStringToWasm0(jwk, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
538
565
  const len1 = WASM_VECTOR_LEN;
539
566
  const ret = wasm.keyToVerificationMethod(ptr0, len0, ptr1, len1);
540
- return ret;
567
+ return takeObject(ret);
541
568
  }
542
569
 
543
570
  /**
@@ -545,10 +572,10 @@ export function keyToVerificationMethod(method_pattern, jwk) {
545
572
  * @returns {Promise<any>}
546
573
  */
547
574
  export function didToVerificationMethod(did) {
548
- const ptr0 = passStringToWasm0(did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
575
+ const ptr0 = passStringToWasm0(did, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
549
576
  const len0 = WASM_VECTOR_LEN;
550
577
  const ret = wasm.didToVerificationMethod(ptr0, len0);
551
- return ret;
578
+ return takeObject(ret);
552
579
  }
553
580
 
554
581
  /**
@@ -559,16 +586,16 @@ export function didToVerificationMethod(did) {
559
586
  * @returns {Promise<any>}
560
587
  */
561
588
  export function issueCredential(credential, proof_options, key, context_map) {
562
- const ptr0 = passStringToWasm0(credential, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
589
+ const ptr0 = passStringToWasm0(credential, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
563
590
  const len0 = WASM_VECTOR_LEN;
564
- const ptr1 = passStringToWasm0(proof_options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
591
+ const ptr1 = passStringToWasm0(proof_options, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
565
592
  const len1 = WASM_VECTOR_LEN;
566
- const ptr2 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
593
+ const ptr2 = passStringToWasm0(key, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
567
594
  const len2 = WASM_VECTOR_LEN;
568
- const ptr3 = passStringToWasm0(context_map, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
595
+ const ptr3 = passStringToWasm0(context_map, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
569
596
  const len3 = WASM_VECTOR_LEN;
570
597
  const ret = wasm.issueCredential(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
571
- return ret;
598
+ return takeObject(ret);
572
599
  }
573
600
 
574
601
  /**
@@ -578,14 +605,14 @@ export function issueCredential(credential, proof_options, key, context_map) {
578
605
  * @returns {Promise<any>}
579
606
  */
580
607
  export function prepareIssueCredential(credential, linked_data_proof_options, public_key) {
581
- const ptr0 = passStringToWasm0(credential, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
608
+ const ptr0 = passStringToWasm0(credential, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
582
609
  const len0 = WASM_VECTOR_LEN;
583
- const ptr1 = passStringToWasm0(linked_data_proof_options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
610
+ const ptr1 = passStringToWasm0(linked_data_proof_options, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
584
611
  const len1 = WASM_VECTOR_LEN;
585
- const ptr2 = passStringToWasm0(public_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
612
+ const ptr2 = passStringToWasm0(public_key, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
586
613
  const len2 = WASM_VECTOR_LEN;
587
614
  const ret = wasm.prepareIssueCredential(ptr0, len0, ptr1, len1, ptr2, len2);
588
- return ret;
615
+ return takeObject(ret);
589
616
  }
590
617
 
591
618
  /**
@@ -595,14 +622,14 @@ export function prepareIssueCredential(credential, linked_data_proof_options, pu
595
622
  * @returns {Promise<any>}
596
623
  */
597
624
  export function completeIssueCredential(credential, preparation, signature) {
598
- const ptr0 = passStringToWasm0(credential, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
625
+ const ptr0 = passStringToWasm0(credential, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
599
626
  const len0 = WASM_VECTOR_LEN;
600
- const ptr1 = passStringToWasm0(preparation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
627
+ const ptr1 = passStringToWasm0(preparation, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
601
628
  const len1 = WASM_VECTOR_LEN;
602
- const ptr2 = passStringToWasm0(signature, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
629
+ const ptr2 = passStringToWasm0(signature, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
603
630
  const len2 = WASM_VECTOR_LEN;
604
631
  const ret = wasm.completeIssueCredential(ptr0, len0, ptr1, len1, ptr2, len2);
605
- return ret;
632
+ return takeObject(ret);
606
633
  }
607
634
 
608
635
  /**
@@ -612,14 +639,14 @@ export function completeIssueCredential(credential, preparation, signature) {
612
639
  * @returns {Promise<any>}
613
640
  */
614
641
  export function verifyCredential(vc, proof_options, context_map) {
615
- const ptr0 = passStringToWasm0(vc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
642
+ const ptr0 = passStringToWasm0(vc, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
616
643
  const len0 = WASM_VECTOR_LEN;
617
- const ptr1 = passStringToWasm0(proof_options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
644
+ const ptr1 = passStringToWasm0(proof_options, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
618
645
  const len1 = WASM_VECTOR_LEN;
619
- const ptr2 = passStringToWasm0(context_map, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
646
+ const ptr2 = passStringToWasm0(context_map, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
620
647
  const len2 = WASM_VECTOR_LEN;
621
648
  const ret = wasm.verifyCredential(ptr0, len0, ptr1, len1, ptr2, len2);
622
- return ret;
649
+ return takeObject(ret);
623
650
  }
624
651
 
625
652
  /**
@@ -630,16 +657,16 @@ export function verifyCredential(vc, proof_options, context_map) {
630
657
  * @returns {Promise<any>}
631
658
  */
632
659
  export function issuePresentation(presentation, proof_options, key, context_map) {
633
- const ptr0 = passStringToWasm0(presentation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
660
+ const ptr0 = passStringToWasm0(presentation, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
634
661
  const len0 = WASM_VECTOR_LEN;
635
- const ptr1 = passStringToWasm0(proof_options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
662
+ const ptr1 = passStringToWasm0(proof_options, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
636
663
  const len1 = WASM_VECTOR_LEN;
637
- const ptr2 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
664
+ const ptr2 = passStringToWasm0(key, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
638
665
  const len2 = WASM_VECTOR_LEN;
639
- const ptr3 = passStringToWasm0(context_map, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
666
+ const ptr3 = passStringToWasm0(context_map, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
640
667
  const len3 = WASM_VECTOR_LEN;
641
668
  const ret = wasm.issuePresentation(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
642
- return ret;
669
+ return takeObject(ret);
643
670
  }
644
671
 
645
672
  /**
@@ -649,14 +676,14 @@ export function issuePresentation(presentation, proof_options, key, context_map)
649
676
  * @returns {Promise<any>}
650
677
  */
651
678
  export function prepareIssuePresentation(presentation, linked_data_proof_options, public_key) {
652
- const ptr0 = passStringToWasm0(presentation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
679
+ const ptr0 = passStringToWasm0(presentation, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
653
680
  const len0 = WASM_VECTOR_LEN;
654
- const ptr1 = passStringToWasm0(linked_data_proof_options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
681
+ const ptr1 = passStringToWasm0(linked_data_proof_options, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
655
682
  const len1 = WASM_VECTOR_LEN;
656
- const ptr2 = passStringToWasm0(public_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
683
+ const ptr2 = passStringToWasm0(public_key, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
657
684
  const len2 = WASM_VECTOR_LEN;
658
685
  const ret = wasm.prepareIssuePresentation(ptr0, len0, ptr1, len1, ptr2, len2);
659
- return ret;
686
+ return takeObject(ret);
660
687
  }
661
688
 
662
689
  /**
@@ -666,18 +693,24 @@ export function generateEd25519Key() {
666
693
  let deferred2_0;
667
694
  let deferred2_1;
668
695
  try {
669
- const ret = wasm.generateEd25519Key();
670
- var ptr1 = ret[0];
671
- var len1 = ret[1];
672
- if (ret[3]) {
696
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
697
+ wasm.generateEd25519Key(retptr);
698
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
699
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
700
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
701
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
702
+ var ptr1 = r0;
703
+ var len1 = r1;
704
+ if (r3) {
673
705
  ptr1 = 0; len1 = 0;
674
- throw takeFromExternrefTable0(ret[2]);
706
+ throw takeObject(r2);
675
707
  }
676
708
  deferred2_0 = ptr1;
677
709
  deferred2_1 = len1;
678
710
  return getStringFromWasm0(ptr1, len1);
679
711
  } finally {
680
- wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
712
+ wasm.__wbindgen_add_to_stack_pointer(16);
713
+ wasm.__wbindgen_export_4(deferred2_0, deferred2_1, 1);
681
714
  }
682
715
  }
683
716
 
@@ -695,20 +728,26 @@ export function generateEd25519KeyFromBytes(bytes) {
695
728
  let deferred3_0;
696
729
  let deferred3_1;
697
730
  try {
698
- const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
731
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
732
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export_0);
699
733
  const len0 = WASM_VECTOR_LEN;
700
- const ret = wasm.generateEd25519KeyFromBytes(ptr0, len0);
701
- var ptr2 = ret[0];
702
- var len2 = ret[1];
703
- if (ret[3]) {
734
+ wasm.generateEd25519KeyFromBytes(retptr, ptr0, len0);
735
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
736
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
737
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
738
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
739
+ var ptr2 = r0;
740
+ var len2 = r1;
741
+ if (r3) {
704
742
  ptr2 = 0; len2 = 0;
705
- throw takeFromExternrefTable0(ret[2]);
743
+ throw takeObject(r2);
706
744
  }
707
745
  deferred3_0 = ptr2;
708
746
  deferred3_1 = len2;
709
747
  return getStringFromWasm0(ptr2, len2);
710
748
  } finally {
711
- wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
749
+ wasm.__wbindgen_add_to_stack_pointer(16);
750
+ wasm.__wbindgen_export_4(deferred3_0, deferred3_1, 1);
712
751
  }
713
752
  }
714
753
 
@@ -719,18 +758,24 @@ export function generateSecp256k1Key() {
719
758
  let deferred2_0;
720
759
  let deferred2_1;
721
760
  try {
722
- const ret = wasm.generateSecp256k1Key();
723
- var ptr1 = ret[0];
724
- var len1 = ret[1];
725
- if (ret[3]) {
761
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
762
+ wasm.generateSecp256k1Key(retptr);
763
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
764
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
765
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
766
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
767
+ var ptr1 = r0;
768
+ var len1 = r1;
769
+ if (r3) {
726
770
  ptr1 = 0; len1 = 0;
727
- throw takeFromExternrefTable0(ret[2]);
771
+ throw takeObject(r2);
728
772
  }
729
773
  deferred2_0 = ptr1;
730
774
  deferred2_1 = len1;
731
775
  return getStringFromWasm0(ptr1, len1);
732
776
  } finally {
733
- wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
777
+ wasm.__wbindgen_add_to_stack_pointer(16);
778
+ wasm.__wbindgen_export_4(deferred2_0, deferred2_1, 1);
734
779
  }
735
780
  }
736
781
 
@@ -742,28 +787,34 @@ export function generateSecp256k1KeyFromBytes(bytes) {
742
787
  let deferred3_0;
743
788
  let deferred3_1;
744
789
  try {
745
- const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
790
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
791
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export_0);
746
792
  const len0 = WASM_VECTOR_LEN;
747
- const ret = wasm.generateSecp256k1KeyFromBytes(ptr0, len0);
748
- var ptr2 = ret[0];
749
- var len2 = ret[1];
750
- if (ret[3]) {
793
+ wasm.generateSecp256k1KeyFromBytes(retptr, ptr0, len0);
794
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
795
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
796
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
797
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
798
+ var ptr2 = r0;
799
+ var len2 = r1;
800
+ if (r3) {
751
801
  ptr2 = 0; len2 = 0;
752
- throw takeFromExternrefTable0(ret[2]);
802
+ throw takeObject(r2);
753
803
  }
754
804
  deferred3_0 = ptr2;
755
805
  deferred3_1 = len2;
756
806
  return getStringFromWasm0(ptr2, len2);
757
807
  } finally {
758
- wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
808
+ wasm.__wbindgen_add_to_stack_pointer(16);
809
+ wasm.__wbindgen_export_4(deferred3_0, deferred3_1, 1);
759
810
  }
760
811
  }
761
812
 
762
813
  function passArrayJsValueToWasm0(array, malloc) {
763
814
  const ptr = malloc(array.length * 4, 4) >>> 0;
815
+ const mem = getDataViewMemory0();
764
816
  for (let i = 0; i < array.length; i++) {
765
- const add = addToExternrefTable0(array[i]);
766
- getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
817
+ mem.setUint32(ptr + 4 * i, addHeapObject(array[i]), true);
767
818
  }
768
819
  WASM_VECTOR_LEN = array.length;
769
820
  return ptr;
@@ -774,12 +825,12 @@ function passArrayJsValueToWasm0(array, malloc) {
774
825
  * @returns {Promise<any>}
775
826
  */
776
827
  export function createJwe(cleartext, recipients) {
777
- const ptr0 = passStringToWasm0(cleartext, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
828
+ const ptr0 = passStringToWasm0(cleartext, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
778
829
  const len0 = WASM_VECTOR_LEN;
779
- const ptr1 = passArrayJsValueToWasm0(recipients, wasm.__wbindgen_malloc);
830
+ const ptr1 = passArrayJsValueToWasm0(recipients, wasm.__wbindgen_export_0);
780
831
  const len1 = WASM_VECTOR_LEN;
781
832
  const ret = wasm.createJwe(ptr0, len0, ptr1, len1);
782
- return ret;
833
+ return takeObject(ret);
783
834
  }
784
835
 
785
836
  /**
@@ -788,12 +839,12 @@ export function createJwe(cleartext, recipients) {
788
839
  * @returns {Promise<any>}
789
840
  */
790
841
  export function decryptJwe(jwe, jwks) {
791
- const ptr0 = passStringToWasm0(jwe, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
842
+ const ptr0 = passStringToWasm0(jwe, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
792
843
  const len0 = WASM_VECTOR_LEN;
793
- const ptr1 = passArrayJsValueToWasm0(jwks, wasm.__wbindgen_malloc);
844
+ const ptr1 = passArrayJsValueToWasm0(jwks, wasm.__wbindgen_export_0);
794
845
  const len1 = WASM_VECTOR_LEN;
795
846
  const ret = wasm.decryptJwe(ptr0, len0, ptr1, len1);
796
- return ret;
847
+ return takeObject(ret);
797
848
  }
798
849
 
799
850
  /**
@@ -802,10 +853,10 @@ export function decryptJwe(jwe, jwks) {
802
853
  * @returns {Promise<any>}
803
854
  */
804
855
  export function createDagJwe(cleartext, recipients) {
805
- const ptr0 = passArrayJsValueToWasm0(recipients, wasm.__wbindgen_malloc);
856
+ const ptr0 = passArrayJsValueToWasm0(recipients, wasm.__wbindgen_export_0);
806
857
  const len0 = WASM_VECTOR_LEN;
807
- const ret = wasm.createDagJwe(cleartext, ptr0, len0);
808
- return ret;
858
+ const ret = wasm.createDagJwe(addHeapObject(cleartext), ptr0, len0);
859
+ return takeObject(ret);
809
860
  }
810
861
 
811
862
  /**
@@ -814,24 +865,24 @@ export function createDagJwe(cleartext, recipients) {
814
865
  * @returns {Promise<any>}
815
866
  */
816
867
  export function decryptDagJwe(jwe, jwks) {
817
- const ptr0 = passStringToWasm0(jwe, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
868
+ const ptr0 = passStringToWasm0(jwe, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
818
869
  const len0 = WASM_VECTOR_LEN;
819
- const ptr1 = passArrayJsValueToWasm0(jwks, wasm.__wbindgen_malloc);
870
+ const ptr1 = passArrayJsValueToWasm0(jwks, wasm.__wbindgen_export_0);
820
871
  const len1 = WASM_VECTOR_LEN;
821
872
  const ret = wasm.decryptDagJwe(ptr0, len0, ptr1, len1);
822
- return ret;
873
+ return takeObject(ret);
823
874
  }
824
875
 
825
- function __wbg_adapter_6(arg0, arg1, arg2) {
826
- wasm.closure4311_externref_shim(arg0, arg1, arg2);
876
+ function __wbg_adapter_4(arg0, arg1) {
877
+ wasm.__wbindgen_export_5(arg0, arg1);
827
878
  }
828
879
 
829
- function __wbg_adapter_21(arg0, arg1) {
830
- wasm.wasm_bindgen_5201f94d5c03cb67___convert__closures_____invoke______(arg0, arg1);
880
+ function __wbg_adapter_17(arg0, arg1, arg2) {
881
+ wasm.__wbindgen_export_6(arg0, arg1, addHeapObject(arg2));
831
882
  }
832
883
 
833
- function __wbg_adapter_165(arg0, arg1, arg2, arg3) {
834
- wasm.closure4700_externref_shim(arg0, arg1, arg2, arg3);
884
+ function __wbg_adapter_107(arg0, arg1, arg2, arg3) {
885
+ wasm.__wbindgen_export_7(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
835
886
  }
836
887
 
837
888
  const __wbindgen_enum_RequestCache = ["default", "no-store", "reload", "no-cache", "force-cache", "only-if-cached"];
@@ -880,94 +931,94 @@ function __wbg_get_imports() {
880
931
  imports.wbg = {};
881
932
  imports.wbg.__wbg_Error_e17e777aac105295 = function(arg0, arg1) {
882
933
  const ret = Error(getStringFromWasm0(arg0, arg1));
883
- return ret;
934
+ return addHeapObject(ret);
884
935
  };
885
936
  imports.wbg.__wbg_String_8f0eb39a4a4c2f66 = function(arg0, arg1) {
886
- const ret = String(arg1);
887
- const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
937
+ const ret = String(getObject(arg1));
938
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
888
939
  const len1 = WASM_VECTOR_LEN;
889
940
  getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
890
941
  getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
891
942
  };
892
943
  imports.wbg.__wbg_abort_67e1b49bf6614565 = function(arg0) {
893
- arg0.abort();
944
+ getObject(arg0).abort();
894
945
  };
895
946
  imports.wbg.__wbg_abort_d830bf2e9aa6ec5b = function(arg0, arg1) {
896
- arg0.abort(arg1);
947
+ getObject(arg0).abort(getObject(arg1));
897
948
  };
898
949
  imports.wbg.__wbg_append_72a3c0addd2bce38 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
899
- arg0.append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
950
+ getObject(arg0).append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
900
951
  }, arguments) };
901
952
  imports.wbg.__wbg_arrayBuffer_9c99b8e2809e8cbb = function() { return handleError(function (arg0) {
902
- const ret = arg0.arrayBuffer();
903
- return ret;
953
+ const ret = getObject(arg0).arrayBuffer();
954
+ return addHeapObject(ret);
904
955
  }, arguments) };
905
956
  imports.wbg.__wbg_call_13410aac570ffff7 = function() { return handleError(function (arg0, arg1) {
906
- const ret = arg0.call(arg1);
907
- return ret;
957
+ const ret = getObject(arg0).call(getObject(arg1));
958
+ return addHeapObject(ret);
908
959
  }, arguments) };
909
960
  imports.wbg.__wbg_call_a5400b25a865cfd8 = function() { return handleError(function (arg0, arg1, arg2) {
910
- const ret = arg0.call(arg1, arg2);
911
- return ret;
961
+ const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
962
+ return addHeapObject(ret);
912
963
  }, arguments) };
913
964
  imports.wbg.__wbg_clearTimeout_42d9ccd50822fd3a = function(arg0) {
914
- const ret = clearTimeout(arg0);
915
- return ret;
965
+ const ret = clearTimeout(takeObject(arg0));
966
+ return addHeapObject(ret);
916
967
  };
917
968
  imports.wbg.__wbg_crypto_574e78ad8b13b65f = function(arg0) {
918
- const ret = arg0.crypto;
919
- return ret;
969
+ const ret = getObject(arg0).crypto;
970
+ return addHeapObject(ret);
920
971
  };
921
972
  imports.wbg.__wbg_done_75ed0ee6dd243d9d = function(arg0) {
922
- const ret = arg0.done;
973
+ const ret = getObject(arg0).done;
923
974
  return ret;
924
975
  };
925
976
  imports.wbg.__wbg_entries_2be2f15bd5554996 = function(arg0) {
926
- const ret = Object.entries(arg0);
927
- return ret;
977
+ const ret = Object.entries(getObject(arg0));
978
+ return addHeapObject(ret);
928
979
  };
929
980
  imports.wbg.__wbg_fetch_6bbc32f991730587 = function(arg0) {
930
- const ret = fetch(arg0);
931
- return ret;
981
+ const ret = fetch(getObject(arg0));
982
+ return addHeapObject(ret);
932
983
  };
933
984
  imports.wbg.__wbg_fetch_87aed7f306ec6d63 = function(arg0, arg1) {
934
- const ret = arg0.fetch(arg1);
935
- return ret;
985
+ const ret = getObject(arg0).fetch(getObject(arg1));
986
+ return addHeapObject(ret);
936
987
  };
937
988
  imports.wbg.__wbg_from_88bc52ce20ba6318 = function(arg0) {
938
- const ret = Array.from(arg0);
939
- return ret;
989
+ const ret = Array.from(getObject(arg0));
990
+ return addHeapObject(ret);
940
991
  };
941
992
  imports.wbg.__wbg_getRandomValues_1c61fac11405ffdc = function() { return handleError(function (arg0, arg1) {
942
993
  globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
943
994
  }, arguments) };
944
995
  imports.wbg.__wbg_getRandomValues_b8f5dbd5f3995a9e = function() { return handleError(function (arg0, arg1) {
945
- arg0.getRandomValues(arg1);
996
+ getObject(arg0).getRandomValues(getObject(arg1));
946
997
  }, arguments) };
947
998
  imports.wbg.__wbg_getTime_6bb3f64e0f18f817 = function(arg0) {
948
- const ret = arg0.getTime();
999
+ const ret = getObject(arg0).getTime();
949
1000
  return ret;
950
1001
  };
951
1002
  imports.wbg.__wbg_get_0da715ceaecea5c8 = function(arg0, arg1) {
952
- const ret = arg0[arg1 >>> 0];
953
- return ret;
1003
+ const ret = getObject(arg0)[arg1 >>> 0];
1004
+ return addHeapObject(ret);
954
1005
  };
955
1006
  imports.wbg.__wbg_get_458e874b43b18b25 = function() { return handleError(function (arg0, arg1) {
956
- const ret = Reflect.get(arg0, arg1);
957
- return ret;
1007
+ const ret = Reflect.get(getObject(arg0), getObject(arg1));
1008
+ return addHeapObject(ret);
958
1009
  }, arguments) };
959
1010
  imports.wbg.__wbg_has_b89e451f638123e3 = function() { return handleError(function (arg0, arg1) {
960
- const ret = Reflect.has(arg0, arg1);
1011
+ const ret = Reflect.has(getObject(arg0), getObject(arg1));
961
1012
  return ret;
962
1013
  }, arguments) };
963
1014
  imports.wbg.__wbg_headers_29fec3c72865cd75 = function(arg0) {
964
- const ret = arg0.headers;
965
- return ret;
1015
+ const ret = getObject(arg0).headers;
1016
+ return addHeapObject(ret);
966
1017
  };
967
1018
  imports.wbg.__wbg_instanceof_ArrayBuffer_67f3012529f6a2dd = function(arg0) {
968
1019
  let result;
969
1020
  try {
970
- result = arg0 instanceof ArrayBuffer;
1021
+ result = getObject(arg0) instanceof ArrayBuffer;
971
1022
  } catch (_) {
972
1023
  result = false;
973
1024
  }
@@ -977,7 +1028,7 @@ function __wbg_get_imports() {
977
1028
  imports.wbg.__wbg_instanceof_Map_ebb01a5b6b5ffd0b = function(arg0) {
978
1029
  let result;
979
1030
  try {
980
- result = arg0 instanceof Map;
1031
+ result = getObject(arg0) instanceof Map;
981
1032
  } catch (_) {
982
1033
  result = false;
983
1034
  }
@@ -987,7 +1038,7 @@ function __wbg_get_imports() {
987
1038
  imports.wbg.__wbg_instanceof_Response_50fde2cd696850bf = function(arg0) {
988
1039
  let result;
989
1040
  try {
990
- result = arg0 instanceof Response;
1041
+ result = getObject(arg0) instanceof Response;
991
1042
  } catch (_) {
992
1043
  result = false;
993
1044
  }
@@ -997,7 +1048,7 @@ function __wbg_get_imports() {
997
1048
  imports.wbg.__wbg_instanceof_Uint8Array_9a8378d955933db7 = function(arg0) {
998
1049
  let result;
999
1050
  try {
1000
- result = arg0 instanceof Uint8Array;
1051
+ result = getObject(arg0) instanceof Uint8Array;
1001
1052
  } catch (_) {
1002
1053
  result = false;
1003
1054
  }
@@ -1005,44 +1056,44 @@ function __wbg_get_imports() {
1005
1056
  return ret;
1006
1057
  };
1007
1058
  imports.wbg.__wbg_isArray_030cce220591fb41 = function(arg0) {
1008
- const ret = Array.isArray(arg0);
1059
+ const ret = Array.isArray(getObject(arg0));
1009
1060
  return ret;
1010
1061
  };
1011
1062
  imports.wbg.__wbg_isSafeInteger_1c0d1af5542e102a = function(arg0) {
1012
- const ret = Number.isSafeInteger(arg0);
1063
+ const ret = Number.isSafeInteger(getObject(arg0));
1013
1064
  return ret;
1014
1065
  };
1015
1066
  imports.wbg.__wbg_iterator_f370b34483c71a1c = function() {
1016
1067
  const ret = Symbol.iterator;
1017
- return ret;
1068
+ return addHeapObject(ret);
1018
1069
  };
1019
1070
  imports.wbg.__wbg_keys_ef52390b2ae0e714 = function(arg0) {
1020
- const ret = Object.keys(arg0);
1021
- return ret;
1071
+ const ret = Object.keys(getObject(arg0));
1072
+ return addHeapObject(ret);
1022
1073
  };
1023
1074
  imports.wbg.__wbg_length_186546c51cd61acd = function(arg0) {
1024
- const ret = arg0.length;
1075
+ const ret = getObject(arg0).length;
1025
1076
  return ret;
1026
1077
  };
1027
1078
  imports.wbg.__wbg_length_6bb7e81f9d7713e4 = function(arg0) {
1028
- const ret = arg0.length;
1079
+ const ret = getObject(arg0).length;
1029
1080
  return ret;
1030
1081
  };
1031
1082
  imports.wbg.__wbg_msCrypto_a61aeb35a24c1329 = function(arg0) {
1032
- const ret = arg0.msCrypto;
1033
- return ret;
1083
+ const ret = getObject(arg0).msCrypto;
1084
+ return addHeapObject(ret);
1034
1085
  };
1035
1086
  imports.wbg.__wbg_new0_b0a0a38c201e6df5 = function() {
1036
1087
  const ret = new Date();
1037
- return ret;
1088
+ return addHeapObject(ret);
1038
1089
  };
1039
1090
  imports.wbg.__wbg_new_19c25a3f2fa63a02 = function() {
1040
1091
  const ret = new Object();
1041
- return ret;
1092
+ return addHeapObject(ret);
1042
1093
  };
1043
1094
  imports.wbg.__wbg_new_1f3a344cf3123716 = function() {
1044
1095
  const ret = new Array();
1045
- return ret;
1096
+ return addHeapObject(ret);
1046
1097
  };
1047
1098
  imports.wbg.__wbg_new_2e3c58a15f39f5f9 = function(arg0, arg1) {
1048
1099
  try {
@@ -1051,204 +1102,204 @@ function __wbg_get_imports() {
1051
1102
  const a = state0.a;
1052
1103
  state0.a = 0;
1053
1104
  try {
1054
- return __wbg_adapter_165(a, state0.b, arg0, arg1);
1105
+ return __wbg_adapter_107(a, state0.b, arg0, arg1);
1055
1106
  } finally {
1056
1107
  state0.a = a;
1057
1108
  }
1058
1109
  };
1059
1110
  const ret = new Promise(cb0);
1060
- return ret;
1111
+ return addHeapObject(ret);
1061
1112
  } finally {
1062
1113
  state0.a = state0.b = 0;
1063
1114
  }
1064
1115
  };
1065
1116
  imports.wbg.__wbg_new_2ff1f68f3676ea53 = function() {
1066
1117
  const ret = new Map();
1067
- return ret;
1118
+ return addHeapObject(ret);
1068
1119
  };
1069
1120
  imports.wbg.__wbg_new_638ebfaedbf32a5e = function(arg0) {
1070
- const ret = new Uint8Array(arg0);
1071
- return ret;
1121
+ const ret = new Uint8Array(getObject(arg0));
1122
+ return addHeapObject(ret);
1072
1123
  };
1073
1124
  imports.wbg.__wbg_new_66b9434b4e59b63e = function() { return handleError(function () {
1074
1125
  const ret = new AbortController();
1075
- return ret;
1126
+ return addHeapObject(ret);
1076
1127
  }, arguments) };
1077
1128
  imports.wbg.__wbg_new_f6e53210afea8e45 = function() { return handleError(function () {
1078
1129
  const ret = new Headers();
1079
- return ret;
1130
+ return addHeapObject(ret);
1080
1131
  }, arguments) };
1081
1132
  imports.wbg.__wbg_newfromslice_074c56947bd43469 = function(arg0, arg1) {
1082
1133
  const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
1083
- return ret;
1134
+ return addHeapObject(ret);
1084
1135
  };
1085
1136
  imports.wbg.__wbg_newnoargs_254190557c45b4ec = function(arg0, arg1) {
1086
1137
  const ret = new Function(getStringFromWasm0(arg0, arg1));
1087
- return ret;
1138
+ return addHeapObject(ret);
1088
1139
  };
1089
1140
  imports.wbg.__wbg_newwithlength_a167dcc7aaa3ba77 = function(arg0) {
1090
1141
  const ret = new Uint8Array(arg0 >>> 0);
1091
- return ret;
1142
+ return addHeapObject(ret);
1092
1143
  };
1093
1144
  imports.wbg.__wbg_newwithstrandinit_b5d168a29a3fd85f = function() { return handleError(function (arg0, arg1, arg2) {
1094
- const ret = new Request(getStringFromWasm0(arg0, arg1), arg2);
1095
- return ret;
1145
+ const ret = new Request(getStringFromWasm0(arg0, arg1), getObject(arg2));
1146
+ return addHeapObject(ret);
1096
1147
  }, arguments) };
1097
1148
  imports.wbg.__wbg_next_5b3530e612fde77d = function(arg0) {
1098
- const ret = arg0.next;
1099
- return ret;
1149
+ const ret = getObject(arg0).next;
1150
+ return addHeapObject(ret);
1100
1151
  };
1101
1152
  imports.wbg.__wbg_next_692e82279131b03c = function() { return handleError(function (arg0) {
1102
- const ret = arg0.next();
1103
- return ret;
1153
+ const ret = getObject(arg0).next();
1154
+ return addHeapObject(ret);
1104
1155
  }, arguments) };
1105
1156
  imports.wbg.__wbg_node_905d3e251edff8a2 = function(arg0) {
1106
- const ret = arg0.node;
1107
- return ret;
1157
+ const ret = getObject(arg0).node;
1158
+ return addHeapObject(ret);
1108
1159
  };
1109
1160
  imports.wbg.__wbg_now_886b39d7ec380719 = function(arg0) {
1110
- const ret = arg0.now();
1161
+ const ret = getObject(arg0).now();
1111
1162
  return ret;
1112
1163
  };
1113
1164
  imports.wbg.__wbg_process_dc0fbacc7c1c06f7 = function(arg0) {
1114
- const ret = arg0.process;
1115
- return ret;
1165
+ const ret = getObject(arg0).process;
1166
+ return addHeapObject(ret);
1116
1167
  };
1117
1168
  imports.wbg.__wbg_prototypesetcall_3d4a26c1ed734349 = function(arg0, arg1, arg2) {
1118
- Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
1169
+ Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
1119
1170
  };
1120
1171
  imports.wbg.__wbg_push_330b2eb93e4e1212 = function(arg0, arg1) {
1121
- const ret = arg0.push(arg1);
1172
+ const ret = getObject(arg0).push(getObject(arg1));
1122
1173
  return ret;
1123
1174
  };
1124
1175
  imports.wbg.__wbg_queueMicrotask_25d0739ac89e8c88 = function(arg0) {
1125
- queueMicrotask(arg0);
1176
+ queueMicrotask(getObject(arg0));
1126
1177
  };
1127
1178
  imports.wbg.__wbg_queueMicrotask_4488407636f5bf24 = function(arg0) {
1128
- const ret = arg0.queueMicrotask;
1129
- return ret;
1179
+ const ret = getObject(arg0).queueMicrotask;
1180
+ return addHeapObject(ret);
1130
1181
  };
1131
1182
  imports.wbg.__wbg_randomFillSync_ac0988aba3254290 = function() { return handleError(function (arg0, arg1) {
1132
- arg0.randomFillSync(arg1);
1183
+ getObject(arg0).randomFillSync(takeObject(arg1));
1133
1184
  }, arguments) };
1134
1185
  imports.wbg.__wbg_require_60cc747a6bc5215a = function() { return handleError(function () {
1135
1186
  const ret = module.require;
1136
- return ret;
1187
+ return addHeapObject(ret);
1137
1188
  }, arguments) };
1138
1189
  imports.wbg.__wbg_resolve_4055c623acdd6a1b = function(arg0) {
1139
- const ret = Promise.resolve(arg0);
1140
- return ret;
1190
+ const ret = Promise.resolve(getObject(arg0));
1191
+ return addHeapObject(ret);
1141
1192
  };
1142
1193
  imports.wbg.__wbg_setTimeout_4ec014681668a581 = function(arg0, arg1) {
1143
- const ret = setTimeout(arg0, arg1);
1144
- return ret;
1194
+ const ret = setTimeout(getObject(arg0), arg1);
1195
+ return addHeapObject(ret);
1145
1196
  };
1146
1197
  imports.wbg.__wbg_set_1353b2a5e96bc48c = function(arg0, arg1, arg2) {
1147
- arg0.set(getArrayU8FromWasm0(arg1, arg2));
1198
+ getObject(arg0).set(getArrayU8FromWasm0(arg1, arg2));
1148
1199
  };
1149
1200
  imports.wbg.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
1150
- arg0[arg1] = arg2;
1201
+ getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
1151
1202
  };
1152
1203
  imports.wbg.__wbg_set_453345bcda80b89a = function() { return handleError(function (arg0, arg1, arg2) {
1153
- const ret = Reflect.set(arg0, arg1, arg2);
1204
+ const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
1154
1205
  return ret;
1155
1206
  }, arguments) };
1156
1207
  imports.wbg.__wbg_set_90f6c0f7bd8c0415 = function(arg0, arg1, arg2) {
1157
- arg0[arg1 >>> 0] = arg2;
1208
+ getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
1158
1209
  };
1159
1210
  imports.wbg.__wbg_set_b7f1cf4fae26fe2a = function(arg0, arg1, arg2) {
1160
- const ret = arg0.set(arg1, arg2);
1161
- return ret;
1211
+ const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
1212
+ return addHeapObject(ret);
1162
1213
  };
1163
1214
  imports.wbg.__wbg_setbody_c8460bdf44147df8 = function(arg0, arg1) {
1164
- arg0.body = arg1;
1215
+ getObject(arg0).body = getObject(arg1);
1165
1216
  };
1166
1217
  imports.wbg.__wbg_setcache_90ca4ad8a8ad40d3 = function(arg0, arg1) {
1167
- arg0.cache = __wbindgen_enum_RequestCache[arg1];
1218
+ getObject(arg0).cache = __wbindgen_enum_RequestCache[arg1];
1168
1219
  };
1169
1220
  imports.wbg.__wbg_setcredentials_9cd60d632c9d5dfc = function(arg0, arg1) {
1170
- arg0.credentials = __wbindgen_enum_RequestCredentials[arg1];
1221
+ getObject(arg0).credentials = __wbindgen_enum_RequestCredentials[arg1];
1171
1222
  };
1172
1223
  imports.wbg.__wbg_setheaders_0052283e2f3503d1 = function(arg0, arg1) {
1173
- arg0.headers = arg1;
1224
+ getObject(arg0).headers = getObject(arg1);
1174
1225
  };
1175
1226
  imports.wbg.__wbg_setmethod_9b504d5b855b329c = function(arg0, arg1, arg2) {
1176
- arg0.method = getStringFromWasm0(arg1, arg2);
1227
+ getObject(arg0).method = getStringFromWasm0(arg1, arg2);
1177
1228
  };
1178
1229
  imports.wbg.__wbg_setmode_a23e1a2ad8b512f8 = function(arg0, arg1) {
1179
- arg0.mode = __wbindgen_enum_RequestMode[arg1];
1230
+ getObject(arg0).mode = __wbindgen_enum_RequestMode[arg1];
1180
1231
  };
1181
1232
  imports.wbg.__wbg_setsignal_8c45ad1247a74809 = function(arg0, arg1) {
1182
- arg0.signal = arg1;
1233
+ getObject(arg0).signal = getObject(arg1);
1183
1234
  };
1184
1235
  imports.wbg.__wbg_signal_da4d466ce86118b5 = function(arg0) {
1185
- const ret = arg0.signal;
1186
- return ret;
1236
+ const ret = getObject(arg0).signal;
1237
+ return addHeapObject(ret);
1187
1238
  };
1188
1239
  imports.wbg.__wbg_static_accessor_GLOBAL_8921f820c2ce3f12 = function() {
1189
1240
  const ret = typeof global === 'undefined' ? null : global;
1190
- return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
1241
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
1191
1242
  };
1192
1243
  imports.wbg.__wbg_static_accessor_GLOBAL_THIS_f0a4409105898184 = function() {
1193
1244
  const ret = typeof globalThis === 'undefined' ? null : globalThis;
1194
- return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
1245
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
1195
1246
  };
1196
1247
  imports.wbg.__wbg_static_accessor_SELF_995b214ae681ff99 = function() {
1197
1248
  const ret = typeof self === 'undefined' ? null : self;
1198
- return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
1249
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
1199
1250
  };
1200
1251
  imports.wbg.__wbg_static_accessor_WINDOW_cde3890479c675ea = function() {
1201
1252
  const ret = typeof window === 'undefined' ? null : window;
1202
- return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
1253
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
1203
1254
  };
1204
1255
  imports.wbg.__wbg_status_3fea3036088621d6 = function(arg0) {
1205
- const ret = arg0.status;
1256
+ const ret = getObject(arg0).status;
1206
1257
  return ret;
1207
1258
  };
1208
1259
  imports.wbg.__wbg_stringify_b98c93d0a190446a = function() { return handleError(function (arg0) {
1209
- const ret = JSON.stringify(arg0);
1210
- return ret;
1260
+ const ret = JSON.stringify(getObject(arg0));
1261
+ return addHeapObject(ret);
1211
1262
  }, arguments) };
1212
1263
  imports.wbg.__wbg_subarray_70fd07feefe14294 = function(arg0, arg1, arg2) {
1213
- const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
1214
- return ret;
1264
+ const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
1265
+ return addHeapObject(ret);
1215
1266
  };
1216
1267
  imports.wbg.__wbg_then_b33a773d723afa3e = function(arg0, arg1, arg2) {
1217
- const ret = arg0.then(arg1, arg2);
1218
- return ret;
1268
+ const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
1269
+ return addHeapObject(ret);
1219
1270
  };
1220
1271
  imports.wbg.__wbg_then_e22500defe16819f = function(arg0, arg1) {
1221
- const ret = arg0.then(arg1);
1222
- return ret;
1272
+ const ret = getObject(arg0).then(getObject(arg1));
1273
+ return addHeapObject(ret);
1223
1274
  };
1224
1275
  imports.wbg.__wbg_url_e5720dfacf77b05e = function(arg0, arg1) {
1225
- const ret = arg1.url;
1226
- const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1276
+ const ret = getObject(arg1).url;
1277
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
1227
1278
  const len1 = WASM_VECTOR_LEN;
1228
1279
  getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
1229
1280
  getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
1230
1281
  };
1231
1282
  imports.wbg.__wbg_value_dd9372230531eade = function(arg0) {
1232
- const ret = arg0.value;
1233
- return ret;
1283
+ const ret = getObject(arg0).value;
1284
+ return addHeapObject(ret);
1234
1285
  };
1235
1286
  imports.wbg.__wbg_versions_c01dfd4722a88165 = function(arg0) {
1236
- const ret = arg0.versions;
1237
- return ret;
1287
+ const ret = getObject(arg0).versions;
1288
+ return addHeapObject(ret);
1238
1289
  };
1239
1290
  imports.wbg.__wbg_wbindgenbigintgetasi64_ac743ece6ab9bba1 = function(arg0, arg1) {
1240
- const v = arg1;
1291
+ const v = getObject(arg1);
1241
1292
  const ret = typeof(v) === 'bigint' ? v : undefined;
1242
1293
  getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
1243
1294
  getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
1244
1295
  };
1245
1296
  imports.wbg.__wbg_wbindgenbooleanget_3fe6f642c7d97746 = function(arg0) {
1246
- const v = arg0;
1297
+ const v = getObject(arg0);
1247
1298
  const ret = typeof(v) === 'boolean' ? v : undefined;
1248
1299
  return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
1249
1300
  };
1250
1301
  imports.wbg.__wbg_wbindgencbdrop_eb10308566512b88 = function(arg0) {
1251
- const obj = arg0.original;
1302
+ const obj = getObject(arg0).original;
1252
1303
  if (obj.cnt-- == 1) {
1253
1304
  obj.a = 0;
1254
1305
  return true;
@@ -1257,59 +1308,59 @@ function __wbg_get_imports() {
1257
1308
  return ret;
1258
1309
  };
1259
1310
  imports.wbg.__wbg_wbindgendebugstring_99ef257a3ddda34d = function(arg0, arg1) {
1260
- const ret = debugString(arg1);
1261
- const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1311
+ const ret = debugString(getObject(arg1));
1312
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
1262
1313
  const len1 = WASM_VECTOR_LEN;
1263
1314
  getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
1264
1315
  getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
1265
1316
  };
1266
1317
  imports.wbg.__wbg_wbindgenin_d7a1ee10933d2d55 = function(arg0, arg1) {
1267
- const ret = arg0 in arg1;
1318
+ const ret = getObject(arg0) in getObject(arg1);
1268
1319
  return ret;
1269
1320
  };
1270
1321
  imports.wbg.__wbg_wbindgenisbigint_ecb90cc08a5a9154 = function(arg0) {
1271
- const ret = typeof(arg0) === 'bigint';
1322
+ const ret = typeof(getObject(arg0)) === 'bigint';
1272
1323
  return ret;
1273
1324
  };
1274
1325
  imports.wbg.__wbg_wbindgenisfunction_8cee7dce3725ae74 = function(arg0) {
1275
- const ret = typeof(arg0) === 'function';
1326
+ const ret = typeof(getObject(arg0)) === 'function';
1276
1327
  return ret;
1277
1328
  };
1278
1329
  imports.wbg.__wbg_wbindgenisnull_f3037694abe4d97a = function(arg0) {
1279
- const ret = arg0 === null;
1330
+ const ret = getObject(arg0) === null;
1280
1331
  return ret;
1281
1332
  };
1282
1333
  imports.wbg.__wbg_wbindgenisobject_307a53c6bd97fbf8 = function(arg0) {
1283
- const val = arg0;
1334
+ const val = getObject(arg0);
1284
1335
  const ret = typeof(val) === 'object' && val !== null;
1285
1336
  return ret;
1286
1337
  };
1287
1338
  imports.wbg.__wbg_wbindgenisstring_d4fa939789f003b0 = function(arg0) {
1288
- const ret = typeof(arg0) === 'string';
1339
+ const ret = typeof(getObject(arg0)) === 'string';
1289
1340
  return ret;
1290
1341
  };
1291
1342
  imports.wbg.__wbg_wbindgenisundefined_c4b71d073b92f3c5 = function(arg0) {
1292
- const ret = arg0 === undefined;
1343
+ const ret = getObject(arg0) === undefined;
1293
1344
  return ret;
1294
1345
  };
1295
1346
  imports.wbg.__wbg_wbindgenjsvaleq_e6f2ad59ccae1b58 = function(arg0, arg1) {
1296
- const ret = arg0 === arg1;
1347
+ const ret = getObject(arg0) === getObject(arg1);
1297
1348
  return ret;
1298
1349
  };
1299
1350
  imports.wbg.__wbg_wbindgenjsvallooseeq_9bec8c9be826bed1 = function(arg0, arg1) {
1300
- const ret = arg0 == arg1;
1351
+ const ret = getObject(arg0) == getObject(arg1);
1301
1352
  return ret;
1302
1353
  };
1303
1354
  imports.wbg.__wbg_wbindgennumberget_f74b4c7525ac05cb = function(arg0, arg1) {
1304
- const obj = arg1;
1355
+ const obj = getObject(arg1);
1305
1356
  const ret = typeof(obj) === 'number' ? obj : undefined;
1306
1357
  getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
1307
1358
  getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
1308
1359
  };
1309
1360
  imports.wbg.__wbg_wbindgenstringget_0f16a6ddddef376f = function(arg0, arg1) {
1310
- const obj = arg1;
1361
+ const obj = getObject(arg1);
1311
1362
  const ret = typeof(obj) === 'string' ? obj : undefined;
1312
- var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1363
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
1313
1364
  var len1 = WASM_VECTOR_LEN;
1314
1365
  getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
1315
1366
  getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
@@ -1317,55 +1368,52 @@ function __wbg_get_imports() {
1317
1368
  imports.wbg.__wbg_wbindgenthrow_451ec1a8469d7eb6 = function(arg0, arg1) {
1318
1369
  throw new Error(getStringFromWasm0(arg0, arg1));
1319
1370
  };
1371
+ imports.wbg.__wbindgen_cast_1eaafab1968e741d = function(arg0, arg1) {
1372
+ // Cast intrinsic for `Closure(Closure { dtor_idx: 639, function: Function { arguments: [], shim_idx: 640, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
1373
+ const ret = makeMutClosure(arg0, arg1, 639, __wbg_adapter_4);
1374
+ return addHeapObject(ret);
1375
+ };
1320
1376
  imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
1321
1377
  // Cast intrinsic for `Ref(String) -> Externref`.
1322
1378
  const ret = getStringFromWasm0(arg0, arg1);
1323
- return ret;
1379
+ return addHeapObject(ret);
1324
1380
  };
1325
1381
  imports.wbg.__wbindgen_cast_2ddd8a25ff58642a = function(arg0, arg1) {
1326
1382
  // Cast intrinsic for `I128 -> Externref`.
1327
1383
  const ret = (BigInt.asUintN(64, arg0) | (arg1 << BigInt(64)));
1328
- return ret;
1384
+ return addHeapObject(ret);
1329
1385
  };
1330
1386
  imports.wbg.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
1331
1387
  // Cast intrinsic for `U64 -> Externref`.
1332
1388
  const ret = BigInt.asUintN(64, arg0);
1333
- return ret;
1389
+ return addHeapObject(ret);
1334
1390
  };
1335
- imports.wbg.__wbindgen_cast_692d7ce9ed110604 = function(arg0, arg1) {
1336
- // Cast intrinsic for `Closure(Closure { dtor_idx: 4310, function: Function { arguments: [Externref], shim_idx: 4311, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
1337
- const ret = makeMutClosure(arg0, arg1, 4310, __wbg_adapter_6);
1338
- return ret;
1391
+ imports.wbg.__wbindgen_cast_67d14185bb436b4e = function(arg0, arg1) {
1392
+ // Cast intrinsic for `Closure(Closure { dtor_idx: 726, function: Function { arguments: [Externref], shim_idx: 727, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
1393
+ const ret = makeMutClosure(arg0, arg1, 726, __wbg_adapter_17);
1394
+ return addHeapObject(ret);
1339
1395
  };
1340
1396
  imports.wbg.__wbindgen_cast_9ae0607507abb057 = function(arg0) {
1341
1397
  // Cast intrinsic for `I64 -> Externref`.
1342
1398
  const ret = arg0;
1343
- return ret;
1344
- };
1345
- imports.wbg.__wbindgen_cast_bbc055d8f2ad2375 = function(arg0, arg1) {
1346
- // Cast intrinsic for `Closure(Closure { dtor_idx: 4276, function: Function { arguments: [], shim_idx: 4277, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
1347
- const ret = makeMutClosure(arg0, arg1, 4276, __wbg_adapter_21);
1348
- return ret;
1399
+ return addHeapObject(ret);
1349
1400
  };
1350
1401
  imports.wbg.__wbindgen_cast_cb9088102bce6b30 = function(arg0, arg1) {
1351
1402
  // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
1352
1403
  const ret = getArrayU8FromWasm0(arg0, arg1);
1353
- return ret;
1404
+ return addHeapObject(ret);
1354
1405
  };
1355
1406
  imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
1356
1407
  // Cast intrinsic for `F64 -> Externref`.
1357
1408
  const ret = arg0;
1358
- return ret;
1409
+ return addHeapObject(ret);
1410
+ };
1411
+ imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
1412
+ const ret = getObject(arg0);
1413
+ return addHeapObject(ret);
1359
1414
  };
1360
- imports.wbg.__wbindgen_init_externref_table = function() {
1361
- const table = wasm.__wbindgen_export_4;
1362
- const offset = table.grow(4);
1363
- table.set(0, undefined);
1364
- table.set(offset + 0, undefined);
1365
- table.set(offset + 1, null);
1366
- table.set(offset + 2, true);
1367
- table.set(offset + 3, false);
1368
- ;
1415
+ imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
1416
+ takeObject(arg0);
1369
1417
  };
1370
1418
 
1371
1419
  return imports;
@@ -1382,7 +1430,7 @@ function __wbg_finalize_init(instance, module) {
1382
1430
  cachedUint8ArrayMemory0 = null;
1383
1431
 
1384
1432
 
1385
- wasm.__wbindgen_start();
1433
+
1386
1434
  return wasm;
1387
1435
  }
1388
1436