@learncard/didkit-plugin 1.4.6 → 1.4.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,17 +1,8 @@
1
1
  let wasm;
2
2
 
3
- const cachedTextDecoder =
4
- typeof TextDecoder !== 'undefined'
5
- ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true })
6
- : {
7
- decode: () => {
8
- throw Error('TextDecoder not available');
9
- },
10
- };
3
+ const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } });
11
4
 
12
- if (typeof TextDecoder !== 'undefined') {
13
- cachedTextDecoder.decode();
14
- }
5
+ if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
15
6
 
16
7
  let cachedUint8Memory0 = null;
17
8
 
@@ -42,9 +33,7 @@ function addHeapObject(obj) {
42
33
  return idx;
43
34
  }
44
35
 
45
- function getObject(idx) {
46
- return heap[idx];
47
- }
36
+ function getObject(idx) { return heap[idx]; }
48
37
 
49
38
  function dropObject(idx) {
50
39
  if (idx < 132) return;
@@ -60,36 +49,27 @@ function takeObject(idx) {
60
49
 
61
50
  let WASM_VECTOR_LEN = 0;
62
51
 
63
- const cachedTextEncoder =
64
- typeof TextEncoder !== 'undefined'
65
- ? new TextEncoder('utf-8')
66
- : {
67
- encode: () => {
68
- throw Error('TextEncoder not available');
69
- },
70
- };
52
+ const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } });
71
53
 
72
- const encodeString =
73
- typeof cachedTextEncoder.encodeInto === 'function'
74
- ? function (arg, view) {
75
- return cachedTextEncoder.encodeInto(arg, view);
76
- }
77
- : function (arg, view) {
78
- const buf = cachedTextEncoder.encode(arg);
79
- view.set(buf);
80
- return {
81
- read: arg.length,
82
- written: buf.length,
83
- };
54
+ const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
55
+ ? function (arg, view) {
56
+ return cachedTextEncoder.encodeInto(arg, view);
57
+ }
58
+ : function (arg, view) {
59
+ const buf = cachedTextEncoder.encode(arg);
60
+ view.set(buf);
61
+ return {
62
+ read: arg.length,
63
+ written: buf.length
84
64
  };
65
+ });
85
66
 
