@spacesprotocol/libveritas 0.1.2 → 0.1.3

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 (4) hide show
  1. package/libveritas.d.ts +57 -61
  2. package/libveritas.js +670 -327
  3. package/libveritas_bg.wasm +0 -0
  4. package/package.json +1 -1
package/libveritas.js CHANGED
@@ -15,25 +15,41 @@ export class Anchors {
15
15
  * @returns {any}
16
16
  */
17
17
  computeTrustSet() {
18
- const ret = wasm.anchors_computeTrustSet(this.__wbg_ptr);
19
- if (ret[2]) {
20
- throw takeFromExternrefTable0(ret[1]);
18
+ try {
19
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
20
+ wasm.anchors_computeTrustSet(retptr, this.__wbg_ptr);
21
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
22
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
23
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
24
+ if (r2) {
25
+ throw takeObject(r1);
26
+ }
27
+ return takeObject(r0);
28
+ } finally {
29
+ wasm.__wbindgen_add_to_stack_pointer(16);
21
30
  }
22
- return takeFromExternrefTable0(ret[0]);
23
31
  }
24
32
  /**
25
33
  * @param {string} json
26
34
  */
27
35
  constructor(json) {
28
- const ptr0 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
29
- const len0 = WASM_VECTOR_LEN;
30
- const ret = wasm.anchors_from_json(ptr0, len0);
31
- if (ret[2]) {
32
- throw takeFromExternrefTable0(ret[1]);
36
+ try {
37
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
38
+ const ptr0 = passStringToWasm0(json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
39
+ const len0 = WASM_VECTOR_LEN;
40
+ wasm.anchors_from_json(retptr, ptr0, len0);
41
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
42
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
43
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
44
+ if (r2) {
45
+ throw takeObject(r1);
46
+ }
47
+ this.__wbg_ptr = r0 >>> 0;
48
+ AnchorsFinalization.register(this, this.__wbg_ptr, this);
49
+ return this;
50
+ } finally {
51
+ wasm.__wbindgen_add_to_stack_pointer(16);
33
52
  }
34
- this.__wbg_ptr = ret[0] >>> 0;
35
- AnchorsFinalization.register(this, this.__wbg_ptr, this);
36
- return this;
37
53
  }
38
54
  }
39
55
  if (Symbol.dispose) Anchors.prototype[Symbol.dispose] = Anchors.prototype.free;
@@ -59,13 +75,22 @@ export class Lookup {
59
75
  * @returns {string[]}
60
76
  */
61
77
  advance(zones) {
62
- const ret = wasm.lookup_advance(this.__wbg_ptr, zones);
63
- if (ret[3]) {
64
- throw takeFromExternrefTable0(ret[2]);
78
+ try {
79
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
80
+ wasm.lookup_advance(retptr, this.__wbg_ptr, addHeapObject(zones));
81
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
82
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
83
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
84
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
85
+ if (r3) {
86
+ throw takeObject(r2);
87
+ }
88
+ var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
89
+ wasm.__wbindgen_export4(r0, r1 * 4, 4);
90
+ return v1;
91
+ } finally {
92
+ wasm.__wbindgen_add_to_stack_pointer(16);
65
93
  }
66
- var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
67
- wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
68
- return v1;
69
94
  }
70
95
  /**
71
96
  * Expand zone handles using the alias map accumulated during resolution.
@@ -73,36 +98,59 @@ export class Lookup {
73
98
  * @returns {any}
74
99
  */
75
100
  expandZones(zones) {
76
- const ret = wasm.lookup_expandZones(this.__wbg_ptr, zones);
77
- if (ret[2]) {
78
- throw takeFromExternrefTable0(ret[1]);
101
+ try {
102
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
103
+ wasm.lookup_expandZones(retptr, this.__wbg_ptr, addHeapObject(zones));
104
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
105
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
106
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
107
+ if (r2) {
108
+ throw takeObject(r1);
109
+ }
110
+ return takeObject(r0);
111
+ } finally {
112
+ wasm.__wbindgen_add_to_stack_pointer(16);
79
113
  }
80
- return takeFromExternrefTable0(ret[0]);
81
114
  }
82
115
  /**
83
116
  * Create a lookup from an array of handle name strings.
84
117
  * @param {string[]} names
85
118
  */
86
119
  constructor(names) {
87
- const ptr0 = passArrayJsValueToWasm0(names, wasm.__wbindgen_malloc);
88
- const len0 = WASM_VECTOR_LEN;
89
- const ret = wasm.lookup_new(ptr0, len0);
90
- if (ret[2]) {
91
- throw takeFromExternrefTable0(ret[1]);
120
+ try {
121
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
122
+ const ptr0 = passArrayJsValueToWasm0(names, wasm.__wbindgen_export);
123
+ const len0 = WASM_VECTOR_LEN;
124
+ wasm.lookup_new(retptr, ptr0, len0);
125
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
126
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
127
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
128
+ if (r2) {
129
+ throw takeObject(r1);
130
+ }
131
+ this.__wbg_ptr = r0 >>> 0;
132
+ LookupFinalization.register(this, this.__wbg_ptr, this);
133
+ return this;
134
+ } finally {
135
+ wasm.__wbindgen_add_to_stack_pointer(16);
92
136
  }
93
- this.__wbg_ptr = ret[0] >>> 0;
94
- LookupFinalization.register(this, this.__wbg_ptr, this);
95
- return this;
96
137
  }
97
138
  /**
98
139
  * Returns the first batch of handles to look up.
99
140
  * @returns {string[]}
100
141
  */
101
142
  start() {
102
- const ret = wasm.lookup_start(this.__wbg_ptr);
103
- var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
104
- wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
105
- return v1;
143
+ try {
144
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
145
+ wasm.lookup_start(retptr, this.__wbg_ptr);
146
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
147
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
148
+ var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
149
+ wasm.__wbindgen_export4(r0, r1 * 4, 4);
150
+ return v1;
151
+ } finally {
152
+ wasm.__wbindgen_add_to_stack_pointer(16);
153
+ }
106
154
  }
107
155
  }
108
156
  if (Symbol.dispose) Lookup.prototype[Symbol.dispose] = Lookup.prototype.free;
@@ -133,15 +181,23 @@ export class Message {
133
181
  * @param {Uint8Array} bytes
134
182
  */
135
183
  constructor(bytes) {
136
- const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
137
- const len0 = WASM_VECTOR_LEN;
138
- const ret = wasm.message_from_bytes(ptr0, len0);
139
- if (ret[2]) {
140
- throw takeFromExternrefTable0(ret[1]);
184
+ try {
185
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
186
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
187
+ const len0 = WASM_VECTOR_LEN;
188
+ wasm.message_from_bytes(retptr, ptr0, len0);
189
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
190
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
191
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
192
+ if (r2) {
193
+ throw takeObject(r1);
194
+ }
195
+ this.__wbg_ptr = r0 >>> 0;
196
+ MessageFinalization.register(this, this.__wbg_ptr, this);
197
+ return this;
198
+ } finally {
199
+ wasm.__wbindgen_add_to_stack_pointer(16);
141
200
  }
142
- this.__wbg_ptr = ret[0] >>> 0;
143
- MessageFinalization.register(this, this.__wbg_ptr, this);
144
- return this;
145
201
  }
146
202
  /**
147
203
  * Set delegate records on the message for a canonical name.
@@ -149,13 +205,20 @@ export class Message {
149
205
  * @param {Uint8Array} records_bytes
150
206
  */
151
207
  setDelegateRecords(canonical, records_bytes) {
152
- const ptr0 = passStringToWasm0(canonical, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
153
- const len0 = WASM_VECTOR_LEN;
154
- const ptr1 = passArray8ToWasm0(records_bytes, wasm.__wbindgen_malloc);
155
- const len1 = WASM_VECTOR_LEN;
156
- const ret = wasm.message_setDelegateRecords(this.__wbg_ptr, ptr0, len0, ptr1, len1);
157
- if (ret[1]) {
158
- throw takeFromExternrefTable0(ret[0]);
208
+ try {
209
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
210
+ const ptr0 = passStringToWasm0(canonical, wasm.__wbindgen_export, wasm.__wbindgen_export2);
211
+ const len0 = WASM_VECTOR_LEN;
212
+ const ptr1 = passArray8ToWasm0(records_bytes, wasm.__wbindgen_export);
213
+ const len1 = WASM_VECTOR_LEN;
214
+ wasm.message_setDelegateRecords(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
215
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
216
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
217
+ if (r1) {
218
+ throw takeObject(r0);
219
+ }
220
+ } finally {
221
+ wasm.__wbindgen_add_to_stack_pointer(16);
159
222
  }
160
223
  }
161
224
  /**
@@ -164,13 +227,20 @@ export class Message {
164
227
  * @param {Uint8Array} records_bytes
165
228
  */
166
229
  setRecords(canonical, records_bytes) {
167
- const ptr0 = passStringToWasm0(canonical, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
168
- const len0 = WASM_VECTOR_LEN;
169
- const ptr1 = passArray8ToWasm0(records_bytes, wasm.__wbindgen_malloc);
170
- const len1 = WASM_VECTOR_LEN;
171
- const ret = wasm.message_setRecords(this.__wbg_ptr, ptr0, len0, ptr1, len1);
172
- if (ret[1]) {
173
- throw takeFromExternrefTable0(ret[0]);
230
+ try {
231
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
232
+ const ptr0 = passStringToWasm0(canonical, wasm.__wbindgen_export, wasm.__wbindgen_export2);
233
+ const len0 = WASM_VECTOR_LEN;
234
+ const ptr1 = passArray8ToWasm0(records_bytes, wasm.__wbindgen_export);
235
+ const len1 = WASM_VECTOR_LEN;
236
+ wasm.message_setRecords(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
237
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
238
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
239
+ if (r1) {
240
+ throw takeObject(r0);
241
+ }
242
+ } finally {
243
+ wasm.__wbindgen_add_to_stack_pointer(16);
174
244
  }
175
245
  }
176
246
  /**
@@ -178,10 +248,17 @@ export class Message {
178
248
  * @returns {Uint8Array}
179
249
  */
180
250
  toBytes() {
181
- const ret = wasm.message_toBytes(this.__wbg_ptr);
182
- var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
183
- wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
184
- return v1;
251
+ try {
252
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
253
+ wasm.message_toBytes(retptr, this.__wbg_ptr);
254
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
255
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
256
+ var v1 = getArrayU8FromWasm0(r0, r1).slice();
257
+ wasm.__wbindgen_export4(r0, r1 * 1, 1);
258
+ return v1;
259
+ } finally {
260
+ wasm.__wbindgen_add_to_stack_pointer(16);
261
+ }
185
262
  }
186
263
  /**
187
264
  * Update records on this message.
@@ -198,9 +275,16 @@ export class Message {
198
275
  * @param {any} updates
199
276
  */
200
277
  update(updates) {
201
- const ret = wasm.message_update(this.__wbg_ptr, updates);
202
- if (ret[1]) {
203
- throw takeFromExternrefTable0(ret[0]);
278
+ try {
279
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
280
+ wasm.message_update(retptr, this.__wbg_ptr, addHeapObject(updates));
281
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
282
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
283
+ if (r1) {
284
+ throw takeObject(r0);
285
+ }
286
+ } finally {
287
+ wasm.__wbindgen_add_to_stack_pointer(16);
204
288
  }
205
289
  }
206
290
  }
@@ -225,11 +309,18 @@ export class MessageBuilder {
225
309
  * @param {Uint8Array} cert_bytes
226
310
  */
227
311
  addCert(cert_bytes) {
228
- const ptr0 = passArray8ToWasm0(cert_bytes, wasm.__wbindgen_malloc);
229
- const len0 = WASM_VECTOR_LEN;
230
- const ret = wasm.messagebuilder_addCert(this.__wbg_ptr, ptr0, len0);
231
- if (ret[1]) {
232
- throw takeFromExternrefTable0(ret[0]);
312
+ try {
313
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
314
+ const ptr0 = passArray8ToWasm0(cert_bytes, wasm.__wbindgen_export);
315
+ const len0 = WASM_VECTOR_LEN;
316
+ wasm.messagebuilder_addCert(retptr, this.__wbg_ptr, ptr0, len0);
317
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
318
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
319
+ if (r1) {
320
+ throw takeObject(r0);
321
+ }
322
+ } finally {
323
+ wasm.__wbindgen_add_to_stack_pointer(16);
233
324
  }
234
325
  }
235
326
  /**
@@ -237,11 +328,18 @@ export class MessageBuilder {
237
328
  * @param {Uint8Array} chain_bytes
238
329
  */
239
330
  addChain(chain_bytes) {
240
- const ptr0 = passArray8ToWasm0(chain_bytes, wasm.__wbindgen_malloc);
241
- const len0 = WASM_VECTOR_LEN;
242
- const ret = wasm.messagebuilder_addChain(this.__wbg_ptr, ptr0, len0);
243
- if (ret[1]) {
244
- throw takeFromExternrefTable0(ret[0]);
331
+ try {
332
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
333
+ const ptr0 = passArray8ToWasm0(chain_bytes, wasm.__wbindgen_export);
334
+ const len0 = WASM_VECTOR_LEN;
335
+ wasm.messagebuilder_addChain(retptr, this.__wbg_ptr, ptr0, len0);
336
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
337
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
338
+ if (r1) {
339
+ throw takeObject(r0);
340
+ }
341
+ } finally {
342
+ wasm.__wbindgen_add_to_stack_pointer(16);
245
343
  }
246
344
  }
247
345
  /**
@@ -250,13 +348,20 @@ export class MessageBuilder {
250
348
  * @param {Uint8Array} records_bytes
251
349
  */
252
350
  addHandle(chain_bytes, records_bytes) {
253
- const ptr0 = passArray8ToWasm0(chain_bytes, wasm.__wbindgen_malloc);
254
- const len0 = WASM_VECTOR_LEN;
255
- const ptr1 = passArray8ToWasm0(records_bytes, wasm.__wbindgen_malloc);
256
- const len1 = WASM_VECTOR_LEN;
257
- const ret = wasm.messagebuilder_addHandle(this.__wbg_ptr, ptr0, len0, ptr1, len1);
258
- if (ret[1]) {
259
- throw takeFromExternrefTable0(ret[0]);
351
+ try {
352
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
353
+ const ptr0 = passArray8ToWasm0(chain_bytes, wasm.__wbindgen_export);
354
+ const len0 = WASM_VECTOR_LEN;
355
+ const ptr1 = passArray8ToWasm0(records_bytes, wasm.__wbindgen_export);
356
+ const len1 = WASM_VECTOR_LEN;
357
+ wasm.messagebuilder_addHandle(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
358
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
359
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
360
+ if (r1) {
361
+ throw takeObject(r0);
362
+ }
363
+ } finally {
364
+ wasm.__wbindgen_add_to_stack_pointer(16);
260
365
  }
261
366
  }
262
367
  /**
@@ -265,13 +370,20 @@ export class MessageBuilder {
265
370
  * @param {Uint8Array} records_bytes
266
371
  */
267
372
  addRecords(handle, records_bytes) {
268
- const ptr0 = passStringToWasm0(handle, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
269
- const len0 = WASM_VECTOR_LEN;
270
- const ptr1 = passArray8ToWasm0(records_bytes, wasm.__wbindgen_malloc);
271
- const len1 = WASM_VECTOR_LEN;
272
- const ret = wasm.messagebuilder_addRecords(this.__wbg_ptr, ptr0, len0, ptr1, len1);
273
- if (ret[1]) {
274
- throw takeFromExternrefTable0(ret[0]);
373
+ try {
374
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
375
+ const ptr0 = passStringToWasm0(handle, wasm.__wbindgen_export, wasm.__wbindgen_export2);
376
+ const len0 = WASM_VECTOR_LEN;
377
+ const ptr1 = passArray8ToWasm0(records_bytes, wasm.__wbindgen_export);
378
+ const len1 = WASM_VECTOR_LEN;
379
+ wasm.messagebuilder_addRecords(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
380
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
381
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
382
+ if (r1) {
383
+ throw takeObject(r0);
384
+ }
385
+ } finally {
386
+ wasm.__wbindgen_add_to_stack_pointer(16);
275
387
  }
276
388
  }
277
389
  /**
@@ -279,9 +391,16 @@ export class MessageBuilder {
279
391
  * @param {any} entry
280
392
  */
281
393
  addUpdate(entry) {
282
- const ret = wasm.messagebuilder_addUpdate(this.__wbg_ptr, entry);
283
- if (ret[1]) {
284
- throw takeFromExternrefTable0(ret[0]);
394
+ try {
395
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
396
+ wasm.messagebuilder_addUpdate(retptr, this.__wbg_ptr, addHeapObject(entry));
397
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
398
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
399
+ if (r1) {
400
+ throw takeObject(r0);
401
+ }
402
+ } finally {
403
+ wasm.__wbindgen_add_to_stack_pointer(16);
285
404
  }
286
405
  }
287
406
  /**
@@ -293,13 +412,21 @@ export class MessageBuilder {
293
412
  * @returns {any}
294
413
  */
295
414
  build(chain_proof) {
296
- const ptr0 = passArray8ToWasm0(chain_proof, wasm.__wbindgen_malloc);
297
- const len0 = WASM_VECTOR_LEN;
298
- const ret = wasm.messagebuilder_build(this.__wbg_ptr, ptr0, len0);
299
- if (ret[2]) {
300
- throw takeFromExternrefTable0(ret[1]);
415
+ try {
416
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
417
+ const ptr0 = passArray8ToWasm0(chain_proof, wasm.__wbindgen_export);
418
+ const len0 = WASM_VECTOR_LEN;
419
+ wasm.messagebuilder_build(retptr, this.__wbg_ptr, ptr0, len0);
420
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
421
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
422
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
423
+ if (r2) {
424
+ throw takeObject(r1);
425
+ }
426
+ return takeObject(r0);
427
+ } finally {
428
+ wasm.__wbindgen_add_to_stack_pointer(16);
301
429
  }
302
- return takeFromExternrefTable0(ret[0]);
303
430
  }
304
431
  /**
305
432
  * Returns the chain proof request as a JS object.
@@ -308,11 +435,19 @@ export class MessageBuilder {
308
435
  * @returns {any}
309
436
  */
310
437
  chainProofRequest() {
311
- const ret = wasm.messagebuilder_chainProofRequest(this.__wbg_ptr);
312
- if (ret[2]) {
313
- throw takeFromExternrefTable0(ret[1]);
438
+ try {
439
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
440
+ wasm.messagebuilder_chainProofRequest(retptr, this.__wbg_ptr);
441
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
442
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
443
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
444
+ if (r2) {
445
+ throw takeObject(r1);
446
+ }
447
+ return takeObject(r0);
448
+ } finally {
449
+ wasm.__wbindgen_add_to_stack_pointer(16);
314
450
  }
315
- return takeFromExternrefTable0(ret[0]);
316
451
  }
317
452
  /**
318
453
  * Create an empty builder.
@@ -349,11 +484,18 @@ export class QueryContext {
349
484
  * @param {string} handle
350
485
  */
351
486
  addRequest(handle) {
352
- const ptr0 = passStringToWasm0(handle, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
353
- const len0 = WASM_VECTOR_LEN;
354
- const ret = wasm.querycontext_addRequest(this.__wbg_ptr, ptr0, len0);
355
- if (ret[1]) {
356
- throw takeFromExternrefTable0(ret[0]);
487
+ try {
488
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
489
+ const ptr0 = passStringToWasm0(handle, wasm.__wbindgen_export, wasm.__wbindgen_export2);
490
+ const len0 = WASM_VECTOR_LEN;
491
+ wasm.querycontext_addRequest(retptr, this.__wbg_ptr, ptr0, len0);
492
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
493
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
494
+ if (r1) {
495
+ throw takeObject(r0);
496
+ }
497
+ } finally {
498
+ wasm.__wbindgen_add_to_stack_pointer(16);
357
499
  }
358
500
  }
359
501
  /**
@@ -361,11 +503,18 @@ export class QueryContext {
361
503
  * @param {Uint8Array} zone_bytes
362
504
  */
363
505
  addZone(zone_bytes) {
364
- const ptr0 = passArray8ToWasm0(zone_bytes, wasm.__wbindgen_malloc);
365
- const len0 = WASM_VECTOR_LEN;
366
- const ret = wasm.querycontext_addZone(this.__wbg_ptr, ptr0, len0);
367
- if (ret[1]) {
368
- throw takeFromExternrefTable0(ret[0]);
506
+ try {
507
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
508
+ const ptr0 = passArray8ToWasm0(zone_bytes, wasm.__wbindgen_export);
509
+ const len0 = WASM_VECTOR_LEN;
510
+ wasm.querycontext_addZone(retptr, this.__wbg_ptr, ptr0, len0);
511
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
512
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
513
+ if (r1) {
514
+ throw takeObject(r0);
515
+ }
516
+ } finally {
517
+ wasm.__wbindgen_add_to_stack_pointer(16);
369
518
  }
370
519
  }
371
520
  constructor() {
@@ -405,10 +554,10 @@ export class Record {
405
554
  * @returns {any}
406
555
  */
407
556
  static addr(key, value) {
408
- const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
557
+ const ptr0 = passStringToWasm0(key, wasm.__wbindgen_export, wasm.__wbindgen_export2);
409
558
  const len0 = WASM_VECTOR_LEN;
410
- const ret = wasm.record_addr(ptr0, len0, value);
411
- return ret;
559
+ const ret = wasm.record_addr(ptr0, len0, addHeapObject(value));
560
+ return takeObject(ret);
412
561
  }
413
562
  /**
414
563
  * @param {string} key
@@ -416,12 +565,12 @@ export class Record {
416
565
  * @returns {any}
417
566
  */
418
567
  static blob(key, value) {
419
- const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
568
+ const ptr0 = passStringToWasm0(key, wasm.__wbindgen_export, wasm.__wbindgen_export2);
420
569
  const len0 = WASM_VECTOR_LEN;
421
- const ptr1 = passArray8ToWasm0(value, wasm.__wbindgen_malloc);
570
+ const ptr1 = passArray8ToWasm0(value, wasm.__wbindgen_export);
422
571
  const len1 = WASM_VECTOR_LEN;
423
572
  const ret = wasm.record_blob(ptr0, len0, ptr1, len1);
424
- return ret;
573
+ return takeObject(ret);
425
574
  }
426
575
  /**
427
576
  * @param {bigint} version
@@ -429,7 +578,7 @@ export class Record {
429
578
  */
430
579
  static seq(version) {
431
580
  const ret = wasm.record_seq(version);
432
- return ret;
581
+ return takeObject(ret);
433
582
  }
434
583
  /**
435
584
  * @param {string} canonical
@@ -439,14 +588,14 @@ export class Record {
439
588
  * @returns {any}
440
589
  */
441
590
  static sig(canonical, handle, flags, sig) {
442
- const ptr0 = passStringToWasm0(canonical, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
591
+ const ptr0 = passStringToWasm0(canonical, wasm.__wbindgen_export, wasm.__wbindgen_export2);
443
592
  const len0 = WASM_VECTOR_LEN;
444
- const ptr1 = passStringToWasm0(handle, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
593
+ const ptr1 = passStringToWasm0(handle, wasm.__wbindgen_export, wasm.__wbindgen_export2);
445
594
  const len1 = WASM_VECTOR_LEN;
446
- const ptr2 = passArray8ToWasm0(sig, wasm.__wbindgen_malloc);
595
+ const ptr2 = passArray8ToWasm0(sig, wasm.__wbindgen_export);
447
596
  const len2 = WASM_VECTOR_LEN;
448
597
  const ret = wasm.record_sig(ptr0, len0, ptr1, len1, flags, ptr2, len2);
449
- return ret;
598
+ return takeObject(ret);
450
599
  }
451
600
  /**
452
601
  * @param {string} key
@@ -454,10 +603,10 @@ export class Record {
454
603
  * @returns {any}
455
604
  */
456
605
  static txt(key, value) {
457
- const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
606
+ const ptr0 = passStringToWasm0(key, wasm.__wbindgen_export, wasm.__wbindgen_export2);
458
607
  const len0 = WASM_VECTOR_LEN;
459
- const ret = wasm.record_txt(ptr0, len0, value);
460
- return ret;
608
+ const ret = wasm.record_txt(ptr0, len0, addHeapObject(value));
609
+ return takeObject(ret);
461
610
  }
462
611
  /**
463
612
  * @param {number} rtype
@@ -465,10 +614,10 @@ export class Record {
465
614
  * @returns {any}
466
615
  */
467
616
  static unknown(rtype, rdata) {
468
- const ptr0 = passArray8ToWasm0(rdata, wasm.__wbindgen_malloc);
617
+ const ptr0 = passArray8ToWasm0(rdata, wasm.__wbindgen_export);
469
618
  const len0 = WASM_VECTOR_LEN;
470
619
  const ret = wasm.record_unknown(rtype, ptr0, len0);
471
- return ret;
620
+ return takeObject(ret);
472
621
  }
473
622
  }
474
623
  if (Symbol.dispose) Record.prototype[Symbol.dispose] = Record.prototype.free;
@@ -516,7 +665,7 @@ export class RecordSet {
516
665
  * @param {Uint8Array} data
517
666
  */
518
667
  constructor(data) {
519
- const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
668
+ const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
520
669
  const len0 = WASM_VECTOR_LEN;
521
670
  const ret = wasm.recordset_new(ptr0, len0);
522
671
  this.__wbg_ptr = ret >>> 0;
@@ -529,42 +678,72 @@ export class RecordSet {
529
678
  * @returns {RecordSet}
530
679
  */
531
680
  static pack(records) {
532
- const ret = wasm.recordset_pack(records);
533
- if (ret[2]) {
534
- throw takeFromExternrefTable0(ret[1]);
681
+ try {
682
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
683
+ wasm.recordset_pack(retptr, addHeapObject(records));
684
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
685
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
686
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
687
+ if (r2) {
688
+ throw takeObject(r1);
689
+ }
690
+ return RecordSet.__wrap(r0);
691
+ } finally {
692
+ wasm.__wbindgen_add_to_stack_pointer(16);
535
693
  }
536
- return RecordSet.__wrap(ret[0]);
537
694
  }
538
695
  /**
539
696
  * The 32-byte signing hash (Spaces signed-message prefix + SHA256).
540
697
  * @returns {Uint8Array}
541
698
  */
542
699
  signingId() {
543
- const ret = wasm.recordset_signingId(this.__wbg_ptr);
544
- var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
545
- wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
546
- return v1;
700
+ try {
701
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
702
+ wasm.recordset_signingId(retptr, this.__wbg_ptr);
703
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
704
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
705
+ var v1 = getArrayU8FromWasm0(r0, r1).slice();
706
+ wasm.__wbindgen_export4(r0, r1 * 1, 1);
707
+ return v1;
708
+ } finally {
709
+ wasm.__wbindgen_add_to_stack_pointer(16);
710
+ }
547
711
  }
548
712
  /**
549
713
  * Raw wire bytes.
550
714
  * @returns {Uint8Array}
551
715
  */
552
716
  toBytes() {
553
- const ret = wasm.recordset_toBytes(this.__wbg_ptr);
554
- var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
555
- wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
556
- return v1;
717
+ try {
718
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
719
+ wasm.recordset_toBytes(retptr, this.__wbg_ptr);
720
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
721
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
722
+ var v1 = getArrayU8FromWasm0(r0, r1).slice();
723
+ wasm.__wbindgen_export4(r0, r1 * 1, 1);
724
+ return v1;
725
+ } finally {
726
+ wasm.__wbindgen_add_to_stack_pointer(16);
727
+ }
557
728
  }
558
729
  /**
559
730
  * Parse all records.
560
731
  * @returns {any}
561
732
  */
562
733
  unpack() {
563
- const ret = wasm.recordset_unpack(this.__wbg_ptr);
564
- if (ret[2]) {
565
- throw takeFromExternrefTable0(ret[1]);
734
+ try {
735
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
736
+ wasm.recordset_unpack(retptr, this.__wbg_ptr);
737
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
738
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
739
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
740
+ if (r2) {
741
+ throw takeObject(r1);
742
+ }
743
+ return takeObject(r0);
744
+ } finally {
745
+ wasm.__wbindgen_add_to_stack_pointer(16);
566
746
  }
567
- return takeFromExternrefTable0(ret[0]);
568
747
  }
569
748
  }
570
749
  if (Symbol.dispose) RecordSet.prototype[Symbol.dispose] = RecordSet.prototype.free;
@@ -606,12 +785,16 @@ export class UnsignedRecordSet {
606
785
  let deferred1_0;
607
786
  let deferred1_1;
608
787
  try {
609
- const ret = wasm.unsignedrecordset_canonical(this.__wbg_ptr);
610
- deferred1_0 = ret[0];
611
- deferred1_1 = ret[1];
612
- return getStringFromWasm0(ret[0], ret[1]);
788
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
789
+ wasm.unsignedrecordset_canonical(retptr, this.__wbg_ptr);
790
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
791
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
792
+ deferred1_0 = r0;
793
+ deferred1_1 = r1;
794
+ return getStringFromWasm0(r0, r1);
613
795
  } finally {
614
- wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
796
+ wasm.__wbindgen_add_to_stack_pointer(16);
797
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
615
798
  }
616
799
  }
617
800
  /**
@@ -630,12 +813,16 @@ export class UnsignedRecordSet {
630
813
  let deferred1_0;
631
814
  let deferred1_1;
632
815
  try {
633
- const ret = wasm.unsignedrecordset_handle(this.__wbg_ptr);
634
- deferred1_0 = ret[0];
635
- deferred1_1 = ret[1];
636
- return getStringFromWasm0(ret[0], ret[1]);
816
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
817
+ wasm.unsignedrecordset_handle(retptr, this.__wbg_ptr);
818
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
819
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
820
+ deferred1_0 = r0;
821
+ deferred1_1 = r1;
822
+ return getStringFromWasm0(r0, r1);
637
823
  } finally {
638
- wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
824
+ wasm.__wbindgen_add_to_stack_pointer(16);
825
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
639
826
  }
640
827
  }
641
828
  /**
@@ -652,12 +839,19 @@ export class UnsignedRecordSet {
652
839
  * @returns {Uint8Array}
653
840
  */
654
841
  packSig(signature) {
655
- const ptr0 = passArray8ToWasm0(signature, wasm.__wbindgen_malloc);
656
- const len0 = WASM_VECTOR_LEN;
657
- const ret = wasm.unsignedrecordset_packSig(this.__wbg_ptr, ptr0, len0);
658
- var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
659
- wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
660
- return v2;
842
+ try {
843
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
844
+ const ptr0 = passArray8ToWasm0(signature, wasm.__wbindgen_export);
845
+ const len0 = WASM_VECTOR_LEN;
846
+ wasm.unsignedrecordset_packSig(retptr, this.__wbg_ptr, ptr0, len0);
847
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
848
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
849
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
850
+ wasm.__wbindgen_export4(r0, r1 * 1, 1);
851
+ return v2;
852
+ } finally {
853
+ wasm.__wbindgen_add_to_stack_pointer(16);
854
+ }
661
855
  }
662
856
  /**
663
857
  * Set sig flags (e.g. `SIG_PRIMARY_ZONE`).
@@ -671,20 +865,34 @@ export class UnsignedRecordSet {
671
865
  * @returns {Uint8Array}
672
866
  */
673
867
  signableBytes() {
674
- const ret = wasm.unsignedrecordset_signableBytes(this.__wbg_ptr);
675
- var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
676
- wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
677
- return v1;
868
+ try {
869
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
870
+ wasm.unsignedrecordset_signableBytes(retptr, this.__wbg_ptr);
871
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
872
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
873
+ var v1 = getArrayU8FromWasm0(r0, r1).slice();
874
+ wasm.__wbindgen_export4(r0, r1 * 1, 1);
875
+ return v1;
876
+ } finally {
877
+ wasm.__wbindgen_add_to_stack_pointer(16);
878
+ }
678
879
  }
679
880
  /**
680
881
  * The 32-byte signing hash (Spaces signed-message prefix + SHA256).
681
882
  * @returns {Uint8Array}
682
883
  */
683
884
  signingId() {
684
- const ret = wasm.unsignedrecordset_signingId(this.__wbg_ptr);
685
- var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
686
- wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
687
- return v1;
885
+ try {
886
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
887
+ wasm.unsignedrecordset_signingId(retptr, this.__wbg_ptr);
888
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
889
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
890
+ var v1 = getArrayU8FromWasm0(r0, r1).slice();
891
+ wasm.__wbindgen_export4(r0, r1 * 1, 1);
892
+ return v1;
893
+ } finally {
894
+ wasm.__wbindgen_add_to_stack_pointer(16);
895
+ }
688
896
  }
689
897
  }
690
898
  if (Symbol.dispose) UnsignedRecordSet.prototype[Symbol.dispose] = UnsignedRecordSet.prototype.free;
@@ -739,10 +947,17 @@ export class VerifiedMessage {
739
947
  * @returns {Uint8Array[]}
740
948
  */
741
949
  certificates() {
742
- const ret = wasm.verifiedmessage_certificates(this.__wbg_ptr);
743
- var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
744
- wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
745
- return v1;
950
+ try {
951
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
952
+ wasm.verifiedmessage_certificates(retptr, this.__wbg_ptr);
953
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
954
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
955
+ var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
956
+ wasm.__wbindgen_export4(r0, r1 * 4, 4);
957
+ return v1;
958
+ } finally {
959
+ wasm.__wbindgen_add_to_stack_pointer(16);
960
+ }
746
961
  }
747
962
  /**
748
963
  * Get the verified message for rebroadcasting or updating.
@@ -757,31 +972,53 @@ export class VerifiedMessage {
757
972
  * @returns {Uint8Array}
758
973
  */
759
974
  messageBytes() {
760
- const ret = wasm.verifiedmessage_messageBytes(this.__wbg_ptr);
761
- var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
762
- wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
763
- return v1;
975
+ try {
976
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
977
+ wasm.verifiedmessage_messageBytes(retptr, this.__wbg_ptr);
978
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
979
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
980
+ var v1 = getArrayU8FromWasm0(r0, r1).slice();
981
+ wasm.__wbindgen_export4(r0, r1 * 1, 1);
982
+ return v1;
983
+ } finally {
984
+ wasm.__wbindgen_add_to_stack_pointer(16);
985
+ }
764
986
  }
765
987
  /**
766
988
  * The root id this message was verified against.
767
989
  * @returns {Uint8Array}
768
990
  */
769
991
  rootId() {
770
- const ret = wasm.verifiedmessage_rootId(this.__wbg_ptr);
771
- var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
772
- wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
773
- return v1;
992
+ try {
993
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
994
+ wasm.verifiedmessage_rootId(retptr, this.__wbg_ptr);
995
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
996
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
997
+ var v1 = getArrayU8FromWasm0(r0, r1).slice();
998
+ wasm.__wbindgen_export4(r0, r1 * 1, 1);
999
+ return v1;
1000
+ } finally {
1001
+ wasm.__wbindgen_add_to_stack_pointer(16);
1002
+ }
774
1003
  }
775
1004
  /**
776
1005
  * All verified zones as plain JS objects.
777
1006
  * @returns {any}
778
1007
  */
779
1008
  zones() {
780
- const ret = wasm.verifiedmessage_zones(this.__wbg_ptr);
781
- if (ret[2]) {
782
- throw takeFromExternrefTable0(ret[1]);
1009
+ try {
1010
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1011
+ wasm.verifiedmessage_zones(retptr, this.__wbg_ptr);
1012
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1013
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1014
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1015
+ if (r2) {
1016
+ throw takeObject(r1);
1017
+ }
1018
+ return takeObject(r0);
1019
+ } finally {
1020
+ wasm.__wbindgen_add_to_stack_pointer(16);
783
1021
  }
784
- return takeFromExternrefTable0(ret[0]);
785
1022
  }
786
1023
  }
787
1024
  if (Symbol.dispose) VerifiedMessage.prototype[Symbol.dispose] = VerifiedMessage.prototype.free;
@@ -801,11 +1038,19 @@ export class Veritas {
801
1038
  * @returns {any}
802
1039
  */
803
1040
  computeTrustSet() {
804
- const ret = wasm.veritas_computeTrustSet(this.__wbg_ptr);
805
- if (ret[2]) {
806
- throw takeFromExternrefTable0(ret[1]);
1041
+ try {
1042
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1043
+ wasm.veritas_computeTrustSet(retptr, this.__wbg_ptr);
1044
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1045
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1046
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1047
+ if (r2) {
1048
+ throw takeObject(r1);
1049
+ }
1050
+ return takeObject(r0);
1051
+ } finally {
1052
+ wasm.__wbindgen_add_to_stack_pointer(16);
807
1053
  }
808
- return takeFromExternrefTable0(ret[0]);
809
1054
  }
810
1055
  /**
811
1056
  * @param {number} commitment_height
@@ -819,14 +1064,22 @@ export class Veritas {
819
1064
  * @param {Anchors} anchors
820
1065
  */
821
1066
  constructor(anchors) {
822
- _assertClass(anchors, Anchors);
823
- const ret = wasm.veritas_new(anchors.__wbg_ptr);
824
- if (ret[2]) {
825
- throw takeFromExternrefTable0(ret[1]);
1067
+ try {
1068
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1069
+ _assertClass(anchors, Anchors);
1070
+ wasm.veritas_new(retptr, anchors.__wbg_ptr);
1071
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1072
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1073
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1074
+ if (r2) {
1075
+ throw takeObject(r1);
1076
+ }
1077
+ this.__wbg_ptr = r0 >>> 0;
1078
+ VeritasFinalization.register(this, this.__wbg_ptr, this);
1079
+ return this;
1080
+ } finally {
1081
+ wasm.__wbindgen_add_to_stack_pointer(16);
826
1082
  }
827
- this.__wbg_ptr = ret[0] >>> 0;
828
- VeritasFinalization.register(this, this.__wbg_ptr, this);
829
- return this;
830
1083
  }
831
1084
  /**
832
1085
  * @returns {number}
@@ -850,12 +1103,16 @@ export class Veritas {
850
1103
  let deferred1_0;
851
1104
  let deferred1_1;
852
1105
  try {
853
- const ret = wasm.veritas_sovereigntyFor(this.__wbg_ptr, commitment_height);
854
- deferred1_0 = ret[0];
855
- deferred1_1 = ret[1];
856
- return getStringFromWasm0(ret[0], ret[1]);
1106
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1107
+ wasm.veritas_sovereigntyFor(retptr, this.__wbg_ptr, commitment_height);
1108
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1109
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1110
+ deferred1_0 = r0;
1111
+ deferred1_1 = r1;
1112
+ return getStringFromWasm0(r0, r1);
857
1113
  } finally {
858
- wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
1114
+ wasm.__wbindgen_add_to_stack_pointer(16);
1115
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
859
1116
  }
860
1117
  }
861
1118
  /**
@@ -865,13 +1122,21 @@ export class Veritas {
865
1122
  * @returns {VerifiedMessage}
866
1123
  */
867
1124
  verify(ctx, msg) {
868
- _assertClass(ctx, QueryContext);
869
- _assertClass(msg, Message);
870
- const ret = wasm.veritas_verify(this.__wbg_ptr, ctx.__wbg_ptr, msg.__wbg_ptr);
871
- if (ret[2]) {
872
- throw takeFromExternrefTable0(ret[1]);
1125
+ try {
1126
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1127
+ _assertClass(ctx, QueryContext);
1128
+ _assertClass(msg, Message);
1129
+ wasm.veritas_verify(retptr, this.__wbg_ptr, ctx.__wbg_ptr, msg.__wbg_ptr);
1130
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1131
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1132
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1133
+ if (r2) {
1134
+ throw takeObject(r1);
1135
+ }
1136
+ return VerifiedMessage.__wrap(r0);
1137
+ } finally {
1138
+ wasm.__wbindgen_add_to_stack_pointer(16);
873
1139
  }
874
- return VerifiedMessage.__wrap(ret[0]);
875
1140
  }
876
1141
  /**
877
1142
  * Verify a message with option flags (combine with bitwise OR).
@@ -881,13 +1146,21 @@ export class Veritas {
881
1146
  * @returns {VerifiedMessage}
882
1147
  */
883
1148
  verifyWithOptions(ctx, msg, options) {
884
- _assertClass(ctx, QueryContext);
885
- _assertClass(msg, Message);
886
- const ret = wasm.veritas_verifyWithOptions(this.__wbg_ptr, ctx.__wbg_ptr, msg.__wbg_ptr, options);
887
- if (ret[2]) {
888
- throw takeFromExternrefTable0(ret[1]);
1149
+ try {
1150
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1151
+ _assertClass(ctx, QueryContext);
1152
+ _assertClass(msg, Message);
1153
+ wasm.veritas_verifyWithOptions(retptr, this.__wbg_ptr, ctx.__wbg_ptr, msg.__wbg_ptr, options);
1154
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1155
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1156
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1157
+ if (r2) {
1158
+ throw takeObject(r1);
1159
+ }
1160
+ return VerifiedMessage.__wrap(r0);
1161
+ } finally {
1162
+ wasm.__wbindgen_add_to_stack_pointer(16);
889
1163
  }
890
- return VerifiedMessage.__wrap(ret[0]);
891
1164
  }
892
1165
  }
893
1166
  if (Symbol.dispose) Veritas.prototype[Symbol.dispose] = Veritas.prototype.free;
@@ -901,17 +1174,26 @@ if (Symbol.dispose) Veritas.prototype[Symbol.dispose] = Veritas.prototype.free;
901
1174
  * @returns {Uint8Array}
902
1175
  */
903
1176
  export function createCertificateChain(subject, cert_bytes_list) {
904
- const ptr0 = passStringToWasm0(subject, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
905
- const len0 = WASM_VECTOR_LEN;
906
- const ptr1 = passArrayJsValueToWasm0(cert_bytes_list, wasm.__wbindgen_malloc);
907
- const len1 = WASM_VECTOR_LEN;
908
- const ret = wasm.createCertificateChain(ptr0, len0, ptr1, len1);
909
- if (ret[3]) {
910
- throw takeFromExternrefTable0(ret[2]);
911
- }
912
- var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
913
- wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
914
- return v3;
1177
+ try {
1178
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1179
+ const ptr0 = passStringToWasm0(subject, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1180
+ const len0 = WASM_VECTOR_LEN;
1181
+ const ptr1 = passArrayJsValueToWasm0(cert_bytes_list, wasm.__wbindgen_export);
1182
+ const len1 = WASM_VECTOR_LEN;
1183
+ wasm.createCertificateChain(retptr, ptr0, len0, ptr1, len1);
1184
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1185
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1186
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1187
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
1188
+ if (r3) {
1189
+ throw takeObject(r2);
1190
+ }
1191
+ var v3 = getArrayU8FromWasm0(r0, r1).slice();
1192
+ wasm.__wbindgen_export4(r0, r1 * 1, 1);
1193
+ return v3;
1194
+ } finally {
1195
+ wasm.__wbindgen_add_to_stack_pointer(16);
1196
+ }
915
1197
  }
916
1198
 
917
1199
  /**
@@ -920,13 +1202,21 @@ export function createCertificateChain(subject, cert_bytes_list) {
920
1202
  * @returns {any}
921
1203
  */
922
1204
  export function decodeCertificate(bytes) {
923
- const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
924
- const len0 = WASM_VECTOR_LEN;
925
- const ret = wasm.decodeCertificate(ptr0, len0);
926
- if (ret[2]) {
927
- throw takeFromExternrefTable0(ret[1]);
1205
+ try {
1206
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1207
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
1208
+ const len0 = WASM_VECTOR_LEN;
1209
+ wasm.decodeCertificate(retptr, ptr0, len0);
1210
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1211
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1212
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1213
+ if (r2) {
1214
+ throw takeObject(r1);
1215
+ }
1216
+ return takeObject(r0);
1217
+ } finally {
1218
+ wasm.__wbindgen_add_to_stack_pointer(16);
928
1219
  }
929
- return takeFromExternrefTable0(ret[0]);
930
1220
  }
931
1221
 
932
1222
  /**
@@ -935,13 +1225,21 @@ export function decodeCertificate(bytes) {
935
1225
  * @returns {any}
936
1226
  */
937
1227
  export function decodeZone(bytes) {
938
- const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
939
- const len0 = WASM_VECTOR_LEN;
940
- const ret = wasm.decodeZone(ptr0, len0);
941
- if (ret[2]) {
942
- throw takeFromExternrefTable0(ret[1]);
1228
+ try {
1229
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1230
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
1231
+ const len0 = WASM_VECTOR_LEN;
1232
+ wasm.decodeZone(retptr, ptr0, len0);
1233
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1234
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1235
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1236
+ if (r2) {
1237
+ throw takeObject(r1);
1238
+ }
1239
+ return takeObject(r0);
1240
+ } finally {
1241
+ wasm.__wbindgen_add_to_stack_pointer(16);
943
1242
  }
944
- return takeFromExternrefTable0(ret[0]);
945
1243
  }
946
1244
 
947
1245
  /**
@@ -951,12 +1249,19 @@ export function decodeZone(bytes) {
951
1249
  * @returns {Uint8Array}
952
1250
  */
953
1251
  export function hashSignableMessage(msg) {
954
- const ptr0 = passArray8ToWasm0(msg, wasm.__wbindgen_malloc);
955
- const len0 = WASM_VECTOR_LEN;
956
- const ret = wasm.hashSignableMessage(ptr0, len0);
957
- var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
958
- wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
959
- return v2;
1252
+ try {
1253
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1254
+ const ptr0 = passArray8ToWasm0(msg, wasm.__wbindgen_export);
1255
+ const len0 = WASM_VECTOR_LEN;
1256
+ wasm.hashSignableMessage(retptr, ptr0, len0);
1257
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1258
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1259
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
1260
+ wasm.__wbindgen_export4(r0, r1 * 1, 1);
1261
+ return v2;
1262
+ } finally {
1263
+ wasm.__wbindgen_add_to_stack_pointer(16);
1264
+ }
960
1265
  }
961
1266
 
962
1267
  /**
@@ -966,15 +1271,22 @@ export function hashSignableMessage(msg) {
966
1271
  * @param {Uint8Array} pubkey
967
1272
  */
968
1273
  export function verifySchnorr(msg_hash, signature, pubkey) {
969
- const ptr0 = passArray8ToWasm0(msg_hash, wasm.__wbindgen_malloc);
970
- const len0 = WASM_VECTOR_LEN;
971
- const ptr1 = passArray8ToWasm0(signature, wasm.__wbindgen_malloc);
972
- const len1 = WASM_VECTOR_LEN;
973
- const ptr2 = passArray8ToWasm0(pubkey, wasm.__wbindgen_malloc);
974
- const len2 = WASM_VECTOR_LEN;
975
- const ret = wasm.verifySchnorr(ptr0, len0, ptr1, len1, ptr2, len2);
976
- if (ret[1]) {
977
- throw takeFromExternrefTable0(ret[0]);
1274
+ try {
1275
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1276
+ const ptr0 = passArray8ToWasm0(msg_hash, wasm.__wbindgen_export);
1277
+ const len0 = WASM_VECTOR_LEN;
1278
+ const ptr1 = passArray8ToWasm0(signature, wasm.__wbindgen_export);
1279
+ const len1 = WASM_VECTOR_LEN;
1280
+ const ptr2 = passArray8ToWasm0(pubkey, wasm.__wbindgen_export);
1281
+ const len2 = WASM_VECTOR_LEN;
1282
+ wasm.verifySchnorr(retptr, ptr0, len0, ptr1, len1, ptr2, len2);
1283
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1284
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1285
+ if (r1) {
1286
+ throw takeObject(r0);
1287
+ }
1288
+ } finally {
1289
+ wasm.__wbindgen_add_to_stack_pointer(16);
978
1290
  }
979
1291
  }
980
1292
 
@@ -985,15 +1297,22 @@ export function verifySchnorr(msg_hash, signature, pubkey) {
985
1297
  * @param {Uint8Array} pubkey
986
1298
  */
987
1299
  export function verifySpacesMessage(msg, signature, pubkey) {
988
- const ptr0 = passArray8ToWasm0(msg, wasm.__wbindgen_malloc);
989
- const len0 = WASM_VECTOR_LEN;
990
- const ptr1 = passArray8ToWasm0(signature, wasm.__wbindgen_malloc);
991
- const len1 = WASM_VECTOR_LEN;
992
- const ptr2 = passArray8ToWasm0(pubkey, wasm.__wbindgen_malloc);
993
- const len2 = WASM_VECTOR_LEN;
994
- const ret = wasm.verifySpacesMessage(ptr0, len0, ptr1, len1, ptr2, len2);
995
- if (ret[1]) {
996
- throw takeFromExternrefTable0(ret[0]);
1300
+ try {
1301
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1302
+ const ptr0 = passArray8ToWasm0(msg, wasm.__wbindgen_export);
1303
+ const len0 = WASM_VECTOR_LEN;
1304
+ const ptr1 = passArray8ToWasm0(signature, wasm.__wbindgen_export);
1305
+ const len1 = WASM_VECTOR_LEN;
1306
+ const ptr2 = passArray8ToWasm0(pubkey, wasm.__wbindgen_export);
1307
+ const len2 = WASM_VECTOR_LEN;
1308
+ wasm.verifySpacesMessage(retptr, ptr0, len0, ptr1, len1, ptr2, len2);
1309
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1310
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1311
+ if (r1) {
1312
+ throw takeObject(r0);
1313
+ }
1314
+ } finally {
1315
+ wasm.__wbindgen_add_to_stack_pointer(16);
997
1316
  }
998
1317
  }
999
1318
 
@@ -1004,11 +1323,19 @@ export function verifySpacesMessage(msg, signature, pubkey) {
1004
1323
  * @returns {boolean}
1005
1324
  */
1006
1325
  export function zoneIsBetterThan(a, b) {
1007
- const ret = wasm.zoneIsBetterThan(a, b);
1008
- if (ret[2]) {
1009
- throw takeFromExternrefTable0(ret[1]);
1326
+ try {
1327
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1328
+ wasm.zoneIsBetterThan(retptr, addHeapObject(a), addHeapObject(b));
1329
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1330
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1331
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1332
+ if (r2) {
1333
+ throw takeObject(r1);
1334
+ }
1335
+ return r0 !== 0;
1336
+ } finally {
1337
+ wasm.__wbindgen_add_to_stack_pointer(16);
1010
1338
  }
1011
- return ret[0] !== 0;
1012
1339
  }
1013
1340
 
1014
1341
  /**
@@ -1017,64 +1344,73 @@ export function zoneIsBetterThan(a, b) {
1017
1344
  * @returns {Uint8Array}
1018
1345
  */
1019
1346
  export function zoneToBytes(zone) {
1020
- const ret = wasm.zoneToBytes(zone);
1021
- if (ret[3]) {
1022
- throw takeFromExternrefTable0(ret[2]);
1347
+ try {
1348
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1349
+ wasm.zoneToBytes(retptr, addHeapObject(zone));
1350
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1351
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1352
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1353
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
1354
+ if (r3) {
1355
+ throw takeObject(r2);
1356
+ }
1357
+ var v1 = getArrayU8FromWasm0(r0, r1).slice();
1358
+ wasm.__wbindgen_export4(r0, r1 * 1, 1);
1359
+ return v1;
1360
+ } finally {
1361
+ wasm.__wbindgen_add_to_stack_pointer(16);
1023
1362
  }
1024
- var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
1025
- wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
1026
- return v1;
1027
1363
  }
1028
1364
  function __wbg_get_imports() {
1029
1365
  const import0 = {
1030
1366
  __proto__: null,
1031
1367
  __wbg_Error_960c155d3d49e4c2: function(arg0, arg1) {
1032
1368
  const ret = Error(getStringFromWasm0(arg0, arg1));
1033
- return ret;
1369
+ return addHeapObject(ret);
1034
1370
  },
1035
1371
  __wbg___wbindgen_bigint_get_as_i64_3d3aba5d616c6a51: function(arg0, arg1) {
1036
- const v = arg1;
1372
+ const v = getObject(arg1);
1037
1373
  const ret = typeof(v) === 'bigint' ? v : undefined;
1038
1374
  getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
1039
1375
  getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
1040
1376
  },
1041
1377
  __wbg___wbindgen_debug_string_ab4b34d23d6778bd: function(arg0, arg1) {
1042
- const ret = debugString(arg1);
1043
- const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1378
+ const ret = debugString(getObject(arg1));
1379
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1044
1380
  const len1 = WASM_VECTOR_LEN;
1045
1381
  getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
1046
1382
  getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
1047
1383
  },
1048
1384
  __wbg___wbindgen_is_bigint_ec25c7f91b4d9e93: function(arg0) {
1049
- const ret = typeof(arg0) === 'bigint';
1385
+ const ret = typeof(getObject(arg0)) === 'bigint';
1050
1386
  return ret;
1051
1387
  },
1052
1388
  __wbg___wbindgen_is_null_52ff4ec04186736f: function(arg0) {
1053
- const ret = arg0 === null;
1389
+ const ret = getObject(arg0) === null;
1054
1390
  return ret;
1055
1391
  },
1056
1392
  __wbg___wbindgen_is_string_6df3bf7ef1164ed3: function(arg0) {
1057
- const ret = typeof(arg0) === 'string';
1393
+ const ret = typeof(getObject(arg0)) === 'string';
1058
1394
  return ret;
1059
1395
  },
1060
1396
  __wbg___wbindgen_is_undefined_29a43b4d42920abd: function(arg0) {
1061
- const ret = arg0 === undefined;
1397
+ const ret = getObject(arg0) === undefined;
1062
1398
  return ret;
1063
1399
  },
1064
1400
  __wbg___wbindgen_jsval_eq_d3465d8a07697228: function(arg0, arg1) {
1065
- const ret = arg0 === arg1;
1401
+ const ret = getObject(arg0) === getObject(arg1);
1066
1402
  return ret;
1067
1403
  },
1068
1404
  __wbg___wbindgen_number_get_c7f42aed0525c451: function(arg0, arg1) {
1069
- const obj = arg1;
1405
+ const obj = getObject(arg1);
1070
1406
  const ret = typeof(obj) === 'number' ? obj : undefined;
1071
1407
  getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
1072
1408
  getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
1073
1409
  },
1074
1410
  __wbg___wbindgen_string_get_7ed5322991caaec5: function(arg0, arg1) {
1075
- const obj = arg1;
1411
+ const obj = getObject(arg1);
1076
1412
  const ret = typeof(obj) === 'string' ? obj : undefined;
1077
- var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1413
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1078
1414
  var len1 = WASM_VECTOR_LEN;
1079
1415
  getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
1080
1416
  getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
@@ -1083,98 +1419,92 @@ function __wbg_get_imports() {
1083
1419
  throw new Error(getStringFromWasm0(arg0, arg1));
1084
1420
  },
1085
1421
  __wbg_from_0dbf29f09e7fb200: function(arg0) {
1086
- const ret = Array.from(arg0);
1087
- return ret;
1422
+ const ret = Array.from(getObject(arg0));
1423
+ return addHeapObject(ret);
1088
1424
  },
1089
1425
  __wbg_get_6011fa3a58f61074: function() { return handleError(function (arg0, arg1) {
1090
- const ret = Reflect.get(arg0, arg1);
1091
- return ret;
1426
+ const ret = Reflect.get(getObject(arg0), getObject(arg1));
1427
+ return addHeapObject(ret);
1092
1428
  }, arguments); },
1093
1429
  __wbg_get_8360291721e2339f: function(arg0, arg1) {
1094
- const ret = arg0[arg1 >>> 0];
1095
- return ret;
1430
+ const ret = getObject(arg0)[arg1 >>> 0];
1431
+ return addHeapObject(ret);
1096
1432
  },
1097
1433
  __wbg_isArray_c3109d14ffc06469: function(arg0) {
1098
- const ret = Array.isArray(arg0);
1434
+ const ret = Array.isArray(getObject(arg0));
1099
1435
  return ret;
1100
1436
  },
1101
1437
  __wbg_length_3d4ecd04bd8d22f1: function(arg0) {
1102
- const ret = arg0.length;
1438
+ const ret = getObject(arg0).length;
1103
1439
  return ret;
1104
1440
  },
1105
1441
  __wbg_length_9f1775224cf1d815: function(arg0) {
1106
- const ret = arg0.length;
1442
+ const ret = getObject(arg0).length;
1107
1443
  return ret;
1108
1444
  },
1109
1445
  __wbg_message_new: function(arg0) {
1110
1446
  const ret = Message.__wrap(arg0);
1111
- return ret;
1447
+ return addHeapObject(ret);
1112
1448
  },
1113
1449
  __wbg_new_682678e2f47e32bc: function() {
1114
1450
  const ret = new Array();
1115
- return ret;
1451
+ return addHeapObject(ret);
1116
1452
  },
1117
1453
  __wbg_new_aa8d0fa9762c29bd: function() {
1118
1454
  const ret = new Object();
1119
- return ret;
1455
+ return addHeapObject(ret);
1120
1456
  },
1121
1457
  __wbg_new_from_slice_b5ea43e23f6008c0: function(arg0, arg1) {
1122
1458
  const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
1123
- return ret;
1459
+ return addHeapObject(ret);
1124
1460
  },
1125
1461
  __wbg_new_with_length_8c854e41ea4dae9b: function(arg0) {
1126
1462
  const ret = new Uint8Array(arg0 >>> 0);
1127
- return ret;
1463
+ return addHeapObject(ret);
1128
1464
  },
1129
1465
  __wbg_parse_1bbc9c053611d0a7: function() { return handleError(function (arg0, arg1) {
1130
1466
  const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
1131
- return ret;
1467
+ return addHeapObject(ret);
1132
1468
  }, arguments); },
1133
1469
  __wbg_prototypesetcall_a6b02eb00b0f4ce2: function(arg0, arg1, arg2) {
1134
- Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
1470
+ Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
1135
1471
  },
1136
1472
  __wbg_push_471a5b068a5295f6: function(arg0, arg1) {
1137
- const ret = arg0.push(arg1);
1473
+ const ret = getObject(arg0).push(getObject(arg1));
1138
1474
  return ret;
1139
1475
  },
1140
1476
  __wbg_set_022bee52d0b05b19: function() { return handleError(function (arg0, arg1, arg2) {
1141
- const ret = Reflect.set(arg0, arg1, arg2);
1477
+ const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
1142
1478
  return ret;
1143
1479
  }, arguments); },
1144
1480
  __wbg_set_3d484eb794afec82: function(arg0, arg1, arg2) {
1145
- arg0.set(getArrayU8FromWasm0(arg1, arg2));
1481
+ getObject(arg0).set(getArrayU8FromWasm0(arg1, arg2));
1146
1482
  },
1147
1483
  __wbg_stringify_91082ed7a5a5769e: function() { return handleError(function (arg0) {
1148
- const ret = JSON.stringify(arg0);
1149
- return ret;
1484
+ const ret = JSON.stringify(getObject(arg0));
1485
+ return addHeapObject(ret);
1150
1486
  }, arguments); },
1151
1487
  __wbg_unsignedrecordset_new: function(arg0) {
1152
1488
  const ret = UnsignedRecordSet.__wrap(arg0);
1153
- return ret;
1489
+ return addHeapObject(ret);
1154
1490
  },
1155
1491
  __wbindgen_cast_0000000000000001: function(arg0) {
1156
1492
  // Cast intrinsic for `F64 -> Externref`.
1157
1493
  const ret = arg0;
1158
- return ret;
1494
+ return addHeapObject(ret);
1159
1495
  },
1160
1496
  __wbindgen_cast_0000000000000002: function(arg0, arg1) {
1161
1497
  // Cast intrinsic for `Ref(String) -> Externref`.
1162
1498
  const ret = getStringFromWasm0(arg0, arg1);
1163
- return ret;
1499
+ return addHeapObject(ret);
1164
1500
  },
1165
1501
  __wbindgen_cast_0000000000000003: function(arg0) {
1166
1502
  // Cast intrinsic for `U64 -> Externref`.
1167
1503
  const ret = BigInt.asUintN(64, arg0);
1168
- return ret;
1504
+ return addHeapObject(ret);
1169
1505
  },
1170
- __wbindgen_init_externref_table: function() {
1171
- const table = wasm.__wbindgen_externrefs;
1172
- const offset = table.grow(4);
1173
- table.set(0, undefined);
1174
- table.set(offset + 0, undefined);
1175
- table.set(offset + 1, null);
1176
- table.set(offset + 2, true);
1177
- table.set(offset + 3, false);
1506
+ __wbindgen_object_drop_ref: function(arg0) {
1507
+ takeObject(arg0);
1178
1508
  },
1179
1509
  };
1180
1510
  return {
@@ -1214,9 +1544,12 @@ const VeritasFinalization = (typeof FinalizationRegistry === 'undefined')
1214
1544
  ? { register: () => {}, unregister: () => {} }
1215
1545
  : new FinalizationRegistry(ptr => wasm.__wbg_veritas_free(ptr >>> 0, 1));
1216
1546
 
1217
- function addToExternrefTable0(obj) {
1218
- const idx = wasm.__externref_table_alloc();
1219
- wasm.__wbindgen_externrefs.set(idx, obj);
1547
+ function addHeapObject(obj) {
1548
+ if (heap_next === heap.length) heap.push(heap.length + 1);
1549
+ const idx = heap_next;
1550
+ heap_next = heap[idx];
1551
+
1552
+ heap[idx] = obj;
1220
1553
  return idx;
1221
1554
  }
1222
1555
 
@@ -1291,14 +1624,19 @@ function debugString(val) {
1291
1624
  return className;
1292
1625
  }
1293
1626
 
1627
+ function dropObject(idx) {
1628
+ if (idx < 1028) return;
1629
+ heap[idx] = heap_next;
1630
+ heap_next = idx;
1631
+ }
1632
+
1294
1633
  function getArrayJsValueFromWasm0(ptr, len) {
1295
1634
  ptr = ptr >>> 0;
1296
1635
  const mem = getDataViewMemory0();
1297
1636
  const result = [];
1298
1637
  for (let i = ptr; i < ptr + 4 * len; i += 4) {
1299
- result.push(wasm.__wbindgen_externrefs.get(mem.getUint32(i, true)));
1638
+ result.push(takeObject(mem.getUint32(i, true)));
1300
1639
  }
1301
- wasm.__externref_drop_slice(ptr, len);
1302
1640
  return result;
1303
1641
  }
1304
1642
 
@@ -1328,15 +1666,21 @@ function getUint8ArrayMemory0() {
1328
1666
  return cachedUint8ArrayMemory0;
1329
1667
  }
1330
1668
 
1669
+ function getObject(idx) { return heap[idx]; }
1670
+
1331
1671
  function handleError(f, args) {
1332
1672
  try {
1333
1673
  return f.apply(this, args);
1334
1674
  } catch (e) {
1335
- const idx = addToExternrefTable0(e);
1336
- wasm.__wbindgen_exn_store(idx);
1675
+ wasm.__wbindgen_export3(addHeapObject(e));
1337
1676
  }
1338
1677
  }
1339
1678
 
1679
+ let heap = new Array(1024).fill(undefined);
1680
+ heap.push(undefined, null, true, false);
1681
+
1682
+ let heap_next = heap.length;
1683
+
1340
1684
  function isLikeNone(x) {
1341
1685
  return x === undefined || x === null;
1342
1686
  }
@@ -1350,9 +1694,9 @@ function passArray8ToWasm0(arg, malloc) {
1350
1694
 
1351
1695
  function passArrayJsValueToWasm0(array, malloc) {
1352
1696
  const ptr = malloc(array.length * 4, 4) >>> 0;
1697
+ const mem = getDataViewMemory0();
1353
1698
  for (let i = 0; i < array.length; i++) {
1354
- const add = addToExternrefTable0(array[i]);
1355
- getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
1699
+ mem.setUint32(ptr + 4 * i, addHeapObject(array[i]), true);
1356
1700
  }
1357
1701
  WASM_VECTOR_LEN = array.length;
1358
1702
  return ptr;
@@ -1395,10 +1739,10 @@ function passStringToWasm0(arg, malloc, realloc) {
1395
1739
  return ptr;
1396
1740
  }
1397
1741
 
1398
- function takeFromExternrefTable0(idx) {
1399
- const value = wasm.__wbindgen_externrefs.get(idx);
1400
- wasm.__externref_table_dealloc(idx);
1401
- return value;
1742
+ function takeObject(idx) {
1743
+ const ret = getObject(idx);
1744
+ dropObject(idx);
1745
+ return ret;
1402
1746
  }
1403
1747
 
1404
1748
  let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
@@ -1436,7 +1780,6 @@ function __wbg_finalize_init(instance, module) {
1436
1780
  wasmModule = module;
1437
1781
  cachedDataViewMemory0 = null;
1438
1782
  cachedUint8ArrayMemory0 = null;
1439
- wasm.__wbindgen_start();
1440
1783
  return wasm;
1441
1784
  }
1442
1785