@worldcoin/idkit-core 4.0.11 → 4.0.13-dev.cd5a8f0

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.
Files changed (6) hide show
  1. package/dist/idkit_wasm_bg.wasm +0 -0
  2. package/dist/index.cjs +1340 -1295
  3. package/dist/index.d.cts +46 -42
  4. package/dist/index.d.ts +46 -42
  5. package/dist/index.js +1340 -1296
  6. package/package.json +1 -1
package/dist/index.js CHANGED
@@ -39,8 +39,9 @@ __export(idkit_wasm_exports, {
39
39
  RpSignature: () => RpSignature,
40
40
  base64Decode: () => base64Decode,
41
41
  base64Encode: () => base64Encode,
42
+ computeRpSignatureMessage: () => computeRpSignatureMessage,
42
43
  createSession: () => createSession,
43
- default: () => idkit_wasm_default,
44
+ default: () => __wbg_init,
44
45
  hashSignal: () => hashSignal,
45
46
  initSync: () => initSync,
46
47
  init_wasm: () => init_wasm,
@@ -48,383 +49,143 @@ __export(idkit_wasm_exports, {
48
49
  request: () => request,
49
50
  signRequest: () => signRequest
50
51
  });
51
- var wasm;
52
- var cachedUint8ArrayMemory0 = null;
53
- function getUint8ArrayMemory0() {
54
- if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
55
- cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
56
- }
57
- return cachedUint8ArrayMemory0;
58
- }
59
- var cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
60
- cachedTextDecoder.decode();
61
- var MAX_SAFARI_DECODE_BYTES = 2146435072;
62
- var numBytesDecoded = 0;
63
- function decodeText(ptr, len) {
64
- numBytesDecoded += len;
65
- if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
66
- cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
67
- cachedTextDecoder.decode();
68
- numBytesDecoded = len;
69
- }
70
- return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
71
- }
72
- function getStringFromWasm0(ptr, len) {
73
- ptr = ptr >>> 0;
74
- return decodeText(ptr, len);
75
- }
76
- var heap = new Array(128).fill(void 0);
77
- heap.push(void 0, null, true, false);
78
- var heap_next = heap.length;
79
- function addHeapObject(obj) {
80
- if (heap_next === heap.length) heap.push(heap.length + 1);
81
- const idx = heap_next;
82
- heap_next = heap[idx];
83
- heap[idx] = obj;
84
- return idx;
85
- }
86
- function getObject(idx) {
87
- return heap[idx];
88
- }
89
- var WASM_VECTOR_LEN = 0;
90
- var cachedTextEncoder = new TextEncoder();
91
- if (!("encodeInto" in cachedTextEncoder)) {
92
- cachedTextEncoder.encodeInto = function(arg, view) {
93
- const buf = cachedTextEncoder.encode(arg);
94
- view.set(buf);
95
- return {
96
- read: arg.length,
97
- written: buf.length
98
- };
99
- };
100
- }
101
- function passStringToWasm0(arg, malloc, realloc) {
102
- if (realloc === void 0) {
103
- const buf = cachedTextEncoder.encode(arg);
104
- const ptr2 = malloc(buf.length, 1) >>> 0;
105
- getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
106
- WASM_VECTOR_LEN = buf.length;
107
- return ptr2;
108
- }
109
- let len = arg.length;
110
- let ptr = malloc(len, 1) >>> 0;
111
- const mem = getUint8ArrayMemory0();
112
- let offset = 0;
113
- for (; offset < len; offset++) {
114
- const code = arg.charCodeAt(offset);
115
- if (code > 127) break;
116
- mem[ptr + offset] = code;
117
- }
118
- if (offset !== len) {
119
- if (offset !== 0) {
120
- arg = arg.slice(offset);
121
- }
122
- ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
123
- const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
124
- const ret = cachedTextEncoder.encodeInto(arg, view);
125
- offset += ret.written;
126
- ptr = realloc(ptr, len, offset, 1) >>> 0;
127
- }
128
- WASM_VECTOR_LEN = offset;
129
- return ptr;
130
- }
131
- var cachedDataViewMemory0 = null;
132
- function getDataViewMemory0() {
133
- if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm.memory.buffer) {
134
- cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
135
- }
136
- return cachedDataViewMemory0;
137
- }
138
- function isLikeNone(x) {
139
- return x === void 0 || x === null;
140
- }
141
- function debugString(val) {
142
- const type = typeof val;
143
- if (type == "number" || type == "boolean" || val == null) {
144
- return `${val}`;
52
+ var BridgeEncryption = class {
53
+ __destroy_into_raw() {
54
+ const ptr = this.__wbg_ptr;
55
+ this.__wbg_ptr = 0;
56
+ BridgeEncryptionFinalization.unregister(this);
57
+ return ptr;
145
58
  }
146
- if (type == "string") {
147
- return `"${val}"`;
59
+ free() {
60
+ const ptr = this.__destroy_into_raw();
61
+ wasm.__wbg_bridgeencryption_free(ptr, 0);
148
62
  }
149
- if (type == "symbol") {
150
- const description = val.description;
151
- if (description == null) {
152
- return "Symbol";
153
- } else {
154
- return `Symbol(${description})`;
63
+ /**
64
+ * Decrypts a base64-encoded ciphertext using AES-256-GCM
65
+ *
66
+ * # Errors
67
+ *
68
+ * Returns an error if decryption fails or the output is not valid UTF-8
69
+ * @param {string} ciphertext_base64
70
+ * @returns {string}
71
+ */
72
+ decrypt(ciphertext_base64) {
73
+ let deferred3_0;
74
+ let deferred3_1;
75
+ try {
76
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
77
+ const ptr0 = passStringToWasm0(ciphertext_base64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
78
+ const len0 = WASM_VECTOR_LEN;
79
+ wasm.bridgeencryption_decrypt(retptr, this.__wbg_ptr, ptr0, len0);
80
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
81
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
82
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
83
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
84
+ var ptr2 = r0;
85
+ var len2 = r1;
86
+ if (r3) {
87
+ ptr2 = 0;
88
+ len2 = 0;
89
+ throw takeObject(r2);
90
+ }
91
+ deferred3_0 = ptr2;
92
+ deferred3_1 = len2;
93
+ return getStringFromWasm0(ptr2, len2);
94
+ } finally {
95
+ wasm.__wbindgen_add_to_stack_pointer(16);
96
+ wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
155
97
  }
156
98
  }
157
- if (type == "function") {
158
- const name = val.name;
159
- if (typeof name == "string" && name.length > 0) {
160
- return `Function(${name})`;
161
- } else {
162
- return "Function";
99
+ /**
100
+ * Encrypts a plaintext string using AES-256-GCM and returns base64
101
+ *
102
+ * # Errors
103
+ *
104
+ * Returns an error if encryption fails
105
+ * @param {string} plaintext
106
+ * @returns {string}
107
+ */
108
+ encrypt(plaintext) {
109
+ let deferred3_0;
110
+ let deferred3_1;
111
+ try {
112
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
113
+ const ptr0 = passStringToWasm0(plaintext, wasm.__wbindgen_export, wasm.__wbindgen_export2);
114
+ const len0 = WASM_VECTOR_LEN;
115
+ wasm.bridgeencryption_encrypt(retptr, this.__wbg_ptr, ptr0, len0);
116
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
117
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
118
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
119
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
120
+ var ptr2 = r0;
121
+ var len2 = r1;
122
+ if (r3) {
123
+ ptr2 = 0;
124
+ len2 = 0;
125
+ throw takeObject(r2);
126
+ }
127
+ deferred3_0 = ptr2;
128
+ deferred3_1 = len2;
129
+ return getStringFromWasm0(ptr2, len2);
130
+ } finally {
131
+ wasm.__wbindgen_add_to_stack_pointer(16);
132
+ wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
163
133
  }
164
134
  }
165
- if (Array.isArray(val)) {
166
- const length = val.length;
167
- let debug = "[";
168
- if (length > 0) {
169
- debug += debugString(val[0]);
170
- }
171
- for (let i = 1; i < length; i++) {
172
- debug += ", " + debugString(val[i]);
135
+ /**
136
+ * Returns the key as a base64-encoded string
137
+ * @returns {string}
138
+ */
139
+ keyBase64() {
140
+ let deferred1_0;
141
+ let deferred1_1;
142
+ try {
143
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
144
+ wasm.bridgeencryption_keyBase64(retptr, this.__wbg_ptr);
145
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
146
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
147
+ deferred1_0 = r0;
148
+ deferred1_1 = r1;
149
+ return getStringFromWasm0(r0, r1);
150
+ } finally {
151
+ wasm.__wbindgen_add_to_stack_pointer(16);
152
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
173
153
  }
174
- debug += "]";
175
- return debug;
176
- }
177
- const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
178
- let className;
179
- if (builtInMatches && builtInMatches.length > 1) {
180
- className = builtInMatches[1];
181
- } else {
182
- return toString.call(val);
183
154
  }
184
- if (className == "Object") {
155
+ /**
156
+ * Creates a new `BridgeEncryption` instance with randomly generated key and nonce
157
+ *
158
+ * # Errors
159
+ *
160
+ * Returns an error if key generation fails
161
+ */
162
+ constructor() {
185
163
  try {
186
- return "Object(" + JSON.stringify(val) + ")";
187
- } catch (_) {
188
- return "Object";
164
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
165
+ wasm.bridgeencryption_new(retptr);
166
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
167
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
168
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
169
+ if (r2) {
170
+ throw takeObject(r1);
171
+ }
172
+ this.__wbg_ptr = r0 >>> 0;
173
+ BridgeEncryptionFinalization.register(this, this.__wbg_ptr, this);
174
+ return this;
175
+ } finally {
176
+ wasm.__wbindgen_add_to_stack_pointer(16);
189
177
  }
190
178
  }
191
- if (val instanceof Error) {
192
- return `${val.name}: ${val.message}
193
- ${val.stack}`;
194
- }
195
- return className;
196
- }
197
- function handleError(f, args) {
198
- try {
199
- return f.apply(this, args);
200
- } catch (e) {
201
- wasm.__wbindgen_export3(addHeapObject(e));
202
- }
203
- }
204
- function dropObject(idx) {
205
- if (idx < 132) return;
206
- heap[idx] = heap_next;
207
- heap_next = idx;
208
- }
209
- function takeObject(idx) {
210
- const ret = getObject(idx);
211
- dropObject(idx);
212
- return ret;
213
- }
214
- function getArrayU8FromWasm0(ptr, len) {
215
- ptr = ptr >>> 0;
216
- return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
217
- }
218
- var CLOSURE_DTORS = typeof FinalizationRegistry === "undefined" ? { register: () => {
219
- }, unregister: () => {
220
- } } : new FinalizationRegistry((state) => state.dtor(state.a, state.b));
221
- function makeMutClosure(arg0, arg1, dtor, f) {
222
- const state = { a: arg0, b: arg1, cnt: 1, dtor };
223
- const real = (...args) => {
224
- state.cnt++;
225
- const a = state.a;
226
- state.a = 0;
227
- try {
228
- return f(a, state.b, ...args);
229
- } finally {
230
- state.a = a;
231
- real._wbg_cb_unref();
232
- }
233
- };
234
- real._wbg_cb_unref = () => {
235
- if (--state.cnt === 0) {
236
- state.dtor(state.a, state.b);
237
- state.a = 0;
238
- CLOSURE_DTORS.unregister(state);
239
- }
240
- };
241
- CLOSURE_DTORS.register(real, state, state);
242
- return real;
243
- }
244
- function _assertClass(instance, klass) {
245
- if (!(instance instanceof klass)) {
246
- throw new Error(`expected instance of ${klass.name}`);
247
- }
248
- }
249
- function base64Decode(data) {
250
- try {
251
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
252
- const ptr0 = passStringToWasm0(data, wasm.__wbindgen_export, wasm.__wbindgen_export2);
253
- const len0 = WASM_VECTOR_LEN;
254
- wasm.base64Decode(retptr, ptr0, len0);
255
- var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
256
- var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
257
- var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
258
- var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
259
- if (r3) {
260
- throw takeObject(r2);
261
- }
262
- var v2 = getArrayU8FromWasm0(r0, r1).slice();
263
- wasm.__wbindgen_export4(r0, r1 * 1, 1);
264
- return v2;
265
- } finally {
266
- wasm.__wbindgen_add_to_stack_pointer(16);
267
- }
268
- }
269
- function proveSession(session_id, app_id, rp_context, action_description, bridge_url, override_connect_base_url, environment) {
270
- const ptr0 = passStringToWasm0(session_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
271
- const len0 = WASM_VECTOR_LEN;
272
- const ptr1 = passStringToWasm0(app_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
273
- const len1 = WASM_VECTOR_LEN;
274
- _assertClass(rp_context, RpContextWasm);
275
- var ptr2 = rp_context.__destroy_into_raw();
276
- var ptr3 = isLikeNone(action_description) ? 0 : passStringToWasm0(action_description, wasm.__wbindgen_export, wasm.__wbindgen_export2);
277
- var len3 = WASM_VECTOR_LEN;
278
- var ptr4 = isLikeNone(bridge_url) ? 0 : passStringToWasm0(bridge_url, wasm.__wbindgen_export, wasm.__wbindgen_export2);
279
- var len4 = WASM_VECTOR_LEN;
280
- var ptr5 = isLikeNone(override_connect_base_url) ? 0 : passStringToWasm0(override_connect_base_url, wasm.__wbindgen_export, wasm.__wbindgen_export2);
281
- var len5 = WASM_VECTOR_LEN;
282
- var ptr6 = isLikeNone(environment) ? 0 : passStringToWasm0(environment, wasm.__wbindgen_export, wasm.__wbindgen_export2);
283
- var len6 = WASM_VECTOR_LEN;
284
- const ret = wasm.idkitbuilder_forProveSession(ptr0, len0, ptr1, len1, ptr2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6);
285
- return IDKitBuilder.__wrap(ret);
286
- }
287
- function createSession(app_id, rp_context, action_description, bridge_url, override_connect_base_url, environment) {
288
- const ptr0 = passStringToWasm0(app_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
289
- const len0 = WASM_VECTOR_LEN;
290
- _assertClass(rp_context, RpContextWasm);
291
- var ptr1 = rp_context.__destroy_into_raw();
292
- var ptr2 = isLikeNone(action_description) ? 0 : passStringToWasm0(action_description, wasm.__wbindgen_export, wasm.__wbindgen_export2);
293
- var len2 = WASM_VECTOR_LEN;
294
- var ptr3 = isLikeNone(bridge_url) ? 0 : passStringToWasm0(bridge_url, wasm.__wbindgen_export, wasm.__wbindgen_export2);
295
- var len3 = WASM_VECTOR_LEN;
296
- var ptr4 = isLikeNone(override_connect_base_url) ? 0 : passStringToWasm0(override_connect_base_url, wasm.__wbindgen_export, wasm.__wbindgen_export2);
297
- var len4 = WASM_VECTOR_LEN;
298
- var ptr5 = isLikeNone(environment) ? 0 : passStringToWasm0(environment, wasm.__wbindgen_export, wasm.__wbindgen_export2);
299
- var len5 = WASM_VECTOR_LEN;
300
- const ret = wasm.createSession(ptr0, len0, ptr1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5);
301
- return IDKitBuilder.__wrap(ret);
302
- }
303
- function passArray8ToWasm0(arg, malloc) {
304
- const ptr = malloc(arg.length * 1, 1) >>> 0;
305
- getUint8ArrayMemory0().set(arg, ptr / 1);
306
- WASM_VECTOR_LEN = arg.length;
307
- return ptr;
308
- }
309
- function base64Encode(data) {
310
- let deferred2_0;
311
- let deferred2_1;
312
- try {
313
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
314
- const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
315
- const len0 = WASM_VECTOR_LEN;
316
- wasm.base64Encode(retptr, ptr0, len0);
317
- var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
318
- var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
319
- deferred2_0 = r0;
320
- deferred2_1 = r1;
321
- return getStringFromWasm0(r0, r1);
322
- } finally {
323
- wasm.__wbindgen_add_to_stack_pointer(16);
324
- wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
325
- }
326
- }
327
- function request(app_id, action, rp_context, action_description, bridge_url, allow_legacy_proofs, override_connect_base_url, environment) {
328
- const ptr0 = passStringToWasm0(app_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
329
- const len0 = WASM_VECTOR_LEN;
330
- const ptr1 = passStringToWasm0(action, wasm.__wbindgen_export, wasm.__wbindgen_export2);
331
- const len1 = WASM_VECTOR_LEN;
332
- _assertClass(rp_context, RpContextWasm);
333
- var ptr2 = rp_context.__destroy_into_raw();
334
- var ptr3 = isLikeNone(action_description) ? 0 : passStringToWasm0(action_description, wasm.__wbindgen_export, wasm.__wbindgen_export2);
335
- var len3 = WASM_VECTOR_LEN;
336
- var ptr4 = isLikeNone(bridge_url) ? 0 : passStringToWasm0(bridge_url, wasm.__wbindgen_export, wasm.__wbindgen_export2);
337
- var len4 = WASM_VECTOR_LEN;
338
- var ptr5 = isLikeNone(override_connect_base_url) ? 0 : passStringToWasm0(override_connect_base_url, wasm.__wbindgen_export, wasm.__wbindgen_export2);
339
- var len5 = WASM_VECTOR_LEN;
340
- var ptr6 = isLikeNone(environment) ? 0 : passStringToWasm0(environment, wasm.__wbindgen_export, wasm.__wbindgen_export2);
341
- var len6 = WASM_VECTOR_LEN;
342
- const ret = wasm.idkitbuilder_new(ptr0, len0, ptr1, len1, ptr2, ptr3, len3, ptr4, len4, allow_legacy_proofs, ptr5, len5, ptr6, len6);
343
- return IDKitBuilder.__wrap(ret);
344
- }
345
- function hashSignal(signal) {
346
- let deferred2_0;
347
- let deferred2_1;
348
- try {
349
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
350
- wasm.hashSignal(retptr, addHeapObject(signal));
351
- var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
352
- var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
353
- var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
354
- var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
355
- var ptr1 = r0;
356
- var len1 = r1;
357
- if (r3) {
358
- ptr1 = 0;
359
- len1 = 0;
360
- throw takeObject(r2);
361
- }
362
- deferred2_0 = ptr1;
363
- deferred2_1 = len1;
364
- return getStringFromWasm0(ptr1, len1);
365
- } finally {
366
- wasm.__wbindgen_add_to_stack_pointer(16);
367
- wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
368
- }
369
- }
370
- function init_wasm() {
371
- wasm.init_wasm();
372
- }
373
- function signRequest(action, signing_key_hex, ttl_seconds) {
374
- try {
375
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
376
- const ptr0 = passStringToWasm0(action, wasm.__wbindgen_export, wasm.__wbindgen_export2);
377
- const len0 = WASM_VECTOR_LEN;
378
- const ptr1 = passStringToWasm0(signing_key_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
379
- const len1 = WASM_VECTOR_LEN;
380
- wasm.signRequest(retptr, ptr0, len0, ptr1, len1, !isLikeNone(ttl_seconds), isLikeNone(ttl_seconds) ? BigInt(0) : ttl_seconds);
381
- var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
382
- var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
383
- var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
384
- if (r2) {
385
- throw takeObject(r1);
386
- }
387
- return RpSignature.__wrap(r0);
388
- } finally {
389
- wasm.__wbindgen_add_to_stack_pointer(16);
390
- }
391
- }
392
- function __wasm_bindgen_func_elem_619(arg0, arg1) {
393
- wasm.__wasm_bindgen_func_elem_619(arg0, arg1);
394
- }
395
- function __wasm_bindgen_func_elem_982(arg0, arg1, arg2) {
396
- wasm.__wasm_bindgen_func_elem_982(arg0, arg1, addHeapObject(arg2));
397
- }
398
- function __wasm_bindgen_func_elem_1367(arg0, arg1, arg2, arg3) {
399
- wasm.__wasm_bindgen_func_elem_1367(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
400
- }
401
- var __wbindgen_enum_RequestCache = ["default", "no-store", "reload", "no-cache", "force-cache", "only-if-cached"];
402
- var __wbindgen_enum_RequestCredentials = ["omit", "same-origin", "include"];
403
- var __wbindgen_enum_RequestMode = ["same-origin", "no-cors", "cors", "navigate"];
404
- var BridgeEncryptionFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
405
- }, unregister: () => {
406
- } } : new FinalizationRegistry((ptr) => wasm.__wbg_bridgeencryption_free(ptr >>> 0, 1));
407
- var BridgeEncryption = class {
408
- __destroy_into_raw() {
409
- const ptr = this.__wbg_ptr;
410
- this.__wbg_ptr = 0;
411
- BridgeEncryptionFinalization.unregister(this);
412
- return ptr;
413
- }
414
- free() {
415
- const ptr = this.__destroy_into_raw();
416
- wasm.__wbg_bridgeencryption_free(ptr, 0);
417
- }
418
179
  /**
419
- * Returns the key as a base64-encoded string
180
+ * Returns the nonce as a base64-encoded string
420
181
  * @returns {string}
421
182
  */
422
- keyBase64() {
183
+ nonceBase64() {
423
184
  let deferred1_0;
424
185
  let deferred1_1;
425
186
  try {
426
187
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
427
- wasm.bridgeencryption_keyBase64(retptr, this.__wbg_ptr);
188
+ wasm.bridgeencryption_nonceBase64(retptr, this.__wbg_ptr);
428
189
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
429
190
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
430
191
  deferred1_0 = r0;
@@ -435,37 +196,73 @@ var BridgeEncryption = class {
435
196
  wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
436
197
  }
437
198
  }
199
+ };
200
+ if (Symbol.dispose) BridgeEncryption.prototype[Symbol.dispose] = BridgeEncryption.prototype.free;
201
+ var CredentialRequestWasm = class _CredentialRequestWasm {
202
+ static __wrap(ptr) {
203
+ ptr = ptr >>> 0;
204
+ const obj = Object.create(_CredentialRequestWasm.prototype);
205
+ obj.__wbg_ptr = ptr;
206
+ CredentialRequestWasmFinalization.register(obj, obj.__wbg_ptr, obj);
207
+ return obj;
208
+ }
209
+ __destroy_into_raw() {
210
+ const ptr = this.__wbg_ptr;
211
+ this.__wbg_ptr = 0;
212
+ CredentialRequestWasmFinalization.unregister(this);
213
+ return ptr;
214
+ }
215
+ free() {
216
+ const ptr = this.__destroy_into_raw();
217
+ wasm.__wbg_credentialrequestwasm_free(ptr, 0);
218
+ }
438
219
  /**
439
- * Returns the nonce as a base64-encoded string
440
- * @returns {string}
220
+ * Gets the credential type
221
+ * @returns {any}
441
222
  */
442
- nonceBase64() {
443
- let deferred1_0;
444
- let deferred1_1;
223
+ credentialType() {
224
+ const ret = wasm.credentialrequestwasm_credentialType(this.__wbg_ptr);
225
+ return takeObject(ret);
226
+ }
227
+ /**
228
+ * Gets the signal as raw bytes
229
+ * @returns {Uint8Array | undefined}
230
+ */
231
+ getSignalBytes() {
445
232
  try {
446
233
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
447
- wasm.bridgeencryption_nonceBase64(retptr, this.__wbg_ptr);
234
+ wasm.credentialrequestwasm_getSignalBytes(retptr, this.__wbg_ptr);
448
235
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
449
236
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
450
- deferred1_0 = r0;
451
- deferred1_1 = r1;
452
- return getStringFromWasm0(r0, r1);
237
+ let v1;
238
+ if (r0 !== 0) {
239
+ v1 = getArrayU8FromWasm0(r0, r1).slice();
240
+ wasm.__wbindgen_export4(r0, r1 * 1, 1);
241
+ }
242
+ return v1;
453
243
  } finally {
454
244
  wasm.__wbindgen_add_to_stack_pointer(16);
455
- wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
456
245
  }
457
246
  }
458
247
  /**
459
- * Creates a new `BridgeEncryption` instance with randomly generated key and nonce
248
+ * Creates a new request item
249
+ *
250
+ * # Arguments
251
+ * * `credential_type` - The type of credential to request (e.g., `proof_of_human`, `face`)
252
+ * * `signal` - Optional signal string
460
253
  *
461
254
  * # Errors
462
255
  *
463
- * Returns an error if key generation fails
256
+ * Returns an error if the credential type is invalid
257
+ * @param {any} credential_type
258
+ * @param {string | null} [signal]
464
259
  */
465
- constructor() {
260
+ constructor(credential_type, signal) {
466
261
  try {
467
262
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
468
- wasm.bridgeencryption_new(retptr);
263
+ var ptr0 = isLikeNone(signal) ? 0 : passStringToWasm0(signal, wasm.__wbindgen_export, wasm.__wbindgen_export2);
264
+ var len0 = WASM_VECTOR_LEN;
265
+ wasm.credentialrequestwasm_new(retptr, addHeapObject(credential_type), ptr0, len0);
469
266
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
470
267
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
471
268
  var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -473,107 +270,35 @@ var BridgeEncryption = class {
473
270
  throw takeObject(r1);
474
271
  }
475
272
  this.__wbg_ptr = r0 >>> 0;
476
- BridgeEncryptionFinalization.register(this, this.__wbg_ptr, this);
273
+ CredentialRequestWasmFinalization.register(this, this.__wbg_ptr, this);
477
274
  return this;
478
275
  } finally {
479
276
  wasm.__wbindgen_add_to_stack_pointer(16);
480
277
  }
481
278
  }
482
279
  /**
483
- * Decrypts a base64-encoded ciphertext using AES-256-GCM
484
- *
485
- * # Errors
486
- *
487
- * Returns an error if decryption fails or the output is not valid UTF-8
488
- * @param {string} ciphertext_base64
489
- * @returns {string}
490
- */
491
- decrypt(ciphertext_base64) {
492
- let deferred3_0;
493
- let deferred3_1;
494
- try {
495
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
496
- const ptr0 = passStringToWasm0(ciphertext_base64, wasm.__wbindgen_export, wasm.__wbindgen_export2);
497
- const len0 = WASM_VECTOR_LEN;
498
- wasm.bridgeencryption_decrypt(retptr, this.__wbg_ptr, ptr0, len0);
499
- var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
500
- var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
501
- var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
502
- var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
503
- var ptr2 = r0;
504
- var len2 = r1;
505
- if (r3) {
506
- ptr2 = 0;
507
- len2 = 0;
508
- throw takeObject(r2);
509
- }
510
- deferred3_0 = ptr2;
511
- deferred3_1 = len2;
512
- return getStringFromWasm0(ptr2, len2);
513
- } finally {
514
- wasm.__wbindgen_add_to_stack_pointer(16);
515
- wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
516
- }
517
- }
518
- /**
519
- * Encrypts a plaintext string using AES-256-GCM and returns base64
280
+ * Converts the request item to JSON
520
281
  *
521
282
  * # Errors
522
283
  *
523
- * Returns an error if encryption fails
524
- * @param {string} plaintext
525
- * @returns {string}
284
+ * Returns an error if serialization fails
285
+ * @returns {any}
526
286
  */
527
- encrypt(plaintext) {
528
- let deferred3_0;
529
- let deferred3_1;
287
+ toJSON() {
530
288
  try {
531
289
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
532
- const ptr0 = passStringToWasm0(plaintext, wasm.__wbindgen_export, wasm.__wbindgen_export2);
533
- const len0 = WASM_VECTOR_LEN;
534
- wasm.bridgeencryption_encrypt(retptr, this.__wbg_ptr, ptr0, len0);
290
+ wasm.credentialrequestwasm_toJSON(retptr, this.__wbg_ptr);
535
291
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
536
292
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
537
293
  var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
538
- var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
539
- var ptr2 = r0;
540
- var len2 = r1;
541
- if (r3) {
542
- ptr2 = 0;
543
- len2 = 0;
544
- throw takeObject(r2);
294
+ if (r2) {
295
+ throw takeObject(r1);
545
296
  }
546
- deferred3_0 = ptr2;
547
- deferred3_1 = len2;
548
- return getStringFromWasm0(ptr2, len2);
297
+ return takeObject(r0);
549
298
  } finally {
550
299
  wasm.__wbindgen_add_to_stack_pointer(16);
551
- wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
552
300
  }
553
301
  }
554
- };
555
- if (Symbol.dispose) BridgeEncryption.prototype[Symbol.dispose] = BridgeEncryption.prototype.free;
556
- var CredentialRequestWasmFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
557
- }, unregister: () => {
558
- } } : new FinalizationRegistry((ptr) => wasm.__wbg_credentialrequestwasm_free(ptr >>> 0, 1));
559
- var CredentialRequestWasm = class _CredentialRequestWasm {
560
- static __wrap(ptr) {
561
- ptr = ptr >>> 0;
562
- const obj = Object.create(_CredentialRequestWasm.prototype);
563
- obj.__wbg_ptr = ptr;
564
- CredentialRequestWasmFinalization.register(obj, obj.__wbg_ptr, obj);
565
- return obj;
566
- }
567
- __destroy_into_raw() {
568
- const ptr = this.__wbg_ptr;
569
- this.__wbg_ptr = 0;
570
- CredentialRequestWasmFinalization.unregister(this);
571
- return ptr;
572
- }
573
- free() {
574
- const ptr = this.__destroy_into_raw();
575
- wasm.__wbg_credentialrequestwasm_free(ptr, 0);
576
- }
577
302
  /**
578
303
  * Creates a new request item with raw bytes for the signal
579
304
  *
@@ -601,62 +326,6 @@ var CredentialRequestWasm = class _CredentialRequestWasm {
601
326
  wasm.__wbindgen_add_to_stack_pointer(16);
602
327
  }
603
328
  }
604
- /**
605
- * Gets the credential type
606
- * @returns {any}
607
- */
608
- credentialType() {
609
- const ret = wasm.credentialrequestwasm_credentialType(this.__wbg_ptr);
610
- return takeObject(ret);
611
- }
612
- /**
613
- * Gets the signal as raw bytes
614
- * @returns {Uint8Array | undefined}
615
- */
616
- getSignalBytes() {
617
- try {
618
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
619
- wasm.credentialrequestwasm_getSignalBytes(retptr, this.__wbg_ptr);
620
- var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
621
- var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
622
- let v1;
623
- if (r0 !== 0) {
624
- v1 = getArrayU8FromWasm0(r0, r1).slice();
625
- wasm.__wbindgen_export4(r0, r1 * 1, 1);
626
- }
627
- return v1;
628
- } finally {
629
- wasm.__wbindgen_add_to_stack_pointer(16);
630
- }
631
- }
632
- /**
633
- * Creates a new request item with genesis minimum timestamp
634
- *
635
- * # Errors
636
- *
637
- * Returns an error if the credential type is invalid
638
- * @param {any} credential_type
639
- * @param {string | null | undefined} signal
640
- * @param {bigint} genesis_min
641
- * @returns {CredentialRequestWasm}
642
- */
643
- static withGenesisMin(credential_type, signal, genesis_min) {
644
- try {
645
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
646
- var ptr0 = isLikeNone(signal) ? 0 : passStringToWasm0(signal, wasm.__wbindgen_export, wasm.__wbindgen_export2);
647
- var len0 = WASM_VECTOR_LEN;
648
- wasm.credentialrequestwasm_withGenesisMin(retptr, addHeapObject(credential_type), ptr0, len0, genesis_min);
649
- var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
650
- var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
651
- var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
652
- if (r2) {
653
- throw takeObject(r1);
654
- }
655
- return _CredentialRequestWasm.__wrap(r0);
656
- } finally {
657
- wasm.__wbindgen_add_to_stack_pointer(16);
658
- }
659
- }
660
329
  /**
661
330
  * Creates a new request item with expiration minimum timestamp
662
331
  *
@@ -686,65 +355,35 @@ var CredentialRequestWasm = class _CredentialRequestWasm {
686
355
  }
687
356
  }
688
357
  /**
689
- * Creates a new request item
690
- *
691
- * # Arguments
692
- * * `credential_type` - The type of credential to request (e.g., "orb", "face")
693
- * * `signal` - Optional signal string
358
+ * Creates a new request item with genesis minimum timestamp
694
359
  *
695
360
  * # Errors
696
361
  *
697
362
  * Returns an error if the credential type is invalid
698
363
  * @param {any} credential_type
699
- * @param {string | null} [signal]
364
+ * @param {string | null | undefined} signal
365
+ * @param {bigint} genesis_min
366
+ * @returns {CredentialRequestWasm}
700
367
  */
701
- constructor(credential_type, signal) {
368
+ static withGenesisMin(credential_type, signal, genesis_min) {
702
369
  try {
703
370
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
704
371
  var ptr0 = isLikeNone(signal) ? 0 : passStringToWasm0(signal, wasm.__wbindgen_export, wasm.__wbindgen_export2);
705
372
  var len0 = WASM_VECTOR_LEN;
706
- wasm.credentialrequestwasm_new(retptr, addHeapObject(credential_type), ptr0, len0);
707
- var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
708
- var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
709
- var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
710
- if (r2) {
711
- throw takeObject(r1);
712
- }
713
- this.__wbg_ptr = r0 >>> 0;
714
- CredentialRequestWasmFinalization.register(this, this.__wbg_ptr, this);
715
- return this;
716
- } finally {
717
- wasm.__wbindgen_add_to_stack_pointer(16);
718
- }
719
- }
720
- /**
721
- * Converts the request item to JSON
722
- *
723
- * # Errors
724
- *
725
- * Returns an error if serialization fails
726
- * @returns {any}
727
- */
728
- toJSON() {
729
- try {
730
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
731
- wasm.credentialrequestwasm_toJSON(retptr, this.__wbg_ptr);
373
+ wasm.credentialrequestwasm_withGenesisMin(retptr, addHeapObject(credential_type), ptr0, len0, genesis_min);
732
374
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
733
375
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
734
376
  var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
735
377
  if (r2) {
736
378
  throw takeObject(r1);
737
379
  }
738
- return takeObject(r0);
380
+ return _CredentialRequestWasm.__wrap(r0);
739
381
  } finally {
740
382
  wasm.__wbindgen_add_to_stack_pointer(16);
741
383
  }
742
384
  }
743
385
  };
744
386
  if (Symbol.dispose) CredentialRequestWasm.prototype[Symbol.dispose] = CredentialRequestWasm.prototype.free;
745
- var IDKitBuilderFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
746
- }, unregister: () => {
747
- } } : new FinalizationRegistry((ptr) => wasm.__wbg_idkitbuilder_free(ptr >>> 0, 1));
748
387
  var IDKitBuilder = class _IDKitBuilder {
749
388
  static __wrap(ptr) {
750
389
  ptr = ptr >>> 0;
@@ -774,32 +413,30 @@ var IDKitBuilder = class _IDKitBuilder {
774
413
  return takeObject(ret);
775
414
  }
776
415
  /**
777
- * Builds the native payload for constraints (synchronous, no bridge connection).
778
- *
779
- * Used by the native transport to get the same payload format as the bridge
780
- * without creating a network connection.
781
- *
782
- * # Errors
783
- *
784
- * Returns an error if constraints are invalid or payload construction fails.
785
- * @param {any} constraints_json
786
- * @returns {any}
416
+ * Creates a new builder for creating a new session
417
+ * @param {string} app_id
418
+ * @param {RpContextWasm} rp_context
419
+ * @param {string | null} [action_description]
420
+ * @param {string | null} [bridge_url]
421
+ * @param {string | null} [override_connect_base_url]
422
+ * @param {string | null} [environment]
423
+ * @returns {IDKitBuilder}
787
424
  */
788
- nativePayload(constraints_json) {
789
- try {
790
- const ptr = this.__destroy_into_raw();
791
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
792
- wasm.idkitbuilder_nativePayload(retptr, ptr, addHeapObject(constraints_json));
793
- var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
794
- var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
795
- var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
796
- if (r2) {
797
- throw takeObject(r1);
798
- }
799
- return takeObject(r0);
800
- } finally {
801
- wasm.__wbindgen_add_to_stack_pointer(16);
802
- }
425
+ static forCreateSession(app_id, rp_context, action_description, bridge_url, override_connect_base_url, environment) {
426
+ const ptr0 = passStringToWasm0(app_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
427
+ const len0 = WASM_VECTOR_LEN;
428
+ _assertClass(rp_context, RpContextWasm);
429
+ var ptr1 = rp_context.__destroy_into_raw();
430
+ var ptr2 = isLikeNone(action_description) ? 0 : passStringToWasm0(action_description, wasm.__wbindgen_export, wasm.__wbindgen_export2);
431
+ var len2 = WASM_VECTOR_LEN;
432
+ var ptr3 = isLikeNone(bridge_url) ? 0 : passStringToWasm0(bridge_url, wasm.__wbindgen_export, wasm.__wbindgen_export2);
433
+ var len3 = WASM_VECTOR_LEN;
434
+ var ptr4 = isLikeNone(override_connect_base_url) ? 0 : passStringToWasm0(override_connect_base_url, wasm.__wbindgen_export, wasm.__wbindgen_export2);
435
+ var len4 = WASM_VECTOR_LEN;
436
+ var ptr5 = isLikeNone(environment) ? 0 : passStringToWasm0(environment, wasm.__wbindgen_export, wasm.__wbindgen_export2);
437
+ var len5 = WASM_VECTOR_LEN;
438
+ const ret = wasm.idkitbuilder_forCreateSession(ptr0, len0, ptr1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5);
439
+ return _IDKitBuilder.__wrap(ret);
803
440
  }
804
441
  /**
805
442
  * Creates a new builder for proving an existing session
@@ -831,30 +468,32 @@ var IDKitBuilder = class _IDKitBuilder {
831
468
  return _IDKitBuilder.__wrap(ret);
832
469
  }
833
470
  /**
834
- * Creates a new builder for creating a new session
835
- * @param {string} app_id
836
- * @param {RpContextWasm} rp_context
837
- * @param {string | null} [action_description]
838
- * @param {string | null} [bridge_url]
839
- * @param {string | null} [override_connect_base_url]
840
- * @param {string | null} [environment]
841
- * @returns {IDKitBuilder}
471
+ * Builds the native payload for constraints (synchronous, no bridge connection).
472
+ *
473
+ * Used by the native transport to get the same payload format as the bridge
474
+ * without creating a network connection.
475
+ *
476
+ * # Errors
477
+ *
478
+ * Returns an error if constraints are invalid or payload construction fails.
479
+ * @param {any} constraints_json
480
+ * @returns {any}
842
481
  */
843
- static forCreateSession(app_id, rp_context, action_description, bridge_url, override_connect_base_url, environment) {
844
- const ptr0 = passStringToWasm0(app_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
845
- const len0 = WASM_VECTOR_LEN;
846
- _assertClass(rp_context, RpContextWasm);
847
- var ptr1 = rp_context.__destroy_into_raw();
848
- var ptr2 = isLikeNone(action_description) ? 0 : passStringToWasm0(action_description, wasm.__wbindgen_export, wasm.__wbindgen_export2);
849
- var len2 = WASM_VECTOR_LEN;
850
- var ptr3 = isLikeNone(bridge_url) ? 0 : passStringToWasm0(bridge_url, wasm.__wbindgen_export, wasm.__wbindgen_export2);
851
- var len3 = WASM_VECTOR_LEN;
852
- var ptr4 = isLikeNone(override_connect_base_url) ? 0 : passStringToWasm0(override_connect_base_url, wasm.__wbindgen_export, wasm.__wbindgen_export2);
853
- var len4 = WASM_VECTOR_LEN;
854
- var ptr5 = isLikeNone(environment) ? 0 : passStringToWasm0(environment, wasm.__wbindgen_export, wasm.__wbindgen_export2);
855
- var len5 = WASM_VECTOR_LEN;
856
- const ret = wasm.createSession(ptr0, len0, ptr1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5);
857
- return _IDKitBuilder.__wrap(ret);
482
+ nativePayload(constraints_json) {
483
+ try {
484
+ const ptr = this.__destroy_into_raw();
485
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
486
+ wasm.idkitbuilder_nativePayload(retptr, ptr, addHeapObject(constraints_json));
487
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
488
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
489
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
490
+ if (r2) {
491
+ throw takeObject(r1);
492
+ }
493
+ return takeObject(r0);
494
+ } finally {
495
+ wasm.__wbindgen_add_to_stack_pointer(16);
496
+ }
858
497
  }
859
498
  /**
860
499
  * Builds the native payload from a preset (synchronous, no bridge connection).
@@ -956,9 +595,6 @@ var IDKitBuilder = class _IDKitBuilder {
956
595
  }
957
596
  };
958
597
  if (Symbol.dispose) IDKitBuilder.prototype[Symbol.dispose] = IDKitBuilder.prototype.free;
959
- var IDKitProofFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
960
- }, unregister: () => {
961
- } } : new FinalizationRegistry((ptr) => wasm.__wbg_idkitproof_free(ptr >>> 0, 1));
962
598
  var IDKitProof = class {
963
599
  __destroy_into_raw() {
964
600
  const ptr = this.__wbg_ptr;
@@ -1029,9 +665,6 @@ var IDKitProof = class {
1029
665
  }
1030
666
  };
1031
667
  if (Symbol.dispose) IDKitProof.prototype[Symbol.dispose] = IDKitProof.prototype.free;
1032
- var IDKitRequestFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
1033
- }, unregister: () => {
1034
- } } : new FinalizationRegistry((ptr) => wasm.__wbg_idkitrequest_free(ptr >>> 0, 1));
1035
668
  var IDKitRequest = class _IDKitRequest {
1036
669
  static __wrap(ptr) {
1037
670
  ptr = ptr >>> 0;
@@ -1051,19 +684,21 @@ var IDKitRequest = class _IDKitRequest {
1051
684
  wasm.__wbg_idkitrequest_free(ptr, 0);
1052
685
  }
1053
686
  /**
1054
- * Returns the request ID for this request
687
+ * Returns the connect URL for World App
688
+ *
689
+ * This URL should be displayed as a QR code for users to scan with World App.
1055
690
  *
1056
691
  * # Errors
1057
692
  *
1058
693
  * Returns an error if the request has been closed
1059
694
  * @returns {string}
1060
695
  */
1061
- requestId() {
696
+ connectUrl() {
1062
697
  let deferred2_0;
1063
698
  let deferred2_1;
1064
699
  try {
1065
700
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1066
- wasm.idkitrequest_requestId(retptr, this.__wbg_ptr);
701
+ wasm.idkitrequest_connectUrl(retptr, this.__wbg_ptr);
1067
702
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1068
703
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1069
704
  var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -1084,21 +719,37 @@ var IDKitRequest = class _IDKitRequest {
1084
719
  }
1085
720
  }
1086
721
  /**
1087
- * Returns the connect URL for World App
722
+ * Polls the bridge for the current status (non-blocking)
1088
723
  *
1089
- * This URL should be displayed as a QR code for users to scan with World App.
724
+ * Returns a status object with type:
725
+ * - `"waiting_for_connection"` - Waiting for World App to retrieve the request
726
+ * - `"awaiting_confirmation"` - World App has retrieved the request, waiting for user
727
+ * - `"confirmed"` - User confirmed and provided a proof
728
+ * - `"failed"` - Request has failed
729
+ *
730
+ * # Errors
731
+ *
732
+ * Returns an error if the request fails or the response is invalid
733
+ * @returns {Promise<any>}
734
+ */
735
+ pollForStatus() {
736
+ const ret = wasm.idkitrequest_pollForStatus(this.__wbg_ptr);
737
+ return takeObject(ret);
738
+ }
739
+ /**
740
+ * Returns the request ID for this request
1090
741
  *
1091
742
  * # Errors
1092
743
  *
1093
744
  * Returns an error if the request has been closed
1094
745
  * @returns {string}
1095
746
  */
1096
- connectUrl() {
747
+ requestId() {
1097
748
  let deferred2_0;
1098
749
  let deferred2_1;
1099
750
  try {
1100
751
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1101
- wasm.idkitrequest_connectUrl(retptr, this.__wbg_ptr);
752
+ wasm.idkitrequest_requestId(retptr, this.__wbg_ptr);
1102
753
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1103
754
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1104
755
  var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -1118,194 +769,1092 @@ var IDKitRequest = class _IDKitRequest {
1118
769
  wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
1119
770
  }
1120
771
  }
772
+ };
773
+ if (Symbol.dispose) IDKitRequest.prototype[Symbol.dispose] = IDKitRequest.prototype.free;
774
+ var RpContextWasm = class {
775
+ __destroy_into_raw() {
776
+ const ptr = this.__wbg_ptr;
777
+ this.__wbg_ptr = 0;
778
+ RpContextWasmFinalization.unregister(this);
779
+ return ptr;
780
+ }
781
+ free() {
782
+ const ptr = this.__destroy_into_raw();
783
+ wasm.__wbg_rpcontextwasm_free(ptr, 0);
784
+ }
1121
785
  /**
1122
- * Polls the bridge for the current status (non-blocking)
786
+ * Creates a new RP context
1123
787
  *
1124
- * Returns a status object with type:
1125
- * - `"waiting_for_connection"` - Waiting for World App to retrieve the request
1126
- * - `"awaiting_confirmation"` - World App has retrieved the request, waiting for user
1127
- * - `"confirmed"` - User confirmed and provided a proof
1128
- * - `"failed"` - Request has failed
788
+ * # Arguments
789
+ * * `rp_id` - The registered RP ID (e.g., `"rp_123456789abcdef0"`)
790
+ * * `nonce` - Unique nonce for this proof request
791
+ * * `created_at` - Unix timestamp (seconds since epoch) when created
792
+ * * `expires_at` - Unix timestamp (seconds since epoch) when expires
793
+ * * `signature` - The RP's ECDSA signature of the `nonce` and `created_at` timestamp
1129
794
  *
1130
795
  * # Errors
1131
796
  *
1132
- * Returns an error if the request fails or the response is invalid
1133
- * @returns {Promise<any>}
797
+ * Returns an error if `rp_id` is not a valid RP ID (must start with `rp_`)
798
+ * @param {string} rp_id
799
+ * @param {string} nonce
800
+ * @param {bigint} created_at
801
+ * @param {bigint} expires_at
802
+ * @param {string} signature
1134
803
  */
1135
- pollForStatus() {
1136
- const ret = wasm.idkitrequest_pollForStatus(this.__wbg_ptr);
1137
- return takeObject(ret);
804
+ constructor(rp_id, nonce, created_at, expires_at, signature) {
805
+ try {
806
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
807
+ const ptr0 = passStringToWasm0(rp_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
808
+ const len0 = WASM_VECTOR_LEN;
809
+ const ptr1 = passStringToWasm0(nonce, wasm.__wbindgen_export, wasm.__wbindgen_export2);
810
+ const len1 = WASM_VECTOR_LEN;
811
+ const ptr2 = passStringToWasm0(signature, wasm.__wbindgen_export, wasm.__wbindgen_export2);
812
+ const len2 = WASM_VECTOR_LEN;
813
+ wasm.rpcontextwasm_new(retptr, ptr0, len0, ptr1, len1, created_at, expires_at, ptr2, len2);
814
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
815
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
816
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
817
+ if (r2) {
818
+ throw takeObject(r1);
819
+ }
820
+ this.__wbg_ptr = r0 >>> 0;
821
+ RpContextWasmFinalization.register(this, this.__wbg_ptr, this);
822
+ return this;
823
+ } finally {
824
+ wasm.__wbindgen_add_to_stack_pointer(16);
825
+ }
826
+ }
827
+ };
828
+ if (Symbol.dispose) RpContextWasm.prototype[Symbol.dispose] = RpContextWasm.prototype.free;
829
+ var RpSignature = class _RpSignature {
830
+ static __wrap(ptr) {
831
+ ptr = ptr >>> 0;
832
+ const obj = Object.create(_RpSignature.prototype);
833
+ obj.__wbg_ptr = ptr;
834
+ RpSignatureFinalization.register(obj, obj.__wbg_ptr, obj);
835
+ return obj;
836
+ }
837
+ __destroy_into_raw() {
838
+ const ptr = this.__wbg_ptr;
839
+ this.__wbg_ptr = 0;
840
+ RpSignatureFinalization.unregister(this);
841
+ return ptr;
842
+ }
843
+ free() {
844
+ const ptr = this.__destroy_into_raw();
845
+ wasm.__wbg_rpsignature_free(ptr, 0);
846
+ }
847
+ /**
848
+ * Gets the creation timestamp
849
+ * @returns {bigint}
850
+ */
851
+ get createdAt() {
852
+ const ret = wasm.rpsignature_createdAt(this.__wbg_ptr);
853
+ return BigInt.asUintN(64, ret);
854
+ }
855
+ /**
856
+ * Gets the expiration timestamp
857
+ * @returns {bigint}
858
+ */
859
+ get expiresAt() {
860
+ const ret = wasm.rpsignature_expiresAt(this.__wbg_ptr);
861
+ return BigInt.asUintN(64, ret);
862
+ }
863
+ /**
864
+ * Gets the nonce as hex string (0x-prefixed field element)
865
+ * @returns {string}
866
+ */
867
+ get nonce() {
868
+ let deferred1_0;
869
+ let deferred1_1;
870
+ try {
871
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
872
+ wasm.rpsignature_nonce(retptr, this.__wbg_ptr);
873
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
874
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
875
+ deferred1_0 = r0;
876
+ deferred1_1 = r1;
877
+ return getStringFromWasm0(r0, r1);
878
+ } finally {
879
+ wasm.__wbindgen_add_to_stack_pointer(16);
880
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
881
+ }
882
+ }
883
+ /**
884
+ * Gets the signature as hex string (0x-prefixed, 65 bytes)
885
+ * @returns {string}
886
+ */
887
+ get sig() {
888
+ let deferred1_0;
889
+ let deferred1_1;
890
+ try {
891
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
892
+ wasm.rpsignature_sig(retptr, this.__wbg_ptr);
893
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
894
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
895
+ deferred1_0 = r0;
896
+ deferred1_1 = r1;
897
+ return getStringFromWasm0(r0, r1);
898
+ } finally {
899
+ wasm.__wbindgen_add_to_stack_pointer(16);
900
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
901
+ }
902
+ }
903
+ /**
904
+ * Converts to JSON
905
+ *
906
+ * # Errors
907
+ *
908
+ * Returns an error if setting object properties fails
909
+ * @returns {any}
910
+ */
911
+ toJSON() {
912
+ try {
913
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
914
+ wasm.rpsignature_toJSON(retptr, this.__wbg_ptr);
915
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
916
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
917
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
918
+ if (r2) {
919
+ throw takeObject(r1);
920
+ }
921
+ return takeObject(r0);
922
+ } finally {
923
+ wasm.__wbindgen_add_to_stack_pointer(16);
924
+ }
925
+ }
926
+ };
927
+ if (Symbol.dispose) RpSignature.prototype[Symbol.dispose] = RpSignature.prototype.free;
928
+ function base64Decode(data) {
929
+ try {
930
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
931
+ const ptr0 = passStringToWasm0(data, wasm.__wbindgen_export, wasm.__wbindgen_export2);
932
+ const len0 = WASM_VECTOR_LEN;
933
+ wasm.base64Decode(retptr, ptr0, len0);
934
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
935
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
936
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
937
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
938
+ if (r3) {
939
+ throw takeObject(r2);
940
+ }
941
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
942
+ wasm.__wbindgen_export4(r0, r1 * 1, 1);
943
+ return v2;
944
+ } finally {
945
+ wasm.__wbindgen_add_to_stack_pointer(16);
946
+ }
947
+ }
948
+ function base64Encode(data) {
949
+ let deferred2_0;
950
+ let deferred2_1;
951
+ try {
952
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
953
+ const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
954
+ const len0 = WASM_VECTOR_LEN;
955
+ wasm.base64Encode(retptr, ptr0, len0);
956
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
957
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
958
+ deferred2_0 = r0;
959
+ deferred2_1 = r1;
960
+ return getStringFromWasm0(r0, r1);
961
+ } finally {
962
+ wasm.__wbindgen_add_to_stack_pointer(16);
963
+ wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
964
+ }
965
+ }
966
+ function computeRpSignatureMessage(nonce, created_at, expires_at) {
967
+ try {
968
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
969
+ const ptr0 = passStringToWasm0(nonce, wasm.__wbindgen_export, wasm.__wbindgen_export2);
970
+ const len0 = WASM_VECTOR_LEN;
971
+ wasm.computeRpSignatureMessage(retptr, ptr0, len0, created_at, expires_at);
972
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
973
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
974
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
975
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
976
+ if (r3) {
977
+ throw takeObject(r2);
978
+ }
979
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
980
+ wasm.__wbindgen_export4(r0, r1 * 1, 1);
981
+ return v2;
982
+ } finally {
983
+ wasm.__wbindgen_add_to_stack_pointer(16);
984
+ }
985
+ }
986
+ function createSession(app_id, rp_context, action_description, bridge_url, override_connect_base_url, environment) {
987
+ const ptr0 = passStringToWasm0(app_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
988
+ const len0 = WASM_VECTOR_LEN;
989
+ _assertClass(rp_context, RpContextWasm);
990
+ var ptr1 = rp_context.__destroy_into_raw();
991
+ var ptr2 = isLikeNone(action_description) ? 0 : passStringToWasm0(action_description, wasm.__wbindgen_export, wasm.__wbindgen_export2);
992
+ var len2 = WASM_VECTOR_LEN;
993
+ var ptr3 = isLikeNone(bridge_url) ? 0 : passStringToWasm0(bridge_url, wasm.__wbindgen_export, wasm.__wbindgen_export2);
994
+ var len3 = WASM_VECTOR_LEN;
995
+ var ptr4 = isLikeNone(override_connect_base_url) ? 0 : passStringToWasm0(override_connect_base_url, wasm.__wbindgen_export, wasm.__wbindgen_export2);
996
+ var len4 = WASM_VECTOR_LEN;
997
+ var ptr5 = isLikeNone(environment) ? 0 : passStringToWasm0(environment, wasm.__wbindgen_export, wasm.__wbindgen_export2);
998
+ var len5 = WASM_VECTOR_LEN;
999
+ const ret = wasm.createSession(ptr0, len0, ptr1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5);
1000
+ return IDKitBuilder.__wrap(ret);
1001
+ }
1002
+ function hashSignal(signal) {
1003
+ let deferred2_0;
1004
+ let deferred2_1;
1005
+ try {
1006
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1007
+ wasm.hashSignal(retptr, addHeapObject(signal));
1008
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1009
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1010
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1011
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
1012
+ var ptr1 = r0;
1013
+ var len1 = r1;
1014
+ if (r3) {
1015
+ ptr1 = 0;
1016
+ len1 = 0;
1017
+ throw takeObject(r2);
1018
+ }
1019
+ deferred2_0 = ptr1;
1020
+ deferred2_1 = len1;
1021
+ return getStringFromWasm0(ptr1, len1);
1022
+ } finally {
1023
+ wasm.__wbindgen_add_to_stack_pointer(16);
1024
+ wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
1025
+ }
1026
+ }
1027
+ function init_wasm() {
1028
+ wasm.init_wasm();
1029
+ }
1030
+ function proveSession(session_id, app_id, rp_context, action_description, bridge_url, override_connect_base_url, environment) {
1031
+ const ptr0 = passStringToWasm0(session_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1032
+ const len0 = WASM_VECTOR_LEN;
1033
+ const ptr1 = passStringToWasm0(app_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1034
+ const len1 = WASM_VECTOR_LEN;
1035
+ _assertClass(rp_context, RpContextWasm);
1036
+ var ptr2 = rp_context.__destroy_into_raw();
1037
+ var ptr3 = isLikeNone(action_description) ? 0 : passStringToWasm0(action_description, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1038
+ var len3 = WASM_VECTOR_LEN;
1039
+ var ptr4 = isLikeNone(bridge_url) ? 0 : passStringToWasm0(bridge_url, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1040
+ var len4 = WASM_VECTOR_LEN;
1041
+ var ptr5 = isLikeNone(override_connect_base_url) ? 0 : passStringToWasm0(override_connect_base_url, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1042
+ var len5 = WASM_VECTOR_LEN;
1043
+ var ptr6 = isLikeNone(environment) ? 0 : passStringToWasm0(environment, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1044
+ var len6 = WASM_VECTOR_LEN;
1045
+ const ret = wasm.proveSession(ptr0, len0, ptr1, len1, ptr2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6);
1046
+ return IDKitBuilder.__wrap(ret);
1047
+ }
1048
+ function request(app_id, action, rp_context, action_description, bridge_url, allow_legacy_proofs, override_connect_base_url, environment) {
1049
+ const ptr0 = passStringToWasm0(app_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1050
+ const len0 = WASM_VECTOR_LEN;
1051
+ const ptr1 = passStringToWasm0(action, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1052
+ const len1 = WASM_VECTOR_LEN;
1053
+ _assertClass(rp_context, RpContextWasm);
1054
+ var ptr2 = rp_context.__destroy_into_raw();
1055
+ var ptr3 = isLikeNone(action_description) ? 0 : passStringToWasm0(action_description, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1056
+ var len3 = WASM_VECTOR_LEN;
1057
+ var ptr4 = isLikeNone(bridge_url) ? 0 : passStringToWasm0(bridge_url, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1058
+ var len4 = WASM_VECTOR_LEN;
1059
+ var ptr5 = isLikeNone(override_connect_base_url) ? 0 : passStringToWasm0(override_connect_base_url, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1060
+ var len5 = WASM_VECTOR_LEN;
1061
+ var ptr6 = isLikeNone(environment) ? 0 : passStringToWasm0(environment, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1062
+ var len6 = WASM_VECTOR_LEN;
1063
+ const ret = wasm.request(ptr0, len0, ptr1, len1, ptr2, ptr3, len3, ptr4, len4, allow_legacy_proofs, ptr5, len5, ptr6, len6);
1064
+ return IDKitBuilder.__wrap(ret);
1065
+ }
1066
+ function signRequest(signing_key_hex, ttl_seconds) {
1067
+ try {
1068
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1069
+ const ptr0 = passStringToWasm0(signing_key_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1070
+ const len0 = WASM_VECTOR_LEN;
1071
+ wasm.signRequest(retptr, ptr0, len0, !isLikeNone(ttl_seconds), isLikeNone(ttl_seconds) ? BigInt(0) : ttl_seconds);
1072
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1073
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1074
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1075
+ if (r2) {
1076
+ throw takeObject(r1);
1077
+ }
1078
+ return RpSignature.__wrap(r0);
1079
+ } finally {
1080
+ wasm.__wbindgen_add_to_stack_pointer(16);
1081
+ }
1082
+ }
1083
+ function __wbg_get_imports() {
1084
+ const import0 = {
1085
+ __proto__: null,
1086
+ __wbg_Error_83742b46f01ce22d: function(arg0, arg1) {
1087
+ const ret = Error(getStringFromWasm0(arg0, arg1));
1088
+ return addHeapObject(ret);
1089
+ },
1090
+ __wbg_String_8564e559799eccda: function(arg0, arg1) {
1091
+ const ret = String(getObject(arg1));
1092
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1093
+ const len1 = WASM_VECTOR_LEN;
1094
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
1095
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
1096
+ },
1097
+ __wbg___wbindgen_bigint_get_as_i64_447a76b5c6ef7bda: function(arg0, arg1) {
1098
+ const v = getObject(arg1);
1099
+ const ret = typeof v === "bigint" ? v : void 0;
1100
+ getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
1101
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
1102
+ },
1103
+ __wbg___wbindgen_boolean_get_c0f3f60bac5a78d1: function(arg0) {
1104
+ const v = getObject(arg0);
1105
+ const ret = typeof v === "boolean" ? v : void 0;
1106
+ return isLikeNone(ret) ? 16777215 : ret ? 1 : 0;
1107
+ },
1108
+ __wbg___wbindgen_debug_string_5398f5bb970e0daa: function(arg0, arg1) {
1109
+ const ret = debugString(getObject(arg1));
1110
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1111
+ const len1 = WASM_VECTOR_LEN;
1112
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
1113
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
1114
+ },
1115
+ __wbg___wbindgen_in_41dbb8413020e076: function(arg0, arg1) {
1116
+ const ret = getObject(arg0) in getObject(arg1);
1117
+ return ret;
1118
+ },
1119
+ __wbg___wbindgen_is_bigint_e2141d4f045b7eda: function(arg0) {
1120
+ const ret = typeof getObject(arg0) === "bigint";
1121
+ return ret;
1122
+ },
1123
+ __wbg___wbindgen_is_function_3c846841762788c1: function(arg0) {
1124
+ const ret = typeof getObject(arg0) === "function";
1125
+ return ret;
1126
+ },
1127
+ __wbg___wbindgen_is_object_781bc9f159099513: function(arg0) {
1128
+ const val = getObject(arg0);
1129
+ const ret = typeof val === "object" && val !== null;
1130
+ return ret;
1131
+ },
1132
+ __wbg___wbindgen_is_string_7ef6b97b02428fae: function(arg0) {
1133
+ const ret = typeof getObject(arg0) === "string";
1134
+ return ret;
1135
+ },
1136
+ __wbg___wbindgen_is_undefined_52709e72fb9f179c: function(arg0) {
1137
+ const ret = getObject(arg0) === void 0;
1138
+ return ret;
1139
+ },
1140
+ __wbg___wbindgen_jsval_eq_ee31bfad3e536463: function(arg0, arg1) {
1141
+ const ret = getObject(arg0) === getObject(arg1);
1142
+ return ret;
1143
+ },
1144
+ __wbg___wbindgen_jsval_loose_eq_5bcc3bed3c69e72b: function(arg0, arg1) {
1145
+ const ret = getObject(arg0) == getObject(arg1);
1146
+ return ret;
1147
+ },
1148
+ __wbg___wbindgen_number_get_34bb9d9dcfa21373: function(arg0, arg1) {
1149
+ const obj = getObject(arg1);
1150
+ const ret = typeof obj === "number" ? obj : void 0;
1151
+ getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
1152
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
1153
+ },
1154
+ __wbg___wbindgen_string_get_395e606bd0ee4427: function(arg0, arg1) {
1155
+ const obj = getObject(arg1);
1156
+ const ret = typeof obj === "string" ? obj : void 0;
1157
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1158
+ var len1 = WASM_VECTOR_LEN;
1159
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
1160
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
1161
+ },
1162
+ __wbg___wbindgen_throw_6ddd609b62940d55: function(arg0, arg1) {
1163
+ throw new Error(getStringFromWasm0(arg0, arg1));
1164
+ },
1165
+ __wbg__wbg_cb_unref_6b5b6b8576d35cb1: function(arg0) {
1166
+ getObject(arg0)._wbg_cb_unref();
1167
+ },
1168
+ __wbg_abort_5ef96933660780b7: function(arg0) {
1169
+ getObject(arg0).abort();
1170
+ },
1171
+ __wbg_abort_6479c2d794ebf2ee: function(arg0, arg1) {
1172
+ getObject(arg0).abort(getObject(arg1));
1173
+ },
1174
+ __wbg_append_608dfb635ee8998f: function() {
1175
+ return handleError(function(arg0, arg1, arg2, arg3, arg4) {
1176
+ getObject(arg0).append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
1177
+ }, arguments);
1178
+ },
1179
+ __wbg_arrayBuffer_eb8e9ca620af2a19: function() {
1180
+ return handleError(function(arg0) {
1181
+ const ret = getObject(arg0).arrayBuffer();
1182
+ return addHeapObject(ret);
1183
+ }, arguments);
1184
+ },
1185
+ __wbg_call_2d781c1f4d5c0ef8: function() {
1186
+ return handleError(function(arg0, arg1, arg2) {
1187
+ const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
1188
+ return addHeapObject(ret);
1189
+ }, arguments);
1190
+ },
1191
+ __wbg_call_e133b57c9155d22c: function() {
1192
+ return handleError(function(arg0, arg1) {
1193
+ const ret = getObject(arg0).call(getObject(arg1));
1194
+ return addHeapObject(ret);
1195
+ }, arguments);
1196
+ },
1197
+ __wbg_clearTimeout_6b8d9a38b9263d65: function(arg0) {
1198
+ const ret = clearTimeout(takeObject(arg0));
1199
+ return addHeapObject(ret);
1200
+ },
1201
+ __wbg_crypto_38df2bab126b63dc: function(arg0) {
1202
+ const ret = getObject(arg0).crypto;
1203
+ return addHeapObject(ret);
1204
+ },
1205
+ __wbg_done_08ce71ee07e3bd17: function(arg0) {
1206
+ const ret = getObject(arg0).done;
1207
+ return ret;
1208
+ },
1209
+ __wbg_entries_e8a20ff8c9757101: function(arg0) {
1210
+ const ret = Object.entries(getObject(arg0));
1211
+ return addHeapObject(ret);
1212
+ },
1213
+ __wbg_error_a6fa202b58aa1cd3: function(arg0, arg1) {
1214
+ let deferred0_0;
1215
+ let deferred0_1;
1216
+ try {
1217
+ deferred0_0 = arg0;
1218
+ deferred0_1 = arg1;
1219
+ console.error(getStringFromWasm0(arg0, arg1));
1220
+ } finally {
1221
+ wasm.__wbindgen_export4(deferred0_0, deferred0_1, 1);
1222
+ }
1223
+ },
1224
+ __wbg_fetch_5550a88cf343aaa9: function(arg0, arg1) {
1225
+ const ret = getObject(arg0).fetch(getObject(arg1));
1226
+ return addHeapObject(ret);
1227
+ },
1228
+ __wbg_fetch_9dad4fe911207b37: function(arg0) {
1229
+ const ret = fetch(getObject(arg0));
1230
+ return addHeapObject(ret);
1231
+ },
1232
+ __wbg_getRandomValues_a1cf2e70b003a59d: function() {
1233
+ return handleError(function(arg0, arg1) {
1234
+ globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
1235
+ }, arguments);
1236
+ },
1237
+ __wbg_getRandomValues_c44a50d8cfdaebeb: function() {
1238
+ return handleError(function(arg0, arg1) {
1239
+ getObject(arg0).getRandomValues(getObject(arg1));
1240
+ }, arguments);
1241
+ },
1242
+ __wbg_get_326e41e095fb2575: function() {
1243
+ return handleError(function(arg0, arg1) {
1244
+ const ret = Reflect.get(getObject(arg0), getObject(arg1));
1245
+ return addHeapObject(ret);
1246
+ }, arguments);
1247
+ },
1248
+ __wbg_get_a8ee5c45dabc1b3b: function(arg0, arg1) {
1249
+ const ret = getObject(arg0)[arg1 >>> 0];
1250
+ return addHeapObject(ret);
1251
+ },
1252
+ __wbg_get_unchecked_329cfe50afab7352: function(arg0, arg1) {
1253
+ const ret = getObject(arg0)[arg1 >>> 0];
1254
+ return addHeapObject(ret);
1255
+ },
1256
+ __wbg_has_926ef2ff40b308cf: function() {
1257
+ return handleError(function(arg0, arg1) {
1258
+ const ret = Reflect.has(getObject(arg0), getObject(arg1));
1259
+ return ret;
1260
+ }, arguments);
1261
+ },
1262
+ __wbg_headers_eb2234545f9ff993: function(arg0) {
1263
+ const ret = getObject(arg0).headers;
1264
+ return addHeapObject(ret);
1265
+ },
1266
+ __wbg_idkitrequest_new: function(arg0) {
1267
+ const ret = IDKitRequest.__wrap(arg0);
1268
+ return addHeapObject(ret);
1269
+ },
1270
+ __wbg_instanceof_ArrayBuffer_101e2bf31071a9f6: function(arg0) {
1271
+ let result;
1272
+ try {
1273
+ result = getObject(arg0) instanceof ArrayBuffer;
1274
+ } catch (_) {
1275
+ result = false;
1276
+ }
1277
+ const ret = result;
1278
+ return ret;
1279
+ },
1280
+ __wbg_instanceof_Map_f194b366846aca0c: function(arg0) {
1281
+ let result;
1282
+ try {
1283
+ result = getObject(arg0) instanceof Map;
1284
+ } catch (_) {
1285
+ result = false;
1286
+ }
1287
+ const ret = result;
1288
+ return ret;
1289
+ },
1290
+ __wbg_instanceof_Response_9b4d9fd451e051b1: function(arg0) {
1291
+ let result;
1292
+ try {
1293
+ result = getObject(arg0) instanceof Response;
1294
+ } catch (_) {
1295
+ result = false;
1296
+ }
1297
+ const ret = result;
1298
+ return ret;
1299
+ },
1300
+ __wbg_instanceof_Uint8Array_740438561a5b956d: function(arg0) {
1301
+ let result;
1302
+ try {
1303
+ result = getObject(arg0) instanceof Uint8Array;
1304
+ } catch (_) {
1305
+ result = false;
1306
+ }
1307
+ const ret = result;
1308
+ return ret;
1309
+ },
1310
+ __wbg_isArray_33b91feb269ff46e: function(arg0) {
1311
+ const ret = Array.isArray(getObject(arg0));
1312
+ return ret;
1313
+ },
1314
+ __wbg_isSafeInteger_ecd6a7f9c3e053cd: function(arg0) {
1315
+ const ret = Number.isSafeInteger(getObject(arg0));
1316
+ return ret;
1317
+ },
1318
+ __wbg_iterator_d8f549ec8fb061b1: function() {
1319
+ const ret = Symbol.iterator;
1320
+ return addHeapObject(ret);
1321
+ },
1322
+ __wbg_length_b3416cf66a5452c8: function(arg0) {
1323
+ const ret = getObject(arg0).length;
1324
+ return ret;
1325
+ },
1326
+ __wbg_length_ea16607d7b61445b: function(arg0) {
1327
+ const ret = getObject(arg0).length;
1328
+ return ret;
1329
+ },
1330
+ __wbg_msCrypto_bd5a034af96bcba6: function(arg0) {
1331
+ const ret = getObject(arg0).msCrypto;
1332
+ return addHeapObject(ret);
1333
+ },
1334
+ __wbg_new_0837727332ac86ba: function() {
1335
+ return handleError(function() {
1336
+ const ret = new Headers();
1337
+ return addHeapObject(ret);
1338
+ }, arguments);
1339
+ },
1340
+ __wbg_new_227d7c05414eb861: function() {
1341
+ const ret = new Error();
1342
+ return addHeapObject(ret);
1343
+ },
1344
+ __wbg_new_49d5571bd3f0c4d4: function() {
1345
+ const ret = /* @__PURE__ */ new Map();
1346
+ return addHeapObject(ret);
1347
+ },
1348
+ __wbg_new_5f486cdf45a04d78: function(arg0) {
1349
+ const ret = new Uint8Array(getObject(arg0));
1350
+ return addHeapObject(ret);
1351
+ },
1352
+ __wbg_new_a70fbab9066b301f: function() {
1353
+ const ret = new Array();
1354
+ return addHeapObject(ret);
1355
+ },
1356
+ __wbg_new_ab79df5bd7c26067: function() {
1357
+ const ret = new Object();
1358
+ return addHeapObject(ret);
1359
+ },
1360
+ __wbg_new_c518c60af666645b: function() {
1361
+ return handleError(function() {
1362
+ const ret = new AbortController();
1363
+ return addHeapObject(ret);
1364
+ }, arguments);
1365
+ },
1366
+ __wbg_new_from_slice_22da9388ac046e50: function(arg0, arg1) {
1367
+ const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
1368
+ return addHeapObject(ret);
1369
+ },
1370
+ __wbg_new_typed_aaaeaf29cf802876: function(arg0, arg1) {
1371
+ try {
1372
+ var state0 = { a: arg0, b: arg1 };
1373
+ var cb0 = (arg02, arg12) => {
1374
+ const a = state0.a;
1375
+ state0.a = 0;
1376
+ try {
1377
+ return __wasm_bindgen_func_elem_1382(a, state0.b, arg02, arg12);
1378
+ } finally {
1379
+ state0.a = a;
1380
+ }
1381
+ };
1382
+ const ret = new Promise(cb0);
1383
+ return addHeapObject(ret);
1384
+ } finally {
1385
+ state0.a = state0.b = 0;
1386
+ }
1387
+ },
1388
+ __wbg_new_with_length_825018a1616e9e55: function(arg0) {
1389
+ const ret = new Uint8Array(arg0 >>> 0);
1390
+ return addHeapObject(ret);
1391
+ },
1392
+ __wbg_new_with_str_and_init_b4b54d1a819bc724: function() {
1393
+ return handleError(function(arg0, arg1, arg2) {
1394
+ const ret = new Request(getStringFromWasm0(arg0, arg1), getObject(arg2));
1395
+ return addHeapObject(ret);
1396
+ }, arguments);
1397
+ },
1398
+ __wbg_next_11b99ee6237339e3: function() {
1399
+ return handleError(function(arg0) {
1400
+ const ret = getObject(arg0).next();
1401
+ return addHeapObject(ret);
1402
+ }, arguments);
1403
+ },
1404
+ __wbg_next_e01a967809d1aa68: function(arg0) {
1405
+ const ret = getObject(arg0).next;
1406
+ return addHeapObject(ret);
1407
+ },
1408
+ __wbg_node_84ea875411254db1: function(arg0) {
1409
+ const ret = getObject(arg0).node;
1410
+ return addHeapObject(ret);
1411
+ },
1412
+ __wbg_now_16f0c993d5dd6c27: function() {
1413
+ const ret = Date.now();
1414
+ return ret;
1415
+ },
1416
+ __wbg_process_44c7a14e11e9f69e: function(arg0) {
1417
+ const ret = getObject(arg0).process;
1418
+ return addHeapObject(ret);
1419
+ },
1420
+ __wbg_prototypesetcall_d62e5099504357e6: function(arg0, arg1, arg2) {
1421
+ Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
1422
+ },
1423
+ __wbg_queueMicrotask_0c399741342fb10f: function(arg0) {
1424
+ const ret = getObject(arg0).queueMicrotask;
1425
+ return addHeapObject(ret);
1426
+ },
1427
+ __wbg_queueMicrotask_a082d78ce798393e: function(arg0) {
1428
+ queueMicrotask(getObject(arg0));
1429
+ },
1430
+ __wbg_randomFillSync_6c25eac9869eb53c: function() {
1431
+ return handleError(function(arg0, arg1) {
1432
+ getObject(arg0).randomFillSync(takeObject(arg1));
1433
+ }, arguments);
1434
+ },
1435
+ __wbg_require_b4edbdcf3e2a1ef0: function() {
1436
+ return handleError(function() {
1437
+ const ret = module.require;
1438
+ return addHeapObject(ret);
1439
+ }, arguments);
1440
+ },
1441
+ __wbg_resolve_ae8d83246e5bcc12: function(arg0) {
1442
+ const ret = Promise.resolve(getObject(arg0));
1443
+ return addHeapObject(ret);
1444
+ },
1445
+ __wbg_setTimeout_f757f00851f76c42: function(arg0, arg1) {
1446
+ const ret = setTimeout(getObject(arg0), arg1);
1447
+ return addHeapObject(ret);
1448
+ },
1449
+ __wbg_set_282384002438957f: function(arg0, arg1, arg2) {
1450
+ getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
1451
+ },
1452
+ __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
1453
+ getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
1454
+ },
1455
+ __wbg_set_7eaa4f96924fd6b3: function() {
1456
+ return handleError(function(arg0, arg1, arg2) {
1457
+ const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
1458
+ return ret;
1459
+ }, arguments);
1460
+ },
1461
+ __wbg_set_bf7251625df30a02: function(arg0, arg1, arg2) {
1462
+ const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
1463
+ return addHeapObject(ret);
1464
+ },
1465
+ __wbg_set_body_a3d856b097dfda04: function(arg0, arg1) {
1466
+ getObject(arg0).body = getObject(arg1);
1467
+ },
1468
+ __wbg_set_cache_ec7e430c6056ebda: function(arg0, arg1) {
1469
+ getObject(arg0).cache = __wbindgen_enum_RequestCache[arg1];
1470
+ },
1471
+ __wbg_set_credentials_ed63183445882c65: function(arg0, arg1) {
1472
+ getObject(arg0).credentials = __wbindgen_enum_RequestCredentials[arg1];
1473
+ },
1474
+ __wbg_set_headers_3c8fecc693b75327: function(arg0, arg1) {
1475
+ getObject(arg0).headers = getObject(arg1);
1476
+ },
1477
+ __wbg_set_method_8c015e8bcafd7be1: function(arg0, arg1, arg2) {
1478
+ getObject(arg0).method = getStringFromWasm0(arg1, arg2);
1479
+ },
1480
+ __wbg_set_mode_5a87f2c809cf37c2: function(arg0, arg1) {
1481
+ getObject(arg0).mode = __wbindgen_enum_RequestMode[arg1];
1482
+ },
1483
+ __wbg_set_signal_0cebecb698f25d21: function(arg0, arg1) {
1484
+ getObject(arg0).signal = getObject(arg1);
1485
+ },
1486
+ __wbg_signal_166e1da31adcac18: function(arg0) {
1487
+ const ret = getObject(arg0).signal;
1488
+ return addHeapObject(ret);
1489
+ },
1490
+ __wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) {
1491
+ const ret = getObject(arg1).stack;
1492
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1493
+ const len1 = WASM_VECTOR_LEN;
1494
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
1495
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
1496
+ },
1497
+ __wbg_static_accessor_GLOBAL_8adb955bd33fac2f: function() {
1498
+ const ret = typeof global === "undefined" ? null : global;
1499
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
1500
+ },
1501
+ __wbg_static_accessor_GLOBAL_THIS_ad356e0db91c7913: function() {
1502
+ const ret = typeof globalThis === "undefined" ? null : globalThis;
1503
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
1504
+ },
1505
+ __wbg_static_accessor_SELF_f207c857566db248: function() {
1506
+ const ret = typeof self === "undefined" ? null : self;
1507
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
1508
+ },
1509
+ __wbg_static_accessor_WINDOW_bb9f1ba69d61b386: function() {
1510
+ const ret = typeof window === "undefined" ? null : window;
1511
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
1512
+ },
1513
+ __wbg_status_318629ab93a22955: function(arg0) {
1514
+ const ret = getObject(arg0).status;
1515
+ return ret;
1516
+ },
1517
+ __wbg_stringify_5ae93966a84901ac: function() {
1518
+ return handleError(function(arg0) {
1519
+ const ret = JSON.stringify(getObject(arg0));
1520
+ return addHeapObject(ret);
1521
+ }, arguments);
1522
+ },
1523
+ __wbg_subarray_a068d24e39478a8a: function(arg0, arg1, arg2) {
1524
+ const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
1525
+ return addHeapObject(ret);
1526
+ },
1527
+ __wbg_text_372f5b91442c50f9: function() {
1528
+ return handleError(function(arg0) {
1529
+ const ret = getObject(arg0).text();
1530
+ return addHeapObject(ret);
1531
+ }, arguments);
1532
+ },
1533
+ __wbg_then_098abe61755d12f6: function(arg0, arg1) {
1534
+ const ret = getObject(arg0).then(getObject(arg1));
1535
+ return addHeapObject(ret);
1536
+ },
1537
+ __wbg_then_9e335f6dd892bc11: function(arg0, arg1, arg2) {
1538
+ const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
1539
+ return addHeapObject(ret);
1540
+ },
1541
+ __wbg_url_7fefc1820fba4e0c: function(arg0, arg1) {
1542
+ const ret = getObject(arg1).url;
1543
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1544
+ const len1 = WASM_VECTOR_LEN;
1545
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
1546
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
1547
+ },
1548
+ __wbg_value_21fc78aab0322612: function(arg0) {
1549
+ const ret = getObject(arg0).value;
1550
+ return addHeapObject(ret);
1551
+ },
1552
+ __wbg_versions_276b2795b1c6a219: function(arg0) {
1553
+ const ret = getObject(arg0).versions;
1554
+ return addHeapObject(ret);
1555
+ },
1556
+ __wbindgen_cast_0000000000000001: function(arg0, arg1) {
1557
+ const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_632, __wasm_bindgen_func_elem_633);
1558
+ return addHeapObject(ret);
1559
+ },
1560
+ __wbindgen_cast_0000000000000002: function(arg0, arg1) {
1561
+ const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_962, __wasm_bindgen_func_elem_963);
1562
+ return addHeapObject(ret);
1563
+ },
1564
+ __wbindgen_cast_0000000000000003: function(arg0) {
1565
+ const ret = arg0;
1566
+ return addHeapObject(ret);
1567
+ },
1568
+ __wbindgen_cast_0000000000000004: function(arg0) {
1569
+ const ret = arg0;
1570
+ return addHeapObject(ret);
1571
+ },
1572
+ __wbindgen_cast_0000000000000005: function(arg0, arg1) {
1573
+ const ret = getArrayU8FromWasm0(arg0, arg1);
1574
+ return addHeapObject(ret);
1575
+ },
1576
+ __wbindgen_cast_0000000000000006: function(arg0, arg1) {
1577
+ const ret = getStringFromWasm0(arg0, arg1);
1578
+ return addHeapObject(ret);
1579
+ },
1580
+ __wbindgen_cast_0000000000000007: function(arg0) {
1581
+ const ret = BigInt.asUintN(64, arg0);
1582
+ return addHeapObject(ret);
1583
+ },
1584
+ __wbindgen_object_clone_ref: function(arg0) {
1585
+ const ret = getObject(arg0);
1586
+ return addHeapObject(ret);
1587
+ },
1588
+ __wbindgen_object_drop_ref: function(arg0) {
1589
+ takeObject(arg0);
1590
+ }
1591
+ };
1592
+ return {
1593
+ __proto__: null,
1594
+ "./idkit_wasm_bg.js": import0
1595
+ };
1596
+ }
1597
+ function __wasm_bindgen_func_elem_633(arg0, arg1) {
1598
+ wasm.__wasm_bindgen_func_elem_633(arg0, arg1);
1599
+ }
1600
+ function __wasm_bindgen_func_elem_963(arg0, arg1, arg2) {
1601
+ try {
1602
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1603
+ wasm.__wasm_bindgen_func_elem_963(retptr, arg0, arg1, addHeapObject(arg2));
1604
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1605
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1606
+ if (r1) {
1607
+ throw takeObject(r0);
1608
+ }
1609
+ } finally {
1610
+ wasm.__wbindgen_add_to_stack_pointer(16);
1138
1611
  }
1139
- };
1140
- if (Symbol.dispose) IDKitRequest.prototype[Symbol.dispose] = IDKitRequest.prototype.free;
1612
+ }
1613
+ function __wasm_bindgen_func_elem_1382(arg0, arg1, arg2, arg3) {
1614
+ wasm.__wasm_bindgen_func_elem_1382(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
1615
+ }
1616
+ var __wbindgen_enum_RequestCache = ["default", "no-store", "reload", "no-cache", "force-cache", "only-if-cached"];
1617
+ var __wbindgen_enum_RequestCredentials = ["omit", "same-origin", "include"];
1618
+ var __wbindgen_enum_RequestMode = ["same-origin", "no-cors", "cors", "navigate"];
1619
+ var BridgeEncryptionFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
1620
+ }, unregister: () => {
1621
+ } } : new FinalizationRegistry((ptr) => wasm.__wbg_bridgeencryption_free(ptr >>> 0, 1));
1622
+ var CredentialRequestWasmFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
1623
+ }, unregister: () => {
1624
+ } } : new FinalizationRegistry((ptr) => wasm.__wbg_credentialrequestwasm_free(ptr >>> 0, 1));
1625
+ var IDKitBuilderFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
1626
+ }, unregister: () => {
1627
+ } } : new FinalizationRegistry((ptr) => wasm.__wbg_idkitbuilder_free(ptr >>> 0, 1));
1628
+ var IDKitProofFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
1629
+ }, unregister: () => {
1630
+ } } : new FinalizationRegistry((ptr) => wasm.__wbg_idkitproof_free(ptr >>> 0, 1));
1631
+ var IDKitRequestFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
1632
+ }, unregister: () => {
1633
+ } } : new FinalizationRegistry((ptr) => wasm.__wbg_idkitrequest_free(ptr >>> 0, 1));
1141
1634
  var RpContextWasmFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
1142
1635
  }, unregister: () => {
1143
1636
  } } : new FinalizationRegistry((ptr) => wasm.__wbg_rpcontextwasm_free(ptr >>> 0, 1));
1144
- var RpContextWasm = class {
1145
- __destroy_into_raw() {
1146
- const ptr = this.__wbg_ptr;
1147
- this.__wbg_ptr = 0;
1148
- RpContextWasmFinalization.unregister(this);
1149
- return ptr;
1150
- }
1151
- free() {
1152
- const ptr = this.__destroy_into_raw();
1153
- wasm.__wbg_rpcontextwasm_free(ptr, 0);
1154
- }
1155
- /**
1156
- * Creates a new RP context
1157
- *
1158
- * # Arguments
1159
- * * `rp_id` - The registered RP ID (e.g., `"rp_123456789abcdef0"`)
1160
- * * `nonce` - Unique nonce for this proof request
1161
- * * `created_at` - Unix timestamp (seconds since epoch) when created
1162
- * * `expires_at` - Unix timestamp (seconds since epoch) when expires
1163
- * * `signature` - The RP's ECDSA signature of the `nonce` and `created_at` timestamp
1164
- *
1165
- * # Errors
1166
- *
1167
- * Returns an error if `rp_id` is not a valid RP ID (must start with `rp_`)
1168
- * @param {string} rp_id
1169
- * @param {string} nonce
1170
- * @param {bigint} created_at
1171
- * @param {bigint} expires_at
1172
- * @param {string} signature
1173
- */
1174
- constructor(rp_id, nonce, created_at, expires_at, signature) {
1175
- try {
1176
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1177
- const ptr0 = passStringToWasm0(rp_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1178
- const len0 = WASM_VECTOR_LEN;
1179
- const ptr1 = passStringToWasm0(nonce, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1180
- const len1 = WASM_VECTOR_LEN;
1181
- const ptr2 = passStringToWasm0(signature, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1182
- const len2 = WASM_VECTOR_LEN;
1183
- wasm.rpcontextwasm_new(retptr, ptr0, len0, ptr1, len1, created_at, expires_at, ptr2, len2);
1184
- var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1185
- var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1186
- var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1187
- if (r2) {
1188
- throw takeObject(r1);
1189
- }
1190
- this.__wbg_ptr = r0 >>> 0;
1191
- RpContextWasmFinalization.register(this, this.__wbg_ptr, this);
1192
- return this;
1193
- } finally {
1194
- wasm.__wbindgen_add_to_stack_pointer(16);
1195
- }
1196
- }
1197
- };
1198
- if (Symbol.dispose) RpContextWasm.prototype[Symbol.dispose] = RpContextWasm.prototype.free;
1199
1637
  var RpSignatureFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
1200
1638
  }, unregister: () => {
1201
1639
  } } : new FinalizationRegistry((ptr) => wasm.__wbg_rpsignature_free(ptr >>> 0, 1));
1202
- var RpSignature = class _RpSignature {
1203
- static __wrap(ptr) {
1204
- ptr = ptr >>> 0;
1205
- const obj = Object.create(_RpSignature.prototype);
1206
- obj.__wbg_ptr = ptr;
1207
- RpSignatureFinalization.register(obj, obj.__wbg_ptr, obj);
1208
- return obj;
1640
+ function addHeapObject(obj) {
1641
+ if (heap_next === heap.length) heap.push(heap.length + 1);
1642
+ const idx = heap_next;
1643
+ heap_next = heap[idx];
1644
+ heap[idx] = obj;
1645
+ return idx;
1646
+ }
1647
+ function _assertClass(instance, klass) {
1648
+ if (!(instance instanceof klass)) {
1649
+ throw new Error(`expected instance of ${klass.name}`);
1209
1650
  }
1210
- __destroy_into_raw() {
1211
- const ptr = this.__wbg_ptr;
1212
- this.__wbg_ptr = 0;
1213
- RpSignatureFinalization.unregister(this);
1214
- return ptr;
1651
+ }
1652
+ var CLOSURE_DTORS = typeof FinalizationRegistry === "undefined" ? { register: () => {
1653
+ }, unregister: () => {
1654
+ } } : new FinalizationRegistry((state) => state.dtor(state.a, state.b));
1655
+ function debugString(val) {
1656
+ const type = typeof val;
1657
+ if (type == "number" || type == "boolean" || val == null) {
1658
+ return `${val}`;
1215
1659
  }
1216
- free() {
1217
- const ptr = this.__destroy_into_raw();
1218
- wasm.__wbg_rpsignature_free(ptr, 0);
1660
+ if (type == "string") {
1661
+ return `"${val}"`;
1219
1662
  }
1220
- /**
1221
- * Gets the creation timestamp
1222
- * @returns {bigint}
1223
- */
1224
- get createdAt() {
1225
- const ret = wasm.rpsignature_createdAt(this.__wbg_ptr);
1226
- return BigInt.asUintN(64, ret);
1663
+ if (type == "symbol") {
1664
+ const description = val.description;
1665
+ if (description == null) {
1666
+ return "Symbol";
1667
+ } else {
1668
+ return `Symbol(${description})`;
1669
+ }
1227
1670
  }
1228
- /**
1229
- * Gets the expiration timestamp
1230
- * @returns {bigint}
1231
- */
1232
- get expiresAt() {
1233
- const ret = wasm.rpsignature_expiresAt(this.__wbg_ptr);
1234
- return BigInt.asUintN(64, ret);
1671
+ if (type == "function") {
1672
+ const name = val.name;
1673
+ if (typeof name == "string" && name.length > 0) {
1674
+ return `Function(${name})`;
1675
+ } else {
1676
+ return "Function";
1677
+ }
1235
1678
  }
1236
- /**
1237
- * Gets the signature as hex string (0x-prefixed, 65 bytes)
1238
- * @returns {string}
1239
- */
1240
- get sig() {
1241
- let deferred1_0;
1242
- let deferred1_1;
1243
- try {
1244
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1245
- wasm.rpsignature_sig(retptr, this.__wbg_ptr);
1246
- var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1247
- var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1248
- deferred1_0 = r0;
1249
- deferred1_1 = r1;
1250
- return getStringFromWasm0(r0, r1);
1251
- } finally {
1252
- wasm.__wbindgen_add_to_stack_pointer(16);
1253
- wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1679
+ if (Array.isArray(val)) {
1680
+ const length = val.length;
1681
+ let debug = "[";
1682
+ if (length > 0) {
1683
+ debug += debugString(val[0]);
1684
+ }
1685
+ for (let i = 1; i < length; i++) {
1686
+ debug += ", " + debugString(val[i]);
1254
1687
  }
1688
+ debug += "]";
1689
+ return debug;
1255
1690
  }
1256
- /**
1257
- * Gets the nonce as hex string (0x-prefixed field element)
1258
- * @returns {string}
1259
- */
1260
- get nonce() {
1261
- let deferred1_0;
1262
- let deferred1_1;
1691
+ const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
1692
+ let className;
1693
+ if (builtInMatches && builtInMatches.length > 1) {
1694
+ className = builtInMatches[1];
1695
+ } else {
1696
+ return toString.call(val);
1697
+ }
1698
+ if (className == "Object") {
1263
1699
  try {
1264
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1265
- wasm.rpsignature_nonce(retptr, this.__wbg_ptr);
1266
- var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1267
- var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1268
- deferred1_0 = r0;
1269
- deferred1_1 = r1;
1270
- return getStringFromWasm0(r0, r1);
1271
- } finally {
1272
- wasm.__wbindgen_add_to_stack_pointer(16);
1273
- wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1700
+ return "Object(" + JSON.stringify(val) + ")";
1701
+ } catch (_) {
1702
+ return "Object";
1274
1703
  }
1275
1704
  }
1276
- /**
1277
- * Converts to JSON
1278
- *
1279
- * # Errors
1280
- *
1281
- * Returns an error if setting object properties fails
1282
- * @returns {any}
1283
- */
1284
- toJSON() {
1705
+ if (val instanceof Error) {
1706
+ return `${val.name}: ${val.message}
1707
+ ${val.stack}`;
1708
+ }
1709
+ return className;
1710
+ }
1711
+ function dropObject(idx) {
1712
+ if (idx < 1028) return;
1713
+ heap[idx] = heap_next;
1714
+ heap_next = idx;
1715
+ }
1716
+ function getArrayU8FromWasm0(ptr, len) {
1717
+ ptr = ptr >>> 0;
1718
+ return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
1719
+ }
1720
+ var cachedDataViewMemory0 = null;
1721
+ function getDataViewMemory0() {
1722
+ if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm.memory.buffer) {
1723
+ cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
1724
+ }
1725
+ return cachedDataViewMemory0;
1726
+ }
1727
+ function getStringFromWasm0(ptr, len) {
1728
+ ptr = ptr >>> 0;
1729
+ return decodeText(ptr, len);
1730
+ }
1731
+ var cachedUint8ArrayMemory0 = null;
1732
+ function getUint8ArrayMemory0() {
1733
+ if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
1734
+ cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
1735
+ }
1736
+ return cachedUint8ArrayMemory0;
1737
+ }
1738
+ function getObject(idx) {
1739
+ return heap[idx];
1740
+ }
1741
+ function handleError(f, args) {
1742
+ try {
1743
+ return f.apply(this, args);
1744
+ } catch (e) {
1745
+ wasm.__wbindgen_export3(addHeapObject(e));
1746
+ }
1747
+ }
1748
+ var heap = new Array(1024).fill(void 0);
1749
+ heap.push(void 0, null, true, false);
1750
+ var heap_next = heap.length;
1751
+ function isLikeNone(x) {
1752
+ return x === void 0 || x === null;
1753
+ }
1754
+ function makeMutClosure(arg0, arg1, dtor, f) {
1755
+ const state = { a: arg0, b: arg1, cnt: 1, dtor };
1756
+ const real = (...args) => {
1757
+ state.cnt++;
1758
+ const a = state.a;
1759
+ state.a = 0;
1285
1760
  try {
1286
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1287
- wasm.rpsignature_toJSON(retptr, this.__wbg_ptr);
1288
- var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1289
- var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1290
- var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1291
- if (r2) {
1292
- throw takeObject(r1);
1293
- }
1294
- return takeObject(r0);
1761
+ return f(a, state.b, ...args);
1295
1762
  } finally {
1296
- wasm.__wbindgen_add_to_stack_pointer(16);
1763
+ state.a = a;
1764
+ real._wbg_cb_unref();
1765
+ }
1766
+ };
1767
+ real._wbg_cb_unref = () => {
1768
+ if (--state.cnt === 0) {
1769
+ state.dtor(state.a, state.b);
1770
+ state.a = 0;
1771
+ CLOSURE_DTORS.unregister(state);
1772
+ }
1773
+ };
1774
+ CLOSURE_DTORS.register(real, state, state);
1775
+ return real;
1776
+ }
1777
+ function passArray8ToWasm0(arg, malloc) {
1778
+ const ptr = malloc(arg.length * 1, 1) >>> 0;
1779
+ getUint8ArrayMemory0().set(arg, ptr / 1);
1780
+ WASM_VECTOR_LEN = arg.length;
1781
+ return ptr;
1782
+ }
1783
+ function passStringToWasm0(arg, malloc, realloc) {
1784
+ if (realloc === void 0) {
1785
+ const buf = cachedTextEncoder.encode(arg);
1786
+ const ptr2 = malloc(buf.length, 1) >>> 0;
1787
+ getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
1788
+ WASM_VECTOR_LEN = buf.length;
1789
+ return ptr2;
1790
+ }
1791
+ let len = arg.length;
1792
+ let ptr = malloc(len, 1) >>> 0;
1793
+ const mem = getUint8ArrayMemory0();
1794
+ let offset = 0;
1795
+ for (; offset < len; offset++) {
1796
+ const code = arg.charCodeAt(offset);
1797
+ if (code > 127) break;
1798
+ mem[ptr + offset] = code;
1799
+ }
1800
+ if (offset !== len) {
1801
+ if (offset !== 0) {
1802
+ arg = arg.slice(offset);
1297
1803
  }
1804
+ ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
1805
+ const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
1806
+ const ret = cachedTextEncoder.encodeInto(arg, view);
1807
+ offset += ret.written;
1808
+ ptr = realloc(ptr, len, offset, 1) >>> 0;
1298
1809
  }
1299
- };
1300
- if (Symbol.dispose) RpSignature.prototype[Symbol.dispose] = RpSignature.prototype.free;
1301
- var EXPECTED_RESPONSE_TYPES = /* @__PURE__ */ new Set(["basic", "cors", "default"]);
1810
+ WASM_VECTOR_LEN = offset;
1811
+ return ptr;
1812
+ }
1813
+ function takeObject(idx) {
1814
+ const ret = getObject(idx);
1815
+ dropObject(idx);
1816
+ return ret;
1817
+ }
1818
+ var cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
1819
+ cachedTextDecoder.decode();
1820
+ var MAX_SAFARI_DECODE_BYTES = 2146435072;
1821
+ var numBytesDecoded = 0;
1822
+ function decodeText(ptr, len) {
1823
+ numBytesDecoded += len;
1824
+ if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
1825
+ cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
1826
+ cachedTextDecoder.decode();
1827
+ numBytesDecoded = len;
1828
+ }
1829
+ return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
1830
+ }
1831
+ var cachedTextEncoder = new TextEncoder();
1832
+ if (!("encodeInto" in cachedTextEncoder)) {
1833
+ cachedTextEncoder.encodeInto = function(arg, view) {
1834
+ const buf = cachedTextEncoder.encode(arg);
1835
+ view.set(buf);
1836
+ return {
1837
+ read: arg.length,
1838
+ written: buf.length
1839
+ };
1840
+ };
1841
+ }
1842
+ var WASM_VECTOR_LEN = 0;
1843
+ var wasm;
1844
+ function __wbg_finalize_init(instance, module2) {
1845
+ wasm = instance.exports;
1846
+ cachedDataViewMemory0 = null;
1847
+ cachedUint8ArrayMemory0 = null;
1848
+ wasm.__wbindgen_start();
1849
+ return wasm;
1850
+ }
1302
1851
  async function __wbg_load(module2, imports) {
1303
1852
  if (typeof Response === "function" && module2 instanceof Response) {
1304
1853
  if (typeof WebAssembly.instantiateStreaming === "function") {
1305
1854
  try {
1306
1855
  return await WebAssembly.instantiateStreaming(module2, imports);
1307
1856
  } catch (e) {
1308
- const validResponse = module2.ok && EXPECTED_RESPONSE_TYPES.has(module2.type);
1857
+ const validResponse = module2.ok && expectedResponseType(module2.type);
1309
1858
  if (validResponse && module2.headers.get("Content-Type") !== "application/wasm") {
1310
1859
  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);
1311
1860
  } else {
@@ -1323,528 +1872,19 @@ async function __wbg_load(module2, imports) {
1323
1872
  return instance;
1324
1873
  }
1325
1874
  }
1326
- }
1327
- function __wbg_get_imports() {
1328
- const imports = {};
1329
- imports.wbg = {};
1330
- imports.wbg.__wbg_Error_e83987f665cf5504 = function(arg0, arg1) {
1331
- const ret = Error(getStringFromWasm0(arg0, arg1));
1332
- return addHeapObject(ret);
1333
- };
1334
- imports.wbg.__wbg_String_8f0eb39a4a4c2f66 = function(arg0, arg1) {
1335
- const ret = String(getObject(arg1));
1336
- const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1337
- const len1 = WASM_VECTOR_LEN;
1338
- getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
1339
- getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
1340
- };
1341
- imports.wbg.__wbg___wbindgen_bigint_get_as_i64_f3ebc5a755000afd = function(arg0, arg1) {
1342
- const v = getObject(arg1);
1343
- const ret = typeof v === "bigint" ? v : void 0;
1344
- getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
1345
- getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
1346
- };
1347
- imports.wbg.__wbg___wbindgen_boolean_get_6d5a1ee65bab5f68 = function(arg0) {
1348
- const v = getObject(arg0);
1349
- const ret = typeof v === "boolean" ? v : void 0;
1350
- return isLikeNone(ret) ? 16777215 : ret ? 1 : 0;
1351
- };
1352
- imports.wbg.__wbg___wbindgen_debug_string_df47ffb5e35e6763 = function(arg0, arg1) {
1353
- const ret = debugString(getObject(arg1));
1354
- const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1355
- const len1 = WASM_VECTOR_LEN;
1356
- getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
1357
- getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
1358
- };
1359
- imports.wbg.__wbg___wbindgen_in_bb933bd9e1b3bc0f = function(arg0, arg1) {
1360
- const ret = getObject(arg0) in getObject(arg1);
1361
- return ret;
1362
- };
1363
- imports.wbg.__wbg___wbindgen_is_bigint_cb320707dcd35f0b = function(arg0) {
1364
- const ret = typeof getObject(arg0) === "bigint";
1365
- return ret;
1366
- };
1367
- imports.wbg.__wbg___wbindgen_is_function_ee8a6c5833c90377 = function(arg0) {
1368
- const ret = typeof getObject(arg0) === "function";
1369
- return ret;
1370
- };
1371
- imports.wbg.__wbg___wbindgen_is_object_c818261d21f283a4 = function(arg0) {
1372
- const val = getObject(arg0);
1373
- const ret = typeof val === "object" && val !== null;
1374
- return ret;
1375
- };
1376
- imports.wbg.__wbg___wbindgen_is_string_fbb76cb2940daafd = function(arg0) {
1377
- const ret = typeof getObject(arg0) === "string";
1378
- return ret;
1379
- };
1380
- imports.wbg.__wbg___wbindgen_is_undefined_2d472862bd29a478 = function(arg0) {
1381
- const ret = getObject(arg0) === void 0;
1382
- return ret;
1383
- };
1384
- imports.wbg.__wbg___wbindgen_jsval_eq_6b13ab83478b1c50 = function(arg0, arg1) {
1385
- const ret = getObject(arg0) === getObject(arg1);
1386
- return ret;
1387
- };
1388
- imports.wbg.__wbg___wbindgen_jsval_loose_eq_b664b38a2f582147 = function(arg0, arg1) {
1389
- const ret = getObject(arg0) == getObject(arg1);
1390
- return ret;
1391
- };
1392
- imports.wbg.__wbg___wbindgen_number_get_a20bf9b85341449d = function(arg0, arg1) {
1393
- const obj = getObject(arg1);
1394
- const ret = typeof obj === "number" ? obj : void 0;
1395
- getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
1396
- getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
1397
- };
1398
- imports.wbg.__wbg___wbindgen_string_get_e4f06c90489ad01b = function(arg0, arg1) {
1399
- const obj = getObject(arg1);
1400
- const ret = typeof obj === "string" ? obj : void 0;
1401
- var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1402
- var len1 = WASM_VECTOR_LEN;
1403
- getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
1404
- getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
1405
- };
1406
- imports.wbg.__wbg___wbindgen_throw_b855445ff6a94295 = function(arg0, arg1) {
1407
- throw new Error(getStringFromWasm0(arg0, arg1));
1408
- };
1409
- imports.wbg.__wbg__wbg_cb_unref_2454a539ea5790d9 = function(arg0) {
1410
- getObject(arg0)._wbg_cb_unref();
1411
- };
1412
- imports.wbg.__wbg_abort_28ad55c5825b004d = function(arg0, arg1) {
1413
- getObject(arg0).abort(getObject(arg1));
1414
- };
1415
- imports.wbg.__wbg_abort_e7eb059f72f9ed0c = function(arg0) {
1416
- getObject(arg0).abort();
1417
- };
1418
- imports.wbg.__wbg_append_b577eb3a177bc0fa = function() {
1419
- return handleError(function(arg0, arg1, arg2, arg3, arg4) {
1420
- getObject(arg0).append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
1421
- }, arguments);
1422
- };
1423
- imports.wbg.__wbg_arrayBuffer_b375eccb84b4ddf3 = function() {
1424
- return handleError(function(arg0) {
1425
- const ret = getObject(arg0).arrayBuffer();
1426
- return addHeapObject(ret);
1427
- }, arguments);
1428
- };
1429
- imports.wbg.__wbg_call_525440f72fbfc0ea = function() {
1430
- return handleError(function(arg0, arg1, arg2) {
1431
- const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
1432
- return addHeapObject(ret);
1433
- }, arguments);
1434
- };
1435
- imports.wbg.__wbg_call_e762c39fa8ea36bf = function() {
1436
- return handleError(function(arg0, arg1) {
1437
- const ret = getObject(arg0).call(getObject(arg1));
1438
- return addHeapObject(ret);
1439
- }, arguments);
1440
- };
1441
- imports.wbg.__wbg_clearTimeout_7a42b49784aea641 = function(arg0) {
1442
- const ret = clearTimeout(takeObject(arg0));
1443
- return addHeapObject(ret);
1444
- };
1445
- imports.wbg.__wbg_crypto_574e78ad8b13b65f = function(arg0) {
1446
- const ret = getObject(arg0).crypto;
1447
- return addHeapObject(ret);
1448
- };
1449
- imports.wbg.__wbg_done_2042aa2670fb1db1 = function(arg0) {
1450
- const ret = getObject(arg0).done;
1451
- return ret;
1452
- };
1453
- imports.wbg.__wbg_entries_e171b586f8f6bdbf = function(arg0) {
1454
- const ret = Object.entries(getObject(arg0));
1455
- return addHeapObject(ret);
1456
- };
1457
- imports.wbg.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
1458
- let deferred0_0;
1459
- let deferred0_1;
1460
- try {
1461
- deferred0_0 = arg0;
1462
- deferred0_1 = arg1;
1463
- console.error(getStringFromWasm0(arg0, arg1));
1464
- } finally {
1465
- wasm.__wbindgen_export4(deferred0_0, deferred0_1, 1);
1466
- }
1467
- };
1468
- imports.wbg.__wbg_fetch_74a3e84ebd2c9a0e = function(arg0) {
1469
- const ret = fetch(getObject(arg0));
1470
- return addHeapObject(ret);
1471
- };
1472
- imports.wbg.__wbg_fetch_f8ba0e29a9d6de0d = function(arg0, arg1) {
1473
- const ret = getObject(arg0).fetch(getObject(arg1));
1474
- return addHeapObject(ret);
1475
- };
1476
- imports.wbg.__wbg_getRandomValues_38a1ff1ea09f6cc7 = function() {
1477
- return handleError(function(arg0, arg1) {
1478
- globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
1479
- }, arguments);
1480
- };
1481
- imports.wbg.__wbg_getRandomValues_b8f5dbd5f3995a9e = function() {
1482
- return handleError(function(arg0, arg1) {
1483
- getObject(arg0).getRandomValues(getObject(arg1));
1484
- }, arguments);
1485
- };
1486
- imports.wbg.__wbg_get_7bed016f185add81 = function(arg0, arg1) {
1487
- const ret = getObject(arg0)[arg1 >>> 0];
1488
- return addHeapObject(ret);
1489
- };
1490
- imports.wbg.__wbg_get_efcb449f58ec27c2 = function() {
1491
- return handleError(function(arg0, arg1) {
1492
- const ret = Reflect.get(getObject(arg0), getObject(arg1));
1493
- return addHeapObject(ret);
1494
- }, arguments);
1495
- };
1496
- imports.wbg.__wbg_has_787fafc980c3ccdb = function() {
1497
- return handleError(function(arg0, arg1) {
1498
- const ret = Reflect.has(getObject(arg0), getObject(arg1));
1499
- return ret;
1500
- }, arguments);
1501
- };
1502
- imports.wbg.__wbg_headers_b87d7eaba61c3278 = function(arg0) {
1503
- const ret = getObject(arg0).headers;
1504
- return addHeapObject(ret);
1505
- };
1506
- imports.wbg.__wbg_idkitrequest_new = function(arg0) {
1507
- const ret = IDKitRequest.__wrap(arg0);
1508
- return addHeapObject(ret);
1509
- };
1510
- imports.wbg.__wbg_instanceof_ArrayBuffer_70beb1189ca63b38 = function(arg0) {
1511
- let result;
1512
- try {
1513
- result = getObject(arg0) instanceof ArrayBuffer;
1514
- } catch (_) {
1515
- result = false;
1516
- }
1517
- const ret = result;
1518
- return ret;
1519
- };
1520
- imports.wbg.__wbg_instanceof_Map_8579b5e2ab5437c7 = function(arg0) {
1521
- let result;
1522
- try {
1523
- result = getObject(arg0) instanceof Map;
1524
- } catch (_) {
1525
- result = false;
1526
- }
1527
- const ret = result;
1528
- return ret;
1529
- };
1530
- imports.wbg.__wbg_instanceof_Response_f4f3e87e07f3135c = function(arg0) {
1531
- let result;
1532
- try {
1533
- result = getObject(arg0) instanceof Response;
1534
- } catch (_) {
1535
- result = false;
1536
- }
1537
- const ret = result;
1538
- return ret;
1539
- };
1540
- imports.wbg.__wbg_instanceof_Uint8Array_20c8e73002f7af98 = function(arg0) {
1541
- let result;
1542
- try {
1543
- result = getObject(arg0) instanceof Uint8Array;
1544
- } catch (_) {
1545
- result = false;
1546
- }
1547
- const ret = result;
1548
- return ret;
1549
- };
1550
- imports.wbg.__wbg_isArray_96e0af9891d0945d = function(arg0) {
1551
- const ret = Array.isArray(getObject(arg0));
1552
- return ret;
1553
- };
1554
- imports.wbg.__wbg_isSafeInteger_d216eda7911dde36 = function(arg0) {
1555
- const ret = Number.isSafeInteger(getObject(arg0));
1556
- return ret;
1557
- };
1558
- imports.wbg.__wbg_iterator_e5822695327a3c39 = function() {
1559
- const ret = Symbol.iterator;
1560
- return addHeapObject(ret);
1561
- };
1562
- imports.wbg.__wbg_length_69bca3cb64fc8748 = function(arg0) {
1563
- const ret = getObject(arg0).length;
1564
- return ret;
1565
- };
1566
- imports.wbg.__wbg_length_cdd215e10d9dd507 = function(arg0) {
1567
- const ret = getObject(arg0).length;
1568
- return ret;
1569
- };
1570
- imports.wbg.__wbg_msCrypto_a61aeb35a24c1329 = function(arg0) {
1571
- const ret = getObject(arg0).msCrypto;
1572
- return addHeapObject(ret);
1573
- };
1574
- imports.wbg.__wbg_new_1acc0b6eea89d040 = function() {
1575
- const ret = new Object();
1576
- return addHeapObject(ret);
1577
- };
1578
- imports.wbg.__wbg_new_2531773dac38ebb3 = function() {
1579
- return handleError(function() {
1580
- const ret = new AbortController();
1581
- return addHeapObject(ret);
1582
- }, arguments);
1583
- };
1584
- imports.wbg.__wbg_new_3c3d849046688a66 = function(arg0, arg1) {
1585
- try {
1586
- var state0 = { a: arg0, b: arg1 };
1587
- var cb0 = (arg02, arg12) => {
1588
- const a = state0.a;
1589
- state0.a = 0;
1590
- try {
1591
- return __wasm_bindgen_func_elem_1367(a, state0.b, arg02, arg12);
1592
- } finally {
1593
- state0.a = a;
1594
- }
1595
- };
1596
- const ret = new Promise(cb0);
1597
- return addHeapObject(ret);
1598
- } finally {
1599
- state0.a = state0.b = 0;
1875
+ function expectedResponseType(type) {
1876
+ switch (type) {
1877
+ case "basic":
1878
+ case "cors":
1879
+ case "default":
1880
+ return true;
1600
1881
  }
1601
- };
1602
- imports.wbg.__wbg_new_5a79be3ab53b8aa5 = function(arg0) {
1603
- const ret = new Uint8Array(getObject(arg0));
1604
- return addHeapObject(ret);
1605
- };
1606
- imports.wbg.__wbg_new_68651c719dcda04e = function() {
1607
- const ret = /* @__PURE__ */ new Map();
1608
- return addHeapObject(ret);
1609
- };
1610
- imports.wbg.__wbg_new_8a6f238a6ece86ea = function() {
1611
- const ret = new Error();
1612
- return addHeapObject(ret);
1613
- };
1614
- imports.wbg.__wbg_new_9edf9838a2def39c = function() {
1615
- return handleError(function() {
1616
- const ret = new Headers();
1617
- return addHeapObject(ret);
1618
- }, arguments);
1619
- };
1620
- imports.wbg.__wbg_new_e17d9f43105b08be = function() {
1621
- const ret = new Array();
1622
- return addHeapObject(ret);
1623
- };
1624
- imports.wbg.__wbg_new_from_slice_92f4d78ca282a2d2 = function(arg0, arg1) {
1625
- const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
1626
- return addHeapObject(ret);
1627
- };
1628
- imports.wbg.__wbg_new_no_args_ee98eee5275000a4 = function(arg0, arg1) {
1629
- const ret = new Function(getStringFromWasm0(arg0, arg1));
1630
- return addHeapObject(ret);
1631
- };
1632
- imports.wbg.__wbg_new_with_length_01aa0dc35aa13543 = function(arg0) {
1633
- const ret = new Uint8Array(arg0 >>> 0);
1634
- return addHeapObject(ret);
1635
- };
1636
- imports.wbg.__wbg_new_with_str_and_init_0ae7728b6ec367b1 = function() {
1637
- return handleError(function(arg0, arg1, arg2) {
1638
- const ret = new Request(getStringFromWasm0(arg0, arg1), getObject(arg2));
1639
- return addHeapObject(ret);
1640
- }, arguments);
1641
- };
1642
- imports.wbg.__wbg_next_020810e0ae8ebcb0 = function() {
1643
- return handleError(function(arg0) {
1644
- const ret = getObject(arg0).next();
1645
- return addHeapObject(ret);
1646
- }, arguments);
1647
- };
1648
- imports.wbg.__wbg_next_2c826fe5dfec6b6a = function(arg0) {
1649
- const ret = getObject(arg0).next;
1650
- return addHeapObject(ret);
1651
- };
1652
- imports.wbg.__wbg_node_905d3e251edff8a2 = function(arg0) {
1653
- const ret = getObject(arg0).node;
1654
- return addHeapObject(ret);
1655
- };
1656
- imports.wbg.__wbg_now_793306c526e2e3b6 = function() {
1657
- const ret = Date.now();
1658
- return ret;
1659
- };
1660
- imports.wbg.__wbg_process_dc0fbacc7c1c06f7 = function(arg0) {
1661
- const ret = getObject(arg0).process;
1662
- return addHeapObject(ret);
1663
- };
1664
- imports.wbg.__wbg_prototypesetcall_2a6620b6922694b2 = function(arg0, arg1, arg2) {
1665
- Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
1666
- };
1667
- imports.wbg.__wbg_queueMicrotask_34d692c25c47d05b = function(arg0) {
1668
- const ret = getObject(arg0).queueMicrotask;
1669
- return addHeapObject(ret);
1670
- };
1671
- imports.wbg.__wbg_queueMicrotask_9d76cacb20c84d58 = function(arg0) {
1672
- queueMicrotask(getObject(arg0));
1673
- };
1674
- imports.wbg.__wbg_randomFillSync_ac0988aba3254290 = function() {
1675
- return handleError(function(arg0, arg1) {
1676
- getObject(arg0).randomFillSync(takeObject(arg1));
1677
- }, arguments);
1678
- };
1679
- imports.wbg.__wbg_require_60cc747a6bc5215a = function() {
1680
- return handleError(function() {
1681
- const ret = module.require;
1682
- return addHeapObject(ret);
1683
- }, arguments);
1684
- };
1685
- imports.wbg.__wbg_resolve_caf97c30b83f7053 = function(arg0) {
1686
- const ret = Promise.resolve(getObject(arg0));
1687
- return addHeapObject(ret);
1688
- };
1689
- imports.wbg.__wbg_setTimeout_7bb3429662ab1e70 = function(arg0, arg1) {
1690
- const ret = setTimeout(getObject(arg0), arg1);
1691
- return addHeapObject(ret);
1692
- };
1693
- imports.wbg.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
1694
- getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
1695
- };
1696
- imports.wbg.__wbg_set_907fb406c34a251d = function(arg0, arg1, arg2) {
1697
- const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
1698
- return addHeapObject(ret);
1699
- };
1700
- imports.wbg.__wbg_set_body_3c365989753d61f4 = function(arg0, arg1) {
1701
- getObject(arg0).body = getObject(arg1);
1702
- };
1703
- imports.wbg.__wbg_set_c213c871859d6500 = function(arg0, arg1, arg2) {
1704
- getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
1705
- };
1706
- imports.wbg.__wbg_set_c2abbebe8b9ebee1 = function() {
1707
- return handleError(function(arg0, arg1, arg2) {
1708
- const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
1709
- return ret;
1710
- }, arguments);
1711
- };
1712
- imports.wbg.__wbg_set_cache_2f9deb19b92b81e3 = function(arg0, arg1) {
1713
- getObject(arg0).cache = __wbindgen_enum_RequestCache[arg1];
1714
- };
1715
- imports.wbg.__wbg_set_credentials_f621cd2d85c0c228 = function(arg0, arg1) {
1716
- getObject(arg0).credentials = __wbindgen_enum_RequestCredentials[arg1];
1717
- };
1718
- imports.wbg.__wbg_set_headers_6926da238cd32ee4 = function(arg0, arg1) {
1719
- getObject(arg0).headers = getObject(arg1);
1720
- };
1721
- imports.wbg.__wbg_set_method_c02d8cbbe204ac2d = function(arg0, arg1, arg2) {
1722
- getObject(arg0).method = getStringFromWasm0(arg1, arg2);
1723
- };
1724
- imports.wbg.__wbg_set_mode_52ef73cfa79639cb = function(arg0, arg1) {
1725
- getObject(arg0).mode = __wbindgen_enum_RequestMode[arg1];
1726
- };
1727
- imports.wbg.__wbg_set_signal_dda2cf7ccb6bee0f = function(arg0, arg1) {
1728
- getObject(arg0).signal = getObject(arg1);
1729
- };
1730
- imports.wbg.__wbg_signal_4db5aa055bf9eb9a = function(arg0) {
1731
- const ret = getObject(arg0).signal;
1732
- return addHeapObject(ret);
1733
- };
1734
- imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
1735
- const ret = getObject(arg1).stack;
1736
- const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1737
- const len1 = WASM_VECTOR_LEN;
1738
- getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
1739
- getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
1740
- };
1741
- imports.wbg.__wbg_static_accessor_GLOBAL_89e1d9ac6a1b250e = function() {
1742
- const ret = typeof global === "undefined" ? null : global;
1743
- return isLikeNone(ret) ? 0 : addHeapObject(ret);
1744
- };
1745
- imports.wbg.__wbg_static_accessor_GLOBAL_THIS_8b530f326a9e48ac = function() {
1746
- const ret = typeof globalThis === "undefined" ? null : globalThis;
1747
- return isLikeNone(ret) ? 0 : addHeapObject(ret);
1748
- };
1749
- imports.wbg.__wbg_static_accessor_SELF_6fdf4b64710cc91b = function() {
1750
- const ret = typeof self === "undefined" ? null : self;
1751
- return isLikeNone(ret) ? 0 : addHeapObject(ret);
1752
- };
1753
- imports.wbg.__wbg_static_accessor_WINDOW_b45bfc5a37f6cfa2 = function() {
1754
- const ret = typeof window === "undefined" ? null : window;
1755
- return isLikeNone(ret) ? 0 : addHeapObject(ret);
1756
- };
1757
- imports.wbg.__wbg_status_de7eed5a7a5bfd5d = function(arg0) {
1758
- const ret = getObject(arg0).status;
1759
- return ret;
1760
- };
1761
- imports.wbg.__wbg_stringify_b5fb28f6465d9c3e = function() {
1762
- return handleError(function(arg0) {
1763
- const ret = JSON.stringify(getObject(arg0));
1764
- return addHeapObject(ret);
1765
- }, arguments);
1766
- };
1767
- imports.wbg.__wbg_subarray_480600f3d6a9f26c = function(arg0, arg1, arg2) {
1768
- const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
1769
- return addHeapObject(ret);
1770
- };
1771
- imports.wbg.__wbg_text_dc33c15c17bdfb52 = function() {
1772
- return handleError(function(arg0) {
1773
- const ret = getObject(arg0).text();
1774
- return addHeapObject(ret);
1775
- }, arguments);
1776
- };
1777
- imports.wbg.__wbg_then_4f46f6544e6b4a28 = function(arg0, arg1) {
1778
- const ret = getObject(arg0).then(getObject(arg1));
1779
- return addHeapObject(ret);
1780
- };
1781
- imports.wbg.__wbg_then_70d05cf780a18d77 = function(arg0, arg1, arg2) {
1782
- const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
1783
- return addHeapObject(ret);
1784
- };
1785
- imports.wbg.__wbg_url_b36d2a5008eb056f = function(arg0, arg1) {
1786
- const ret = getObject(arg1).url;
1787
- const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1788
- const len1 = WASM_VECTOR_LEN;
1789
- getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
1790
- getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
1791
- };
1792
- imports.wbg.__wbg_value_692627309814bb8c = function(arg0) {
1793
- const ret = getObject(arg0).value;
1794
- return addHeapObject(ret);
1795
- };
1796
- imports.wbg.__wbg_versions_c01dfd4722a88165 = function(arg0) {
1797
- const ret = getObject(arg0).versions;
1798
- return addHeapObject(ret);
1799
- };
1800
- imports.wbg.__wbindgen_cast_0c688d3d5dd51bcb = function(arg0, arg1) {
1801
- const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_981, __wasm_bindgen_func_elem_982);
1802
- return addHeapObject(ret);
1803
- };
1804
- imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
1805
- const ret = getStringFromWasm0(arg0, arg1);
1806
- return addHeapObject(ret);
1807
- };
1808
- imports.wbg.__wbindgen_cast_26df652e200d9104 = function(arg0, arg1) {
1809
- const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_618, __wasm_bindgen_func_elem_619);
1810
- return addHeapObject(ret);
1811
- };
1812
- imports.wbg.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
1813
- const ret = BigInt.asUintN(64, arg0);
1814
- return addHeapObject(ret);
1815
- };
1816
- imports.wbg.__wbindgen_cast_9ae0607507abb057 = function(arg0) {
1817
- const ret = arg0;
1818
- return addHeapObject(ret);
1819
- };
1820
- imports.wbg.__wbindgen_cast_cb9088102bce6b30 = function(arg0, arg1) {
1821
- const ret = getArrayU8FromWasm0(arg0, arg1);
1822
- return addHeapObject(ret);
1823
- };
1824
- imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
1825
- const ret = arg0;
1826
- return addHeapObject(ret);
1827
- };
1828
- imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
1829
- const ret = getObject(arg0);
1830
- return addHeapObject(ret);
1831
- };
1832
- imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
1833
- takeObject(arg0);
1834
- };
1835
- return imports;
1836
- }
1837
- function __wbg_finalize_init(instance, module2) {
1838
- wasm = instance.exports;
1839
- __wbg_init.__wbindgen_wasm_module = module2;
1840
- cachedDataViewMemory0 = null;
1841
- cachedUint8ArrayMemory0 = null;
1842
- wasm.__wbindgen_start();
1843
- return wasm;
1882
+ return false;
1883
+ }
1844
1884
  }
1845
1885
  function initSync(module2) {
1846
1886
  if (wasm !== void 0) return wasm;
1847
- if (typeof module2 !== "undefined") {
1887
+ if (module2 !== void 0) {
1848
1888
  if (Object.getPrototypeOf(module2) === Object.prototype) {
1849
1889
  ({ module: module2 } = module2);
1850
1890
  } else {
@@ -1856,18 +1896,18 @@ function initSync(module2) {
1856
1896
  module2 = new WebAssembly.Module(module2);
1857
1897
  }
1858
1898
  const instance = new WebAssembly.Instance(module2, imports);
1859
- return __wbg_finalize_init(instance, module2);
1899
+ return __wbg_finalize_init(instance);
1860
1900
  }
1861
1901
  async function __wbg_init(module_or_path) {
1862
1902
  if (wasm !== void 0) return wasm;
1863
- if (typeof module_or_path !== "undefined") {
1903
+ if (module_or_path !== void 0) {
1864
1904
  if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
1865
1905
  ({ module_or_path } = module_or_path);
1866
1906
  } else {
1867
1907
  console.warn("using deprecated parameters for the initialization function; pass a single object instead");
1868
1908
  }
1869
1909
  }
1870
- if (typeof module_or_path === "undefined") {
1910
+ if (module_or_path === void 0) {
1871
1911
  module_or_path = new URL("idkit_wasm_bg.wasm", import.meta.url);
1872
1912
  }
1873
1913
  const imports = __wbg_get_imports();
@@ -1875,9 +1915,8 @@ async function __wbg_init(module_or_path) {
1875
1915
  module_or_path = fetch(module_or_path);
1876
1916
  }
1877
1917
  const { instance, module: module2 } = await __wbg_load(await module_or_path, imports);
1878
- return __wbg_finalize_init(instance, module2);
1918
+ return __wbg_finalize_init(instance);
1879
1919
  }
1880
- var idkit_wasm_default = __wbg_init;
1881
1920
 
1882
1921
  // src/lib/wasm.ts
1883
1922
  var wasmInitialized = false;
@@ -1891,7 +1930,7 @@ async function initIDKit() {
1891
1930
  }
1892
1931
  wasmInitPromise = (async () => {
1893
1932
  try {
1894
- await idkit_wasm_default();
1933
+ await __wbg_init();
1895
1934
  wasmInitialized = true;
1896
1935
  } catch (error) {
1897
1936
  wasmInitPromise = null;
@@ -1914,7 +1953,7 @@ function getWorldAppVerifyVersion() {
1914
1953
  }
1915
1954
  var _requestCounter = 0;
1916
1955
  var _activeNativeRequest = null;
1917
- function createNativeRequest(wasmPayload, config, signalHashes = {}, version) {
1956
+ function createNativeRequest(wasmPayload, config, signalHashes = {}, legacySignalHash, version = 2) {
1918
1957
  if (_activeNativeRequest?.isPending()) {
1919
1958
  console.warn(
1920
1959
  "IDKit native request already in flight. Reusing active request."
@@ -1925,13 +1964,14 @@ function createNativeRequest(wasmPayload, config, signalHashes = {}, version) {
1925
1964
  wasmPayload,
1926
1965
  config,
1927
1966
  signalHashes,
1967
+ legacySignalHash,
1928
1968
  version
1929
1969
  );
1930
1970
  _activeNativeRequest = request2;
1931
1971
  return request2;
1932
1972
  }
1933
1973
  var NativeIDKitRequest = class {
1934
- constructor(wasmPayload, config, signalHashes = {}, version) {
1974
+ constructor(wasmPayload, config, signalHashes = {}, legacySignalHash, version = 2) {
1935
1975
  this.connectorURI = "";
1936
1976
  this.resolved = false;
1937
1977
  this.cancelled = false;
@@ -1958,7 +1998,8 @@ var NativeIDKitRequest = class {
1958
1998
  const result = nativeResultToIDKitResult(
1959
1999
  responsePayload,
1960
2000
  config,
1961
- signalHashes
2001
+ signalHashes,
2002
+ legacySignalHash
1962
2003
  );
1963
2004
  this.resolvedResult = result;
1964
2005
  this.cleanup();
@@ -2096,7 +2137,7 @@ var NativeVerifyError = class extends Error {
2096
2137
  this.code = code;
2097
2138
  }
2098
2139
  };
2099
- function nativeResultToIDKitResult(payload, config, signalHashes) {
2140
+ function nativeResultToIDKitResult(payload, config, signalHashes, legacySignalHash) {
2100
2141
  const p = payload;
2101
2142
  const rpNonce = config.rp_context?.nonce ?? "";
2102
2143
  if ("responses" in p && Array.isArray(p.responses)) {
@@ -2142,7 +2183,7 @@ function nativeResultToIDKitResult(payload, config, signalHashes) {
2142
2183
  action: config.action ?? "",
2143
2184
  responses: verifications.map((v) => ({
2144
2185
  identifier: v.verification_level,
2145
- signal_hash: v.signal_hash ?? signalHashes[v.verification_level],
2186
+ signal_hash: v.signal_hash ?? signalHashes[v.verification_level] ?? legacySignalHash,
2146
2187
  proof: v.proof,
2147
2188
  merkle_root: v.merkle_root,
2148
2189
  nullifier: v.nullifier_hash
@@ -2157,7 +2198,7 @@ function nativeResultToIDKitResult(payload, config, signalHashes) {
2157
2198
  responses: [
2158
2199
  {
2159
2200
  identifier: p.verification_level,
2160
- signal_hash: p.signal_hash ?? signalHashes[p.verification_level],
2201
+ signal_hash: p.signal_hash ?? signalHashes[p.verification_level] ?? legacySignalHash,
2161
2202
  proof: p.proof,
2162
2203
  merkle_root: p.merkle_root,
2163
2204
  nullifier: p.nullifier_hash
@@ -2279,7 +2320,7 @@ var IDKitBuilder2 = class {
2279
2320
  * @example
2280
2321
  * ```typescript
2281
2322
  * const request = await IDKit.request({ app_id, action, rp_context, allow_legacy_proofs: false })
2282
- * .constraints(any(CredentialRequest('orb'), CredentialRequest('face')));
2323
+ * .constraints(any(CredentialRequest('proof_of_human'), CredentialRequest('face')));
2283
2324
  * ```
2284
2325
  */
2285
2326
  async constraints(constraints) {
@@ -2297,6 +2338,7 @@ var IDKitBuilder2 = class {
2297
2338
  wasmResult.payload,
2298
2339
  this.config,
2299
2340
  wasmResult.signal_hashes ?? {},
2341
+ wasmResult.legacy_signal_hash ?? void 0,
2300
2342
  2
2301
2343
  );
2302
2344
  }
@@ -2332,6 +2374,7 @@ var IDKitBuilder2 = class {
2332
2374
  wasmResult.payload,
2333
2375
  this.config,
2334
2376
  wasmResult.signal_hashes ?? {},
2377
+ wasmResult.legacy_signal_hash ?? void 0,
2335
2378
  2
2336
2379
  );
2337
2380
  }
@@ -2342,6 +2385,7 @@ var IDKitBuilder2 = class {
2342
2385
  wasmResult.payload,
2343
2386
  this.config,
2344
2387
  wasmResult.signal_hashes ?? {},
2388
+ wasmResult.legacy_signal_hash ?? void 0,
2345
2389
  1
2346
2390
  );
2347
2391
  } catch (err) {
@@ -2448,4 +2492,4 @@ function isValidHex(s) {
2448
2492
  return /^[0-9a-fA-F]+$/.test(s);
2449
2493
  }
2450
2494
 
2451
- export { IDKit, IDKitErrorCodes, deviceLegacy, documentLegacy, hashSignal2 as hashSignal, isNode, isReactNative, isWeb, orbLegacy, secureDocumentLegacy, selfieCheckLegacy };
2495
+ export { IDKit, IDKitErrorCodes, deviceLegacy, documentLegacy, hashSignal2 as hashSignal, isInWorldApp, isNode, isReactNative, isWeb, orbLegacy, secureDocumentLegacy, selfieCheckLegacy };