86
67
  function passStringToWasm0(arg, malloc, realloc) {
68
+
87
69
  if (realloc === undefined) {
88
70
  const buf = cachedTextEncoder.encode(arg);
89
71
  const ptr = malloc(buf.length, 1) >>> 0;
90
- getUint8Memory0()
91
- .subarray(ptr, ptr + buf.length)
92
- .set(buf);
72
+ getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
93
73
  WASM_VECTOR_LEN = buf.length;
94
74
  return ptr;
95
75
  }
@@ -103,7 +83,7 @@ function passStringToWasm0(arg, malloc, realloc) {
103
83
 
104
84
  for (; offset < len; offset++) {
105
85
  const code = arg.charCodeAt(offset);
106
- if (code > 0x7f) break;
86
+ if (code > 0x7F) break;
107
87
  mem[ptr + offset] = code;
108
88
  }
109
89
 
@@ -111,7 +91,7 @@ function passStringToWasm0(arg, malloc, realloc) {
111
91
  if (offset !== 0) {
112
92
  arg = arg.slice(offset);
113
93
  }
114
- ptr = realloc(ptr, len, (len = offset + arg.length * 3), 1) >>> 0;
94
+ ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
115
95
  const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
116
96
  const ret = encodeString(arg, view);
117
97
 
@@ -214,6 +194,7 @@ function makeMutClosure(arg0, arg1, dtor, f) {
214
194
  } finally {
215
195
  if (--state.cnt === 0) {
216
196
  wasm.__wbindgen_export_2.get(state.dtor)(a, state.b);
197
+
217
198
  } else {
218
199
  state.a = a;
219
200
  }
@@ -224,16 +205,12 @@ function makeMutClosure(arg0, arg1, dtor, f) {
224
205
  return real;
225
206
  }
226
207
  function __wbg_adapter_26(arg0, arg1, arg2) {
227
- wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hae32635367f5810e(
228
- arg0,
229
- arg1,
230
- addHeapObject(arg2)
231
- );
208
+ wasm.wasm_bindgen__convert__closures__invoke1_mut__h45806fd75c456525(arg0, arg1, addHeapObject(arg2));
232
209
  }
233
210
 
234
211
  /**
235
- * @returns {string}
236
- */
212
+ * @returns {string}
213
+ */
237
214
  export function getVersion() {
238
215
  let deferred1_0;
239
216
  let deferred1_1;
@@ -252,10 +229,10 @@ export function getVersion() {
252
229
  }
253
230
 
254
231
  /**
255
- * @param {string} did
256
- * @param {string} input_metadata
257
- * @returns {Promise<any>}
258
- */
232
+ * @param {string} did
233
+ * @param {string} input_metadata
234
+ * @returns {Promise<any>}
235
+ */
259
236
  export function didResolver(did, input_metadata) {
260
237
  const ptr0 = passStringToWasm0(did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
261
238
  const len0 = WASM_VECTOR_LEN;
@@ -266,10 +243,10 @@ export function didResolver(did, input_metadata) {
266
243
  }
267
244
 
268
245
  /**
269
- * @param {string} did
270
- * @param {string} input_metadata
271
- * @returns {Promise<any>}
272
- */
246
+ * @param {string} did
247
+ * @param {string} input_metadata
248
+ * @returns {Promise<any>}
249
+ */
273
250
  export function resolveDID(did, input_metadata) {
274
251
  const ptr0 = passStringToWasm0(did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
275
252
  const len0 = WASM_VECTOR_LEN;
@@ -280,8 +257,8 @@ export function resolveDID(did, input_metadata) {
280
257
  }
281
258
 
282
259
  /**
283
- * @returns {string}
284
- */
260
+ * @returns {string}
261
+ */
285
262
  export function generateEd25519Key() {
286
263
  let deferred2_0;
287
264
  let deferred2_1;
@@ -295,8 +272,7 @@ export function generateEd25519Key() {
295
272
  var ptr1 = r0;
296
273
  var len1 = r1;
297
274
  if (r3) {
298
- ptr1 = 0;
299
- len1 = 0;
275
+ ptr1 = 0; len1 = 0;
300
276
  throw takeObject(r2);
301
277
  }
302
278
  deferred2_0 = ptr1;
@@ -315,9 +291,9 @@ function passArray8ToWasm0(arg, malloc) {
315
291
  return ptr;
316
292
  }
317
293
  /**
318
- * @param {Uint8Array} bytes
319
- * @returns {string}
320
- */
294
+ * @param {Uint8Array} bytes
295
+ * @returns {string}
296
+ */
321
297
  export function generateEd25519KeyFromBytes(bytes) {
322
298
  let deferred3_0;
323
299
  let deferred3_1;
@@ -333,8 +309,7 @@ export function generateEd25519KeyFromBytes(bytes) {
333
309
  var ptr2 = r0;
334
310
  var len2 = r1;
335
311
  if (r3) {
336
- ptr2 = 0;
337
- len2 = 0;
312
+ ptr2 = 0; len2 = 0;
338
313
  throw takeObject(r2);
339
314
  }
340
315
  deferred3_0 = ptr2;
@@ -347,8 +322,8 @@ export function generateEd25519KeyFromBytes(bytes) {
347
322
  }
348
323
 
349
324
  /**
350
- * @returns {string}
351
- */
325
+ * @returns {string}
326
+ */
352
327
  export function generateSecp256k1Key() {
353
328
  let deferred2_0;
354
329
  let deferred2_1;
@@ -362,8 +337,7 @@ export function generateSecp256k1Key() {
362
337
  var ptr1 = r0;
363
338
  var len1 = r1;
364
339
  if (r3) {
365
- ptr1 = 0;
366
- len1 = 0;
340
+ ptr1 = 0; len1 = 0;
367
341
  throw takeObject(r2);
368
342
  }
369
343
  deferred2_0 = ptr1;
@@ -376,9 +350,9 @@ export function generateSecp256k1Key() {
376
350
  }
377
351
 
378
352
  /**
379
- * @param {Uint8Array} bytes
380
- * @returns {string}
381
- */
353
+ * @param {Uint8Array} bytes
354
+ * @returns {string}
355
+ */
382
356
  export function generateSecp256k1KeyFromBytes(bytes) {
383
357
  let deferred3_0;
384
358
  let deferred3_1;
@@ -394,8 +368,7 @@ export function generateSecp256k1KeyFromBytes(bytes) {
394
368
  var ptr2 = r0;
395
369
  var len2 = r1;
396
370
  if (r3) {
397
- ptr2 = 0;
398
- len2 = 0;
371
+ ptr2 = 0; len2 = 0;
399
372
  throw takeObject(r2);
400
373
  }
401
374
  deferred3_0 = ptr2;
@@ -408,20 +381,16 @@ export function generateSecp256k1KeyFromBytes(bytes) {
408
381
  }
409
382
 
410
383
  /**
411
- * @param {string} method_pattern
412
- * @param {string} jwk
413
- * @returns {string}
414
- */
384
+ * @param {string} method_pattern
385
+ * @param {string} jwk
386
+ * @returns {string}
387
+ */
415
388
  export function keyToDID(method_pattern, jwk) {
416
389
  let deferred4_0;
417
390
  let deferred4_1;
418
391
  try {
419
392
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
420
- const ptr0 = passStringToWasm0(
421
- method_pattern,
422
- wasm.__wbindgen_malloc,
423
- wasm.__wbindgen_realloc
424
- );
393
+ const ptr0 = passStringToWasm0(method_pattern, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
425
394
  const len0 = WASM_VECTOR_LEN;
426
395
  const ptr1 = passStringToWasm0(jwk, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
427
396
  const len1 = WASM_VECTOR_LEN;
@@ -433,8 +402,7 @@ export function keyToDID(method_pattern, jwk) {
433
402
  var ptr3 = r0;
434
403
  var len3 = r1;
435
404
  if (r3) {
436
- ptr3 = 0;
437
- len3 = 0;
405
+ ptr3 = 0; len3 = 0;
438
406
  throw takeObject(r2);
439
407
  }
440
408
  deferred4_0 = ptr3;
@@ -447,10 +415,10 @@ export function keyToDID(method_pattern, jwk) {
447
415
  }
448
416
 
449
417
  /**
450
- * @param {string} method_pattern
451
- * @param {string} jwk
452
- * @returns {Promise<any>}
453
- */
418
+ * @param {string} method_pattern
419
+ * @param {string} jwk
420
+ * @returns {Promise<any>}
421
+ */
454
422
  export function keyToVerificationMethod(method_pattern, jwk) {
455
423
  const ptr0 = passStringToWasm0(method_pattern, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
456
424
  const len0 = WASM_VECTOR_LEN;
@@ -461,9 +429,9 @@ export function keyToVerificationMethod(method_pattern, jwk) {
461
429
  }
462
430
 
463
431
  /**
464
- * @param {string} did
465
- * @returns {Promise<any>}
466
- */
432
+ * @param {string} did
433
+ * @returns {Promise<any>}
434
+ */
467
435
  export function didToVerificationMethod(did) {
468
436
  const ptr0 = passStringToWasm0(did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
469
437
  const len0 = WASM_VECTOR_LEN;
@@ -472,12 +440,12 @@ export function didToVerificationMethod(did) {
472
440
  }
473
441
 
474
442
  /**
475
- * @param {string} credential
476
- * @param {string} proof_options
477
- * @param {string} key
478
- * @param {string} context_map
479
- * @returns {Promise<any>}
480
- */
443
+ * @param {string} credential
444
+ * @param {string} proof_options
445
+ * @param {string} key
446
+ * @param {string} context_map
447
+ * @returns {Promise<any>}
448
+ */
481
449
  export function issueCredential(credential, proof_options, key, context_map) {
482
450
  const ptr0 = passStringToWasm0(credential, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
483
451
  const len0 = WASM_VECTOR_LEN;
@@ -492,19 +460,15 @@ export function issueCredential(credential, proof_options, key, context_map) {
492
460
  }
493
461
 
494
462
  /**
495
- * @param {string} credential
496
- * @param {string} linked_data_proof_options
497
- * @param {string} public_key
498
- * @returns {Promise<any>}
499
- */
463
+ * @param {string} credential
464
+ * @param {string} linked_data_proof_options
465
+ * @param {string} public_key
466
+ * @returns {Promise<any>}
467
+ */
500
468
  export function prepareIssueCredential(credential, linked_data_proof_options, public_key) {
501
469
  const ptr0 = passStringToWasm0(credential, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
502
470
  const len0 = WASM_VECTOR_LEN;
503
- const ptr1 = passStringToWasm0(
504
- linked_data_proof_options,
505
- wasm.__wbindgen_malloc,
506
- wasm.__wbindgen_realloc
507
- );
471
+ const ptr1 = passStringToWasm0(linked_data_proof_options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
508
472
  const len1 = WASM_VECTOR_LEN;
509
473
  const ptr2 = passStringToWasm0(public_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
510
474
  const len2 = WASM_VECTOR_LEN;
@@ -513,11 +477,11 @@ export function prepareIssueCredential(credential, linked_data_proof_options, pu
513
477
  }
514
478
 
515
479
  /**
516
- * @param {string} credential
517
- * @param {string} preparation
518
- * @param {string} signature
519
- * @returns {Promise<any>}
520
- */
480
+ * @param {string} credential
481
+ * @param {string} preparation
482
+ * @param {string} signature
483
+ * @returns {Promise<any>}
484
+ */
521
485
  export function completeIssueCredential(credential, preparation, signature) {
522
486
  const ptr0 = passStringToWasm0(credential, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
523
487
  const len0 = WASM_VECTOR_LEN;
@@ -530,11 +494,11 @@ export function completeIssueCredential(credential, preparation, signature) {
530
494
  }
531
495
 
532
496
  /**
533
- * @param {string} vc
534
- * @param {string} proof_options
535
- * @param {string} context_map
536
- * @returns {Promise<any>}
537
- */
497
+ * @param {string} vc
498
+ * @param {string} proof_options
499
+ * @param {string} context_map
500
+ * @returns {Promise<any>}
501
+ */
538
502
  export function verifyCredential(vc, proof_options, context_map) {
539
503
  const ptr0 = passStringToWasm0(vc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
540
504
  const len0 = WASM_VECTOR_LEN;
@@ -547,12 +511,12 @@ export function verifyCredential(vc, proof_options, context_map) {
547
511
  }
548
512
 
549
513
  /**
550
- * @param {string} presentation
551
- * @param {string} proof_options
552
- * @param {string} key
553
- * @param {string} context_map
554
- * @returns {Promise<any>}
555
- */
514
+ * @param {string} presentation
515
+ * @param {string} proof_options
516
+ * @param {string} key
517
+ * @param {string} context_map
518
+ * @returns {Promise<any>}
519
+ */
556
520
  export function issuePresentation(presentation, proof_options, key, context_map) {
557
521
  const ptr0 = passStringToWasm0(presentation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
558
522
  const len0 = WASM_VECTOR_LEN;
@@ -567,19 +531,15 @@ export function issuePresentation(presentation, proof_options, key, context_map)
567
531
  }
568
532
 
569
533
  /**
570
- * @param {string} presentation
571
- * @param {string} linked_data_proof_options
572
- * @param {string} public_key
573
- * @returns {Promise<any>}
574
- */
534
+ * @param {string} presentation
535
+ * @param {string} linked_data_proof_options
536
+ * @param {string} public_key
537
+ * @returns {Promise<any>}
538
+ */
575
539
  export function prepareIssuePresentation(presentation, linked_data_proof_options, public_key) {
576
540
  const ptr0 = passStringToWasm0(presentation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
577
541
  const len0 = WASM_VECTOR_LEN;
578
- const ptr1 = passStringToWasm0(
579
- linked_data_proof_options,
580
- wasm.__wbindgen_malloc,
581
- wasm.__wbindgen_realloc
582
- );
542
+ const ptr1 = passStringToWasm0(linked_data_proof_options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
583
543
  const len1 = WASM_VECTOR_LEN;
584
544
  const ptr2 = passStringToWasm0(public_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
585
545
  const len2 = WASM_VECTOR_LEN;
@@ -588,11 +548,11 @@ export function prepareIssuePresentation(presentation, linked_data_proof_options
588
548
  }
589
549
 
590
550
  /**
591
- * @param {string} presentation
592
- * @param {string} preparation
593
- * @param {string} signature
594
- * @returns {Promise<any>}
595
- */
551
+ * @param {string} presentation
552
+ * @param {string} preparation
553
+ * @param {string} signature
554
+ * @returns {Promise<any>}
555
+ */
596
556
  export function completeIssuePresentation(presentation, preparation, signature) {
597
557
  const ptr0 = passStringToWasm0(presentation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
598
558
  const len0 = WASM_VECTOR_LEN;
@@ -605,11 +565,11 @@ export function completeIssuePresentation(presentation, preparation, signature)
605
565
  }
606
566
 
607
567
  /**
608
- * @param {string} vp
609
- * @param {string} proof_options
610
- * @param {string} context_map
611
- * @returns {Promise<any>}
612
- */
568
+ * @param {string} vp
569
+ * @param {string} proof_options
570
+ * @param {string} context_map
571
+ * @returns {Promise<any>}
572
+ */
613
573
  export function verifyPresentation(vp, proof_options, context_map) {
614
574
  const ptr0 = passStringToWasm0(vp, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
615
575
  const len0 = WASM_VECTOR_LEN;
@@ -622,20 +582,16 @@ export function verifyPresentation(vp, proof_options, context_map) {
622
582
  }
623
583
 
624
584
  /**
625
- * @param {string} holder
626
- * @param {string} linked_data_proof_options
627
- * @param {string} key
628
- * @param {string} context_map
629
- * @returns {Promise<any>}
630
- */
585
+ * @param {string} holder
586
+ * @param {string} linked_data_proof_options
587
+ * @param {string} key
588
+ * @param {string} context_map
589
+ * @returns {Promise<any>}
590
+ */
631
591
  export function DIDAuth(holder, linked_data_proof_options, key, context_map) {
632
592
  const ptr0 = passStringToWasm0(holder, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
633
593
  const len0 = WASM_VECTOR_LEN;
634
- const ptr1 = passStringToWasm0(
635
- linked_data_proof_options,
636
- wasm.__wbindgen_malloc,
637
- wasm.__wbindgen_realloc
638
- );
594
+ const ptr1 = passStringToWasm0(linked_data_proof_options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
639
595
  const len1 = WASM_VECTOR_LEN;
640
596
  const ptr2 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
641
597
  const len2 = WASM_VECTOR_LEN;
@@ -646,9 +602,9 @@ export function DIDAuth(holder, linked_data_proof_options, key, context_map) {
646
602
  }
647
603
 
648
604
  /**
649
- * @param {string} tz
650
- * @returns {Promise<any>}
651
- */
605
+ * @param {string} tz
606
+ * @returns {Promise<any>}
607
+ */
652
608
  export function JWKFromTezos(tz) {
653
609
  const ptr0 = passStringToWasm0(tz, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
654
610
  const len0 = WASM_VECTOR_LEN;
@@ -657,20 +613,16 @@ export function JWKFromTezos(tz) {
657
613
  }
658
614
 
659
615
  /**
660
- * @param {string} capability
661
- * @param {string} linked_data_proof_options
662
- * @param {string} parents
663
- * @param {string} key
664
- * @returns {Promise<any>}
665
- */
616
+ * @param {string} capability
617
+ * @param {string} linked_data_proof_options
618
+ * @param {string} parents
619
+ * @param {string} key
620
+ * @returns {Promise<any>}
621
+ */
666
622
  export function delegateCapability(capability, linked_data_proof_options, parents, key) {
667
623
  const ptr0 = passStringToWasm0(capability, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
668
624
  const len0 = WASM_VECTOR_LEN;
669
- const ptr1 = passStringToWasm0(
670
- linked_data_proof_options,
671
- wasm.__wbindgen_malloc,
672
- wasm.__wbindgen_realloc
673
- );
625
+ const ptr1 = passStringToWasm0(linked_data_proof_options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
674
626
  const len1 = WASM_VECTOR_LEN;
675
627
  const ptr2 = passStringToWasm0(parents, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
676
628
  const len2 = WASM_VECTOR_LEN;
@@ -681,25 +633,16 @@ export function delegateCapability(capability, linked_data_proof_options, parent
681
633
  }
682
634
 
683
635
  /**
684
- * @param {string} capability
685
- * @param {string} linked_data_proof_options
686
- * @param {string} parents
687
- * @param {string} public_key
688
- * @returns {Promise<any>}
689
- */
690
- export function prepareDelegateCapability(
691
- capability,
692
- linked_data_proof_options,
693
- parents,
694
- public_key
695
- ) {
636
+ * @param {string} capability
637
+ * @param {string} linked_data_proof_options
638
+ * @param {string} parents
639
+ * @param {string} public_key
640
+ * @returns {Promise<any>}
641
+ */
642
+ export function prepareDelegateCapability(capability, linked_data_proof_options, parents, public_key) {
696
643
  const ptr0 = passStringToWasm0(capability, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
697
644
  const len0 = WASM_VECTOR_LEN;
698
- const ptr1 = passStringToWasm0(
699
- linked_data_proof_options,
700
- wasm.__wbindgen_malloc,
701
- wasm.__wbindgen_realloc
702
- );
645
+ const ptr1 = passStringToWasm0(linked_data_proof_options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
703
646
  const len1 = WASM_VECTOR_LEN;
704
647
  const ptr2 = passStringToWasm0(parents, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
705
648
  const len2 = WASM_VECTOR_LEN;
@@ -710,11 +653,11 @@ export function prepareDelegateCapability(
710
653
  }
711
654
 
712
655
  /**
713
- * @param {string} capability
714
- * @param {string} preparation
715
- * @param {string} signature
716
- * @returns {Promise<any>}
717
- */
656
+ * @param {string} capability
657
+ * @param {string} preparation
658
+ * @param {string} signature
659
+ * @returns {Promise<any>}
660
+ */
718
661
  export function completeDelegateCapability(capability, preparation, signature) {
719
662
  const ptr0 = passStringToWasm0(capability, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
720
663
  const len0 = WASM_VECTOR_LEN;
@@ -727,9 +670,9 @@ export function completeDelegateCapability(capability, preparation, signature) {
727
670
  }
728
671
 
729
672
  /**
730
- * @param {string} delegation
731
- * @returns {Promise<any>}
732
- */
673
+ * @param {string} delegation
674
+ * @returns {Promise<any>}
675
+ */
733
676
  export function verifyDelegation(delegation) {
734
677
  const ptr0 = passStringToWasm0(delegation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
735
678
  const len0 = WASM_VECTOR_LEN;
@@ -738,22 +681,18 @@ export function verifyDelegation(delegation) {
738
681
  }
739
682
 
740
683
  /**
741
- * @param {string} invocation
742
- * @param {string} target_id
743
- * @param {string} linked_data_proof_options
744
- * @param {string} key
745
- * @returns {Promise<any>}
746
- */
684
+ * @param {string} invocation
685
+ * @param {string} target_id
686
+ * @param {string} linked_data_proof_options
687
+ * @param {string} key
688
+ * @returns {Promise<any>}
689
+ */
747
690
  export function invokeCapability(invocation, target_id, linked_data_proof_options, key) {
748
691
  const ptr0 = passStringToWasm0(invocation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
749
692
  const len0 = WASM_VECTOR_LEN;
750
693
  const ptr1 = passStringToWasm0(target_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
751
694
  const len1 = WASM_VECTOR_LEN;
752
- const ptr2 = passStringToWasm0(
753
- linked_data_proof_options,
754
- wasm.__wbindgen_malloc,
755
- wasm.__wbindgen_realloc
756
- );
695
+ const ptr2 = passStringToWasm0(linked_data_proof_options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
757
696
  const len2 = WASM_VECTOR_LEN;
758
697
  const ptr3 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
759
698
  const len3 = WASM_VECTOR_LEN;
@@ -762,27 +701,18 @@ export function invokeCapability(invocation, target_id, linked_data_proof_option
762
701
  }
763
702
 
764
703
  /**
765
- * @param {string} invocation
766
- * @param {string} target_id
767
- * @param {string} linked_data_proof_options
768
- * @param {string} public_key
769
- * @returns {Promise<any>}
770
- */
771
- export function prepareInvokeCapability(
772
- invocation,
773
- target_id,
774
- linked_data_proof_options,
775
- public_key
776
- ) {
704
+ * @param {string} invocation
705
+ * @param {string} target_id
706
+ * @param {string} linked_data_proof_options
707
+ * @param {string} public_key
708
+ * @returns {Promise<any>}
709
+ */
710
+ export function prepareInvokeCapability(invocation, target_id, linked_data_proof_options, public_key) {
777
711
  const ptr0 = passStringToWasm0(invocation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
778
712
  const len0 = WASM_VECTOR_LEN;
779
713
  const ptr1 = passStringToWasm0(target_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
780
714
  const len1 = WASM_VECTOR_LEN;
781
- const ptr2 = passStringToWasm0(
782
- linked_data_proof_options,
783
- wasm.__wbindgen_malloc,
784
- wasm.__wbindgen_realloc
785
- );
715
+ const ptr2 = passStringToWasm0(linked_data_proof_options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
786
716
  const len2 = WASM_VECTOR_LEN;
787
717
  const ptr3 = passStringToWasm0(public_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
788
718
  const len3 = WASM_VECTOR_LEN;
@@ -791,11 +721,11 @@ export function prepareInvokeCapability(
791
721
  }
792
722
 
793
723
  /**
794
- * @param {string} invocation
795
- * @param {string} preparation
796
- * @param {string} signature
797
- * @returns {Promise<any>}
798
- */
724
+ * @param {string} invocation
725
+ * @param {string} preparation
726
+ * @param {string} signature
727
+ * @returns {Promise<any>}
728
+ */
799
729
  export function completeInvokeCapability(invocation, preparation, signature) {
800
730
  const ptr0 = passStringToWasm0(invocation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
801
731
  const len0 = WASM_VECTOR_LEN;
@@ -808,9 +738,9 @@ export function completeInvokeCapability(invocation, preparation, signature) {
808
738
  }
809
739
 
810
740
  /**
811
- * @param {string} invocation
812
- * @returns {Promise<any>}
813
- */
741
+ * @param {string} invocation
742
+ * @returns {Promise<any>}
743
+ */
814
744
  export function verifyInvocationSignature(invocation) {
815
745
  const ptr0 = passStringToWasm0(invocation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
816
746
  const len0 = WASM_VECTOR_LEN;
@@ -819,10 +749,10 @@ export function verifyInvocationSignature(invocation) {
819
749
  }
820
750
 
821
751
  /**
822
- * @param {string} invocation
823
- * @param {string} delegation
824
- * @returns {Promise<any>}
825
- */
752
+ * @param {string} invocation
753
+ * @param {string} delegation
754
+ * @returns {Promise<any>}
755
+ */
826
756
  export function verifyInvocation(invocation, delegation) {
827
757
  const ptr0 = passStringToWasm0(invocation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
828
758
  const len0 = WASM_VECTOR_LEN;
@@ -833,9 +763,9 @@ export function verifyInvocation(invocation, delegation) {
833
763
  }
834
764
 
835
765
  /**
836
- * @param {string} url
837
- * @returns {Promise<any>}
838
- */
766
+ * @param {string} url
767
+ * @returns {Promise<any>}
768
+ */
839
769
  export function contextLoader(url) {
840
770
  const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
841
771
  const len0 = WASM_VECTOR_LEN;
@@ -856,12 +786,7 @@ function getArrayU8FromWasm0(ptr, len) {
856
786
  return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
857
787
  }
858
788
  function __wbg_adapter_139(arg0, arg1, arg2, arg3) {
859
- wasm.wasm_bindgen__convert__closures__invoke2_mut__h6e6bc1a8c3634b3b(
860
- arg0,
861
- arg1,
862
- addHeapObject(arg2),
863
- addHeapObject(arg3)
864
- );
789
+ wasm.wasm_bindgen__convert__closures__invoke2_mut__h46bbe3de5dd3bce3(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
865
790
  }
866
791
 
867
792
  async function __wbg_load(module, imports) {
@@ -869,12 +794,11 @@ async function __wbg_load(module, imports) {
869
794
  if (typeof WebAssembly.instantiateStreaming === 'function') {
870
795
  try {
871
796
  return await WebAssembly.instantiateStreaming(module, imports);
797
+
872
798
  } catch (e) {
873
799
  if (module.headers.get('Content-Type') != 'application/wasm') {
874
- console.warn(
875
- '`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n',
876
- e
877
- );
800
+ console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
801
+
878
802
  } else {
879
803
  throw e;
880
804
  }
@@ -883,11 +807,13 @@ async function __wbg_load(module, imports) {
883
807
 
884
808
  const bytes = await module.arrayBuffer();
885
809
  return await WebAssembly.instantiate(bytes, imports);
810
+
886
811
  } else {
887
812
  const instance = await WebAssembly.instantiate(module, imports);
888
813
 
889
814
  if (instance instanceof WebAssembly.Instance) {
890
815
  return { instance, module };
816
+
891
817
  } else {
892
818
  return instance;
893
819
  }
@@ -913,14 +839,14 @@ function __wbg_get_imports() {
913
839
  const ret = false;
914
840
  return ret;
915
841
  };
916
- imports.wbg.__wbg_fetch_57429b87be3dcc33 = function (arg0) {
917
- const ret = fetch(getObject(arg0));
918
- return addHeapObject(ret);
919
- };
920
842
  imports.wbg.__wbindgen_object_clone_ref = function (arg0) {
921
843
  const ret = getObject(arg0);
922
844
  return addHeapObject(ret);
923
845
  };
846
+ imports.wbg.__wbg_fetch_57429b87be3dcc33 = function (arg0) {
847
+ const ret = fetch(getObject(arg0));
848
+ return addHeapObject(ret);
849
+ };
924
850
  imports.wbg.__wbg_fetch_8eaf01857a5bb21f = function (arg0, arg1) {
925
851
  const ret = getObject(arg0).fetch(getObject(arg1));
926
852
  return addHeapObject(ret);
@@ -954,27 +880,28 @@ function __wbg_get_imports() {
954
880
  return handleError(function (arg0) {
955
881
  const ret = getObject(arg0).arrayBuffer();
956
882
  return addHeapObject(ret);
957
- }, arguments);
883
+ }, arguments)
884
+ };
885
+ imports.wbg.__wbg_newwithstrandinit_cad5cd6038c7ff5d = function () {
886
+ return handleError(function (arg0, arg1, arg2) {
887
+ const ret = new Request(getStringFromWasm0(arg0, arg1), getObject(arg2));
888
+ return addHeapObject(ret);
889
+ }, arguments)
958
890
  };
959
891
  imports.wbg.__wbg_now_0cfdc90c97d0c24b = function (arg0) {
960
892
  const ret = getObject(arg0).now();
961
893
  return ret;
962
894
  };
963
- imports.wbg.__wbg_newwithstrandinit_cad5cd6038c7ff5d = function () {
964
- return handleError(function (arg0, arg1, arg2) {
965
- const ret = new Request(getStringFromWasm0(arg0, arg1), getObject(arg2));
895
+ imports.wbg.__wbg_new_1eead62f64ca15ce = function () {
896
+ return handleError(function () {
897
+ const ret = new Headers();
966
898
  return addHeapObject(ret);
967
- }, arguments);
899
+ }, arguments)
968
900
  };
969
- imports.wbg.__wbindgen_string_get = function (arg0, arg1) {
970
- const obj = getObject(arg1);
971
- const ret = typeof obj === 'string' ? obj : undefined;
972
- var ptr1 = isLikeNone(ret)
973
- ? 0
974
- : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
975
- var len1 = WASM_VECTOR_LEN;
976
- getInt32Memory0()[arg0 / 4 + 1] = len1;
977
- getInt32Memory0()[arg0 / 4 + 0] = ptr1;
901
+ imports.wbg.__wbg_append_fda9e3432e3e88da = function () {
902
+ return handleError(function (arg0, arg1, arg2, arg3, arg4) {
903
+ getObject(arg0).append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
904
+ }, arguments)
978
905
  };
979
906
  imports.wbg.__wbg_signal_4bd18fb489af2d4c = function (arg0) {
980
907
  const ret = getObject(arg0).signal;
@@ -984,27 +911,24 @@ function __wbg_get_imports() {
984
911
  return handleError(function () {
985
912
  const ret = new AbortController();
986
913
  return addHeapObject(ret);
987
- }, arguments);
914
+ }, arguments)
988
915
  };
989
916
  imports.wbg.__wbg_abort_654b796176d117aa = function (arg0) {
990
917
  getObject(arg0).abort();
991
918
  };
992
- imports.wbg.__wbg_new_1eead62f64ca15ce = function () {
993
- return handleError(function () {
994
- const ret = new Headers();
995
- return addHeapObject(ret);
996
- }, arguments);
997
- };
998
- imports.wbg.__wbg_append_fda9e3432e3e88da = function () {
999
- return handleError(function (arg0, arg1, arg2, arg3, arg4) {
1000
- getObject(arg0).append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
1001
- }, arguments);
919
+ imports.wbg.__wbindgen_string_get = function (arg0, arg1) {
920
+ const obj = getObject(arg1);
921
+ const ret = typeof (obj) === 'string' ? obj : undefined;
922
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
923
+ var len1 = WASM_VECTOR_LEN;
924
+ getInt32Memory0()[arg0 / 4 + 1] = len1;
925
+ getInt32Memory0()[arg0 / 4 + 0] = ptr1;
1002
926
  };
1003
927
  imports.wbg.__wbg_self_7eede1f4488bf346 = function () {
1004
928
  return handleError(function () {
1005
929
  const ret = self.self;
1006
930
  return addHeapObject(ret);
1007
- }, arguments);
931
+ }, arguments)
1008
932
  };
1009
933
  imports.wbg.__wbg_crypto_c909fb428dcbddb6 = function (arg0) {
1010
934
  const ret = getObject(arg0).crypto;
@@ -1042,7 +966,7 @@ function __wbg_get_imports() {
1042
966
  };
1043
967
  imports.wbg.__wbindgen_is_object = function (arg0) {
1044
968
  const val = getObject(arg0);
1045
- const ret = typeof val === 'object' && val !== null;
969
+ const ret = typeof (val) === 'object' && val !== null;
1046
970
  return ret;
1047
971
  };
1048
972
  imports.wbg.__wbg_process_298734cf255a885d = function (arg0) {
@@ -1058,7 +982,7 @@ function __wbg_get_imports() {
1058
982
  return addHeapObject(ret);
1059
983
  };
1060
984
  imports.wbg.__wbindgen_is_string = function (arg0) {
1061
- const ret = typeof getObject(arg0) === 'string';
985
+ const ret = typeof (getObject(arg0)) === 'string';
1062
986
  return ret;
1063
987
  };
1064
988
  imports.wbg.__wbg_msCrypto_bcb970640f50a1e8 = function (arg0) {
@@ -1069,21 +993,21 @@ function __wbg_get_imports() {
1069
993
  return handleError(function () {
1070
994
  const ret = module.require;
1071
995
  return addHeapObject(ret);
1072
- }, arguments);
996
+ }, arguments)
1073
997
  };
1074
998
  imports.wbg.__wbindgen_is_function = function (arg0) {
1075
- const ret = typeof getObject(arg0) === 'function';
999
+ const ret = typeof (getObject(arg0)) === 'function';
1076
1000
  return ret;
1077
1001
  };
1078
- imports.wbg.__wbg_getRandomValues_37fa2ca9e4e07fab = function () {
1079
- return handleError(function (arg0, arg1) {
1080
- getObject(arg0).getRandomValues(getObject(arg1));
1081
- }, arguments);
1082
- };
1083
1002
  imports.wbg.__wbg_randomFillSync_dc1e9a60c158336d = function () {
1084
1003
  return handleError(function (arg0, arg1) {
1085
1004
  getObject(arg0).randomFillSync(takeObject(arg1));
1086
- }, arguments);
1005
+ }, arguments)
1006
+ };
1007
+ imports.wbg.__wbg_getRandomValues_37fa2ca9e4e07fab = function () {
1008
+ return handleError(function (arg0, arg1) {
1009
+ getObject(arg0).getRandomValues(getObject(arg1));
1010
+ }, arguments)
1087
1011
  };
1088
1012
  imports.wbg.__wbg_newnoargs_581967eacc0e2604 = function (arg0, arg1) {
1089
1013
  const ret = new Function(getStringFromWasm0(arg0, arg1));
@@ -1097,7 +1021,7 @@ function __wbg_get_imports() {
1097
1021
  return handleError(function (arg0) {
1098
1022
  const ret = getObject(arg0).next();
1099
1023
  return addHeapObject(ret);
1100
- }, arguments);
1024
+ }, arguments)
1101
1025
  };
1102
1026
  imports.wbg.__wbg_done_5c1f01fb660d73b5 = function (arg0) {
1103
1027
  const ret = getObject(arg0).done;
@@ -1115,13 +1039,13 @@ function __wbg_get_imports() {
1115
1039
  return handleError(function (arg0, arg1) {
1116
1040
  const ret = Reflect.get(getObject(arg0), getObject(arg1));
1117
1041
  return addHeapObject(ret);
1118
- }, arguments);
1042
+ }, arguments)
1119
1043
  };
1120
1044
  imports.wbg.__wbg_call_cb65541d95d71282 = function () {
1121
1045
  return handleError(function (arg0, arg1) {
1122
1046
  const ret = getObject(arg0).call(getObject(arg1));
1123
1047
  return addHeapObject(ret);
1124
- }, arguments);
1048
+ }, arguments)
1125
1049
  };
1126
1050
  imports.wbg.__wbg_new_b51585de1b234aff = function () {
1127
1051
  const ret = new Object();
@@ -1131,31 +1055,31 @@ function __wbg_get_imports() {
1131
1055
  return handleError(function () {
1132
1056
  const ret = self.self;
1133
1057
  return addHeapObject(ret);
1134
- }, arguments);
1058
+ }, arguments)
1135
1059
  };
1136
1060
  imports.wbg.__wbg_window_5f4faef6c12b79ec = function () {
1137
1061
  return handleError(function () {
1138
1062
  const ret = window.window;
1139
1063
  return addHeapObject(ret);
1140
- }, arguments);
1064
+ }, arguments)
1141
1065
  };
1142
1066
  imports.wbg.__wbg_globalThis_1d39714405582d3c = function () {
1143
1067
  return handleError(function () {
1144
1068
  const ret = globalThis.globalThis;
1145
1069
  return addHeapObject(ret);
1146
- }, arguments);
1070
+ }, arguments)
1147
1071
  };
1148
1072
  imports.wbg.__wbg_global_651f05c6a0944d1c = function () {
1149
1073
  return handleError(function () {
1150
1074
  const ret = global.global;
1151
1075
  return addHeapObject(ret);
1152
- }, arguments);
1076
+ }, arguments)
1153
1077
  };
1154
1078
  imports.wbg.__wbg_call_01734de55d61e11d = function () {
1155
1079
  return handleError(function (arg0, arg1, arg2) {
1156
1080
  const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
1157
1081
  return addHeapObject(ret);
1158
- }, arguments);
1082
+ }, arguments)
1159
1083
  };
1160
1084
  imports.wbg.__wbg_getTime_5e2054f832d82ec9 = function (arg0) {
1161
1085
  const ret = getObject(arg0).getTime();
@@ -1222,23 +1146,23 @@ function __wbg_get_imports() {
1222
1146
  const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
1223
1147
  return addHeapObject(ret);
1224
1148
  };
1225
- imports.wbg.__wbg_stringify_e25465938f3f611f = function () {
1226
- return handleError(function (arg0) {
1227
- const ret = JSON.stringify(getObject(arg0));
1228
- return addHeapObject(ret);
1229
- }, arguments);
1230
- };
1231
1149
  imports.wbg.__wbg_has_c5fcd020291e56b8 = function () {
1232
1150
  return handleError(function (arg0, arg1) {
1233
1151
  const ret = Reflect.has(getObject(arg0), getObject(arg1));
1234
1152
  return ret;
1235
- }, arguments);
1153
+ }, arguments)
1236
1154
  };
1237
1155
  imports.wbg.__wbg_set_092e06b0f9d71865 = function () {
1238
1156
  return handleError(function (arg0, arg1, arg2) {
1239
1157
  const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
1240
1158
  return ret;
1241
- }, arguments);
1159
+ }, arguments)
1160
+ };
1161
+ imports.wbg.__wbg_stringify_e25465938f3f611f = function () {
1162
+ return handleError(function (arg0) {
1163
+ const ret = JSON.stringify(getObject(arg0));
1164
+ return addHeapObject(ret);
1165
+ }, arguments)
1242
1166
  };
1243
1167
  imports.wbg.__wbindgen_debug_string = function (arg0, arg1) {
1244
1168
  const ret = debugString(getObject(arg1));
@@ -1254,15 +1178,17 @@ function __wbg_get_imports() {
1254
1178
  const ret = wasm.memory;
1255
1179
  return addHeapObject(ret);
1256
1180
  };
1257
- imports.wbg.__wbindgen_closure_wrapper12805 = function (arg0, arg1, arg2) {
1258
- const ret = makeMutClosure(arg0, arg1, 3862, __wbg_adapter_26);
1181
+ imports.wbg.__wbindgen_closure_wrapper12457 = function (arg0, arg1, arg2) {
1182
+ const ret = makeMutClosure(arg0, arg1, 4397, __wbg_adapter_26);
1259
1183
  return addHeapObject(ret);
1260
1184
  };
1261
1185
 
1262
1186
  return imports;
1263
1187
  }
1264
1188
 
1265
- function __wbg_init_memory(imports, maybe_memory) { }
1189
+ function __wbg_init_memory(imports, maybe_memory) {
1190
+
1191
+ }
1266
1192
 
1267
1193
  function __wbg_finalize_init(instance, module) {
1268
1194
  wasm = instance.exports;
@@ -1270,6 +1196,7 @@ function __wbg_finalize_init(instance, module) {
1270
1196
  cachedInt32Memory0 = null;
1271
1197
  cachedUint8Memory0 = null;
1272
1198
 
1199
+
1273
1200
  return wasm;
1274
1201
  }
1275
1202
 
@@ -1294,11 +1221,7 @@ async function __wbg_init(input) {
1294
1221
 
1295
1222
  const imports = __wbg_get_imports();
1296
1223
 
1297
- if (
1298
- typeof input === 'string' ||
1299
- (typeof Request === 'function' && input instanceof Request) ||
1300
- (typeof URL === 'function' && input instanceof URL)
1301
- ) {
1224
+ if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) {
1302
1225
  input = fetch(input);
1303
1226
  }
1304
1227
 
@@ -1309,5 +1232,5 @@ async function __wbg_init(input) {
1309
1232
  return __wbg_finalize_init(instance, module);
1310
1233
  }
1311
1234
 
1312
- export { initSync };
1235
+ export { initSync }
1313
1236
  export default __wbg_init;