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