@bytecodealliance/jco 0.13.2 → 0.14.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (43) hide show
  1. package/README.md +23 -21
  2. package/lib/wasi_snapshot_preview1.command.wasm +0 -0
  3. package/lib/wasi_snapshot_preview1.reactor.wasm +0 -0
  4. package/obj/interfaces/wasi-filesystem-types.d.ts +4 -9
  5. package/obj/interfaces/wasi-io-error.d.ts +6 -0
  6. package/obj/interfaces/wasi-io-streams.d.ts +2 -4
  7. package/obj/js-component-bindgen-component.component.wasm +0 -0
  8. package/obj/js-component-bindgen-component.core.wasm +0 -0
  9. package/obj/js-component-bindgen-component.core2.wasm +0 -0
  10. package/obj/js-component-bindgen-component.d.ts +27 -18
  11. package/obj/js-component-bindgen-component.js +849 -784
  12. package/obj/wasm-tools.component.wasm +0 -0
  13. package/obj/wasm-tools.core.wasm +0 -0
  14. package/obj/wasm-tools.core2.wasm +0 -0
  15. package/obj/wasm-tools.d.ts +18 -17
  16. package/obj/wasm-tools.js +779 -751
  17. package/package.json +3 -3
  18. package/src/api.d.ts +42 -0
  19. package/src/api.d.ts.map +1 -0
  20. package/src/browser.d.ts +4 -0
  21. package/src/browser.d.ts.map +1 -0
  22. package/src/cmd/componentize.d.ts +2 -0
  23. package/src/cmd/componentize.d.ts.map +1 -0
  24. package/src/cmd/componentize.js +1 -0
  25. package/src/cmd/opt.d.ts +15 -0
  26. package/src/cmd/opt.d.ts.map +1 -0
  27. package/src/cmd/run.d.ts +2 -0
  28. package/src/cmd/run.d.ts.map +1 -0
  29. package/src/cmd/run.js +23 -6
  30. package/src/cmd/transpile.d.ts +44 -0
  31. package/src/cmd/transpile.d.ts.map +1 -0
  32. package/src/cmd/transpile.js +206 -45
  33. package/src/cmd/wasm-tools.d.ts +8 -0
  34. package/src/cmd/wasm-tools.d.ts.map +1 -0
  35. package/src/cmd/wasm-tools.js +3 -2
  36. package/src/common.d.ts +16 -0
  37. package/src/common.d.ts.map +1 -0
  38. package/src/common.js +3 -0
  39. package/src/jco.d.ts +3 -0
  40. package/src/jco.d.ts.map +1 -0
  41. package/src/jco.js +9 -4
  42. package/src/ora-shim.d.ts +7 -0
  43. package/src/ora-shim.d.ts.map +1 -0
package/obj/js-component-bindgen-component.js CHANGED
@@ -1,6 +1,6 @@
1
1
  import { environment, exit as exit$1, stderr, stdin, stdout, terminalInput, terminalOutput, terminalStderr, terminalStdin, terminalStdout } from '@bytecodealliance/preview2-shim/cli';
2
2
  import { preopens, types } from '@bytecodealliance/preview2-shim/filesystem';
3
- import { streams } from '@bytecodealliance/preview2-shim/io';
3
+ import { error, streams } from '@bytecodealliance/preview2-shim/io';
4
4
  import { random } from '@bytecodealliance/preview2-shim/random';
5
5
  const { getEnvironment } = environment;
6
6
  const { exit } = exit$1;
@@ -16,8 +16,8 @@ const { getDirectories } = preopens;
16
16
  const { Descriptor,
17
17
  DirectoryEntryStream,
18
18
  filesystemErrorCode } = types;
