@learncard/core 1.0.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/README.md +128 -0
- package/dist/README.md +89 -0
- package/dist/core.cjs.development.js +48753 -0
- package/dist/core.cjs.development.js.map +7 -0
- package/dist/core.cjs.production.min.js +896 -0
- package/dist/core.cjs.production.min.js.map +7 -0
- package/dist/core.d.ts +232 -0
- package/dist/core.esm.js +48756 -0
- package/dist/core.esm.js.map +7 -0
- package/dist/didkit/README.md +89 -0
- package/dist/didkit/didkit_wasm.d.ts +222 -0
- package/dist/didkit/didkit_wasm.js +1070 -0
- package/dist/didkit/didkit_wasm_bg.wasm +0 -0
- package/dist/didkit/didkit_wasm_bg.wasm.d.ts +48 -0
- package/dist/didkit/package.json +15 -0
- package/dist/didkit_wasm.d.ts +222 -0
- package/dist/didkit_wasm.js +1070 -0
- package/dist/didkit_wasm_bg.wasm +0 -0
- package/dist/didkit_wasm_bg.wasm.d.ts +48 -0
- package/dist/index.js +7 -0
- package/dist/package.json +15 -0
- package/package.json +54 -0
@@ -0,0 +1,1070 @@
|
|
1
|
+
let wasm;
|
2
|
+
|
3
|
+
const cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
|
4
|
+
|
5
|
+
cachedTextDecoder.decode();
|
6
|
+
|
7
|
+
let cachegetUint8Memory0 = null;
|
8
|
+
function getUint8Memory0() {
|
9
|
+
if (cachegetUint8Memory0 === null || cachegetUint8Memory0.buffer !== wasm.memory.buffer) {
|
10
|
+
cachegetUint8Memory0 = new Uint8Array(wasm.memory.buffer);
|
11
|
+
}
|
12
|
+
return cachegetUint8Memory0;
|
13
|
+
}
|
14
|
+
|
15
|
+
function getStringFromWasm0(ptr, len) {
|
16
|
+
return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
|
17
|
+
}
|
18
|
+
|
19
|
+
const heap = new Array(32).fill(undefined);
|
20
|
+
|
21
|
+
heap.push(undefined, null, true, false);
|
22
|
+
|
23
|
+
let heap_next = heap.length;
|
24
|
+
|
25
|
+
function addHeapObject(obj) {
|
26
|
+
if (heap_next === heap.length) heap.push(heap.length + 1);
|
27
|
+
const idx = heap_next;
|
28
|
+
heap_next = heap[idx];
|
29
|
+
|
30
|
+
heap[idx] = obj;
|
31
|
+
return idx;
|
32
|
+
}
|
33
|
+
|
34
|
+
function getObject(idx) {
|
35
|
+
return heap[idx];
|
36
|
+
}
|
37
|
+
|
38
|
+
function dropObject(idx) {
|
39
|
+
if (idx < 36) return;
|
40
|
+
heap[idx] = heap_next;
|
41
|
+
heap_next = idx;
|
42
|
+
}
|
43
|
+
|
44
|
+
function takeObject(idx) {
|
45
|
+
const ret = getObject(idx);
|
46
|
+
dropObject(idx);
|
47
|
+
return ret;
|
48
|
+
}
|
49
|
+
|
50
|
+
let WASM_VECTOR_LEN = 0;
|
51
|
+
|
52
|
+
const cachedTextEncoder = new TextEncoder('utf-8');
|
53
|
+
|
54
|
+
const encodeString =
|
55
|
+
typeof cachedTextEncoder.encodeInto === 'function'
|
56
|
+
? function (arg, view) {
|
57
|
+
return cachedTextEncoder.encodeInto(arg, view);
|
58
|
+
}
|
59
|
+
: function (arg, view) {
|
60
|
+
const buf = cachedTextEncoder.encode(arg);
|
61
|
+
view.set(buf);
|
62
|
+
return {
|
63
|
+
read: arg.length,
|
64
|
+
written: buf.length,
|
65
|
+
};
|
66
|
+
};
|
67
|
+
|
68
|
+
function passStringToWasm0(arg, malloc, realloc) {
|
69
|
+
if (realloc === undefined) {
|
70
|
+
const buf = cachedTextEncoder.encode(arg);
|
71
|
+
const ptr = malloc(buf.length);
|
72
|
+
getUint8Memory0()
|
73
|
+
.subarray(ptr, ptr + buf.length)
|
74
|
+
.set(buf);
|
75
|
+
WASM_VECTOR_LEN = buf.length;
|
76
|
+
return ptr;
|
77
|
+
}
|
78
|
+
|
79
|
+
let len = arg.length;
|
80
|
+
let ptr = malloc(len);
|
81
|
+
|
82
|
+
const mem = getUint8Memory0();
|
83
|
+
|
84
|
+
let offset = 0;
|
85
|
+
|
86
|
+
for (; offset < len; offset++) {
|
87
|
+
const code = arg.charCodeAt(offset);
|
88
|
+
if (code > 0x7f) break;
|
89
|
+
mem[ptr + offset] = code;
|
90
|
+
}
|
91
|
+
|
92
|
+
if (offset !== len) {
|
93
|
+
if (offset !== 0) {
|
94
|
+
arg = arg.slice(offset);
|
95
|
+
}
|
96
|
+
ptr = realloc(ptr, len, (len = offset + arg.length * 3));
|
97
|
+
const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
|
98
|
+
const ret = encodeString(arg, view);
|
99
|
+
|
100
|
+
offset += ret.written;
|
101
|
+
}
|
102
|
+
|
103
|
+
WASM_VECTOR_LEN = offset;
|
104
|
+
return ptr;
|
105
|
+
}
|
106
|
+
|
107
|
+
function isLikeNone(x) {
|
108
|
+
return x === undefined || x === null;
|
109
|
+
}
|
110
|
+
|
111
|
+
let cachegetInt32Memory0 = null;
|
112
|
+
function getInt32Memory0() {
|
113
|
+
if (cachegetInt32Memory0 === null || cachegetInt32Memory0.buffer !== wasm.memory.buffer) {
|
114
|
+
cachegetInt32Memory0 = new Int32Array(wasm.memory.buffer);
|
115
|
+
}
|
116
|
+
return cachegetInt32Memory0;
|
117
|
+
}
|
118
|
+
|
119
|
+
function debugString(val) {
|
120
|
+
// primitive types
|
121
|
+
const type = typeof val;
|
122
|
+
if (type == 'number' || type == 'boolean' || val == null) {
|
123
|
+
return `${val}`;
|
124
|
+
}
|
125
|
+
if (type == 'string') {
|
126
|
+
return `"${val}"`;
|
127
|
+
}
|
128
|
+
if (type == 'symbol') {
|
129
|
+
const description = val.description;
|
130
|
+
if (description == null) {
|
131
|
+
return 'Symbol';
|
132
|
+
} else {
|
133
|
+
return `Symbol(${description})`;
|
134
|
+
}
|
135
|
+
}
|
136
|
+
if (type == 'function') {
|
137
|
+
const name = val.name;
|
138
|
+
if (typeof name == 'string' && name.length > 0) {
|
139
|
+
return `Function(${name})`;
|
140
|
+
} else {
|
141
|
+
return 'Function';
|
142
|
+
}
|
143
|
+
}
|
144
|
+
// objects
|
145
|
+
if (Array.isArray(val)) {
|
146
|
+
const length = val.length;
|
147
|
+
let debug = '[';
|
148
|
+
if (length > 0) {
|
149
|
+
debug += debugString(val[0]);
|
150
|
+
}
|
151
|
+
for (let i = 1; i < length; i++) {
|
152
|
+
debug += ', ' + debugString(val[i]);
|
153
|
+
}
|
154
|
+
debug += ']';
|
155
|
+
return debug;
|
156
|
+
}
|
157
|
+
// Test for built-in
|
158
|
+
const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
|
159
|
+
let className;
|
160
|
+
if (builtInMatches.length > 1) {
|
161
|
+
className = builtInMatches[1];
|
162
|
+
} else {
|
163
|
+
// Failed to match the standard '[object ClassName]'
|
164
|
+
return toString.call(val);
|
165
|
+
}
|
166
|
+
if (className == 'Object') {
|
167
|
+
// we're a user defined class or Object
|
168
|
+
// JSON.stringify avoids problems with cycles, and is generally much
|
169
|
+
// easier than looping through ownProperties of `val`.
|
170
|
+
try {
|
171
|
+
return 'Object(' + JSON.stringify(val) + ')';
|
172
|
+
} catch (_) {
|
173
|
+
return 'Object';
|
174
|
+
}
|
175
|
+
}
|
176
|
+
// errors
|
177
|
+
if (val instanceof Error) {
|
178
|
+
return `${val.name}: ${val.message}\n${val.stack}`;
|
179
|
+
}
|
180
|
+
// TODO we could test for more things here, like `Set`s and `Map`s.
|
181
|
+
return className;
|
182
|
+
}
|
183
|
+
|
184
|
+
function makeMutClosure(arg0, arg1, dtor, f) {
|
185
|
+
const state = { a: arg0, b: arg1, cnt: 1, dtor };
|
186
|
+
const real = (...args) => {
|
187
|
+
// First up with a closure we increment the internal reference
|
188
|
+
// count. This ensures that the Rust closure environment won't
|
189
|
+
// be deallocated while we're invoking it.
|
190
|
+
state.cnt++;
|
191
|
+
const a = state.a;
|
192
|
+
state.a = 0;
|
193
|
+
try {
|
194
|
+
return f(a, state.b, ...args);
|
195
|
+
} finally {
|
196
|
+
if (--state.cnt === 0) {
|
197
|
+
wasm.__wbindgen_export_2.get(state.dtor)(a, state.b);
|
198
|
+
} else {
|
199
|
+
state.a = a;
|
200
|
+
}
|
201
|
+
}
|
202
|
+
};
|
203
|
+
real.original = state;
|
204
|
+
|
205
|
+
return real;
|
206
|
+
}
|
207
|
+
function __wbg_adapter_24(arg0, arg1, arg2) {
|
208
|
+
wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h91a8814f66f14b17(
|
209
|
+
arg0,
|
210
|
+
arg1,
|
211
|
+
addHeapObject(arg2)
|
212
|
+
);
|
213
|
+
}
|
214
|
+
|
215
|
+
/**
|
216
|
+
* @returns {string}
|
217
|
+
*/
|
218
|
+
export function getVersion() {
|
219
|
+
try {
|
220
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
221
|
+
wasm.getVersion(retptr);
|
222
|
+
var r0 = getInt32Memory0()[retptr / 4 + 0];
|
223
|
+
var r1 = getInt32Memory0()[retptr / 4 + 1];
|
224
|
+
return getStringFromWasm0(r0, r1);
|
225
|
+
} finally {
|
226
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
227
|
+
wasm.__wbindgen_free(r0, r1);
|
228
|
+
}
|
229
|
+
}
|
230
|
+
|
231
|
+
/**
|
232
|
+
* @param {string} did
|
233
|
+
* @param {string} input_metadata
|
234
|
+
* @returns {Promise<any>}
|
235
|
+
*/
|
236
|
+
export function resolveDID(did, input_metadata) {
|
237
|
+
const ptr0 = passStringToWasm0(did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
238
|
+
const len0 = WASM_VECTOR_LEN;
|
239
|
+
const ptr1 = passStringToWasm0(input_metadata, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
240
|
+
const len1 = WASM_VECTOR_LEN;
|
241
|
+
const ret = wasm.resolveDID(ptr0, len0, ptr1, len1);
|
242
|
+
return takeObject(ret);
|
243
|
+
}
|
244
|
+
|
245
|
+
/**
|
246
|
+
* @returns {string}
|
247
|
+
*/
|
248
|
+
export function generateEd25519Key() {
|
249
|
+
try {
|
250
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
251
|
+
wasm.generateEd25519Key(retptr);
|
252
|
+
var r0 = getInt32Memory0()[retptr / 4 + 0];
|
253
|
+
var r1 = getInt32Memory0()[retptr / 4 + 1];
|
254
|
+
var r2 = getInt32Memory0()[retptr / 4 + 2];
|
255
|
+
var r3 = getInt32Memory0()[retptr / 4 + 3];
|
256
|
+
var ptr0 = r0;
|
257
|
+
var len0 = r1;
|
258
|
+
if (r3) {
|
259
|
+
ptr0 = 0;
|
260
|
+
len0 = 0;
|
261
|
+
throw takeObject(r2);
|
262
|
+
}
|
263
|
+
return getStringFromWasm0(ptr0, len0);
|
264
|
+
} finally {
|
265
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
266
|
+
wasm.__wbindgen_free(ptr0, len0);
|
267
|
+
}
|
268
|
+
}
|
269
|
+
|
270
|
+
function passArray8ToWasm0(arg, malloc) {
|
271
|
+
const ptr = malloc(arg.length * 1);
|
272
|
+
getUint8Memory0().set(arg, ptr / 1);
|
273
|
+
WASM_VECTOR_LEN = arg.length;
|
274
|
+
return ptr;
|
275
|
+
}
|
276
|
+
/**
|
277
|
+
* @param {Uint8Array} bytes
|
278
|
+
* @returns {string}
|
279
|
+
*/
|
280
|
+
export function generateEd25519KeyFromBytes(bytes) {
|
281
|
+
try {
|
282
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
283
|
+
const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
|
284
|
+
const len0 = WASM_VECTOR_LEN;
|
285
|
+
wasm.generateEd25519KeyFromBytes(retptr, ptr0, len0);
|
286
|
+
var r0 = getInt32Memory0()[retptr / 4 + 0];
|
287
|
+
var r1 = getInt32Memory0()[retptr / 4 + 1];
|
288
|
+
var r2 = getInt32Memory0()[retptr / 4 + 2];
|
289
|
+
var r3 = getInt32Memory0()[retptr / 4 + 3];
|
290
|
+
var ptr1 = r0;
|
291
|
+
var len1 = r1;
|
292
|
+
if (r3) {
|
293
|
+
ptr1 = 0;
|
294
|
+
len1 = 0;
|
295
|
+
throw takeObject(r2);
|
296
|
+
}
|
297
|
+
return getStringFromWasm0(ptr1, len1);
|
298
|
+
} finally {
|
299
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
300
|
+
wasm.__wbindgen_free(ptr1, len1);
|
301
|
+
}
|
302
|
+
}
|
303
|
+
|
304
|
+
/**
|
305
|
+
* @param {string} method_pattern
|
306
|
+
* @param {string} jwk
|
307
|
+
* @returns {string}
|
308
|
+
*/
|
309
|
+
export function keyToDID(method_pattern, jwk) {
|
310
|
+
try {
|
311
|
+
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
|
312
|
+
const ptr0 = passStringToWasm0(
|
313
|
+
method_pattern,
|
314
|
+
wasm.__wbindgen_malloc,
|
315
|
+
wasm.__wbindgen_realloc
|
316
|
+
);
|
317
|
+
const len0 = WASM_VECTOR_LEN;
|
318
|
+
const ptr1 = passStringToWasm0(jwk, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
319
|
+
const len1 = WASM_VECTOR_LEN;
|
320
|
+
wasm.keyToDID(retptr, ptr0, len0, ptr1, len1);
|
321
|
+
var r0 = getInt32Memory0()[retptr / 4 + 0];
|
322
|
+
var r1 = getInt32Memory0()[retptr / 4 + 1];
|
323
|
+
var r2 = getInt32Memory0()[retptr / 4 + 2];
|
324
|
+
var r3 = getInt32Memory0()[retptr / 4 + 3];
|
325
|
+
var ptr2 = r0;
|
326
|
+
var len2 = r1;
|
327
|
+
if (r3) {
|
328
|
+
ptr2 = 0;
|
329
|
+
len2 = 0;
|
330
|
+
throw takeObject(r2);
|
331
|
+
}
|
332
|
+
return getStringFromWasm0(ptr2, len2);
|
333
|
+
} finally {
|
334
|
+
wasm.__wbindgen_add_to_stack_pointer(16);
|
335
|
+
wasm.__wbindgen_free(ptr2, len2);
|
336
|
+
}
|
337
|
+
}
|
338
|
+
|
339
|
+
/**
|
340
|
+
* @param {string} method_pattern
|
341
|
+
* @param {string} jwk
|
342
|
+
* @returns {Promise<any>}
|
343
|
+
*/
|
344
|
+
export function keyToVerificationMethod(method_pattern, jwk) {
|
345
|
+
const ptr0 = passStringToWasm0(method_pattern, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
346
|
+
const len0 = WASM_VECTOR_LEN;
|
347
|
+
const ptr1 = passStringToWasm0(jwk, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
348
|
+
const len1 = WASM_VECTOR_LEN;
|
349
|
+
const ret = wasm.keyToVerificationMethod(ptr0, len0, ptr1, len1);
|
350
|
+
return takeObject(ret);
|
351
|
+
}
|
352
|
+
|
353
|
+
/**
|
354
|
+
* @param {string} credential
|
355
|
+
* @param {string} proof_options
|
356
|
+
* @param {string} key
|
357
|
+
* @returns {Promise<any>}
|
358
|
+
*/
|
359
|
+
export function issueCredential(credential, proof_options, key) {
|
360
|
+
const ptr0 = passStringToWasm0(credential, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
361
|
+
const len0 = WASM_VECTOR_LEN;
|
362
|
+
const ptr1 = passStringToWasm0(proof_options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
363
|
+
const len1 = WASM_VECTOR_LEN;
|
364
|
+
const ptr2 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
365
|
+
const len2 = WASM_VECTOR_LEN;
|
366
|
+
const ret = wasm.issueCredential(ptr0, len0, ptr1, len1, ptr2, len2);
|
367
|
+
return takeObject(ret);
|
368
|
+
}
|
369
|
+
|
370
|
+
/**
|
371
|
+
* @param {string} credential
|
372
|
+
* @param {string} linked_data_proof_options
|
373
|
+
* @param {string} public_key
|
374
|
+
* @returns {Promise<any>}
|
375
|
+
*/
|
376
|
+
export function prepareIssueCredential(credential, linked_data_proof_options, public_key) {
|
377
|
+
const ptr0 = passStringToWasm0(credential, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
378
|
+
const len0 = WASM_VECTOR_LEN;
|
379
|
+
const ptr1 = passStringToWasm0(
|
380
|
+
linked_data_proof_options,
|
381
|
+
wasm.__wbindgen_malloc,
|
382
|
+
wasm.__wbindgen_realloc
|
383
|
+
);
|
384
|
+
const len1 = WASM_VECTOR_LEN;
|
385
|
+
const ptr2 = passStringToWasm0(public_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
386
|
+
const len2 = WASM_VECTOR_LEN;
|
387
|
+
const ret = wasm.prepareIssueCredential(ptr0, len0, ptr1, len1, ptr2, len2);
|
388
|
+
return takeObject(ret);
|
389
|
+
}
|
390
|
+
|
391
|
+
/**
|
392
|
+
* @param {string} credential
|
393
|
+
* @param {string} preparation
|
394
|
+
* @param {string} signature
|
395
|
+
* @returns {Promise<any>}
|
396
|
+
*/
|
397
|
+
export function completeIssueCredential(credential, preparation, signature) {
|
398
|
+
const ptr0 = passStringToWasm0(credential, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
399
|
+
const len0 = WASM_VECTOR_LEN;
|
400
|
+
const ptr1 = passStringToWasm0(preparation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
401
|
+
const len1 = WASM_VECTOR_LEN;
|
402
|
+
const ptr2 = passStringToWasm0(signature, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
403
|
+
const len2 = WASM_VECTOR_LEN;
|
404
|
+
const ret = wasm.completeIssueCredential(ptr0, len0, ptr1, len1, ptr2, len2);
|
405
|
+
return takeObject(ret);
|
406
|
+
}
|
407
|
+
|
408
|
+
/**
|
409
|
+
* @param {string} vc
|
410
|
+
* @param {string} proof_options
|
411
|
+
* @returns {Promise<any>}
|
412
|
+
*/
|
413
|
+
export function verifyCredential(vc, proof_options) {
|
414
|
+
const ptr0 = passStringToWasm0(vc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
415
|
+
const len0 = WASM_VECTOR_LEN;
|
416
|
+
const ptr1 = passStringToWasm0(proof_options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
417
|
+
const len1 = WASM_VECTOR_LEN;
|
418
|
+
const ret = wasm.verifyCredential(ptr0, len0, ptr1, len1);
|
419
|
+
return takeObject(ret);
|
420
|
+
}
|
421
|
+
|
422
|
+
/**
|
423
|
+
* @param {string} presentation
|
424
|
+
* @param {string} proof_options
|
425
|
+
* @param {string} key
|
426
|
+
* @returns {Promise<any>}
|
427
|
+
*/
|
428
|
+
export function issuePresentation(presentation, proof_options, key) {
|
429
|
+
const ptr0 = passStringToWasm0(presentation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
430
|
+
const len0 = WASM_VECTOR_LEN;
|
431
|
+
const ptr1 = passStringToWasm0(proof_options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
432
|
+
const len1 = WASM_VECTOR_LEN;
|
433
|
+
const ptr2 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
434
|
+
const len2 = WASM_VECTOR_LEN;
|
435
|
+
const ret = wasm.issuePresentation(ptr0, len0, ptr1, len1, ptr2, len2);
|
436
|
+
return takeObject(ret);
|
437
|
+
}
|
438
|
+
|
439
|
+
/**
|
440
|
+
* @param {string} presentation
|
441
|
+
* @param {string} linked_data_proof_options
|
442
|
+
* @param {string} public_key
|
443
|
+
* @returns {Promise<any>}
|
444
|
+
*/
|
445
|
+
export function prepareIssuePresentation(presentation, linked_data_proof_options, public_key) {
|
446
|
+
const ptr0 = passStringToWasm0(presentation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
447
|
+
const len0 = WASM_VECTOR_LEN;
|
448
|
+
const ptr1 = passStringToWasm0(
|
449
|
+
linked_data_proof_options,
|
450
|
+
wasm.__wbindgen_malloc,
|
451
|
+
wasm.__wbindgen_realloc
|
452
|
+
);
|
453
|
+
const len1 = WASM_VECTOR_LEN;
|
454
|
+
const ptr2 = passStringToWasm0(public_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
455
|
+
const len2 = WASM_VECTOR_LEN;
|
456
|
+
const ret = wasm.prepareIssuePresentation(ptr0, len0, ptr1, len1, ptr2, len2);
|
457
|
+
return takeObject(ret);
|
458
|
+
}
|
459
|
+
|
460
|
+
/**
|
461
|
+
* @param {string} presentation
|
462
|
+
* @param {string} preparation
|
463
|
+
* @param {string} signature
|
464
|
+
* @returns {Promise<any>}
|
465
|
+
*/
|
466
|
+
export function completeIssuePresentation(presentation, preparation, signature) {
|
467
|
+
const ptr0 = passStringToWasm0(presentation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
468
|
+
const len0 = WASM_VECTOR_LEN;
|
469
|
+
const ptr1 = passStringToWasm0(preparation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
470
|
+
const len1 = WASM_VECTOR_LEN;
|
471
|
+
const ptr2 = passStringToWasm0(signature, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
472
|
+
const len2 = WASM_VECTOR_LEN;
|
473
|
+
const ret = wasm.completeIssuePresentation(ptr0, len0, ptr1, len1, ptr2, len2);
|
474
|
+
return takeObject(ret);
|
475
|
+
}
|
476
|
+
|
477
|
+
/**
|
478
|
+
* @param {string} vp
|
479
|
+
* @param {string} proof_options
|
480
|
+
* @returns {Promise<any>}
|
481
|
+
*/
|
482
|
+
export function verifyPresentation(vp, proof_options) {
|
483
|
+
const ptr0 = passStringToWasm0(vp, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
484
|
+
const len0 = WASM_VECTOR_LEN;
|
485
|
+
const ptr1 = passStringToWasm0(proof_options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
486
|
+
const len1 = WASM_VECTOR_LEN;
|
487
|
+
const ret = wasm.verifyPresentation(ptr0, len0, ptr1, len1);
|
488
|
+
return takeObject(ret);
|
489
|
+
}
|
490
|
+
|
491
|
+
/**
|
492
|
+
* @param {string} holder
|
493
|
+
* @param {string} linked_data_proof_options
|
494
|
+
* @param {string} key
|
495
|
+
* @returns {Promise<any>}
|
496
|
+
*/
|
497
|
+
export function DIDAuth(holder, linked_data_proof_options, key) {
|
498
|
+
const ptr0 = passStringToWasm0(holder, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
499
|
+
const len0 = WASM_VECTOR_LEN;
|
500
|
+
const ptr1 = passStringToWasm0(
|
501
|
+
linked_data_proof_options,
|
502
|
+
wasm.__wbindgen_malloc,
|
503
|
+
wasm.__wbindgen_realloc
|
504
|
+
);
|
505
|
+
const len1 = WASM_VECTOR_LEN;
|
506
|
+
const ptr2 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
507
|
+
const len2 = WASM_VECTOR_LEN;
|
508
|
+
const ret = wasm.DIDAuth(ptr0, len0, ptr1, len1, ptr2, len2);
|
509
|
+
return takeObject(ret);
|
510
|
+
}
|
511
|
+
|
512
|
+
/**
|
513
|
+
* @param {string} tz
|
514
|
+
* @returns {Promise<any>}
|
515
|
+
*/
|
516
|
+
export function JWKFromTezos(tz) {
|
517
|
+
const ptr0 = passStringToWasm0(tz, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
518
|
+
const len0 = WASM_VECTOR_LEN;
|
519
|
+
const ret = wasm.JWKFromTezos(ptr0, len0);
|
520
|
+
return takeObject(ret);
|
521
|
+
}
|
522
|
+
|
523
|
+
/**
|
524
|
+
* @param {string} capability
|
525
|
+
* @param {string} linked_data_proof_options
|
526
|
+
* @param {string} parents
|
527
|
+
* @param {string} key
|
528
|
+
* @returns {Promise<any>}
|
529
|
+
*/
|
530
|
+
export function delegateCapability(capability, linked_data_proof_options, parents, key) {
|
531
|
+
const ptr0 = passStringToWasm0(capability, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
532
|
+
const len0 = WASM_VECTOR_LEN;
|
533
|
+
const ptr1 = passStringToWasm0(
|
534
|
+
linked_data_proof_options,
|
535
|
+
wasm.__wbindgen_malloc,
|
536
|
+
wasm.__wbindgen_realloc
|
537
|
+
);
|
538
|
+
const len1 = WASM_VECTOR_LEN;
|
539
|
+
const ptr2 = passStringToWasm0(parents, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
540
|
+
const len2 = WASM_VECTOR_LEN;
|
541
|
+
const ptr3 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
542
|
+
const len3 = WASM_VECTOR_LEN;
|
543
|
+
const ret = wasm.delegateCapability(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
|
544
|
+
return takeObject(ret);
|
545
|
+
}
|
546
|
+
|
547
|
+
/**
|
548
|
+
* @param {string} capability
|
549
|
+
* @param {string} linked_data_proof_options
|
550
|
+
* @param {string} parents
|
551
|
+
* @param {string} public_key
|
552
|
+
* @returns {Promise<any>}
|
553
|
+
*/
|
554
|
+
export function prepareDelegateCapability(
|
555
|
+
capability,
|
556
|
+
linked_data_proof_options,
|
557
|
+
parents,
|
558
|
+
public_key
|
559
|
+
) {
|
560
|
+
const ptr0 = passStringToWasm0(capability, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
561
|
+
const len0 = WASM_VECTOR_LEN;
|
562
|
+
const ptr1 = passStringToWasm0(
|
563
|
+
linked_data_proof_options,
|
564
|
+
wasm.__wbindgen_malloc,
|
565
|
+
wasm.__wbindgen_realloc
|
566
|
+
);
|
567
|
+
const len1 = WASM_VECTOR_LEN;
|
568
|
+
const ptr2 = passStringToWasm0(parents, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
569
|
+
const len2 = WASM_VECTOR_LEN;
|
570
|
+
const ptr3 = passStringToWasm0(public_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
571
|
+
const len3 = WASM_VECTOR_LEN;
|
572
|
+
const ret = wasm.prepareDelegateCapability(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
|
573
|
+
return takeObject(ret);
|
574
|
+
}
|
575
|
+
|
576
|
+
/**
|
577
|
+
* @param {string} capability
|
578
|
+
* @param {string} preparation
|
579
|
+
* @param {string} signature
|
580
|
+
* @returns {Promise<any>}
|
581
|
+
*/
|
582
|
+
export function completeDelegateCapability(capability, preparation, signature) {
|
583
|
+
const ptr0 = passStringToWasm0(capability, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
584
|
+
const len0 = WASM_VECTOR_LEN;
|
585
|
+
const ptr1 = passStringToWasm0(preparation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
586
|
+
const len1 = WASM_VECTOR_LEN;
|
587
|
+
const ptr2 = passStringToWasm0(signature, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
588
|
+
const len2 = WASM_VECTOR_LEN;
|
589
|
+
const ret = wasm.completeDelegateCapability(ptr0, len0, ptr1, len1, ptr2, len2);
|
590
|
+
return takeObject(ret);
|
591
|
+
}
|
592
|
+
|
593
|
+
/**
|
594
|
+
* @param {string} delegation
|
595
|
+
* @returns {Promise<any>}
|
596
|
+
*/
|
597
|
+
export function verifyDelegation(delegation) {
|
598
|
+
const ptr0 = passStringToWasm0(delegation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
599
|
+
const len0 = WASM_VECTOR_LEN;
|
600
|
+
const ret = wasm.verifyDelegation(ptr0, len0);
|
601
|
+
return takeObject(ret);
|
602
|
+
}
|
603
|
+
|
604
|
+
/**
|
605
|
+
* @param {string} invocation
|
606
|
+
* @param {string} target_id
|
607
|
+
* @param {string} linked_data_proof_options
|
608
|
+
* @param {string} key
|
609
|
+
* @returns {Promise<any>}
|
610
|
+
*/
|
611
|
+
export function invokeCapability(invocation, target_id, linked_data_proof_options, key) {
|
612
|
+
const ptr0 = passStringToWasm0(invocation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
613
|
+
const len0 = WASM_VECTOR_LEN;
|
614
|
+
const ptr1 = passStringToWasm0(target_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
615
|
+
const len1 = WASM_VECTOR_LEN;
|
616
|
+
const ptr2 = passStringToWasm0(
|
617
|
+
linked_data_proof_options,
|
618
|
+
wasm.__wbindgen_malloc,
|
619
|
+
wasm.__wbindgen_realloc
|
620
|
+
);
|
621
|
+
const len2 = WASM_VECTOR_LEN;
|
622
|
+
const ptr3 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
623
|
+
const len3 = WASM_VECTOR_LEN;
|
624
|
+
const ret = wasm.invokeCapability(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
|
625
|
+
return takeObject(ret);
|
626
|
+
}
|
627
|
+
|
628
|
+
/**
|
629
|
+
* @param {string} invocation
|
630
|
+
* @param {string} target_id
|
631
|
+
* @param {string} linked_data_proof_options
|
632
|
+
* @param {string} public_key
|
633
|
+
* @returns {Promise<any>}
|
634
|
+
*/
|
635
|
+
export function prepareInvokeCapability(
|
636
|
+
invocation,
|
637
|
+
target_id,
|
638
|
+
linked_data_proof_options,
|
639
|
+
public_key
|
640
|
+
) {
|
641
|
+
const ptr0 = passStringToWasm0(invocation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
642
|
+
const len0 = WASM_VECTOR_LEN;
|
643
|
+
const ptr1 = passStringToWasm0(target_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
644
|
+
const len1 = WASM_VECTOR_LEN;
|
645
|
+
const ptr2 = passStringToWasm0(
|
646
|
+
linked_data_proof_options,
|
647
|
+
wasm.__wbindgen_malloc,
|
648
|
+
wasm.__wbindgen_realloc
|
649
|
+
);
|
650
|
+
const len2 = WASM_VECTOR_LEN;
|
651
|
+
const ptr3 = passStringToWasm0(public_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
652
|
+
const len3 = WASM_VECTOR_LEN;
|
653
|
+
const ret = wasm.prepareInvokeCapability(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
|
654
|
+
return takeObject(ret);
|
655
|
+
}
|
656
|
+
|
657
|
+
/**
|
658
|
+
* @param {string} invocation
|
659
|
+
* @param {string} preparation
|
660
|
+
* @param {string} signature
|
661
|
+
* @returns {Promise<any>}
|
662
|
+
*/
|
663
|
+
export function completeInvokeCapability(invocation, preparation, signature) {
|
664
|
+
const ptr0 = passStringToWasm0(invocation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
665
|
+
const len0 = WASM_VECTOR_LEN;
|
666
|
+
const ptr1 = passStringToWasm0(preparation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
667
|
+
const len1 = WASM_VECTOR_LEN;
|
668
|
+
const ptr2 = passStringToWasm0(signature, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
669
|
+
const len2 = WASM_VECTOR_LEN;
|
670
|
+
const ret = wasm.completeInvokeCapability(ptr0, len0, ptr1, len1, ptr2, len2);
|
671
|
+
return takeObject(ret);
|
672
|
+
}
|
673
|
+
|
674
|
+
/**
|
675
|
+
* @param {string} invocation
|
676
|
+
* @returns {Promise<any>}
|
677
|
+
*/
|
678
|
+
export function verifyInvocationSignature(invocation) {
|
679
|
+
const ptr0 = passStringToWasm0(invocation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
680
|
+
const len0 = WASM_VECTOR_LEN;
|
681
|
+
const ret = wasm.verifyInvocationSignature(ptr0, len0);
|
682
|
+
return takeObject(ret);
|
683
|
+
}
|
684
|
+
|
685
|
+
/**
|
686
|
+
* @param {string} invocation
|
687
|
+
* @param {string} delegation
|
688
|
+
* @returns {Promise<any>}
|
689
|
+
*/
|
690
|
+
export function verifyInvocation(invocation, delegation) {
|
691
|
+
const ptr0 = passStringToWasm0(invocation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
692
|
+
const len0 = WASM_VECTOR_LEN;
|
693
|
+
const ptr1 = passStringToWasm0(delegation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
694
|
+
const len1 = WASM_VECTOR_LEN;
|
695
|
+
const ret = wasm.verifyInvocation(ptr0, len0, ptr1, len1);
|
696
|
+
return takeObject(ret);
|
697
|
+
}
|
698
|
+
|
699
|
+
function handleError(f, args) {
|
700
|
+
try {
|
701
|
+
return f.apply(this, args);
|
702
|
+
} catch (e) {
|
703
|
+
wasm.__wbindgen_exn_store(addHeapObject(e));
|
704
|
+
}
|
705
|
+
}
|
706
|
+
|
707
|
+
function getArrayU8FromWasm0(ptr, len) {
|
708
|
+
return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
|
709
|
+
}
|
710
|
+
function __wbg_adapter_108(arg0, arg1, arg2, arg3) {
|
711
|
+
wasm.wasm_bindgen__convert__closures__invoke2_mut__h3ecfeb7a01c1be81(
|
712
|
+
arg0,
|
713
|
+
arg1,
|
714
|
+
addHeapObject(arg2),
|
715
|
+
addHeapObject(arg3)
|
716
|
+
);
|
717
|
+
}
|
718
|
+
|
719
|
+
async function load(module, imports) {
|
720
|
+
if (typeof Response === 'function' && module instanceof Response) {
|
721
|
+
if (typeof WebAssembly.instantiateStreaming === 'function') {
|
722
|
+
try {
|
723
|
+
return await WebAssembly.instantiateStreaming(module, imports);
|
724
|
+
} catch (e) {
|
725
|
+
if (module.headers.get('Content-Type') != 'application/wasm') {
|
726
|
+
console.warn(
|
727
|
+
'`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',
|
728
|
+
e
|
729
|
+
);
|
730
|
+
} else {
|
731
|
+
throw e;
|
732
|
+
}
|
733
|
+
}
|
734
|
+
}
|
735
|
+
|
736
|
+
const bytes = await module.arrayBuffer();
|
737
|
+
return await WebAssembly.instantiate(bytes, imports);
|
738
|
+
} else {
|
739
|
+
const instance = await WebAssembly.instantiate(module, imports);
|
740
|
+
|
741
|
+
if (instance instanceof WebAssembly.Instance) {
|
742
|
+
return { instance, module };
|
743
|
+
} else {
|
744
|
+
return instance;
|
745
|
+
}
|
746
|
+
}
|
747
|
+
}
|
748
|
+
|
749
|
+
async function init(input) {
|
750
|
+
if (typeof input === 'undefined') {
|
751
|
+
// input = new URL('didkit_wasm_bg.wasm', import.meta.url);
|
752
|
+
}
|
753
|
+
const imports = {};
|
754
|
+
imports.wbg = {};
|
755
|
+
imports.wbg.__wbindgen_string_new = function (arg0, arg1) {
|
756
|
+
const ret = getStringFromWasm0(arg0, arg1);
|
757
|
+
return addHeapObject(ret);
|
758
|
+
};
|
759
|
+
imports.wbg.__wbindgen_object_drop_ref = function (arg0) {
|
760
|
+
takeObject(arg0);
|
761
|
+
};
|
762
|
+
imports.wbg.__wbindgen_cb_drop = function (arg0) {
|
763
|
+
const obj = takeObject(arg0).original;
|
764
|
+
if (obj.cnt-- == 1) {
|
765
|
+
obj.a = 0;
|
766
|
+
return true;
|
767
|
+
}
|
768
|
+
const ret = false;
|
769
|
+
return ret;
|
770
|
+
};
|
771
|
+
imports.wbg.__wbindgen_object_clone_ref = function (arg0) {
|
772
|
+
const ret = getObject(arg0);
|
773
|
+
return addHeapObject(ret);
|
774
|
+
};
|
775
|
+
imports.wbg.__wbg_fetch_811d43d6bdcad5b1 = function (arg0) {
|
776
|
+
const ret = fetch(getObject(arg0));
|
777
|
+
return addHeapObject(ret);
|
778
|
+
};
|
779
|
+
imports.wbg.__wbg_fetch_bf56e2a9f0644e3f = function (arg0, arg1) {
|
780
|
+
const ret = getObject(arg0).fetch(getObject(arg1));
|
781
|
+
return addHeapObject(ret);
|
782
|
+
};
|
783
|
+
imports.wbg.__wbg_new_89d7f088c1c45353 = function () {
|
784
|
+
return handleError(function () {
|
785
|
+
const ret = new Headers();
|
786
|
+
return addHeapObject(ret);
|
787
|
+
}, arguments);
|
788
|
+
};
|
789
|
+
imports.wbg.__wbg_append_f4f93bc73c45ee3e = function () {
|
790
|
+
return handleError(function (arg0, arg1, arg2, arg3, arg4) {
|
791
|
+
getObject(arg0).append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
|
792
|
+
}, arguments);
|
793
|
+
};
|
794
|
+
imports.wbg.__wbindgen_string_get = function (arg0, arg1) {
|
795
|
+
const obj = getObject(arg1);
|
796
|
+
const ret = typeof obj === 'string' ? obj : undefined;
|
797
|
+
var ptr0 = isLikeNone(ret)
|
798
|
+
? 0
|
799
|
+
: passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
800
|
+
var len0 = WASM_VECTOR_LEN;
|
801
|
+
getInt32Memory0()[arg0 / 4 + 1] = len0;
|
802
|
+
getInt32Memory0()[arg0 / 4 + 0] = ptr0;
|
803
|
+
};
|
804
|
+
imports.wbg.__wbg_instanceof_Response_ccfeb62399355bcd = function (arg0) {
|
805
|
+
const ret = getObject(arg0) instanceof Response;
|
806
|
+
return ret;
|
807
|
+
};
|
808
|
+
imports.wbg.__wbg_url_06c0f822d68d195c = function (arg0, arg1) {
|
809
|
+
const ret = getObject(arg1).url;
|
810
|
+
const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
811
|
+
const len0 = WASM_VECTOR_LEN;
|
812
|
+
getInt32Memory0()[arg0 / 4 + 1] = len0;
|
813
|
+
getInt32Memory0()[arg0 / 4 + 0] = ptr0;
|
814
|
+
};
|
815
|
+
imports.wbg.__wbg_status_600fd8b881393898 = function (arg0) {
|
816
|
+
const ret = getObject(arg0).status;
|
817
|
+
return ret;
|
818
|
+
};
|
819
|
+
imports.wbg.__wbg_headers_9e7f2c05a9b962ea = function (arg0) {
|
820
|
+
const ret = getObject(arg0).headers;
|
821
|
+
return addHeapObject(ret);
|
822
|
+
};
|
823
|
+
imports.wbg.__wbg_arrayBuffer_5a99283a3954c850 = function () {
|
824
|
+
return handleError(function (arg0) {
|
825
|
+
const ret = getObject(arg0).arrayBuffer();
|
826
|
+
return addHeapObject(ret);
|
827
|
+
}, arguments);
|
828
|
+
};
|
829
|
+
imports.wbg.__wbg_newwithstrandinit_fd99688f189f053e = function () {
|
830
|
+
return handleError(function (arg0, arg1, arg2) {
|
831
|
+
const ret = new Request(getStringFromWasm0(arg0, arg1), getObject(arg2));
|
832
|
+
return addHeapObject(ret);
|
833
|
+
}, arguments);
|
834
|
+
};
|
835
|
+
imports.wbg.__wbindgen_is_object = function (arg0) {
|
836
|
+
const val = getObject(arg0);
|
837
|
+
const ret = typeof val === 'object' && val !== null;
|
838
|
+
return ret;
|
839
|
+
};
|
840
|
+
imports.wbg.__wbg_self_86b4b13392c7af56 = function () {
|
841
|
+
return handleError(function () {
|
842
|
+
const ret = self.self;
|
843
|
+
return addHeapObject(ret);
|
844
|
+
}, arguments);
|
845
|
+
};
|
846
|
+
imports.wbg.__wbg_crypto_b8c92eaac23d0d80 = function (arg0) {
|
847
|
+
const ret = getObject(arg0).crypto;
|
848
|
+
return addHeapObject(ret);
|
849
|
+
};
|
850
|
+
imports.wbg.__wbg_msCrypto_9ad6677321a08dd8 = function (arg0) {
|
851
|
+
const ret = getObject(arg0).msCrypto;
|
852
|
+
return addHeapObject(ret);
|
853
|
+
};
|
854
|
+
imports.wbg.__wbindgen_is_undefined = function (arg0) {
|
855
|
+
const ret = getObject(arg0) === undefined;
|
856
|
+
return ret;
|
857
|
+
};
|
858
|
+
imports.wbg.__wbg_static_accessor_MODULE_452b4680e8614c81 = function () {
|
859
|
+
const ret = module;
|
860
|
+
return addHeapObject(ret);
|
861
|
+
};
|
862
|
+
imports.wbg.__wbg_require_f5521a5b85ad2542 = function (arg0, arg1, arg2) {
|
863
|
+
const ret = getObject(arg0).require(getStringFromWasm0(arg1, arg2));
|
864
|
+
return addHeapObject(ret);
|
865
|
+
};
|
866
|
+
imports.wbg.__wbg_getRandomValues_dd27e6b0652b3236 = function (arg0) {
|
867
|
+
const ret = getObject(arg0).getRandomValues;
|
868
|
+
return addHeapObject(ret);
|
869
|
+
};
|
870
|
+
imports.wbg.__wbg_getRandomValues_e57c9b75ddead065 = function (arg0, arg1) {
|
871
|
+
getObject(arg0).getRandomValues(getObject(arg1));
|
872
|
+
};
|
873
|
+
imports.wbg.__wbg_randomFillSync_d2ba53160aec6aba = function (arg0, arg1, arg2) {
|
874
|
+
getObject(arg0).randomFillSync(getArrayU8FromWasm0(arg1, arg2));
|
875
|
+
};
|
876
|
+
imports.wbg.__wbindgen_is_function = function (arg0) {
|
877
|
+
const ret = typeof getObject(arg0) === 'function';
|
878
|
+
return ret;
|
879
|
+
};
|
880
|
+
imports.wbg.__wbg_newnoargs_e23b458e372830de = function (arg0, arg1) {
|
881
|
+
const ret = new Function(getStringFromWasm0(arg0, arg1));
|
882
|
+
return addHeapObject(ret);
|
883
|
+
};
|
884
|
+
imports.wbg.__wbg_next_cabb70b365520721 = function (arg0) {
|
885
|
+
const ret = getObject(arg0).next;
|
886
|
+
return addHeapObject(ret);
|
887
|
+
};
|
888
|
+
imports.wbg.__wbg_next_bf3d83fc18df496e = function () {
|
889
|
+
return handleError(function (arg0) {
|
890
|
+
const ret = getObject(arg0).next();
|
891
|
+
return addHeapObject(ret);
|
892
|
+
}, arguments);
|
893
|
+
};
|
894
|
+
imports.wbg.__wbg_done_040f966faa9a72b3 = function (arg0) {
|
895
|
+
const ret = getObject(arg0).done;
|
896
|
+
return ret;
|
897
|
+
};
|
898
|
+
imports.wbg.__wbg_value_419afbd9b9574c4c = function (arg0) {
|
899
|
+
const ret = getObject(arg0).value;
|
900
|
+
return addHeapObject(ret);
|
901
|
+
};
|
902
|
+
imports.wbg.__wbg_iterator_4832ef1f15b0382b = function () {
|
903
|
+
const ret = Symbol.iterator;
|
904
|
+
return addHeapObject(ret);
|
905
|
+
};
|
906
|
+
imports.wbg.__wbg_get_a9cab131e3152c49 = function () {
|
907
|
+
return handleError(function (arg0, arg1) {
|
908
|
+
const ret = Reflect.get(getObject(arg0), getObject(arg1));
|
909
|
+
return addHeapObject(ret);
|
910
|
+
}, arguments);
|
911
|
+
};
|
912
|
+
imports.wbg.__wbg_call_ae78342adc33730a = function () {
|
913
|
+
return handleError(function (arg0, arg1) {
|
914
|
+
const ret = getObject(arg0).call(getObject(arg1));
|
915
|
+
return addHeapObject(ret);
|
916
|
+
}, arguments);
|
917
|
+
};
|
918
|
+
imports.wbg.__wbg_new_36359baae5a47e27 = function () {
|
919
|
+
const ret = new Object();
|
920
|
+
return addHeapObject(ret);
|
921
|
+
};
|
922
|
+
imports.wbg.__wbg_call_3ed288a247f13ea5 = function () {
|
923
|
+
return handleError(function (arg0, arg1, arg2) {
|
924
|
+
const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
|
925
|
+
return addHeapObject(ret);
|
926
|
+
}, arguments);
|
927
|
+
};
|
928
|
+
imports.wbg.__wbg_getTime_bffb1c09df09618b = function (arg0) {
|
929
|
+
const ret = getObject(arg0).getTime();
|
930
|
+
return ret;
|
931
|
+
};
|
932
|
+
imports.wbg.__wbg_new0_0ff7eb5c1486f3ec = function () {
|
933
|
+
const ret = new Date();
|
934
|
+
return addHeapObject(ret);
|
935
|
+
};
|
936
|
+
imports.wbg.__wbg_new_37705eed627d5ed9 = function (arg0, arg1) {
|
937
|
+
try {
|
938
|
+
var state0 = { a: arg0, b: arg1 };
|
939
|
+
var cb0 = (arg0, arg1) => {
|
940
|
+
const a = state0.a;
|
941
|
+
state0.a = 0;
|
942
|
+
try {
|
943
|
+
return __wbg_adapter_108(a, state0.b, arg0, arg1);
|
944
|
+
} finally {
|
945
|
+
state0.a = a;
|
946
|
+
}
|
947
|
+
};
|
948
|
+
const ret = new Promise(cb0);
|
949
|
+
return addHeapObject(ret);
|
950
|
+
} finally {
|
951
|
+
state0.a = state0.b = 0;
|
952
|
+
}
|
953
|
+
};
|
954
|
+
imports.wbg.__wbg_resolve_a9a87bdd64e9e62c = function (arg0) {
|
955
|
+
const ret = Promise.resolve(getObject(arg0));
|
956
|
+
return addHeapObject(ret);
|
957
|
+
};
|
958
|
+
imports.wbg.__wbg_then_ce526c837d07b68f = function (arg0, arg1) {
|
959
|
+
const ret = getObject(arg0).then(getObject(arg1));
|
960
|
+
return addHeapObject(ret);
|
961
|
+
};
|
962
|
+
imports.wbg.__wbg_then_842e65b843962f56 = function (arg0, arg1, arg2) {
|
963
|
+
const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
|
964
|
+
return addHeapObject(ret);
|
965
|
+
};
|
966
|
+
imports.wbg.__wbg_self_99737b4dcdf6f0d8 = function () {
|
967
|
+
return handleError(function () {
|
968
|
+
const ret = self.self;
|
969
|
+
return addHeapObject(ret);
|
970
|
+
}, arguments);
|
971
|
+
};
|
972
|
+
imports.wbg.__wbg_window_9b61fbbf3564c4fb = function () {
|
973
|
+
return handleError(function () {
|
974
|
+
const ret = window.window;
|
975
|
+
return addHeapObject(ret);
|
976
|
+
}, arguments);
|
977
|
+
};
|
978
|
+
imports.wbg.__wbg_globalThis_8e275ef40caea3a3 = function () {
|
979
|
+
return handleError(function () {
|
980
|
+
const ret = globalThis.globalThis;
|
981
|
+
return addHeapObject(ret);
|
982
|
+
}, arguments);
|
983
|
+
};
|
984
|
+
imports.wbg.__wbg_global_5de1e0f82bddcd27 = function () {
|
985
|
+
return handleError(function () {
|
986
|
+
const ret = global.global;
|
987
|
+
return addHeapObject(ret);
|
988
|
+
}, arguments);
|
989
|
+
};
|
990
|
+
imports.wbg.__wbg_buffer_7af23f65f6c64548 = function (arg0) {
|
991
|
+
const ret = getObject(arg0).buffer;
|
992
|
+
return addHeapObject(ret);
|
993
|
+
};
|
994
|
+
imports.wbg.__wbg_newwithbyteoffsetandlength_ce1e75f0ce5f7974 = function (arg0, arg1, arg2) {
|
995
|
+
const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
|
996
|
+
return addHeapObject(ret);
|
997
|
+
};
|
998
|
+
imports.wbg.__wbg_new_cc9018bd6f283b6f = function (arg0) {
|
999
|
+
const ret = new Uint8Array(getObject(arg0));
|
1000
|
+
return addHeapObject(ret);
|
1001
|
+
};
|
1002
|
+
imports.wbg.__wbg_set_f25e869e4565d2a2 = function (arg0, arg1, arg2) {
|
1003
|
+
getObject(arg0).set(getObject(arg1), arg2 >>> 0);
|
1004
|
+
};
|
1005
|
+
imports.wbg.__wbg_length_0acb1cf9bbaf8519 = function (arg0) {
|
1006
|
+
const ret = getObject(arg0).length;
|
1007
|
+
return ret;
|
1008
|
+
};
|
1009
|
+
imports.wbg.__wbg_newwithlength_8f0657faca9f1422 = function (arg0) {
|
1010
|
+
const ret = new Uint8Array(arg0 >>> 0);
|
1011
|
+
return addHeapObject(ret);
|
1012
|
+
};
|
1013
|
+
imports.wbg.__wbg_subarray_da527dbd24eafb6b = function (arg0, arg1, arg2) {
|
1014
|
+
const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
|
1015
|
+
return addHeapObject(ret);
|
1016
|
+
};
|
1017
|
+
imports.wbg.__wbg_has_ce995ec88636803d = function () {
|
1018
|
+
return handleError(function (arg0, arg1) {
|
1019
|
+
const ret = Reflect.has(getObject(arg0), getObject(arg1));
|
1020
|
+
return ret;
|
1021
|
+
}, arguments);
|
1022
|
+
};
|
1023
|
+
imports.wbg.__wbg_set_93b1c87ee2af852e = function () {
|
1024
|
+
return handleError(function (arg0, arg1, arg2) {
|
1025
|
+
const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
|
1026
|
+
return ret;
|
1027
|
+
}, arguments);
|
1028
|
+
};
|
1029
|
+
imports.wbg.__wbg_stringify_c760003feffcc1f2 = function () {
|
1030
|
+
return handleError(function (arg0) {
|
1031
|
+
const ret = JSON.stringify(getObject(arg0));
|
1032
|
+
return addHeapObject(ret);
|
1033
|
+
}, arguments);
|
1034
|
+
};
|
1035
|
+
imports.wbg.__wbindgen_debug_string = function (arg0, arg1) {
|
1036
|
+
const ret = debugString(getObject(arg1));
|
1037
|
+
const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
1038
|
+
const len0 = WASM_VECTOR_LEN;
|
1039
|
+
getInt32Memory0()[arg0 / 4 + 1] = len0;
|
1040
|
+
getInt32Memory0()[arg0 / 4 + 0] = ptr0;
|
1041
|
+
};
|
1042
|
+
imports.wbg.__wbindgen_throw = function (arg0, arg1) {
|
1043
|
+
throw new Error(getStringFromWasm0(arg0, arg1));
|
1044
|
+
};
|
1045
|
+
imports.wbg.__wbindgen_memory = function () {
|
1046
|
+
const ret = wasm.memory;
|
1047
|
+
return addHeapObject(ret);
|
1048
|
+
};
|
1049
|
+
imports.wbg.__wbindgen_closure_wrapper10902 = function (arg0, arg1, arg2) {
|
1050
|
+
const ret = makeMutClosure(arg0, arg1, 3717, __wbg_adapter_24);
|
1051
|
+
return addHeapObject(ret);
|
1052
|
+
};
|
1053
|
+
|
1054
|
+
if (
|
1055
|
+
typeof input === 'string' ||
|
1056
|
+
(typeof Request === 'function' && input instanceof Request) ||
|
1057
|
+
(typeof URL === 'function' && input instanceof URL)
|
1058
|
+
) {
|
1059
|
+
input = fetch(input);
|
1060
|
+
}
|
1061
|
+
|
1062
|
+
const { instance, module } = await load(await input, imports);
|
1063
|
+
|
1064
|
+
wasm = instance.exports;
|
1065
|
+
init.__wbindgen_wasm_module = module;
|
1066
|
+
|
1067
|
+
return wasm;
|
1068
|
+
}
|
1069
|
+
|
1070
|
+
export default init;
|