19
- const { Error: Error$1,
20
- InputStream,
19
+ const { Error: Error$1 } = error;
20
+ const { InputStream,
21
21
  OutputStream } = streams;
22
22
  const { getRandomBytes } = random;
23
23
 
@@ -53,13 +53,15 @@ const hasOwnProperty = Object.prototype.hasOwnProperty;
53
53
 
54
54
  const instantiateCore = WebAssembly.instantiate;
55
55
 
56
- const resourceHandleSymbol = Symbol();
56
+ const resourceHandleSymbol = Symbol('resource');
57
+
58
+ const symbolDispose = Symbol.dispose || Symbol.for('dispose');
57
59
 
58
60
  function throwUninitialized() {
59
61
  throw new TypeError('Wasm uninitialized use `await $init` first');
60
62
  }
61
63
 
62
- const toUint64 = val => BigInt.asUintN(64, val);
64
+ const toUint64 = val => BigInt.asUintN(64, BigInt(val));
63
65
 
64
66
  function toUint32(val) {
65
67
  return val >>> 0;
@@ -80,8 +82,7 @@ function utf8Encode(s, realloc, memory) {
80
82
  let ptr = 0;
81
83
  let writtenTotal = 0;
82
84
  while (s.length > 0) {
83
- ptr = realloc(ptr, allocLen, 1, allocLen + s.length);
84
- allocLen += s.length;
85
+ ptr = realloc(ptr, allocLen, 1, allocLen += s.length * 2);
85
86
  const { read, written } = utf8Encoder.encodeInto(
86
87
  s,
87
88
  new Uint8Array(memory.buffer, ptr + writtenTotal, allocLen - writtenTotal),
@@ -89,8 +90,6 @@ function utf8Encode(s, realloc, memory) {
89
90
  writtenTotal += written;
90
91
  s = s.slice(read);
91
92
  }
92
- if (allocLen > writtenTotal)
93
- ptr = realloc(ptr, allocLen, 1, writtenTotal);
94
93
  utf8EncodedLen = writtenTotal;
95
94
  return ptr;
96
95
  }
@@ -101,9 +100,9 @@ let exports1;
101
100
  function trampoline8() {
102
101
  const ret = getStderr();
103
102
  if (!(ret instanceof OutputStream)) {
104
- throw new Error('Not a valid "OutputStream" resource.');
103
+ throw new Error('Resource error: Not a valid "OutputStream" resource.');
105
104
  }
106
- const handle0 = handleCnt2++;
105
+ var handle0 = handleCnt2++;
107
106
  handleTable2.set(handle0, { rep: ret, own: true });
108
107
  return handle0;
109
108
  }
@@ -135,19 +134,19 @@ function trampoline9(arg0) {
135
134
  function trampoline10() {
136
135
  const ret = getStdin();
137
136
  if (!(ret instanceof InputStream)) {
138
- throw new Error('Not a valid "InputStream" resource.');
137
+ throw new Error('Resource error: Not a valid "InputStream" resource.');
139
138
  }
140
- const handle0 = handleCnt0++;
141
- handleTable0.set(handle0, { rep: ret, own: true });
139
+ var handle0 = handleCnt1++;
140
+ handleTable1.set(handle0, { rep: ret, own: true });
142
141
  return handle0;
143
142
  }
144
143
 
145
144
  function trampoline11() {
146
145
  const ret = getStdout();
147
146
  if (!(ret instanceof OutputStream)) {
148
- throw new Error('Not a valid "OutputStream" resource.');
147
+ throw new Error('Resource error: Not a valid "OutputStream" resource.');
149
148
  }
150
- const handle0 = handleCnt2++;
149
+ var handle0 = handleCnt2++;
151
150
  handleTable2.set(handle0, { rep: ret, own: true });
152
151
  return handle0;
153
152
  }
@@ -155,20 +154,20 @@ let exports2;
155
154
 
156
155
  function trampoline12(arg0) {
157
156
  const ret = getDirectories();
158
- const vec3 = ret;
159
- const len3 = vec3.length;
160
- const result3 = realloc0(0, 0, 4, len3 * 12);
157
+ var vec3 = ret;
158
+ var len3 = vec3.length;
159
+ var result3 = realloc0(0, 0, 4, len3 * 12);
161
160
  for (let i = 0; i < vec3.length; i++) {
162
161
  const e = vec3[i];
163
- const base = result3 + i * 12;const [tuple0_0, tuple0_1] = e;
162
+ const base = result3 + i * 12;var [tuple0_0, tuple0_1] = e;
164
163
  if (!(tuple0_0 instanceof Descriptor)) {
165
- throw new Error('Not a valid "Descriptor" resource.');
164
+ throw new Error('Resource error: Not a valid "Descriptor" resource.');
166
165
  }
167
- const handle1 = handleCnt3++;
166
+ var handle1 = handleCnt3++;
168
167
  handleTable3.set(handle1, { rep: tuple0_0, own: true });
169
168
  dataView(memory0).setInt32(base + 0, handle1, true);
170
- const ptr2 = utf8Encode(tuple0_1, realloc0, memory0);
171
- const len2 = utf8EncodedLen;
169
+ var ptr2 = utf8Encode(tuple0_1, realloc0, memory0);
170
+ var len2 = utf8EncodedLen;
172
171
  dataView(memory0).setInt32(base + 8, len2, true);
173
172
  dataView(memory0).setInt32(base + 4, ptr2, true);
174
173
  }
@@ -179,178 +178,179 @@ let memory0;
179
178
  let realloc0;
180
179
 
181
180
  function trampoline13(arg0, arg1, arg2) {
182
- const rsc0 = handleTable3.get(arg0).rep;
181
+ var handle1 = arg0;
182
+ var rsc0 = handleTable3.get(handle1).rep;
183
183
  let ret;
184
184
  try {
185
185
  ret = { tag: 'ok', val: Descriptor.prototype.readViaStream.call(rsc0, BigInt.asUintN(64, arg1)) };
186
186
  } catch (e) {
187
187
  ret = { tag: 'err', val: getErrorPayload(e) };
188
188
  }
189
- const variant3 = ret;
190
- switch (variant3.tag) {
189
+ var variant4 = ret;
190
+ switch (variant4.tag) {
191
191
  case 'ok': {
192
- const e = variant3.val;
192
+ const e = variant4.val;
193
193
  dataView(memory0).setInt8(arg2 + 0, 0, true);
194
194
  if (!(e instanceof InputStream)) {
195
- throw new Error('Not a valid "InputStream" resource.');
195
+ throw new Error('Resource error: Not a valid "InputStream" resource.');
196
196
  }
197
- const handle1 = handleCnt0++;
198
- handleTable0.set(handle1, { rep: e, own: true });
199
- dataView(memory0).setInt32(arg2 + 4, handle1, true);
197
+ var handle2 = handleCnt1++;
198
+ handleTable1.set(handle2, { rep: e, own: true });
199
+ dataView(memory0).setInt32(arg2 + 4, handle2, true);
200
200
  break;
201
201
  }
202
202
  case 'err': {
203
- const e = variant3.val;
203
+ const e = variant4.val;
204
204
  dataView(memory0).setInt8(arg2 + 0, 1, true);
205
- const val2 = e;
206
- let enum2;
207
- switch (val2) {
205
+ var val3 = e;
206
+ let enum3;
207
+ switch (val3) {
208
208
  case 'access': {
209
- enum2 = 0;
209
+ enum3 = 0;
210
210
  break;
211
211
  }
212
212
  case 'would-block': {
213
- enum2 = 1;
213
+ enum3 = 1;
214
214
  break;
215
215
  }
216
216
  case 'already': {
217
- enum2 = 2;
217
+ enum3 = 2;
218
218
  break;
219
219
  }
220
220
  case 'bad-descriptor': {
221
- enum2 = 3;
221
+ enum3 = 3;
222
222
  break;
223
223
  }
224
224
  case 'busy': {
225
- enum2 = 4;
225
+ enum3 = 4;
226
226
  break;
227
227
  }
228
228
  case 'deadlock': {
229
- enum2 = 5;
229
+ enum3 = 5;
230
230
  break;
231
231
  }
232
232
  case 'quota': {
233
- enum2 = 6;
233
+ enum3 = 6;
234
234
  break;
235
235
  }
236
236
  case 'exist': {
237
- enum2 = 7;
237
+ enum3 = 7;
238
238
  break;
239
239
  }
240
240
  case 'file-too-large': {
241
- enum2 = 8;
241
+ enum3 = 8;
242
242
  break;
243
243
  }
244
244
  case 'illegal-byte-sequence': {
245
- enum2 = 9;
245
+ enum3 = 9;
246
246
  break;
247
247
  }
248
248
  case 'in-progress': {
249
- enum2 = 10;
249
+ enum3 = 10;
250
250
  break;
251
251
  }
252
252
  case 'interrupted': {
253
- enum2 = 11;
253
+ enum3 = 11;
254
254
  break;
255
255
  }
256
256
  case 'invalid': {
257
- enum2 = 12;
257
+ enum3 = 12;
258
258
  break;
259
259
  }
260
260
  case 'io': {
261
- enum2 = 13;
261
+ enum3 = 13;
262
262
  break;
263
263
  }
264
264
  case 'is-directory': {
265
- enum2 = 14;
265
+ enum3 = 14;
266
266
  break;
267
267
  }
268
268
  case 'loop': {
269
- enum2 = 15;
269
+ enum3 = 15;
270
270
  break;
271
271
  }
272
272
  case 'too-many-links': {
273
- enum2 = 16;
273
+ enum3 = 16;
274
274
  break;
275
275
  }
276
276
  case 'message-size': {
277
- enum2 = 17;
277
+ enum3 = 17;
278
278
  break;
279
279
  }
280
280
  case 'name-too-long': {
281
- enum2 = 18;
281
+ enum3 = 18;
282
282
  break;
283
283
  }
284
284
  case 'no-device': {
285
- enum2 = 19;
285
+ enum3 = 19;
286
286
  break;
287
287
  }
288
288
  case 'no-entry': {
289
- enum2 = 20;
289
+ enum3 = 20;
290
290
  break;
291
291
  }
292
292
  case 'no-lock': {
293
- enum2 = 21;
293
+ enum3 = 21;
294
294
  break;
295
295
  }
296
296
  case 'insufficient-memory': {
297
- enum2 = 22;
297
+ enum3 = 22;
298
298
  break;
299
299
  }
300
300
  case 'insufficient-space': {
301
- enum2 = 23;
301
+ enum3 = 23;
302
302
  break;
303
303
  }
304
304
  case 'not-directory': {
305
- enum2 = 24;
305
+ enum3 = 24;
306
306
  break;
307
307
  }
308
308
  case 'not-empty': {
309
- enum2 = 25;
309
+ enum3 = 25;
310
310
  break;
311
311
  }
312
312
  case 'not-recoverable': {
313
- enum2 = 26;
313
+ enum3 = 26;
314
314
  break;
315
315
  }
316
316
  case 'unsupported': {
317
- enum2 = 27;
317
+ enum3 = 27;
318
318
  break;
319
319
  }
320
320
  case 'no-tty': {
321
- enum2 = 28;
321
+ enum3 = 28;
322
322
  break;
323
323
  }
324
324
  case 'no-such-device': {
325
- enum2 = 29;
325
+ enum3 = 29;
326
326
  break;
327
327
  }
328
328
  case 'overflow': {
329
- enum2 = 30;
329
+ enum3 = 30;
330
330
  break;
331
331
  }
332
332
  case 'not-permitted': {
333
- enum2 = 31;
333
+ enum3 = 31;
334
334
  break;
335
335
  }
336
336
  case 'pipe': {
337
- enum2 = 32;
337
+ enum3 = 32;
338
338
  break;
339
339
  }
340
340
  case 'read-only': {
341
- enum2 = 33;
341
+ enum3 = 33;
342
342
  break;
343
343
  }
344
344
  case 'invalid-seek': {
345
- enum2 = 34;
345
+ enum3 = 34;
346
346
  break;
347
347
  }
348
348
  case 'text-file-busy': {
349
- enum2 = 35;
349
+ enum3 = 35;
350
350
  break;
351
351
  }
352
352
  case 'cross-device': {
353
- enum2 = 36;
353
+ enum3 = 36;
354
354
  break;
355
355
  }
356
356
  default: {
@@ -358,10 +358,10 @@ function trampoline13(arg0, arg1, arg2) {
358
358
  console.error(e);
359
359
  }
360
360
 
361
- throw new TypeError(`"${val2}" is not one of the cases of error-code`);
361
+ throw new TypeError(`"${val3}" is not one of the cases of error-code`);
362
362
  }
363
363
  }
364
- dataView(memory0).setInt8(arg2 + 4, enum2, true);
364
+ dataView(memory0).setInt8(arg2 + 4, enum3, true);
365
365
  break;
366
366
  }
367
367
  default: {
@@ -371,178 +371,179 @@ function trampoline13(arg0, arg1, arg2) {
371
371
  }
372
372
 
373
373
  function trampoline14(arg0, arg1, arg2) {
374
- const rsc0 = handleTable3.get(arg0).rep;
374
+ var handle1 = arg0;
375
+ var rsc0 = handleTable3.get(handle1).rep;
375
376
  let ret;
376
377
  try {
377
378
  ret = { tag: 'ok', val: Descriptor.prototype.writeViaStream.call(rsc0, BigInt.asUintN(64, arg1)) };
378
379
  } catch (e) {
379
380
  ret = { tag: 'err', val: getErrorPayload(e) };
380
381
  }
381
- const variant3 = ret;
382
- switch (variant3.tag) {
382
+ var variant4 = ret;
383
+ switch (variant4.tag) {
383
384
  case 'ok': {
384
- const e = variant3.val;
385
+ const e = variant4.val;
385
386
  dataView(memory0).setInt8(arg2 + 0, 0, true);
386
387
  if (!(e instanceof OutputStream)) {
387
- throw new Error('Not a valid "OutputStream" resource.');
388
+ throw new Error('Resource error: Not a valid "OutputStream" resource.');
388
389
  }
389
- const handle1 = handleCnt2++;
390
- handleTable2.set(handle1, { rep: e, own: true });
391
- dataView(memory0).setInt32(arg2 + 4, handle1, true);
390
+ var handle2 = handleCnt2++;
391
+ handleTable2.set(handle2, { rep: e, own: true });
392
+ dataView(memory0).setInt32(arg2 + 4, handle2, true);
392
393
  break;
393
394
  }
394
395
  case 'err': {
395
- const e = variant3.val;
396
+ const e = variant4.val;
396
397
  dataView(memory0).setInt8(arg2 + 0, 1, true);
397
- const val2 = e;
398
- let enum2;
399
- switch (val2) {
398
+ var val3 = e;
399
+ let enum3;
400
+ switch (val3) {
400
401
  case 'access': {
401
- enum2 = 0;
402
+ enum3 = 0;
402
403
  break;
403
404
  }
404
405
  case 'would-block': {
405
- enum2 = 1;
406
+ enum3 = 1;
406
407
  break;
407
408
  }
408
409
  case 'already': {
409
- enum2 = 2;
410
+ enum3 = 2;
410
411
  break;
411
412
  }
412
413
  case 'bad-descriptor': {
413
- enum2 = 3;
414
+ enum3 = 3;
414
415
  break;
415
416
  }
416
417
  case 'busy': {
417
- enum2 = 4;
418
+ enum3 = 4;
418
419
  break;
419
420
  }
420
421
  case 'deadlock': {
421
- enum2 = 5;
422
+ enum3 = 5;
422
423
  break;
423
424
  }
424
425
  case 'quota': {
425
- enum2 = 6;
426
+ enum3 = 6;
426
427
  break;
427
428
  }
428
429
  case 'exist': {
429
- enum2 = 7;
430
+ enum3 = 7;
430
431
  break;
431
432
  }
432
433
  case 'file-too-large': {
433
- enum2 = 8;
434
+ enum3 = 8;
434
435
  break;
435
436
  }
436
437
  case 'illegal-byte-sequence': {
437
- enum2 = 9;
438
+ enum3 = 9;
438
439
  break;
439
440
  }
440
441
  case 'in-progress': {
441
- enum2 = 10;
442
+ enum3 = 10;
442
443
  break;
443
444
  }
444
445
  case 'interrupted': {
445
- enum2 = 11;
446
+ enum3 = 11;
446
447
  break;
447
448
  }
448
449
  case 'invalid': {
449
- enum2 = 12;
450
+ enum3 = 12;
450
451
  break;
451
452
  }
452
453
  case 'io': {
453
- enum2 = 13;
454
+ enum3 = 13;
454
455
  break;
455
456
  }
456
457
  case 'is-directory': {
457
- enum2 = 14;
458
+ enum3 = 14;
458
459
  break;
459
460
  }
460
461
  case 'loop': {
461
- enum2 = 15;
462
+ enum3 = 15;
462
463
  break;
463
464
  }
464
465
  case 'too-many-links': {
465
- enum2 = 16;
466
+ enum3 = 16;
466
467
  break;
467
468
  }
468
469
  case 'message-size': {
469
- enum2 = 17;
470
+ enum3 = 17;
470
471
  break;
471
472
  }
472
473
  case 'name-too-long': {
473
- enum2 = 18;
474
+ enum3 = 18;
474
475
  break;
475
476
  }
476
477
  case 'no-device': {
477
- enum2 = 19;
478
+ enum3 = 19;
478
479
  break;
479
480
  }
480
481
  case 'no-entry': {
481
- enum2 = 20;
482
+ enum3 = 20;
482
483
  break;
483
484
  }
484
485
  case 'no-lock': {
485
- enum2 = 21;
486
+ enum3 = 21;
486
487
  break;
487
488
  }
488
489
  case 'insufficient-memory': {
489
- enum2 = 22;
490
+ enum3 = 22;
490
491
  break;
491
492
  }
492
493
  case 'insufficient-space': {
493
- enum2 = 23;
494
+ enum3 = 23;
494
495
  break;
495
496
  }
496
497
  case 'not-directory': {
497
- enum2 = 24;
498
+ enum3 = 24;
498
499
  break;
499
500
  }
500
501
  case 'not-empty': {
501
- enum2 = 25;
502
+ enum3 = 25;
502
503
  break;
503
504
  }
504
505
  case 'not-recoverable': {
505
- enum2 = 26;
506
+ enum3 = 26;
506
507
  break;
507
508
  }
508
509
  case 'unsupported': {
509
- enum2 = 27;
510
+ enum3 = 27;
510
511
  break;
511
512
  }
512
513
  case 'no-tty': {
513
- enum2 = 28;
514
+ enum3 = 28;
514
515
  break;
515
516
  }
516
517
  case 'no-such-device': {
517
- enum2 = 29;
518
+ enum3 = 29;
518
519
  break;
519
520
  }
520
521
  case 'overflow': {
521
- enum2 = 30;
522
+ enum3 = 30;
522
523
  break;
523
524
  }
524
525
  case 'not-permitted': {
525
- enum2 = 31;
526
+ enum3 = 31;
526
527
  break;
527
528
  }
528
529
  case 'pipe': {
529
- enum2 = 32;
530
+ enum3 = 32;
530
531
  break;
531
532
  }
532
533
  case 'read-only': {
533
- enum2 = 33;
534
+ enum3 = 33;
534
535
  break;
535
536
  }
536
537
  case 'invalid-seek': {
537
- enum2 = 34;
538
+ enum3 = 34;
538
539
  break;
539
540
  }
540
541
  case 'text-file-busy': {
541
- enum2 = 35;
542
+ enum3 = 35;
542
543
  break;
543
544
  }
544
545
  case 'cross-device': {
545
- enum2 = 36;
546
+ enum3 = 36;
546
547
  break;
547
548
  }
548
549
  default: {
@@ -550,10 +551,10 @@ function trampoline14(arg0, arg1, arg2) {
550
551
  console.error(e);
551
552
  }
552
553
 
553
- throw new TypeError(`"${val2}" is not one of the cases of error-code`);
554
+ throw new TypeError(`"${val3}" is not one of the cases of error-code`);
554
555
  }
555
556
  }
556
- dataView(memory0).setInt8(arg2 + 4, enum2, true);
557
+ dataView(memory0).setInt8(arg2 + 4, enum3, true);
557
558
  break;
558
559
  }
559
560
  default: {
@@ -563,178 +564,179 @@ function trampoline14(arg0, arg1, arg2) {
563
564
  }
564
565
 
565
566
  function trampoline15(arg0, arg1) {
566
- const rsc0 = handleTable3.get(arg0).rep;
567
+ var handle1 = arg0;
568
+ var rsc0 = handleTable3.get(handle1).rep;
567
569
  let ret;
568
570
  try {
569
571
  ret = { tag: 'ok', val: Descriptor.prototype.appendViaStream.call(rsc0) };
570
572
  } catch (e) {
571
573
  ret = { tag: 'err', val: getErrorPayload(e) };
572
574
  }
573
- const variant3 = ret;
574
- switch (variant3.tag) {
575
+ var variant4 = ret;
576
+ switch (variant4.tag) {
575
577
  case 'ok': {
576
- const e = variant3.val;
578
+ const e = variant4.val;
577
579
  dataView(memory0).setInt8(arg1 + 0, 0, true);
578
580
  if (!(e instanceof OutputStream)) {
579
- throw new Error('Not a valid "OutputStream" resource.');
581
+ throw new Error('Resource error: Not a valid "OutputStream" resource.');
580
582
  }
581
- const handle1 = handleCnt2++;
582
- handleTable2.set(handle1, { rep: e, own: true });
583
- dataView(memory0).setInt32(arg1 + 4, handle1, true);
583
+ var handle2 = handleCnt2++;
584
+ handleTable2.set(handle2, { rep: e, own: true });
585
+ dataView(memory0).setInt32(arg1 + 4, handle2, true);
584
586
  break;
585
587
  }
586
588
  case 'err': {
587
- const e = variant3.val;
589
+ const e = variant4.val;
588
590
  dataView(memory0).setInt8(arg1 + 0, 1, true);
589
- const val2 = e;
590
- let enum2;
591
- switch (val2) {
591
+ var val3 = e;
592
+ let enum3;
593
+ switch (val3) {
592
594
  case 'access': {
593
- enum2 = 0;
595
+ enum3 = 0;
594
596
  break;
595
597
  }
596
598
  case 'would-block': {
597
- enum2 = 1;
599
+ enum3 = 1;
598
600
  break;
599
601
  }
600
602
  case 'already': {
601
- enum2 = 2;
603
+ enum3 = 2;
602
604
  break;
603
605
  }
604
606
  case 'bad-descriptor': {
605
- enum2 = 3;
607
+ enum3 = 3;
606
608
  break;
607
609
  }
608
610
  case 'busy': {
609
- enum2 = 4;
611
+ enum3 = 4;
610
612
  break;
611
613
  }
612
614
  case 'deadlock': {
613
- enum2 = 5;
615
+ enum3 = 5;
614
616
  break;
615
617
  }
616
618
  case 'quota': {
617
- enum2 = 6;
619
+ enum3 = 6;
618
620
  break;
619
621
  }
620
622
  case 'exist': {
621
- enum2 = 7;
623
+ enum3 = 7;
622
624
  break;
623
625
  }
624
626
  case 'file-too-large': {
625
- enum2 = 8;
627
+ enum3 = 8;
626
628
  break;
627
629
  }
628
630
  case 'illegal-byte-sequence': {
629
- enum2 = 9;
631
+ enum3 = 9;
630
632
  break;
631
633
  }
632
634
  case 'in-progress': {
633
- enum2 = 10;
635
+ enum3 = 10;
634
636
  break;
635
637
  }
636
638
  case 'interrupted': {
637
- enum2 = 11;
639
+ enum3 = 11;
638
640
  break;
639
641
  }
640
642
  case 'invalid': {
641
- enum2 = 12;
643
+ enum3 = 12;
642
644
  break;
643
645
  }
644
646
  case 'io': {
645
- enum2 = 13;
647
+ enum3 = 13;
646
648
  break;
647
649
  }
648
650
  case 'is-directory': {
649
- enum2 = 14;
651
+ enum3 = 14;
650
652
  break;
651
653
  }
652
654
  case 'loop': {
653
- enum2 = 15;
655
+ enum3 = 15;
654
656
  break;
655
657
  }
656
658
  case 'too-many-links': {
657
- enum2 = 16;
659
+ enum3 = 16;
658
660
  break;
659
661
  }
660
662
  case 'message-size': {
661
- enum2 = 17;
663
+ enum3 = 17;
662
664
  break;
663
665
  }
664
666
  case 'name-too-long': {
665
- enum2 = 18;
667
+ enum3 = 18;
666
668
  break;
667
669
  }
668
670
  case 'no-device': {
669
- enum2 = 19;
671
+ enum3 = 19;
670
672
  break;
671
673
  }
672
674
  case 'no-entry': {
673
- enum2 = 20;
675
+ enum3 = 20;
674
676
  break;
675
677
  }
676
678
  case 'no-lock': {
677
- enum2 = 21;
679
+ enum3 = 21;
678
680
  break;
679
681
  }
680
682
  case 'insufficient-memory': {
681
- enum2 = 22;
683
+ enum3 = 22;
682
684
  break;
683
685
  }
684
686
  case 'insufficient-space': {
685
- enum2 = 23;
687
+ enum3 = 23;
686
688
  break;
687
689
  }
688
690
  case 'not-directory': {
689
- enum2 = 24;
691
+ enum3 = 24;
690
692
  break;
691
693
  }
692
694
  case 'not-empty': {
693
- enum2 = 25;
695
+ enum3 = 25;
694
696
  break;
695
697
  }
696
698
  case 'not-recoverable': {
697
- enum2 = 26;
699
+ enum3 = 26;
698
700
  break;
699
701
  }
700
702
  case 'unsupported': {
701
- enum2 = 27;
703
+ enum3 = 27;
702
704
  break;
703
705
  }
704
706
  case 'no-tty': {
705
- enum2 = 28;
707
+ enum3 = 28;
706
708
  break;
707
709
  }
708
710
  case 'no-such-device': {
709
- enum2 = 29;
711
+ enum3 = 29;
710
712
  break;
711
713
  }
712
714
  case 'overflow': {
713
- enum2 = 30;
715
+ enum3 = 30;
714
716
  break;
715
717
  }
716
718
  case 'not-permitted': {
717
- enum2 = 31;
719
+ enum3 = 31;
718
720
  break;
719
721
  }
720
722
  case 'pipe': {
721
- enum2 = 32;
723
+ enum3 = 32;
722
724
  break;
723
725
  }
724
726
  case 'read-only': {
725
- enum2 = 33;
727
+ enum3 = 33;
726
728
  break;
727
729
  }
728
730
  case 'invalid-seek': {
729
- enum2 = 34;
731
+ enum3 = 34;
730
732
  break;
731
733
  }
732
734
  case 'text-file-busy': {
733
- enum2 = 35;
735
+ enum3 = 35;
734
736
  break;
735
737
  }
736
738
  case 'cross-device': {
737
- enum2 = 36;
739
+ enum3 = 36;
738
740
  break;
739
741
  }
740
742
  default: {
@@ -742,10 +744,10 @@ function trampoline15(arg0, arg1) {
742
744
  console.error(e);
743
745
  }
744
746
 
745
- throw new TypeError(`"${val2}" is not one of the cases of error-code`);
747
+ throw new TypeError(`"${val3}" is not one of the cases of error-code`);
746
748
  }
747
749
  }
748
- dataView(memory0).setInt8(arg1 + 4, enum2, true);
750
+ dataView(memory0).setInt8(arg1 + 4, enum3, true);
749
751
  break;
750
752
  }
751
753
  default: {
@@ -755,51 +757,52 @@ function trampoline15(arg0, arg1) {
755
757
  }
756
758
 
757
759
  function trampoline16(arg0, arg1) {
758
- const rsc0 = handleTable3.get(arg0).rep;
760
+ var handle1 = arg0;
761
+ var rsc0 = handleTable3.get(handle1).rep;
759
762
  let ret;
760
763
  try {
761
764
  ret = { tag: 'ok', val: Descriptor.prototype.getType.call(rsc0) };
762
765
  } catch (e) {
763
766
  ret = { tag: 'err', val: getErrorPayload(e) };
764
767
  }
765
- const variant3 = ret;
766
- switch (variant3.tag) {
768
+ var variant4 = ret;
769
+ switch (variant4.tag) {
767
770
  case 'ok': {
768
- const e = variant3.val;
771
+ const e = variant4.val;
769
772
  dataView(memory0).setInt8(arg1 + 0, 0, true);
770
- const val1 = e;
771
- let enum1;
772
- switch (val1) {
773
+ var val2 = e;
774
+ let enum2;
775
+ switch (val2) {
773
776
  case 'unknown': {
774
- enum1 = 0;
777
+ enum2 = 0;
775
778
  break;
776
779
  }
777
780
  case 'block-device': {
778
- enum1 = 1;
781
+ enum2 = 1;
779
782
  break;
780
783
  }
781
784
  case 'character-device': {
782
- enum1 = 2;
785
+ enum2 = 2;
783
786
  break;
784
787
  }
785
788
  case 'directory': {
786
- enum1 = 3;
789
+ enum2 = 3;
787
790
  break;
788
791
  }
789
792
  case 'fifo': {
790
- enum1 = 4;
793
+ enum2 = 4;
791
794
  break;
792
795
  }
793
796
  case 'symbolic-link': {
794
- enum1 = 5;
797
+ enum2 = 5;
795
798
  break;
796
799
  }
797
800
  case 'regular-file': {
798
- enum1 = 6;
801
+ enum2 = 6;
799
802
  break;
800
803
  }
801
804
  case 'socket': {
802
- enum1 = 7;
805
+ enum2 = 7;
803
806
  break;
804
807
  }
805
808
  default: {
@@ -807,164 +810,164 @@ function trampoline16(arg0, arg1) {
807
810
  console.error(e);
808
811
  }
809
812
 
810
- throw new TypeError(`"${val1}" is not one of the cases of descriptor-type`);
813
+ throw new TypeError(`"${val2}" is not one of the cases of descriptor-type`);
811
814
  }
812
815
  }
813
- dataView(memory0).setInt8(arg1 + 1, enum1, true);
816
+ dataView(memory0).setInt8(arg1 + 1, enum2, true);
814
817
  break;
815
818
  }
816
819
  case 'err': {
817
- const e = variant3.val;
820
+ const e = variant4.val;
818
821
  dataView(memory0).setInt8(arg1 + 0, 1, true);
819
- const val2 = e;
820
- let enum2;
821
- switch (val2) {
822
+ var val3 = e;
823
+ let enum3;
824
+ switch (val3) {
822
825
  case 'access': {
823
- enum2 = 0;
826
+ enum3 = 0;
824
827
  break;
825
828
  }
826
829
  case 'would-block': {
827
- enum2 = 1;
830
+ enum3 = 1;
828
831
  break;
829
832
  }
830
833
  case 'already': {
831
- enum2 = 2;
834
+ enum3 = 2;
832
835
  break;
833
836
  }
834
837
  case 'bad-descriptor': {
835
- enum2 = 3;
838
+ enum3 = 3;
836
839
  break;
837
840
  }
838
841
  case 'busy': {
839
- enum2 = 4;
842
+ enum3 = 4;
840
843
  break;
841
844
  }
842
845
  case 'deadlock': {
843
- enum2 = 5;
846
+ enum3 = 5;
844
847
  break;
845
848
  }
846
849
  case 'quota': {
847
- enum2 = 6;
850
+ enum3 = 6;
848
851
  break;
849
852
  }
850
853
  case 'exist': {
851
- enum2 = 7;
854
+ enum3 = 7;
852
855
  break;
853
856
  }
854
857
  case 'file-too-large': {
855
- enum2 = 8;
858
+ enum3 = 8;
856
859
  break;
857
860
  }
858
861
  case 'illegal-byte-sequence': {
859
- enum2 = 9;
862
+ enum3 = 9;
860
863
  break;
861
864
  }
862
865
  case 'in-progress': {
863
- enum2 = 10;
866
+ enum3 = 10;
864
867
  break;
865
868
  }
866
869
  case 'interrupted': {
867
- enum2 = 11;
870
+ enum3 = 11;
868
871
  break;
869
872
  }
870
873
  case 'invalid': {
871
- enum2 = 12;
874
+ enum3 = 12;
872
875
  break;
873
876
  }
874
877
  case 'io': {
875
- enum2 = 13;
878
+ enum3 = 13;
876
879
  break;
877
880
  }
878
881
  case 'is-directory': {
879
- enum2 = 14;
882
+ enum3 = 14;
880
883
  break;
881
884
  }
882
885
  case 'loop': {
883
- enum2 = 15;
886
+ enum3 = 15;
884
887
  break;
885
888
  }
886
889
  case 'too-many-links': {
887
- enum2 = 16;
890
+ enum3 = 16;
888
891
  break;
889
892
  }
890
893
  case 'message-size': {
891
- enum2 = 17;
894
+ enum3 = 17;
892
895
  break;
893
896
  }
894
897
  case 'name-too-long': {
895
- enum2 = 18;
898
+ enum3 = 18;
896
899
  break;
897
900
  }
898
901
  case 'no-device': {
899
- enum2 = 19;
902
+ enum3 = 19;
900
903
  break;
901
904
  }
902
905
  case 'no-entry': {
903
- enum2 = 20;
906
+ enum3 = 20;
904
907
  break;
905
908
  }
906
909
  case 'no-lock': {
907
- enum2 = 21;
910
+ enum3 = 21;
908
911
  break;
909
912
  }
910
913
  case 'insufficient-memory': {
911
- enum2 = 22;
914
+ enum3 = 22;
912
915
  break;
913
916
  }
914
917
  case 'insufficient-space': {
915
- enum2 = 23;
918
+ enum3 = 23;
916
919
  break;
917
920
  }
918
921
  case 'not-directory': {
919
- enum2 = 24;
922
+ enum3 = 24;
920
923
  break;
921
924
  }
922
925
  case 'not-empty': {
923
- enum2 = 25;
926
+ enum3 = 25;
924
927
  break;
925
928
  }
926
929
  case 'not-recoverable': {
927
- enum2 = 26;
930
+ enum3 = 26;
928
931
  break;
929
932
  }
930
933
  case 'unsupported': {
931
- enum2 = 27;
934
+ enum3 = 27;
932
935
  break;
933
936
  }
934
937
  case 'no-tty': {
935
- enum2 = 28;
938
+ enum3 = 28;
936
939
  break;
937
940
  }
938
941
  case 'no-such-device': {
939
- enum2 = 29;
942
+ enum3 = 29;
940
943
  break;
941
944
  }
942
945
  case 'overflow': {
943
- enum2 = 30;
946
+ enum3 = 30;
944
947
  break;
945
948
  }
946
949
  case 'not-permitted': {
947
- enum2 = 31;
950
+ enum3 = 31;
948
951
  break;
949
952
  }
950
953
  case 'pipe': {
951
- enum2 = 32;
954
+ enum3 = 32;
952
955
  break;
953
956
  }
954
957
  case 'read-only': {
955
- enum2 = 33;
958
+ enum3 = 33;
956
959
  break;
957
960
  }
958
961
  case 'invalid-seek': {
959
- enum2 = 34;
962
+ enum3 = 34;
960
963
  break;
961
964
  }
962
965
  case 'text-file-busy': {
963
- enum2 = 35;
966
+ enum3 = 35;
964
967
  break;
965
968
  }
966
969
  case 'cross-device': {
967
- enum2 = 36;
970
+ enum3 = 36;
968
971
  break;
969
972
  }
970
973
  default: {
@@ -972,10 +975,10 @@ function trampoline16(arg0, arg1) {
972
975
  console.error(e);
973
976
  }
974
977
 
975
- throw new TypeError(`"${val2}" is not one of the cases of error-code`);
978
+ throw new TypeError(`"${val3}" is not one of the cases of error-code`);
976
979
  }
977
980
  }
978
- dataView(memory0).setInt8(arg1 + 1, enum2, true);
981
+ dataView(memory0).setInt8(arg1 + 1, enum3, true);
979
982
  break;
980
983
  }
981
984
  default: {
@@ -985,249 +988,250 @@ function trampoline16(arg0, arg1) {
985
988
  }
986
989
 
987
990
  function trampoline17(arg0, arg1) {
988
- const rsc0 = handleTable3.get(arg0).rep;
991
+ var handle1 = arg0;
992
+ var rsc0 = handleTable3.get(handle1).rep;
989
993
  let ret;
990
994
  try {
991
995
  ret = { tag: 'ok', val: Descriptor.prototype.stat.call(rsc0) };
992
996
  } catch (e) {
993
997
  ret = { tag: 'err', val: getErrorPayload(e) };
994
998
  }
995
- const variant10 = ret;
996
- switch (variant10.tag) {
999
+ var variant11 = ret;
1000
+ switch (variant11.tag) {
997
1001
  case 'ok': {
998
- const e = variant10.val;
1002
+ const e = variant11.val;
999
1003
  dataView(memory0).setInt8(arg1 + 0, 0, true);
1000
- const {type: v1_0, linkCount: v1_1, size: v1_2, dataAccessTimestamp: v1_3, dataModificationTimestamp: v1_4, statusChangeTimestamp: v1_5 } = e;
1001
- const val2 = v1_0;
1002
- let enum2;
1003
- switch (val2) {
1004
+ var {type: v2_0, linkCount: v2_1, size: v2_2, dataAccessTimestamp: v2_3, dataModificationTimestamp: v2_4, statusChangeTimestamp: v2_5 } = e;
1005
+ var val3 = v2_0;
1006
+ let enum3;
1007
+ switch (val3) {
1004
1008
  case 'unknown': {
1005
- enum2 = 0;
1009
+ enum3 = 0;
1006
1010
  break;
1007
1011
  }
1008
1012
  case 'block-device': {
1009
- enum2 = 1;
1013
+ enum3 = 1;
1010
1014
  break;
1011
1015
  }
1012
1016
  case 'character-device': {
1013
- enum2 = 2;
1017
+ enum3 = 2;
1014
1018
  break;
1015
1019
  }
1016
1020
  case 'directory': {
1017
- enum2 = 3;
1021
+ enum3 = 3;
1018
1022
  break;
1019
1023
  }
1020
1024
  case 'fifo': {
1021
- enum2 = 4;
1025
+ enum3 = 4;
1022
1026
  break;
1023
1027
  }
1024
1028
  case 'symbolic-link': {
1025
- enum2 = 5;
1029
+ enum3 = 5;
1026
1030
  break;
1027
1031
  }
1028
1032
  case 'regular-file': {
1029
- enum2 = 6;
1033
+ enum3 = 6;
1030
1034
  break;
1031
1035
  }
1032
1036
  case 'socket': {
1033
- enum2 = 7;
1037
+ enum3 = 7;
1034
1038
  break;
1035
1039
  }
1036
1040
  default: {
1037
- if ((v1_0) instanceof Error) {
1038
- console.error(v1_0);
1041
+ if ((v2_0) instanceof Error) {
1042
+ console.error(v2_0);
1039
1043
  }
1040
1044
 
1041
- throw new TypeError(`"${val2}" is not one of the cases of descriptor-type`);
1045
+ throw new TypeError(`"${val3}" is not one of the cases of descriptor-type`);
1042
1046
  }
1043
1047
  }
1044
- dataView(memory0).setInt8(arg1 + 8, enum2, true);
1045
- dataView(memory0).setBigInt64(arg1 + 16, toUint64(v1_1), true);
1046
- dataView(memory0).setBigInt64(arg1 + 24, toUint64(v1_2), true);
1047
- const variant4 = v1_3;
1048
- if (variant4 === null || variant4=== undefined) {
1048
+ dataView(memory0).setInt8(arg1 + 8, enum3, true);
1049
+ dataView(memory0).setBigInt64(arg1 + 16, toUint64(v2_1), true);
1050
+ dataView(memory0).setBigInt64(arg1 + 24, toUint64(v2_2), true);
1051
+ var variant5 = v2_3;
1052
+ if (variant5 === null || variant5=== undefined) {
1049
1053
  dataView(memory0).setInt8(arg1 + 32, 0, true);
1050
1054
  } else {
1051
- const e = variant4;
1055
+ const e = variant5;
1052
1056
  dataView(memory0).setInt8(arg1 + 32, 1, true);
1053
- const {seconds: v3_0, nanoseconds: v3_1 } = e;
1054
- dataView(memory0).setBigInt64(arg1 + 40, toUint64(v3_0), true);
1055
- dataView(memory0).setInt32(arg1 + 48, toUint32(v3_1), true);
1057
+ var {seconds: v4_0, nanoseconds: v4_1 } = e;
1058
+ dataView(memory0).setBigInt64(arg1 + 40, toUint64(v4_0), true);
1059
+ dataView(memory0).setInt32(arg1 + 48, toUint32(v4_1), true);
1056
1060
  }
1057
- const variant6 = v1_4;
1058
- if (variant6 === null || variant6=== undefined) {
1061
+ var variant7 = v2_4;
1062
+ if (variant7 === null || variant7=== undefined) {
1059
1063
  dataView(memory0).setInt8(arg1 + 56, 0, true);
1060
1064
  } else {
1061
- const e = variant6;
1065
+ const e = variant7;
1062
1066
  dataView(memory0).setInt8(arg1 + 56, 1, true);
1063
- const {seconds: v5_0, nanoseconds: v5_1 } = e;
1064
- dataView(memory0).setBigInt64(arg1 + 64, toUint64(v5_0), true);
1065
- dataView(memory0).setInt32(arg1 + 72, toUint32(v5_1), true);
1067
+ var {seconds: v6_0, nanoseconds: v6_1 } = e;
1068
+ dataView(memory0).setBigInt64(arg1 + 64, toUint64(v6_0), true);
1069
+ dataView(memory0).setInt32(arg1 + 72, toUint32(v6_1), true);
1066
1070
  }
1067
- const variant8 = v1_5;
1068
- if (variant8 === null || variant8=== undefined) {
1071
+ var variant9 = v2_5;
1072
+ if (variant9 === null || variant9=== undefined) {
1069
1073
  dataView(memory0).setInt8(arg1 + 80, 0, true);
1070
1074
  } else {
1071
- const e = variant8;
1075
+ const e = variant9;
1072
1076
  dataView(memory0).setInt8(arg1 + 80, 1, true);
1073
- const {seconds: v7_0, nanoseconds: v7_1 } = e;
1074
- dataView(memory0).setBigInt64(arg1 + 88, toUint64(v7_0), true);
1075
- dataView(memory0).setInt32(arg1 + 96, toUint32(v7_1), true);
1077
+ var {seconds: v8_0, nanoseconds: v8_1 } = e;
1078
+ dataView(memory0).setBigInt64(arg1 + 88, toUint64(v8_0), true);
1079
+ dataView(memory0).setInt32(arg1 + 96, toUint32(v8_1), true);
1076
1080
  }
1077
1081
  break;
1078
1082
  }
1079
1083
  case 'err': {
1080
- const e = variant10.val;
1084
+ const e = variant11.val;
1081
1085
  dataView(memory0).setInt8(arg1 + 0, 1, true);
1082
- const val9 = e;
1083
- let enum9;
1084
- switch (val9) {
1086
+ var val10 = e;
1087
+ let enum10;
1088
+ switch (val10) {
1085
1089
  case 'access': {
1086
- enum9 = 0;
1090
+ enum10 = 0;
1087
1091
  break;
1088
1092
  }
1089
1093
  case 'would-block': {
1090
- enum9 = 1;
1094
+ enum10 = 1;
1091
1095
  break;
1092
1096
  }
1093
1097
  case 'already': {
1094
- enum9 = 2;
1098
+ enum10 = 2;
1095
1099
  break;
1096
1100
  }
1097
1101
  case 'bad-descriptor': {
1098
- enum9 = 3;
1102
+ enum10 = 3;
1099
1103
  break;
1100
1104
  }
1101
1105
  case 'busy': {
1102
- enum9 = 4;
1106
+ enum10 = 4;
1103
1107
  break;
1104
1108
  }
1105
1109
  case 'deadlock': {
1106
- enum9 = 5;
1110
+ enum10 = 5;
1107
1111
  break;
1108
1112
  }
1109
1113
  case 'quota': {
1110
- enum9 = 6;
1114
+ enum10 = 6;
1111
1115
  break;
1112
1116
  }
1113
1117
  case 'exist': {
1114
- enum9 = 7;
1118
+ enum10 = 7;
1115
1119
  break;
1116
1120
  }
1117
1121
  case 'file-too-large': {
1118
- enum9 = 8;
1122
+ enum10 = 8;
1119
1123
  break;
1120
1124
  }
1121
1125
  case 'illegal-byte-sequence': {
1122
- enum9 = 9;
1126
+ enum10 = 9;
1123
1127
  break;
1124
1128
  }
1125
1129
  case 'in-progress': {
1126
- enum9 = 10;
1130
+ enum10 = 10;
1127
1131
  break;
1128
1132
  }
1129
1133
  case 'interrupted': {
1130
- enum9 = 11;
1134
+ enum10 = 11;
1131
1135
  break;
1132
1136
  }
1133
1137
  case 'invalid': {
1134
- enum9 = 12;
1138
+ enum10 = 12;
1135
1139
  break;
1136
1140
  }
1137
1141
  case 'io': {
1138
- enum9 = 13;
1142
+ enum10 = 13;
1139
1143
  break;
1140
1144
  }
1141
1145
  case 'is-directory': {
1142
- enum9 = 14;
1146
+ enum10 = 14;
1143
1147
  break;
1144
1148
  }
1145
1149
  case 'loop': {
1146
- enum9 = 15;
1150
+ enum10 = 15;
1147
1151
  break;
1148
1152
  }
1149
1153
  case 'too-many-links': {
1150
- enum9 = 16;
1154
+ enum10 = 16;
1151
1155
  break;
1152
1156
  }
1153
1157
  case 'message-size': {
1154
- enum9 = 17;
1158
+ enum10 = 17;
1155
1159
  break;
1156
1160
  }
1157
1161
  case 'name-too-long': {
1158
- enum9 = 18;
1162
+ enum10 = 18;
1159
1163
  break;
1160
1164
  }
1161
1165
  case 'no-device': {
1162
- enum9 = 19;
1166
+ enum10 = 19;
1163
1167
  break;
1164
1168
  }
1165
1169
  case 'no-entry': {
1166
- enum9 = 20;
1170
+ enum10 = 20;
1167
1171
  break;
1168
1172
  }
1169
1173
  case 'no-lock': {
1170
- enum9 = 21;
1174
+ enum10 = 21;
1171
1175
  break;
1172
1176
  }
1173
1177
  case 'insufficient-memory': {
1174
- enum9 = 22;
1178
+ enum10 = 22;
1175
1179
  break;
1176
1180
  }
1177
1181
  case 'insufficient-space': {
1178
- enum9 = 23;
1182
+ enum10 = 23;
1179
1183
  break;
1180
1184
  }
1181
1185
  case 'not-directory': {
1182
- enum9 = 24;
1186
+ enum10 = 24;
1183
1187
  break;
1184
1188
  }
1185
1189
  case 'not-empty': {
1186
- enum9 = 25;
1190
+ enum10 = 25;
1187
1191
  break;
1188
1192
  }
1189
1193
  case 'not-recoverable': {
1190
- enum9 = 26;
1194
+ enum10 = 26;
1191
1195
  break;
1192
1196
  }
1193
1197
  case 'unsupported': {
1194
- enum9 = 27;
1198
+ enum10 = 27;
1195
1199
  break;
1196
1200
  }
1197
1201
  case 'no-tty': {
1198
- enum9 = 28;
1202
+ enum10 = 28;
1199
1203
  break;
1200
1204
  }
1201
1205
  case 'no-such-device': {
1202
- enum9 = 29;
1206
+ enum10 = 29;
1203
1207
  break;
1204
1208
  }
1205
1209
  case 'overflow': {
1206
- enum9 = 30;
1210
+ enum10 = 30;
1207
1211
  break;
1208
1212
  }
1209
1213
  case 'not-permitted': {
1210
- enum9 = 31;
1214
+ enum10 = 31;
1211
1215
  break;
1212
1216
  }
1213
1217
  case 'pipe': {
1214
- enum9 = 32;
1218
+ enum10 = 32;
1215
1219
  break;
1216
1220
  }
1217
1221
  case 'read-only': {
1218
- enum9 = 33;
1222
+ enum10 = 33;
1219
1223
  break;
1220
1224
  }
1221
1225
  case 'invalid-seek': {
1222
- enum9 = 34;
1226
+ enum10 = 34;
1223
1227
  break;
1224
1228
  }
1225
1229
  case 'text-file-busy': {
1226
- enum9 = 35;
1230
+ enum10 = 35;
1227
1231
  break;
1228
1232
  }
1229
1233
  case 'cross-device': {
1230
- enum9 = 36;
1234
+ enum10 = 36;
1231
1235
  break;
1232
1236
  }
1233
1237
  default: {
@@ -1235,10 +1239,10 @@ function trampoline17(arg0, arg1) {
1235
1239
  console.error(e);
1236
1240
  }
1237
1241
 
1238
- throw new TypeError(`"${val9}" is not one of the cases of error-code`);
1242
+ throw new TypeError(`"${val10}" is not one of the cases of error-code`);
1239
1243
  }
1240
1244
  }
1241
- dataView(memory0).setInt8(arg1 + 8, enum9, true);
1245
+ dataView(memory0).setInt8(arg1 + 8, enum10, true);
1242
1246
  break;
1243
1247
  }
1244
1248
  default: {
@@ -1247,21 +1251,22 @@ function trampoline17(arg0, arg1) {
1247
1251
  }
1248
1252
  }
1249
1253
 
1250
- function trampoline18(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
1251
- const rsc0 = handleTable3.get(arg0).rep;
1254
+ function trampoline18(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
1255
+ var handle1 = arg0;
1256
+ var rsc0 = handleTable3.get(handle1).rep;
1252
1257
  if ((arg1 & 4294967294) !== 0) {
1253
1258
  throw new TypeError('flags have extraneous bits set');
1254
1259
  }
1255
- const flags1 = {
1260
+ var flags2 = {
1256
1261
  symlinkFollow: Boolean(arg1 & 1),
1257
1262
  };
1258
- const ptr2 = arg2;
1259
- const len2 = arg3;
1260
- const result2 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr2, len2));
1263
+ var ptr3 = arg2;
1264
+ var len3 = arg3;
1265
+ var result3 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr3, len3));
1261
1266
  if ((arg4 & 4294967280) !== 0) {
1262
1267
  throw new TypeError('flags have extraneous bits set');
1263
1268
  }
1264
- const flags3 = {
1269
+ var flags4 = {
1265
1270
  create: Boolean(arg4 & 1),
1266
1271
  directory: Boolean(arg4 & 2),
1267
1272
  exclusive: Boolean(arg4 & 4),
@@ -1270,7 +1275,7 @@ function trampoline18(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
1270
1275
  if ((arg5 & 4294967232) !== 0) {
1271
1276
  throw new TypeError('flags have extraneous bits set');
1272
1277
  }
1273
- const flags4 = {
1278
+ var flags5 = {
1274
1279
  read: Boolean(arg5 & 1),
1275
1280
  write: Boolean(arg5 & 2),
1276
1281
  fileIntegritySync: Boolean(arg5 & 4),
@@ -1278,37 +1283,29 @@ function trampoline18(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
1278
1283
  requestedWriteSync: Boolean(arg5 & 16),
1279
1284
  mutateDirectory: Boolean(arg5 & 32),
1280
1285
  };
1281
- if ((arg6 & 4294967288) !== 0) {
1282
- throw new TypeError('flags have extraneous bits set');
1283
- }
1284
- const flags5 = {
1285
- readable: Boolean(arg6 & 1),
1286
- writable: Boolean(arg6 & 2),
1287
- executable: Boolean(arg6 & 4),
1288
- };
1289
1286
  let ret;
1290
1287
  try {
1291
- ret = { tag: 'ok', val: Descriptor.prototype.openAt.call(rsc0, flags1, result2, flags3, flags4, flags5) };
1288
+ ret = { tag: 'ok', val: Descriptor.prototype.openAt.call(rsc0, flags2, result3, flags4, flags5) };
1292
1289
  } catch (e) {
1293
1290
  ret = { tag: 'err', val: getErrorPayload(e) };
1294
1291
  }
1295
- const variant8 = ret;
1292
+ var variant8 = ret;
1296
1293
  switch (variant8.tag) {
1297
1294
  case 'ok': {
1298
1295
  const e = variant8.val;
1299
- dataView(memory0).setInt8(arg7 + 0, 0, true);
1296
+ dataView(memory0).setInt8(arg6 + 0, 0, true);
1300
1297
  if (!(e instanceof Descriptor)) {
1301
- throw new Error('Not a valid "Descriptor" resource.');
1298
+ throw new Error('Resource error: Not a valid "Descriptor" resource.');
1302
1299
  }
1303
- const handle6 = handleCnt3++;
1300
+ var handle6 = handleCnt3++;
1304
1301
  handleTable3.set(handle6, { rep: e, own: true });
1305
- dataView(memory0).setInt32(arg7 + 4, handle6, true);
1302
+ dataView(memory0).setInt32(arg6 + 4, handle6, true);
1306
1303
  break;
1307
1304
  }
1308
1305
  case 'err': {
1309
1306
  const e = variant8.val;
1310
- dataView(memory0).setInt8(arg7 + 0, 1, true);
1311
- const val7 = e;
1307
+ dataView(memory0).setInt8(arg6 + 0, 1, true);
1308
+ var val7 = e;
1312
1309
  let enum7;
1313
1310
  switch (val7) {
1314
1311
  case 'access': {
@@ -1467,7 +1464,7 @@ function trampoline18(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
1467
1464
  throw new TypeError(`"${val7}" is not one of the cases of error-code`);
1468
1465
  }
1469
1466
  }
1470
- dataView(memory0).setInt8(arg7 + 4, enum7, true);
1467
+ dataView(memory0).setInt8(arg6 + 4, enum7, true);
1471
1468
  break;
1472
1469
  }
1473
1470
  default: {
@@ -1477,175 +1474,176 @@ function trampoline18(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
1477
1474
  }
1478
1475
 
1479
1476
  function trampoline19(arg0, arg1) {
1480
- const rsc0 = handleTable3.get(arg0).rep;
1477
+ var handle1 = arg0;
1478
+ var rsc0 = handleTable3.get(handle1).rep;
1481
1479
  let ret;
1482
1480
  try {
1483
1481
  ret = { tag: 'ok', val: Descriptor.prototype.metadataHash.call(rsc0) };
1484
1482
  } catch (e) {
1485
1483
  ret = { tag: 'err', val: getErrorPayload(e) };
1486
1484
  }
1487
- const variant3 = ret;
1488
- switch (variant3.tag) {
1485
+ var variant4 = ret;
1486
+ switch (variant4.tag) {
1489
1487
  case 'ok': {
1490
- const e = variant3.val;
1488
+ const e = variant4.val;
1491
1489
  dataView(memory0).setInt8(arg1 + 0, 0, true);
1492
- const {lower: v1_0, upper: v1_1 } = e;
1493
- dataView(memory0).setBigInt64(arg1 + 8, toUint64(v1_0), true);
1494
- dataView(memory0).setBigInt64(arg1 + 16, toUint64(v1_1), true);
1490
+ var {lower: v2_0, upper: v2_1 } = e;
1491
+ dataView(memory0).setBigInt64(arg1 + 8, toUint64(v2_0), true);
1492
+ dataView(memory0).setBigInt64(arg1 + 16, toUint64(v2_1), true);
1495
1493
  break;
1496
1494
  }
1497
1495
  case 'err': {
1498
- const e = variant3.val;
1496
+ const e = variant4.val;
1499
1497
  dataView(memory0).setInt8(arg1 + 0, 1, true);
1500
- const val2 = e;
1501
- let enum2;
1502
- switch (val2) {
1498
+ var val3 = e;
1499
+ let enum3;
1500
+ switch (val3) {
1503
1501
  case 'access': {
1504
- enum2 = 0;
1502
+ enum3 = 0;
1505
1503
  break;
1506
1504
  }
1507
1505
  case 'would-block': {
1508
- enum2 = 1;
1506
+ enum3 = 1;
1509
1507
  break;
1510
1508
  }
1511
1509
  case 'already': {
1512
- enum2 = 2;
1510
+ enum3 = 2;
1513
1511
  break;
1514
1512
  }
1515
1513
  case 'bad-descriptor': {
1516
- enum2 = 3;
1514
+ enum3 = 3;
1517
1515
  break;
1518
1516
  }
1519
1517
  case 'busy': {
1520
- enum2 = 4;
1518
+ enum3 = 4;
1521
1519
  break;
1522
1520
  }
1523
1521
  case 'deadlock': {
1524
- enum2 = 5;
1522
+ enum3 = 5;
1525
1523
  break;
1526
1524
  }
1527
1525
  case 'quota': {
1528
- enum2 = 6;
1526
+ enum3 = 6;
1529
1527
  break;
1530
1528
  }
1531
1529
  case 'exist': {
1532
- enum2 = 7;
1530
+ enum3 = 7;
1533
1531
  break;
1534
1532
  }
1535
1533
  case 'file-too-large': {
1536
- enum2 = 8;
1534
+ enum3 = 8;
1537
1535
  break;
1538
1536
  }
1539
1537
  case 'illegal-byte-sequence': {
1540
- enum2 = 9;
1538
+ enum3 = 9;
1541
1539
  break;
1542
1540
  }
1543
1541
  case 'in-progress': {
1544
- enum2 = 10;
1542
+ enum3 = 10;
1545
1543
  break;
1546
1544
  }
1547
1545
  case 'interrupted': {
1548
- enum2 = 11;
1546
+ enum3 = 11;
1549
1547
  break;
1550
1548
  }
1551
1549
  case 'invalid': {
1552
- enum2 = 12;
1550
+ enum3 = 12;
1553
1551
  break;
1554
1552
  }
1555
1553
  case 'io': {
1556
- enum2 = 13;
1554
+ enum3 = 13;
1557
1555
  break;
1558
1556
  }
1559
1557
  case 'is-directory': {
1560
- enum2 = 14;
1558
+ enum3 = 14;
1561
1559
  break;
1562
1560
  }
1563
1561
  case 'loop': {
1564
- enum2 = 15;
1562
+ enum3 = 15;
1565
1563
  break;
1566
1564
  }
1567
1565
  case 'too-many-links': {
1568
- enum2 = 16;
1566
+ enum3 = 16;
1569
1567
  break;
1570
1568
  }
1571
1569
  case 'message-size': {
1572
- enum2 = 17;
1570
+ enum3 = 17;
1573
1571
  break;
1574
1572
  }
1575
1573
  case 'name-too-long': {
1576
- enum2 = 18;
1574
+ enum3 = 18;
1577
1575
  break;
1578
1576
  }
1579
1577
  case 'no-device': {
1580
- enum2 = 19;
1578
+ enum3 = 19;
1581
1579
  break;
1582
1580
  }
1583
1581
  case 'no-entry': {
1584
- enum2 = 20;
1582
+ enum3 = 20;
1585
1583
  break;
1586
1584
  }
1587
1585
  case 'no-lock': {
1588
- enum2 = 21;
1586
+ enum3 = 21;
1589
1587
  break;
1590
1588
  }
1591
1589
  case 'insufficient-memory': {
1592
- enum2 = 22;
1590
+ enum3 = 22;
1593
1591
  break;
1594
1592
  }
1595
1593
  case 'insufficient-space': {
1596
- enum2 = 23;
1594
+ enum3 = 23;
1597
1595
  break;
1598
1596
  }
1599
1597
  case 'not-directory': {
1600
- enum2 = 24;
1598
+ enum3 = 24;
1601
1599
  break;
1602
1600
  }
1603
1601
  case 'not-empty': {
1604
- enum2 = 25;
1602
+ enum3 = 25;
1605
1603
  break;
1606
1604
  }
1607
1605
  case 'not-recoverable': {
1608
- enum2 = 26;
1606
+ enum3 = 26;
1609
1607
  break;
1610
1608
  }
1611
1609
  case 'unsupported': {
1612
- enum2 = 27;
1610
+ enum3 = 27;
1613
1611
  break;
1614
1612
  }
1615
1613
  case 'no-tty': {
1616
- enum2 = 28;
1614
+ enum3 = 28;
1617
1615
  break;
1618
1616
  }
1619
1617
  case 'no-such-device': {
1620
- enum2 = 29;
1618
+ enum3 = 29;
1621
1619
  break;
1622
1620
  }
1623
1621
  case 'overflow': {
1624
- enum2 = 30;
1622
+ enum3 = 30;
1625
1623
  break;
1626
1624
  }
1627
1625
  case 'not-permitted': {
1628
- enum2 = 31;
1626
+ enum3 = 31;
1629
1627
  break;
1630
1628
  }
1631
1629
  case 'pipe': {
1632
- enum2 = 32;
1630
+ enum3 = 32;
1633
1631
  break;
1634
1632
  }
1635
1633
  case 'read-only': {
1636
- enum2 = 33;
1634
+ enum3 = 33;
1637
1635
  break;
1638
1636
  }
1639
1637
  case 'invalid-seek': {
1640
- enum2 = 34;
1638
+ enum3 = 34;
1641
1639
  break;
1642
1640
  }
1643
1641
  case 'text-file-busy': {
1644
- enum2 = 35;
1642
+ enum3 = 35;
1645
1643
  break;
1646
1644
  }
1647
1645
  case 'cross-device': {
1648
- enum2 = 36;
1646
+ enum3 = 36;
1649
1647
  break;
1650
1648
  }
1651
1649
  default: {
@@ -1653,10 +1651,10 @@ function trampoline19(arg0, arg1) {
1653
1651
  console.error(e);
1654
1652
  }
1655
1653
 
1656
- throw new TypeError(`"${val2}" is not one of the cases of error-code`);
1654
+ throw new TypeError(`"${val3}" is not one of the cases of error-code`);
1657
1655
  }
1658
1656
  }
1659
- dataView(memory0).setInt8(arg1 + 8, enum2, true);
1657
+ dataView(memory0).setInt8(arg1 + 8, enum3, true);
1660
1658
  break;
1661
1659
  }
1662
1660
  default: {
@@ -1666,163 +1664,164 @@ function trampoline19(arg0, arg1) {
1666
1664
  }
1667
1665
 
1668
1666
  function trampoline20(arg0, arg1) {
1669
- const rsc0 = handleTable1.get(arg0).rep;
1667
+ var handle1 = arg0;
1668
+ var rsc0 = handleTable0.get(handle1).rep;
1670
1669
  const ret = filesystemErrorCode(rsc0);
1671
- const variant2 = ret;
1672
- if (variant2 === null || variant2=== undefined) {
1670
+ var variant3 = ret;
1671
+ if (variant3 === null || variant3=== undefined) {
1673
1672
  dataView(memory0).setInt8(arg1 + 0, 0, true);
1674
1673
  } else {
1675
- const e = variant2;
1674
+ const e = variant3;
1676
1675
  dataView(memory0).setInt8(arg1 + 0, 1, true);
1677
- const val1 = e;
1678
- let enum1;
1679
- switch (val1) {
1676
+ var val2 = e;
1677
+ let enum2;
1678
+ switch (val2) {
1680
1679
  case 'access': {
1681
- enum1 = 0;
1680
+ enum2 = 0;
1682
1681
  break;
1683
1682
  }
1684
1683
  case 'would-block': {
1685
- enum1 = 1;
1684
+ enum2 = 1;
1686
1685
  break;
1687
1686
  }
1688
1687
  case 'already': {
1689
- enum1 = 2;
1688
+ enum2 = 2;
1690
1689
  break;
1691
1690
  }
1692
1691
  case 'bad-descriptor': {
1693
- enum1 = 3;
1692
+ enum2 = 3;
1694
1693
  break;
1695
1694
  }
1696
1695
  case 'busy': {
1697
- enum1 = 4;
1696
+ enum2 = 4;
1698
1697
  break;
1699
1698
  }
1700
1699
  case 'deadlock': {
1701
- enum1 = 5;
1700
+ enum2 = 5;
1702
1701
  break;
1703
1702
  }
1704
1703
  case 'quota': {
1705
- enum1 = 6;
1704
+ enum2 = 6;
1706
1705
  break;
1707
1706
  }
1708
1707
  case 'exist': {
1709
- enum1 = 7;
1708
+ enum2 = 7;
1710
1709
  break;
1711
1710
  }
1712
1711
  case 'file-too-large': {
1713
- enum1 = 8;
1712
+ enum2 = 8;
1714
1713
  break;
1715
1714
  }
1716
1715
  case 'illegal-byte-sequence': {
1717
- enum1 = 9;
1716
+ enum2 = 9;
1718
1717
  break;
1719
1718
  }
1720
1719
  case 'in-progress': {
1721
- enum1 = 10;
1720
+ enum2 = 10;
1722
1721
  break;
1723
1722
  }
1724
1723
  case 'interrupted': {
1725
- enum1 = 11;
1724
+ enum2 = 11;
1726
1725
  break;
1727
1726
  }
1728
1727
  case 'invalid': {
1729
- enum1 = 12;
1728
+ enum2 = 12;
1730
1729
  break;
1731
1730
  }
1732
1731
  case 'io': {
1733
- enum1 = 13;
1732
+ enum2 = 13;
1734
1733
  break;
1735
1734
  }
1736
1735
  case 'is-directory': {
1737
- enum1 = 14;
1736
+ enum2 = 14;
1738
1737
  break;
1739
1738
  }
1740
1739
  case 'loop': {
1741
- enum1 = 15;
1740
+ enum2 = 15;
1742
1741
  break;
1743
1742
  }
1744
1743
  case 'too-many-links': {
1745
- enum1 = 16;
1744
+ enum2 = 16;
1746
1745
  break;
1747
1746
  }
1748
1747
  case 'message-size': {
1749
- enum1 = 17;
1748
+ enum2 = 17;
1750
1749
  break;
1751
1750
  }
1752
1751
  case 'name-too-long': {
1753
- enum1 = 18;
1752
+ enum2 = 18;
1754
1753
  break;
1755
1754
  }
1756
1755
  case 'no-device': {
1757
- enum1 = 19;
1756
+ enum2 = 19;
1758
1757
  break;
1759
1758
  }
1760
1759
  case 'no-entry': {
1761
- enum1 = 20;
1760
+ enum2 = 20;
1762
1761
  break;
1763
1762
  }
1764
1763
  case 'no-lock': {
1765
- enum1 = 21;
1764
+ enum2 = 21;
1766
1765
  break;
1767
1766
  }
1768
1767
  case 'insufficient-memory': {
1769
- enum1 = 22;
1768
+ enum2 = 22;
1770
1769
  break;
1771
1770
  }
1772
1771
  case 'insufficient-space': {
1773
- enum1 = 23;
1772
+ enum2 = 23;
1774
1773
  break;
1775
1774
  }
1776
1775
  case 'not-directory': {
1777
- enum1 = 24;
1776
+ enum2 = 24;
1778
1777
  break;
1779
1778
  }
1780
1779
  case 'not-empty': {
1781
- enum1 = 25;
1780
+ enum2 = 25;
1782
1781
  break;
1783
1782
  }
1784
1783
  case 'not-recoverable': {
1785
- enum1 = 26;
1784
+ enum2 = 26;
1786
1785
  break;
1787
1786
  }
1788
1787
  case 'unsupported': {
1789
- enum1 = 27;
1788
+ enum2 = 27;
1790
1789
  break;
1791
1790
  }
1792
1791
  case 'no-tty': {
1793
- enum1 = 28;
1792
+ enum2 = 28;
1794
1793
  break;
1795
1794
  }
1796
1795
  case 'no-such-device': {
1797
- enum1 = 29;
1796
+ enum2 = 29;
1798
1797
  break;
1799
1798
  }
1800
1799
  case 'overflow': {
1801
- enum1 = 30;
1800
+ enum2 = 30;
1802
1801
  break;
1803
1802
  }
1804
1803
  case 'not-permitted': {
1805
- enum1 = 31;
1804
+ enum2 = 31;
1806
1805
  break;
1807
1806
  }
1808
1807
  case 'pipe': {
1809
- enum1 = 32;
1808
+ enum2 = 32;
1810
1809
  break;
1811
1810
  }
1812
1811
  case 'read-only': {
1813
- enum1 = 33;
1812
+ enum2 = 33;
1814
1813
  break;
1815
1814
  }
1816
1815
  case 'invalid-seek': {
1817
- enum1 = 34;
1816
+ enum2 = 34;
1818
1817
  break;
1819
1818
  }
1820
1819
  case 'text-file-busy': {
1821
- enum1 = 35;
1820
+ enum2 = 35;
1822
1821
  break;
1823
1822
  }
1824
1823
  case 'cross-device': {
1825
- enum1 = 36;
1824
+ enum2 = 36;
1826
1825
  break;
1827
1826
  }
1828
1827
  default: {
@@ -1830,49 +1829,50 @@ function trampoline20(arg0, arg1) {
1830
1829
  console.error(e);
1831
1830
  }
1832
1831
 
1833
- throw new TypeError(`"${val1}" is not one of the cases of error-code`);
1832
+ throw new TypeError(`"${val2}" is not one of the cases of error-code`);
1834
1833
  }
1835
1834
  }
1836
- dataView(memory0).setInt8(arg1 + 1, enum1, true);
1835
+ dataView(memory0).setInt8(arg1 + 1, enum2, true);
1837
1836
  }
1838
1837
  }
1839
1838
 
1840
1839
  function trampoline21(arg0, arg1, arg2) {
1841
- const rsc0 = handleTable0.get(arg0).rep;
1840
+ var handle1 = arg0;
1841
+ var rsc0 = handleTable1.get(handle1).rep;
1842
1842
  let ret;
1843
1843
  try {
1844
1844
  ret = { tag: 'ok', val: InputStream.prototype.read.call(rsc0, BigInt.asUintN(64, arg1)) };
1845
1845
  } catch (e) {
1846
1846
  ret = { tag: 'err', val: getErrorPayload(e) };
1847
1847
  }
1848
- const variant4 = ret;
1849
- switch (variant4.tag) {
1848
+ var variant5 = ret;
1849
+ switch (variant5.tag) {
1850
1850
  case 'ok': {
1851
- const e = variant4.val;
1851
+ const e = variant5.val;
1852
1852
  dataView(memory0).setInt8(arg2 + 0, 0, true);
1853
- const val1 = e;
1854
- const len1 = val1.byteLength;
1855
- const ptr1 = realloc0(0, 0, 1, len1 * 1);
1856
- const src1 = new Uint8Array(val1.buffer || val1, val1.byteOffset, len1 * 1);
1857
- (new Uint8Array(memory0.buffer, ptr1, len1 * 1)).set(src1);
1858
- dataView(memory0).setInt32(arg2 + 8, len1, true);
1859
- dataView(memory0).setInt32(arg2 + 4, ptr1, true);
1853
+ var val2 = e;
1854
+ var len2 = val2.byteLength;
1855
+ var ptr2 = realloc0(0, 0, 1, len2 * 1);
1856
+ var src2 = new Uint8Array(val2.buffer || val2, val2.byteOffset, len2 * 1);
1857
+ (new Uint8Array(memory0.buffer, ptr2, len2 * 1)).set(src2);
1858
+ dataView(memory0).setInt32(arg2 + 8, len2, true);
1859
+ dataView(memory0).setInt32(arg2 + 4, ptr2, true);
1860
1860
  break;
1861
1861
  }
1862
1862
  case 'err': {
1863
- const e = variant4.val;
1863
+ const e = variant5.val;
1864
1864
  dataView(memory0).setInt8(arg2 + 0, 1, true);
1865
- const variant3 = e;
1866
- switch (variant3.tag) {
1865
+ var variant4 = e;
1866
+ switch (variant4.tag) {
1867
1867
  case 'last-operation-failed': {
1868
- const e = variant3.val;
1868
+ const e = variant4.val;
1869
1869
  dataView(memory0).setInt8(arg2 + 4, 0, true);
1870
1870
  if (!(e instanceof Error$1)) {
1871
- throw new Error('Not a valid "Error" resource.');
1871
+ throw new Error('Resource error: Not a valid "Error" resource.');
1872
1872
  }
1873
- const handle2 = handleCnt1++;
1874
- handleTable1.set(handle2, { rep: e, own: true });
1875
- dataView(memory0).setInt32(arg2 + 8, handle2, true);
1873
+ var handle3 = handleCnt0++;
1874
+ handleTable0.set(handle3, { rep: e, own: true });
1875
+ dataView(memory0).setInt32(arg2 + 8, handle3, true);
1876
1876
  break;
1877
1877
  }
1878
1878
  case 'closed': {
@@ -1880,7 +1880,7 @@ function trampoline21(arg0, arg1, arg2) {
1880
1880
  break;
1881
1881
  }
1882
1882
  default: {
1883
- throw new TypeError('invalid variant specified for StreamError');
1883
+ throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant4.tag)}\` (received \`${variant4}\`) specified for \`StreamError\``);
1884
1884
  }
1885
1885
  }
1886
1886
  break;
@@ -1892,41 +1892,42 @@ function trampoline21(arg0, arg1, arg2) {
1892
1892
  }
1893
1893
 
1894
1894
  function trampoline22(arg0, arg1, arg2) {
1895
- const rsc0 = handleTable0.get(arg0).rep;
1895
+ var handle1 = arg0;
1896
+ var rsc0 = handleTable1.get(handle1).rep;
1896
1897
  let ret;
1897
1898
  try {
1898
1899
  ret = { tag: 'ok', val: InputStream.prototype.blockingRead.call(rsc0, BigInt.asUintN(64, arg1)) };
1899
1900
  } catch (e) {
1900
1901
  ret = { tag: 'err', val: getErrorPayload(e) };
1901
1902
  }
1902
- const variant4 = ret;
1903
- switch (variant4.tag) {
1903
+ var variant5 = ret;
1904
+ switch (variant5.tag) {
1904
1905
  case 'ok': {
1905
- const e = variant4.val;
1906
+ const e = variant5.val;
1906
1907
  dataView(memory0).setInt8(arg2 + 0, 0, true);
1907
- const val1 = e;
1908
- const len1 = val1.byteLength;
1909
- const ptr1 = realloc0(0, 0, 1, len1 * 1);
1910
- const src1 = new Uint8Array(val1.buffer || val1, val1.byteOffset, len1 * 1);
1911
- (new Uint8Array(memory0.buffer, ptr1, len1 * 1)).set(src1);
1912
- dataView(memory0).setInt32(arg2 + 8, len1, true);
1913
- dataView(memory0).setInt32(arg2 + 4, ptr1, true);
1908
+ var val2 = e;
1909
+ var len2 = val2.byteLength;
1910
+ var ptr2 = realloc0(0, 0, 1, len2 * 1);
1911
+ var src2 = new Uint8Array(val2.buffer || val2, val2.byteOffset, len2 * 1);
1912
+ (new Uint8Array(memory0.buffer, ptr2, len2 * 1)).set(src2);
1913
+ dataView(memory0).setInt32(arg2 + 8, len2, true);
1914
+ dataView(memory0).setInt32(arg2 + 4, ptr2, true);
1914
1915
  break;
1915
1916
  }
1916
1917
  case 'err': {
1917
- const e = variant4.val;
1918
+ const e = variant5.val;
1918
1919
  dataView(memory0).setInt8(arg2 + 0, 1, true);
1919
- const variant3 = e;
1920
- switch (variant3.tag) {
1920
+ var variant4 = e;
1921
+ switch (variant4.tag) {
1921
1922
  case 'last-operation-failed': {
1922
- const e = variant3.val;
1923
+ const e = variant4.val;
1923
1924
  dataView(memory0).setInt8(arg2 + 4, 0, true);
1924
1925
  if (!(e instanceof Error$1)) {
1925
- throw new Error('Not a valid "Error" resource.');
1926
+ throw new Error('Resource error: Not a valid "Error" resource.');
1926
1927
  }
1927
- const handle2 = handleCnt1++;
1928
- handleTable1.set(handle2, { rep: e, own: true });
1929
- dataView(memory0).setInt32(arg2 + 8, handle2, true);
1928
+ var handle3 = handleCnt0++;
1929
+ handleTable0.set(handle3, { rep: e, own: true });
1930
+ dataView(memory0).setInt32(arg2 + 8, handle3, true);
1930
1931
  break;
1931
1932
  }
1932
1933
  case 'closed': {
@@ -1934,7 +1935,7 @@ function trampoline22(arg0, arg1, arg2) {
1934
1935
  break;
1935
1936
  }
1936
1937
  default: {
1937
- throw new TypeError('invalid variant specified for StreamError');
1938
+ throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant4.tag)}\` (received \`${variant4}\`) specified for \`StreamError\``);
1938
1939
  }
1939
1940
  }
1940
1941
  break;
@@ -1946,35 +1947,36 @@ function trampoline22(arg0, arg1, arg2) {
1946
1947
  }
1947
1948
 
1948
1949
  function trampoline23(arg0, arg1) {
1949
- const rsc0 = handleTable2.get(arg0).rep;
1950
+ var handle1 = arg0;
1951
+ var rsc0 = handleTable2.get(handle1).rep;
1950
1952
  let ret;
1951
1953
  try {
1952
1954
  ret = { tag: 'ok', val: OutputStream.prototype.checkWrite.call(rsc0) };
1953
1955
  } catch (e) {
1954
1956
  ret = { tag: 'err', val: getErrorPayload(e) };
1955
1957
  }
1956
- const variant3 = ret;
1957
- switch (variant3.tag) {
1958
+ var variant4 = ret;
1959
+ switch (variant4.tag) {
1958
1960
  case 'ok': {
1959
- const e = variant3.val;
1961
+ const e = variant4.val;
1960
1962
  dataView(memory0).setInt8(arg1 + 0, 0, true);
1961
1963
  dataView(memory0).setBigInt64(arg1 + 8, toUint64(e), true);
1962
1964
  break;
1963
1965
  }
1964
1966
  case 'err': {
1965
- const e = variant3.val;
1967
+ const e = variant4.val;
1966
1968
  dataView(memory0).setInt8(arg1 + 0, 1, true);
1967
- const variant2 = e;
1968
- switch (variant2.tag) {
1969
+ var variant3 = e;
1970
+ switch (variant3.tag) {
1969
1971
  case 'last-operation-failed': {
1970
- const e = variant2.val;
1972
+ const e = variant3.val;
1971
1973
  dataView(memory0).setInt8(arg1 + 8, 0, true);
1972
1974
  if (!(e instanceof Error$1)) {
1973
- throw new Error('Not a valid "Error" resource.');
1975
+ throw new Error('Resource error: Not a valid "Error" resource.');
1974
1976
  }
1975
- const handle1 = handleCnt1++;
1976
- handleTable1.set(handle1, { rep: e, own: true });
1977
- dataView(memory0).setInt32(arg1 + 12, handle1, true);
1977
+ var handle2 = handleCnt0++;
1978
+ handleTable0.set(handle2, { rep: e, own: true });
1979
+ dataView(memory0).setInt32(arg1 + 12, handle2, true);
1978
1980
  break;
1979
1981
  }
1980
1982
  case 'closed': {
@@ -1982,7 +1984,7 @@ function trampoline23(arg0, arg1) {
1982
1984
  break;
1983
1985
  }
1984
1986
  default: {
1985
- throw new TypeError('invalid variant specified for StreamError');
1987
+ throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant3.tag)}\` (received \`${variant3}\`) specified for \`StreamError\``);
1986
1988
  }
1987
1989
  }
1988
1990
  break;
@@ -1994,37 +1996,38 @@ function trampoline23(arg0, arg1) {
1994
1996
  }
1995
1997
 
1996
1998
  function trampoline24(arg0, arg1, arg2, arg3) {
1997
- const rsc0 = handleTable2.get(arg0).rep;
1998
- const ptr1 = arg1;
1999
- const len1 = arg2;
2000
- const result1 = new Uint8Array(memory0.buffer.slice(ptr1, ptr1 + len1 * 1));
1999
+ var handle1 = arg0;
2000
+ var rsc0 = handleTable2.get(handle1).rep;
2001
+ var ptr2 = arg1;
2002
+ var len2 = arg2;
2003
+ var result2 = new Uint8Array(memory0.buffer.slice(ptr2, ptr2 + len2 * 1));
2001
2004
  let ret;
2002
2005
  try {
2003
- ret = { tag: 'ok', val: OutputStream.prototype.write.call(rsc0, result1) };
2006
+ ret = { tag: 'ok', val: OutputStream.prototype.write.call(rsc0, result2) };
2004
2007
  } catch (e) {
2005
2008
  ret = { tag: 'err', val: getErrorPayload(e) };
2006
2009
  }
2007
- const variant4 = ret;
2008
- switch (variant4.tag) {
2010
+ var variant5 = ret;
2011
+ switch (variant5.tag) {
2009
2012
  case 'ok': {
2010
- const e = variant4.val;
2013
+ const e = variant5.val;
2011
2014
  dataView(memory0).setInt8(arg3 + 0, 0, true);
2012
2015
  break;
2013
2016
  }
2014
2017
  case 'err': {
2015
- const e = variant4.val;
2018
+ const e = variant5.val;
2016
2019
  dataView(memory0).setInt8(arg3 + 0, 1, true);
2017
- const variant3 = e;
2018
- switch (variant3.tag) {
2020
+ var variant4 = e;
2021
+ switch (variant4.tag) {
2019
2022
  case 'last-operation-failed': {
2020
- const e = variant3.val;
2023
+ const e = variant4.val;
2021
2024
  dataView(memory0).setInt8(arg3 + 4, 0, true);
2022
2025
  if (!(e instanceof Error$1)) {
2023
- throw new Error('Not a valid "Error" resource.');
2026
+ throw new Error('Resource error: Not a valid "Error" resource.');
2024
2027
  }
2025
- const handle2 = handleCnt1++;
2026
- handleTable1.set(handle2, { rep: e, own: true });
2027
- dataView(memory0).setInt32(arg3 + 8, handle2, true);
2028
+ var handle3 = handleCnt0++;
2029
+ handleTable0.set(handle3, { rep: e, own: true });
2030
+ dataView(memory0).setInt32(arg3 + 8, handle3, true);
2028
2031
  break;
2029
2032
  }
2030
2033
  case 'closed': {
@@ -2032,7 +2035,7 @@ function trampoline24(arg0, arg1, arg2, arg3) {
2032
2035
  break;
2033
2036
  }
2034
2037
  default: {
2035
- throw new TypeError('invalid variant specified for StreamError');
2038
+ throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant4.tag)}\` (received \`${variant4}\`) specified for \`StreamError\``);
2036
2039
  }
2037
2040
  }
2038
2041
  break;
@@ -2044,37 +2047,38 @@ function trampoline24(arg0, arg1, arg2, arg3) {
2044
2047
  }
2045
2048
 
2046
2049
  function trampoline25(arg0, arg1, arg2, arg3) {
2047
- const rsc0 = handleTable2.get(arg0).rep;
2048
- const ptr1 = arg1;
2049
- const len1 = arg2;
2050
- const result1 = new Uint8Array(memory0.buffer.slice(ptr1, ptr1 + len1 * 1));
2050
+ var handle1 = arg0;
2051
+ var rsc0 = handleTable2.get(handle1).rep;
2052
+ var ptr2 = arg1;
2053
+ var len2 = arg2;
2054
+ var result2 = new Uint8Array(memory0.buffer.slice(ptr2, ptr2 + len2 * 1));
2051
2055
  let ret;
2052
2056
  try {
2053
- ret = { tag: 'ok', val: OutputStream.prototype.blockingWriteAndFlush.call(rsc0, result1) };
2057
+ ret = { tag: 'ok', val: OutputStream.prototype.blockingWriteAndFlush.call(rsc0, result2) };
2054
2058
  } catch (e) {
2055
2059
  ret = { tag: 'err', val: getErrorPayload(e) };
2056
2060
  }
2057
- const variant4 = ret;
2058
- switch (variant4.tag) {
2061
+ var variant5 = ret;
2062
+ switch (variant5.tag) {
2059
2063
  case 'ok': {
2060
- const e = variant4.val;
2064
+ const e = variant5.val;
2061
2065
  dataView(memory0).setInt8(arg3 + 0, 0, true);
2062
2066
  break;
2063
2067
  }
2064
2068
  case 'err': {
2065
- const e = variant4.val;
2069
+ const e = variant5.val;
2066
2070
  dataView(memory0).setInt8(arg3 + 0, 1, true);
2067
- const variant3 = e;
2068
- switch (variant3.tag) {
2071
+ var variant4 = e;
2072
+ switch (variant4.tag) {
2069
2073
  case 'last-operation-failed': {
2070
- const e = variant3.val;
2074
+ const e = variant4.val;
2071
2075
  dataView(memory0).setInt8(arg3 + 4, 0, true);
2072
2076
  if (!(e instanceof Error$1)) {
2073
- throw new Error('Not a valid "Error" resource.');
2077
+ throw new Error('Resource error: Not a valid "Error" resource.');
2074
2078
  }
2075
- const handle2 = handleCnt1++;
2076
- handleTable1.set(handle2, { rep: e, own: true });
2077
- dataView(memory0).setInt32(arg3 + 8, handle2, true);
2079
+ var handle3 = handleCnt0++;
2080
+ handleTable0.set(handle3, { rep: e, own: true });
2081
+ dataView(memory0).setInt32(arg3 + 8, handle3, true);
2078
2082
  break;
2079
2083
  }
2080
2084
  case 'closed': {
@@ -2082,7 +2086,7 @@ function trampoline25(arg0, arg1, arg2, arg3) {
2082
2086
  break;
2083
2087
  }
2084
2088
  default: {
2085
- throw new TypeError('invalid variant specified for StreamError');
2089
+ throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant4.tag)}\` (received \`${variant4}\`) specified for \`StreamError\``);
2086
2090
  }
2087
2091
  }
2088
2092
  break;
@@ -2094,34 +2098,35 @@ function trampoline25(arg0, arg1, arg2, arg3) {
2094
2098
  }
2095
2099
 
2096
2100
  function trampoline26(arg0, arg1) {
2097
- const rsc0 = handleTable2.get(arg0).rep;
2101
+ var handle1 = arg0;
2102
+ var rsc0 = handleTable2.get(handle1).rep;
2098
2103
  let ret;
2099
2104
  try {
2100
2105
  ret = { tag: 'ok', val: OutputStream.prototype.blockingFlush.call(rsc0) };
2101
2106
  } catch (e) {
2102
2107
  ret = { tag: 'err', val: getErrorPayload(e) };
2103
2108
  }
2104
- const variant3 = ret;
2105
- switch (variant3.tag) {
2109
+ var variant4 = ret;
2110
+ switch (variant4.tag) {
2106
2111
  case 'ok': {
2107
- const e = variant3.val;
2112
+ const e = variant4.val;
2108
2113
  dataView(memory0).setInt8(arg1 + 0, 0, true);
2109
2114
  break;
2110
2115
  }
2111
2116
  case 'err': {
2112
- const e = variant3.val;
2117
+ const e = variant4.val;
2113
2118
  dataView(memory0).setInt8(arg1 + 0, 1, true);
2114
- const variant2 = e;
2115
- switch (variant2.tag) {
2119
+ var variant3 = e;
2120
+ switch (variant3.tag) {
2116
2121
  case 'last-operation-failed': {
2117
- const e = variant2.val;
2122
+ const e = variant3.val;
2118
2123
  dataView(memory0).setInt8(arg1 + 4, 0, true);
2119
2124
  if (!(e instanceof Error$1)) {
2120
- throw new Error('Not a valid "Error" resource.');
2125
+ throw new Error('Resource error: Not a valid "Error" resource.');
2121
2126
  }
2122
- const handle1 = handleCnt1++;
2123
- handleTable1.set(handle1, { rep: e, own: true });
2124
- dataView(memory0).setInt32(arg1 + 8, handle1, true);
2127
+ var handle2 = handleCnt0++;
2128
+ handleTable0.set(handle2, { rep: e, own: true });
2129
+ dataView(memory0).setInt32(arg1 + 8, handle2, true);
2125
2130
  break;
2126
2131
  }
2127
2132
  case 'closed': {
@@ -2129,7 +2134,7 @@ function trampoline26(arg0, arg1) {
2129
2134
  break;
2130
2135
  }
2131
2136
  default: {
2132
- throw new TypeError('invalid variant specified for StreamError');
2137
+ throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant3.tag)}\` (received \`${variant3}\`) specified for \`StreamError\``);
2133
2138
  }
2134
2139
  }
2135
2140
  break;
@@ -2142,10 +2147,10 @@ function trampoline26(arg0, arg1) {
2142
2147
 
2143
2148
  function trampoline27(arg0, arg1) {
2144
2149
  const ret = getRandomBytes(BigInt.asUintN(64, arg0));
2145
- const val0 = ret;
2146
- const len0 = val0.byteLength;
2147
- const ptr0 = realloc0(0, 0, 1, len0 * 1);
2148
- const src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, len0 * 1);
2150
+ var val0 = ret;
2151
+ var len0 = val0.byteLength;
2152
+ var ptr0 = realloc0(0, 0, 1, len0 * 1);
2153
+ var src0 = new Uint8Array(val0.buffer || val0, val0.byteOffset, len0 * 1);
2149
2154
  (new Uint8Array(memory0.buffer, ptr0, len0 * 1)).set(src0);
2150
2155
  dataView(memory0).setInt32(arg1 + 4, len0, true);
2151
2156
  dataView(memory0).setInt32(arg1 + 0, ptr0, true);
@@ -2153,18 +2158,18 @@ function trampoline27(arg0, arg1) {
2153
2158
 
2154
2159
  function trampoline28(arg0) {
2155
2160
  const ret = getEnvironment();
2156
- const vec3 = ret;
2157
- const len3 = vec3.length;
2158
- const result3 = realloc0(0, 0, 4, len3 * 16);
2161
+ var vec3 = ret;
2162
+ var len3 = vec3.length;
2163
+ var result3 = realloc0(0, 0, 4, len3 * 16);
2159
2164
  for (let i = 0; i < vec3.length; i++) {
2160
2165
  const e = vec3[i];
2161
- const base = result3 + i * 16;const [tuple0_0, tuple0_1] = e;
2162
- const ptr1 = utf8Encode(tuple0_0, realloc0, memory0);
2163
- const len1 = utf8EncodedLen;
2166
+ const base = result3 + i * 16;var [tuple0_0, tuple0_1] = e;
2167
+ var ptr1 = utf8Encode(tuple0_0, realloc0, memory0);
2168
+ var len1 = utf8EncodedLen;
2164
2169
  dataView(memory0).setInt32(base + 4, len1, true);
2165
2170
  dataView(memory0).setInt32(base + 0, ptr1, true);
2166
- const ptr2 = utf8Encode(tuple0_1, realloc0, memory0);
2167
- const len2 = utf8EncodedLen;
2171
+ var ptr2 = utf8Encode(tuple0_1, realloc0, memory0);
2172
+ var len2 = utf8EncodedLen;
2168
2173
  dataView(memory0).setInt32(base + 12, len2, true);
2169
2174
  dataView(memory0).setInt32(base + 8, ptr2, true);
2170
2175
  }
@@ -2174,16 +2179,16 @@ function trampoline28(arg0) {
2174
2179
 
2175
2180
  function trampoline29(arg0) {
2176
2181
  const ret = getTerminalStdin();
2177
- const variant1 = ret;
2182
+ var variant1 = ret;
2178
2183
  if (variant1 === null || variant1=== undefined) {
2179
2184
  dataView(memory0).setInt8(arg0 + 0, 0, true);
2180
2185
  } else {
2181
2186
  const e = variant1;
2182
2187
  dataView(memory0).setInt8(arg0 + 0, 1, true);
2183
2188
  if (!(e instanceof TerminalInput)) {
2184
- throw new Error('Not a valid "TerminalInput" resource.');
2189
+ throw new Error('Resource error: Not a valid "TerminalInput" resource.');
2185
2190
  }
2186
- const handle0 = handleCnt6++;
2191
+ var handle0 = handleCnt6++;
2187
2192
  handleTable6.set(handle0, { rep: e, own: true });
2188
2193
  dataView(memory0).setInt32(arg0 + 4, handle0, true);
2189
2194
  }
@@ -2191,16 +2196,16 @@ function trampoline29(arg0) {
2191
2196
 
2192
2197
  function trampoline30(arg0) {
2193
2198
  const ret = getTerminalStdout();
2194
- const variant1 = ret;
2199
+ var variant1 = ret;
2195
2200
  if (variant1 === null || variant1=== undefined) {
2196
2201
  dataView(memory0).setInt8(arg0 + 0, 0, true);
2197
2202
  } else {
2198
2203
  const e = variant1;
2199
2204
  dataView(memory0).setInt8(arg0 + 0, 1, true);
2200
2205
  if (!(e instanceof TerminalOutput)) {
2201
- throw new Error('Not a valid "TerminalOutput" resource.');
2206
+ throw new Error('Resource error: Not a valid "TerminalOutput" resource.');
2202
2207
  }
2203
- const handle0 = handleCnt7++;
2208
+ var handle0 = handleCnt7++;
2204
2209
  handleTable7.set(handle0, { rep: e, own: true });
2205
2210
  dataView(memory0).setInt32(arg0 + 4, handle0, true);
2206
2211
  }
@@ -2208,16 +2213,16 @@ function trampoline30(arg0) {
2208
2213
 
2209
2214
  function trampoline31(arg0) {
2210
2215
  const ret = getTerminalStderr();
2211
- const variant1 = ret;
2216
+ var variant1 = ret;
2212
2217
  if (variant1 === null || variant1=== undefined) {
2213
2218
  dataView(memory0).setInt8(arg0 + 0, 0, true);
2214
2219
  } else {
2215
2220
  const e = variant1;
2216
2221
  dataView(memory0).setInt8(arg0 + 0, 1, true);
2217
2222
  if (!(e instanceof TerminalOutput)) {
2218
- throw new Error('Not a valid "TerminalOutput" resource.');
2223
+ throw new Error('Resource error: Not a valid "TerminalOutput" resource.');
2219
2224
  }
2220
- const handle0 = handleCnt7++;
2225
+ var handle0 = handleCnt7++;
2221
2226
  handleTable7.set(handle0, { rep: e, own: true });
2222
2227
  dataView(memory0).setInt32(arg0 + 4, handle0, true);
2223
2228
  }
@@ -2226,95 +2231,103 @@ let exports3;
2226
2231
  let realloc1;
2227
2232
  let postReturn0;
2228
2233
  let postReturn1;
2229
- const handleTable4= new Map();
2230
- let handleCnt4 = 0;
2231
2234
  function trampoline0(handle) {
2232
2235
  const handleEntry = handleTable4.get(handle);
2233
2236
  if (!handleEntry) {
2234
2237
  throw new Error(`Resource error: Invalid handle ${handle}`);
2235
2238
  }
2236
2239
  handleTable4.delete(handle);
2240
+ if (handleEntry.own && handleEntry.rep[symbolDispose]) {
2241
+ handleEntry.rep[symbolDispose]();
2242
+ }
2237
2243
  }
2238
- const handleTable1= new Map();
2239
- let handleCnt1 = 0;
2240
2244
  function trampoline1(handle) {
2241
- const handleEntry = handleTable1.get(handle);
2245
+ const handleEntry = handleTable0.get(handle);
2242
2246
  if (!handleEntry) {
2243
2247
  throw new Error(`Resource error: Invalid handle ${handle}`);
2244
2248
  }
2245
- handleTable1.delete(handle);
2249
+ handleTable0.delete(handle);
2250
+ if (handleEntry.own && handleEntry.rep[symbolDispose]) {
2251
+ handleEntry.rep[symbolDispose]();
2252
+ }
2246
2253
  }
2247
- const handleTable0= new Map();
2248
- let handleCnt0 = 0;
2249
2254
  function trampoline2(handle) {
2250
- const handleEntry = handleTable0.get(handle);
2255
+ const handleEntry = handleTable1.get(handle);
2251
2256
  if (!handleEntry) {
2252
2257
  throw new Error(`Resource error: Invalid handle ${handle}`);
2253
2258
  }
2254
- handleTable0.delete(handle);
2259
+ handleTable1.delete(handle);
2260
+ if (handleEntry.own && handleEntry.rep[symbolDispose]) {
2261
+ handleEntry.rep[symbolDispose]();
2262
+ }
2255
2263
  }
2256
- const handleTable2= new Map();
2257
- let handleCnt2 = 0;
2258
2264
  function trampoline3(handle) {
2259
2265
  const handleEntry = handleTable2.get(handle);
2260
2266
  if (!handleEntry) {
2261
2267
  throw new Error(`Resource error: Invalid handle ${handle}`);
2262
2268
  }
2263
2269
  handleTable2.delete(handle);
2270
+ if (handleEntry.own && handleEntry.rep[symbolDispose]) {
2271
+ handleEntry.rep[symbolDispose]();
2272
+ }
2264
2273
  }
2265
- const handleTable3= new Map();
2266
- let handleCnt3 = 0;
2267
2274
  function trampoline4(handle) {
2268
2275
  const handleEntry = handleTable3.get(handle);
2269
2276
  if (!handleEntry) {
2270
2277
  throw new Error(`Resource error: Invalid handle ${handle}`);
2271
2278
  }
2272
2279
  handleTable3.delete(handle);
2280
+ if (handleEntry.own && handleEntry.rep[symbolDispose]) {
2281
+ handleEntry.rep[symbolDispose]();
2282
+ }
2273
2283
  }
2274
- const handleTable5= new Map();
2275
- let handleCnt5 = 0;
2276
2284
  function trampoline5(handle) {
2277
2285
  const handleEntry = handleTable5.get(handle);
2278
2286
  if (!handleEntry) {
2279
2287
  throw new Error(`Resource error: Invalid handle ${handle}`);
2280
2288
  }
2281
2289
  handleTable5.delete(handle);
2290
+ if (handleEntry.own && handleEntry.rep[symbolDispose]) {
2291
+ handleEntry.rep[symbolDispose]();
2292
+ }
2282
2293
  }
2283
- const handleTable6= new Map();
2284
- let handleCnt6 = 0;
2285
2294
  function trampoline6(handle) {
2286
- const handleEntry = handleTable6.get(handle);
2295
+ const handleEntry = handleTable7.get(handle);
2287
2296
  if (!handleEntry) {
2288
2297
  throw new Error(`Resource error: Invalid handle ${handle}`);
2289
2298
  }
2290
- handleTable6.delete(handle);
2299
+ handleTable7.delete(handle);
2300
+ if (handleEntry.own && handleEntry.rep[symbolDispose]) {
2301
+ handleEntry.rep[symbolDispose]();
2302
+ }
2291
2303
  }
2292
- const handleTable7= new Map();
2293
- let handleCnt7 = 0;
2294
2304
  function trampoline7(handle) {
2295
- const handleEntry = handleTable7.get(handle);
2305
+ const handleEntry = handleTable6.get(handle);
2296
2306
  if (!handleEntry) {
2297
2307
  throw new Error(`Resource error: Invalid handle ${handle}`);
2298
2308
  }
2299
- handleTable7.delete(handle);
2309
+ handleTable6.delete(handle);
2310
+ if (handleEntry.own && handleEntry.rep[symbolDispose]) {
2311
+ handleEntry.rep[symbolDispose]();
2312
+ }
2300
2313
  }
2301
2314
 
2302
2315
  function generate(arg0, arg1) {
2303
2316
  if (!_initialized) throwUninitialized();
2304
- const ptr0 = realloc1(0, 0, 4, 52);
2305
- const val1 = arg0;
2306
- const len1 = val1.byteLength;
2307
- const ptr1 = realloc1(0, 0, 1, len1 * 1);
2308
- const src1 = new Uint8Array(val1.buffer || val1, val1.byteOffset, len1 * 1);
2317
+ var ptr0 = realloc1(0, 0, 4, 52);
2318
+ var val1 = arg0;
2319
+ var len1 = val1.byteLength;
2320
+ var ptr1 = realloc1(0, 0, 1, len1 * 1);
2321
+ var src1 = new Uint8Array(val1.buffer || val1, val1.byteOffset, len1 * 1);
2309
2322
  (new Uint8Array(memory0.buffer, ptr1, len1 * 1)).set(src1);
2310
2323
  dataView(memory0).setInt32(ptr0 + 4, len1, true);
2311
2324
  dataView(memory0).setInt32(ptr0 + 0, ptr1, true);
2312
- const {name: v2_0, noTypescript: v2_1, instantiation: v2_2, map: v2_3, compat: v2_4, noNodejsCompat: v2_5, base64Cutoff: v2_6, tlaCompat: v2_7, validLiftingOptimization: v2_8, tracing: v2_9 } = arg1;
2313
- const ptr3 = utf8Encode(v2_0, realloc1, memory0);
2314
- const len3 = utf8EncodedLen;
2325
+ var {name: v2_0, noTypescript: v2_1, instantiation: v2_2, map: v2_3, compat: v2_4, noNodejsCompat: v2_5, base64Cutoff: v2_6, tlaCompat: v2_7, validLiftingOptimization: v2_8, tracing: v2_9, noNamespacedExports: v2_10 } = arg1;
2326
+ var ptr3 = utf8Encode(v2_0, realloc1, memory0);
2327
+ var len3 = utf8EncodedLen;
2315
2328
  dataView(memory0).setInt32(ptr0 + 12, len3, true);
2316
2329
  dataView(memory0).setInt32(ptr0 + 8, ptr3, true);
2317
- const variant4 = v2_1;
2330
+ var variant4 = v2_1;
2318
2331
  if (variant4 === null || variant4=== undefined) {
2319
2332
  dataView(memory0).setInt8(ptr0 + 16, 0, true);
2320
2333
  } else {
@@ -2322,154 +2335,175 @@ function generate(arg0, arg1) {
2322
2335
  dataView(memory0).setInt8(ptr0 + 16, 1, true);
2323
2336
  dataView(memory0).setInt8(ptr0 + 17, e ? 1 : 0, true);
2324
2337
  }
2325
- const variant5 = v2_2;
2326
- if (variant5 === null || variant5=== undefined) {
2338
+ var variant6 = v2_2;
2339
+ if (variant6 === null || variant6=== undefined) {
2327
2340
  dataView(memory0).setInt8(ptr0 + 18, 0, true);
2328
2341
  } else {
2329
- const e = variant5;
2342
+ const e = variant6;
2330
2343
  dataView(memory0).setInt8(ptr0 + 18, 1, true);
2331
- dataView(memory0).setInt8(ptr0 + 19, e ? 1 : 0, true);
2344
+ var variant5 = e;
2345
+ switch (variant5.tag) {
2346
+ case 'async': {
2347
+ dataView(memory0).setInt8(ptr0 + 19, 0, true);
2348
+ break;
2349
+ }
2350
+ case 'sync': {
2351
+ dataView(memory0).setInt8(ptr0 + 19, 1, true);
2352
+ break;
2353
+ }
2354
+ default: {
2355
+ throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant5.tag)}\` (received \`${variant5}\`) specified for \`InstantiationMode\``);
2356
+ }
2357
+ }
2332
2358
  }
2333
- const variant10 = v2_3;
2334
- if (variant10 === null || variant10=== undefined) {
2359
+ var variant11 = v2_3;
2360
+ if (variant11 === null || variant11=== undefined) {
2335
2361
  dataView(memory0).setInt8(ptr0 + 20, 0, true);
2336
2362
  } else {
2337
- const e = variant10;
2363
+ const e = variant11;
2338
2364
  dataView(memory0).setInt8(ptr0 + 20, 1, true);
2339
- const vec9 = e;
2340
- const len9 = vec9.length;
2341
- const result9 = realloc1(0, 0, 4, len9 * 16);
2342
- for (let i = 0; i < vec9.length; i++) {
2343
- const e = vec9[i];
2344
- const base = result9 + i * 16;const [tuple6_0, tuple6_1] = e;
2345
- const ptr7 = utf8Encode(tuple6_0, realloc1, memory0);
2346
- const len7 = utf8EncodedLen;
2347
- dataView(memory0).setInt32(base + 4, len7, true);
2348
- dataView(memory0).setInt32(base + 0, ptr7, true);
2349
- const ptr8 = utf8Encode(tuple6_1, realloc1, memory0);
2350
- const len8 = utf8EncodedLen;
2351
- dataView(memory0).setInt32(base + 12, len8, true);
2352
- dataView(memory0).setInt32(base + 8, ptr8, true);
2365
+ var vec10 = e;
2366
+ var len10 = vec10.length;
2367
+ var result10 = realloc1(0, 0, 4, len10 * 16);
2368
+ for (let i = 0; i < vec10.length; i++) {
2369
+ const e = vec10[i];
2370
+ const base = result10 + i * 16;var [tuple7_0, tuple7_1] = e;
2371
+ var ptr8 = utf8Encode(tuple7_0, realloc1, memory0);
2372
+ var len8 = utf8EncodedLen;
2373
+ dataView(memory0).setInt32(base + 4, len8, true);
2374
+ dataView(memory0).setInt32(base + 0, ptr8, true);
2375
+ var ptr9 = utf8Encode(tuple7_1, realloc1, memory0);
2376
+ var len9 = utf8EncodedLen;
2377
+ dataView(memory0).setInt32(base + 12, len9, true);
2378
+ dataView(memory0).setInt32(base + 8, ptr9, true);
2353
2379
  }
2354
- dataView(memory0).setInt32(ptr0 + 28, len9, true);
2355
- dataView(memory0).setInt32(ptr0 + 24, result9, true);
2380
+ dataView(memory0).setInt32(ptr0 + 28, len10, true);
2381
+ dataView(memory0).setInt32(ptr0 + 24, result10, true);
2356
2382
  }
2357
- const variant11 = v2_4;
2358
- if (variant11 === null || variant11=== undefined) {
2383
+ var variant12 = v2_4;
2384
+ if (variant12 === null || variant12=== undefined) {
2359
2385
  dataView(memory0).setInt8(ptr0 + 32, 0, true);
2360
2386
  } else {
2361
- const e = variant11;
2387
+ const e = variant12;
2362
2388
  dataView(memory0).setInt8(ptr0 + 32, 1, true);
2363
2389
  dataView(memory0).setInt8(ptr0 + 33, e ? 1 : 0, true);
2364
2390
  }
2365
- const variant12 = v2_5;
2366
- if (variant12 === null || variant12=== undefined) {
2391
+ var variant13 = v2_5;
2392
+ if (variant13 === null || variant13=== undefined) {
2367
2393
  dataView(memory0).setInt8(ptr0 + 34, 0, true);
2368
2394
  } else {
2369
- const e = variant12;
2395
+ const e = variant13;
2370
2396
  dataView(memory0).setInt8(ptr0 + 34, 1, true);
2371
2397
  dataView(memory0).setInt8(ptr0 + 35, e ? 1 : 0, true);
2372
2398
  }
2373
- const variant13 = v2_6;
2374
- if (variant13 === null || variant13=== undefined) {
2399
+ var variant14 = v2_6;
2400
+ if (variant14 === null || variant14=== undefined) {
2375
2401
  dataView(memory0).setInt8(ptr0 + 36, 0, true);
2376
2402
  } else {
2377
- const e = variant13;
2403
+ const e = variant14;
2378
2404
  dataView(memory0).setInt8(ptr0 + 36, 1, true);
2379
2405
  dataView(memory0).setInt32(ptr0 + 40, toUint32(e), true);
2380
2406
  }
2381
- const variant14 = v2_7;
2382
- if (variant14 === null || variant14=== undefined) {
2407
+ var variant15 = v2_7;
2408
+ if (variant15 === null || variant15=== undefined) {
2383
2409
  dataView(memory0).setInt8(ptr0 + 44, 0, true);
2384
2410
  } else {
2385
- const e = variant14;
2411
+ const e = variant15;
2386
2412
  dataView(memory0).setInt8(ptr0 + 44, 1, true);
2387
2413
  dataView(memory0).setInt8(ptr0 + 45, e ? 1 : 0, true);
2388
2414
  }
2389
- const variant15 = v2_8;
2390
- if (variant15 === null || variant15=== undefined) {
2415
+ var variant16 = v2_8;
2416
+ if (variant16 === null || variant16=== undefined) {
2391
2417
  dataView(memory0).setInt8(ptr0 + 46, 0, true);
2392
2418
  } else {
2393
- const e = variant15;
2419
+ const e = variant16;
2394
2420
  dataView(memory0).setInt8(ptr0 + 46, 1, true);
2395
2421
  dataView(memory0).setInt8(ptr0 + 47, e ? 1 : 0, true);
2396
2422
  }
2397
- const variant16 = v2_9;
2398
- if (variant16 === null || variant16=== undefined) {
2423
+ var variant17 = v2_9;
2424
+ if (variant17 === null || variant17=== undefined) {
2399
2425
  dataView(memory0).setInt8(ptr0 + 48, 0, true);
2400
2426
  } else {
2401
- const e = variant16;
2427
+ const e = variant17;
2402
2428
  dataView(memory0).setInt8(ptr0 + 48, 1, true);
2403
2429
  dataView(memory0).setInt8(ptr0 + 49, e ? 1 : 0, true);
2404
2430
  }
2431
+ var variant18 = v2_10;
2432
+ if (variant18 === null || variant18=== undefined) {
2433
+ dataView(memory0).setInt8(ptr0 + 50, 0, true);
2434
+ } else {
2435
+ const e = variant18;
2436
+ dataView(memory0).setInt8(ptr0 + 50, 1, true);
2437
+ dataView(memory0).setInt8(ptr0 + 51, e ? 1 : 0, true);
2438
+ }
2405
2439
  const ret = exports1.generate(ptr0);
2406
- let variant26;
2440
+ let variant28;
2407
2441
  switch (dataView(memory0).getUint8(ret + 0, true)) {
2408
2442
  case 0: {
2409
- const len19 = dataView(memory0).getInt32(ret + 8, true);
2410
- const base19 = dataView(memory0).getInt32(ret + 4, true);
2411
- const result19 = [];
2412
- for (let i = 0; i < len19; i++) {
2413
- const base = base19 + i * 16;
2414
- const ptr17 = dataView(memory0).getInt32(base + 0, true);
2415
- const len17 = dataView(memory0).getInt32(base + 4, true);
2416
- const result17 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr17, len17));
2417
- const ptr18 = dataView(memory0).getInt32(base + 8, true);
2418
- const len18 = dataView(memory0).getInt32(base + 12, true);
2419
- const result18 = new Uint8Array(memory0.buffer.slice(ptr18, ptr18 + len18 * 1));
2420
- result19.push([result17, result18]);
2421
- }
2422
- const len21 = dataView(memory0).getInt32(ret + 16, true);
2423
- const base21 = dataView(memory0).getInt32(ret + 12, true);
2424
- const result21 = [];
2443
+ var len21 = dataView(memory0).getInt32(ret + 8, true);
2444
+ var base21 = dataView(memory0).getInt32(ret + 4, true);
2445
+ var result21 = [];
2425
2446
  for (let i = 0; i < len21; i++) {
2426
- const base = base21 + i * 8;
2427
- const ptr20 = dataView(memory0).getInt32(base + 0, true);
2428
- const len20 = dataView(memory0).getInt32(base + 4, true);
2429
- const result20 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr20, len20));
2430
- result21.push(result20);
2431
- }
2432
- const len24 = dataView(memory0).getInt32(ret + 24, true);
2433
- const base24 = dataView(memory0).getInt32(ret + 20, true);
2434
- const result24 = [];
2435
- for (let i = 0; i < len24; i++) {
2436
- const base = base24 + i * 12;
2437
- const ptr22 = dataView(memory0).getInt32(base + 0, true);
2438
- const len22 = dataView(memory0).getInt32(base + 4, true);
2439
- const result22 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr22, len22));
2440
- let enum23;
2447
+ const base = base21 + i * 16;
2448
+ var ptr19 = dataView(memory0).getInt32(base + 0, true);
2449
+ var len19 = dataView(memory0).getInt32(base + 4, true);
2450
+ var result19 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr19, len19));
2451
+ var ptr20 = dataView(memory0).getInt32(base + 8, true);
2452
+ var len20 = dataView(memory0).getInt32(base + 12, true);
2453
+ var result20 = new Uint8Array(memory0.buffer.slice(ptr20, ptr20 + len20 * 1));
2454
+ result21.push([result19, result20]);
2455
+ }
2456
+ var len23 = dataView(memory0).getInt32(ret + 16, true);
2457
+ var base23 = dataView(memory0).getInt32(ret + 12, true);
2458
+ var result23 = [];
2459
+ for (let i = 0; i < len23; i++) {
2460
+ const base = base23 + i * 8;
2461
+ var ptr22 = dataView(memory0).getInt32(base + 0, true);
2462
+ var len22 = dataView(memory0).getInt32(base + 4, true);
2463
+ var result22 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr22, len22));
2464
+ result23.push(result22);
2465
+ }
2466
+ var len26 = dataView(memory0).getInt32(ret + 24, true);
2467
+ var base26 = dataView(memory0).getInt32(ret + 20, true);
2468
+ var result26 = [];
2469
+ for (let i = 0; i < len26; i++) {
2470
+ const base = base26 + i * 12;
2471
+ var ptr24 = dataView(memory0).getInt32(base + 0, true);
2472
+ var len24 = dataView(memory0).getInt32(base + 4, true);
2473
+ var result24 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr24, len24));
2474
+ let enum25;
2441
2475
  switch (dataView(memory0).getUint8(base + 8, true)) {
2442
2476
  case 0: {
2443
- enum23 = 'function';
2477
+ enum25 = 'function';
2444
2478
  break;
2445
2479
  }
2446
2480
  case 1: {
2447
- enum23 = 'instance';
2481
+ enum25 = 'instance';
2448
2482
  break;
2449
2483
  }
2450
2484
  default: {
2451
2485
  throw new TypeError('invalid discriminant specified for ExportType');
2452
2486
  }
2453
2487
  }
2454
- result24.push([result22, enum23]);
2488
+ result26.push([result24, enum25]);
2455
2489
  }
2456
- variant26= {
2490
+ variant28= {
2457
2491
  tag: 'ok',
2458
2492
  val: {
2459
- files: result19,
2460
- imports: result21,
2461
- exports: result24,
2493
+ files: result21,
2494
+ imports: result23,
2495
+ exports: result26,
2462
2496
  }
2463
2497
  };
2464
2498
  break;
2465
2499
  }
2466
2500
  case 1: {
2467
- const ptr25 = dataView(memory0).getInt32(ret + 4, true);
2468
- const len25 = dataView(memory0).getInt32(ret + 8, true);
2469
- const result25 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr25, len25));
2470
- variant26= {
2501
+ var ptr27 = dataView(memory0).getInt32(ret + 4, true);
2502
+ var len27 = dataView(memory0).getInt32(ret + 8, true);
2503
+ var result27 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr27, len27));
2504
+ variant28= {
2471
2505
  tag: 'err',
2472
- val: result25
2506
+ val: result27
2473
2507
  };
2474
2508
  break;
2475
2509
  }
@@ -2478,26 +2512,26 @@ function generate(arg0, arg1) {
2478
2512
  }
2479
2513
  }
2480
2514
  postReturn0(ret);
2481
- if (variant26.tag === 'err') {
2482
- throw new ComponentError(variant26.val);
2515
+ if (variant28.tag === 'err') {
2516
+ throw new ComponentError(variant28.val);
2483
2517
  }
2484
- return variant26.val;
2518
+ return variant28.val;
2485
2519
  }
2486
2520
 
2487
2521
  function generateTypes(arg0, arg1) {
2488
2522
  if (!_initialized) throwUninitialized();
2489
- const ptr0 = utf8Encode(arg0, realloc1, memory0);
2490
- const len0 = utf8EncodedLen;
2491
- const {wit: v1_0, world: v1_1, tlaCompat: v1_2, instantiation: v1_3, map: v1_4 } = arg1;
2492
- const variant5 = v1_0;
2523
+ var ptr0 = utf8Encode(arg0, realloc1, memory0);
2524
+ var len0 = utf8EncodedLen;
2525
+ var {wit: v1_0, world: v1_1, tlaCompat: v1_2, instantiation: v1_3, map: v1_4 } = arg1;
2526
+ var variant5 = v1_0;
2493
2527
  let variant5_0;
2494
2528
  let variant5_1;
2495
2529
  let variant5_2;
2496
2530
  switch (variant5.tag) {
2497
2531
  case 'source': {
2498
2532
  const e = variant5.val;
2499
- const ptr2 = utf8Encode(e, realloc1, memory0);
2500
- const len2 = utf8EncodedLen;
2533
+ var ptr2 = utf8Encode(e, realloc1, memory0);
2534
+ var len2 = utf8EncodedLen;
2501
2535
  variant5_0 = 0;
2502
2536
  variant5_1 = ptr2;
2503
2537
  variant5_2 = len2;
@@ -2505,10 +2539,10 @@ function generateTypes(arg0, arg1) {
2505
2539
  }
2506
2540
  case 'binary': {
2507
2541
  const e = variant5.val;
2508
- const val3 = e;
2509
- const len3 = val3.byteLength;
2510
- const ptr3 = realloc1(0, 0, 1, len3 * 1);
2511
- const src3 = new Uint8Array(val3.buffer || val3, val3.byteOffset, len3 * 1);
2542
+ var val3 = e;
2543
+ var len3 = val3.byteLength;
2544
+ var ptr3 = realloc1(0, 0, 1, len3 * 1);
2545
+ var src3 = new Uint8Array(val3.buffer || val3, val3.byteOffset, len3 * 1);
2512
2546
  (new Uint8Array(memory0.buffer, ptr3, len3 * 1)).set(src3);
2513
2547
  variant5_0 = 1;
2514
2548
  variant5_1 = ptr3;
@@ -2517,18 +2551,18 @@ function generateTypes(arg0, arg1) {
2517
2551
  }
2518
2552
  case 'path': {
2519
2553
  const e = variant5.val;
2520
- const ptr4 = utf8Encode(e, realloc1, memory0);
2521
- const len4 = utf8EncodedLen;
2554
+ var ptr4 = utf8Encode(e, realloc1, memory0);
2555
+ var len4 = utf8EncodedLen;
2522
2556
  variant5_0 = 2;
2523
2557
  variant5_1 = ptr4;
2524
2558
  variant5_2 = len4;
2525
2559
  break;
2526
2560
  }
2527
2561
  default: {
2528
- throw new TypeError('invalid variant specified for Wit');
2562
+ throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant5.tag)}\` (received \`${variant5}\`) specified for \`Wit\``);
2529
2563
  }
2530
2564
  }
2531
- const variant7 = v1_1;
2565
+ var variant7 = v1_1;
2532
2566
  let variant7_0;
2533
2567
  let variant7_1;
2534
2568
  let variant7_2;
@@ -2538,13 +2572,13 @@ function generateTypes(arg0, arg1) {
2538
2572
  variant7_2 = 0;
2539
2573
  } else {
2540
2574
  const e = variant7;
2541
- const ptr6 = utf8Encode(e, realloc1, memory0);
2542
- const len6 = utf8EncodedLen;
2575
+ var ptr6 = utf8Encode(e, realloc1, memory0);
2576
+ var len6 = utf8EncodedLen;
2543
2577
  variant7_0 = 1;
2544
2578
  variant7_1 = ptr6;
2545
2579
  variant7_2 = len6;
2546
2580
  }
2547
- const variant8 = v1_2;
2581
+ var variant8 = v1_2;
2548
2582
  let variant8_0;
2549
2583
  let variant8_1;
2550
2584
  if (variant8 === null || variant8=== undefined) {
@@ -2555,76 +2589,91 @@ function generateTypes(arg0, arg1) {
2555
2589
  variant8_0 = 1;
2556
2590
  variant8_1 = e ? 1 : 0;
2557
2591
  }
2558
- const variant9 = v1_3;
2559
- let variant9_0;
2560
- let variant9_1;
2561
- if (variant9 === null || variant9=== undefined) {
2562
- variant9_0 = 0;
2563
- variant9_1 = 0;
2592
+ var variant10 = v1_3;
2593
+ let variant10_0;
2594
+ let variant10_1;
2595
+ if (variant10 === null || variant10=== undefined) {
2596
+ variant10_0 = 0;
2597
+ variant10_1 = 0;
2564
2598
  } else {
2565
- const e = variant9;
2566
- variant9_0 = 1;
2567
- variant9_1 = e ? 1 : 0;
2568
- }
2569
- const variant14 = v1_4;
2570
- let variant14_0;
2571
- let variant14_1;
2572
- let variant14_2;
2573
- if (variant14 === null || variant14=== undefined) {
2574
- variant14_0 = 0;
2575
- variant14_1 = 0;
2576
- variant14_2 = 0;
2599
+ const e = variant10;
2600
+ var variant9 = e;
2601
+ let variant9_0;
2602
+ switch (variant9.tag) {
2603
+ case 'async': {
2604
+ variant9_0 = 0;
2605
+ break;
2606
+ }
2607
+ case 'sync': {
2608
+ variant9_0 = 1;
2609
+ break;
2610
+ }
2611
+ default: {
2612
+ throw new TypeError(`invalid variant tag value \`${JSON.stringify(variant9.tag)}\` (received \`${variant9}\`) specified for \`InstantiationMode\``);
2613
+ }
2614
+ }
2615
+ variant10_0 = 1;
2616
+ variant10_1 = variant9_0;
2617
+ }
2618
+ var variant15 = v1_4;
2619
+ let variant15_0;
2620
+ let variant15_1;
2621
+ let variant15_2;
2622
+ if (variant15 === null || variant15=== undefined) {
2623
+ variant15_0 = 0;
2624
+ variant15_1 = 0;
2625
+ variant15_2 = 0;
2577
2626
  } else {
2578
- const e = variant14;
2579
- const vec13 = e;
2580
- const len13 = vec13.length;
2581
- const result13 = realloc1(0, 0, 4, len13 * 16);
2582
- for (let i = 0; i < vec13.length; i++) {
2583
- const e = vec13[i];
2584
- const base = result13 + i * 16;const [tuple10_0, tuple10_1] = e;
2585
- const ptr11 = utf8Encode(tuple10_0, realloc1, memory0);
2586
- const len11 = utf8EncodedLen;
2587
- dataView(memory0).setInt32(base + 4, len11, true);
2588
- dataView(memory0).setInt32(base + 0, ptr11, true);
2589
- const ptr12 = utf8Encode(tuple10_1, realloc1, memory0);
2590
- const len12 = utf8EncodedLen;
2591
- dataView(memory0).setInt32(base + 12, len12, true);
2592
- dataView(memory0).setInt32(base + 8, ptr12, true);
2627
+ const e = variant15;
2628
+ var vec14 = e;
2629
+ var len14 = vec14.length;
2630
+ var result14 = realloc1(0, 0, 4, len14 * 16);
2631
+ for (let i = 0; i < vec14.length; i++) {
2632
+ const e = vec14[i];
2633
+ const base = result14 + i * 16;var [tuple11_0, tuple11_1] = e;
2634
+ var ptr12 = utf8Encode(tuple11_0, realloc1, memory0);
2635
+ var len12 = utf8EncodedLen;
2636
+ dataView(memory0).setInt32(base + 4, len12, true);
2637
+ dataView(memory0).setInt32(base + 0, ptr12, true);
2638
+ var ptr13 = utf8Encode(tuple11_1, realloc1, memory0);
2639
+ var len13 = utf8EncodedLen;
2640
+ dataView(memory0).setInt32(base + 12, len13, true);
2641
+ dataView(memory0).setInt32(base + 8, ptr13, true);
2593
2642
  }
2594
- variant14_0 = 1;
2595
- variant14_1 = result13;
2596
- variant14_2 = len13;
2643
+ variant15_0 = 1;
2644
+ variant15_1 = result14;
2645
+ variant15_2 = len14;
2597
2646
  }
2598
- const ret = exports1['generate-types'](ptr0, len0, variant5_0, variant5_1, variant5_2, variant7_0, variant7_1, variant7_2, variant8_0, variant8_1, variant9_0, variant9_1, variant14_0, variant14_1, variant14_2);
2599
- let variant19;
2647
+ const ret = exports1['generate-types'](ptr0, len0, variant5_0, variant5_1, variant5_2, variant7_0, variant7_1, variant7_2, variant8_0, variant8_1, variant10_0, variant10_1, variant15_0, variant15_1, variant15_2);
2648
+ let variant20;
2600
2649
  switch (dataView(memory0).getUint8(ret + 0, true)) {
2601
2650
  case 0: {
2602
- const len17 = dataView(memory0).getInt32(ret + 8, true);
2603
- const base17 = dataView(memory0).getInt32(ret + 4, true);
2604
- const result17 = [];
2605
- for (let i = 0; i < len17; i++) {
2606
- const base = base17 + i * 16;
2607
- const ptr15 = dataView(memory0).getInt32(base + 0, true);
2608
- const len15 = dataView(memory0).getInt32(base + 4, true);
2609
- const result15 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr15, len15));
2610
- const ptr16 = dataView(memory0).getInt32(base + 8, true);
2611
- const len16 = dataView(memory0).getInt32(base + 12, true);
2612
- const result16 = new Uint8Array(memory0.buffer.slice(ptr16, ptr16 + len16 * 1));
2613
- result17.push([result15, result16]);
2614
- }
2615
- variant19= {
2651
+ var len18 = dataView(memory0).getInt32(ret + 8, true);
2652
+ var base18 = dataView(memory0).getInt32(ret + 4, true);
2653
+ var result18 = [];
2654
+ for (let i = 0; i < len18; i++) {
2655
+ const base = base18 + i * 16;
2656
+ var ptr16 = dataView(memory0).getInt32(base + 0, true);
2657
+ var len16 = dataView(memory0).getInt32(base + 4, true);
2658
+ var result16 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr16, len16));
2659
+ var ptr17 = dataView(memory0).getInt32(base + 8, true);
2660
+ var len17 = dataView(memory0).getInt32(base + 12, true);
2661
+ var result17 = new Uint8Array(memory0.buffer.slice(ptr17, ptr17 + len17 * 1));
2662
+ result18.push([result16, result17]);
2663
+ }
2664
+ variant20= {
2616
2665
  tag: 'ok',
2617
- val: result17
2666
+ val: result18
2618
2667
  };
2619
2668
  break;
2620
2669
  }
2621
2670
  case 1: {
2622
- const ptr18 = dataView(memory0).getInt32(ret + 4, true);
2623
- const len18 = dataView(memory0).getInt32(ret + 8, true);
2624
- const result18 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr18, len18));
2625
- variant19= {
2671
+ var ptr19 = dataView(memory0).getInt32(ret + 4, true);
2672
+ var len19 = dataView(memory0).getInt32(ret + 8, true);
2673
+ var result19 = utf8Decoder.decode(new Uint8Array(memory0.buffer, ptr19, len19));
2674
+ variant20= {
2626
2675
  tag: 'err',
2627
- val: result18
2676
+ val: result19
2628
2677
  };
2629
2678
  break;
2630
2679
  }
@@ -2633,20 +2682,34 @@ function generateTypes(arg0, arg1) {
2633
2682
  }
2634
2683
  }
2635
2684
  postReturn1(ret);
2636
- if (variant19.tag === 'err') {
2637
- throw new ComponentError(variant19.val);
2685
+ if (variant20.tag === 'err') {
2686
+ throw new ComponentError(variant20.val);
2638
2687
  }
2639
- return variant19.val;
2688
+ return variant20.val;
2640
2689
  }
2690
+ const handleTable0= new Map();
2691
+ let handleCnt0 = 0;
2692
+ const handleTable1= new Map();
2693
+ let handleCnt1 = 0;
2694
+ const handleTable2= new Map();
2695
+ let handleCnt2 = 0;
2696
+ const handleTable3= new Map();
2697
+ let handleCnt3 = 0;
2698
+ const handleTable4= new Map();
2699
+ let handleCnt4 = 0;
2700
+ const handleTable5= new Map();
2701
+ let handleCnt5 = 0;
2702
+ const handleTable6= new Map();
2703
+ let handleCnt6 = 0;
2704
+ const handleTable7= new Map();
2705
+ let handleCnt7 = 0;
2641
2706
 
2642
2707
  let _initialized = false;
2643
2708
  export const $init = (async() => {
2644
2709
  const module0 = fetchCompile(new URL('./js-component-bindgen-component.core.wasm', import.meta.url));
2645
2710
  const module1 = fetchCompile(new URL('./js-component-bindgen-component.core2.wasm', import.meta.url));
2646
- const module2 = base64Compile('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');
2647
- const module3 = base64Compile('AGFzbQEAAAABUgxgAX8AYAN/fn8AYAJ/fwBgCH9/f39/f39/AGAEf39/fwBgAn5/AGACf38Bf2AEf39/fwF/YAl/f39/f35+f38Bf2ABfwF/YAN/f38Bf2ABfwACwAEgAAEwAAAAATEAAQABMgABAAEzAAIAATQAAgABNQACAAE2AAMAATcAAgABOAACAAE5AAEAAjEwAAEAAjExAAIAAjEyAAQAAjEzAAQAAjE0AAIAAjE1AAUAAjE2AAAAAjE3AAAAAjE4AAAAAjE5AAAAAjIwAAYAAjIxAAcAAjIyAAcAAjIzAAgAAjI0AAYAAjI1AAYAAjI2AAYAAjI3AAkAAjI4AAYAAjI5AAoAAjMwAAsACCRpbXBvcnRzAXABHx8JJQEAQQALHwABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4ALglwcm9kdWNlcnMBDHByb2Nlc3NlZC1ieQENd2l0LWNvbXBvbmVudAYwLjE2LjAAHARuYW1lABUUd2l0LWNvbXBvbmVudDpmaXh1cHM');
2648
- const instanceFlags0 = new WebAssembly.Global({ value: "i32", mutable: true }, 3);
2649
- Promise.all([module0, module1, module2, module3]).catch(() => {});
2711
+ const module2 = base64Compile('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');
2712
+ const module3 = base64Compile('AGFzbQEAAAABUQxgAX8AYAN/fn8AYAJ/fwBgB39/f39/f38AYAR/f39/AGACfn8AYAJ/fwF/YAR/f39/AX9gCX9/f39/fn5/fwF/YAF/AX9gA39/fwF/YAF/AALAASAAATAAAAABMQABAAEyAAEAATMAAgABNAACAAE1AAIAATYAAwABNwACAAE4AAIAATkAAQACMTAAAQACMTEAAgACMTIABAACMTMABAACMTQAAgACMTUABQACMTYAAAACMTcAAAACMTgAAAACMTkAAAACMjAABgACMjEABwACMjIABwACMjMACAACMjQABgACMjUABgACMjYABgACMjcACQACMjgABgACMjkACgACMzAACwAIJGltcG9ydHMBcAEfHwklAQBBAAsfAAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHgAuCXByb2R1Y2VycwEMcHJvY2Vzc2VkLWJ5AQ13aXQtY29tcG9uZW50BjAuMTkuMAAcBG5hbWUAFRR3aXQtY29tcG9uZW50OmZpeHVwcw');
2650
2713
  ({ exports: exports0 } = await instantiateCore(await module2));
2651
2714
  ({ exports: exports1 } = await instantiateCore(await module0, {
2652
2715
  wasi_snapshot_preview1: {
@@ -2670,40 +2733,40 @@ export const $init = (async() => {
2670
2733
  env: {
2671
2734
  memory: exports1.memory,
2672
2735
  },
2673
- 'wasi:cli/environment@0.2.0-rc-2023-11-05': {
2736
+ 'wasi:cli/environment@0.2.0-rc-2023-11-10': {
2674
2737
  'get-environment': exports0['16'],
2675
2738
  },
2676
- 'wasi:cli/exit@0.2.0-rc-2023-11-05': {
2739
+ 'wasi:cli/exit@0.2.0-rc-2023-11-10': {
2677
2740
  exit: trampoline9,
2678
2741
  },
2679
- 'wasi:cli/stderr@0.2.0-rc-2023-11-05': {
2742
+ 'wasi:cli/stderr@0.2.0-rc-2023-11-10': {
2680
2743
  'get-stderr': trampoline8,
2681
2744
  },
2682
- 'wasi:cli/stdin@0.2.0-rc-2023-11-05': {
2745
+ 'wasi:cli/stdin@0.2.0-rc-2023-11-10': {
2683
2746
  'get-stdin': trampoline10,
2684
2747
  },
2685
- 'wasi:cli/stdout@0.2.0-rc-2023-11-05': {
2748
+ 'wasi:cli/stdout@0.2.0-rc-2023-11-10': {
2686
2749
  'get-stdout': trampoline11,
2687
2750
  },
2688
- 'wasi:cli/terminal-input@0.2.0-rc-2023-11-05': {
2689
- '[resource-drop]terminal-input': trampoline6,
2751
+ 'wasi:cli/terminal-input@0.2.0-rc-2023-11-10': {
2752
+ '[resource-drop]terminal-input': trampoline7,
2690
2753
  },
2691
- 'wasi:cli/terminal-output@0.2.0-rc-2023-11-05': {
2692
- '[resource-drop]terminal-output': trampoline7,
2754
+ 'wasi:cli/terminal-output@0.2.0-rc-2023-11-10': {
2755
+ '[resource-drop]terminal-output': trampoline6,
2693
2756
  },
2694
- 'wasi:cli/terminal-stderr@0.2.0-rc-2023-11-05': {
2757
+ 'wasi:cli/terminal-stderr@0.2.0-rc-2023-11-10': {
2695
2758
  'get-terminal-stderr': exports0['19'],
2696
2759
  },
2697
- 'wasi:cli/terminal-stdin@0.2.0-rc-2023-11-05': {
2760
+ 'wasi:cli/terminal-stdin@0.2.0-rc-2023-11-10': {
2698
2761
  'get-terminal-stdin': exports0['17'],
2699
2762
  },
2700
- 'wasi:cli/terminal-stdout@0.2.0-rc-2023-11-05': {
2763
+ 'wasi:cli/terminal-stdout@0.2.0-rc-2023-11-10': {
2701
2764
  'get-terminal-stdout': exports0['18'],
2702
2765
  },
2703
- 'wasi:filesystem/preopens@0.2.0-rc-2023-11-05': {
2766
+ 'wasi:filesystem/preopens@0.2.0-rc-2023-11-10': {
2704
2767
  'get-directories': exports0['0'],
2705
2768
  },
2706
- 'wasi:filesystem/types@0.2.0-rc-2023-11-05': {
2769
+ 'wasi:filesystem/types@0.2.0-rc-2023-11-10': {
2707
2770
  '[method]descriptor.append-via-stream': exports0['3'],
2708
2771
  '[method]descriptor.get-type': exports0['4'],
2709
2772
  '[method]descriptor.metadata-hash': exports0['7'],
@@ -2715,21 +2778,23 @@ export const $init = (async() => {
2715
2778
  '[resource-drop]directory-entry-stream': trampoline0,
2716
2779
  'filesystem-error-code': exports0['8'],
2717
2780
  },
2718
- 'wasi:io/streams@0.2.0-rc-2023-11-05': {
2781
+ 'wasi:io/error@0.2.0-rc-2023-11-10': {
2782
+ '[resource-drop]error': trampoline1,
2783
+ },
2784
+ 'wasi:io/streams@0.2.0-rc-2023-11-10': {
2719
2785
  '[method]input-stream.blocking-read': exports0['10'],
2720
2786
  '[method]input-stream.read': exports0['9'],
2721
2787
  '[method]output-stream.blocking-flush': exports0['14'],
2722
2788
  '[method]output-stream.blocking-write-and-flush': exports0['13'],
2723
2789
  '[method]output-stream.check-write': exports0['11'],
2724
2790
  '[method]output-stream.write': exports0['12'],
2725
- '[resource-drop]error': trampoline1,
2726
2791
  '[resource-drop]input-stream': trampoline2,
2727
2792
  '[resource-drop]output-stream': trampoline3,
2728
2793
  },
2729
- 'wasi:random/random@0.2.0-rc-2023-11-05': {
2794
+ 'wasi:random/random@0.2.0-rc-2023-11-10': {
2730
2795
  'get-random-bytes': exports0['15'],
2731
2796
  },
2732
- 'wasi:sockets/tcp@0.2.0-rc-2023-11-05': {
2797
+ 'wasi:sockets/tcp@0.2.0-rc-2023-11-10': {
2733
2798
  '[resource-drop]tcp-socket': trampoline5,
2734
2799
  },
2735
2800
  }));
@@ -2777,4 +2842,4 @@ export const $init = (async() => {
2777
2842
  _initialized = true;
2778
2843
  })();
2779
2844
 
2780
- export { generate, generateTypes }
2845
+ export { generate, generateTypes, }